/mandos/release : revision 237.7.19

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.2.3"

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

360

if key == "+":

299

361

self.proxy.Enable(dbus_interface = client_interface)

300

elif key == u"-":

362

elif key == "-":

301

363

self.proxy.Disable(dbus_interface = client_interface)

302

elif key == u"a":

364

elif key == "a":

303

365

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

304

366

dbus_interface = client_interface)

305

elif key == u"d":

367

elif key == "d":

306

368

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

307

369

dbus_interface = client_interface)

308

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

370

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

309

371

self.server_proxy_object.RemoveClient(self.proxy

310

372

.object_path)

311

elif key == u"s":

373

elif key == "s":

312

374

self.proxy.StartChecker(dbus_interface = client_interface)

313

elif key == u"S":

375

elif key == "S":

314

376

self.proxy.StopChecker(dbus_interface = client_interface)

315

elif key == u"C":

377

elif key == "C":

316

378

self.proxy.CheckedOK(dbus_interface = client_interface)

317

379

# xxx

318

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

380

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

319

381

# self.proxy.pause()

320

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

382

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

321

383

# self.proxy.unpause()

322

# elif key == u"RET":

384

# elif key == "RET":

323

385

# self.open()

324

# elif key == u"+":

325

# self.proxy.Approve(True)

326

# elif key == u"-":

327

# self.proxy.Approve(False)

328

386

else:

329

387

return key

330

388

345

403

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

346

404

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

347

405

"""

348

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

349

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

350

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

406

def keypress(self, maxcolrow, key):

407

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

408

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

351

409

return

352

410

return ret

353

411

362

420

self.screen = urwid.curses_display.Screen()

363

421

364

422

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

423

("normal",

424

"default", "default", None),

425

("bold",

426

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

427

("underline-blink",

428

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

429

("standout",

430

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

431

("bold-underline-blink",

432

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

433

("bold-standout",

434

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

435

("underline-blink-standout",

436

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

437

("bold-underline-blink-standout",

438

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

439

"standout")),

382

440

))

383

441

384

442

if urwid.supports_unicode():

385

self.divider = u"─" # \u2500

386

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

443

self.divider = "─" # \u2500

444

#self.divider = "━" # \u2501

387

445

else:

388

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

389

self.divider = u"_" # \u005f

446

#self.divider = "-" # \u002d

447

self.divider = "_" # \u005f

390

448

391

449

self.screen.start()

392

450

406

464

# This keeps track of whether self.uilist currently has

407

465

# self.logbox in it or not

408

466

self.log_visible = True

409

self.log_wrap = u"any"

467

self.log_wrap = "any"

410

468

411

469

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

470

self.log_message_raw(("bold",

471

"Mandos Monitor version " + version))

472

self.log_message_raw(("bold",

473

"q: Quit ?: Help"))

416

474

417

475

self.busname = domain + '.Mandos'

418

476

self.main_loop = gobject.MainLoop()

419

477

self.bus = dbus.SystemBus()

420

478

mandos_dbus_objc = self.bus.get_object(

421

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

479

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

422

480

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

423

481

dbus_interface

424

482

= server_interface)

429

487

mandos_clients = dbus.Dictionary()

430

488

431

489

(self.mandos_serv

432

.connect_to_signal(u"ClientRemoved",

490

.connect_to_signal("ClientRemoved",

433

491

self.find_and_remove_client,

434

492

dbus_interface=server_interface,

435

493

byte_arrays=True))

436

494

(self.mandos_serv

437

.connect_to_signal(u"ClientAdded",

495

.connect_to_signal("ClientAdded",

438

496

self.add_new_client,

439

497

dbus_interface=server_interface,

440

498

byte_arrays=True))

441

499

(self.mandos_serv

442

.connect_to_signal(u"ClientNotFound",

500

.connect_to_signal("ClientNotFound",

443

501

self.client_not_found,

444

502

dbus_interface=server_interface,

445

503

byte_arrays=True))

460

518

path=path)

461

519

462

520

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,

521

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

522

" could not be found" % (address,

465

523

fingerprint)))

466

524

467

525

def rebuild(self):

469

527

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

470

528

self.uilist = []

471

529

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

472

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

530

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

531

clients),

473

532

#header=urwid.Divider(),

474

533

header=None,

475

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

534

footer=

535

urwid.Divider(div_char=

536

self.divider)))

476

537

if self.log_visible:

477

538

self.uilist.append(self.logbox)

478

539

pass

480

541

481

542

def log_message(self, message):

482

543

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

483

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

544

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

484

545

485

546

def log_message_raw(self, markup):

486

547

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

489

550

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

490

551

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

491

552

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

492

coming_from=u"above")

553

coming_from="above")

493

554

self.refresh()

494

555

495

556

def toggle_log_display(self):

496

557

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

497

558

self.log_visible = not self.log_visible

498

559

self.rebuild()

499

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

500

+ unicode(self.log_visible))

560

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

561

# + unicode(self.log_visible))

501

562

502

563

def change_log_display(self):

503

564

"""Change type of log display.

504

565

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

505

if self.log_wrap == u"clip":

506

self.log_wrap = u"any"

566

if self.log_wrap == "clip":

567

self.log_wrap = "any"

507

568

else:

508

self.log_wrap = u"clip"

569

self.log_wrap = "clip"

509

570

for textwidget in self.log:

510

571

textwidget.set_wrap_mode(self.log_wrap)

511

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

572

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

512

573

513

574

def find_and_remove_client(self, path, name):

514

575

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

541

602

if path is None:

542

603

path = client.proxy.object_path

543

604

self.clients_dict[path] = client

544

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

605

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

545

606

self.refresh()

546

607

547

608

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

578

639

579

640

def process_input(self, source, condition):

580

641

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

642

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

643

"ctrl p": "up", # Emacs

644

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

645

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

646

" ": "page down", # less

647

"f": "page down", # less

648

"b": "page up", # less

649

"j": "down", # vi

650

"k": "up", # vi

590

651

}

591

652

for key in keys:

592

653

try:

594

655

except KeyError: # :-)

595

656

pass

596

657

597

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

658

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

598

659

self.stop()

599

660

break

600

elif key == u"window resize":

661

elif key == "window resize":

601

662

self.size = self.screen.get_cols_rows()

602

663

self.refresh()

603

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

664

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

604

665

self.refresh()

605

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

666

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

606

667

self.toggle_log_display()

607

668

self.refresh()

608

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

669

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

609

670

self.change_log_display()

610

671

self.refresh()

611

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

672

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

612

673

if not self.log_visible:

613

674

self.log_visible = True

614

675

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

676

self.log_message_raw(("bold",

677

" ".

678

join(("q: Quit",

679

"?: Help",

680

"l: Log window toggle",

681

"TAB: Switch window",

682

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

683

self.log_message_raw(("bold",

684

" "

685

.join(("Clients:",

686

"+: Enable",

687

"-: Disable",

688

"R: Remove",

689

"s: Start new checker",

690

"S: Stop checker",

691

"C: Checker OK",

692

"a: Approve",

693

"d: Deny"))))

633

694

self.refresh()

634

elif key == u"tab":

695

elif key == "tab":

635

696

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

636

697

self.topwidget.set_focus(0)

637

698

else:

638

699

self.topwidget.set_focus(self.logbox)

639

700

self.refresh()

640

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

641

# or key == u">"):

701

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

702

# or key == ">"):

642

703

# pass # xxx end-of-buffer

643

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

644

# or key == u"<"):

704

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

705

# or key == "<"):

645

706

# pass # xxx beginning-of-buffer

646

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

707

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

647

708

# pass # xxx move-end-of-line

648

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

709

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

649

710

# pass # xxx move-beginning-of-line

650

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

711

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

651

712

# pass # xxx left

652

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

713

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

653

714

# pass # xxx right

654

#elif key == u"a":

715

#elif key == "a":

655

716

# pass # scroll up log

656

#elif key == u"z":

717

#elif key == "z":

657

718

# pass # scroll down log

658

719

elif self.topwidget.selectable():

659

720

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