/mandos/trunk : revision 844

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)

39

import os

40

import collections

41

import doctest

42

import json

43

42

44

43

import dbus

45

44

65

64

"ApprovalDelay": "Approval Delay",

66

65

"ApprovalDuration": "Approval Duration",

67

66

"Checker": "Checker",

68

"ExtendedTimeout": "Extended Timeout",

69

"Expires": "Expires",

70

"LastCheckerStatus": "Last Checker Status",

67

"ExtendedTimeout": "Extended Timeout"

71

68

}

72

69

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

73

70

domain = "se.recompile"

75

72

server_path = "/"

76

73

server_interface = domain + ".Mandos"

77

74

client_interface = domain + ".Mandos.Client"

78

version = "1.7.10"

75

version = "1.7.7"

79

76

80

77

81

78

try:

83

80

except AttributeError:

84

81

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

85

82

86

87

83

def milliseconds_to_string(ms):

88

84

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

85

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

86

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

87

hours = td.seconds // 3600,

88

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

89

seconds = td.seconds % 60))

94

90

95

91

96

92

def rfc3339_duration_to_delta(duration):

97

93

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

98

94

99

95

>>> rfc3339_duration_to_delta("P7D")

100

96

datetime.timedelta(7)

101

97

>>> rfc3339_duration_to_delta("PT60S")

111

107

>>> rfc3339_duration_to_delta("P1DT3M20S")

112

108

datetime.timedelta(1, 200)

113

109

"""

114

110

115

111

# Parsing an RFC 3339 duration with regular expressions is not

116

112

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

117

113

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

118

114

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

119

115

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

120

116

# avoid excessive use of external libraries.

121

117

122

118

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

123

119

Token = collections.namedtuple("Token", (

124

120

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

157

153

frozenset((token_year, token_month,

158

154

token_day, token_time,

159

155

token_week)))

160

# Define starting values:

161

# Value so far

162

value = datetime.timedelta()

156

# Define starting values

157

value = datetime.timedelta() # Value so far

163

158

found_token = None

164

# Following valid tokens

165

followers = frozenset((token_duration, ))

166

# String left to parse

167

s = duration

159

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

160

s = duration # String left to parse

168

161

# Loop until end token is found

169

162

while found_token is not token_end:

170

163

# Search for any currently valid tokens

194

187

195

188

def string_to_delta(interval):

196

189

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

197

190

198

191

>>> string_to_delta('7d')

199

192

datetime.timedelta(7)

200

193

>>> string_to_delta('60s')

208

201

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

209

202

datetime.timedelta(0, 330)

210

203

"""

211

204

212

205

try:

213

206

return rfc3339_duration_to_delta(interval)

214

207

except ValueError:

215

208

pass

216

209

217

210

value = datetime.timedelta(0)

218

211

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

219

212

220

213

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

221

214

if suffix == "d":

222

215

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

241

234

"ApprovalDuration", "ExtendedTimeout"):

242

235

return milliseconds_to_string(value)

243

236

return str(value)

244

237

245

238

# Create format string to print table rows

246

239

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)

240

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

241

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

242

for client in clients)),

243

key = key)

251

244

for key in keywords)

252

245

# Print header line

253

246

print(format_string.format(**tablewords))

254

247

for client in clients:

255

print(format_string

256

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

257

for key in keywords}))

248

print(format_string.format(**{

249

key: valuetostring(client[key], key)

250

for key in keywords }))

258

251

259

252

260

253

def has_actions(options):

281

274

def main():

282

275

parser = argparse.ArgumentParser()

283

276

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

284

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

277

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

285

278

help="show version number and exit")

286

279

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

287

280

help="Select all clients")

288

281

parser.add_argument("-v", "--verbose", action="store_true",

289

282

help="Print all fields")

290

parser.add_argument("-j", "--dump-json", action="store_true",

291

help="Dump client data in JSON format")

292

283

parser.add_argument("-e", "--enable", action="store_true",

293

284

help="Enable client")

294

285

parser.add_argument("-d", "--disable", action="store_true",

333

324

help="Run self-test")

334

325

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

335

326

options = parser.parse_args()

336

327

337

328

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

338

329

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

339

330

if options.verbose and has_actions(options):

340

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

341

if options.dump_json and (options.verbose

342

or has_actions(options)):

343

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

331

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

332

" --all.")

344

333

if options.all and not has_actions(options):

345

334

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

346

335

347

336

if options.check:

348

337

fail_count, test_count = doctest.testmod()

349

338

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

350

339

351

340

try:

352

341

bus = dbus.SystemBus()

353

342

mandos_dbus_objc = bus.get_object(busname, server_path)

354

343

except dbus.exceptions.DBusException:

355

344

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

356

345

sys.exit(1)

357

346

358

347

mandos_serv = dbus.Interface(mandos_dbus_objc,

359

dbus_interface=server_interface)

348

dbus_interface = server_interface)

360

349

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

350

mandos_dbus_objc, dbus_interface = dbus.OBJECT_MANAGER_IFACE)

351

352

#block stderr since dbus library prints to stderr

364

353

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

365

354

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

366

355

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

367

356

os.close(null)

368

357

try:

369

358

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}

359

mandos_clients = { path: ifs_and_props[client_interface]

360

for path, ifs_and_props in

361

mandos_serv_object_manager

362

.GetManagedObjects().items()

363

if client_interface in ifs_and_props }

375

364

finally:

376

# restore stderr

365

#restore stderr

377

366

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

378

367

os.close(stderrcopy)

379

368

except dbus.exceptions.DBusException as e:

380

print("Access denied: "

381

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

382

file=sys.stderr)

369

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

370

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

383

371

sys.exit(1)

384

372

385

373

# Compile dict of (clients: properties) to process

386

clients = {}

387

374

clients={}

375

388

376

if options.all or not options.client:

389

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

390

for path, properties in mandos_clients.items()}

377

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

378

for path, properties in mandos_clients.items() }

391

379

else:

392

380

for name in options.client:

393

381

for path, client in mandos_clients.items():

399

387

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

400

388

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

401

389

sys.exit(1)

402

390

403

391

if not has_actions(options) and clients:

404

if options.verbose or options.dump_json:

392

if options.verbose:

405

393

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

406

394

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

407

395

"CheckerRunning", "LastEnabled",

408

396

"ApprovalPending", "ApprovedByDefault",

409

397

"LastApprovalRequest", "ApprovalDelay",

410

398

"ApprovalDuration", "Checker",

411

"ExtendedTimeout", "Expires",

412

"LastCheckerStatus")

399

"ExtendedTimeout")

413

400

else:

414

401

keywords = defaultkeywords

415

416

if options.dump_json:

417

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

418

bool(client[key])

419

if isinstance(client[key],

420

dbus.Boolean)

421

else client[key]

422

for key in keywords}

423

for client in clients.values()},

424

fp=sys.stdout, indent=4,

425

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

426

print()

427

else:

428

print_clients(clients.values(), keywords)

402

403

print_clients(clients.values(), keywords)

429

404

else:

430

405

# Process each client in the list by all selected options

431

406

for client in clients:

432

407

433

408

def set_client_prop(prop, value):

434

409

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

435

410

client.Set(client_interface, prop, value,

436

411

dbus_interface=dbus.PROPERTIES_IFACE)

437

412

438

413

def set_client_prop_ms(prop, value):

439

414

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

440

415

from a string to milliseconds."""

441

416

set_client_prop(prop,

442

417

string_to_delta(value).total_seconds()

443

418

* 1000)

444

419

445

420

if options.remove:

446

421

mandos_serv.RemoveClient(client.__dbus_object_path__)

447

422

if options.enable:

455

430

if options.stop_checker:

456

431

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

457

432

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)

433

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

434

"Enabled",

435

dbus_interface=

436

dbus.PROPERTIES_IFACE)

437

else 1)

463

438

if options.checker is not None:

464

439

set_client_prop("Checker", options.checker)

465

440

if options.host is not None: