/mandos/release : revision 237.7.61

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@recompile.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)

28

50

29

51

# Some useful constants

30

domain = 'se.bsnet.fukt'

52

domain = 'se.recompile'

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

170

200

else:

171

201

self._update_timer_callback_lock -= 1

172

202

if old == 0 and self._update_timer_callback_lock:

203

# Will update the shown timer value every second

173

204

self._update_timer_callback_tag = (gobject.timeout_add

174

205

(1000,

175

206

self.update_timer))

182

213

if self.last_checker_failed:

183

214

self.last_checker_failed = False

184

215

self.using_timer(False)

185

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

186

# u' was successful'

187

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

216

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

217

# ' was successful'

218

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

188

219

self.update()

189

220

return

190

221

# Checker failed

192

223

self.last_checker_failed = True

193

224

self.using_timer(True)

194

225

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,

226

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

227

' failed with exit code %s'

228

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

198

229

os.WEXITSTATUS(condition)))

199

230

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,

231

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

232

' was killed by signal %s'

233

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

203

234

os.WTERMSIG(condition)))

204

235

elif os.WCOREDUMP(condition):

205

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

206

u' dumped core'

207

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

236

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

237

' dumped core'

238

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

208

239

else:

209

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

210

u' mysteriously')

240

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

241

' mysteriously')

211

242

self.update()

212

243

213

244

def checker_started(self, command):

214

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

215

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

245

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

246

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

216

247

pass

217

248

218

249

def got_secret(self):

219

250

self.last_checker_failed = False

220

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

221

% self.properties[u"Name"])

251

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

252

% self.properties["Name"])

222

253

223

254

def need_approval(self, timeout, default):

224

255

if not default:

225

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

256

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

226

257

else:

227

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

258

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

228

259

self.logger(message

229

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

260

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

230

261

self.using_timer(True)

231

262

232

263

def rejected(self, reason):

233

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

234

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

264

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

265

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

235

266

236

267

def selectable(self):

237

268

"""Make this a "selectable" widget.

238

269

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

239

270

return True

240

271

241

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

272

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

242

273

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

243

274

whether we have focus or not.

244

275

This overrides the method from urwid.FlowWidget"""

245

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

276

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

246

277

247

278

def current_widget(self, focus=False):

248

279

if focus or self.opened:

252

283

def update(self):

253

284

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

254

285

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

286

with_standout = { "normal": "standout",

287

"bold": "bold-standout",

288

"underline-blink":

289

"underline-blink-standout",

290

"bold-underline-blink":

291

"bold-underline-blink-standout",

261

292

}

262

293

263

294

# Rebuild focus and non-focus widgets using current properties

264

295

265

296

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

297

base = ('%(name)s: '

298

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

299

if not self.properties["Enabled"]:

300

message = "DISABLED"

301

elif self.properties["ApprovalPending"]:

271

302

timeout = datetime.timedelta(milliseconds

272

303

= self.properties

273

[u"ApprovalDelay"])

304

["ApprovalDelay"])

274

305

last_approval_request = isoformat_to_datetime(

275

self.properties[u"LastApprovalRequest"])

306

self.properties["LastApprovalRequest"])

276

307

if last_approval_request is not None:

277

308

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

278

309

- last_approval_request)

279

310

else:

280

311

timer = datetime.timedelta()

281

if self.properties[u"ApprovedByDefault"]:

282

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

312

if self.properties["ApprovedByDefault"]:

313

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

283

314

else:

284

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

315

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

285

316

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

286

317

elif self.last_checker_failed:

287

timeout = datetime.timedelta(milliseconds

288

= self.properties

289

[u"Timeout"])

290

last_ok = isoformat_to_datetime(

291

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

292

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

293

self.properties[u"LastEnabled"]))

294

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

295

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

296

u' gets disabled: %s'

318

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

319

expires = self.properties["Expires"]

320

if expires == "":

321

timer = datetime.timedelta(0)

322

else:

323

expires = datetime.datetime.strptime(expires,

324

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

325

timer = expires - datetime.datetime.utcnow()

326

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

327

' gets disabled: %s'

297

328

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

298

329

else:

299

message = u"enabled"

330

message = "enabled"

300

331

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

301

332

302

333

if not urwid.supports_unicode():

303

334

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

304

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

335

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

305

336

self._text_widget.set_text(textlist)

306

337

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

307

338

text[1])

316

347

self.update_hook()

317

348

318

349

def update_timer(self):

319

"called by gobject"

350

"""called by gobject. Will indefinitely loop until

351

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

320

352

self.update()

321

353

return True # Keep calling this

322

354

323

def delete(self):

355

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

324

356

if self._update_timer_callback_tag is not None:

325

357

gobject.source_remove(self._update_timer_callback_tag)

326

358

self._update_timer_callback_tag = None

359

for match in self.match_objects:

360

match.remove()

361

self.match_objects = ()

327

362

if self.delete_hook is not None:

328

363

self.delete_hook(self)

364

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

329

365

330

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

366

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

331

367

"""Render differently if we have focus.

332

368

This overrides the method from urwid.FlowWidget"""

333

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

369

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

334

370

focus=focus)

335

371

336

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

372

def keypress(self, maxcolrow, key):

337

373

"""Handle keys.

338

374

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

375

if key == "+":

376

self.proxy.Enable(dbus_interface = client_interface,

377

ignore_reply=True)

378

elif key == "-":

379

self.proxy.Disable(dbus_interface = client_interface,

380

ignore_reply=True)

381

elif key == "a":

344

382

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

345

dbus_interface = client_interface)

346

elif key == u"d":

383

dbus_interface = client_interface,

384

ignore_reply=True)

385

elif key == "d":

347

386

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

387

dbus_interface = client_interface,

388

ignore_reply=True)

389

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

350

390

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)

391

.object_path,

392

ignore_reply=True)

393

elif key == "s":

394

self.proxy.StartChecker(dbus_interface = client_interface,

395

ignore_reply=True)

396

elif key == "S":

397

self.proxy.StopChecker(dbus_interface = client_interface,

398

ignore_reply=True)

399

elif key == "C":

400

self.proxy.CheckedOK(dbus_interface = client_interface,

401

ignore_reply=True)

358

402

# xxx

359

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

403

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

360

404

# self.proxy.pause()

361

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

405

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

362

406

# self.proxy.unpause()

363

# elif key == u"RET":

407

# elif key == "RET":

364

408

# self.open()

365

409

else:

366

410

return key

382

426

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

383

427

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

384

428

"""

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

429

def keypress(self, maxcolrow, key):

430

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

431

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

389

432

return

390

433

return ret

391

434

400

443

self.screen = urwid.curses_display.Screen()

401

444

402

445

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

446

("normal",

447

"default", "default", None),

448

("bold",

449

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

450

("underline-blink",

451

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

452

("standout",

453

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

454

("bold-underline-blink",

455

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

456

("bold-standout",

457

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

458

("underline-blink-standout",

459

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

460

("bold-underline-blink-standout",

461

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

462

"standout")),

420

463

))

421

464

422

465

if urwid.supports_unicode():

423

self.divider = u"─" # \u2500

424

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

466

self.divider = "─" # \u2500

467

#self.divider = "━" # \u2501

425

468

else:

426

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

427

self.divider = u"_" # \u005f

469

#self.divider = "-" # \u002d

470

self.divider = "_" # \u005f

428

471

429

472

self.screen.start()

430

473

444

487

# This keeps track of whether self.uilist currently has

445

488

# self.logbox in it or not

446

489

self.log_visible = True

447

self.log_wrap = u"any"

490

self.log_wrap = "any"

448

491

449

492

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

493

self.log_message_raw(("bold",

494

"Mandos Monitor version " + version))

495

self.log_message_raw(("bold",

496

"q: Quit ?: Help"))

454

497

455

498

self.busname = domain + '.Mandos'

456

499

self.main_loop = gobject.MainLoop()

457

500

self.bus = dbus.SystemBus()

458

501

mandos_dbus_objc = self.bus.get_object(

459

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

502

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

460

503

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

461

504

dbus_interface

462

505

= server_interface)

467

510

mandos_clients = dbus.Dictionary()

468

511

469

512

(self.mandos_serv

470

.connect_to_signal(u"ClientRemoved",

513

.connect_to_signal("ClientRemoved",

471

514

self.find_and_remove_client,

472

515

dbus_interface=server_interface,

473

516

byte_arrays=True))

474

517

(self.mandos_serv

475

.connect_to_signal(u"ClientAdded",

518

.connect_to_signal("ClientAdded",

476

519

self.add_new_client,

477

520

dbus_interface=server_interface,

478

521

byte_arrays=True))

479

522

(self.mandos_serv

480

.connect_to_signal(u"ClientNotFound",

523

.connect_to_signal("ClientNotFound",

481

524

self.client_not_found,

482

525

dbus_interface=server_interface,

483

526

byte_arrays=True))

498

541

path=path)

499

542

500

543

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,

544

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

545

" could not be found" % (address,

503

546

fingerprint)))

504

547

505

548

def rebuild(self):

521

564

522

565

def log_message(self, message):

523

566

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

524

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

567

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

525

568

526

569

def log_message_raw(self, markup):

527

570

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

530

573

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

531

574

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

532

575

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

533

coming_from=u"above")

576

coming_from="above")

534

577

self.refresh()

535

578

536

579

def toggle_log_display(self):

537

580

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

538

581

self.log_visible = not self.log_visible

539

582

self.rebuild()

540

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

583

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

541

584

# + unicode(self.log_visible))

542

585

543

586

def change_log_display(self):

544

587

"""Change type of log display.

545

588

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

546

if self.log_wrap == u"clip":

547

self.log_wrap = u"any"

589

if self.log_wrap == "clip":

590

self.log_wrap = "any"

548

591

else:

549

self.log_wrap = u"clip"

592

self.log_wrap = "clip"

550

593

for textwidget in self.log:

551

594

textwidget.set_wrap_mode(self.log_wrap)

552

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

595

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

553

596

554

597

def find_and_remove_client(self, path, name):

555

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

598

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

556

599

557

600

This is connected to the ClientRemoved signal from the

558

601

Mandos server object."""

560

603

client = self.clients_dict[path]

561

604

except KeyError:

562

605

# not found?

606

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

607

path)

563

608

return

564

self.remove_client(client, path)

609

client.delete()

565

610

566

611

def add_new_client(self, path):

567

612

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

582

627

if path is None:

583

628

path = client.proxy.object_path

584

629

self.clients_dict[path] = client

585

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

630

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

586

631

self.refresh()

587

632

588

633

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

619

664

620

665

def process_input(self, source, condition):

621

666

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

667

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

668

"ctrl p": "up", # Emacs

669

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

670

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

671

" ": "page down", # less

672

"f": "page down", # less

673

"b": "page up", # less

674

"j": "down", # vi

675

"k": "up", # vi

631

676

}

632

677

for key in keys:

633

678

try:

635

680

except KeyError: # :-)

636

681

pass

637

682

638

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

683

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

639

684

self.stop()

640

685

break

641

elif key == u"window resize":

686

elif key == "window resize":

642

687

self.size = self.screen.get_cols_rows()

643

688

self.refresh()

644

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

689

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

645

690

self.refresh()

646

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

691

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

647

692

self.toggle_log_display()

648

693

self.refresh()

649

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

694

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

650

695

self.change_log_display()

651

696

self.refresh()

652

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

697

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

653

698

if not self.log_visible:

654

699

self.log_visible = True

655

700

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

701

self.log_message_raw(("bold",

702

" ".

703

join(("q: Quit",

704

"?: Help",

705

"l: Log window toggle",

706

"TAB: Switch window",

707

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

708

self.log_message_raw(("bold",

709

" "

710

.join(("Clients:",

711

"+: Enable",

712

"-: Disable",

713

"R: Remove",

714

"s: Start new checker",

715

"S: Stop checker",

716

"C: Checker OK",

717

"a: Approve",

718

"d: Deny"))))

674

719

self.refresh()

675

elif key == u"tab":

720

elif key == "tab":

676

721

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

677

722

self.topwidget.set_focus(0)

678

723

else:

679

724

self.topwidget.set_focus(self.logbox)

680

725

self.refresh()

681

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

682

# or key == u">"):

726

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

727

# or key == ">"):

683

728

# pass # xxx end-of-buffer

684

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

685

# or key == u"<"):

729

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

730

# or key == "<"):

686

731

# pass # xxx beginning-of-buffer

687

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

732

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

688

733

# pass # xxx move-end-of-line

689

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

734

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

690

735

# pass # xxx move-beginning-of-line

691

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

736

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

692

737

# pass # xxx left

693

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

738

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

694

739

# pass # xxx right

695

#elif key == u"a":

740

#elif key == "a":

696

741

# pass # scroll up log

697

#elif key == u"z":

742

#elif key == "z":

698

743

# pass # scroll down log

699

744

elif self.topwidget.selectable():

700

745

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