/mandos/release : revision 353

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)

65

"ApprovalDelay": "Approval Delay",

66

"ApprovalDuration": "Approval Duration",

67

"Checker": "Checker",

68

"ExtendedTimeout": "Extended Timeout"

68

"ExtendedTimeout": "Extended Timeout",

69

"Expires": "Expires",

70

"LastCheckerStatus": "Last Checker Status",

69

71

}

70

72

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

71

73

domain = "se.recompile"

73

75

server_path = "/"

74

76

server_interface = domain + ".Mandos"

75

77

client_interface = domain + ".Mandos.Client"

76

version = "1.7.10"

78

version = "1.7.12"

77

79

78

80

79

81

try:

81

83

except AttributeError:

82

84

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

83

85

86

84

87

def milliseconds_to_string(ms):

85

88

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

86

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

87

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

88

hours = td.seconds // 3600,

89

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

90

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

91

94

92

95

93

96

def rfc3339_duration_to_delta(duration):

94

97

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

95

98

96

99

>>> rfc3339_duration_to_delta("P7D")

97

100

datetime.timedelta(7)

98

101

>>> rfc3339_duration_to_delta("PT60S")

108

111

>>> rfc3339_duration_to_delta("P1DT3M20S")

109

112

datetime.timedelta(1, 200)

110

113

"""

111

114

112

115

# Parsing an RFC 3339 duration with regular expressions is not

113

116

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

114

117

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

115

118

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

116

119

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

117

120

# avoid excessive use of external libraries.

118

121

119

122

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

120

123

Token = collections.namedtuple("Token", (

121

124

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

154

157

frozenset((token_year, token_month,

155

158

token_day, token_time,

156

159

token_week)))

157

# Define starting values

158

value = datetime.timedelta() # Value so far

160

# Define starting values:

161

# Value so far

162

value = datetime.timedelta()

159

163

found_token = None

160

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

161

s = duration # String left to parse

164

# Following valid tokens

165

followers = frozenset((token_duration, ))

166

# String left to parse

167

s = duration

162

168

# Loop until end token is found

163

169

while found_token is not token_end:

164

170

# Search for any currently valid tokens

188

194

189

195

def string_to_delta(interval):

190

196

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

191

197

192

198

>>> string_to_delta('7d')

193

199

datetime.timedelta(7)

194

200

>>> string_to_delta('60s')

202

208

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

203

209

datetime.timedelta(0, 330)

204

210

"""

205

211

206

212

try:

207

213

return rfc3339_duration_to_delta(interval)

208

214

except ValueError:

209

215

pass

210

216

211

217

value = datetime.timedelta(0)

212

218

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

213

219

214

220

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

215

221

if suffix == "d":

216

222

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

235

241

"ApprovalDuration", "ExtendedTimeout"):

236

242

return milliseconds_to_string(value)

237

243

return str(value)

238

244

239

245

# Create format string to print table rows

240

246

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

241

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

242

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

243

for client in clients)),

244

key = key)

247

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

248

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

249

for client in clients)),

250

key=key)

245

251

for key in keywords)

246

252

# Print header line

247

253

print(format_string.format(**tablewords))

248

254

for client in clients:

249

print(format_string.format(**{

250

key: valuetostring(client[key], key)

251

for key in keywords }))

255

print(format_string

256

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

257

for key in keywords}))

252

258

253

259

254

260

def has_actions(options):

275

281

def main():

276

282

parser = argparse.ArgumentParser()

277

283

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

278

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

284

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

279

285

help="show version number and exit")

280

286

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

281

287

help="Select all clients")

327

333

help="Run self-test")

328

334

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

329

335

options = parser.parse_args()

330

336

331

337

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

332

338

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

333

339

if options.verbose and has_actions(options):

334

340

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

335

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

341

if options.dump_json and (options.verbose

342

or has_actions(options)):

336

343

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

337

344

if options.all and not has_actions(options):

338

345

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

339

346

340

347

if options.check:

341

348

fail_count, test_count = doctest.testmod()

342

349

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

343

350

344

351

try:

345

352

bus = dbus.SystemBus()

346

353

mandos_dbus_objc = bus.get_object(busname, server_path)

347

354

except dbus.exceptions.DBusException:

348

355

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

349

356

sys.exit(1)

350

357

351

358

mandos_serv = dbus.Interface(mandos_dbus_objc,

352

dbus_interface = server_interface)

359

dbus_interface=server_interface)

353

360

mandos_serv_object_manager = dbus.Interface(

354

mandos_dbus_objc, dbus_interface = dbus.OBJECT_MANAGER_IFACE)

355

356

#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

357

364

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

358

365

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

359

366

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

360

367

os.close(null)

361

368

try:

362

369

try:

363

mandos_clients = { path: ifs_and_props[client_interface]

364

for path, ifs_and_props in

365

mandos_serv_object_manager

366

.GetManagedObjects().items()

367

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}

368

375

finally:

369

#restore stderr

376

# restore stderr

370

377

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

371

378

os.close(stderrcopy)

372

379

except dbus.exceptions.DBusException as e:

373

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

374

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

380

print("Access denied: "

381

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

382

file=sys.stderr)

375

383

sys.exit(1)

376

384

377

385

# Compile dict of (clients: properties) to process

378

clients={}

379

386

clients = {}

387

380

388

if options.all or not options.client:

381

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

382

for path, properties in mandos_clients.items() }

389

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

390

for path, properties in mandos_clients.items()}

383

391

else:

384

392

for name in options.client:

385

393

for path, client in mandos_clients.items():

391

399

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

392

400

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

393

401

sys.exit(1)

394

402

395

403

if not has_actions(options) and clients:

396

404

if options.verbose or options.dump_json:

397

405

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

400

408

"ApprovalPending", "ApprovedByDefault",

401

409

"LastApprovalRequest", "ApprovalDelay",

402

410

"ApprovalDuration", "Checker",

403

"ExtendedTimeout")

411

"ExtendedTimeout", "Expires",

412

"LastCheckerStatus")

404

413

else:

405

414

keywords = defaultkeywords

406

415

407

416

if options.dump_json:

408

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

409

for key in keywords }

410

for client in clients.values() },

411

fp = sys.stdout, indent = 4,

412

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

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=(',', ': '))

413

426

print()

414

427

else:

415

428

print_clients(clients.values(), keywords)

416

429

else:

417

430

# Process each client in the list by all selected options

418

431

for client in clients:

419

432

420

433

def set_client_prop(prop, value):

421

434

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

422

435

client.Set(client_interface, prop, value,

423

436

dbus_interface=dbus.PROPERTIES_IFACE)

424

437

425

438

def set_client_prop_ms(prop, value):

426

439

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

427

440

from a string to milliseconds."""

428

441

set_client_prop(prop,

429

442

string_to_delta(value).total_seconds()

430

443

* 1000)

431

444

432

445

if options.remove:

433

446

mandos_serv.RemoveClient(client.__dbus_object_path__)

434

447

if options.enable:

442

455

if options.stop_checker:

443

456

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

444

457

if options.is_enabled:

445

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

446

"Enabled",

447

dbus_interface=

448

dbus.PROPERTIES_IFACE)

449

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)

450

463

if options.checker is not None:

451

464

set_client_prop("Checker", options.checker)

452

465

if options.host is not None: