/mandos/trunk : revision 404

4

from __future__ import division, absolute_import, with_statement

5

6

import sys

7

import os

8

7

import signal

9

8

10

import datetime

11

12

9

import urwid.curses_display

13

10

import urwid

14

11

19

16

20

17

import UserList

21

18

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

19

# Some useful constants

30

20

domain = 'se.bsnet.fukt'

31

21

server_interface = domain + '.Mandos'

32

22

client_interface = domain + '.Mandos.Client'

33

version = "1.0.15"

23

version = "1.0.14"

34

24

35

25

# Always run in monochrome mode

36

26

urwid.curses_display.curses.has_colors = lambda : False

45

35

properties and calls a hook function when any of them are

46

36

changed.

47

37

"""

48

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

38

def __init__(self, proxy_object=None, properties=None, *args,

39

**kwargs):

40

# Type conversion mapping

41

self.type_map = {

42

dbus.ObjectPath: unicode,

43

dbus.ByteArray: str,

44

dbus.Signature: unicode,

45

dbus.Byte: chr,

46

dbus.Int16: int,

47

dbus.UInt16: int,

48

dbus.Int32: int,

49

dbus.UInt32: int,

50

dbus.Int64: int,

51

dbus.UInt64: int,

52

dbus.Dictionary: dict,

53

dbus.Array: list,

54

dbus.String: unicode,

55

dbus.Boolean: bool,

56

dbus.Double: float,

57

dbus.Struct: tuple,

58

}

49

59

self.proxy = proxy_object # Mandos Client proxy object

50

60

51

self.properties = dict()

52

self.proxy.connect_to_signal(u"PropertyChanged",

61

if properties is None:

62

self.properties = dict()

63

else:

64

self.properties = dict(self.convert_property(prop, val)

65

for prop, val in

66

properties.iteritems())

67

self.proxy.connect_to_signal("PropertyChanged",

53

68

self.property_changed,

54

69

client_interface,

55

70

byte_arrays=True)

56

71

57

self.properties.update(

58

self.proxy.GetAll(client_interface,

59

dbus_interface = dbus.PROPERTIES_IFACE))

72

if properties is None:

73

self.properties.update(

74

self.convert_property(prop, val)

75

for prop, val in

76

self.proxy.GetAll(client_interface,

77

dbus_interface =

78

dbus.PROPERTIES_IFACE).iteritems())

60

79

super(MandosClientPropertyCache, self).__init__(

61

proxy_object=proxy_object, *args, **kwargs)

80

proxy_object=proxy_object,

81

properties=properties, *args, **kwargs)

62

82

83

def convert_property(self, property, value):

84

"""This converts the arguments from a D-Bus signal, which are

85

D-Bus types, into normal Python types, using a conversion

86

function from "self.type_map".

87

"""

88

property_name = unicode(property) # Always a dbus.String

89

if isinstance(value, dbus.UTF8String):

90

# Should not happen, but prepare for it anyway

91

value = dbus.String(str(value).decode("utf-8"))

92

try:

93

convfunc = self.type_map[type(value)]

94

except KeyError:

95

# Unknown type, return unmodified

96

return property_name, value

97

return property_name, convfunc(value)

63

98

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

64

99

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

65

100

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

66

101

"""

102

# Convert name and value

103

property_name, cvalue = self.convert_property(property, value)

67

104

# Update properties dict with new value

68

self.properties[property] = value

105

self.properties[property_name] = cvalue

69

106

70

107

71

108

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

73

110

"""

74

111

75

112

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

76

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

113

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

77

114

# Called on update

78

115

self.update_hook = update_hook

79

116

# Called on delete

80

117

self.delete_hook = delete_hook

81

118

# Mandos Server proxy object

82

119

self.server_proxy_object = server_proxy_object

83

# Logger

84

self.logger = logger

85

120

86

121

# The widget shown normally

87

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

122

self._text_widget = urwid.Text("")

88

123

# The widget shown when we have focus

89

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

124

self._focus_text_widget = urwid.Text("")

90

125

super(MandosClientWidget, self).__init__(

91

126

update_hook=update_hook, delete_hook=delete_hook,

92

127

*args, **kwargs)

93

128

self.update()

94

129

self.opened = False

95

self.proxy.connect_to_signal(u"CheckerCompleted",

96

self.checker_completed,

97

client_interface,

98

byte_arrays=True)

99

self.proxy.connect_to_signal(u"CheckerStarted",

100

self.checker_started,

101

client_interface,

102

byte_arrays=True)

103

self.proxy.connect_to_signal(u"GotSecret",

104

self.got_secret,

105

client_interface,

106

byte_arrays=True)

107

self.proxy.connect_to_signal(u"NeedApproval",

108

self.need_approval,

109

client_interface,

110

byte_arrays=True)

111

self.proxy.connect_to_signal(u"Rejected",

112

self.rejected,

113

client_interface,

114

byte_arrays=True)

115

116

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

117

if exitstatus == 0:

118

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

119

# u' was successful'

120

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

121

return

122

if os.WIFEXITED(condition):

123

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

124

u' failed with exit code %s'

125

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

126

os.WEXITSTATUS(condition)))

127

return

128

if os.WIFSIGNALED(condition):

129

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

130

u' was killed by signal %s'

131

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

132

os.WTERMSIG(condition)))

133

return

134

if os.WCOREDUMP(condition):

135

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

136

u' dumped core'

137

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

138

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

139

140

def checker_started(self, command):

141

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

142

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

143

pass

144

145

def got_secret(self):

146

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

147

% self.properties[u"name"])

148

149

def need_approval(self, timeout, default):

150

if not default:

151

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

152

else:

153

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

154

self.logger(message

155

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

156

157

def rejected(self, reason):

158

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

159

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

160

130

161

131

def selectable(self):

162

132

"""Make this a "selectable" widget.

186

156

}

187

157

188

158

# Rebuild focus and non-focus widgets using current properties

189

self._text = (u'%(name)s: %(enabled)s'

190

% { u"name": self.properties[u"name"],

191

u"enabled":

192

(u"enabled"

193

if self.properties[u"enabled"]

194

else u"DISABLED")})

159

self._text = (u'name="%(name)s", enabled=%(enabled)s'

160

% self.properties)

195

161

if not urwid.supports_unicode():

196

162

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

197

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

163

textlist = [(u"normal", u"BLÄRGH: "), (u"bold", self._text)]

198

164

self._text_widget.set_text(textlist)

199

165

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

200

166

text[1])

225

191

self.proxy.Enable()

226

192

elif key == u"d" or key == u"-":

227

193

self.proxy.Disable()

228

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

194

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

229

195

self.server_proxy_object.RemoveClient(self.proxy

230

196

.object_path)

231

197

elif key == u"s":

232

198

self.proxy.StartChecker()

199

elif key == u"c":

200

self.proxy.StopChecker()

233

201

elif key == u"S":

234

self.proxy.StopChecker()

235

elif key == u"C":

236

202

self.proxy.CheckedOK()

237

203

# xxx

238

204

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

241

207

# self.proxy.unpause()

242

208

# elif key == u"RET":

243

209

# self.open()

244

elif key == u"+":

245

self.proxy.Approve(True)

246

elif key == u"-":

247

self.proxy.Approve(False)

248

210

else:

249

211

return key

250

212

260

222

self.update()

261

223

262

224

263

class ConstrainedListBox(urwid.ListBox):

264

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

265

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

266

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

267

"""

268

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

269

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

270

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

271

return

272

return ret

273

274

275

225

class UserInterface(object):

276

226

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

277

227

with boxes, lists of client widgets, etc.

278

228

"""

279

def __init__(self, max_log_length=1000):

280

DBusGMainLoop(set_as_default=True)

229

def __init__(self):

230

DBusGMainLoop(set_as_default=True )

281

231

282

232

self.screen = urwid.curses_display.Screen()

283

233

301

251

u"standout")),

302

252

))

303

253

304

if urwid.supports_unicode():

305

self.divider = u"─" # \u2500

306

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

307

else:

308

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

309

self.divider = u"_" # \u005f

310

311

254

self.screen.start()

312

255

313

256

self.size = self.screen.get_cols_rows()

314

257

315

258

self.clients = urwid.SimpleListWalker([])

316

259

self.clients_dict = {}

317

318

# We will add Text widgets to this list

319

self.log = []

320

self.max_log_length = max_log_length

321

322

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

323

# from the ListWalker without it getting destroyed

324

self.logbox = ConstrainedListBox(self.log)

325

326

# This keeps track of whether self.uilist currently has

327

# self.logbox in it or not

328

self.log_visible = True

329

self.log_wrap = u"any"

330

331

self.rebuild()

332

self.log_message_raw((u"bold",

333

u"Mandos Monitor version " + version))

334

self.log_message_raw((u"bold",

335

u"q: Quit ?: Help"))

260

self.topwidget = urwid.LineBox(urwid.ListBox(self.clients))

261

#self.topwidget = urwid.ListBox(clients)

336

262

337

263

self.busname = domain + '.Mandos'

338

264

self.main_loop = gobject.MainLoop()

349

275

mandos_clients = dbus.Dictionary()

350

276

351

277

(self.mandos_serv

352

.connect_to_signal(u"ClientRemoved",

278

.connect_to_signal("ClientRemoved",

353

279

self.find_and_remove_client,

354

280

dbus_interface=server_interface,

355

281

byte_arrays=True))

356

282

(self.mandos_serv

357

.connect_to_signal(u"ClientAdded",

283

.connect_to_signal("ClientAdded",

358

284

self.add_new_client,

359

285

dbus_interface=server_interface,

360

286

byte_arrays=True))

361

(self.mandos_serv

362

.connect_to_signal(u"ClientNotFound",

363

self.client_not_found,

364

dbus_interface=server_interface,

365

byte_arrays=True))

366

for path, client in mandos_clients.iteritems():

287

for path, client in (mandos_clients.iteritems()):

367

288

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

368

289

path)

369

290

self.add_client(MandosClientWidget(server_proxy_object

374

295

update_hook

375

296

=self.refresh,

376

297

delete_hook

377

=self.remove_client,

378

logger

379

=self.log_message),

298

=self.remove_client),

380

299

path=path)

381

300

382

def client_not_found(self, fingerprint, address):

383

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

384

u" could not be found" % (address,

385

fingerprint)))

386

387

def rebuild(self):

388

"""This rebuilds the User Interface.

389

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

390

self.uilist = []

391

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

392

self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),

393

#header=urwid.Divider(),

394

header=None,

395

footer=urwid.Divider(div_char=self.divider)))

396

if self.log_visible:

397

self.uilist.append(self.logbox)

398

pass

399

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

400

401

def log_message(self, message):

402

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

403

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

404

405

def log_message_raw(self, markup):

406

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

407

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

408

if (self.max_log_length

409

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

410

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

411

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

412

coming_from=u"above")

413

self.refresh()

414

415

def toggle_log_display(self):

416

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

417

self.log_visible = not self.log_visible

418

self.rebuild()

419

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

420

+ unicode(self.log_visible))

421

422

def change_log_display(self):

423

"""Change type of log display.

424

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

425

if self.log_wrap == u"clip":

426

self.log_wrap = u"any"

427

else:

428

self.log_wrap = u"clip"

429

for textwidget in self.log:

430

textwidget.set_wrap_mode(self.log_wrap)

431

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

432

433

301

def find_and_remove_client(self, path, name):

434

302

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

435

303

442

310

return

443

311

self.remove_client(client, path)

444

312

445

def add_new_client(self, path):

313

def add_new_client(self, path, properties):

446

314

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

447

315

self.add_client(MandosClientWidget(server_proxy_object

448

316

=self.mandos_serv,

449

317

proxy_object

450

318

=client_proxy_object,

319

properties=properties,

451

320

update_hook

452

321

=self.refresh,

453

322

delete_hook

454

=self.remove_client,

455

logger

456

=self.log_message),

323

=self.remove_client),

457

324

path=path)

458

325

459

326

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

469

336

if path is None:

470

337

path = client.proxy.object_path

471

338

del self.clients_dict[path]

472

if not self.clients_dict:

473

# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker

474

# is completely emptied, we need to recreate it.

475

self.clients = urwid.SimpleListWalker([])

476

self.rebuild()

477

339

self.refresh()

478

340

479

341

def refresh(self):

498

360

499

361

def process_input(self, source, condition):

500

362

keys = self.screen.get_input()

501

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

502

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

503

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

504

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

505

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

506

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

507

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

508

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

509

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

363

translations = { u"j": u"down",

364

u"k": u"up",

510

365

}

511

366

for key in keys:

512

367

try:

520

375

elif key == u"window resize":

521

376

self.size = self.screen.get_cols_rows()

522

377

self.refresh()

523

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

524

self.refresh()

525

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

526

self.toggle_log_display()

527

self.refresh()

528

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

529

self.change_log_display()

530

self.refresh()

531

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

532

if not self.log_visible:

533

self.log_visible = True

534

self.rebuild()

535

self.log_message_raw((u"bold",

536

u" ".

537

join((u"q: Quit",

538

u"?: Help",

539

u"l: Log window toggle",

540

u"TAB: Switch window",

541

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

542

self.log_message_raw((u"bold",

543

u" "

544

.join((u"Clients:",

545

u"e: Enable",

546

u"d: Disable",

547

u"r: Remove",

548

u"s: Start new checker",

549

u"S: Stop checker",

550

u"C: Checker OK"))))

551

self.refresh()

552

elif key == u"tab":

553

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

554

self.topwidget.set_focus(0)

555

else:

556

self.topwidget.set_focus(self.logbox)

557

self.refresh()

558

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

559

# or key == u">"):

560

# pass # xxx end-of-buffer

561

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

562

# or key == u"<"):

563

# pass # xxx beginning-of-buffer

564

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

565

# pass # xxx move-end-of-line

566

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

567

# pass # xxx move-beginning-of-line

568

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

569

# pass # xxx left

570

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

571

# pass # xxx right

572

#elif key == u"a":

573

# pass # scroll up log

574

#elif key == u"z":

575

# pass # scroll down log

378

elif key == "":

379

self.refresh()

576

380

elif self.topwidget.selectable():

577

381

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

578

382

self.refresh()

581

385

ui = UserInterface()

582

386

try:

583

387

ui.run()

584

except Exception, e:

585

ui.log_message(unicode(e))

388

except:

586

389

ui.screen.stop()

587

390

raise