/mandos/trunk : revision 435

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

#

24

3

25

from __future__ import (division, absolute_import, print_function,

26

unicode_literals)

4

from __future__ import division, absolute_import, with_statement

27

5

28

6

import sys

29

7

import os

43

21

44

22

import locale

45

23

46

locale.setlocale(locale.LC_ALL, '')

24

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

47

25

48

26

import logging

49

27

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

52

30

domain = 'se.bsnet.fukt'

53

31

server_interface = domain + '.Mandos'

54

32

client_interface = domain + '.Mandos.Client'

55

version = "1.3.1"

33

version = "1.0.15"

56

34

57

35

# Always run in monochrome mode

58

36

urwid.curses_display.curses.has_colors = lambda : False

66

44

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

67

45

if not iso:

68

46

return None

69

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

70

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

71

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

47

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

48

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

49

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

72

50

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

73

51

return datetime.datetime(int(year),

74

52

int(month),

87

65

self.proxy = proxy_object # Mandos Client proxy object

88

66

89

67

self.properties = dict()

90

self.property_changed_match = (

91

self.proxy.connect_to_signal("PropertyChanged",

92

self.property_changed,

93

client_interface,

94

byte_arrays=True))

68

self.proxy.connect_to_signal(u"PropertyChanged",

69

self.property_changed,

70

client_interface,

71

byte_arrays=True)

95

72

96

73

self.properties.update(

97

74

self.proxy.GetAll(client_interface,

98

75

dbus_interface = dbus.PROPERTIES_IFACE))

99

76

100

#XXX This breaks good super behaviour

77

#XXX This break good super behaviour!

101

78

# super(MandosClientPropertyCache, self).__init__(

102

79

# *args, **kwargs)

103

80

107

84

"""

108

85

# Update properties dict with new value

109

86

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)

115

87

116

88

117

89

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

130

102

self.logger = logger

131

103

132

104

self._update_timer_callback_tag = None

133

self._update_timer_callback_lock = 0

134

105

self.last_checker_failed = False

135

106

136

107

# The widget shown normally

137

self._text_widget = urwid.Text("")

108

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

138

109

# The widget shown when we have focus

139

self._focus_text_widget = urwid.Text("")

110

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

140

111

super(MandosClientWidget, self).__init__(

141

112

update_hook=update_hook, delete_hook=delete_hook,

142

113

*args, **kwargs)

143

114

self.update()

144

115

self.opened = False

145

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)

146

136

last_checked_ok = isoformat_to_datetime(self.properties

147

["LastCheckedOK"])

137

[u"LastCheckedOK"])

148

138

if last_checked_ok is None:

149

139

self.last_checker_failed = True

150

140

else:

153

143

> datetime.timedelta

154

144

(milliseconds=

155

145

self.properties

156

["Interval"]))

157

146

[u"Interval"]))

158

147

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

204

148

self._update_timer_callback_tag = (gobject.timeout_add

205

149

(1000,

206

150

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

210

151

211

152

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

212

153

if exitstatus == 0:

213

154

if self.last_checker_failed:

214

155

self.last_checker_failed = False

215

self.using_timer(False)

216

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

217

# ' was successful'

218

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

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

219

161

self.update()

220

162

return

221

163

# Checker failed

222

164

if not self.last_checker_failed:

223

165

self.last_checker_failed = True

224

self.using_timer(True)

166

self._update_timer_callback_tag = (gobject.timeout_add

167

(1000,

168

self.update_timer))

225

169

if os.WIFEXITED(condition):

226

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

227

' failed with exit code %s'

228

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

170

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

171

u' failed with exit code %s'

172

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

229

173

os.WEXITSTATUS(condition)))

230

174

elif os.WIFSIGNALED(condition):

231

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

232

' was killed by signal %s'

233

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

175

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

176

u' was killed by signal %s'

177

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

234

178

os.WTERMSIG(condition)))

235

179

elif os.WCOREDUMP(condition):

236

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

237

' dumped core'

238

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

180

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

181

u' dumped core'

182

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

239

183

else:

240

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

241

' mysteriously')

184

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

185

u' mysteriously')

242

186

self.update()

243

187

244

188

def checker_started(self, command):

245

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

246

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

189

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

190

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

247

191

pass

248

192

249

193

def got_secret(self):

250

194

self.last_checker_failed = False

251

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

252

% self.properties["Name"])

195

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

196

% self.properties[u"Name"])

253

197

254

198

def need_approval(self, timeout, default):

255

199

if not default:

256

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

200

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

257

201

else:

258

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

202

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

259

203

self.logger(message

260

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

261

self.using_timer(True)

204

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

262

205

263

206

def rejected(self, reason):

264

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

265

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

207

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

208

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

266

209

267

210

def selectable(self):

268

211

"""Make this a "selectable" widget.

269

212

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

270

213

return True

271

214

272

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

215

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

273

216

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

274

217

whether we have focus or not.

275

218

This overrides the method from urwid.FlowWidget"""

276

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

219

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

277

220

278

221

def current_widget(self, focus=False):

279

222

if focus or self.opened:

283

226

def update(self):

284

227

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

285

228

# How to add standout mode to a style

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

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

292

235

}

293

236

294

237

# Rebuild focus and non-focus widgets using current properties

295

238

296

239

# Base part of a client. Name!

297

base = ('%(name)s: '

298

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

299

if not self.properties["Enabled"]:

300

message = "DISABLED"

301

elif self.properties["ApprovalPending"]:

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:

302

250

timeout = datetime.timedelta(milliseconds

303

251

= self.properties

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'

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'

328

260

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

329

261

else:

330

message = "enabled"

262

message = u"enabled"

331

263

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

332

264

333

265

if not urwid.supports_unicode():

334

266

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

335

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

267

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

336

268

self._text_widget.set_text(textlist)

337

269

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

338

270

text[1])

347

279

self.update_hook()

348

280

349

281

def update_timer(self):

350

"""called by gobject. Will indefinitely loop until

351

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

282

"called by gobject"

352

283

self.update()

353

284

return True # Keep calling this

354

285

355

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

286

def delete(self):

356

287

if self._update_timer_callback_tag is not None:

357

288

gobject.source_remove(self._update_timer_callback_tag)

358

289

self._update_timer_callback_tag = None

359

for match in self.match_objects:

360

match.remove()

361

self.match_objects = ()

362

290

if self.delete_hook is not None:

363

291

self.delete_hook(self)

364

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

365

292

366

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

293

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

367

294

"""Render differently if we have focus.

368

295

This overrides the method from urwid.FlowWidget"""

369

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

296

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

370

297

focus=focus)

371

298

372

def keypress(self, maxcolrow, key):

299

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

373

300

"""Handle keys.

374

301

This overrides the method from urwid.FlowWidget"""

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

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

382

307

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

383

dbus_interface = client_interface,

384

ignore_reply=True)

385

elif key == "d":

308

dbus_interface = client_interface)

309

elif key == u"d":

386

310

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

387

dbus_interface = client_interface,

388

ignore_reply=True)

389

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

311

dbus_interface = client_interface)

312

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

390

313

self.server_proxy_object.RemoveClient(self.proxy

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)

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)

402

321

# xxx

403

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

322

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

404

323

# self.proxy.pause()

405

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

324

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

406

325

# self.proxy.unpause()

407

# elif key == "RET":

326

# elif key == u"RET":

408

327

# self.open()

409

328

else:

410

329

return key

426

345

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

427

346

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

428

347

"""

429

def keypress(self, maxcolrow, key):

430

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

431

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

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

432

352

return

433

353

return ret

434

354

443

363

self.screen = urwid.curses_display.Screen()

444

364

445

365

self.screen.register_palette((

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

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

463

383

))

464

384

465

385

if urwid.supports_unicode():

466

self.divider = "─" # \u2500

467

#self.divider = "━" # \u2501

386

self.divider = u"─" # \u2500

387

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

468

388

else:

469

#self.divider = "-" # \u002d

470

self.divider = "_" # \u005f

389

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

390

self.divider = u"_" # \u005f

471

391

472

392

self.screen.start()

473

393

487

407

# This keeps track of whether self.uilist currently has

488

408

# self.logbox in it or not

489

409

self.log_visible = True

490

self.log_wrap = "any"

410

self.log_wrap = u"any"

491

411

492

412

self.rebuild()

493

self.log_message_raw(("bold",

494

"Mandos Monitor version " + version))

495

self.log_message_raw(("bold",

496

"q: Quit ?: Help"))

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

497

417

498

418

self.busname = domain + '.Mandos'

499

419

self.main_loop = gobject.MainLoop()

500

420

self.bus = dbus.SystemBus()

501

421

mandos_dbus_objc = self.bus.get_object(

502

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

422

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

503

423

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

504

424

dbus_interface

505

425

= server_interface)

510

430

mandos_clients = dbus.Dictionary()

511

431

512

432

(self.mandos_serv

513

.connect_to_signal("ClientRemoved",

433

.connect_to_signal(u"ClientRemoved",

514

434

self.find_and_remove_client,

515

435

dbus_interface=server_interface,

516

436

byte_arrays=True))

517

437

(self.mandos_serv

518

.connect_to_signal("ClientAdded",

438

.connect_to_signal(u"ClientAdded",

519

439

self.add_new_client,

520

440

dbus_interface=server_interface,

521

441

byte_arrays=True))

522

442

(self.mandos_serv

523

.connect_to_signal("ClientNotFound",

443

.connect_to_signal(u"ClientNotFound",

524

444

self.client_not_found,

525

445

dbus_interface=server_interface,

526

446

byte_arrays=True))

541

461

path=path)

542

462

543

463

def client_not_found(self, fingerprint, address):

544

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

545

" could not be found" % (address,

464

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

465

u" could not be found" % (address,

546

466

fingerprint)))

547

467

548

468

def rebuild(self):

564

484

565

485

def log_message(self, message):

566

486

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

567

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

487

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

568

488

569

489

def log_message_raw(self, markup):

570

490

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

573

493

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

574

494

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

575

495

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

576

coming_from="above")

496

coming_from=u"above")

577

497

self.refresh()

578

498

579

499

def toggle_log_display(self):

580

500

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

581

501

self.log_visible = not self.log_visible

582

502

self.rebuild()

583

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

503

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

584

504

# + unicode(self.log_visible))

585

505

586

506

def change_log_display(self):

587

507

"""Change type of log display.

588

508

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

589

if self.log_wrap == "clip":

590

self.log_wrap = "any"

509

if self.log_wrap == u"clip":

510

self.log_wrap = u"any"

591

511

else:

592

self.log_wrap = "clip"

512

self.log_wrap = u"clip"

593

513

for textwidget in self.log:

594

514

textwidget.set_wrap_mode(self.log_wrap)

595

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

515

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

596

516

597

517

def find_and_remove_client(self, path, name):

598

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

518

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

599

519

600

520

This is connected to the ClientRemoved signal from the

601

521

Mandos server object."""

603

523

client = self.clients_dict[path]

604

524

except KeyError:

605

525

# not found?

606

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

607

path)

608

526

return

609

client.delete()

527

self.remove_client(client, path)

610

528

611

529

def add_new_client(self, path):

612

530

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

627

545

if path is None:

628

546

path = client.proxy.object_path

629

547

self.clients_dict[path] = client

630

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

548

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

631

549

self.refresh()

632

550

633

551

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

664

582

665

583

def process_input(self, source, condition):

666

584

keys = self.screen.get_input()

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

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

676

594

}

677

595

for key in keys:

678

596

try:

680

598

except KeyError: # :-)

681

599

pass

682

600

683

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

601

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

684

602

self.stop()

685

603

break

686

elif key == "window resize":

604

elif key == u"window resize":

687

605

self.size = self.screen.get_cols_rows()

688

606

self.refresh()

689

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

607

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

690

608

self.refresh()

691

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

609

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

692

610

self.toggle_log_display()

693

611

self.refresh()

694

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

612

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

695

613

self.change_log_display()

696

614

self.refresh()

697

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

615

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

698

616

if not self.log_visible:

699

617

self.log_visible = True

700

618

self.rebuild()

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

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

719

637

self.refresh()

720

elif key == "tab":

638

elif key == u"tab":

721

639

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

722

640

self.topwidget.set_focus(0)

723

641

else:

724

642

self.topwidget.set_focus(self.logbox)

725

643

self.refresh()

726

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

727

# or key == ">"):

644

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

645

# or key == u">"):

728

646

# pass # xxx end-of-buffer

729

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

730

# or key == "<"):

647

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

648

# or key == u"<"):

731

649

# pass # xxx beginning-of-buffer

732

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

650

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

733

651

# pass # xxx move-end-of-line

734

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

652

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

735

653

# pass # xxx move-beginning-of-line

736

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

654

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

737

655

# pass # xxx left

738

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

656

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

739

657

# pass # xxx right

740

#elif key == "a":

658

#elif key == u"a":

741

659

# pass # scroll up log

742

#elif key == "z":

660

#elif key == u"z":

743

661

# pass # scroll down log

744

662

elif self.topwidget.selectable():

745

663

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