/mandos/trunk : revision 485

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

5

26

6

27

import sys

7

28

import os

21

42

22

43

import locale

23

44

24

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

45

locale.setlocale(locale.LC_ALL, '')

25

46

26

47

import logging

27

48

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

30

51

domain = 'se.bsnet.fukt'

31

52

server_interface = domain + '.Mandos'

32

53

client_interface = domain + '.Mandos.Client'

33

version = "1.0.15"

54

version = "1.3.0"

34

55

35

56

# Always run in monochrome mode

36

57

urwid.curses_display.curses.has_colors = lambda : False

44

65

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

45

66

if not iso:

46

67

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)

68

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

69

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

70

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

50

71

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

51

72

return datetime.datetime(int(year),

52

73

int(month),

65

86

self.proxy = proxy_object # Mandos Client proxy object

66

87

67

88

self.properties = dict()

68

self.proxy.connect_to_signal(u"PropertyChanged",

89

self.proxy.connect_to_signal("PropertyChanged",

69

90

self.property_changed,

70

91

client_interface,

71

92

byte_arrays=True)

102

123

self.logger = logger

103

124

104

125

self._update_timer_callback_tag = None

126

self._update_timer_callback_lock = 0

105

127

self.last_checker_failed = False

106

128

107

129

# The widget shown normally

108

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

130

self._text_widget = urwid.Text("")

109

131

# The widget shown when we have focus

110

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

132

self._focus_text_widget = urwid.Text("")

111

133

super(MandosClientWidget, self).__init__(

112

134

update_hook=update_hook, delete_hook=delete_hook,

113

135

*args, **kwargs)

114

136

self.update()

115

137

self.opened = False

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)

138

136

139

last_checked_ok = isoformat_to_datetime(self.properties

137

["last_checked_ok"])

140

["LastCheckedOK"])

138

141

if last_checked_ok is None:

139

142

self.last_checker_failed = True

140

143

else:

142

145

- last_checked_ok)

143

146

> datetime.timedelta

144

147

(milliseconds=

145

self.properties["interval"]))

148

self.properties

149

["Interval"]))

150

146

151

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:

147

194

self._update_timer_callback_tag = (gobject.timeout_add

148

195

(1000,

149

196

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

150

200

151

201

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

152

202

if exitstatus == 0:

153

203

if self.last_checker_failed:

154

204

self.last_checker_failed = False

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

205

self.using_timer(False)

206

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

207

# ' was successful'

208

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

160

209

self.update()

161

210

return

162

211

# Checker failed

163

212

if not self.last_checker_failed:

164

213

self.last_checker_failed = True

165

self._update_timer_callback_tag = (gobject.timeout_add

166

(1000,

167

self.update_timer))

214

self.using_timer(True)

168

215

if os.WIFEXITED(condition):

169

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

170

u' failed with exit code %s'

171

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

216

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

217

' failed with exit code %s'

218

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

172

219

os.WEXITSTATUS(condition)))

173

220

elif os.WIFSIGNALED(condition):

174

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

175

u' was killed by signal %s'

176

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

221

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

222

' was killed by signal %s'

223

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

177

224

os.WTERMSIG(condition)))

178

225

elif os.WCOREDUMP(condition):

179

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

180

u' dumped core'

181

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

226

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

227

' dumped core'

228

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

182

229

else:

183

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

230

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

231

' mysteriously')

184

232

self.update()

185

233

186

234

def checker_started(self, command):

187

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

188

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

235

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

236

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

189

237

pass

190

238

191

239

def got_secret(self):

192

240

self.last_checker_failed = False

193

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

194

% self.properties[u"name"])

241

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

242

% self.properties["Name"])

195

243

196

244

def need_approval(self, timeout, default):

197

245

if not default:

198

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

246

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

199

247

else:

200

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

248

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

201

249

self.logger(message

202

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

250

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

251

self.using_timer(True)

203

252

204

253

def rejected(self, reason):

205

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

206

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

254

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

255

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

207

256

208

257

def selectable(self):

209

258

"""Make this a "selectable" widget.

210

259

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

211

260

return True

212

261

213

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

262

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

214

263

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

215

264

whether we have focus or not.

216

265

This overrides the method from urwid.FlowWidget"""

217

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

266

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

218

267

219

268

def current_widget(self, focus=False):

220

269

if focus or self.opened:

224

273

def update(self):

225

274

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

226

275

# How to add standout mode to a style

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

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

233

282

}

234

283

235

284

# Rebuild focus and non-focus widgets using current properties

236

285

237

286

# Base part of a client. Name!

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

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]

247

307

elif self.last_checker_failed:

248

308

timeout = datetime.timedelta(milliseconds

249

= self.properties[u"timeout"])

309

= self.properties

310

["Timeout"])

250

311

last_ok = isoformat_to_datetime(

251

max((self.properties["last_checked_ok"]

252

or self.properties["created"]),

253

self.properties[u"last_enabled"]))

312

max((self.properties["LastCheckedOK"]

313

or self.properties["Created"]),

314

self.properties["LastEnabled"]))

254

315

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

255

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

316

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

317

' gets disabled: %s'

256

318

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

257

319

else:

258

message = u"enabled"

320

message = "enabled"

259

321

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

260

322

261

323

if not urwid.supports_unicode():

262

324

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

263

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

325

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

264

326

self._text_widget.set_text(textlist)

265

327

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

266

328

text[1])

286

348

if self.delete_hook is not None:

287

349

self.delete_hook(self)

288

350

289

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

351

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

290

352

"""Render differently if we have focus.

291

353

This overrides the method from urwid.FlowWidget"""

292

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

354

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

293

355

focus=focus)

294

356

295

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

357

def keypress(self, maxcolrow, key):

296

358

"""Handle keys.

297

359

This overrides the method from urwid.FlowWidget"""

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

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

303

367

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

304

dbus_interface = client_interface)

305

elif key == u"d":

368

dbus_interface = client_interface,

369

ignore_reply=True)

370

elif key == "d":

306

371

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

307

dbus_interface = client_interface)

308

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

372

dbus_interface = client_interface,

373

ignore_reply=True)

374

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

309

375

self.server_proxy_object.RemoveClient(self.proxy

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)

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)

317

387

# xxx

318

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

388

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

319

389

# self.proxy.pause()

320

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

390

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

321

391

# self.proxy.unpause()

322

# elif key == u"RET":

392

# elif key == "RET":

323

393

# self.open()

324

# elif key == u"+":

325

# self.proxy.Approve(True)

326

# elif key == u"-":

327

# self.proxy.Approve(False)

328

394

else:

329

395

return key

330

396

345

411

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

346

412

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

347

413

"""

348

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

349

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

350

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

414

def keypress(self, maxcolrow, key):

415

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

416

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

351

417

return

352

418

return ret

353

419

362

428

self.screen = urwid.curses_display.Screen()

363

429

364

430

self.screen.register_palette((

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

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

382

448

))

383

449

384

450

if urwid.supports_unicode():

385

self.divider = u"─" # \u2500

386

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

451

self.divider = "─" # \u2500

452

#self.divider = "━" # \u2501

387

453

else:

388

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

389

self.divider = u"_" # \u005f

454

#self.divider = "-" # \u002d

455

self.divider = "_" # \u005f

390

456

391

457

self.screen.start()

392

458

406

472

# This keeps track of whether self.uilist currently has

407

473

# self.logbox in it or not

408

474

self.log_visible = True

409

self.log_wrap = u"any"

475

self.log_wrap = "any"

410

476

411

477

self.rebuild()

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

478

self.log_message_raw(("bold",

479

"Mandos Monitor version " + version))

480

self.log_message_raw(("bold",

481

"q: Quit ?: Help"))

416

482

417

483

self.busname = domain + '.Mandos'

418

484

self.main_loop = gobject.MainLoop()

419

485

self.bus = dbus.SystemBus()

420

486

mandos_dbus_objc = self.bus.get_object(

421

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

487

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

422

488

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

423

489

dbus_interface

424

490

= server_interface)

429

495

mandos_clients = dbus.Dictionary()

430

496

431

497

(self.mandos_serv

432

.connect_to_signal(u"ClientRemoved",

498

.connect_to_signal("ClientRemoved",

433

499

self.find_and_remove_client,

434

500

dbus_interface=server_interface,

435

501

byte_arrays=True))

436

502

(self.mandos_serv

437

.connect_to_signal(u"ClientAdded",

503

.connect_to_signal("ClientAdded",

438

504

self.add_new_client,

439

505

dbus_interface=server_interface,

440

506

byte_arrays=True))

441

507

(self.mandos_serv

442

.connect_to_signal(u"ClientNotFound",

508

.connect_to_signal("ClientNotFound",

443

509

self.client_not_found,

444

510

dbus_interface=server_interface,

445

511

byte_arrays=True))

460

526

path=path)

461

527

462

528

def client_not_found(self, fingerprint, address):

463

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

464

u" could not be found" % (address,

529

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

530

" could not be found" % (address,

465

531

fingerprint)))

466

532

467

533

def rebuild(self):

469

535

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

470

536

self.uilist = []

471

537

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

472

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

538

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

539

clients),

473

540

#header=urwid.Divider(),

474

541

header=None,

475

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

542

footer=

543

urwid.Divider(div_char=

544

self.divider)))

476

545

if self.log_visible:

477

546

self.uilist.append(self.logbox)

478

547

pass

480

549

481

550

def log_message(self, message):

482

551

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

483

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

552

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

484

553

485

554

def log_message_raw(self, markup):

486

555

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

489

558

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

490

559

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

491

560

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

492

coming_from=u"above")

561

coming_from="above")

493

562

self.refresh()

494

563

495

564

def toggle_log_display(self):

496

565

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

497

566

self.log_visible = not self.log_visible

498

567

self.rebuild()

499

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

500

+ unicode(self.log_visible))

568

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

569

# + unicode(self.log_visible))

501

570

502

571

def change_log_display(self):

503

572

"""Change type of log display.

504

573

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

505

if self.log_wrap == u"clip":

506

self.log_wrap = u"any"

574

if self.log_wrap == "clip":

575

self.log_wrap = "any"

507

576

else:

508

self.log_wrap = u"clip"

577

self.log_wrap = "clip"

509

578

for textwidget in self.log:

510

579

textwidget.set_wrap_mode(self.log_wrap)

511

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

580

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

512

581

513

582

def find_and_remove_client(self, path, name):

514

583

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

541

610

if path is None:

542

611

path = client.proxy.object_path

543

612

self.clients_dict[path] = client

544

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

613

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

545

614

self.refresh()

546

615

547

616

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

578

647

579

648

def process_input(self, source, condition):

580

649

keys = self.screen.get_input()

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

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

590

659

}

591

660

for key in keys:

592

661

try:

594

663

except KeyError: # :-)

595

664

pass

596

665

597

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

666

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

598

667

self.stop()

599

668

break

600

elif key == u"window resize":

669

elif key == "window resize":

601

670

self.size = self.screen.get_cols_rows()

602

671

self.refresh()

603

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

672

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

604

673

self.refresh()

605

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

674

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

606

675

self.toggle_log_display()

607

676

self.refresh()

608

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

677

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

609

678

self.change_log_display()

610

679

self.refresh()

611

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

680

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

612

681

if not self.log_visible:

613

682

self.log_visible = True

614

683

self.rebuild()

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

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

633

702

self.refresh()

634

elif key == u"tab":

703

elif key == "tab":

635

704

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

636

705

self.topwidget.set_focus(0)

637

706

else:

638

707

self.topwidget.set_focus(self.logbox)

639

708

self.refresh()

640

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

641

# or key == u">"):

709

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

710

# or key == ">"):

642

711

# pass # xxx end-of-buffer

643

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

644

# or key == u"<"):

712

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

713

# or key == "<"):

645

714

# pass # xxx beginning-of-buffer

646

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

715

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

647

716

# pass # xxx move-end-of-line

648

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

717

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

649

718

# pass # xxx move-beginning-of-line

650

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

719

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

651

720

# pass # xxx left

652

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

721

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

653

722

# pass # xxx right

654

#elif key == u"a":

723

#elif key == "a":

655

724

# pass # scroll up log

656

#elif key == u"z":

725

#elif key == "z":

657

726

# pass # scroll down log

658

727

elif self.topwidget.selectable():

659

728

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