/mandos/trunk : revision 1182

1

#!/usr/bin/python3 -bbI

1

#!/usr/bin/python3 -bb

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

40

38

41

39

import urwid.curses_display

42

40

import urwid

46

44

47

45

import dbus

48

46

47

import locale

48

49

import logging

50

49

51

if sys.version_info.major == 2:

50

52

str = unicode

51

53

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)

54

locale.setlocale(locale.LC_ALL, '')

55

56

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

61

57

62

58

# Some useful constants

63

domain = "se.recompile"

64

server_interface = domain + ".Mandos"

65

client_interface = domain + ".Mandos.Client"

59

domain = 'se.recompile'

60

server_interface = domain + '.Mandos'

61

client_interface = domain + '.Mandos.Client'

66

62

version = "1.8.9"

67

63

68

64

try:

126

122

"""

127

123

128

124

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

129

delete_hook=None, **kwargs):

125

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

130

126

# Called on update

131

127

self.update_hook = update_hook

132

128

# Called on delete

133

129

self.delete_hook = delete_hook

134

130

# Mandos Server proxy object

135

131

self.server_proxy_object = server_proxy_object

132

# Logger

133

self.logger = logger

136

134

137

135

self._update_timer_callback_tag = None

138

136

165

163

self.rejected,

166

164

client_interface,

167

165

byte_arrays=True))

168

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

166

self.logger('Created client {}'

167

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

169

168

170

169

def using_timer(self, flag):

171

170

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

173

172

"""

174

173

if flag and self._update_timer_callback_tag is None:

175

174

# Will update the shown timer value every second

176

self._update_timer_callback_tag = (

177

GLib.timeout_add(1000,

178

glib_safely(self.update_timer)))

175

self._update_timer_callback_tag = (GLib.timeout_add

176

(1000,

177

self.update_timer))

179

178

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

180

179

GLib.source_remove(self._update_timer_callback_tag)

181

180

self._update_timer_callback_tag = None

182

181

183

182

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

184

183

if exitstatus == 0:

185

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

186

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

184

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

185

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

186

command), level=0)

187

self.update()

188

return

189

# Checker failed

190

if os.WIFEXITED(condition):

191

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

192

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

193

command, os.WEXITSTATUS(condition))

191

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

192

' with exit code {}'

193

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

194

os.WEXITSTATUS(condition)))

194

195

elif os.WIFSIGNALED(condition):

195

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

196

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

197

command, os.WTERMSIG(condition))

196

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

197

' killed by signal {}'

198

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

199

os.WTERMSIG(condition)))

198

200

self.update()

199

201

200

202

def checker_started(self, command):

201

203

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

202

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

203

self.properties["Name"], command)

204

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

205

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

206

command), level=0)

204

207

205

208

def got_secret(self):

206

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

207

self.properties["Name"])

209

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

210

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

208

211

209

212

def need_approval(self, timeout, default):

210

213

if not default:

211

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

214

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

212

215

else:

213

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

214

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

216

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

217

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

218

timeout/1000))

215

219

216

220

def rejected(self, reason):

217

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

218

self.properties["Name"], reason)

221

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

222

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

219

223

220

224

def selectable(self):

221

225

"""Make this a "selectable" widget.

247

251

# Rebuild focus and non-focus widgets using current properties

248

252

249

253

# Base part of a client. Name!

250

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

254

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

251

255

if not self.properties["Enabled"]:

252

256

message = "DISABLED"

253

257

self.using_timer(False)

275

279

timer = datetime.timedelta(0)

276

280

else:

277

281

expires = (datetime.datetime.strptime

278

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

282

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

279

283

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

280

284

datetime.timedelta())

281

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

282

" gets disabled: {}"

285

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

286

' gets disabled: {}'

283

287

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

284

288

self.using_timer(True)

285

289

else:

383

387

self.update()

384

388

385

389

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

396

390

class ConstrainedListBox(urwid.ListBox):

397

391

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

398

392

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

410

404

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

411

405

with boxes, lists of client widgets, etc.

412

406

"""

413

def __init__(self, max_log_length=1000):

407

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

414

408

DBusGMainLoop(set_as_default=True)

415

409

416

410

self.screen = urwid.curses_display.Screen()

453

447

self.log = urwid.SimpleListWalker([])

454

448

self.max_log_length = max_log_length

455

449

450

self.log_level = log_level

451

456

452

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

457

453

# from the ListWalker without it getting destroyed

458

454

self.logbox = ConstrainedListBox(self.log)

462

458

self.log_visible = True

463

459

self.log_wrap = "any"

464

460

465

self.loghandler = UILogHandler(self)

466

467

461

self.rebuild()

468

self.add_log_line(("bold",

469

"Mandos Monitor version " + version))

470

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

462

self.log_message_raw(("bold",

463

"Mandos Monitor version " + version))

464

self.log_message_raw(("bold",

465

"q: Quit ?: Help"))

471

466

472

self.busname = domain + ".Mandos"

467

self.busname = domain + '.Mandos'

473

468

self.main_loop = GLib.MainLoop()

474

469

475

470

def client_not_found(self, key_id, address):

476

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

477

" not be found", address, key_id)

471

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

472

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

478

473

479

474

def rebuild(self):

480

475

"""This rebuilds the User Interface.

491

486

self.uilist.append(self.logbox)

492

487

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

493

488

494

def add_log_line(self, markup):

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

495

501

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

496

502

if self.max_log_length:

497

503

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

498

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

504

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

499

505

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

500

506

coming_from="above")

501

507

self.refresh()

504

510

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

505

511

self.log_visible = not self.log_visible

506

512

self.rebuild()

507

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

513

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

514

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

508

515

509

516

def change_log_display(self):

510

517

"""Change type of log display.

515

522

self.log_wrap = "clip"

516

523

for textwidget in self.log:

517

524

textwidget.set_wrap_mode(self.log_wrap)

518

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

525

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

526

level=0)

519

527

520

528

def find_and_remove_client(self, path, interfaces):

521

529

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

529

537

client = self.clients_dict[path]

530

538

except KeyError:

531

539

# not found?

532

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

540

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

541

.format(path))

533

542

return

534

543

client.delete()

535

544

548

557

proxy_object=client_proxy_object,

549

558

update_hook=self.refresh,

550

559

delete_hook=self.remove_client,

560

logger=self.log_message,

551

561

properties=dict(ifs_and_props[client_interface])),

552

562

path=path)

553

563

573

583

574

584

def run(self):

575

585

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

581

586

self.bus = dbus.SystemBus()

582

587

mandos_dbus_objc = self.bus.get_object(

583

588

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

587

592

mandos_clients = (self.mandos_serv

588

593

.GetAllClientsWithProperties())

589

594

if not mandos_clients:

590

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

595

self.log_message_raw(("bold",

596

"Note: Server has no clients."))

591

597

except dbus.exceptions.DBusException:

592

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

598

self.log_message_raw(("bold",

599

"Note: No Mandos server running."))

593

600

mandos_clients = dbus.Dictionary()

594

601

595

602

(self.mandos_serv

615

622

proxy_object=client_proxy_object,

616

623

properties=client,

617

624

update_hook=self.refresh,

618

delete_hook=self.remove_client),

625

delete_hook=self.remove_client,

626

logger=self.log_message),

619

627

path=path)

620

628

621

629

self.refresh()

623

631

GLib.io_add_watch(

624

632

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

625

633

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

626

glib_safely(self.process_input)))

634

self.process_input))

627

635

self.main_loop.run()

628

636

# Main loop has finished, we should close everything now

629

637

GLib.source_remove(self._input_callback_tag)

633

641

634

642

def stop(self):

635

643

self.main_loop.quit()

636

log.removeHandler(self.loghandler)

637

log.propagate = self.orig_log_propagate

638

644

639

645

def process_input(self, source, condition):

640

646

keys = self.screen.get_input()

673

679

if not self.log_visible:

674

680

self.log_visible = True

675

681

self.rebuild()

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

))))

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

695

702

self.refresh()

696

703

elif key == "tab":

697

704

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

700

707

self.topwidget.set_focus(self.logbox)

701

708

self.refresh()

702

709

elif key == "v":

703

if log.level < logging.INFO:

704

log.setLevel(logging.INFO)

705

log.info("Verbose mode: Off")

710

if self.log_level == 0:

711

self.log_level = 1

712

self.log_message("Verbose mode: Off")

706

713

else:

707

log.setLevel(logging.NOTSET)

708

log.info("Verbose mode: On")

714

self.log_level = 0

715

self.log_message("Verbose mode: On")

709

716

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

710

717

# or key == ">"):

711

718

# pass # xxx end-of-buffer

730

737

return True

731

738

732

739

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

746

740

ui = UserInterface()

747

741

try:

748

742

ui.run()

749

743

except KeyboardInterrupt:

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

744

ui.screen.stop()

745

except Exception as e:

746

ui.log_message(str(e))

747

ui.screen.stop()

757

748

raise