/mandos/release : revision 24.1.185

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

# elif key == u"+":

329

# self.proxy.Approve(True)

330

# elif key == u"-":

331

# self.proxy.Approve(False)

332

409

else:

333

410

return key

334

411

349

426

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

350

427

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

351

428

"""

352

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

353

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

354

maxrow), key)

355

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

356

432

return

357

433

return ret

358

434

367

443

self.screen = urwid.curses_display.Screen()

368

444

369

445

self.screen.register_palette((

370

(u"normal",

371

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

372

(u"bold",

373

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

374

(u"underline-blink",

375

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

376

(u"standout",

377

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

378

(u"bold-underline-blink",

379

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

380

(u"bold-standout",

381

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

382

(u"underline-blink-standout",

383

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

384

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

385

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

386

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

387

463

))

388

464

389

465

if urwid.supports_unicode():

390

self.divider = u"─" # \u2500

391

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

466

self.divider = "─" # \u2500

467

#self.divider = "━" # \u2501

392

468

else:

393

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

394

self.divider = u"_" # \u005f

469

#self.divider = "-" # \u002d

470

self.divider = "_" # \u005f

395

471

396

472

self.screen.start()

397

473

411

487

# This keeps track of whether self.uilist currently has

412

488

# self.logbox in it or not

413

489

self.log_visible = True

414

self.log_wrap = u"any"

490

self.log_wrap = "any"

415

491

416

492

self.rebuild()

417

self.log_message_raw((u"bold",

418

u"Mandos Monitor version " + version))

419

self.log_message_raw((u"bold",

420

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

421

497

422

498

self.busname = domain + '.Mandos'

423

499

self.main_loop = gobject.MainLoop()

424

500

self.bus = dbus.SystemBus()

425

501

mandos_dbus_objc = self.bus.get_object(

426

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

502

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

427

503

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

428

504

dbus_interface

429

505

= server_interface)

434

510

mandos_clients = dbus.Dictionary()

435

511

436

512

(self.mandos_serv

437

.connect_to_signal(u"ClientRemoved",

513

.connect_to_signal("ClientRemoved",

438

514

self.find_and_remove_client,

439

515

dbus_interface=server_interface,

440

516

byte_arrays=True))

441

517

(self.mandos_serv

442

.connect_to_signal(u"ClientAdded",

518

.connect_to_signal("ClientAdded",

443

519

self.add_new_client,

444

520

dbus_interface=server_interface,

445

521

byte_arrays=True))

446

522

(self.mandos_serv

447

.connect_to_signal(u"ClientNotFound",

523

.connect_to_signal("ClientNotFound",

448

524

self.client_not_found,

449

525

dbus_interface=server_interface,

450

526

byte_arrays=True))

465

541

path=path)

466

542

467

543

def client_not_found(self, fingerprint, address):

468

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

469

u" could not be found" % (address,

544

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

545

" could not be found" % (address,

470

546

fingerprint)))

471

547

472

548

def rebuild(self):

488

564

489

565

def log_message(self, message):

490

566

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

491

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

567

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

492

568

493

569

def log_message_raw(self, markup):

494

570

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

497

573

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

498

574

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

499

575

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

500

coming_from=u"above")

576

coming_from="above")

501

577

self.refresh()

502

578

503

579

def toggle_log_display(self):

504

580

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

505

581

self.log_visible = not self.log_visible

506

582

self.rebuild()

507

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

508

+ unicode(self.log_visible))

583

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

584

# + unicode(self.log_visible))

509

585

510

586

def change_log_display(self):

511

587

"""Change type of log display.

512

588

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

513

if self.log_wrap == u"clip":

514

self.log_wrap = u"any"

589

if self.log_wrap == "clip":

590

self.log_wrap = "any"

515

591

else:

516

self.log_wrap = u"clip"

592

self.log_wrap = "clip"

517

593

for textwidget in self.log:

518

594

textwidget.set_wrap_mode(self.log_wrap)

519

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

595

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

520

596

521

597

def find_and_remove_client(self, path, name):

522

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

598

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

523

599

524

600

This is connected to the ClientRemoved signal from the

525

601

Mandos server object."""

527

603

client = self.clients_dict[path]

528

604

except KeyError:

529

605

# not found?

606

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

607

path)

530

608

return

531

self.remove_client(client, path)

609

client.delete()

532

610

533

611

def add_new_client(self, path):

534

612

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

549

627

if path is None:

550

628

path = client.proxy.object_path

551

629

self.clients_dict[path] = client

552

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

630

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

553

631

self.refresh()

554

632

555

633

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

586

664

587

665

def process_input(self, source, condition):

588

666

keys = self.screen.get_input()

589

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

590

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

591

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

592

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

593

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

594

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

595

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

596

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

597

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

598

676

}

599

677

for key in keys:

600

678

try:

602

680

except KeyError: # :-)

603

681

pass

604

682

605

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

683

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

606

684

self.stop()

607

685

break

608

elif key == u"window resize":

686

elif key == "window resize":

609

687

self.size = self.screen.get_cols_rows()

610

688

self.refresh()

611

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

689

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

612

690

self.refresh()

613

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

691

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

614

692

self.toggle_log_display()

615

693

self.refresh()

616

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

694

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

617

695

self.change_log_display()

618

696

self.refresh()

619

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

697

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

620

698

if not self.log_visible:

621

699

self.log_visible = True

622

700

self.rebuild()

623

self.log_message_raw((u"bold",

624

u" ".

625

join((u"q: Quit",

626

u"?: Help",

627

u"l: Log window toggle",

628

u"TAB: Switch window",

629

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

630

self.log_message_raw((u"bold",

631

u" "

632

.join((u"Clients:",

633

u"+: Enable",

634

u"-: Disable",

635

u"r: Remove",

636

u"s: Start new checker",

637

u"S: Stop checker",

638

u"C: Checker OK",

639

u"a: Approve",

640

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

641

719

self.refresh()

642

elif key == u"tab":

720

elif key == "tab":

643

721

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

644

722

self.topwidget.set_focus(0)

645

723

else:

646

724

self.topwidget.set_focus(self.logbox)

647

725

self.refresh()

648

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

649

# or key == u">"):

726

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

727

# or key == ">"):

650

728

# pass # xxx end-of-buffer

651

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

652

# or key == u"<"):

729

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

730

# or key == "<"):

653

731

# pass # xxx beginning-of-buffer

654

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

732

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

655

733

# pass # xxx move-end-of-line

656

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

734

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

657

735

# pass # xxx move-beginning-of-line

658

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

736

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

659

737

# pass # xxx left

660

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

738

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

661

739

# pass # xxx right

662

#elif key == u"a":

740

#elif key == "a":

663

741

# pass # scroll up log

664

#elif key == u"z":

742

#elif key == "z":

665

743

# pass # scroll down log

666

744

elif self.topwidget.selectable():

667

745

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