/mandos/trunk : revision 237.4.16

1

#!/usr/bin/python

2

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

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

5

#

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

11

# the Free Software Foundation, either version 3 of the License, or

12

# (at your option) any later version.

13

#

14

# This program is distributed in the hope that it will be useful,

15

# but WITHOUT ANY WARRANTY; without even the implied warranty of

16

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

17

# GNU General Public License for more details.

18

#

19

# You should have received a copy of the GNU General Public License

20

# along with this program. If not, see <http://www.gnu.org/licenses/>.

21

#

22

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

23

#

3

24

4

from __future__ import division, absolute_import, with_statement

25

from __future__ import (division, absolute_import, print_function,

26

unicode_literals)

5

27

6

28

import sys

7

29

import os

21

43

22

44

import locale

23

45

24

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

46

locale.setlocale(locale.LC_ALL, '')

25

47

26

48

import logging

27

49

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

30

52

domain = 'se.bsnet.fukt'

31

53

server_interface = domain + '.Mandos'

32

54

client_interface = domain + '.Mandos.Client'

33

version = "1.0.15"

55

version = "1.3.1"

34

56

35

57

# Always run in monochrome mode

36

58

urwid.curses_display.curses.has_colors = lambda : False

44

66

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

45

67

if not iso:

46

68

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)

69

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

70

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

71

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

50

72

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

51

73

return datetime.datetime(int(year),

52

74

int(month),

65

87

self.proxy = proxy_object # Mandos Client proxy object

66

88

67

89

self.properties = dict()

68

self.proxy.connect_to_signal(u"PropertyChanged",

69

self.property_changed,

70

client_interface,

71

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

72

95

73

96

self.properties.update(

74

97

self.proxy.GetAll(client_interface,

75

98

dbus_interface = dbus.PROPERTIES_IFACE))

76

99

77

#XXX This break good super behaviour!

100

#XXX This breaks good super behaviour

78

101

# super(MandosClientPropertyCache, self).__init__(

79

102

# *args, **kwargs)

80

103

84

107

"""

85

108

# Update properties dict with new value

86

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)

87

115

88

116

89

117

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

106

134

self.last_checker_failed = False

107

135

108

136

# The widget shown normally

109

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

137

self._text_widget = urwid.Text("")

110

138

# The widget shown when we have focus

111

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

139

self._focus_text_widget = urwid.Text("")

112

140

super(MandosClientWidget, self).__init__(

113

141

update_hook=update_hook, delete_hook=delete_hook,

114

142

*args, **kwargs)

116

144

self.opened = False

117

145

118

146

last_checked_ok = isoformat_to_datetime(self.properties

119

[u"LastCheckedOK"])

147

["LastCheckedOK"])

120

148

if last_checked_ok is None:

121

149

self.last_checker_failed = True

122

150

else:

125

153

> datetime.timedelta

126

154

(milliseconds=

127

155

self.properties

128

[u"Interval"]))

156

["Interval"]))

129

157

130

158

if self.last_checker_failed:

131

159

self.using_timer(True)

133

161

if self.need_approval:

134

162

self.using_timer(True)

135

163

136

self.proxy.connect_to_signal(u"CheckerCompleted",

137

self.checker_completed,

138

client_interface,

139

byte_arrays=True)

140

self.proxy.connect_to_signal(u"CheckerStarted",

141

self.checker_started,

142

client_interface,

143

byte_arrays=True)

144

self.proxy.connect_to_signal(u"GotSecret",

145

self.got_secret,

146

client_interface,

147

byte_arrays=True)

148

self.proxy.connect_to_signal(u"NeedApproval",

149

self.need_approval,

150

client_interface,

151

byte_arrays=True)

152

self.proxy.connect_to_signal(u"Rejected",

153

self.rejected,

154

client_interface,

155

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

156

186

157

187

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

158

188

super(self, MandosClientWidget).property_changed(property,

159

189

value)

160

if property == u"ApprovalPending":

190

if property == "ApprovalPending":

161

191

using_timer(bool(value))

162

192

163

193

def using_timer(self, flag):

182

212

if self.last_checker_failed:

183

213

self.last_checker_failed = False

184

214

self.using_timer(False)

185

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

186

# u' was successful'

187

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

215

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

216

# ' was successful'

217

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

188

218

self.update()

189

219

return

190

220

# Checker failed

192

222

self.last_checker_failed = True

193

223

self.using_timer(True)

194

224

if os.WIFEXITED(condition):

195

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

196

u' failed with exit code %s'

197

% (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,

198

228

os.WEXITSTATUS(condition)))

199

229

elif os.WIFSIGNALED(condition):

200

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

201

u' was killed by signal %s'

202

% (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,

203

233

os.WTERMSIG(condition)))

204

234

elif os.WCOREDUMP(condition):

205

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

206

u' dumped core'

207

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

235

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

236

' dumped core'

237

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

208

238

else:

209

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

210

u' mysteriously')

239

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

240

' mysteriously')

211

241

self.update()

212

242

213

243

def checker_started(self, command):

214

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

215

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

244

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

245

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

216

246

pass

217

247

218

248

def got_secret(self):

219

249

self.last_checker_failed = False

220

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

221

% self.properties[u"Name"])

250

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

251

% self.properties["Name"])

222

252

223

253

def need_approval(self, timeout, default):

224

254

if not default:

225

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

255

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

226

256

else:

227

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

257

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

228

258

self.logger(message

229

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

259

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

230

260

self.using_timer(True)

231

261

232

262

def rejected(self, reason):

233

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

234

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

263

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

264

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

235

265

236

266

def selectable(self):

237

267

"""Make this a "selectable" widget.

238

268

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

239

269

return True

240

270

241

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

271

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

242

272

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

243

273

whether we have focus or not.

244

274

This overrides the method from urwid.FlowWidget"""

245

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

275

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

246

276

247

277

def current_widget(self, focus=False):

248

278

if focus or self.opened:

252

282

def update(self):

253

283

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

254

284

# How to add standout mode to a style

255

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

256

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

257

u"underline-blink":

258

u"underline-blink-standout",

259

u"bold-underline-blink":

260

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

261

291

}

262

292

263

293

# Rebuild focus and non-focus widgets using current properties

264

294

265

295

# Base part of a client. Name!

266

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

267

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

268

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

269

message = u"DISABLED"

270

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

271

301

timeout = datetime.timedelta(milliseconds

272

302

= self.properties

273

[u"ApprovalDelay"])

303

["ApprovalDelay"])

274

304

last_approval_request = isoformat_to_datetime(

275

self.properties[u"LastApprovalRequest"])

305

self.properties["LastApprovalRequest"])

276

306

if last_approval_request is not None:

277

307

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

278

308

- last_approval_request)

279

309

else:

280

310

timer = datetime.timedelta()

281

if self.properties[u"ApprovedByDefault"]:

282

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

311

if self.properties["ApprovedByDefault"]:

312

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

283

313

else:

284

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

314

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

285

315

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

286

316

elif self.last_checker_failed:

287

317

timeout = datetime.timedelta(milliseconds

288

318

= self.properties

289

[u"Timeout"])

319

["Timeout"])

290

320

last_ok = isoformat_to_datetime(

291

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

292

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

293

self.properties[u"LastEnabled"]))

321

max((self.properties["LastCheckedOK"]

322

or self.properties["Created"]),

323

self.properties["LastEnabled"]))

294

324

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

295

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

296

u' gets disabled: %s'

325

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

326

' gets disabled: %s'

297

327

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

298

328

else:

299

message = u"enabled"

329

message = "enabled"

300

330

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

301

331

302

332

if not urwid.supports_unicode():

303

333

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

304

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

334

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

305

335

self._text_widget.set_text(textlist)

306

336

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

307

337

text[1])

320

350

self.update()

321

351

return True # Keep calling this

322

352

323

def delete(self):

353

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

324

354

if self._update_timer_callback_tag is not None:

325

355

gobject.source_remove(self._update_timer_callback_tag)

326

356

self._update_timer_callback_tag = None

357

for match in self.match_objects:

358

match.remove()

359

self.match_objects = ()

327

360

if self.delete_hook is not None:

328

361

self.delete_hook(self)

362

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

329

363

330

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

364

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

331

365

"""Render differently if we have focus.

332

366

This overrides the method from urwid.FlowWidget"""

333

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

367

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

334

368

focus=focus)

335

369

336

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

370

def keypress(self, maxcolrow, key):

337

371

"""Handle keys.

338

372

This overrides the method from urwid.FlowWidget"""

339

if key == u"+":

340

self.proxy.Enable(dbus_interface = client_interface)

341

elif key == u"-":

342

self.proxy.Disable(dbus_interface = client_interface)

343

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

344

380

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

345

dbus_interface = client_interface)

346

elif key == u"d":

381

dbus_interface = client_interface,

382

ignore_reply=True)

383

elif key == "d":

347

384

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

348

dbus_interface = client_interface)

349

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

350

388

self.server_proxy_object.RemoveClient(self.proxy

351

.object_path)

352

elif key == u"s":

353

self.proxy.StartChecker(dbus_interface = client_interface)

354

elif key == u"S":

355

self.proxy.StopChecker(dbus_interface = client_interface)

356

elif key == u"C":

357

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)

358

400

# xxx

359

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

401

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

360

402

# self.proxy.pause()

361

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

403

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

362

404

# self.proxy.unpause()

363

# elif key == u"RET":

405

# elif key == "RET":

364

406

# self.open()

365

407

else:

366

408

return key

382

424

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

383

425

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

384

426

"""

385

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

386

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

387

maxrow), key)

388

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

389

430

return

390

431

return ret

391

432

400

441

self.screen = urwid.curses_display.Screen()

401

442

402

443

self.screen.register_palette((

403

(u"normal",

404

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

405

(u"bold",

406

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

407

(u"underline-blink",

408

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

409

(u"standout",

410

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

411

(u"bold-underline-blink",

412

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

413

(u"bold-standout",

414

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

415

(u"underline-blink-standout",

416

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

417

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

418

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

419

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

420

461

))

421

462

422

463

if urwid.supports_unicode():

423

self.divider = u"─" # \u2500

424

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

464

self.divider = "─" # \u2500

465

#self.divider = "━" # \u2501

425

466

else:

426

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

427

self.divider = u"_" # \u005f

467

#self.divider = "-" # \u002d

468

self.divider = "_" # \u005f

428

469

429

470

self.screen.start()

430

471

444

485

# This keeps track of whether self.uilist currently has

445

486

# self.logbox in it or not

446

487

self.log_visible = True

447

self.log_wrap = u"any"

488

self.log_wrap = "any"

448

489

449

490

self.rebuild()

450

self.log_message_raw((u"bold",

451

u"Mandos Monitor version " + version))

452

self.log_message_raw((u"bold",

453

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

454

495

455

496

self.busname = domain + '.Mandos'

456

497

self.main_loop = gobject.MainLoop()

457

498

self.bus = dbus.SystemBus()

458

499

mandos_dbus_objc = self.bus.get_object(

459

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

500

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

460

501

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

461

502

dbus_interface

462

503

= server_interface)

467

508

mandos_clients = dbus.Dictionary()

468

509

469

510

(self.mandos_serv

470

.connect_to_signal(u"ClientRemoved",

511

.connect_to_signal("ClientRemoved",

471

512

self.find_and_remove_client,

472

513

dbus_interface=server_interface,

473

514

byte_arrays=True))

474

515

(self.mandos_serv

475

.connect_to_signal(u"ClientAdded",

516

.connect_to_signal("ClientAdded",

476

517

self.add_new_client,

477

518

dbus_interface=server_interface,

478

519

byte_arrays=True))

479

520

(self.mandos_serv

480

.connect_to_signal(u"ClientNotFound",

521

.connect_to_signal("ClientNotFound",

481

522

self.client_not_found,

482

523

dbus_interface=server_interface,

483

524

byte_arrays=True))

498

539

path=path)

499

540

500

541

def client_not_found(self, fingerprint, address):

501

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

502

u" could not be found" % (address,

542

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

543

" could not be found" % (address,

503

544

fingerprint)))

504

545

505

546

def rebuild(self):

521

562

522

563

def log_message(self, message):

523

564

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

524

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

565

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

525

566

526

567

def log_message_raw(self, markup):

527

568

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

530

571

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

531

572

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

532

573

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

533

coming_from=u"above")

574

coming_from="above")

534

575

self.refresh()

535

576

536

577

def toggle_log_display(self):

537

578

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

538

579

self.log_visible = not self.log_visible

539

580

self.rebuild()

540

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

581

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

541

582

# + unicode(self.log_visible))

542

583

543

584

def change_log_display(self):

544

585

"""Change type of log display.

545

586

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

546

if self.log_wrap == u"clip":

547

self.log_wrap = u"any"

587

if self.log_wrap == "clip":

588

self.log_wrap = "any"

548

589

else:

549

self.log_wrap = u"clip"

590

self.log_wrap = "clip"

550

591

for textwidget in self.log:

551

592

textwidget.set_wrap_mode(self.log_wrap)

552

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

593

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

553

594

554

595

def find_and_remove_client(self, path, name):

555

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

596

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

556

597

557

598

This is connected to the ClientRemoved signal from the

558

599

Mandos server object."""

560

601

client = self.clients_dict[path]

561

602

except KeyError:

562

603

# not found?

604

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

605

path)

563

606

return

564

self.remove_client(client, path)

607

client.delete()

565

608

566

609

def add_new_client(self, path):

567

610

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

582

625

if path is None:

583

626

path = client.proxy.object_path

584

627

self.clients_dict[path] = client

585

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

628

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

586

629

self.refresh()

587

630

588

631

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

619

662

620

663

def process_input(self, source, condition):

621

664

keys = self.screen.get_input()

622

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

623

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

624

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

625

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

626

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

627

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

628

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

629

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

630

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

631

674

}

632

675

for key in keys:

633

676

try:

635

678

except KeyError: # :-)

636

679

pass

637

680

638

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

681

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

639

682

self.stop()

640

683

break

641

elif key == u"window resize":

684

elif key == "window resize":

642

685

self.size = self.screen.get_cols_rows()

643

686

self.refresh()

644

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

687

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

645

688

self.refresh()

646

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

689

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

647

690

self.toggle_log_display()

648

691

self.refresh()

649

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

692

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

650

693

self.change_log_display()

651

694

self.refresh()

652

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

695

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

653

696

if not self.log_visible:

654

697

self.log_visible = True

655

698

self.rebuild()

656

self.log_message_raw((u"bold",

657

u" ".

658

join((u"q: Quit",

659

u"?: Help",

660

u"l: Log window toggle",

661

u"TAB: Switch window",

662

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

663

self.log_message_raw((u"bold",

664

u" "

665

.join((u"Clients:",

666

u"+: Enable",

667

u"-: Disable",

668

u"r: Remove",

669

u"s: Start new checker",

670

u"S: Stop checker",

671

u"C: Checker OK",

672

u"a: Approve",

673

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

674

717

self.refresh()

675

elif key == u"tab":

718

elif key == "tab":

676

719

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

677

720

self.topwidget.set_focus(0)

678

721

else:

679

722

self.topwidget.set_focus(self.logbox)

680

723

self.refresh()

681

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

682

# or key == u">"):

724

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

725

# or key == ">"):

683

726

# pass # xxx end-of-buffer

684

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

685

# or key == u"<"):

727

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

728

# or key == "<"):

686

729

# pass # xxx beginning-of-buffer

687

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

730

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

688

731

# pass # xxx move-end-of-line

689

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

732

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

690

733

# pass # xxx move-beginning-of-line

691

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

734

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

692

735

# pass # xxx left

693

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

736

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

694

737

# pass # xxx right

695

#elif key == u"a":

738

#elif key == "a":

696

739

# pass # scroll up log

697

#elif key == u"z":

740

#elif key == "z":

698

741

# pass # scroll down log

699

742

elif self.topwidget.selectable():

700

743

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