/mandos/trunk : revision 452

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, print_function,

26

unicode_literals)

25

from __future__ import division, absolute_import, with_statement

27

26

28

27

import sys

29

28

import os

43

42

44

43

import locale

45

44

46

locale.setlocale(locale.LC_ALL, '')

45

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

47

46

48

47

import logging

49

48

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

52

51

domain = 'se.bsnet.fukt'

53

52

server_interface = domain + '.Mandos'

54

53

client_interface = domain + '.Mandos.Client'

55

version = "1.3.1"

54

version = "1.2"

56

55

57

56

# Always run in monochrome mode

58

57

urwid.curses_display.curses.has_colors = lambda : False

66

65

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

67

66

if not iso:

68

67

return None

69

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

70

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

71

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

68

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

69

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

70

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

72

71

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

73

72

return datetime.datetime(int(year),

74

73

int(month),

87

86

self.proxy = proxy_object # Mandos Client proxy object

88

87

89

88

self.properties = dict()

90

self.property_changed_match = (

91

self.proxy.connect_to_signal("PropertyChanged",

92

self.property_changed,

93

client_interface,

94

byte_arrays=True))

89

self.proxy.connect_to_signal(u"PropertyChanged",

90

self.property_changed,

91

client_interface,

92

byte_arrays=True)

95

93

96

94

self.properties.update(

97

95

self.proxy.GetAll(client_interface,

98

96

dbus_interface = dbus.PROPERTIES_IFACE))

99

97

100

#XXX This breaks good super behaviour

98

#XXX This break good super behaviour!

101

99

# super(MandosClientPropertyCache, self).__init__(

102

100

# *args, **kwargs)

103

101

107

105

"""

108

106

# Update properties dict with new value

109

107

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)

115

108

116

109

117

110

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

134

127

self.last_checker_failed = False

135

128

136

129

# The widget shown normally

137

self._text_widget = urwid.Text("")

130

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

138

131

# The widget shown when we have focus

139

self._focus_text_widget = urwid.Text("")

132

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

140

133

super(MandosClientWidget, self).__init__(

141

134

update_hook=update_hook, delete_hook=delete_hook,

142

135

*args, **kwargs)

144

137

self.opened = False

145

138

146

139

last_checked_ok = isoformat_to_datetime(self.properties

147

["LastCheckedOK"])

140

[u"LastCheckedOK"])

148

141

if last_checked_ok is None:

149

142

self.last_checker_failed = True

150

143

else:

153

146

> datetime.timedelta

154

147

(milliseconds=

155

148

self.properties

156

["Interval"]))

149

[u"Interval"]))

157

150

158

151

if self.last_checker_failed:

159

152

self.using_timer(True)

161

154

if self.need_approval:

162

155

self.using_timer(True)

163

156

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

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)

186

177

187

178

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

188

179

super(self, MandosClientWidget).property_changed(property,

189

180

value)

190

if property == "ApprovalPending":

181

if property == u"ApprovalPending":

191

182

using_timer(bool(value))

192

183

193

184

def using_timer(self, flag):

200

191

else:

201

192

self._update_timer_callback_lock -= 1

202

193

if old == 0 and self._update_timer_callback_lock:

203

# Will update the shown timer value every second

204

194

self._update_timer_callback_tag = (gobject.timeout_add

205

195

(1000,

206

196

self.update_timer))

213

203

if self.last_checker_failed:

214

204

self.last_checker_failed = False

215

205

self.using_timer(False)

216

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

217

# ' was successful'

218

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

206

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

207

# u' was successful'

208

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

219

209

self.update()

220

210

return

221

211

# Checker failed

223

213

self.last_checker_failed = True

224

214

self.using_timer(True)

225

215

if os.WIFEXITED(condition):

226

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

227

' failed with exit code %s'

228

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

216

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

217

u' failed with exit code %s'

218

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

229

219

os.WEXITSTATUS(condition)))

230

220

elif os.WIFSIGNALED(condition):

231

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

232

' was killed by signal %s'

233

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

221

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

222

u' was killed by signal %s'

223

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

234

224

os.WTERMSIG(condition)))

235

225

elif os.WCOREDUMP(condition):

236

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

237

' dumped core'

238

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

226

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

227

u' dumped core'

228

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

239

229

else:

240

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

241

' mysteriously')

230

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

231

u' mysteriously')

242

232

self.update()

243

233

244

234

def checker_started(self, command):

245

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

246

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

235

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

236

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

247

237

pass

248

238

249

239

def got_secret(self):

250

240

self.last_checker_failed = False

251

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

252

% self.properties["Name"])

241

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

242

% self.properties[u"Name"])

253

243

254

244

def need_approval(self, timeout, default):

255

245

if not default:

256

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

246

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

257

247

else:

258

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

248

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

259

249

self.logger(message

260

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

250

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

261

251

self.using_timer(True)

262

252

263

253

def rejected(self, reason):

264

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

265

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

254

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

255

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

266

256

267

257

def selectable(self):

268

258

"""Make this a "selectable" widget.

269

259

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

270

260

return True

271

261

272

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

262

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

273

263

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

274

264

whether we have focus or not.

275

265

This overrides the method from urwid.FlowWidget"""

276

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

266

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

277

267

278

268

def current_widget(self, focus=False):

279

269

if focus or self.opened:

283

273

def update(self):

284

274

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

285

275

# How to add standout mode to a style

286

with_standout = { "normal": "standout",

287

"bold": "bold-standout",

288

"underline-blink":

289

"underline-blink-standout",

290

"bold-underline-blink":

291

"bold-underline-blink-standout",

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

292

282

}

293

283

294

284

# Rebuild focus and non-focus widgets using current properties

295

285

296

286

# Base part of a client. Name!

297

base = ('%(name)s: '

298

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

299

if not self.properties["Enabled"]:

300

message = "DISABLED"

301

elif self.properties["ApprovalPending"]:

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"]:

302

292

timeout = datetime.timedelta(milliseconds

303

293

= self.properties

304

["ApprovalDelay"])

294

[u"ApprovalDelay"])

305

295

last_approval_request = isoformat_to_datetime(

306

self.properties["LastApprovalRequest"])

296

self.properties[u"LastApprovalRequest"])

307

297

if last_approval_request is not None:

308

298

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

309

299

- last_approval_request)

310

300

else:

311

301

timer = datetime.timedelta()

312

if self.properties["ApprovedByDefault"]:

313

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

302

if self.properties[u"ApprovedByDefault"]:

303

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

314

304

else:

315

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

305

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

316

306

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

317

307

elif self.last_checker_failed:

318

# When checker has failed, print a timer until client expires

319

expires = self.properties["Expires"]

320

if expires == "":

321

timer = datetime.timedelta(0)

322

else:

323

expires = datetime.datetime.strptime(expires,

324

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

325

timer = expires - datetime.datetime.utcnow()

326

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

327

' gets disabled: %s'

308

timeout = datetime.timedelta(milliseconds

309

= self.properties

310

[u"Timeout"])

311

last_ok = isoformat_to_datetime(

312

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

313

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

314

self.properties[u"LastEnabled"]))

315

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

316

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

317

u' gets disabled: %s'

328

318

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

329

319

else:

330

message = "enabled"

320

message = u"enabled"

331

321

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

332

322

333

323

if not urwid.supports_unicode():

334

324

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

335

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

325

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

336

326

self._text_widget.set_text(textlist)

337

327

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

338

328

text[1])

347

337

self.update_hook()

348

338

349

339

def update_timer(self):

350

"""called by gobject. Will indefinitely loop until

351

gobject.source_remove() on tag is called"""

340

"called by gobject"

352

341

self.update()

353

342

return True # Keep calling this

354

343

355

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

344

def delete(self):

356

345

if self._update_timer_callback_tag is not None:

357

346

gobject.source_remove(self._update_timer_callback_tag)

358

347

self._update_timer_callback_tag = None

359

for match in self.match_objects:

360

match.remove()

361

self.match_objects = ()

362

348

if self.delete_hook is not None:

363

349

self.delete_hook(self)

364

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

365

350

366

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

351

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

367

352

"""Render differently if we have focus.

368

353

This overrides the method from urwid.FlowWidget"""

369

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

354

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

370

355

focus=focus)

371

356

372

def keypress(self, maxcolrow, key):

357

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

373

358

"""Handle keys.

374

359

This overrides the method from urwid.FlowWidget"""

375

if key == "+":

376

self.proxy.Enable(dbus_interface = client_interface,

377

ignore_reply=True)

378

elif key == "-":

379

self.proxy.Disable(dbus_interface = client_interface,

380

ignore_reply=True)

381

elif key == "a":

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

382

365

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

383

dbus_interface = client_interface,

384

ignore_reply=True)

385

elif key == "d":

366

dbus_interface = client_interface)

367

elif key == u"d":

386

368

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

387

dbus_interface = client_interface,

388

ignore_reply=True)

389

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

369

dbus_interface = client_interface)

370

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

390

371

self.server_proxy_object.RemoveClient(self.proxy

391

.object_path,

392

ignore_reply=True)

393

elif key == "s":

394

self.proxy.StartChecker(dbus_interface = client_interface,

395

ignore_reply=True)

396

elif key == "S":

397

self.proxy.StopChecker(dbus_interface = client_interface,

398

ignore_reply=True)

399

elif key == "C":

400

self.proxy.CheckedOK(dbus_interface = client_interface,

401

ignore_reply=True)

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)

402

379

# xxx

403

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

380

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

404

381

# self.proxy.pause()

405

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

382

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

406

383

# self.proxy.unpause()

407

# elif key == "RET":

384

# elif key == u"RET":

408

385

# self.open()

409

386

else:

410

387

return key

426

403

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

427

404

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

428

405

"""

429

def keypress(self, maxcolrow, key):

430

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

431

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

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

432

410

return

433

411

return ret

434

412

443

421

self.screen = urwid.curses_display.Screen()

444

422

445

423

self.screen.register_palette((

446

("normal",

447

"default", "default", None),

448

("bold",

449

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

450

("underline-blink",

451

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

452

("standout",

453

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

454

("bold-underline-blink",

455

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

456

("bold-standout",

457

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

458

("underline-blink-standout",

459

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

460

("bold-underline-blink-standout",

461

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

462

"standout")),

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

463

441

))

464

442

465

443

if urwid.supports_unicode():

466

self.divider = "─" # \u2500

467

#self.divider = "━" # \u2501

444

self.divider = u"─" # \u2500

445

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

468

446

else:

469

#self.divider = "-" # \u002d

470

self.divider = "_" # \u005f

447

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

448

self.divider = u"_" # \u005f

471

449

472

450

self.screen.start()

473

451

487

465

# This keeps track of whether self.uilist currently has

488

466

# self.logbox in it or not

489

467

self.log_visible = True

490

self.log_wrap = "any"

468

self.log_wrap = u"any"

491

469

492

470

self.rebuild()

493

self.log_message_raw(("bold",

494

"Mandos Monitor version " + version))

495

self.log_message_raw(("bold",

496

"q: Quit ?: Help"))

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

497

475

498

476

self.busname = domain + '.Mandos'

499

477

self.main_loop = gobject.MainLoop()

500

478

self.bus = dbus.SystemBus()

501

479

mandos_dbus_objc = self.bus.get_object(

502

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

480

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

503

481

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

504

482

dbus_interface

505

483

= server_interface)

510

488

mandos_clients = dbus.Dictionary()

511

489

512

490

(self.mandos_serv

513

.connect_to_signal("ClientRemoved",

491

.connect_to_signal(u"ClientRemoved",

514

492

self.find_and_remove_client,

515

493

dbus_interface=server_interface,

516

494

byte_arrays=True))

517

495

(self.mandos_serv

518

.connect_to_signal("ClientAdded",

496

.connect_to_signal(u"ClientAdded",

519

497

self.add_new_client,

520

498

dbus_interface=server_interface,

521

499

byte_arrays=True))

522

500

(self.mandos_serv

523

.connect_to_signal("ClientNotFound",

501

.connect_to_signal(u"ClientNotFound",

524

502

self.client_not_found,

525

503

dbus_interface=server_interface,

526

504

byte_arrays=True))

541

519

path=path)

542

520

543

521

def client_not_found(self, fingerprint, address):

544

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

545

" could not be found" % (address,

522

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

523

u" could not be found" % (address,

546

524

fingerprint)))

547

525

548

526

def rebuild(self):

564

542

565

543

def log_message(self, message):

566

544

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

567

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

545

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

568

546

569

547

def log_message_raw(self, markup):

570

548

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

573

551

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

574

552

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

575

553

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

576

coming_from="above")

554

coming_from=u"above")

577

555

self.refresh()

578

556

579

557

def toggle_log_display(self):

580

558

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

581

559

self.log_visible = not self.log_visible

582

560

self.rebuild()

583

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

561

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

584

562

# + unicode(self.log_visible))

585

563

586

564

def change_log_display(self):

587

565

"""Change type of log display.

588

566

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

589

if self.log_wrap == "clip":

590

self.log_wrap = "any"

567

if self.log_wrap == u"clip":

568

self.log_wrap = u"any"

591

569

else:

592

self.log_wrap = "clip"

570

self.log_wrap = u"clip"

593

571

for textwidget in self.log:

594

572

textwidget.set_wrap_mode(self.log_wrap)

595

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

573

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

596

574

597

575

def find_and_remove_client(self, path, name):

598

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

576

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

599

577

600

578

This is connected to the ClientRemoved signal from the

601

579

Mandos server object."""

603

581

client = self.clients_dict[path]

604

582

except KeyError:

605

583

# not found?

606

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

607

path)

608

584

return

609

client.delete()

585

self.remove_client(client, path)

610

586

611

587

def add_new_client(self, path):

612

588

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

627

603

if path is None:

628

604

path = client.proxy.object_path

629

605

self.clients_dict[path] = client

630

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

606

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

631

607

self.refresh()

632

608

633

609

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

664

640

665

641

def process_input(self, source, condition):

666

642

keys = self.screen.get_input()

667

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

668

"ctrl p": "up", # Emacs

669

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

670

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

671

" ": "page down", # less

672

"f": "page down", # less

673

"b": "page up", # less

674

"j": "down", # vi

675

"k": "up", # vi

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

676

652

}

677

653

for key in keys:

678

654

try:

680

656

except KeyError: # :-)

681

657

pass

682

658

683

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

659

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

684

660

self.stop()

685

661

break

686

elif key == "window resize":

662

elif key == u"window resize":

687

663

self.size = self.screen.get_cols_rows()

688

664

self.refresh()

689

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

665

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

690

666

self.refresh()

691

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

667

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

692

668

self.toggle_log_display()

693

669

self.refresh()

694

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

670

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

695

671

self.change_log_display()

696

672

self.refresh()

697

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

673

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

698

674

if not self.log_visible:

699

675

self.log_visible = True

700

676

self.rebuild()

701

self.log_message_raw(("bold",

702

" ".

703

join(("q: Quit",

704

"?: Help",

705

"l: Log window toggle",

706

"TAB: Switch window",

707

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

708

self.log_message_raw(("bold",

709

" "

710

.join(("Clients:",

711

"+: Enable",

712

"-: Disable",

713

"R: Remove",

714

"s: Start new checker",

715

"S: Stop checker",

716

"C: Checker OK",

717

"a: Approve",

718

"d: Deny"))))

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

719

695

self.refresh()

720

elif key == "tab":

696

elif key == u"tab":

721

697

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

722

698

self.topwidget.set_focus(0)

723

699

else:

724

700

self.topwidget.set_focus(self.logbox)

725

701

self.refresh()

726

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

727

# or key == ">"):

702

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

703

# or key == u">"):

728

704

# pass # xxx end-of-buffer

729

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

730

# or key == "<"):

705

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

706

# or key == u"<"):

731

707

# pass # xxx beginning-of-buffer

732

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

708

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

733

709

# pass # xxx move-end-of-line

734

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

710

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

735

711

# pass # xxx move-beginning-of-line

736

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

712

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

737

713

# pass # xxx left

738

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

714

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

739

715

# pass # xxx right

740

#elif key == "a":

716

#elif key == u"a":

741

717

# pass # scroll up log

742

#elif key == "z":

718

#elif key == u"z":

743

719

# pass # scroll down log

744

720

elif self.topwidget.selectable():

745

721

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