/mandos/trunk : revision 707

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

5

#

6

7

6

7

8

#

9

# This program is free software: you can redistribute it and/or modify

10

# it under the terms of the GNU General Public License as published by

26

from __future__ import (division, absolute_import, print_function,

27

unicode_literals)

28

29

try:

30

from future_builtins import *

31

except ImportError:

32

pass

29

from future_builtins import *

33

30

34

31

import sys

35

32

import argparse

42

39

43

40

import dbus

44

41

45

if sys.version_info.major == 2:

46

str = unicode

47

48

42

locale.setlocale(locale.LC_ALL, "")

49

43

50

44

tablewords = {

64

58

"ApprovalDelay": "Approval Delay",

65

59

"ApprovalDuration": "Approval Duration",

66

60

"Checker": "Checker",

67

"ExtendedTimeout": "Extended Timeout"

68

}

61

"ExtendedTimeout" : "Extended Timeout"

62

}

69

63

defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")

70

64

domain = "se.recompile"

71

65

busname = domain + ".Mandos"

72

66

server_path = "/"

73

67

server_interface = domain + ".Mandos"

74

68

client_interface = domain + ".Mandos.Client"

75

version = "1.6.9"

69

version = "1.6.5"

76

70

71

def timedelta_to_milliseconds(td):

72

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

73

return ((td.days * 24 * 60 * 60 * 1000)

74

+ (td.seconds * 1000)

75

+ (td.microseconds // 1000))

77

76

78

77

def milliseconds_to_string(ms):

79

78

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

80

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

81

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

82

hours = td.seconds // 3600,

83

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

84

seconds = td.seconds % 60))

79

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

80

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

81

hours = td.seconds // 3600,

82

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

83

seconds = td.seconds % 60,

84

))

85

86

87

def rfc3339_duration_to_delta(duration):

125

token_end = Token(re.compile(r"$"), None, frozenset())

126

token_second = Token(re.compile(r"(\d+)S"),

127

datetime.timedelta(seconds=1),

128

frozenset((token_end, )))

128

frozenset((token_end,)))

129

token_minute = Token(re.compile(r"(\d+)M"),

130

datetime.timedelta(minutes=1),

131

frozenset((token_second, token_end)))

147

frozenset((token_month, token_end)))

148

token_week = Token(re.compile(r"(\d+)W"),

149

datetime.timedelta(weeks=1),

150

frozenset((token_end, )))

150

frozenset((token_end,)))

151

token_duration = Token(re.compile(r"P"), None,

152

frozenset((token_year, token_month,

153

token_day, token_time,

154

token_week)))

154

token_week))),

155

# Define starting values

156

value = datetime.timedelta() # Value so far

157

found_token = None

158

followers = frozenset((token_duration, )) # Following valid tokens

158

followers = frozenset(token_duration,) # Following valid tokens

159

s = duration # String left to parse

160

# Loop until end token is found

161

while found_token is not token_end:

223

value += datetime.timedelta(0, 0, 0, int(num))

224

return value

225

226

227

226

def print_clients(clients, keywords):

228

227

def valuetostring(value, keyword):

229

228

if type(value) is dbus.Boolean:

231

230

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

232

231

"ApprovalDuration", "ExtendedTimeout"):

233

232

return milliseconds_to_string(value)

234

return str(value)

233

return unicode(value)

235

234

236

235

# Create format string to print table rows

237

236

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

238

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

239

max(len(valuetostring(client[key], key))

240

for client in clients)),

241

key = key)

242

for key in keywords)

237

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

238

max(len(valuetostring(client[key],

239

key))

240

for client in

241

clients)),

242

key = key) for key in keywords)

243

# Print header line

244

print(format_string.format(**tablewords))

245

for client in clients:

246

print(format_string.format(**{

247

key: valuetostring(client[key], key)

248

for key in keywords }))

249

246

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

247

valuetostring(client[key],

248

key))

249

for key in keywords)))

250

251

def has_actions(options):

252

return any((options.enable,

268

options.approve,

269

options.deny))

270

271

272

271

def main():

273

272

parser = argparse.ArgumentParser()

274

273

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

275

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

274

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

276

275

help="show version number and exit")

277

276

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

278

277

help="Select all clients")

311

310

parser.add_argument("--approval-duration",

312

311

help="Set duration of one client approval")

313

312

parser.add_argument("-H", "--host", help="Set host for client")

314

parser.add_argument("-s", "--secret",

315

type=argparse.FileType(mode="rb"),

313

parser.add_argument("-s", "--secret", type=file,

316

314

help="Set password blob (file) for client")

317

315

parser.add_argument("-A", "--approve", action="store_true",

318

316

help="Approve any current client request")

339

337

bus = dbus.SystemBus()

340

338

mandos_dbus_objc = bus.get_object(busname, server_path)

341

339

except dbus.exceptions.DBusException:

342

print("Could not connect to Mandos server", file=sys.stderr)

340

print("Could not connect to Mandos server",

341

file=sys.stderr)

343

342

sys.exit(1)

344

343

345

344

mandos_serv = dbus.Interface(mandos_dbus_objc,

366

365

clients={}

367

366

368

367

if options.all or not options.client:

369

clients = { bus.get_object(busname, path): properties

370

for path, properties in mandos_clients.items() }

368

clients = dict((bus.get_object(busname, path), properties)

369

for path, properties in

370

mandos_clients.iteritems())

371

else:

372

for name in options.client:

373

for path, client in mandos_clients.items():

373

for path, client in mandos_clients.iteritems():

374

if client["Name"] == name:

375

client_objc = bus.get_object(busname, path)

376

clients[client_objc] = client

377

break

378

else:

379

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

379

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

380

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

381

sys.exit(1)

382

383

if not has_actions(options) and clients:

384

if options.verbose:

385

keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",

386

"Created", "Interval", "Host", "Fingerprint",

387

"CheckerRunning", "LastEnabled",

388

"ApprovalPending", "ApprovedByDefault",

385

keywords = ("Name", "Enabled", "Timeout",

386

"LastCheckedOK", "Created", "Interval",

387

"Host", "Fingerprint", "CheckerRunning",

388

"LastEnabled", "ApprovalPending",

389

"ApprovedByDefault",

389

390

"LastApprovalRequest", "ApprovalDelay",

390

391

"ApprovalDuration", "Checker",

391

392

"ExtendedTimeout")

396

397

else:

397

398

# Process each client in the list by all selected options

398

399

for client in clients:

399

400

def set_client_prop(prop, value):

401

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

402

client.Set(client_interface, prop, value,

403

dbus_interface=dbus.PROPERTIES_IFACE)

404

405

404

def set_client_prop_ms(prop, value):

406

405

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

407

406

from a string to milliseconds."""

408

407

set_client_prop(prop,

409

string_to_delta(value).total_seconds()

410

* 1000)

411

408

timedelta_to_milliseconds

409

(string_to_delta(value)))

412

410

if options.remove:

413

411

mandos_serv.RemoveClient(client.__dbus_object_path__)

414

412

if options.enable:

458

456

client.Approve(dbus.Boolean(False),

459

457

dbus_interface=client_interface)

460

458

461

462

459

if __name__ == "__main__":

463

460

main()