/mandos/release : revision 237.7.25

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

5

26

6

27

import sys

7

28

import os

21

42

22

43

import locale

23

44

24

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

45

locale.setlocale(locale.LC_ALL, '')

25

46

26

47

import logging

27

48

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

30

51

domain = 'se.bsnet.fukt'

31

52

server_interface = domain + '.Mandos'

32

53

client_interface = domain + '.Mandos.Client'

33

version = "1.0.15"

54

version = "1.3.0"

34

55

35

56

# Always run in monochrome mode

36

57

urwid.curses_display.curses.has_colors = lambda : False

44

65

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

45

66

if not iso:

46

67

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)

68

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

69

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

70

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

50

71

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

51

72

return datetime.datetime(int(year),

52

73

int(month),

65

86

self.proxy = proxy_object # Mandos Client proxy object

66

87

67

88

self.properties = dict()

68

self.proxy.connect_to_signal(u"PropertyChanged",

89

self.proxy.connect_to_signal("PropertyChanged",

69

90

self.property_changed,

70

91

client_interface,

71

92

byte_arrays=True)

102

123

self.logger = logger

103

124

104

125

self._update_timer_callback_tag = None

126

self._update_timer_callback_lock = 0

105

127

self.last_checker_failed = False

106

128

107

129

# The widget shown normally

108

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

130

self._text_widget = urwid.Text("")

109

131

# The widget shown when we have focus

110

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

132

self._focus_text_widget = urwid.Text("")

111

133

super(MandosClientWidget, self).__init__(

112

134

update_hook=update_hook, delete_hook=delete_hook,

113

135

*args, **kwargs)

114

136

self.update()

115

137

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)

138

136

139

last_checked_ok = isoformat_to_datetime(self.properties

137

["last_checked_ok"])

140

["LastCheckedOK"])

138

141

if last_checked_ok is None:

139

142

self.last_checker_failed = True

140

143

else:

142

145

- last_checked_ok)

143

146

> datetime.timedelta

144

147

(milliseconds=

145

self.properties["interval"]))

148

self.properties

149

["Interval"]))

150

146

151

if self.last_checker_failed:

152

self.using_timer(True)

153

154

if self.need_approval:

155

self.using_timer(True)

156

157

self.proxy.connect_to_signal("CheckerCompleted",

158

self.checker_completed,

159

client_interface,

160

byte_arrays=True)

161

self.proxy.connect_to_signal("CheckerStarted",

162

self.checker_started,

163

client_interface,

164

byte_arrays=True)

165

self.proxy.connect_to_signal("GotSecret",

166

self.got_secret,

167

client_interface,

168

byte_arrays=True)

169

self.proxy.connect_to_signal("NeedApproval",

170

self.need_approval,

171

client_interface,

172

byte_arrays=True)

173

self.proxy.connect_to_signal("Rejected",

174

self.rejected,

175

client_interface,

176

byte_arrays=True)

177

178

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

179

super(self, MandosClientWidget).property_changed(property,

180

value)

181

if property == "ApprovalPending":

182

using_timer(bool(value))

183

184

def using_timer(self, flag):

185

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

186

activated or deactivated.

187

"""

188

old = self._update_timer_callback_lock

189

if flag:

190

self._update_timer_callback_lock += 1

191

else:

192

self._update_timer_callback_lock -= 1

193

if old == 0 and self._update_timer_callback_lock:

147

194

self._update_timer_callback_tag = (gobject.timeout_add

148

195

(1000,

149

196

self.update_timer))

197

elif old and self._update_timer_callback_lock == 0:

198

gobject.source_remove(self._update_timer_callback_tag)

199

self._update_timer_callback_tag = None

150

200

151

201

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

152

202

if exitstatus == 0:

153

203

if self.last_checker_failed:

154

204

self.last_checker_failed = False

155

gobject.source_remove(self._update_timer_callback_tag)

156

self._update_timer_callback_tag = None

157

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

158

u' was successful'

159

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

205

self.using_timer(False)

206

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

207

# ' was successful'

208

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

160

209

self.update()

161

210

return

162

211

# Checker failed

163

212

if not self.last_checker_failed:

164

213

self.last_checker_failed = True

165

self._update_timer_callback_tag = (gobject.timeout_add

166

(1000,

167

self.update_timer))

214

self.using_timer(True)

168

215

if os.WIFEXITED(condition):

169

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

170

u' failed with exit code %s'

171

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

216

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

217

' failed with exit code %s'

218

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

172

219

os.WEXITSTATUS(condition)))

173

220

elif os.WIFSIGNALED(condition):

174

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

175

u' was killed by signal %s'

176

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

221

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

222

' was killed by signal %s'

223

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

177

224

os.WTERMSIG(condition)))

178

225

elif os.WCOREDUMP(condition):

179

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

180

u' dumped core'

181

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

226

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

227

' dumped core'

228

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

182

229

else:

183

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

230

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

231

' mysteriously')

184

232

self.update()

185

233

186

234

def checker_started(self, command):

187

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

188

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

235

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

236

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

189

237

pass

190

238

191

239

def got_secret(self):

192

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

193

% self.properties[u"name"])

240

self.last_checker_failed = False

241

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

242

% self.properties["Name"])

194

243

195

244

def need_approval(self, timeout, default):

196

245

if not default:

197

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

246

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

198

247

else:

199

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

248

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

200

249

self.logger(message

201

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

250

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

251

self.using_timer(True)

202

252

203

253

def rejected(self, reason):

204

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

205

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

254

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

255

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

206

256

207

257

def selectable(self):

208

258

"""Make this a "selectable" widget.

209

259

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

210

260

return True

211

261

212

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

262

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

213

263

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

214

264

whether we have focus or not.

215

265

This overrides the method from urwid.FlowWidget"""

216

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

266

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

217

267

218

268

def current_widget(self, focus=False):

219

269

if focus or self.opened:

223

273

def update(self):

224

274

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

225

275

# How to add standout mode to a style

226

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

227

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

228

u"underline-blink":

229

u"underline-blink-standout",

230

u"bold-underline-blink":

231

u"bold-underline-blink-standout",

276

with_standout = { "normal": "standout",

277

"bold": "bold-standout",

278

"underline-blink":

279

"underline-blink-standout",

280

"bold-underline-blink":

281

"bold-underline-blink-standout",

232

282

}

233

283

234

284

# Rebuild focus and non-focus widgets using current properties

235

285

236

286

# Base part of a client. Name!

237

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

238

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

239

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

240

message = u"DISABLED"

287

base = ('%(name)s: '

288

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

289

if not self.properties["Enabled"]:

290

message = "DISABLED"

291

elif self.properties["ApprovalPending"]:

292

timeout = datetime.timedelta(milliseconds

293

= self.properties

294

["ApprovalDelay"])

295

last_approval_request = isoformat_to_datetime(

296

self.properties["LastApprovalRequest"])

297

if last_approval_request is not None:

298

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

299

- last_approval_request)

300

else:

301

timer = datetime.timedelta()

302

if self.properties["ApprovedByDefault"]:

303

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

304

else:

305

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

306

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

241

307

elif self.last_checker_failed:

242

308

timeout = datetime.timedelta(milliseconds

243

= self.properties[u"timeout"])

309

= self.properties

310

["Timeout"])

244

311

last_ok = isoformat_to_datetime(

245

max((self.properties["last_checked_ok"]

246

or self.properties["created"]),

247

self.properties[u"last_enabled"]))

312

max((self.properties["LastCheckedOK"]

313

or self.properties["Created"]),

314

self.properties["LastEnabled"]))

248

315

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

249

message = (u'A checker has failed! Time until client gets diabled: %s'

316

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

317

' gets disabled: %s'

250

318

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

251

elif self.properties[u"approved_pending"]:

252

if self.properties[u"approved_by_default"]:

253

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

254

else:

255

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

256

319

else:

257

message = u"enabled"

320

message = "enabled"

258

321

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

259

322

260

323

if not urwid.supports_unicode():

261

324

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

262

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

325

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

263

326

self._text_widget.set_text(textlist)

264

327

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

265

328

text[1])

285

348

if self.delete_hook is not None:

286

349

self.delete_hook(self)

287

350

288

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

351

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

289

352

"""Render differently if we have focus.

290

353

This overrides the method from urwid.FlowWidget"""

291

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

354

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

292

355

focus=focus)

293

356

294

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

357

def keypress(self, maxcolrow, key):

295

358

"""Handle keys.

296

359

This overrides the method from urwid.FlowWidget"""

297

if key == u"+":

360

if key == "+":

298

361

self.proxy.Enable(dbus_interface = client_interface)

299

elif key == u"-":

362

elif key == "-":

300

363

self.proxy.Disable(dbus_interface = client_interface)

301

elif key == u"a":

364

elif key == "a":

302

365

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

303

366

dbus_interface = client_interface)

304

elif key == u"d":

367

elif key == "d":

305

368

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

306

369

dbus_interface = client_interface)

307

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

370

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

308

371

self.server_proxy_object.RemoveClient(self.proxy

309

372

.object_path)

310

elif key == u"s":

373

elif key == "s":

311

374

self.proxy.StartChecker(dbus_interface = client_interface)

312

elif key == u"S":

375

elif key == "S":

313

376

self.proxy.StopChecker(dbus_interface = client_interface)

314

elif key == u"C":

377

elif key == "C":

315

378

self.proxy.CheckedOK(dbus_interface = client_interface)

316

379

# xxx

317

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

380

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

318

381

# self.proxy.pause()

319

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

382

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

320

383

# self.proxy.unpause()

321

# elif key == u"RET":

384

# elif key == "RET":

322

385

# self.open()

323

# elif key == u"+":

324

# self.proxy.Approve(True)

325

# elif key == u"-":

326

# self.proxy.Approve(False)

327

386

else:

328

387

return key

329

388

344

403

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

345

404

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

346

405

"""

347

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

348

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

349

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

406

def keypress(self, maxcolrow, key):

407

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

408

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

350

409

return

351

410

return ret

352

411

361

420

self.screen = urwid.curses_display.Screen()

362

421

363

422

self.screen.register_palette((

364

(u"normal",

365

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

366

(u"bold",

367

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

368

(u"underline-blink",

369

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

370

(u"standout",

371

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

372

(u"bold-underline-blink",

373

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

374

(u"bold-standout",

375

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

376

(u"underline-blink-standout",

377

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

378

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

379

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

380

u"standout")),

423

("normal",

424

"default", "default", None),

425

("bold",

426

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

427

("underline-blink",

428

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

429

("standout",

430

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

431

("bold-underline-blink",

432

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

433

("bold-standout",

434

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

435

("underline-blink-standout",

436

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

437

("bold-underline-blink-standout",

438

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

439

"standout")),

381

440

))

382

441

383

442

if urwid.supports_unicode():

384

self.divider = u"─" # \u2500

385

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

443

self.divider = "─" # \u2500

444

#self.divider = "━" # \u2501

386

445

else:

387

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

388

self.divider = u"_" # \u005f

446

#self.divider = "-" # \u002d

447

self.divider = "_" # \u005f

389

448

390

449

self.screen.start()

391

450

405

464

# This keeps track of whether self.uilist currently has

406

465

# self.logbox in it or not

407

466

self.log_visible = True

408

self.log_wrap = u"any"

467

self.log_wrap = "any"

409

468

410

469

self.rebuild()

411

self.log_message_raw((u"bold",

412

u"Mandos Monitor version " + version))

413

self.log_message_raw((u"bold",

414

u"q: Quit ?: Help"))

470

self.log_message_raw(("bold",

471

"Mandos Monitor version " + version))

472

self.log_message_raw(("bold",

473

"q: Quit ?: Help"))

415

474

416

475

self.busname = domain + '.Mandos'

417

476

self.main_loop = gobject.MainLoop()

418

477

self.bus = dbus.SystemBus()

419

478

mandos_dbus_objc = self.bus.get_object(

420

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

479

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

421

480

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

422

481

dbus_interface

423

482

= server_interface)

428

487

mandos_clients = dbus.Dictionary()

429

488

430

489

(self.mandos_serv

431

.connect_to_signal(u"ClientRemoved",

490

.connect_to_signal("ClientRemoved",

432

491

self.find_and_remove_client,

433

492

dbus_interface=server_interface,

434

493

byte_arrays=True))

435

494

(self.mandos_serv

436

.connect_to_signal(u"ClientAdded",

495

.connect_to_signal("ClientAdded",

437

496

self.add_new_client,

438

497

dbus_interface=server_interface,

439

498

byte_arrays=True))

440

499

(self.mandos_serv

441

.connect_to_signal(u"ClientNotFound",

500

.connect_to_signal("ClientNotFound",

442

501

self.client_not_found,

443

502

dbus_interface=server_interface,

444

503

byte_arrays=True))

459

518

path=path)

460

519

461

520

def client_not_found(self, fingerprint, address):

462

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

463

u" could not be found" % (address,

521

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

522

" could not be found" % (address,

464

523

fingerprint)))

465

524

466

525

def rebuild(self):

468

527

Call this when the widget layout needs to change"""

469

528

self.uilist = []

470

529

#self.uilist.append(urwid.ListBox(self.clients))

471

self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),

530

self.uilist.append(urwid.Frame(ConstrainedListBox(self.

531

clients),

472

532

#header=urwid.Divider(),

473

533

header=None,

474

footer=urwid.Divider(div_char=self.divider)))

534

footer=

535

urwid.Divider(div_char=

536

self.divider)))

475

537

if self.log_visible:

476

538

self.uilist.append(self.logbox)

477

539

pass

479

541

480

542

def log_message(self, message):

481

543

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

482

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

544

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

483

545

484

546

def log_message_raw(self, markup):

485

547

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

488

550

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

489

551

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

490

552

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

491

coming_from=u"above")

553

coming_from="above")

492

554

self.refresh()

493

555

494

556

def toggle_log_display(self):

495

557

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

496

558

self.log_visible = not self.log_visible

497

559

self.rebuild()

498

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

499

+ unicode(self.log_visible))

560

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

561

# + unicode(self.log_visible))

500

562

501

563

def change_log_display(self):

502

564

"""Change type of log display.

503

565

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

504

if self.log_wrap == u"clip":

505

self.log_wrap = u"any"

566

if self.log_wrap == "clip":

567

self.log_wrap = "any"

506

568

else:

507

self.log_wrap = u"clip"

569

self.log_wrap = "clip"

508

570

for textwidget in self.log:

509

571

textwidget.set_wrap_mode(self.log_wrap)

510

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

572

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

511

573

512

574

def find_and_remove_client(self, path, name):

513

575

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

540

602

if path is None:

541

603

path = client.proxy.object_path

542

604

self.clients_dict[path] = client

543

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

605

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

544

606

self.refresh()

545

607

546

608

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

577

639

578

640

def process_input(self, source, condition):

579

641

keys = self.screen.get_input()

580

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

581

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

582

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

583

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

584

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

585

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

586

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

587

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

588

u"k": u"up", # vi

642

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

643

"ctrl p": "up", # Emacs

644

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

645

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

646

" ": "page down", # less

647

"f": "page down", # less

648

"b": "page up", # less

649

"j": "down", # vi

650

"k": "up", # vi

589

651

}

590

652

for key in keys:

591

653

try:

593

655

except KeyError: # :-)

594

656

pass

595

657

596

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

658

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

597

659

self.stop()

598

660

break

599

elif key == u"window resize":

661

elif key == "window resize":

600

662

self.size = self.screen.get_cols_rows()

601

663

self.refresh()

602

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

664

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

603

665

self.refresh()

604

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

666

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

605

667

self.toggle_log_display()

606

668

self.refresh()

607

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

669

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

608

670

self.change_log_display()

609

671

self.refresh()

610

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

672

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

611

673

if not self.log_visible:

612

674

self.log_visible = True

613

675

self.rebuild()

614

self.log_message_raw((u"bold",

615

u" ".

616

join((u"q: Quit",

617

u"?: Help",

618

u"l: Log window toggle",

619

u"TAB: Switch window",

620

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

621

self.log_message_raw((u"bold",

622

u" "

623

.join((u"Clients:",

624

u"+: Enable",

625

u"-: Disable",

626

u"r: Remove",

627

u"s: Start new checker",

628

u"S: Stop checker",

629

u"C: Checker OK",

630

u"a: Approve",

631

u"d: Deny"))))

676

self.log_message_raw(("bold",

677

" ".

678

join(("q: Quit",

679

"?: Help",

680

"l: Log window toggle",

681

"TAB: Switch window",

682

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

683

self.log_message_raw(("bold",

684

" "

685

.join(("Clients:",

686

"+: Enable",

687

"-: Disable",

688

"R: Remove",

689

"s: Start new checker",

690

"S: Stop checker",

691

"C: Checker OK",

692

"a: Approve",

693

"d: Deny"))))

632

694

self.refresh()

633

elif key == u"tab":

695

elif key == "tab":

634

696

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

635

697

self.topwidget.set_focus(0)

636

698

else:

637

699

self.topwidget.set_focus(self.logbox)

638

700

self.refresh()

639

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

640

# or key == u">"):

701

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

702

# or key == ">"):

641

703

# pass # xxx end-of-buffer

642

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

643

# or key == u"<"):

704

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

705

# or key == "<"):

644

706

# pass # xxx beginning-of-buffer

645

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

707

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

646

708

# pass # xxx move-end-of-line

647

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

709

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

648

710

# pass # xxx move-beginning-of-line

649

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

711

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

650

712

# pass # xxx left

651

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

713

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

652

714

# pass # xxx right

653

#elif key == u"a":

715

#elif key == "a":

654

716

# pass # scroll up log

655

#elif key == u"z":

717

#elif key == "z":

656

718

# pass # scroll down log

657

719

elif self.topwidget.selectable():

658

720

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

662

724

ui = UserInterface()

663

725

try:

664

726

ui.run()

727

except KeyboardInterrupt:

728

ui.screen.stop()

665

729

except Exception, e:

666

730

ui.log_message(unicode(e))

667

731

ui.screen.stop()