/mandos/release : revision 285

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:

148

203

self._update_timer_callback_tag = (gobject.timeout_add

149

204

(1000,

150

205

self.update_timer))

206

elif old and self._update_timer_callback_lock == 0:

207

gobject.source_remove(self._update_timer_callback_tag)

208

self._update_timer_callback_tag = None

151

209

152

210

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

153

211

if exitstatus == 0:

154

212

if self.last_checker_failed:

155

213

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

214

self.using_timer(False)

215

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

216

# ' was successful'

217

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

161

218

self.update()

162

219

return

163

220

# Checker failed

164

221

if not self.last_checker_failed:

165

222

self.last_checker_failed = True

166

self._update_timer_callback_tag = (gobject.timeout_add

167

(1000,

168

self.update_timer))

223

self.using_timer(True)

169

224

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,

225

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

226

' failed with exit code %s'

227

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

173

228

os.WEXITSTATUS(condition)))

174

229

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,

230

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

231

' was killed by signal %s'

232

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

178

233

os.WTERMSIG(condition)))

179

234

elif os.WCOREDUMP(condition):

180

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

181

u' dumped core'

182

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

235

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

236

' dumped core'

237

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

183

238

else:

184

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

185

u' mysteriously')

239

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

240

' mysteriously')

186

241

self.update()

187

242

188

243

def checker_started(self, command):

189

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

190

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

244

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

245

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

191

246

pass

192

247

193

248

def got_secret(self):

194

249

self.last_checker_failed = False

195

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

196

% self.properties[u"Name"])

250

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

251

% self.properties["Name"])

197

252

198

253

def need_approval(self, timeout, default):

199

254

if not default:

200

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

255

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

201

256

else:

202

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

257

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

203

258

self.logger(message

204

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

259

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

260

self.using_timer(True)

205

261

206

262

def rejected(self, reason):

207

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

208

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

263

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

264

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

209

265

210

266

def selectable(self):

211

267

"""Make this a "selectable" widget.

212

268

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

213

269

return True

214

270

215

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

271

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

216

272

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

217

273

whether we have focus or not.

218

274

This overrides the method from urwid.FlowWidget"""

219

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

275

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

220

276

221

277

def current_widget(self, focus=False):

222

278

if focus or self.opened:

226

282

def update(self):

227

283

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

228

284

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

285

with_standout = { "normal": "standout",

286

"bold": "bold-standout",

287

"underline-blink":

288

"underline-blink-standout",

289

"bold-underline-blink":

290

"bold-underline-blink-standout",

235

291

}

236

292

237

293

# Rebuild focus and non-focus widgets using current properties

238

294

239

295

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

296

base = ('%(name)s: '

297

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

298

if not self.properties["Enabled"]:

299

message = "DISABLED"

300

elif self.properties["ApprovalPending"]:

301

timeout = datetime.timedelta(milliseconds

302

= self.properties

303

["ApprovalDelay"])

304

last_approval_request = isoformat_to_datetime(

305

self.properties["LastApprovalRequest"])

306

if last_approval_request is not None:

307

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

308

- last_approval_request)

309

else:

310

timer = datetime.timedelta()

311

if self.properties["ApprovedByDefault"]:

312

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

313

else:

314

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

315

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

249

316

elif self.last_checker_failed:

250

317

timeout = datetime.timedelta(milliseconds

251

318

= self.properties

252

[u"Timeout"])

319

["Timeout"])

253

320

last_ok = isoformat_to_datetime(

254

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

255

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

256

self.properties[u"LastEnabled"]))

321

max((self.properties["LastCheckedOK"]

322

or self.properties["Created"]),

323

self.properties["LastEnabled"]))

257

324

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

258

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

259

u' gets diabled: %s'

325

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

326

' gets disabled: %s'

260

327

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

261

328

else:

262

message = u"enabled"

329

message = "enabled"

263

330

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

264

331

265

332

if not urwid.supports_unicode():

266

333

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

267

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

334

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

268

335

self._text_widget.set_text(textlist)

269

336

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

270

337

text[1])

283

350

self.update()

284

351

return True # Keep calling this

285

352

286

def delete(self):

353

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

287

354

if self._update_timer_callback_tag is not None:

288

355

gobject.source_remove(self._update_timer_callback_tag)

289

356

self._update_timer_callback_tag = None

357

for match in self.match_objects:

358

match.remove()

359

self.match_objects = ()

290

360

if self.delete_hook is not None:

291

361

self.delete_hook(self)

362

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

292

363

293

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

364

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

294

365

"""Render differently if we have focus.

295

366

This overrides the method from urwid.FlowWidget"""

296

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

367

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

297

368

focus=focus)

298

369

299

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

370

def keypress(self, maxcolrow, key):

300

371

"""Handle keys.

301

372

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

373

if key == "+":

374

self.proxy.Enable(dbus_interface = client_interface,

375

ignore_reply=True)

376

elif key == "-":

377

self.proxy.Disable(dbus_interface = client_interface,

378

ignore_reply=True)

379

elif key == "a":

307

380

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

308

dbus_interface = client_interface)

309

elif key == u"d":

381

dbus_interface = client_interface,

382

ignore_reply=True)

383

elif key == "d":

310

384

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

385

dbus_interface = client_interface,

386

ignore_reply=True)

387

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

313

388

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)

389

.object_path,

390

ignore_reply=True)

391

elif key == "s":

392

self.proxy.StartChecker(dbus_interface = client_interface,

393

ignore_reply=True)

394

elif key == "S":

395

self.proxy.StopChecker(dbus_interface = client_interface,

396

ignore_reply=True)

397

elif key == "C":

398

self.proxy.CheckedOK(dbus_interface = client_interface,

399

ignore_reply=True)

321

400

# xxx

322

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

401

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

323

402

# self.proxy.pause()

324

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

403

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

325

404

# self.proxy.unpause()

326

# elif key == u"RET":

405

# elif key == "RET":

327

406

# self.open()

328

407

else:

329

408

return key

345

424

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

346

425

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

347

426

"""

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

427

def keypress(self, maxcolrow, key):

428

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

429

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

352

430

return

353

431

return ret

354

432

363

441

self.screen = urwid.curses_display.Screen()

364

442

365

443

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

444

("normal",

445

"default", "default", None),

446

("bold",

447

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

448

("underline-blink",

449

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

450

("standout",

451

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

452

("bold-underline-blink",

453

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

454

("bold-standout",

455

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

456

("underline-blink-standout",

457

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

458

("bold-underline-blink-standout",

459

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

460

"standout")),

383

461

))

384

462

385

463

if urwid.supports_unicode():

386

self.divider = u"─" # \u2500

387

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

464

self.divider = "─" # \u2500

465

#self.divider = "━" # \u2501

388

466

else:

389

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

390

self.divider = u"_" # \u005f

467

#self.divider = "-" # \u002d

468

self.divider = "_" # \u005f

391

469

392

470

self.screen.start()

393

471

407

485

# This keeps track of whether self.uilist currently has

408

486

# self.logbox in it or not

409

487

self.log_visible = True

410

self.log_wrap = u"any"

488

self.log_wrap = "any"

411

489

412

490

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

491

self.log_message_raw(("bold",

492

"Mandos Monitor version " + version))

493

self.log_message_raw(("bold",

494

"q: Quit ?: Help"))

417

495

418

496

self.busname = domain + '.Mandos'

419

497

self.main_loop = gobject.MainLoop()

420

498

self.bus = dbus.SystemBus()

421

499

mandos_dbus_objc = self.bus.get_object(

422

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

500

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

423

501

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

424

502

dbus_interface

425

503

= server_interface)

430

508

mandos_clients = dbus.Dictionary()

431

509

432

510

(self.mandos_serv

433

.connect_to_signal(u"ClientRemoved",

511

.connect_to_signal("ClientRemoved",

434

512

self.find_and_remove_client,

435

513

dbus_interface=server_interface,

436

514

byte_arrays=True))

437

515

(self.mandos_serv

438

.connect_to_signal(u"ClientAdded",

516

.connect_to_signal("ClientAdded",

439

517

self.add_new_client,

440

518

dbus_interface=server_interface,

441

519

byte_arrays=True))

442

520

(self.mandos_serv

443

.connect_to_signal(u"ClientNotFound",

521

.connect_to_signal("ClientNotFound",

444

522

self.client_not_found,

445

523

dbus_interface=server_interface,

446

524

byte_arrays=True))

461

539

path=path)

462

540

463

541

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,

542

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

543

" could not be found" % (address,

466

544

fingerprint)))

467

545

468

546

def rebuild(self):

484

562

485

563

def log_message(self, message):

486

564

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

487

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

565

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

488

566

489

567

def log_message_raw(self, markup):

490

568

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

493

571

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

494

572

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

495

573

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

496

coming_from=u"above")

574

coming_from="above")

497

575

self.refresh()

498

576

499

577

def toggle_log_display(self):

500

578

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

501

579

self.log_visible = not self.log_visible

502

580

self.rebuild()

503

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

581

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

504

582

# + unicode(self.log_visible))

505

583

506

584

def change_log_display(self):

507

585

"""Change type of log display.

508

586

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

509

if self.log_wrap == u"clip":

510

self.log_wrap = u"any"

587

if self.log_wrap == "clip":

588

self.log_wrap = "any"

511

589

else:

512

self.log_wrap = u"clip"

590

self.log_wrap = "clip"

513

591

for textwidget in self.log:

514

592

textwidget.set_wrap_mode(self.log_wrap)

515

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

593

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

516

594

517

595

def find_and_remove_client(self, path, name):

518

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

596

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

519

597

520

598

This is connected to the ClientRemoved signal from the

521

599

Mandos server object."""

523

601

client = self.clients_dict[path]

524

602

except KeyError:

525

603

# not found?

604

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

605

path)

526

606

return

527

self.remove_client(client, path)

607

client.delete()

528

608

529

609

def add_new_client(self, path):

530

610

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

545

625

if path is None:

546

626

path = client.proxy.object_path

547

627

self.clients_dict[path] = client

548

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

628

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

549

629

self.refresh()

550

630

551

631

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

582

662

583

663

def process_input(self, source, condition):

584

664

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

665

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

666

"ctrl p": "up", # Emacs

667

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

668

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

669

" ": "page down", # less

670

"f": "page down", # less

671

"b": "page up", # less

672

"j": "down", # vi

673

"k": "up", # vi

594

674

}

595

675

for key in keys:

596

676

try:

598

678

except KeyError: # :-)

599

679

pass

600

680

601

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

681

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

602

682

self.stop()

603

683

break

604

elif key == u"window resize":

684

elif key == "window resize":

605

685

self.size = self.screen.get_cols_rows()

606

686

self.refresh()

607

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

687

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

608

688

self.refresh()

609

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

689

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

610

690

self.toggle_log_display()

611

691

self.refresh()

612

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

692

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

613

693

self.change_log_display()

614

694

self.refresh()

615

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

695

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

616

696

if not self.log_visible:

617

697

self.log_visible = True

618

698

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

699

self.log_message_raw(("bold",

700

" ".

701

join(("q: Quit",

702

"?: Help",

703

"l: Log window toggle",

704

"TAB: Switch window",

705

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

706

self.log_message_raw(("bold",

707

" "

708

.join(("Clients:",

709

"+: Enable",

710

"-: Disable",

711

"R: Remove",

712

"s: Start new checker",

713

"S: Stop checker",

714

"C: Checker OK",

715

"a: Approve",

716

"d: Deny"))))

637

717

self.refresh()

638

elif key == u"tab":

718

elif key == "tab":

639

719

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

640

720

self.topwidget.set_focus(0)

641

721

else:

642

722

self.topwidget.set_focus(self.logbox)

643

723

self.refresh()

644

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

645

# or key == u">"):

724

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

725

# or key == ">"):

646

726

# pass # xxx end-of-buffer

647

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

648

# or key == u"<"):

727

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

728

# or key == "<"):

649

729

# pass # xxx beginning-of-buffer

650

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

730

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

651

731

# pass # xxx move-end-of-line

652

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

732

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

653

733

# pass # xxx move-beginning-of-line

654

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

734

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

655

735

# pass # xxx left

656

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

736

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

657

737

# pass # xxx right

658

#elif key == u"a":

738

#elif key == "a":

659

739

# pass # scroll up log

660

#elif key == u"z":

740

#elif key == "z":

661

741

# pass # scroll down log

662

742

elif self.topwidget.selectable():

663

743

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