/mandos/trunk : revision 1186

1

#!/usr/bin/python3 -bb

1

#!/usr/bin/python3 -bbI

2

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

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

35

import os

36

import warnings

37

import datetime

38

import locale

39

import logging

38

40

39

41

import urwid.curses_display

40

42

import urwid

44

46

45

47

import dbus

46

48

47

import locale

48

49

import logging

50

51

49

if sys.version_info.major == 2:

52

50

str = unicode

53

51

54

locale.setlocale(locale.LC_ALL, '')

55

56

logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)

52

log = logging.getLogger(os.path.basename(sys.argv[0]))

53

logging.basicConfig(level="NOTSET", # Show all messages

54

format="%(message)s") # Show basic log messages

55

56

logging.captureWarnings(True) # Show warnings via the logging system

57

58

locale.setlocale(locale.LC_ALL, "")

59

60

logging.getLogger("dbus.proxies").setLevel(logging.CRITICAL)

57

61

58

62

# Some useful constants

59

domain = 'se.recompile'

60

server_interface = domain + '.Mandos'

61

client_interface = domain + '.Mandos.Client'

62

version = "1.8.8"

63

domain = "se.recompile"

64

server_interface = domain + ".Mandos"

65

client_interface = domain + ".Mandos.Client"

66

version = "1.8.9"

63

67

64

68

try:

65

69

dbus.OBJECT_MANAGER_IFACE

122

126

"""

123

127

124

128

def __init__(self, server_proxy_object=None, update_hook=None,

125

delete_hook=None, logger=None, **kwargs):

129

delete_hook=None, **kwargs):

126

130

# Called on update

127

131

self.update_hook = update_hook

128

132

# Called on delete

129

133

self.delete_hook = delete_hook

130

134

# Mandos Server proxy object

131

135

self.server_proxy_object = server_proxy_object

132

# Logger

133

self.logger = logger

134

136

135

137

self._update_timer_callback_tag = None

136

138

163

165

self.rejected,

164

166

client_interface,

165

167

byte_arrays=True))

166

self.logger('Created client {}'

167

.format(self.properties["Name"]), level=0)

168

log.debug("Created client %s", self.properties["Name"])

168

169

170

def using_timer(self, flag):

170

171

"""Call this method with True or False when timer should be

172

173

"""

173

174

if flag and self._update_timer_callback_tag is None:

174

175

# Will update the shown timer value every second

175

self._update_timer_callback_tag = (GLib.timeout_add

176

(1000,

177

self.update_timer))

176

self._update_timer_callback_tag = (

177

GLib.timeout_add(1000,

178

glib_safely(self.update_timer)))

178

179

elif not (flag or self._update_timer_callback_tag is None):

179

180

GLib.source_remove(self._update_timer_callback_tag)

180

181

self._update_timer_callback_tag = None

181

182

183

def checker_completed(self, exitstatus, condition, command):

183

184

if exitstatus == 0:

184

self.logger('Checker for client {} (command "{}")'

185

' succeeded'.format(self.properties["Name"],

186

command), level=0)

185

log.debug('Checker for client %s (command "%s")'

186

" succeeded", self.properties["Name"], command)

187

self.update()

188

return

189

# Checker failed

190

if os.WIFEXITED(condition):

191

self.logger('Checker for client {} (command "{}") failed'

192

' with exit code {}'

193

.format(self.properties["Name"], command,

194

os.WEXITSTATUS(condition)))

191

log.info('Checker for client %s (command "%s") failed'

192

" with exit code %d", self.properties["Name"],

193

command, os.WEXITSTATUS(condition))

195

194

elif os.WIFSIGNALED(condition):

196

self.logger('Checker for client {} (command "{}") was'

197

' killed by signal {}'

198

.format(self.properties["Name"], command,

199

os.WTERMSIG(condition)))

195

log.info('Checker for client %s (command "%s") was'

196

" killed by signal %d", self.properties["Name"],

197

command, os.WTERMSIG(condition))

200

198

self.update()

201

199

202

200

def checker_started(self, command):

203

201

"""Server signals that a checker started."""

204

self.logger('Client {} started checker "{}"'

205

.format(self.properties["Name"],

206

command), level=0)

202

log.debug('Client %s started checker "%s"',

203

self.properties["Name"], command)

207

204

208

205

def got_secret(self):

209

self.logger('Client {} received its secret'

210

.format(self.properties["Name"]))

206

log.info("Client %s received its secret",

207

self.properties["Name"])

211

208

212

209

def need_approval(self, timeout, default):

213

210

if not default:

214

message = 'Client {} needs approval within {} seconds'

211

message = "Client %s needs approval within %f seconds"

215

212

else:

216

message = 'Client {} will get its secret in {} seconds'

217

self.logger(message.format(self.properties["Name"],

218

timeout/1000))

213

message = "Client %s will get its secret in %f seconds"

214

log.info(message, self.properties["Name"], timeout/1000)

219

215

220

216

def rejected(self, reason):

221

self.logger('Client {} was rejected; reason: {}'

222

.format(self.properties["Name"], reason))

217

log.info("Client %s was rejected; reason: %s",

218

self.properties["Name"], reason)

223

219

224

220

def selectable(self):

225

221

"""Make this a "selectable" widget.

251

247

# Rebuild focus and non-focus widgets using current properties

252

248

253

249

# Base part of a client. Name!

254

base = '{name}: '.format(name=self.properties["Name"])

250

base = "{name}: ".format(name=self.properties["Name"])

255

251

if not self.properties["Enabled"]:

256

252

message = "DISABLED"

257

253

self.using_timer(False)

279

275

timer = datetime.timedelta(0)

280

276

else:

281

277

expires = (datetime.datetime.strptime

282

(expires, '%Y-%m-%dT%H:%M:%S.%f'))

278

(expires, "%Y-%m-%dT%H:%M:%S.%f"))

283

279

timer = max(expires - datetime.datetime.utcnow(),

284

280

datetime.timedelta())

285

message = ('A checker has failed! Time until client'

286

' gets disabled: {}'

281

message = ("A checker has failed! Time until client"

282

" gets disabled: {}"

287

283

.format(str(timer).rsplit(".", 1)[0]))

288

284

self.using_timer(True)

289

285

else:

387

383

self.update()

388

384

389

385

386

def glib_safely(func, retval=True):

387

def safe_func(*args, **kwargs):

388

try:

389

return func(*args, **kwargs)

390

except Exception:

391

log.exception("")

392

return retval

393

return safe_func

394

395

390

396

class ConstrainedListBox(urwid.ListBox):

391

397

"""Like a normal urwid.ListBox, but will consume all "up" or

392

398

"down" key presses, thus not allowing any containing widgets to

404

410

"""This is the entire user interface - the whole screen

405

411

with boxes, lists of client widgets, etc.

406

412

"""

407

def __init__(self, max_log_length=1000, log_level=1):

413

def __init__(self, max_log_length=1000):

408

414

DBusGMainLoop(set_as_default=True)

409

415

410

416

self.screen = urwid.curses_display.Screen()

447

453

self.log = urwid.SimpleListWalker([])

448

454

self.max_log_length = max_log_length

449

455

450

self.log_level = log_level

451

452

456

# We keep a reference to the log widget so we can remove it

453

457

# from the ListWalker without it getting destroyed

454

458

self.logbox = ConstrainedListBox(self.log)

458

462

self.log_visible = True

459

463

self.log_wrap = "any"

460

464

465

self.loghandler = UILogHandler(self)

466

461

467

self.rebuild()

462

self.log_message_raw(("bold",

463

"Mandos Monitor version " + version))

464

self.log_message_raw(("bold",

465

"q: Quit ?: Help"))

468

self.add_log_line(("bold",

469

"Mandos Monitor version " + version))

470

self.add_log_line(("bold", "q: Quit ?: Help"))

466

471

467

self.busname = domain + '.Mandos'

472

self.busname = domain + ".Mandos"

468

473

self.main_loop = GLib.MainLoop()

469

474

470

475

def client_not_found(self, key_id, address):

471

self.log_message("Client with address {} and key ID {} could"

472

" not be found".format(address, key_id))

476

log.info("Client with address %s and key ID %s could"

477

" not be found", address, key_id)

473

478

474

479

def rebuild(self):

475

480

"""This rebuilds the User Interface.

486

491

self.uilist.append(self.logbox)

487

492

self.topwidget = urwid.Pile(self.uilist)

488

493

489

def log_message(self, message, level=1):

490

"""Log message formatted with timestamp"""

491

if level < self.log_level:

492

return

493

timestamp = datetime.datetime.now().isoformat()

494

self.log_message_raw("{}: {}".format(timestamp, message),

495

level=level)

496

497

def log_message_raw(self, markup, level=1):

498

"""Add a log message to the log buffer."""

499

if level < self.log_level:

500

return

494

def add_log_line(self, markup):

501

495

self.log.append(urwid.Text(markup, wrap=self.log_wrap))

502

496

if self.max_log_length:

503

497

if len(self.log) > self.max_log_length:

504

del self.log[0:len(self.log)-self.max_log_length-1]

498

del self.log[0:(len(self.log) - self.max_log_length)]

505

499

self.logbox.set_focus(len(self.logbox.body.contents)-1,

506

500

coming_from="above")

507

501

self.refresh()

510

504

"""Toggle visibility of the log buffer."""

511

505

self.log_visible = not self.log_visible

512

506

self.rebuild()

513

self.log_message("Log visibility changed to: {}"

514

.format(self.log_visible), level=0)

507

log.debug("Log visibility changed to: %s", self.log_visible)

515

508

516

509

def change_log_display(self):

517

510

"""Change type of log display.

522

515

self.log_wrap = "clip"

523

516

for textwidget in self.log:

524

517

textwidget.set_wrap_mode(self.log_wrap)

525

self.log_message("Wrap mode: {}".format(self.log_wrap),

526

level=0)

518

log.debug("Wrap mode: %s", self.log_wrap)

527

519

528

520

def find_and_remove_client(self, path, interfaces):

529

521

"""Find a client by its object path and remove it.

537

529

client = self.clients_dict[path]

538

530

except KeyError:

539

531

# not found?

540

self.log_message("Unknown client {!r} removed"

541

.format(path))

532

log.warning("Unknown client %s removed", path)

542

533

return

543

534

client.delete()

544

535

557

548

proxy_object=client_proxy_object,

558

549

update_hook=self.refresh,

559

550

delete_hook=self.remove_client,

560

logger=self.log_message,

561

551

properties=dict(ifs_and_props[client_interface])),

562

552

path=path)

563

553

583

573

584

574

def run(self):

585

575

"""Start the main loop and exit when it's done."""

576

log.addHandler(self.loghandler)

577

self.orig_log_propagate = log.propagate

578

log.propagate = False

579

self.orig_log_level = log.level

580

log.setLevel("INFO")

586

581

self.bus = dbus.SystemBus()

587

582

mandos_dbus_objc = self.bus.get_object(

588

583

self.busname, "/", follow_name_owner_changes=True)

592

587

mandos_clients = (self.mandos_serv

593

588

.GetAllClientsWithProperties())

594

589

if not mandos_clients:

595

self.log_message_raw(("bold",

596

"Note: Server has no clients."))

590

log.warning("Note: Server has no clients.")

597

591

except dbus.exceptions.DBusException:

598

self.log_message_raw(("bold",

599

"Note: No Mandos server running."))

592

log.warning("Note: No Mandos server running.")

600

593

mandos_clients = dbus.Dictionary()

601

594

602

595

(self.mandos_serv

622

615

proxy_object=client_proxy_object,

623

616

properties=client,

624

617

update_hook=self.refresh,

625

delete_hook=self.remove_client,

626

logger=self.log_message),

618

delete_hook=self.remove_client),

627

619

path=path)

628

620

629

621

self.refresh()

631

623

GLib.io_add_watch(

632

624

GLib.IOChannel.unix_new(sys.stdin.fileno()),

633

625

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

634

self.process_input))

626

glib_safely(self.process_input)))

635

627

self.main_loop.run()

636

628

# Main loop has finished, we should close everything now

637

629

GLib.source_remove(self._input_callback_tag)

641

633

642

634

def stop(self):

643

635

self.main_loop.quit()

636

log.removeHandler(self.loghandler)

637

log.propagate = self.orig_log_propagate

644

638

645

639

def process_input(self, source, condition):

646

640

keys = self.screen.get_input()

679

673

if not self.log_visible:

680

674

self.log_visible = True

681

675

self.rebuild()

682

self.log_message_raw(("bold",

683

" ".

684

join(("q: Quit",

685

"?: Help",

686

"l: Log window toggle",

687

"TAB: Switch window",

688

"w: Wrap (log lines)",

689

"v: Toggle verbose log",

690

))))

691

self.log_message_raw(("bold",

692

" "

693

.join(("Clients:",

694

"+: Enable",

695

"-: Disable",

696

"R: Remove",

697

"s: Start new checker",

698

"S: Stop checker",

699

"C: Checker OK",

700

"a: Approve",

701

"d: Deny"))))

676

self.add_log_line(("bold",

677

" ".join(("q: Quit",

678

"?: Help",

679

"l: Log window toggle",

680

"TAB: Switch window",

681

"w: Wrap (log lines)",

682

"v: Toggle verbose log",

683

))))

684

self.add_log_line(("bold",

685

" ".join(("Clients:",

686

"+: Enable",

687

"-: Disable",

688

"R: Remove",

689

"s: Start new checker",

690

"S: Stop checker",

691

"C: Checker OK",

692

"a: Approve",

693

"d: Deny",

694

))))

702

695

self.refresh()

703

696

elif key == "tab":

704

697

if self.topwidget.get_focus() is self.logbox:

707

700

self.topwidget.set_focus(self.logbox)

708

701

self.refresh()

709

702

elif key == "v":

710

if self.log_level == 0:

711

self.log_level = 1

712

self.log_message("Verbose mode: Off")

703

if log.level < logging.INFO:

704

log.setLevel(logging.INFO)

705

log.info("Verbose mode: Off")

713

706

else:

714

self.log_level = 0

715

self.log_message("Verbose mode: On")

707

log.setLevel(logging.NOTSET)

708

log.info("Verbose mode: On")

716

709

# elif (key == "end" or key == "meta >" or key == "G"

717

710

# or key == ">"):

718

711

# pass # xxx end-of-buffer

737

730

return True

738

731

739

732

733

class UILogHandler(logging.Handler):

734

def __init__(self, ui, *args, **kwargs):

735

self.ui = ui

736

super(UILogHandler, self).__init__(*args, **kwargs)

737

self.setFormatter(

738

logging.Formatter("%(asctime)s: %(message)s"))

739

def emit(self, record):

740

msg = self.format(record)

741

if record.levelno > logging.INFO:

742

msg = ("bold", msg)

743

self.ui.add_log_line(msg)

744

745

740

746

ui = UserInterface()

741

747

try:

742

748

ui.run()

743

749

except KeyboardInterrupt:

744

ui.screen.stop()

745

except Exception as e:

746

ui.log_message(str(e))

747

ui.screen.stop()

750

with warnings.catch_warnings():

751

warnings.filterwarnings("ignore", "", BytesWarning)

752

ui.screen.stop()

753

except Exception:

754

with warnings.catch_warnings():

755

warnings.filterwarnings("ignore", "", BytesWarning)

756

ui.screen.stop()

748

757

raise