/mandos/release : revision 237.2.196

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

148

self._update_timer_callback_tag = (gobject.timeout_add

204

149

(1000,

205

150

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

209

151

210

152

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

211

153

if exitstatus == 0:

212

154

if self.last_checker_failed:

213

155

self.last_checker_failed = False

214

self.using_timer(False)

215

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

216

# ' was successful'

217

# % (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))

218

161

self.update()

219

162

return

220

163

# Checker failed

221

164

if not self.last_checker_failed:

222

165

self.last_checker_failed = True

223

self.using_timer(True)

166

self._update_timer_callback_tag = (gobject.timeout_add

167

(1000,

168

self.update_timer))

224

169

if os.WIFEXITED(condition):

225

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

226

' failed with exit code %s'

227

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

228

173

os.WEXITSTATUS(condition)))

229

174

elif os.WIFSIGNALED(condition):

230

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

231

' was killed by signal %s'

232

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

233

178

os.WTERMSIG(condition)))

234

179

elif os.WCOREDUMP(condition):

235

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

236

' dumped core'

237

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

180

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

181

u' dumped core'

182

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

238

183

else:

239

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

240

' mysteriously')

184

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

185

u' mysteriously')

241

186

self.update()

242

187

243

188

def checker_started(self, command):

244

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

245

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

189

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

190

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

246

191

pass

247

192

248

193

def got_secret(self):

249

194

self.last_checker_failed = False

250

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

251

% self.properties["Name"])

195

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

196

% self.properties[u"Name"])

252

197

253

198

def need_approval(self, timeout, default):

254

199

if not default:

255

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

200

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

256

201

else:

257

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

202

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

258

203

self.logger(message

259

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

260

self.using_timer(True)

204

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

261

205

262

206

def rejected(self, reason):

263

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

264

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

207

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

208

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

265

209

266

210

def selectable(self):

267

211

"""Make this a "selectable" widget.

268

212

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

269

213

return True

270

214

271

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

215

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

272

216

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

273

217

whether we have focus or not.

274

218

This overrides the method from urwid.FlowWidget"""

275

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

219

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

276

220

277

221

def current_widget(self, focus=False):

278

222

if focus or self.opened:

282

226

def update(self):

283

227

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

284

228

# How to add standout mode to a style

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

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

291

235

}

292

236

293

237

# Rebuild focus and non-focus widgets using current properties

294

238

295

239

# Base part of a client. Name!

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]

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

316

249

elif self.last_checker_failed:

317

250

timeout = datetime.timedelta(milliseconds

318

251

= self.properties

319

["Timeout"])

252

[u"Timeout"])

320

253

last_ok = isoformat_to_datetime(

321

max((self.properties["LastCheckedOK"]

322

or self.properties["Created"]),

323

self.properties["LastEnabled"]))

254

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

255

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

256

self.properties[u"LastEnabled"]))

324

257

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

325

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

326

' gets disabled: %s'

258

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

259

u' gets diabled: %s'

327

260

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

328

261

else:

329

message = "enabled"

262

message = u"enabled"

330

263

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

331

264

332

265

if not urwid.supports_unicode():

333

266

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

334

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

267

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

335

268

self._text_widget.set_text(textlist)

336

269

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

337

270

text[1])

350

283

self.update()

351

284

return True # Keep calling this

352

285

353

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

286

def delete(self):

354

287

if self._update_timer_callback_tag is not None:

355

288

gobject.source_remove(self._update_timer_callback_tag)

356

289

self._update_timer_callback_tag = None

357

for match in self.match_objects:

358

match.remove()

359

self.match_objects = ()

360

290

if self.delete_hook is not None:

361

291

self.delete_hook(self)

362

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

363

292

364

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

293

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

365

294

"""Render differently if we have focus.

366

295

This overrides the method from urwid.FlowWidget"""

367

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

296

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

368

297

focus=focus)

369

298

370

def keypress(self, maxcolrow, key):

299

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

371

300

"""Handle keys.

372

301

This overrides the method from urwid.FlowWidget"""

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

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

380

307

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

381

dbus_interface = client_interface,

382

ignore_reply=True)

383

elif key == "d":

308

dbus_interface = client_interface)

309

elif key == u"d":

384

310

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

385

dbus_interface = client_interface,

386

ignore_reply=True)

387

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

388

313

self.server_proxy_object.RemoveClient(self.proxy

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)

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)

400

321

# xxx

401

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

322

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

402

323

# self.proxy.pause()

403

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

324

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

404

325

# self.proxy.unpause()

405

# elif key == "RET":

326

# elif key == u"RET":

406

327

# self.open()

407

328

else:

408

329

return key

424

345

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

425

346

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

426

347

"""

427

def keypress(self, maxcolrow, key):

428

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

429

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

430

352

return

431

353

return ret

432

354

441

363

self.screen = urwid.curses_display.Screen()

442

364

443

365

self.screen.register_palette((

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

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

461

383

))

462

384

463

385

if urwid.supports_unicode():

464

self.divider = "─" # \u2500

465

#self.divider = "━" # \u2501

386

self.divider = u"─" # \u2500

387

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

466

388

else:

467

#self.divider = "-" # \u002d

468

self.divider = "_" # \u005f

389

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

390

self.divider = u"_" # \u005f

469

391

470

392

self.screen.start()

471

393

485

407

# This keeps track of whether self.uilist currently has

486

408

# self.logbox in it or not

487

409

self.log_visible = True

488

self.log_wrap = "any"

410

self.log_wrap = u"any"

489

411

490

412

self.rebuild()

491

self.log_message_raw(("bold",

492

"Mandos Monitor version " + version))

493

self.log_message_raw(("bold",

494

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

495

417

496

418

self.busname = domain + '.Mandos'

497

419

self.main_loop = gobject.MainLoop()

498

420

self.bus = dbus.SystemBus()

499

421

mandos_dbus_objc = self.bus.get_object(

500

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

422

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

501

423

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

502

424

dbus_interface

503

425

= server_interface)

508

430

mandos_clients = dbus.Dictionary()

509

431

510

432

(self.mandos_serv

511

.connect_to_signal("ClientRemoved",

433

.connect_to_signal(u"ClientRemoved",

512

434

self.find_and_remove_client,

513

435

dbus_interface=server_interface,

514

436

byte_arrays=True))

515

437

(self.mandos_serv

516

.connect_to_signal("ClientAdded",

438

.connect_to_signal(u"ClientAdded",

517

439

self.add_new_client,

518

440

dbus_interface=server_interface,

519

441

byte_arrays=True))

520

442

(self.mandos_serv

521

.connect_to_signal("ClientNotFound",

443

.connect_to_signal(u"ClientNotFound",

522

444

self.client_not_found,

523

445

dbus_interface=server_interface,

524

446

byte_arrays=True))

539

461

path=path)

540

462

541

463

def client_not_found(self, fingerprint, address):

542

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

543

" could not be found" % (address,

464

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

465

u" could not be found" % (address,

544

466

fingerprint)))

545

467

546

468

def rebuild(self):

562

484

563

485

def log_message(self, message):

564

486

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

565

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

487

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

566

488

567

489

def log_message_raw(self, markup):

568

490

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

571

493

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

572

494

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

573

495

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

574

coming_from="above")

496

coming_from=u"above")

575

497

self.refresh()

576

498

577

499

def toggle_log_display(self):

578

500

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

579

501

self.log_visible = not self.log_visible

580

502

self.rebuild()

581

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

503

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

582

504

# + unicode(self.log_visible))

583

505

584

506

def change_log_display(self):

585

507

"""Change type of log display.

586

508

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

587

if self.log_wrap == "clip":

588

self.log_wrap = "any"

509

if self.log_wrap == u"clip":

510

self.log_wrap = u"any"

589

511

else:

590

self.log_wrap = "clip"

512

self.log_wrap = u"clip"

591

513

for textwidget in self.log:

592

514

textwidget.set_wrap_mode(self.log_wrap)

593

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

515

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

594

516

595

517

def find_and_remove_client(self, path, name):

596

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

518

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

597

519

598

520

This is connected to the ClientRemoved signal from the

599

521

Mandos server object."""

601

523

client = self.clients_dict[path]

602

524

except KeyError:

603

525

# not found?

604

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

605

path)

606

526

return

607

client.delete()

527

self.remove_client(client, path)

608

528

609

529

def add_new_client(self, path):

610

530

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

625

545

if path is None:

626

546

path = client.proxy.object_path

627

547

self.clients_dict[path] = client

628

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

548

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

629

549

self.refresh()

630

550

631

551

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

662

582

663

583

def process_input(self, source, condition):

664

584

keys = self.screen.get_input()

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

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

674

594

}

675

595

for key in keys:

676

596

try:

678

598

except KeyError: # :-)

679

599

pass

680

600

681

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

601

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

682

602

self.stop()

683

603

break

684

elif key == "window resize":

604

elif key == u"window resize":

685

605

self.size = self.screen.get_cols_rows()

686

606

self.refresh()

687

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

607

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

688

608

self.refresh()

689

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

609

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

690

610

self.toggle_log_display()

691

611

self.refresh()

692

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

612

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

693

613

self.change_log_display()

694

614

self.refresh()

695

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

615

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

696

616

if not self.log_visible:

697

617

self.log_visible = True

698

618

self.rebuild()

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

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

717

637

self.refresh()

718

elif key == "tab":

638

elif key == u"tab":

719

639

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

720

640

self.topwidget.set_focus(0)

721

641

else:

722

642

self.topwidget.set_focus(self.logbox)

723

643

self.refresh()

724

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

725

# or key == ">"):

644

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

645

# or key == u">"):

726

646

# pass # xxx end-of-buffer

727

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

728

# or key == "<"):

647

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

648

# or key == u"<"):

729

649

# pass # xxx beginning-of-buffer

730

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

650

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

731

651

# pass # xxx move-end-of-line

732

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

652

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

733

653

# pass # xxx move-beginning-of-line

734

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

654

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

735

655

# pass # xxx left

736

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

656

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

737

657

# pass # xxx right

738

#elif key == "a":

658

#elif key == u"a":

739

659

# pass # scroll up log

740

#elif key == "z":

660

#elif key == u"z":

741

661

# pass # scroll down log

742

662

elif self.topwidget.selectable():

743

663

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