/mandos/trunk : revision 495

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

5

#

6

7

6

7

8

#

9

# This program is free software: you can redistribute it and/or modify

10

# it under the terms of the GNU General Public License as published by

22

# Contact the authors at <mandos@fukt.bsnet.se>.

23

#

24

25

from __future__ import division, absolute_import, with_statement

25

from __future__ import (division, absolute_import, print_function,

26

unicode_literals)

26

27

28

import sys

28

29

import os

42

43

44

import locale

44

45

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

46

locale.setlocale(locale.LC_ALL, '')

46

47

48

import logging

48

49

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

51

52

domain = 'se.bsnet.fukt'

52

53

server_interface = domain + '.Mandos'

53

54

client_interface = domain + '.Mandos.Client'

54

version = "1.0.15"

55

version = "1.3.1"

55

56

57

# Always run in monochrome mode

57

58

urwid.curses_display.curses.has_colors = lambda : False

65

66

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

66

67

if not iso:

67

68

return None

68

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

69

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

70

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

69

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

70

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

71

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

71

72

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

72

73

return datetime.datetime(int(year),

73

74

int(month),

86

87

self.proxy = proxy_object # Mandos Client proxy object

87

88

89

self.properties = dict()

89

self.proxy.connect_to_signal(u"PropertyChanged",

90

self.property_changed,

91

client_interface,

92

byte_arrays=True)

90

self.property_changed_match = (

91

self.proxy.connect_to_signal("PropertyChanged",

92

self.property_changed,

93

client_interface,

94

byte_arrays=True))

93

95

94

96

self.properties.update(

95

97

self.proxy.GetAll(client_interface,

96

98

dbus_interface = dbus.PROPERTIES_IFACE))

97

99

98

#XXX This break good super behaviour!

100

#XXX This breaks good super behaviour

99

101

# super(MandosClientPropertyCache, self).__init__(

100

102

# *args, **kwargs)

101

103

105

107

"""

106

108

# Update properties dict with new value

107

109

self.properties[property] = value

110

111

def delete(self, *args, **kwargs):

112

self.property_changed_match.remove()

113

super(MandosClientPropertyCache, self).__init__(

114

*args, **kwargs)

108

115

109

116

110

117

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

127

134

self.last_checker_failed = False

128

135

129

136

# The widget shown normally

130

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

137

self._text_widget = urwid.Text("")

131

138

# The widget shown when we have focus

132

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

139

self._focus_text_widget = urwid.Text("")

133

140

super(MandosClientWidget, self).__init__(

134

141

update_hook=update_hook, delete_hook=delete_hook,

135

142

*args, **kwargs)

137

144

self.opened = False

138

145

139

146

last_checked_ok = isoformat_to_datetime(self.properties

140

[u"LastCheckedOK"])

147

["LastCheckedOK"])

141

148

if last_checked_ok is None:

142

149

self.last_checker_failed = True

143

150

else:

146

153

> datetime.timedelta

147

154

(milliseconds=

148

155

self.properties

149

[u"Interval"]))

156

["Interval"]))

150

157

151

158

if self.last_checker_failed:

152

159

self.using_timer(True)

154

161

if self.need_approval:

155

162

self.using_timer(True)

156

163

157

self.proxy.connect_to_signal(u"CheckerCompleted",

158

self.checker_completed,

159

client_interface,

160

byte_arrays=True)

161

self.proxy.connect_to_signal(u"CheckerStarted",

162

self.checker_started,

163

client_interface,

164

byte_arrays=True)

165

self.proxy.connect_to_signal(u"GotSecret",

166

self.got_secret,

167

client_interface,

168

byte_arrays=True)

169

self.proxy.connect_to_signal(u"NeedApproval",

170

self.need_approval,

171

client_interface,

172

byte_arrays=True)

173

self.proxy.connect_to_signal(u"Rejected",

174

self.rejected,

175

client_interface,

176

byte_arrays=True)

164

self.match_objects = (

165

self.proxy.connect_to_signal("CheckerCompleted",

166

self.checker_completed,

167

client_interface,

168

byte_arrays=True),

169

self.proxy.connect_to_signal("CheckerStarted",

170

self.checker_started,

171

client_interface,

172

byte_arrays=True),

173

self.proxy.connect_to_signal("GotSecret",

174

self.got_secret,

175

client_interface,

176

byte_arrays=True),

177

self.proxy.connect_to_signal("NeedApproval",

178

self.need_approval,

179

client_interface,

180

byte_arrays=True),

181

self.proxy.connect_to_signal("Rejected",

182

self.rejected,

183

client_interface,

184

byte_arrays=True))

185

#self.logger('Created client %s' % (self.properties["Name"]))

177

186

178

187

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

179

188

super(self, MandosClientWidget).property_changed(property,

180

189

value)

181

if property == u"ApprovalPending":

190

if property == "ApprovalPending":

182

191

using_timer(bool(value))

183

192

184

193

def using_timer(self, flag):

203

212

if self.last_checker_failed:

204

213

self.last_checker_failed = False

205

214

self.using_timer(False)

206

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

207

# u' was successful'

208

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

215

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

216

# ' was successful'

217

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

209

218

self.update()

210

219

return

211

220

# Checker failed

213

222

self.last_checker_failed = True

214

223

self.using_timer(True)

215

224

if os.WIFEXITED(condition):

216

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

217

u' failed with exit code %s'

218

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

225

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

226

' failed with exit code %s'

227

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

219

228

os.WEXITSTATUS(condition)))

220

229

elif os.WIFSIGNALED(condition):

221

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

222

u' was killed by signal %s'

223

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

230

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

231

' was killed by signal %s'

232

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

224

233

os.WTERMSIG(condition)))

225

234

elif os.WCOREDUMP(condition):

226

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

227

u' dumped core'

228

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

235

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

236

' dumped core'

237

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

229

238

else:

230

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

231

u' mysteriously')

239

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

240

' mysteriously')

232

241

self.update()

233

242

234

243

def checker_started(self, command):

235

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

236

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

244

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

245

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

237

246

pass

238

247

239

248

def got_secret(self):

240

249

self.last_checker_failed = False

241

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

242

% self.properties[u"Name"])

250

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

251

% self.properties["Name"])

243

252

244

253

def need_approval(self, timeout, default):

245

254

if not default:

246

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

255

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

247

256

else:

248

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

257

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

249

258

self.logger(message

250

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

259

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

251

260

self.using_timer(True)

252

261

253

262

def rejected(self, reason):

254

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

255

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

263

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

264

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

256

265

257

266

def selectable(self):

258

267

"""Make this a "selectable" widget.

259

268

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

260

269

return True

261

270

262

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

271

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

263

272

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

264

273

whether we have focus or not.

265

274

This overrides the method from urwid.FlowWidget"""

266

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

275

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

267

276

268

277

def current_widget(self, focus=False):

269

278

if focus or self.opened:

273

282

def update(self):

274

283

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

275

284

# How to add standout mode to a style

276

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

277

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

278

u"underline-blink":

279

u"underline-blink-standout",

280

u"bold-underline-blink":

281

u"bold-underline-blink-standout",

285

with_standout = { "normal": "standout",

286

"bold": "bold-standout",

287

"underline-blink":

288

"underline-blink-standout",

289

"bold-underline-blink":

290

"bold-underline-blink-standout",

282

291

}

283

292

284

293

# Rebuild focus and non-focus widgets using current properties

285

294

286

295

# Base part of a client. Name!

287

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

288

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

289

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

290

message = u"DISABLED"

291

elif self.properties[u"ApprovalPending"]:

296

base = ('%(name)s: '

297

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

298

if not self.properties["Enabled"]:

299

message = "DISABLED"

300

elif self.properties["ApprovalPending"]:

292

301

timeout = datetime.timedelta(milliseconds

293

302

= self.properties

294

[u"ApprovalDelay"])

303

["ApprovalDelay"])

295

304

last_approval_request = isoformat_to_datetime(

296

self.properties[u"LastApprovalRequest"])

305

self.properties["LastApprovalRequest"])

297

306

if last_approval_request is not None:

298

307

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

299

308

- last_approval_request)

300

309

else:

301

310

timer = datetime.timedelta()

302

if self.properties[u"ApprovedByDefault"]:

303

message = u"Approval in %s. (d)eny?"

311

if self.properties["ApprovedByDefault"]:

312

message = "Approval in %s. (d)eny?"

304

313

else:

305

message = u"Denial in %s. (a)pprove?"

314

message = "Denial in %s. (a)pprove?"

306

315

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

307

316

elif self.last_checker_failed:

308

317

timeout = datetime.timedelta(milliseconds

309

318

= self.properties

310

[u"Timeout"])

319

["Timeout"])

311

320

last_ok = isoformat_to_datetime(

312

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

313

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

314

self.properties[u"LastEnabled"]))

321

max((self.properties["LastCheckedOK"]

322

or self.properties["Created"]),

323

self.properties["LastEnabled"]))

315

324

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

316

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

317

u' gets disabled: %s'

325

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

326

' gets disabled: %s'

318

327

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

319

328

else:

320

message = u"enabled"

329

message = "enabled"

321

330

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

322

331

323

332

if not urwid.supports_unicode():

324

333

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

325

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

334

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

326

335

self._text_widget.set_text(textlist)

327

336

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

328

337

text[1])

341

350

self.update()

342

351

return True # Keep calling this

343

352

344

def delete(self):

353

def delete(self, *args, **kwargs):

345

354

if self._update_timer_callback_tag is not None:

346

355

gobject.source_remove(self._update_timer_callback_tag)

347

356

self._update_timer_callback_tag = None

357

for match in self.match_objects:

358

match.remove()

359

self.match_objects = ()

348

360

if self.delete_hook is not None:

349

361

self.delete_hook(self)

362

return super(MandosClientWidget, self).delete(*args, **kwargs)

350

363

351

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

364

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

352

365

"""Render differently if we have focus.

353

366

This overrides the method from urwid.FlowWidget"""

354

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

367

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

355

368

focus=focus)

356

369

357

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

370

def keypress(self, maxcolrow, key):

358

371

"""Handle keys.

359

372

This overrides the method from urwid.FlowWidget"""

360

if key == u"+":

361

self.proxy.Enable(dbus_interface = client_interface)

362

elif key == u"-":

363

self.proxy.Disable(dbus_interface = client_interface)

364

elif key == u"a":

373

if key == "+":

374

self.proxy.Enable(dbus_interface = client_interface,

375

ignore_reply=True)

376

elif key == "-":

377

self.proxy.Disable(dbus_interface = client_interface,

378

ignore_reply=True)

379

elif key == "a":

365

380

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

366

dbus_interface = client_interface)

367

elif key == u"d":

381

dbus_interface = client_interface,

382

ignore_reply=True)

383

elif key == "d":

368

384

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

369

dbus_interface = client_interface)

370

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

385

dbus_interface = client_interface,

386

ignore_reply=True)

387

elif key == "R" or key == "_" or key == "ctrl k":

371

388

self.server_proxy_object.RemoveClient(self.proxy

372

.object_path)

373

elif key == u"s":

374

self.proxy.StartChecker(dbus_interface = client_interface)

375

elif key == u"S":

376

self.proxy.StopChecker(dbus_interface = client_interface)

377

elif key == u"C":

378

self.proxy.CheckedOK(dbus_interface = client_interface)

389

.object_path,

390

ignore_reply=True)

391

elif key == "s":

392

self.proxy.StartChecker(dbus_interface = client_interface,

393

ignore_reply=True)

394

elif key == "S":

395

self.proxy.StopChecker(dbus_interface = client_interface,

396

ignore_reply=True)

397

elif key == "C":

398

self.proxy.CheckedOK(dbus_interface = client_interface,

399

ignore_reply=True)

379

400

# xxx

380

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

401

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

381

402

# self.proxy.pause()

382

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

403

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

383

404

# self.proxy.unpause()

384

# elif key == u"RET":

405

# elif key == "RET":

385

406

# self.open()

386

407

else:

387

408

return key

403

424

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

404

425

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

405

426

"""

406

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

407

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

408

maxrow), key)

409

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

427

def keypress(self, maxcolrow, key):

428

ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)

429

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

410

430

return

411

431

return ret

412

432

421

441

self.screen = urwid.curses_display.Screen()

422

442

423

443

self.screen.register_palette((

424

(u"normal",

425

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

426

(u"bold",

427

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

428

(u"underline-blink",

429

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

430

(u"standout",

431

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

432

(u"bold-underline-blink",

433

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

434

(u"bold-standout",

435

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

436

(u"underline-blink-standout",

437

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

438

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

439

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

440

u"standout")),

444

("normal",

445

"default", "default", None),

446

("bold",

447

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

448

("underline-blink",

449

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

450

("standout",

451

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

452

("bold-underline-blink",

453

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

454

("bold-standout",

455

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

456

("underline-blink-standout",

457

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

458

("bold-underline-blink-standout",

459

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

460

"standout")),

441

461

))

442

462

443

463

if urwid.supports_unicode():

444

self.divider = u"─" # \u2500

445

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

464

self.divider = "─" # \u2500

465

#self.divider = "━" # \u2501

446

466

else:

447

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

448

self.divider = u"_" # \u005f

467

#self.divider = "-" # \u002d

468

self.divider = "_" # \u005f

449

469

450

470

self.screen.start()

451

471

465

485

# This keeps track of whether self.uilist currently has

466

486

# self.logbox in it or not

467

487

self.log_visible = True

468

self.log_wrap = u"any"

488

self.log_wrap = "any"

469

489

470

490

self.rebuild()

471

self.log_message_raw((u"bold",

472

u"Mandos Monitor version " + version))

473

self.log_message_raw((u"bold",

474

u"q: Quit ?: Help"))

491

self.log_message_raw(("bold",

492

"Mandos Monitor version " + version))

493

self.log_message_raw(("bold",

494

"q: Quit ?: Help"))

475

495

476

496

self.busname = domain + '.Mandos'

477

497

self.main_loop = gobject.MainLoop()

478

498

self.bus = dbus.SystemBus()

479

499

mandos_dbus_objc = self.bus.get_object(

480

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

500

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

481

501

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

482

502

dbus_interface

483

503

= server_interface)

488

508

mandos_clients = dbus.Dictionary()

489

509

490

510

(self.mandos_serv

491

.connect_to_signal(u"ClientRemoved",

511

.connect_to_signal("ClientRemoved",

492

512

self.find_and_remove_client,

493

513

dbus_interface=server_interface,

494

514

byte_arrays=True))

495

515

(self.mandos_serv

496

.connect_to_signal(u"ClientAdded",

516

.connect_to_signal("ClientAdded",

497

517

self.add_new_client,

498

518

dbus_interface=server_interface,

499

519

byte_arrays=True))

500

520

(self.mandos_serv

501

.connect_to_signal(u"ClientNotFound",

521

.connect_to_signal("ClientNotFound",

502

522

self.client_not_found,

503

523

dbus_interface=server_interface,

504

524

byte_arrays=True))

519

539

path=path)

520

540

521

541

def client_not_found(self, fingerprint, address):

522

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

523

u" could not be found" % (address,

542

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

543

" could not be found" % (address,

524

544

fingerprint)))

525

545

526

546

def rebuild(self):

542

562

543

563

def log_message(self, message):

544

564

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

545

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

565

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

546

566

547

567

def log_message_raw(self, markup):

548

568

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

551

571

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

552

572

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

553

573

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

554

coming_from=u"above")

574

coming_from="above")

555

575

self.refresh()

556

576

557

577

def toggle_log_display(self):

558

578

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

559

579

self.log_visible = not self.log_visible

560

580

self.rebuild()

561

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

581

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

562

582

# + unicode(self.log_visible))

563

583

564

584

def change_log_display(self):

565

585

"""Change type of log display.

566

586

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

567

if self.log_wrap == u"clip":

568

self.log_wrap = u"any"

587

if self.log_wrap == "clip":

588

self.log_wrap = "any"

569

589

else:

570

self.log_wrap = u"clip"

590

self.log_wrap = "clip"

571

591

for textwidget in self.log:

572

592

textwidget.set_wrap_mode(self.log_wrap)

573

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

593

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

574

594

575

595

def find_and_remove_client(self, path, name):

576

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

596

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

577

597

578

598

This is connected to the ClientRemoved signal from the

579

599

Mandos server object."""

581

601

client = self.clients_dict[path]

582

602

except KeyError:

583

603

# not found?

604

self.log_message("Unknown client %r (%r) removed", name,

605

path)

584

606

return

585

self.remove_client(client, path)

607

client.delete()

586

608

587

609

def add_new_client(self, path):

588

610

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

603

625

if path is None:

604

626

path = client.proxy.object_path

605

627

self.clients_dict[path] = client

606

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

628

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

607

629

self.refresh()

608

630

609

631

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

640

662

641

663

def process_input(self, source, condition):

642

664

keys = self.screen.get_input()

643

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

644

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

645

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

646

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

647

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

648

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

649

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

650

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

651

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

665

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

666

"ctrl p": "up", # Emacs

667

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

668

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

669

" ": "page down", # less

670

"f": "page down", # less

671

"b": "page up", # less

672

"j": "down", # vi

673

"k": "up", # vi

652

674

}

653

675

for key in keys:

654

676

try:

656

678

except KeyError: # :-)

657

679

pass

658

680

659

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

681

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

660

682

self.stop()

661

683

break

662

elif key == u"window resize":

684

elif key == "window resize":

663

685

self.size = self.screen.get_cols_rows()

664

686

self.refresh()

665

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

687

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

666

688

self.refresh()

667

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

689

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

668

690

self.toggle_log_display()

669

691

self.refresh()

670

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

692

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

671

693

self.change_log_display()

672

694

self.refresh()

673

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

695

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

674

696

if not self.log_visible:

675

697

self.log_visible = True

676

698

self.rebuild()

677

self.log_message_raw((u"bold",

678

u" ".

679

join((u"q: Quit",

680

u"?: Help",

681

u"l: Log window toggle",

682

u"TAB: Switch window",

683

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

684

self.log_message_raw((u"bold",

685

u" "

686

.join((u"Clients:",

687

u"+: Enable",

688

u"-: Disable",

689

u"R: Remove",

690

u"s: Start new checker",

691

u"S: Stop checker",

692

u"C: Checker OK",

693

u"a: Approve",

694

u"d: Deny"))))

699

self.log_message_raw(("bold",

700

" ".

701

join(("q: Quit",

702

"?: Help",

703

"l: Log window toggle",

704

"TAB: Switch window",

705

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

706

self.log_message_raw(("bold",

707

" "

708

.join(("Clients:",

709

"+: Enable",

710

"-: Disable",

711

"R: Remove",

712

"s: Start new checker",

713

"S: Stop checker",

714

"C: Checker OK",

715

"a: Approve",

716

"d: Deny"))))

695

717

self.refresh()

696

elif key == u"tab":

718

elif key == "tab":

697

719

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

698

720

self.topwidget.set_focus(0)

699

721

else:

700

722

self.topwidget.set_focus(self.logbox)

701

723

self.refresh()

702

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

703

# or key == u">"):

724

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

725

# or key == ">"):

704

726

# pass # xxx end-of-buffer

705

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

706

# or key == u"<"):

727

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

728

# or key == "<"):

707

729

# pass # xxx beginning-of-buffer

708

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

730

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

709

731

# pass # xxx move-end-of-line

710

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

732

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

711

733

# pass # xxx move-beginning-of-line

712

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

734

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

713

735

# pass # xxx left

714

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

736

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

715

737

# pass # xxx right

716

#elif key == u"a":

738

#elif key == "a":

717

739

# pass # scroll up log

718

#elif key == u"z":

740

#elif key == "z":

719

741

# pass # scroll down log

720

742

elif self.topwidget.selectable():

721

743

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