/mandos/trunk : revision 24.1.145

1

#!/usr/bin/python

2

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

3

4

from __future__ import division, absolute_import, with_statement

5

6

import sys

7

import os

8

import signal

9

10

import datetime

11

12

import urwid.curses_display

13

import urwid

14

15

from dbus.mainloop.glib import DBusGMainLoop

16

import gobject

17

18

import dbus

19

20

import UserList

21

22

import locale

23

24

locale.setlocale(locale.LC_ALL, u'')

25

26

import logging

27

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

28

29

# Some useful constants

30

domain = 'se.bsnet.fukt'

31

server_interface = domain + '.Mandos'

32

client_interface = domain + '.Mandos.Client'

33

version = "1.0.15"

34

35

# Always run in monochrome mode

36

urwid.curses_display.curses.has_colors = lambda : False

37

38

# Urwid doesn't support blinking, but we want it. Since we have no

39

# use for underline on its own, we make underline also always blink.

40

urwid.curses_display.curses.A_UNDERLINE |= (

41

urwid.curses_display.curses.A_BLINK)

42

43

def isoformat_to_datetime(iso):

44

"Parse an ISO 8601 date string to a datetime.datetime()"

45

if not iso:

46

return None

47

d, t = iso.split(u"T", 1)

48

year, month, day = d.split(u"-", 2)

49

hour, minute, second = t.split(u":", 2)

50

second, fraction = divmod(float(second), 1)

51

return datetime.datetime(int(year),

52

int(month),

53

int(day),

54

int(hour),

55

int(minute),

56

int(second), # Whole seconds

57

int(fraction*1000000)) # Microseconds

58

59

class MandosClientPropertyCache(object):

60

"""This wraps a Mandos Client D-Bus proxy object, caches the

61

properties and calls a hook function when any of them are

62

changed.

63

"""

64

def __init__(self, proxy_object=None, *args, **kwargs):

65

self.proxy = proxy_object # Mandos Client proxy object

66

67

self.properties = dict()

68

self.proxy.connect_to_signal(u"PropertyChanged",

69

self.property_changed,

70

client_interface,

71

byte_arrays=True)

72

73

self.properties.update(

74

self.proxy.GetAll(client_interface,

75

dbus_interface = dbus.PROPERTIES_IFACE))

76

77

#XXX This break good super behaviour!

78

# super(MandosClientPropertyCache, self).__init__(

79

# *args, **kwargs)

80

81

def property_changed(self, property=None, value=None):

82

"""This is called whenever we get a PropertyChanged signal

83

It updates the changed property in the "properties" dict.

84

"""

85

# Update properties dict with new value

86

self.properties[property] = value

87

88

89

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

90

"""A Mandos Client which is visible on the screen.

91

"""

92

93

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

94

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

95

# Called on update

96

self.update_hook = update_hook

97

# Called on delete

98

self.delete_hook = delete_hook

99

# Mandos Server proxy object

100

self.server_proxy_object = server_proxy_object

101

# Logger

102

self.logger = logger

103

104

self._update_timer_callback_tag = None

105

self.last_checker_failed = False

106

107

# The widget shown normally

108

self._text_widget = urwid.Text(u"")

109

# The widget shown when we have focus

110

self._focus_text_widget = urwid.Text(u"")

111

super(MandosClientWidget, self).__init__(

112

update_hook=update_hook, delete_hook=delete_hook,

113

*args, **kwargs)

114

self.update()

115

self.opened = False

116

self.proxy.connect_to_signal(u"CheckerCompleted",

117

self.checker_completed,

118

client_interface,

119

byte_arrays=True)

120

self.proxy.connect_to_signal(u"CheckerStarted",

121

self.checker_started,

122

client_interface,

123

byte_arrays=True)

124

self.proxy.connect_to_signal(u"GotSecret",

125

self.got_secret,

126

client_interface,

127

byte_arrays=True)

128

self.proxy.connect_to_signal(u"NeedApproval",

129

self.need_approval,

130

client_interface,

131

byte_arrays=True)

132

self.proxy.connect_to_signal(u"Rejected",

133

self.rejected,

134

client_interface,

135

byte_arrays=True)

136

last_checked_ok = isoformat_to_datetime(self.properties

137

[u"LastCheckedOK"])

138

if last_checked_ok is None:

139

self.last_checker_failed = True

140

else:

141

self.last_checker_failed = ((datetime.datetime.utcnow()

142

- last_checked_ok)

143

> datetime.timedelta

144

(milliseconds=

145

self.properties

146

[u"Interval"]))

147

if self.last_checker_failed:

148

self._update_timer_callback_tag = (gobject.timeout_add

149

(1000,

150

self.update_timer))

151

152

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

153

if exitstatus == 0:

154

if self.last_checker_failed:

155

self.last_checker_failed = False

156

gobject.source_remove(self._update_timer_callback_tag)

157

self._update_timer_callback_tag = None

158

self.logger(u'Checker for client %s (command "%s")'

159

u' was successful'

160

% (self.properties[u"Name"], command))

161

self.update()

162

return

163

# Checker failed

164

if not self.last_checker_failed:

165

self.last_checker_failed = True

166

self._update_timer_callback_tag = (gobject.timeout_add

167

(1000,

168

self.update_timer))

169

if os.WIFEXITED(condition):

170

self.logger(u'Checker for client %s (command "%s")'

171

u' failed with exit code %s'

172

% (self.properties[u"Name"], command,

173

os.WEXITSTATUS(condition)))

174

elif os.WIFSIGNALED(condition):

175

self.logger(u'Checker for client %s (command "%s")'

176

u' was killed by signal %s'

177

% (self.properties[u"Name"], command,

178

os.WTERMSIG(condition)))

179

elif os.WCOREDUMP(condition):

180

self.logger(u'Checker for client %s (command "%s")'

181

u' dumped core'

182

% (self.properties[u"Name"], command))

183

else:

184

self.logger(u'Checker for client %s completed'

185

u' mysteriously')

186

self.update()

187

188

def checker_started(self, command):

189

#self.logger(u'Client %s started checker "%s"'

190

# % (self.properties[u"Name"], unicode(command)))

191

pass

192

193

def got_secret(self):

194

self.last_checker_failed = False

195

self.logger(u'Client %s received its secret'

196

% self.properties[u"Name"])

197

198

def need_approval(self, timeout, default):

199

if not default:

200

message = u'Client %s needs approval within %s seconds'

201

else:

202

message = u'Client %s will get its secret in %s seconds'

203

self.logger(message

204

% (self.properties[u"Name"], timeout/1000))

205

206

def rejected(self, reason):

207

self.logger(u'Client %s was rejected; reason: %s'

208

% (self.properties[u"Name"], reason))

209

210

def selectable(self):

211

"""Make this a "selectable" widget.

212

This overrides the method from urwid.FlowWidget."""

213

return True

214

215

def rows(self, (maxcol,), focus=False):

216

"""How many rows this widget will occupy might depend on

217

whether we have focus or not.

218

This overrides the method from urwid.FlowWidget"""

219

return self.current_widget(focus).rows((maxcol,), focus=focus)

220

221

def current_widget(self, focus=False):

222

if focus or self.opened:

223

return self._focus_widget

224

return self._widget

225

226

def update(self):

227

"Called when what is visible on the screen should be updated."

228

# How to add standout mode to a style

229

with_standout = { u"normal": u"standout",

230

u"bold": u"bold-standout",

231

u"underline-blink":

232

u"underline-blink-standout",

233

u"bold-underline-blink":

234

u"bold-underline-blink-standout",

235

}

236

237

# Rebuild focus and non-focus widgets using current properties

238

239

# Base part of a client. Name!

240

base = (u'%(name)s: '

241

% {u"name": self.properties[u"Name"]})

242

if not self.properties[u"Enabled"]:

243

message = u"DISABLED"

244

elif self.properties[u"ApprovalPending"]:

245

if self.properties[u"ApprovedByDefault"]:

246

message = u"Connection established to client. (d)eny?"

247

else:

248

message = u"Seeks approval to send secret. (a)pprove?"

249

elif self.last_checker_failed:

250

timeout = datetime.timedelta(milliseconds

251

= self.properties

252

[u"Timeout"])

253

last_ok = isoformat_to_datetime(

254

max((self.properties[u"LastCheckedOK"]

255

or self.properties[u"Created"]),

256

self.properties[u"LastEnabled"]))

257

timer = timeout - (datetime.datetime.utcnow() - last_ok)

258

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

259

u' gets diabled: %s'

260

% unicode(timer).rsplit(".", 1)[0])

261

else:

262

message = u"enabled"

263

self._text = "%s%s" % (base, message)

264

265

if not urwid.supports_unicode():

266

self._text = self._text.encode("ascii", "replace")

267

textlist = [(u"normal", self._text)]

268

self._text_widget.set_text(textlist)

269

self._focus_text_widget.set_text([(with_standout[text[0]],

270

text[1])

271

if isinstance(text, tuple)

272

else text

273

for text in textlist])

274

self._widget = self._text_widget

275

self._focus_widget = urwid.AttrWrap(self._focus_text_widget,

276

"standout")

277

# Run update hook, if any

278

if self.update_hook is not None:

279

self.update_hook()

280

281

def update_timer(self):

282

"called by gobject"

283

self.update()

284

return True # Keep calling this

285

286

def delete(self):

287

if self._update_timer_callback_tag is not None:

288

gobject.source_remove(self._update_timer_callback_tag)

289

self._update_timer_callback_tag = None

290

if self.delete_hook is not None:

291

self.delete_hook(self)

292

293

def render(self, (maxcol,), focus=False):

294

"""Render differently if we have focus.

295

This overrides the method from urwid.FlowWidget"""

296

return self.current_widget(focus).render((maxcol,),

297

focus=focus)

298

299

def keypress(self, (maxcol,), key):

300

"""Handle keys.

301

This overrides the method from urwid.FlowWidget"""

302

if key == u"+":

303

self.proxy.Enable(dbus_interface = client_interface)

304

elif key == u"-":

305

self.proxy.Disable(dbus_interface = client_interface)

306

elif key == u"a":

307

self.proxy.Approve(dbus.Boolean(True, variant_level=1),

308

dbus_interface = client_interface)

309

elif key == u"d":

310

self.proxy.Approve(dbus.Boolean(False, variant_level=1),

311

dbus_interface = client_interface)

312

elif key == u"r" or key == u"_" or key == u"ctrl k":

313

self.server_proxy_object.RemoveClient(self.proxy

314

.object_path)

315

elif key == u"s":

316

self.proxy.StartChecker(dbus_interface = client_interface)

317

elif key == u"S":

318

self.proxy.StopChecker(dbus_interface = client_interface)

319

elif key == u"C":

320

self.proxy.CheckedOK(dbus_interface = client_interface)

321

# xxx

322

# elif key == u"p" or key == "=":

323

# self.proxy.pause()

324

# elif key == u"u" or key == ":":

325

# self.proxy.unpause()

326

# elif key == u"RET":

327

# self.open()

328

# elif key == u"+":

329

# self.proxy.Approve(True)

330

# elif key == u"-":

331

# self.proxy.Approve(False)

332

else:

333

return key

334

335

def property_changed(self, property=None, value=None,

336

*args, **kwargs):

337

"""Call self.update() if old value is not new value.

338

This overrides the method from MandosClientPropertyCache"""

339

property_name = unicode(property)

340

old_value = self.properties.get(property_name)

341

super(MandosClientWidget, self).property_changed(

342

property=property, value=value, *args, **kwargs)

343

if self.properties.get(property_name) != old_value:

344

self.update()

345

346

347

class ConstrainedListBox(urwid.ListBox):

348

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

349

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

350

use them as an excuse to shift focus away from this widget.

351

"""

352

def keypress(self, (maxcol, maxrow), key):

353

ret = super(ConstrainedListBox, self).keypress((maxcol,

354

maxrow), key)

355

if ret in (u"up", u"down"):

356

return

357

return ret

358

359

360

class UserInterface(object):

361

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

362

with boxes, lists of client widgets, etc.

363

"""

364

def __init__(self, max_log_length=1000):

365

DBusGMainLoop(set_as_default=True)

366

367

self.screen = urwid.curses_display.Screen()

368

369

self.screen.register_palette((

370

(u"normal",

371

u"default", u"default", None),

372

(u"bold",

373

u"default", u"default", u"bold"),

374

(u"underline-blink",

375

u"default", u"default", u"underline"),

376

(u"standout",

377

u"default", u"default", u"standout"),

378

(u"bold-underline-blink",

379

u"default", u"default", (u"bold", u"underline")),

380

(u"bold-standout",

381

u"default", u"default", (u"bold", u"standout")),

382

(u"underline-blink-standout",

383

u"default", u"default", (u"underline", u"standout")),

384

(u"bold-underline-blink-standout",

385

u"default", u"default", (u"bold", u"underline",

386

u"standout")),

387

))

388

389

if urwid.supports_unicode():

390

self.divider = u"─" # \u2500

391

#self.divider = u"━" # \u2501

392

else:

393

#self.divider = u"-" # \u002d

394

self.divider = u"_" # \u005f

395

396

self.screen.start()

397

398

self.size = self.screen.get_cols_rows()

399

400

self.clients = urwid.SimpleListWalker([])

401

self.clients_dict = {}

402

403

# We will add Text widgets to this list

404

self.log = []

405

self.max_log_length = max_log_length

406

407

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

408

# from the ListWalker without it getting destroyed

409

self.logbox = ConstrainedListBox(self.log)

410

411

# This keeps track of whether self.uilist currently has

412

# self.logbox in it or not

413

self.log_visible = True

414

self.log_wrap = u"any"

415

416

self.rebuild()

417

self.log_message_raw((u"bold",

418

u"Mandos Monitor version " + version))

419

self.log_message_raw((u"bold",

420

u"q: Quit ?: Help"))

421

422

self.busname = domain + '.Mandos'

423

self.main_loop = gobject.MainLoop()

424

self.bus = dbus.SystemBus()

425

mandos_dbus_objc = self.bus.get_object(

426

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

427

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

428

dbus_interface

429

= server_interface)

430

try:

431

mandos_clients = (self.mandos_serv

432

.GetAllClientsWithProperties())

433

except dbus.exceptions.DBusException:

434

mandos_clients = dbus.Dictionary()

435

436

(self.mandos_serv

437

.connect_to_signal(u"ClientRemoved",

438

self.find_and_remove_client,

439

dbus_interface=server_interface,

440

byte_arrays=True))

441

(self.mandos_serv

442

.connect_to_signal(u"ClientAdded",

443

self.add_new_client,

444

dbus_interface=server_interface,

445

byte_arrays=True))

446

(self.mandos_serv

447

.connect_to_signal(u"ClientNotFound",

448

self.client_not_found,

449

dbus_interface=server_interface,

450

byte_arrays=True))

451

for path, client in mandos_clients.iteritems():

452

client_proxy_object = self.bus.get_object(self.busname,

453

path)

454

self.add_client(MandosClientWidget(server_proxy_object

455

=self.mandos_serv,

456

proxy_object

457

=client_proxy_object,

458

properties=client,

459

update_hook

460

=self.refresh,

461

delete_hook

462

=self.remove_client,

463

logger

464

=self.log_message),

465

path=path)

466

467

def client_not_found(self, fingerprint, address):

468

self.log_message((u"Client with address %s and fingerprint %s"

469

u" could not be found" % (address,

470

fingerprint)))

471

472

def rebuild(self):

473

"""This rebuilds the User Interface.

474

Call this when the widget layout needs to change"""

475

self.uilist = []

476

#self.uilist.append(urwid.ListBox(self.clients))

477

self.uilist.append(urwid.Frame(ConstrainedListBox(self.

478

clients),

479

#header=urwid.Divider(),

480

header=None,

481

footer=

482

urwid.Divider(div_char=

483

self.divider)))

484

if self.log_visible:

485

self.uilist.append(self.logbox)

486

pass

487

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

488

489

def log_message(self, message):

490

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

491

self.log_message_raw(timestamp + u": " + message)

492

493

def log_message_raw(self, markup):

494

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

495

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

496

if (self.max_log_length

497

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

498

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

499

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

500

coming_from=u"above")

501

self.refresh()

502

503

def toggle_log_display(self):

504

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

505

self.log_visible = not self.log_visible

506

self.rebuild()

507

self.log_message(u"Log visibility changed to: "

508

+ unicode(self.log_visible))

509

510

def change_log_display(self):

511

"""Change type of log display.

512

Currently, this toggles wrapping of text lines."""

513

if self.log_wrap == u"clip":

514

self.log_wrap = u"any"

515

else:

516

self.log_wrap = u"clip"

517

for textwidget in self.log:

518

textwidget.set_wrap_mode(self.log_wrap)

519

self.log_message(u"Wrap mode: " + self.log_wrap)

520

521

def find_and_remove_client(self, path, name):

522

"""Find an client from its object path and remove it.

523

524

This is connected to the ClientRemoved signal from the

525

Mandos server object."""

526

try:

527

client = self.clients_dict[path]

528

except KeyError:

529

# not found?

530

return

531

self.remove_client(client, path)

532

533

def add_new_client(self, path):

534

client_proxy_object = self.bus.get_object(self.busname, path)

535

self.add_client(MandosClientWidget(server_proxy_object

536

=self.mandos_serv,

537

proxy_object

538

=client_proxy_object,

539

update_hook

540

=self.refresh,

541

delete_hook

542

=self.remove_client,

543

logger

544

=self.log_message),

545

path=path)

546

547

def add_client(self, client, path=None):

548

self.clients.append(client)

549

if path is None:

550

path = client.proxy.object_path

551

self.clients_dict[path] = client

552

self.clients.sort(None, lambda c: c.properties[u"Name"])

553

self.refresh()

554

555

def remove_client(self, client, path=None):

556

self.clients.remove(client)

557

if path is None:

558

path = client.proxy.object_path

559

del self.clients_dict[path]

560

if not self.clients_dict:

561

# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker

562

# is completely emptied, we need to recreate it.

563

self.clients = urwid.SimpleListWalker([])

564

self.rebuild()

565

self.refresh()

566

567

def refresh(self):

568

"""Redraw the screen"""

569

canvas = self.topwidget.render(self.size, focus=True)

570

self.screen.draw_screen(self.size, canvas)

571

572

def run(self):

573

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

574

self.refresh()

575

self._input_callback_tag = (gobject.io_add_watch

576

(sys.stdin.fileno(),

577

gobject.IO_IN,

578

self.process_input))

579

self.main_loop.run()

580

# Main loop has finished, we should close everything now

581

gobject.source_remove(self._input_callback_tag)

582

self.screen.stop()

583

584

def stop(self):

585

self.main_loop.quit()

586

587

def process_input(self, source, condition):

588

keys = self.screen.get_input()

589

translations = { u"ctrl n": u"down", # Emacs

590

u"ctrl p": u"up", # Emacs

591

u"ctrl v": u"page down", # Emacs

592

u"meta v": u"page up", # Emacs

593

u" ": u"page down", # less

594

u"f": u"page down", # less

595

u"b": u"page up", # less

596

u"j": u"down", # vi

597

u"k": u"up", # vi

598

}

599

for key in keys:

600

try:

601

key = translations[key]

602

except KeyError: # :-)

603

pass

604

605

if key == u"q" or key == u"Q":

606

self.stop()

607

break

608

elif key == u"window resize":

609

self.size = self.screen.get_cols_rows()

610

self.refresh()

611

elif key == u"\f": # Ctrl-L

612

self.refresh()

613

elif key == u"l" or key == u"D":

614

self.toggle_log_display()

615

self.refresh()

616

elif key == u"w" or key == u"i":

617

self.change_log_display()

618

self.refresh()

619

elif key == u"?" or key == u"f1" or key == u"esc":

620

if not self.log_visible:

621

self.log_visible = True

622

self.rebuild()

623

self.log_message_raw((u"bold",

624

u" ".

625

join((u"q: Quit",

626

u"?: Help",

627

u"l: Log window toggle",

628

u"TAB: Switch window",

629

u"w: Wrap (log)"))))

630

self.log_message_raw((u"bold",

631

u" "

632

.join((u"Clients:",

633

u"+: Enable",

634

u"-: Disable",

635

u"r: Remove",

636

u"s: Start new checker",

637

u"S: Stop checker",

638

u"C: Checker OK",

639

u"a: Approve",

640

u"d: Deny"))))

641

self.refresh()

642

elif key == u"tab":

643

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

644

self.topwidget.set_focus(0)

645

else:

646

self.topwidget.set_focus(self.logbox)

647

self.refresh()

648

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

649

# or key == u">"):

650

# pass # xxx end-of-buffer

651

#elif (key == u"home" or key == u"meta <" or key == u"g"

652

# or key == u"<"):

653

# pass # xxx beginning-of-buffer

654

#elif key == u"ctrl e" or key == u"$":

655

# pass # xxx move-end-of-line

656

#elif key == u"ctrl a" or key == u"^":

657

# pass # xxx move-beginning-of-line

658

#elif key == u"ctrl b" or key == u"meta (" or key == u"h":

659

# pass # xxx left

660

#elif key == u"ctrl f" or key == u"meta )" or key == u"l":

661

# pass # xxx right

662

#elif key == u"a":

663

# pass # scroll up log

664

#elif key == u"z":

665

# pass # scroll down log

666

elif self.topwidget.selectable():

667

self.topwidget.keypress(self.size, key)

668

self.refresh()

669

return True

670

671

ui = UserInterface()

672

try:

673

ui.run()

674

except KeyboardInterrupt:

675

ui.screen.stop()

676

except Exception, e:

677

ui.log_message(unicode(e))

678

ui.screen.stop()

679

raise