/mandos/trunk : revision 866

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.14"

78

version = "1.7.10"

79

80

81

try:

83

except AttributeError:

84

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

85

86

87

86

def milliseconds_to_string(ms):

88

87

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

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))

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))

94

93

95

94

96

95

def rfc3339_duration_to_delta(duration):

97

96

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

98

97

99

98

>>> rfc3339_duration_to_delta("P7D")

100

99

datetime.timedelta(7)

101

100

>>> rfc3339_duration_to_delta("PT60S")

111

110

>>> rfc3339_duration_to_delta("P1DT3M20S")

112

111

datetime.timedelta(1, 200)

113

112

"""

114

113

115

114

# Parsing an RFC 3339 duration with regular expressions is not

116

115

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

117

116

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

118

117

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

119

118

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

120

119

# avoid excessive use of external libraries.

121

120

122

121

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

123

122

Token = collections.namedtuple("Token", (

124

123

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

157

156

frozenset((token_year, token_month,

158

157

token_day, token_time,

159

158

token_week)))

160

# Define starting values:

161

# Value so far

162

value = datetime.timedelta()

159

# Define starting values

160

value = datetime.timedelta() # Value so far

163

161

found_token = None

164

# Following valid tokens

165

followers = frozenset((token_duration, ))

166

# String left to parse

167

s = duration

162

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

163

s = duration # String left to parse

168

164

# Loop until end token is found

169

165

while found_token is not token_end:

170

166

# Search for any currently valid tokens

194

190

195

191

def string_to_delta(interval):

196

192

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

197

193

198

194

>>> string_to_delta('7d')

199

195

datetime.timedelta(7)

200

196

>>> string_to_delta('60s')

208

204

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

209

205

datetime.timedelta(0, 330)

210

206

"""

211

207

212

208

try:

213

209

return rfc3339_duration_to_delta(interval)

214

210

except ValueError:

215

211

pass

216

212

217

213

value = datetime.timedelta(0)

218

214

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

219

215

220

216

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

221

217

if suffix == "d":

222

218

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

241

237

"ApprovalDuration", "ExtendedTimeout"):

242

238

return milliseconds_to_string(value)

243

239

return str(value)

244

240

245

241

# Create format string to print table rows

246

242

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

247

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

248

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

249

for client in clients)),

250

key=key)

243

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

244

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

245

for client in clients)),

246

key = key)

251

247

for key in keywords)

252

248

# Print header line

253

249

print(format_string.format(**tablewords))

254

250

for client in clients:

255

print(format_string

256

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

257

for key in keywords}))

251

print(format_string.format(**{

252

key: valuetostring(client[key], key)

253

for key in keywords }))

258

254

259

255

260

256

def has_actions(options):

281

277

def main():

282

278

parser = argparse.ArgumentParser()

283

279

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

284

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

280

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

285

281

help="show version number and exit")

286

282

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

287

283

help="Select all clients")

333

329

help="Run self-test")

334

330

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

335

331

options = parser.parse_args()

336

332

337

333

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

338

334

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

339

335

if options.verbose and has_actions(options):

340

336

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

341

if options.dump_json and (options.verbose

342

or has_actions(options)):

337

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

343

338

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

344

339

if options.all and not has_actions(options):

345

340

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

346

341

347

342

if options.check:

348

343

fail_count, test_count = doctest.testmod()

349

344

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

350

345

351

346

try:

352

347

bus = dbus.SystemBus()

353

348

mandos_dbus_objc = bus.get_object(busname, server_path)

354

349

except dbus.exceptions.DBusException:

355

350

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

356

351

sys.exit(1)

357

352

358

353

mandos_serv = dbus.Interface(mandos_dbus_objc,

359

dbus_interface=server_interface)

354

dbus_interface = server_interface)

360

355

mandos_serv_object_manager = dbus.Interface(

361

mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)

362

363

# block stderr since dbus library prints to stderr

356

mandos_dbus_objc, dbus_interface = dbus.OBJECT_MANAGER_IFACE)

357

358

#block stderr since dbus library prints to stderr

364

359

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

365

360

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

366

361

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

367

362

os.close(null)

368

363

try:

369

364

try:

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}

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 }

375

370

finally:

376

# restore stderr

371

#restore stderr

377

372

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

378

373

os.close(stderrcopy)

379

374

except dbus.exceptions.DBusException as e:

380

print("Access denied: "

381

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

382

file=sys.stderr)

375

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

376

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

383

377

sys.exit(1)

384

378

385

379

# Compile dict of (clients: properties) to process

386

clients = {}

387

380

clients={}

381

388

382

if options.all or not options.client:

389

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

390

for path, properties in mandos_clients.items()}

383

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

384

for path, properties in mandos_clients.items() }

391

385

else:

392

386

for name in options.client:

393

387

for path, client in mandos_clients.items():

399

393

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

400

394

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

401

395

sys.exit(1)

402

396

403

397

if not has_actions(options) and clients:

404

398

if options.verbose or options.dump_json:

405

399

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

412

406

"LastCheckerStatus")

413

407

else:

414

408

keywords = defaultkeywords

415

409

416

410

if options.dump_json:

417

411

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

418

412

bool(client[key])

419

413

if isinstance(client[key],

420

414

dbus.Boolean)

421

415

else client[key]

422

for key in keywords}

423

for client in clients.values()},

424

fp=sys.stdout, indent=4,

425

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

416

for key in keywords }

417

for client in clients.values() },

418

fp = sys.stdout, indent = 4,

419

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

426

420

print()

427

421

else:

428

422

print_clients(clients.values(), keywords)

429

423

else:

430

424

# Process each client in the list by all selected options

431

425

for client in clients:

432

426

433

427

def set_client_prop(prop, value):

434

428

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

435

429

client.Set(client_interface, prop, value,

436

430

dbus_interface=dbus.PROPERTIES_IFACE)

437

431

438

432

def set_client_prop_ms(prop, value):

439

433

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

440

434

from a string to milliseconds."""

441

435

set_client_prop(prop,

442

436

string_to_delta(value).total_seconds()

443

437

* 1000)

444

438

445

439

if options.remove:

446

440

mandos_serv.RemoveClient(client.__dbus_object_path__)

447

441

if options.enable:

455

449

if options.stop_checker:

456

450

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

457

451

if options.is_enabled:

458

if client.Get(client_interface, "Enabled",

459

dbus_interface=dbus.PROPERTIES_IFACE):

460

sys.exit(0)

461

else:

462

sys.exit(1)

452

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

453

"Enabled",

454

dbus_interface=

455

dbus.PROPERTIES_IFACE)

456

else 1)

463

457

if options.checker is not None:

464

458

set_client_prop("Checker", options.checker)

465

459

if options.host is not None: