/mandos/trunk : revision 544

17

# GNU General Public License for more details.

18

#

19

# You should have received a copy of the GNU General Public License

20

# along with this program. If not, see

21

# <http://www.gnu.org/licenses/>.

20

# along with this program. If not, see <http://www.gnu.org/licenses/>.

22

21

#

23

22

# Contact the authors at <mandos@recompile.se>.

24

23

#

26

25

from __future__ import (division, absolute_import, print_function,

27

26

unicode_literals)

28

27

29

from future_builtins import *

30

31

28

import sys

32

29

import dbus

33

30

import argparse

63

60

server_path = "/"

64

61

server_interface = domain + ".Mandos"

65

62

client_interface = domain + ".Mandos.Client"

66

version = "1.5.3"

63

version = "1.4.1"

67

64

68

65

def timedelta_to_milliseconds(td):

69

66

"""Convert a datetime.timedelta object to milliseconds"""

73

70

74

71

def milliseconds_to_string(ms):

75

72

td = datetime.timedelta(0, 0, 0, ms)

76

return ("{days}{hours:02}:{minutes:02}:{seconds:02}"

77

.format(days = "{0}T".format(td.days) if td.days else "",

78

hours = td.seconds // 3600,

79

minutes = (td.seconds % 3600) // 60,

80

seconds = td.seconds % 60,

81

))

73

return ("%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"

74

% { "days": "%dT" % td.days if td.days else "",

75

"hours": td.seconds // 3600,

76

"minutes": (td.seconds % 3600) // 60,

77

"seconds": td.seconds % 60,

78

})

82

79

83

80

def string_to_delta(interval):

84

81

"""Parse a string and return a datetime.timedelta

119

116

if type(value) is dbus.Boolean:

120

117

return "Yes" if value else "No"

121

118

if keyword in ("Timeout", "Interval", "ApprovalDelay",

122

"ApprovalDuration", "ExtendedTimeout"):

119

"ApprovalDuration"):

123

120

return milliseconds_to_string(value)

124

121

return unicode(value)

125

122

126

123

# Create format string to print table rows

127

format_string = " ".join("{{{key}:{width}}}".format(

128

width = max(len(tablewords[key]),

129

max(len(valuetostring(client[key],

130

key))

131

for client in

132

clients)),

133

key = key) for key in keywords)

124

format_string = " ".join("%%-%ds" %

125

max(len(tablewords[key]),

126

max(len(valuetostring(client[key],

127

key))

128

for client in

129

clients))

130

for key in keywords)

134

131

# Print header line

135

print(format_string.format(**tablewords))

132

print(format_string % tuple(tablewords[key] for key in keywords))

136

133

for client in clients:

137

print(format_string.format(**dict((key,

138

valuetostring(client[key],

139

key))

140

for key in keywords)))

134

print(format_string % tuple(valuetostring(client[key], key)

135

for key in keywords))

141

136

142

137

def has_actions(options):

143

138

return any((options.enable,

162

157

def main():

163

158

parser = argparse.ArgumentParser()

164

159

parser.add_argument("--version", action="version",

165

version = "%(prog)s {0}".format(version),

160

version = "%%prog %s" % version,

166

161

help="show version number and exit")

167

162

parser.add_argument("-a", "--all", action="store_true",

168

163

help="Select all clients")

210

205

parser.add_argument("client", nargs="*", help="Client name")

211

206

options = parser.parse_args()

212

207

213

if has_actions(options) and not (options.client or options.all):

208

if has_actions(options) and not options.client and not options.all:

214

209

parser.error("Options require clients names or --all.")

215

210

if options.verbose and has_actions(options):

216

211

parser.error("--verbose can only be used alone or with"

261

256

clients[client_objc] = client

262

257

break

263

258

else:

264

print("Client not found on server: {0!r}"

265

.format(name), file=sys.stderr)

259

print("Client not found on server: %r" % name,

260

file=sys.stderr)

266

261

sys.exit(1)

267

262

268

263

if not has_actions(options) and clients:

282

277

else:

283

278

# Process each client in the list by all selected options

284

279

for client in clients:

285

def set_client_prop(prop, value):

286

"""Set a Client D-Bus property"""

287

client.Set(client_interface, prop, value,

288

dbus_interface=dbus.PROPERTIES_IFACE)

289

def set_client_prop_ms(prop, value):

290

"""Set a Client D-Bus property, converted

291

from a string to milliseconds."""

292

set_client_prop(prop,

293

timedelta_to_milliseconds

294

(string_to_delta(value)))

295

280

if options.remove:

296

281

mandos_serv.RemoveClient(client.__dbus_object_path__)

297

282

if options.enable:

298

set_client_prop("Enabled", dbus.Boolean(True))

283

client.Enable(dbus_interface=client_interface)

299

284

if options.disable:

300

set_client_prop("Enabled", dbus.Boolean(False))

285

client.Disable(dbus_interface=client_interface)

301

286

if options.bump_timeout:

302

set_client_prop("LastCheckedOK", "")

287

client.CheckedOK(dbus_interface=client_interface)

303

288

if options.start_checker:

304

set_client_prop("CheckerRunning", dbus.Boolean(True))

289

client.StartChecker(dbus_interface=client_interface)

305

290

if options.stop_checker:

306

set_client_prop("CheckerRunning", dbus.Boolean(False))

291

client.StopChecker(dbus_interface=client_interface)

307

292

if options.is_enabled:

308

293

sys.exit(0 if client.Get(client_interface,

309

294

"Enabled",

311

296

dbus.PROPERTIES_IFACE)

312

297

else 1)

313

298

if options.checker is not None:

314

set_client_prop("Checker", options.checker)

299

client.Set(client_interface, "Checker",

300

options.checker,

301

dbus_interface=dbus.PROPERTIES_IFACE)

315

302

if options.host is not None:

316

set_client_prop("Host", options.host)

303

client.Set(client_interface, "Host", options.host,

304

dbus_interface=dbus.PROPERTIES_IFACE)

317

305

if options.interval is not None:

318

set_client_prop_ms("Interval", options.interval)

306

client.Set(client_interface, "Interval",

307

timedelta_to_milliseconds

308

(string_to_delta(options.interval)),

309

dbus_interface=dbus.PROPERTIES_IFACE)

319

310

if options.approval_delay is not None:

320

set_client_prop_ms("ApprovalDelay",

321

options.approval_delay)

311

client.Set(client_interface, "ApprovalDelay",

312

timedelta_to_milliseconds

313

(string_to_delta(options.

314

approval_delay)),

315

dbus_interface=dbus.PROPERTIES_IFACE)

322

316

if options.approval_duration is not None:

323

set_client_prop_ms("ApprovalDuration",

324

options.approval_duration)

317

client.Set(client_interface, "ApprovalDuration",

318

timedelta_to_milliseconds

319

(string_to_delta(options.

320

approval_duration)),

321

dbus_interface=dbus.PROPERTIES_IFACE)

325

322

if options.timeout is not None:

326

set_client_prop_ms("Timeout", options.timeout)

323

client.Set(client_interface, "Timeout",

324

timedelta_to_milliseconds

325

(string_to_delta(options.timeout)),

326

dbus_interface=dbus.PROPERTIES_IFACE)

327

if options.extended_timeout is not None:

328

set_client_prop_ms("ExtendedTimeout",

329

options.extended_timeout)

328

client.Set(client_interface, "ExtendedTimeout",

329

timedelta_to_milliseconds

330

(string_to_delta(options.extended_timeout)),

331

dbus_interface=dbus.PROPERTIES_IFACE)

330

332

if options.secret is not None:

331

set_client_prop("Secret",

332

dbus.ByteArray(options.secret.read()))

333

client.Set(client_interface, "Secret",

334

dbus.ByteArray(open(options.secret,

335

"rb").read()),

336

dbus_interface=dbus.PROPERTIES_IFACE)

333

337

if options.approved_by_default is not None:

334

set_client_prop("ApprovedByDefault",

335

dbus.Boolean(options

336

.approved_by_default))

338

client.Set(client_interface, "ApprovedByDefault",

339

dbus.Boolean(options

340

.approved_by_default),

341

dbus_interface=dbus.PROPERTIES_IFACE)

337

342

if options.approve:

338

343

client.Approve(dbus.Boolean(True),

339

344

dbus_interface=client_interface)