/mandos/release : revision 237.7.50

1

#!/usr/bin/python

2

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

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

5

#

6

7

8

#

9

# This program is free software: you can redistribute it and/or modify

10

# it under the terms of the GNU General Public License as published by

11

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

12

# (at your option) any later version.

13

#

14

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

15

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

16

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

17

# GNU General Public License for more details.

18

#

19

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

20

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

21

#

22

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

23

#

3

24

4

from __future__ import division, absolute_import, with_statement

25

from __future__ import (division, absolute_import, print_function,

26

unicode_literals)

5

27

6

28

import sys

7

29

import os

21

43

22

44

import locale

23

45

24

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

46

locale.setlocale(locale.LC_ALL, '')

25

47

26

48

import logging

27

49

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

30

52

domain = 'se.bsnet.fukt'

31

53

server_interface = domain + '.Mandos'

32

54

client_interface = domain + '.Mandos.Client'

33

version = "1.0.15"

55

version = "1.3.1"

34

56

35

57

# Always run in monochrome mode

36

58

urwid.curses_display.curses.has_colors = lambda : False

44

66

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

45

67

if not iso:

46

68

return None

47

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

48

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

49

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

69

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

70

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

71

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

50

72

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

51

73

return datetime.datetime(int(year),

52

74

int(month),

65

87

self.proxy = proxy_object # Mandos Client proxy object

66

88

67

89

self.properties = dict()

68

self.proxy.connect_to_signal(u"PropertyChanged",

69

self.property_changed,

70

client_interface,

71

byte_arrays=True)

90

self.property_changed_match = (

91

self.proxy.connect_to_signal("PropertyChanged",

92

self.property_changed,

93

client_interface,

94

byte_arrays=True))

72

95

73

96

self.properties.update(

74

97

self.proxy.GetAll(client_interface,

75

98

dbus_interface = dbus.PROPERTIES_IFACE))

76

99

77

#XXX This break good super behaviour!

100

#XXX This breaks good super behaviour

78

101

# super(MandosClientPropertyCache, self).__init__(

79

102

# *args, **kwargs)

80

103

84

107

"""

85

108

# Update properties dict with new value

86

109

self.properties[property] = value

110

111

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

112

self.property_changed_match.remove()

113

super(MandosClientPropertyCache, self).__init__(

114

*args, **kwargs)

87

115

88

116

89

117

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

102

130

self.logger = logger

103

131

104

132

self._update_timer_callback_tag = None

133

self._update_timer_callback_lock = 0

105

134

self.last_checker_failed = False

106

135

107

136

# The widget shown normally

108

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

137

self._text_widget = urwid.Text("")

109

138

# The widget shown when we have focus

110

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

139

self._focus_text_widget = urwid.Text("")

111

140

super(MandosClientWidget, self).__init__(

112

141

update_hook=update_hook, delete_hook=delete_hook,

113

142

*args, **kwargs)

114

143

self.update()

115

144

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)

145

136

146

last_checked_ok = isoformat_to_datetime(self.properties

137

[u"LastCheckedOK"])

147

["LastCheckedOK"])

138

148

if last_checked_ok is None:

139

149

self.last_checker_failed = True

140

150

else:

143

153

> datetime.timedelta

144

154

(milliseconds=

145

155

self.properties

146

[u"Interval"]))

156

["Interval"]))

157

147

158

if self.last_checker_failed:

159

self.using_timer(True)

160

161

if self.need_approval:

162

self.using_timer(True)

163

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

186

187

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

188

super(self, MandosClientWidget).property_changed(property,

189

value)

190

if property == "ApprovalPending":

191

using_timer(bool(value))

192

193

def using_timer(self, flag):

194

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

195

activated or deactivated.

196

"""

197

old = self._update_timer_callback_lock

198

if flag:

199

self._update_timer_callback_lock += 1

200

else:

201

self._update_timer_callback_lock -= 1

202

if old == 0 and self._update_timer_callback_lock:

203

# Will update the shown timer value every second

148

204

self._update_timer_callback_tag = (gobject.timeout_add

149

205

(1000,

150

206

self.update_timer))

207

elif old and self._update_timer_callback_lock == 0:

208

gobject.source_remove(self._update_timer_callback_tag)

209

self._update_timer_callback_tag = None

151

210

152

211

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

153

212

if exitstatus == 0:

154

213

if self.last_checker_failed:

155

214

self.last_checker_failed = False

156

gobject.source_remove(self._update_timer_callback_tag)

157

self._update_timer_callback_tag = None

158

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

159

# u' was successful'

160

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

215

self.using_timer(False)

216

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

217

# ' was successful'

218

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

161

219

self.update()

162

220

return

163

221

# Checker failed

164

222

if not self.last_checker_failed:

165

223

self.last_checker_failed = True

166

self._update_timer_callback_tag = (gobject.timeout_add

167

(1000,

168

self.update_timer))

224

self.using_timer(True)

169

225

if os.WIFEXITED(condition):

170

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

171

u' failed with exit code %s'

172

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

173

229

os.WEXITSTATUS(condition)))

174

230

elif os.WIFSIGNALED(condition):

175

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

176

u' was killed by signal %s'

177

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

178

234

os.WTERMSIG(condition)))

179

235

elif os.WCOREDUMP(condition):

180

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

181

u' dumped core'

182

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

236

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

237

' dumped core'

238

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

183

239

else:

184

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

185

u' mysteriously')

240

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

241

' mysteriously')

186

242

self.update()

187

243

188

244

def checker_started(self, command):

189

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

190

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

245

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

246

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

191

247

pass

192

248

193

249

def got_secret(self):

194

250

self.last_checker_failed = False

195

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

196

% self.properties[u"Name"])

251

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

252

% self.properties["Name"])

197

253

198

254

def need_approval(self, timeout, default):

199

255

if not default:

200

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

256

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

201

257

else:

202

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

258

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

203

259

self.logger(message

204

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

260

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

261

self.using_timer(True)

205

262

206

263

def rejected(self, reason):

207

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

208

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

264

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

265

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

209

266

210

267

def selectable(self):

211

268

"""Make this a "selectable" widget.

212

269

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

213

270

return True

214

271

215

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

272

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

216

273

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

217

274

whether we have focus or not.

218

275

This overrides the method from urwid.FlowWidget"""

219

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

276

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

220

277

221

278

def current_widget(self, focus=False):

222

279

if focus or self.opened:

226

283

def update(self):

227

284

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

228

285

# How to add standout mode to a style

229

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

230

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

231

u"underline-blink":

232

u"underline-blink-standout",

233

u"bold-underline-blink":

234

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

235

292

}

236

293

237

294

# Rebuild focus and non-focus widgets using current properties

238

295

239

296

# Base part of a client. Name!

240

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

241

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

242

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

243

message = u"DISABLED"

244

elif self.properties[u"ApprovalPending"]:

245

if self.properties[u"ApprovedByDefault"]:

246

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

247

else:

248

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

249

elif self.last_checker_failed:

297

base = ('%(name)s: '

298

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

299

if not self.properties["Enabled"]:

300

message = "DISABLED"

301

elif self.properties["ApprovalPending"]:

250

302

timeout = datetime.timedelta(milliseconds

251

303

= self.properties

252

[u"Timeout"])

253

last_ok = isoformat_to_datetime(

254

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

255

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

256

self.properties[u"LastEnabled"]))

257

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

258

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

259

u' gets diabled: %s'

304

["ApprovalDelay"])

305

last_approval_request = isoformat_to_datetime(

306

self.properties["LastApprovalRequest"])

307

if last_approval_request is not None:

308

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

309

- last_approval_request)

310

else:

311

timer = datetime.timedelta()

312

if self.properties["ApprovedByDefault"]:

313

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

314

else:

315

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

316

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

317

elif self.last_checker_failed:

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'

260

328

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

261

329

else:

262

message = u"enabled"

330

message = "enabled"

263

331

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

264

332

265

333

if not urwid.supports_unicode():

266

334

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

267

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

335

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

268

336

self._text_widget.set_text(textlist)

269

337

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

270

338

text[1])

279

347

self.update_hook()

280

348

281

349

def update_timer(self):

282

"called by gobject"

350

"""called by gobject. Will indefinitely loop until

351

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

283

352

self.update()

284

353

return True # Keep calling this

285

354

286

def delete(self):

355

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

287

356

if self._update_timer_callback_tag is not None:

288

357

gobject.source_remove(self._update_timer_callback_tag)

289

358

self._update_timer_callback_tag = None

359

for match in self.match_objects:

360

match.remove()

361

self.match_objects = ()

290

362

if self.delete_hook is not None:

291

363

self.delete_hook(self)

364

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

292

365

293

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

366

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

294

367

"""Render differently if we have focus.

295

368

This overrides the method from urwid.FlowWidget"""

296

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

369

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

297

370

focus=focus)

298

371

299

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

372

def keypress(self, maxcolrow, key):

300

373

"""Handle keys.

301

374

This overrides the method from urwid.FlowWidget"""

302

if key == u"+":

303

self.proxy.Enable(dbus_interface = client_interface)

304

elif key == u"-":

305

self.proxy.Disable(dbus_interface = client_interface)

306

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

307

382

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

308

dbus_interface = client_interface)

309

elif key == u"d":

383

dbus_interface = client_interface,

384

ignore_reply=True)

385

elif key == "d":

310

386

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

311

dbus_interface = client_interface)

312

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

313

390

self.server_proxy_object.RemoveClient(self.proxy

314

.object_path)

315

elif key == u"s":

316

self.proxy.StartChecker(dbus_interface = client_interface)

317

elif key == u"S":

318

self.proxy.StopChecker(dbus_interface = client_interface)

319

elif key == u"C":

320

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)

321

402

# xxx

322

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

403

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

323

404

# self.proxy.pause()

324

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

405

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

325

406

# self.proxy.unpause()

326

# elif key == u"RET":

407

# elif key == "RET":

327

408

# self.open()

328

409

else:

329

410

return key

345

426

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

346

427

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

347

428

"""

348

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

349

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

350

maxrow), key)

351

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

352

432

return

353

433

return ret

354

434

363

443

self.screen = urwid.curses_display.Screen()

364

444

365

445

self.screen.register_palette((

366

(u"normal",

367

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

368

(u"bold",

369

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

370

(u"underline-blink",

371

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

372

(u"standout",

373

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

374

(u"bold-underline-blink",

375

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

376

(u"bold-standout",

377

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

378

(u"underline-blink-standout",

379

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

380

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

381

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

382

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

383

463

))

384

464

385

465

if urwid.supports_unicode():

386

self.divider = u"─" # \u2500

387

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

466

self.divider = "─" # \u2500

467

#self.divider = "━" # \u2501

388

468

else:

389

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

390

self.divider = u"_" # \u005f

469

#self.divider = "-" # \u002d

470

self.divider = "_" # \u005f

391

471

392

472

self.screen.start()

393

473

407

487

# This keeps track of whether self.uilist currently has

408

488

# self.logbox in it or not

409

489

self.log_visible = True

410

self.log_wrap = u"any"

490

self.log_wrap = "any"

411

491

412

492

self.rebuild()

413

self.log_message_raw((u"bold",

414

u"Mandos Monitor version " + version))

415

self.log_message_raw((u"bold",

416

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

417

497

418

498

self.busname = domain + '.Mandos'

419

499

self.main_loop = gobject.MainLoop()

420

500

self.bus = dbus.SystemBus()

421

501

mandos_dbus_objc = self.bus.get_object(

422

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

502

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

423

503

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

424

504

dbus_interface

425

505

= server_interface)

430

510

mandos_clients = dbus.Dictionary()

431

511

432

512

(self.mandos_serv

433

.connect_to_signal(u"ClientRemoved",

513

.connect_to_signal("ClientRemoved",

434

514

self.find_and_remove_client,

435

515

dbus_interface=server_interface,

436

516

byte_arrays=True))

437

517

(self.mandos_serv

438

.connect_to_signal(u"ClientAdded",

518

.connect_to_signal("ClientAdded",

439

519

self.add_new_client,

440

520

dbus_interface=server_interface,

441

521

byte_arrays=True))

442

522

(self.mandos_serv

443

.connect_to_signal(u"ClientNotFound",

523

.connect_to_signal("ClientNotFound",

444

524

self.client_not_found,

445

525

dbus_interface=server_interface,

446

526

byte_arrays=True))

461

541

path=path)

462

542

463

543

def client_not_found(self, fingerprint, address):

464

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

465

u" could not be found" % (address,

544

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

545

" could not be found" % (address,

466

546

fingerprint)))

467

547

468

548

def rebuild(self):

484

564

485

565

def log_message(self, message):

486

566

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

487

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

567

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

488

568

489

569

def log_message_raw(self, markup):

490

570

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

493

573

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

494

574

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

495

575

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

496

coming_from=u"above")

576

coming_from="above")

497

577

self.refresh()

498

578

499

579

def toggle_log_display(self):

500

580

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

501

581

self.log_visible = not self.log_visible

502

582

self.rebuild()

503

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

583

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

504

584

# + unicode(self.log_visible))

505

585

506

586

def change_log_display(self):

507

587

"""Change type of log display.

508

588

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

509

if self.log_wrap == u"clip":

510

self.log_wrap = u"any"

589

if self.log_wrap == "clip":

590

self.log_wrap = "any"

511

591

else:

512

self.log_wrap = u"clip"

592

self.log_wrap = "clip"

513

593

for textwidget in self.log:

514

594

textwidget.set_wrap_mode(self.log_wrap)

515

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

595

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

516

596

517

597

def find_and_remove_client(self, path, name):

518

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

598

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

519

599

520

600

This is connected to the ClientRemoved signal from the

521

601

Mandos server object."""

523

603

client = self.clients_dict[path]

524

604

except KeyError:

525

605

# not found?

606

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

607

path)

526

608

return

527

self.remove_client(client, path)

609

client.delete()

528

610

529

611

def add_new_client(self, path):

530

612

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

545

627

if path is None:

546

628

path = client.proxy.object_path

547

629

self.clients_dict[path] = client

548

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

630

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

549

631

self.refresh()

550

632

551

633

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

582

664

583

665

def process_input(self, source, condition):

584

666

keys = self.screen.get_input()

585

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

586

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

587

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

588

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

589

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

590

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

591

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

592

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

593

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

594

676

}

595

677

for key in keys:

596

678

try:

598

680

except KeyError: # :-)

599

681

pass

600

682

601

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

683

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

602

684

self.stop()

603

685

break

604

elif key == u"window resize":

686

elif key == "window resize":

605

687

self.size = self.screen.get_cols_rows()

606

688

self.refresh()

607

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

689

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

608

690

self.refresh()

609

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

691

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

610

692

self.toggle_log_display()

611

693

self.refresh()

612

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

694

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

613

695

self.change_log_display()

614

696

self.refresh()

615

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

697

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

616

698

if not self.log_visible:

617

699

self.log_visible = True

618

700

self.rebuild()

619

self.log_message_raw((u"bold",

620

u" ".

621

join((u"q: Quit",

622

u"?: Help",

623

u"l: Log window toggle",

624

u"TAB: Switch window",

625

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

626

self.log_message_raw((u"bold",

627

u" "

628

.join((u"Clients:",

629

u"+: Enable",

630

u"-: Disable",

631

u"r: Remove",

632

u"s: Start new checker",

633

u"S: Stop checker",

634

u"C: Checker OK",

635

u"a: Approve",

636

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

637

719

self.refresh()

638

elif key == u"tab":

720

elif key == "tab":

639

721

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

640

722

self.topwidget.set_focus(0)

641

723

else:

642

724

self.topwidget.set_focus(self.logbox)

643

725

self.refresh()

644

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

645

# or key == u">"):

726

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

727

# or key == ">"):

646

728

# pass # xxx end-of-buffer

647

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

648

# or key == u"<"):

729

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

730

# or key == "<"):

649

731

# pass # xxx beginning-of-buffer

650

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

732

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

651

733

# pass # xxx move-end-of-line

652

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

734

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

653

735

# pass # xxx move-beginning-of-line

654

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

736

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

655

737

# pass # xxx left

656

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

738

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

657

739

# pass # xxx right

658

#elif key == u"a":

740

#elif key == "a":

659

741

# pass # scroll up log

660

#elif key == u"z":

742

#elif key == "z":

661

743

# pass # scroll down log

662

744

elif self.topwidget.selectable():

663

745

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