/mandos/trunk : revision 896

1

#!/usr/bin/python

2

# -*- mode: python; coding: utf-8 -*-

3

#

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

5

#

5

#

6

7

8

#

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

11

# the Free Software Foundation, either version 3 of the License, or

15

# but WITHOUT ANY WARRANTY; without even the implied warranty of

16

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

17

# GNU General Public License for more details.

18

#

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/>.

22

#

22

#

23

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

24

#

24

#

25

26

from __future__ import (division, absolute_import, print_function,

27

unicode_literals)

75

server_path = "/"

76

server_interface = domain + ".Mandos"

77

client_interface = domain + ".Mandos.Client"

78

version = "1.7.10"

78

version = "1.7.14"

79

80

81

try:

83

except AttributeError:

84

dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"

85

86

87

def milliseconds_to_string(ms):

87

88

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

88

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

89

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

90

hours = td.seconds // 3600,

91

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

92

seconds = td.seconds % 60))

89

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

90

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

91

hours=td.seconds // 3600,

92

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

93

seconds=td.seconds % 60))

93

94

95

96

def rfc3339_duration_to_delta(duration):

96

97

"""Parse an RFC 3339 "duration" and return a datetime.timedelta

97

98

99

>>> rfc3339_duration_to_delta("P7D")

99

100

datetime.timedelta(7)

100

101

>>> rfc3339_duration_to_delta("PT60S")

110

111

>>> rfc3339_duration_to_delta("P1DT3M20S")

111

112

datetime.timedelta(1, 200)

112

113

"""

113

114

115

# Parsing an RFC 3339 duration with regular expressions is not

115

116

# possible - there would have to be multiple places for the same

116

117

# values, like seconds. The current code, while more esoteric, is

117

118

# cleaner without depending on a parsing library. If Python had a

118

119

# built-in library for parsing we would use it, but we'd like to

119

120

# avoid excessive use of external libraries.

120

121

122

# New type for defining tokens, syntax, and semantics all-in-one

122

123

Token = collections.namedtuple("Token", (

123

124

"regexp", # To match token; if "value" is not None, must have

156

157

frozenset((token_year, token_month,

157

158

token_day, token_time,

158

159

token_week)))

159

# Define starting values

160

value = datetime.timedelta() # Value so far

160

# Define starting values:

161

# Value so far

162

value = datetime.timedelta()

161

163

found_token = None

162

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

163

s = duration # String left to parse

164

# Following valid tokens

165

followers = frozenset((token_duration, ))

166

# String left to parse

167

s = duration

164

168

# Loop until end token is found

165

169

while found_token is not token_end:

166

170

# Search for any currently valid tokens

190

194

191

195

def string_to_delta(interval):

192

196

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

193

197

194

198

>>> string_to_delta('7d')

195

199

datetime.timedelta(7)

196

200

>>> string_to_delta('60s')

204

208

>>> string_to_delta('5m 30s')

205

209

datetime.timedelta(0, 330)

206

210

"""

207

211

208

212

try:

209

213

return rfc3339_duration_to_delta(interval)

210

214

except ValueError:

211

215

pass

212

216

213

217

value = datetime.timedelta(0)

214

218

regexp = re.compile(r"(\d+)([dsmhw]?)")

215

219

216

220

for num, suffix in regexp.findall(interval):

217

221

if suffix == "d":

218

222

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

237

241

"ApprovalDuration", "ExtendedTimeout"):

238

242

return milliseconds_to_string(value)

239

243

return str(value)

240

244

241

245

# Create format string to print table rows

242

246

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

243

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

244

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

245

for client in clients)),

246

key = key)

247

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

248

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

249

for client in clients)),

250

key=key)

247

251

for key in keywords)

248

252

# Print header line

249

253

print(format_string.format(**tablewords))

250

254

for client in clients:

251

print(format_string.format(**{

252

key: valuetostring(client[key], key)

253

for key in keywords }))

255

print(format_string

256

.format(**{key: valuetostring(client[key], key)

257

for key in keywords}))

254

258

255

259

256

260

def has_actions(options):

277

281

def main():

278

282

parser = argparse.ArgumentParser()

279

283

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

280

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

284

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

281

285

help="show version number and exit")

282

286

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

283

287

help="Select all clients")

329

333

help="Run self-test")

330

334

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

331

335

options = parser.parse_args()

332

336

333

337

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

334

338

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

335

339

if options.verbose and has_actions(options):

336

340

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

337

if options.dump_json and (options.verbose or has_actions(options)):

341

if options.dump_json and (options.verbose

342

or has_actions(options)):

338

343

parser.error("--dump-json can only be used alone.")

339

344

if options.all and not has_actions(options):

340

345

parser.error("--all requires an action.")

341

346

342

347

if options.check:

343

348

fail_count, test_count = doctest.testmod()

344

349

sys.exit(os.EX_OK if fail_count == 0 else 1)

345

350

346

351

try:

347

352

bus = dbus.SystemBus()

348

353

mandos_dbus_objc = bus.get_object(busname, server_path)

349

354

except dbus.exceptions.DBusException:

350

355

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

351

356

sys.exit(1)

352

357

353

358

mandos_serv = dbus.Interface(mandos_dbus_objc,

354

dbus_interface = server_interface)

359

dbus_interface=server_interface)

355

360

mandos_serv_object_manager = dbus.Interface(

356

mandos_dbus_objc, dbus_interface = dbus.OBJECT_MANAGER_IFACE)

357

358

#block stderr since dbus library prints to stderr

361

mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)

362

363

# block stderr since dbus library prints to stderr

359

364

null = os.open(os.path.devnull, os.O_RDWR)

360

365

stderrcopy = os.dup(sys.stderr.fileno())

361

366

os.dup2(null, sys.stderr.fileno())

362

367

os.close(null)

363

368

try:

364

369

try:

365

mandos_clients = { path: ifs_and_props[client_interface]

366

for path, ifs_and_props in

367

mandos_serv_object_manager

368

.GetManagedObjects().items()

369

if client_interface in ifs_and_props }

370

mandos_clients = {path: ifs_and_props[client_interface]

371

for path, ifs_and_props in

372

mandos_serv_object_manager

373

.GetManagedObjects().items()

374

if client_interface in ifs_and_props}

370

375

finally:

371

#restore stderr

376

# restore stderr

372

377

os.dup2(stderrcopy, sys.stderr.fileno())

373

378

os.close(stderrcopy)

374

379

except dbus.exceptions.DBusException as e:

375

print("Access denied: Accessing mandos server through D-Bus: {}"

376

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

380

print("Access denied: "

381

"Accessing mandos server through D-Bus: {}".format(e),

382

file=sys.stderr)

377

383

sys.exit(1)

378

384

379

385

# Compile dict of (clients: properties) to process

380

clients={}

381

386

clients = {}

387

382

388

if options.all or not options.client:

383

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

384

for path, properties in mandos_clients.items() }

389

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

390

for path, properties in mandos_clients.items()}

385

391

else:

386

392

for name in options.client:

387

393

for path, client in mandos_clients.items():

393

399

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

394

400

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

395

401

sys.exit(1)

396

402

397

403

if not has_actions(options) and clients:

398

404

if options.verbose or options.dump_json:

399

405

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

406

412

"LastCheckerStatus")

407

413

else:

408

414

keywords = defaultkeywords

409

415

410

416

if options.dump_json:

411

417

json.dump({client["Name"]: {key:

412

418

bool(client[key])

413

419

if isinstance(client[key],

414

420

dbus.Boolean)

415

421

else client[key]

416

for key in keywords }

417

for client in clients.values() },

418

fp = sys.stdout, indent = 4,

419

separators = (',', ': '))

422

for key in keywords}

423

for client in clients.values()},

424

fp=sys.stdout, indent=4,

425

separators=(',', ': '))

420

426

print()

421

427

else:

422

428

print_clients(clients.values(), keywords)

423

429

else:

424

430

# Process each client in the list by all selected options

425

431

for client in clients:

426

432

427

433

def set_client_prop(prop, value):

428

434

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

429

435

client.Set(client_interface, prop, value,

430

436

dbus_interface=dbus.PROPERTIES_IFACE)

431

437

432

438

def set_client_prop_ms(prop, value):

433

439

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

434

440

from a string to milliseconds."""

435

441

set_client_prop(prop,

436

442

string_to_delta(value).total_seconds()

437

443

* 1000)

438

444

439

445

if options.remove:

440

446

mandos_serv.RemoveClient(client.__dbus_object_path__)

441

447

if options.enable:

449

455

if options.stop_checker:

450

456

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

451

457

if options.is_enabled:

452

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

453

"Enabled",

454

dbus_interface=

455

dbus.PROPERTIES_IFACE)

456

else 1)

458

if client.Get(client_interface, "Enabled",

459

dbus_interface=dbus.PROPERTIES_IFACE):

460

sys.exit(0)

461

else:

462

sys.exit(1)

457

463

if options.checker is not None:

458

464

set_client_prop("Checker", options.checker)

459

465

if options.host is not None: