/mandos/trunk : revision 323

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

else:

329

return key

330

331

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

332

*args, **kwargs):

333

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

334

This overrides the method from MandosClientPropertyCache"""

335

property_name = unicode(property)

336

old_value = self.properties.get(property_name)

337

super(MandosClientWidget, self).property_changed(

338

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

339

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

340

self.update()

341

342

343

class ConstrainedListBox(urwid.ListBox):

344

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

345

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

346

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

347

"""

348

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

349

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

350

maxrow), key)

351

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

352

return

353

return ret

354

355

356

class UserInterface(object):

357

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

358

with boxes, lists of client widgets, etc.

359

"""

360

def __init__(self, max_log_length=1000):

361

DBusGMainLoop(set_as_default=True)

362

363

self.screen = urwid.curses_display.Screen()

364

365

self.screen.register_palette((

366

(u"normal",

367

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

368

(u"bold",

369

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

370

(u"underline-blink",

371

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

372

(u"standout",

373

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

374

(u"bold-underline-blink",

375

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

376

(u"bold-standout",

377

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

378

(u"underline-blink-standout",

379

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

380

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

381

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

382

u"standout")),

383

))

384

385

if urwid.supports_unicode():

386

self.divider = u"─" # \u2500

387

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

388

else:

389

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

390

self.divider = u"_" # \u005f

391

392

self.screen.start()

393

394

self.size = self.screen.get_cols_rows()

395

396

self.clients = urwid.SimpleListWalker([])

397

self.clients_dict = {}

398

399

# We will add Text widgets to this list

400

self.log = []

401

self.max_log_length = max_log_length

402

403

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

404

# from the ListWalker without it getting destroyed

405

self.logbox = ConstrainedListBox(self.log)

406

407

# This keeps track of whether self.uilist currently has

408

# self.logbox in it or not

409

self.log_visible = True

410

self.log_wrap = u"any"

411

412

self.rebuild()

413

self.log_message_raw((u"bold",

414

u"Mandos Monitor version " + version))

415

self.log_message_raw((u"bold",

416

u"q: Quit ?: Help"))

417

418

self.busname = domain + '.Mandos'

419

self.main_loop = gobject.MainLoop()

420

self.bus = dbus.SystemBus()

421

mandos_dbus_objc = self.bus.get_object(

422

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

423

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

424

dbus_interface

425

= server_interface)

426

try:

427

mandos_clients = (self.mandos_serv

428

.GetAllClientsWithProperties())

429

except dbus.exceptions.DBusException:

430

mandos_clients = dbus.Dictionary()

431

432

(self.mandos_serv

433

.connect_to_signal(u"ClientRemoved",

434

self.find_and_remove_client,

435

dbus_interface=server_interface,

436

byte_arrays=True))

437

(self.mandos_serv

438

.connect_to_signal(u"ClientAdded",

439

self.add_new_client,

440

dbus_interface=server_interface,

441

byte_arrays=True))

442

(self.mandos_serv

443

.connect_to_signal(u"ClientNotFound",

444

self.client_not_found,

445

dbus_interface=server_interface,

446

byte_arrays=True))

447

for path, client in mandos_clients.iteritems():

448

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

449

path)

450

self.add_client(MandosClientWidget(server_proxy_object

451

=self.mandos_serv,

452

proxy_object

453

=client_proxy_object,

454

properties=client,

455

update_hook

456

=self.refresh,

457

delete_hook

458

=self.remove_client,

459

logger

460

=self.log_message),

461

path=path)

462

463

def client_not_found(self, fingerprint, address):

464

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

465

u" could not be found" % (address,

466

fingerprint)))

467

468

def rebuild(self):

469

"""This rebuilds the User Interface.

470

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

471

self.uilist = []

472

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

473

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

474

clients),

475

#header=urwid.Divider(),

476

header=None,

477

footer=

478

urwid.Divider(div_char=

479

self.divider)))

480

if self.log_visible:

481

self.uilist.append(self.logbox)

482

pass

483

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

484

485

def log_message(self, message):

486

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

487

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

488

489

def log_message_raw(self, markup):

490

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

491

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

492

if (self.max_log_length

493

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

494

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

495

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

496

coming_from=u"above")

497

self.refresh()

498

499

def toggle_log_display(self):

500

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

501

self.log_visible = not self.log_visible

502

self.rebuild()

503

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

504

# + unicode(self.log_visible))

505

506

def change_log_display(self):

507

"""Change type of log display.

508

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

509

if self.log_wrap == u"clip":

510

self.log_wrap = u"any"

511

else:

512

self.log_wrap = u"clip"

513

for textwidget in self.log:

514

textwidget.set_wrap_mode(self.log_wrap)

515

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

516

517

def find_and_remove_client(self, path, name):

518

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

519

520

This is connected to the ClientRemoved signal from the

521

Mandos server object."""

522

try:

523

client = self.clients_dict[path]

524

except KeyError:

525

# not found?

526

return

527

self.remove_client(client, path)

528

529

def add_new_client(self, path):

530

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

531

self.add_client(MandosClientWidget(server_proxy_object

532

=self.mandos_serv,

533

proxy_object

534

=client_proxy_object,

535

update_hook

536

=self.refresh,

537

delete_hook

538

=self.remove_client,

539

logger

540

=self.log_message),

541

path=path)

542

543

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

544

self.clients.append(client)

545

if path is None:

546

path = client.proxy.object_path

547

self.clients_dict[path] = client

548

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

549

self.refresh()

550

551

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

552

self.clients.remove(client)

553

if path is None:

554

path = client.proxy.object_path

555

del self.clients_dict[path]

556

if not self.clients_dict:

557

# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker

558

# is completely emptied, we need to recreate it.

559

self.clients = urwid.SimpleListWalker([])

560

self.rebuild()

561

self.refresh()

562

563

def refresh(self):

564

"""Redraw the screen"""

565

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

566

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

567

568

def run(self):

569

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

570

self.refresh()

571

self._input_callback_tag = (gobject.io_add_watch

572

(sys.stdin.fileno(),

573

gobject.IO_IN,

574

self.process_input))

575

self.main_loop.run()

576

# Main loop has finished, we should close everything now

577

gobject.source_remove(self._input_callback_tag)

578

self.screen.stop()

579

580

def stop(self):

581

self.main_loop.quit()

582

583

def process_input(self, source, condition):

584

keys = self.screen.get_input()

585

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

586

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

587

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

588

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

589

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

590

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

591

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

592

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

593

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

594

}

595

for key in keys:

596

try:

597

key = translations[key]

598

except KeyError: # :-)

599

pass

600

601

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

602

self.stop()

603

break

604

elif key == u"window resize":

605

self.size = self.screen.get_cols_rows()

606

self.refresh()

607

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

608

self.refresh()

609

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

610

self.toggle_log_display()

611

self.refresh()

612

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

613

self.change_log_display()

614

self.refresh()

615

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

616

if not self.log_visible:

617

self.log_visible = True

618

self.rebuild()

619

self.log_message_raw((u"bold",

620

u" ".

621

join((u"q: Quit",

622

u"?: Help",

623

u"l: Log window toggle",

624

u"TAB: Switch window",

625

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

626

self.log_message_raw((u"bold",

627

u" "

628

.join((u"Clients:",

629

u"+: Enable",

630

u"-: Disable",

631

u"r: Remove",

632

u"s: Start new checker",

633

u"S: Stop checker",

634

u"C: Checker OK",

635

u"a: Approve",

636

u"d: Deny"))))

637

self.refresh()

638

elif key == u"tab":

639

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

640

self.topwidget.set_focus(0)

641

else:

642

self.topwidget.set_focus(self.logbox)

643

self.refresh()

644

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

645

# or key == u">"):

646

# pass # xxx end-of-buffer

647

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

648

# or key == u"<"):

649

# pass # xxx beginning-of-buffer

650

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

651

# pass # xxx move-end-of-line

652

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

653

# pass # xxx move-beginning-of-line

654

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

655

# pass # xxx left

656

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

657

# pass # xxx right

658

#elif key == u"a":

659

# pass # scroll up log

660

#elif key == u"z":

661

# pass # scroll down log

662

elif self.topwidget.selectable():

663

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

664

self.refresh()

665

return True

666

667

ui = UserInterface()

668

try:

669

ui.run()

670

except KeyboardInterrupt:

671

ui.screen.stop()

672

except Exception, e:

673

ui.log_message(unicode(e))

674

ui.screen.stop()

675

raise