/mandos/trunk : revision 24.1.162

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

#

24

3

25

from __future__ import division, absolute_import, print_function, unicode_literals

4

from __future__ import division, absolute_import, with_statement

26

5

27

6

import sys

28

7

import os

42

21

43

22

import locale

44

23

45

locale.setlocale(locale.LC_ALL, '')

24

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

46

25

47

26

import logging

48

27

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

51

30

domain = 'se.bsnet.fukt'

52

31

server_interface = domain + '.Mandos'

53

32

client_interface = domain + '.Mandos.Client'

54

version = "1.3.0"

33

version = "1.0.15"

55

34

56

35

# Always run in monochrome mode

57

36

urwid.curses_display.curses.has_colors = lambda : False

65

44

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

66

45

if not iso:

67

46

return None

68

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

69

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

70

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

47

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

48

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

49

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

71

50

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

72

51

return datetime.datetime(int(year),

73

52

int(month),

86

65

self.proxy = proxy_object # Mandos Client proxy object

87

66

88

67

self.properties = dict()

89

self.proxy.connect_to_signal("PropertyChanged",

68

self.proxy.connect_to_signal(u"PropertyChanged",

90

69

self.property_changed,

91

70

client_interface,

92

71

byte_arrays=True)

123

102

self.logger = logger

124

103

125

104

self._update_timer_callback_tag = None

126

self._update_timer_callback_lock = 0

127

105

self.last_checker_failed = False

128

106

129

107

# The widget shown normally

130

self._text_widget = urwid.Text("")

108

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

131

109

# The widget shown when we have focus

132

self._focus_text_widget = urwid.Text("")

110

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

133

111

super(MandosClientWidget, self).__init__(

134

112

update_hook=update_hook, delete_hook=delete_hook,

135

113

*args, **kwargs)

136

114

self.update()

137

115

self.opened = False

138

116

self.proxy.connect_to_signal(u"CheckerCompleted",

117

self.checker_completed,

118

client_interface,

119

byte_arrays=True)

120

self.proxy.connect_to_signal(u"CheckerStarted",

121

self.checker_started,

122

client_interface,

123

byte_arrays=True)

124

self.proxy.connect_to_signal(u"GotSecret",

125

self.got_secret,

126

client_interface,

127

byte_arrays=True)

128

self.proxy.connect_to_signal(u"NeedApproval",

129

self.need_approval,

130

client_interface,

131

byte_arrays=True)

132

self.proxy.connect_to_signal(u"Rejected",

133

self.rejected,

134

client_interface,

135

byte_arrays=True)

139

136

last_checked_ok = isoformat_to_datetime(self.properties

140

["LastCheckedOK"])

137

["last_checked_ok"])

141

138

if last_checked_ok is None:

142

139

self.last_checker_failed = True

143

140

else:

145

142

- last_checked_ok)

146

143

> datetime.timedelta

147

144

(milliseconds=

148

self.properties

149

["Interval"]))

150

145

self.properties["interval"]))

151

146

if self.last_checker_failed:

152

self.using_timer(True)

153

154

if self.need_approval:

155

self.using_timer(True)

156

157

self.proxy.connect_to_signal("CheckerCompleted",

158

self.checker_completed,

159

client_interface,

160

byte_arrays=True)

161

self.proxy.connect_to_signal("CheckerStarted",

162

self.checker_started,

163

client_interface,

164

byte_arrays=True)

165

self.proxy.connect_to_signal("GotSecret",

166

self.got_secret,

167

client_interface,

168

byte_arrays=True)

169

self.proxy.connect_to_signal("NeedApproval",

170

self.need_approval,

171

client_interface,

172

byte_arrays=True)

173

self.proxy.connect_to_signal("Rejected",

174

self.rejected,

175

client_interface,

176

byte_arrays=True)

177

178

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

179

super(self, MandosClientWidget).property_changed(property,

180

value)

181

if property == "ApprovalPending":

182

using_timer(bool(value))

183

184

def using_timer(self, flag):

185

"""Call this method with True or False when timer should be

186

activated or deactivated.

187

"""

188

old = self._update_timer_callback_lock

189

if flag:

190

self._update_timer_callback_lock += 1

191

else:

192

self._update_timer_callback_lock -= 1

193

if old == 0 and self._update_timer_callback_lock:

194

147

self._update_timer_callback_tag = (gobject.timeout_add

195

148

(1000,

196

149

self.update_timer))

197

elif old and self._update_timer_callback_lock == 0:

198

gobject.source_remove(self._update_timer_callback_tag)

199

self._update_timer_callback_tag = None

200

150

201

151

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

202

152

if exitstatus == 0:

203

153

if self.last_checker_failed:

204

154

self.last_checker_failed = False

205

self.using_timer(False)

206

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

207

# ' was successful'

208

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

155

gobject.source_remove(self._update_timer_callback_tag)

156

self._update_timer_callback_tag = None

157

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

158

u' was successful'

159

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

209

160

self.update()

210

161

return

211

162

# Checker failed

212

163

if not self.last_checker_failed:

213

164

self.last_checker_failed = True

214

self.using_timer(True)

165

self._update_timer_callback_tag = (gobject.timeout_add

166

(1000,

167

self.update_timer))

215

168

if os.WIFEXITED(condition):

216

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

217

' failed with exit code %s'

218

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

169

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

170

u' failed with exit code %s'

171

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

219

172

os.WEXITSTATUS(condition)))

220

173

elif os.WIFSIGNALED(condition):

221

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

222

' was killed by signal %s'

223

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

174

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

175

u' was killed by signal %s'

176

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

224

177

os.WTERMSIG(condition)))

225

178

elif os.WCOREDUMP(condition):

226

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

227

' dumped core'

228

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

179

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

180

u' dumped core'

181

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

229

182

else:

230

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

231

' mysteriously')

183

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

232

184

self.update()

233

185

234

186

def checker_started(self, command):

235

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

236

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

187

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

188

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

237

189

pass

238

190

239

191

def got_secret(self):

240

192

self.last_checker_failed = False

241

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

242

% self.properties["Name"])

193

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

194

% self.properties[u"name"])

243

195

244

196

def need_approval(self, timeout, default):

245

197

if not default:

246

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

198

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

247

199

else:

248

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

200

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

249

201

self.logger(message

250

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

251

self.using_timer(True)

202

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

252

203

253

204

def rejected(self, reason):

254

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

255

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

205

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

206

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

256

207

257

208

def selectable(self):

258

209

"""Make this a "selectable" widget.

259

210

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

260

211

return True

261

212

262

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

213

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

263

214

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

264

215

whether we have focus or not.

265

216

This overrides the method from urwid.FlowWidget"""

266

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

217

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

267

218

268

219

def current_widget(self, focus=False):

269

220

if focus or self.opened:

273

224

def update(self):

274

225

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

275

226

# How to add standout mode to a style

276

with_standout = { "normal": "standout",

277

"bold": "bold-standout",

278

"underline-blink":

279

"underline-blink-standout",

280

"bold-underline-blink":

281

"bold-underline-blink-standout",

227

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

228

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

229

u"underline-blink":

230

u"underline-blink-standout",

231

u"bold-underline-blink":

232

u"bold-underline-blink-standout",

282

233

}

283

234

284

235

# Rebuild focus and non-focus widgets using current properties

285

236

286

237

# Base part of a client. Name!

287

base = ('%(name)s: '

288

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

289

if not self.properties["Enabled"]:

290

message = "DISABLED"

291

elif self.properties["ApprovalPending"]:

292

timeout = datetime.timedelta(milliseconds

293

= self.properties

294

["ApprovalDelay"])

295

last_approval_request = isoformat_to_datetime(

296

self.properties["LastApprovalRequest"])

297

if last_approval_request is not None:

298

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

299

- last_approval_request)

300

else:

301

timer = datetime.timedelta()

302

if self.properties["ApprovedByDefault"]:

303

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

304

else:

305

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

306

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

238

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

239

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

240

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

241

message = u"DISABLED"

242

elif self.properties[u"approved_pending"]:

243

if self.properties[u"approved_by_default"]:

244

message = u"Connection established to client. (d)eny?"

245

else:

246

message = u"Seeks approval to send secret. (a)pprove?"

307

247

elif self.last_checker_failed:

308

248

timeout = datetime.timedelta(milliseconds

309

= self.properties

310

["Timeout"])

249

= self.properties[u"timeout"])

311

250

last_ok = isoformat_to_datetime(

312

max((self.properties["LastCheckedOK"]

313

or self.properties["Created"]),

314

self.properties["LastEnabled"]))

251

max((self.properties["last_checked_ok"]

252

or self.properties["created"]),

253

self.properties[u"last_enabled"]))

315

254

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

316

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

317

' gets disabled: %s'

255

message = (u'A checker has failed! Time until client gets diabled: %s'

318

256

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

319

257

else:

320

message = "enabled"

258

message = u"enabled"

321

259

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

322

260

323

261

if not urwid.supports_unicode():

324

262

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

325

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

263

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

326

264

self._text_widget.set_text(textlist)

327

265

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

328

266

text[1])

348

286

if self.delete_hook is not None:

349

287

self.delete_hook(self)

350

288

351

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

289

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

352

290

"""Render differently if we have focus.

353

291

This overrides the method from urwid.FlowWidget"""

354

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

292

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

355

293

focus=focus)

356

294

357

def keypress(self, maxcolrow, key):

295

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

358

296

"""Handle keys.

359

297

This overrides the method from urwid.FlowWidget"""

360

if key == "+":

361

self.proxy.Enable(dbus_interface = client_interface,

362

ignore_reply=True)

363

elif key == "-":

364

self.proxy.Disable(dbus_interface = client_interface,

365

ignore_reply=True)

366

elif key == "a":

298

if key == u"+":

299

self.proxy.Enable(dbus_interface = client_interface)

300

elif key == u"-":

301

self.proxy.Disable(dbus_interface = client_interface)

302

elif key == u"a":

367

303

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

368

dbus_interface = client_interface,

369

ignore_reply=True)

370

elif key == "d":

304

dbus_interface = client_interface)

305

elif key == u"d":

371

306

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

372

dbus_interface = client_interface,

373

ignore_reply=True)

374

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

307

dbus_interface = client_interface)

308

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

375

309

self.server_proxy_object.RemoveClient(self.proxy

376

.object_path,

377

ignore_reply=True)

378

elif key == "s":

379

self.proxy.StartChecker(dbus_interface = client_interface,

380

ignore_reply=True)

381

elif key == "S":

382

self.proxy.StopChecker(dbus_interface = client_interface,

383

ignore_reply=True)

384

elif key == "C":

385

self.proxy.CheckedOK(dbus_interface = client_interface,

386

ignore_reply=True)

310

.object_path)

311

elif key == u"s":

312

self.proxy.StartChecker(dbus_interface = client_interface)

313

elif key == u"S":

314

self.proxy.StopChecker(dbus_interface = client_interface)

315

elif key == u"C":

316

self.proxy.CheckedOK(dbus_interface = client_interface)

387

317

# xxx

388

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

318

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

389

319

# self.proxy.pause()

390

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

320

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

391

321

# self.proxy.unpause()

392

# elif key == "RET":

322

# elif key == u"RET":

393

323

# self.open()

324

# elif key == u"+":

325

# self.proxy.Approve(True)

326

# elif key == u"-":

327

# self.proxy.Approve(False)

394

328

else:

395

329

return key

396

330

411

345

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

412

346

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

413

347

"""

414

def keypress(self, maxcolrow, key):

415

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

416

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

348

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

349

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

350

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

417

351

return

418

352

return ret

419

353

428

362

self.screen = urwid.curses_display.Screen()

429

363

430

364

self.screen.register_palette((

431

("normal",

432

"default", "default", None),

433

("bold",

434

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

435

("underline-blink",

436

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

437

("standout",

438

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

439

("bold-underline-blink",

440

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

441

("bold-standout",

442

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

443

("underline-blink-standout",

444

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

445

("bold-underline-blink-standout",

446

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

447

"standout")),

365

(u"normal",

366

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

367

(u"bold",

368

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

369

(u"underline-blink",

370

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

371

(u"standout",

372

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

373

(u"bold-underline-blink",

374

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

375

(u"bold-standout",

376

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

377

(u"underline-blink-standout",

378

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

379

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

380

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

381

u"standout")),

448

382

))

449

383

450

384

if urwid.supports_unicode():

451

self.divider = "─" # \u2500

452

#self.divider = "━" # \u2501

385

self.divider = u"─" # \u2500

386

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

453

387

else:

454

#self.divider = "-" # \u002d

455

self.divider = "_" # \u005f

388

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

389

self.divider = u"_" # \u005f

456

390

457

391

self.screen.start()

458

392

472

406

# This keeps track of whether self.uilist currently has

473

407

# self.logbox in it or not

474

408

self.log_visible = True

475

self.log_wrap = "any"

409

self.log_wrap = u"any"

476

410

477

411

self.rebuild()

478

self.log_message_raw(("bold",

479

"Mandos Monitor version " + version))

480

self.log_message_raw(("bold",

481

"q: Quit ?: Help"))

412

self.log_message_raw((u"bold",

413

u"Mandos Monitor version " + version))

414

self.log_message_raw((u"bold",

415

u"q: Quit ?: Help"))

482

416

483

417

self.busname = domain + '.Mandos'

484

418

self.main_loop = gobject.MainLoop()

485

419

self.bus = dbus.SystemBus()

486

420

mandos_dbus_objc = self.bus.get_object(

487

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

421

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

488

422

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

489

423

dbus_interface

490

424

= server_interface)

495

429

mandos_clients = dbus.Dictionary()

496

430

497

431

(self.mandos_serv

498

.connect_to_signal("ClientRemoved",

432

.connect_to_signal(u"ClientRemoved",

499

433

self.find_and_remove_client,

500

434

dbus_interface=server_interface,

501

435

byte_arrays=True))

502

436

(self.mandos_serv

503

.connect_to_signal("ClientAdded",

437

.connect_to_signal(u"ClientAdded",

504

438

self.add_new_client,

505

439

dbus_interface=server_interface,

506

440

byte_arrays=True))

507

441

(self.mandos_serv

508

.connect_to_signal("ClientNotFound",

442

.connect_to_signal(u"ClientNotFound",

509

443

self.client_not_found,

510

444

dbus_interface=server_interface,

511

445

byte_arrays=True))

526

460

path=path)

527

461

528

462

def client_not_found(self, fingerprint, address):

529

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

530

" could not be found" % (address,

463

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

464

u" could not be found" % (address,

531

465

fingerprint)))

532

466

533

467

def rebuild(self):

535

469

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

536

470

self.uilist = []

537

471

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

538

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

539

clients),

472

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

540

473

#header=urwid.Divider(),

541

474

header=None,

542

footer=

543

urwid.Divider(div_char=

544

self.divider)))

475

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

545

476

if self.log_visible:

546

477

self.uilist.append(self.logbox)

547

478

pass

549

480

550

481

def log_message(self, message):

551

482

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

552

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

483

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

553

484

554

485

def log_message_raw(self, markup):

555

486

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

558

489

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

559

490

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

560

491

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

561

coming_from="above")

492

coming_from=u"above")

562

493

self.refresh()

563

494

564

495

def toggle_log_display(self):

565

496

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

566

497

self.log_visible = not self.log_visible

567

498

self.rebuild()

568

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

569

# + unicode(self.log_visible))

499

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

500

+ unicode(self.log_visible))

570

501

571

502

def change_log_display(self):

572

503

"""Change type of log display.

573

504

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

574

if self.log_wrap == "clip":

575

self.log_wrap = "any"

505

if self.log_wrap == u"clip":

506

self.log_wrap = u"any"

576

507

else:

577

self.log_wrap = "clip"

508

self.log_wrap = u"clip"

578

509

for textwidget in self.log:

579

510

textwidget.set_wrap_mode(self.log_wrap)

580

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

511

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

581

512

582

513

def find_and_remove_client(self, path, name):

583

514

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

610

541

if path is None:

611

542

path = client.proxy.object_path

612

543

self.clients_dict[path] = client

613

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

544

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

614

545

self.refresh()

615

546

616

547

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

647

578

648

579

def process_input(self, source, condition):

649

580

keys = self.screen.get_input()

650

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

651

"ctrl p": "up", # Emacs

652

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

653

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

654

" ": "page down", # less

655

"f": "page down", # less

656

"b": "page up", # less

657

"j": "down", # vi

658

"k": "up", # vi

581

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

582

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

583

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

584

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

585

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

586

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

587

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

588

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

589

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

659

590

}

660

591

for key in keys:

661

592

try:

663

594

except KeyError: # :-)

664

595

pass

665

596

666

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

597

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

667

598

self.stop()

668

599

break

669

elif key == "window resize":

600

elif key == u"window resize":

670

601

self.size = self.screen.get_cols_rows()

671

602

self.refresh()

672

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

603

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

673

604

self.refresh()

674

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

605

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

675

606

self.toggle_log_display()

676

607

self.refresh()

677

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

608

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

678

609

self.change_log_display()

679

610

self.refresh()

680

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

611

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

681

612

if not self.log_visible:

682

613

self.log_visible = True

683

614

self.rebuild()

684

self.log_message_raw(("bold",

685

" ".

686

join(("q: Quit",

687

"?: Help",

688

"l: Log window toggle",

689

"TAB: Switch window",

690

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

691

self.log_message_raw(("bold",

692

" "

693

.join(("Clients:",

694

"+: Enable",

695

"-: Disable",

696

"R: Remove",

697

"s: Start new checker",

698

"S: Stop checker",

699

"C: Checker OK",

700

"a: Approve",

701

"d: Deny"))))

615

self.log_message_raw((u"bold",

616

u" ".

617

join((u"q: Quit",

618

u"?: Help",

619

u"l: Log window toggle",

620

u"TAB: Switch window",

621

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

622

self.log_message_raw((u"bold",

623

u" "

624

.join((u"Clients:",

625

u"+: Enable",

626

u"-: Disable",

627

u"r: Remove",

628

u"s: Start new checker",

629

u"S: Stop checker",

630

u"C: Checker OK",

631

u"a: Approve",

632

u"d: Deny"))))

702

633

self.refresh()

703

elif key == "tab":

634

elif key == u"tab":

704

635

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

705

636

self.topwidget.set_focus(0)

706

637

else:

707

638

self.topwidget.set_focus(self.logbox)

708

639

self.refresh()

709

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

710

# or key == ">"):

640

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

641

# or key == u">"):

711

642

# pass # xxx end-of-buffer

712

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

713

# or key == "<"):

643

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

644

# or key == u"<"):

714

645

# pass # xxx beginning-of-buffer

715

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

646

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

716

647

# pass # xxx move-end-of-line

717

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

648

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

718

649

# pass # xxx move-beginning-of-line

719

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

650

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

720

651

# pass # xxx left

721

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

652

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

722

653

# pass # xxx right

723

#elif key == "a":

654

#elif key == u"a":

724

655

# pass # scroll up log

725

#elif key == "z":

656

#elif key == u"z":

726

657

# pass # scroll down log

727

658

elif self.topwidget.selectable():

728

659

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