/mandos/trunk : revision 759

1

#!/usr/bin/python

2

# -*- mode: python; coding: utf-8 -*-

3

#

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

5

#

6

7

8

#

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

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

#

18

#

19

# You should have received a copy of the GNU General Public License

20

# along with this program. If not, see

21

# <http://www.gnu.org/licenses/>.

22

#

22

#

23

# Contact the authors at <mandos@recompile.se>.

24

#

24

#

25

26

from __future__ import (division, absolute_import, print_function,

27

unicode_literals)

39

import urwid

40

41

from dbus.mainloop.glib import DBusGMainLoop

42

from gi.repository import GLib

42

try:

43

import gobject

44

except ImportError:

45

from gi.repository import GObject as gobject

43

46

44

47

import dbus

45

48

46

49

import locale

47

50

48

import logging

49

50

51

if sys.version_info.major == 2:

51

52

str = unicode

52

53

54

locale.setlocale(locale.LC_ALL, '')

54

55

56

import logging

55

57

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

56

58

57

59

# Some useful constants

58

60

domain = 'se.recompile'

59

61

server_interface = domain + '.Mandos'

60

62

client_interface = domain + '.Mandos.Client'

61

version = "1.7.14"

62

63

try:

64

dbus.OBJECT_MANAGER_IFACE

65

except AttributeError:

66

dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"

67

63

version = "1.6.9"

68

64

69

65

def isoformat_to_datetime(iso):

70

66

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

79

75

int(day),

80

76

int(hour),

81

77

int(minute),

82

int(second), # Whole seconds

83

int(fraction*1000000)) # Microseconds

84

78

int(second), # Whole seconds

79

int(fraction*1000000)) # Microseconds

85

80

86

81

class MandosClientPropertyCache(object):

87

82

"""This wraps a Mandos Client D-Bus proxy object, caches the

89

84

changed.

90

85

"""

91

86

def __init__(self, proxy_object=None, properties=None, **kwargs):

92

self.proxy = proxy_object # Mandos Client proxy object

87

self.proxy = proxy_object # Mandos Client proxy object

93

88

self.properties = dict() if properties is None else properties

94

89

self.property_changed_match = (

95

90

self.proxy.connect_to_signal("PropertiesChanged",

96

91

self.properties_changed,

97

92

dbus.PROPERTIES_IFACE,

98

93

byte_arrays=True))

99

94

100

95

if properties is None:

101

self.properties.update(self.proxy.GetAll(

102

client_interface,

103

dbus_interface=dbus.PROPERTIES_IFACE))

104

96

self.properties.update(

97

self.proxy.GetAll(client_interface,

98

dbus_interface

99

= dbus.PROPERTIES_IFACE))

100

105

101

super(MandosClientPropertyCache, self).__init__(**kwargs)

106

102

107

103

def properties_changed(self, interface, properties, invalidated):

108

104

"""This is called whenever we get a PropertiesChanged signal

109

105

It updates the changed properties in the "properties" dict.

110

106

"""

111

107

# Update properties dict with new value

112

if interface == client_interface:

113

self.properties.update(properties)

114

108

self.properties.update(properties)

109

115

110

def delete(self):

116

111

self.property_changed_match.remove()

117

112

119

114

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

120

115

"""A Mandos Client which is visible on the screen.

121

116

"""

122

117

123

118

def __init__(self, server_proxy_object=None, update_hook=None,

124

119

delete_hook=None, logger=None, **kwargs):

125

120

# Called on update

130

125

self.server_proxy_object = server_proxy_object

131

126

# Logger

132

127

self.logger = logger

133

128

134

129

self._update_timer_callback_tag = None

135

130

136

131

# The widget shown normally

137

132

self._text_widget = urwid.Text("")

138

133

# The widget shown when we have focus

140

135

super(MandosClientWidget, self).__init__(**kwargs)

141

136

self.update()

142

137

self.opened = False

143

138

144

139

self.match_objects = (

145

140

self.proxy.connect_to_signal("CheckerCompleted",

146

141

self.checker_completed,

164

159

byte_arrays=True))

165

160

self.logger('Created client {}'

166

161

.format(self.properties["Name"]), level=0)

167

162

168

163

def using_timer(self, flag):

169

164

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

170

165

activated or deactivated.

171

166

"""

172

167

if flag and self._update_timer_callback_tag is None:

173

168

# Will update the shown timer value every second

174

self._update_timer_callback_tag = (GLib.timeout_add

169

self._update_timer_callback_tag = (gobject.timeout_add

175

170

(1000,

176

171

self.update_timer))

177

172

elif not (flag or self._update_timer_callback_tag is None):

178

GLib.source_remove(self._update_timer_callback_tag)

173

gobject.source_remove(self._update_timer_callback_tag)

179

174

self._update_timer_callback_tag = None

180

181

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

175

176

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

182

177

if exitstatus == 0:

183

178

self.logger('Checker for client {} (command "{}")'

184

179

' succeeded'.format(self.properties["Name"],

186

181

self.update()

187

182

return

188

183

# Checker failed

189

if os.WIFEXITED(condition):

184

if exitstatus >= 0:

190

185

self.logger('Checker for client {} (command "{}") failed'

191

186

' with exit code {}'

192

187

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

193

os.WEXITSTATUS(condition)))

194

elif os.WIFSIGNALED(condition):

188

exitstatus))

189

elif signal != 0:

195

190

self.logger('Checker for client {} (command "{}") was'

196

191

' killed by signal {}'

197

192

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

198

os.WTERMSIG(condition)))

193

signal))

194

else:

195

self.logger('Checker for client {} completed'

196

' mysteriously'

197

.format(self.properties["Name"]))

199

198

self.update()

200

199

201

200

def checker_started(self, command):

202

201

"""Server signals that a checker started."""

203

202

self.logger('Client {} started checker "{}"'

204

203

.format(self.properties["Name"],

205

204

command), level=0)

206

205

207

206

def got_secret(self):

208

207

self.logger('Client {} received its secret'

209

208

.format(self.properties["Name"]))

210

209

211

210

def need_approval(self, timeout, default):

212

211

if not default:

213

212

message = 'Client {} needs approval within {} seconds'

215

214

message = 'Client {} will get its secret in {} seconds'

216

215

self.logger(message.format(self.properties["Name"],

217

216

timeout/1000))

218

217

219

218

def rejected(self, reason):

220

219

self.logger('Client {} was rejected; reason: {}'

221

220

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

222

221

223

222

def selectable(self):

224

223

"""Make this a "selectable" widget.

225

224

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

226

225

return True

227

226

228

227

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

229

228

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

230

229

whether we have focus or not.

231

230

This overrides the method from urwid.FlowWidget"""

232

231

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

233

232

234

233

def current_widget(self, focus=False):

235

234

if focus or self.opened:

236

235

return self._focus_widget

237

236

return self._widget

238

237

239

238

def update(self):

240

239

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

241

240

# How to add standout mode to a style

242

with_standout = {"normal": "standout",

243

"bold": "bold-standout",

244

"underline-blink":

245

"underline-blink-standout",

246

"bold-underline-blink":

247

"bold-underline-blink-standout",

248

}

249

241

with_standout = { "normal": "standout",

242

"bold": "bold-standout",

243

"underline-blink":

244

"underline-blink-standout",

245

"bold-underline-blink":

246

"bold-underline-blink-standout",

247

}

248

250

249

# Rebuild focus and non-focus widgets using current properties

251

250

252

251

# Base part of a client. Name!

253

252

base = '{name}: '.format(name=self.properties["Name"])

254

253

if not self.properties["Enabled"]:

255

254

message = "DISABLED"

256

255

self.using_timer(False)

257

256

elif self.properties["ApprovalPending"]:

258

timeout = datetime.timedelta(

259

milliseconds=self.properties["ApprovalDelay"])

257

timeout = datetime.timedelta(milliseconds

258

= self.properties

259

["ApprovalDelay"])

260

last_approval_request = isoformat_to_datetime(

261

self.properties["LastApprovalRequest"])

262

if last_approval_request is not None:

289

message = "enabled"

290

self.using_timer(False)

291

self._text = "{}{}".format(base, message)

292

293

if not urwid.supports_unicode():

294

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

295

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

305

# Run update hook, if any

306

if self.update_hook is not None:

307

self.update_hook()

308

309

def update_timer(self):

310

"""called by GLib. Will indefinitely loop until

311

GLib.source_remove() on tag is called

312

"""

310

"""called by gobject. Will indefinitely loop until

311

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

313

312

self.update()

314

313

return True # Keep calling this

315

314

316

315

def delete(self, **kwargs):

317

316

if self._update_timer_callback_tag is not None:

318

GLib.source_remove(self._update_timer_callback_tag)

317

gobject.source_remove(self._update_timer_callback_tag)

319

318

self._update_timer_callback_tag = None

320

319

for match in self.match_objects:

321

320

match.remove()

323

322

if self.delete_hook is not None:

324

323

self.delete_hook(self)

325

324

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

326

325

327

326

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

328

327

"""Render differently if we have focus.

329

328

This overrides the method from urwid.FlowWidget"""

330

329

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

331

330

focus=focus)

332

331

333

332

def keypress(self, maxcolrow, key):

334

333

"""Handle keys.

335

334

This overrides the method from urwid.FlowWidget"""

336

335

if key == "+":

337

self.proxy.Set(client_interface, "Enabled",

338

dbus.Boolean(True), ignore_reply=True,

339

dbus_interface=dbus.PROPERTIES_IFACE)

336

self.proxy.Enable(dbus_interface = client_interface,

337

ignore_reply=True)

340

338

elif key == "-":

341

self.proxy.Set(client_interface, "Enabled", False,

342

ignore_reply=True,

343

dbus_interface=dbus.PROPERTIES_IFACE)

339

self.proxy.Disable(dbus_interface = client_interface,

340

ignore_reply=True)

344

341

elif key == "a":

345

342

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

346

dbus_interface=client_interface,

343

dbus_interface = client_interface,

347

344

ignore_reply=True)

348

345

elif key == "d":

349

346

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

350

dbus_interface=client_interface,

347

dbus_interface = client_interface,

351

348

ignore_reply=True)

352

349

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

353

350

self.server_proxy_object.RemoveClient(self.proxy

354

351

.object_path,

355

352

ignore_reply=True)

356

353

elif key == "s":

357

self.proxy.Set(client_interface, "CheckerRunning",

358

dbus.Boolean(True), ignore_reply=True,

359

dbus_interface=dbus.PROPERTIES_IFACE)

354

self.proxy.StartChecker(dbus_interface = client_interface,

355

ignore_reply=True)

360

356

elif key == "S":

361

self.proxy.Set(client_interface, "CheckerRunning",

362

dbus.Boolean(False), ignore_reply=True,

363

dbus_interface=dbus.PROPERTIES_IFACE)

357

self.proxy.StopChecker(dbus_interface = client_interface,

358

ignore_reply=True)

364

359

elif key == "C":

365

self.proxy.CheckedOK(dbus_interface=client_interface,

360

self.proxy.CheckedOK(dbus_interface = client_interface,

366

361

ignore_reply=True)

367

362

# xxx

368

363

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

373

368

# self.open()

374

369

else:

375

370

return key

376

371

377

372

def properties_changed(self, interface, properties, invalidated):

378

373

"""Call self.update() if any properties changed.

379

374

This overrides the method from MandosClientPropertyCache"""

380

old_values = {key: self.properties.get(key)

381

for key in properties.keys()}

375

old_values = { key: self.properties.get(key)

376

for key in properties.keys() }

382

377

super(MandosClientWidget, self).properties_changed(

383

378

interface, properties, invalidated)

384

379

if any(old_values[key] != self.properties.get(key)

392

387

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

393

388

"""

394

389

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

395

ret = (super(ConstrainedListBox, self)

396

.keypress(*args, **kwargs))

390

ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)

397

391

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

398

392

return

399

393

return ret

405

399

"""

406

400

def __init__(self, max_log_length=1000, log_level=1):

407

401

DBusGMainLoop(set_as_default=True)

408

402

409

403

self.screen = urwid.curses_display.Screen()

410

404

411

405

self.screen.register_palette((

412

406

("normal",

413

407

"default", "default", None),

418

412

("standout",

419

413

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

420

414

("bold-underline-blink",

421

"bold,underline,blink", "default",

422

"bold,underline,blink"),

415

"bold,underline,blink", "default", "bold,underline,blink"),

423

416

("bold-standout",

424

417

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

425

418

("underline-blink-standout",

429

422

"bold,underline,blink,standout", "default",

430

423

"bold,underline,blink,standout"),

431

424

))

432

425

433

426

if urwid.supports_unicode():

434

self.divider = "─" # \u2500

427

self.divider = "─" # \u2500

428

#self.divider = "━" # \u2501

435

429

else:

436

self.divider = "_" # \u005f

437

430

#self.divider = "-" # \u002d

431

self.divider = "_" # \u005f

432

438

433

self.screen.start()

439

434

440

435

self.size = self.screen.get_cols_rows()

441

436

442

437

self.clients = urwid.SimpleListWalker([])

443

438

self.clients_dict = {}

444

439

445

440

# We will add Text widgets to this list

446

441

self.log = []

447

442

self.max_log_length = max_log_length

448

443

449

444

self.log_level = log_level

450

445

451

446

# We keep a reference to the log widget so we can remove it

452

447

# from the ListWalker without it getting destroyed

453

448

self.logbox = ConstrainedListBox(self.log)

454

449

455

450

# This keeps track of whether self.uilist currently has

456

451

# self.logbox in it or not

457

452

self.log_visible = True

458

453

self.log_wrap = "any"

459

454

460

455

self.rebuild()

461

456

self.log_message_raw(("bold",

462

457

"Mandos Monitor version " + version))

463

458

self.log_message_raw(("bold",

464

459

"q: Quit ?: Help"))

465

460

466

461

self.busname = domain + '.Mandos'

467

self.main_loop = GLib.MainLoop()

468

462

self.main_loop = gobject.MainLoop()

463

469

464

def client_not_found(self, fingerprint, address):

470

465

self.log_message("Client with address {} and fingerprint {}"

471

466

" could not be found"

472

467

.format(address, fingerprint))

473

468

474

469

def rebuild(self):

475

470

"""This rebuilds the User Interface.

476

471

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

477

472

self.uilist = []

478

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

473

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

479

474

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

480

475

clients),

481

# header=urwid.Divider(),

476

#header=urwid.Divider(),

482

477

header=None,

483

footer=urwid.Divider(

484

div_char=self.divider)))

478

footer=

479

urwid.Divider(div_char=

480

self.divider)))

485

481

if self.log_visible:

486

482

self.uilist.append(self.logbox)

487

483

self.topwidget = urwid.Pile(self.uilist)

488

484

489

485

def log_message(self, message, level=1):

490

486

"""Log message formatted with timestamp"""

491

487

if level < self.log_level:

493

489

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

494

490

self.log_message_raw("{}: {}".format(timestamp, message),

495

491

level=level)

496

492

497

493

def log_message_raw(self, markup, level=1):

498

494

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

499

495

if level < self.log_level:

500

496

return

501

497

self.log.append(urwid.Text(markup, wrap=self.log_wrap))

502

if self.max_log_length:

503

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

504

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

498

if (self.max_log_length

499

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

500

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

505

501

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

506

502

coming_from="above")

507

503

self.refresh()

508

504

509

505

def toggle_log_display(self):

510

506

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

511

507

self.log_visible = not self.log_visible

512

508

self.rebuild()

513

509

self.log_message("Log visibility changed to: {}"

514

510

.format(self.log_visible), level=0)

515

511

516

512

def change_log_display(self):

517

513

"""Change type of log display.

518

514

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

524

520

textwidget.set_wrap_mode(self.log_wrap)

525

521

self.log_message("Wrap mode: {}".format(self.log_wrap),

526

522

level=0)

527

528

def find_and_remove_client(self, path, interfaces):

523

524

def find_and_remove_client(self, path, name):

529

525

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

530

531

This is connected to the InterfacesRemoved signal from the

526

527

This is connected to the ClientRemoved signal from the

532

528

Mandos server object."""

533

if client_interface not in interfaces:

534

# Not a Mandos client object; ignore

535

return

536

529

try:

537

530

client = self.clients_dict[path]

538

531

except KeyError:

539

532

# not found?

540

self.log_message("Unknown client {!r} removed"

541

.format(path))

533

self.log_message("Unknown client {!r} ({!r}) removed"

534

.format(name, path))

542

535

return

543

536

client.delete()

544

545

def add_new_client(self, path, ifs_and_props):

546

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

547

548

This is connected to the InterfacesAdded signal from the

549

Mandos server object.

550

"""

551

if client_interface not in ifs_and_props:

552

# Not a Mandos client object; ignore

553

return

537

538

def add_new_client(self, path):

554

539

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

555

self.add_client(MandosClientWidget(

556

server_proxy_object=self.mandos_serv,

557

proxy_object=client_proxy_object,

558

update_hook=self.refresh,

559

delete_hook=self.remove_client,

560

logger=self.log_message,

561

properties=dict(ifs_and_props[client_interface])),

540

self.add_client(MandosClientWidget(server_proxy_object

541

=self.mandos_serv,

542

proxy_object

543

=client_proxy_object,

544

update_hook

545

=self.refresh,

546

delete_hook

547

=self.remove_client,

548

logger

549

=self.log_message),

562

550

path=path)

563

551

564

552

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

565

553

self.clients.append(client)

566

554

if path is None:

568

556

self.clients_dict[path] = client

569

557

self.clients.sort(key=lambda c: c.properties["Name"])

570

558

self.refresh()

571

559

572

560

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

573

561

self.clients.remove(client)

574

562

if path is None:

575

563

path = client.proxy.object_path

576

564

del self.clients_dict[path]

577

565

self.refresh()

578

566

579

567

def refresh(self):

580

568

"""Redraw the screen"""

581

569

canvas = self.topwidget.render(self.size, focus=True)

582

570

self.screen.draw_screen(self.size, canvas)

583

571

584

572

def run(self):

585

573

"""Start the main loop and exit when it's done."""

586

574

self.bus = dbus.SystemBus()

587

575

mandos_dbus_objc = self.bus.get_object(

588

576

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

589

self.mandos_serv = dbus.Interface(

590

mandos_dbus_objc, dbus_interface=server_interface)

577

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

578

dbus_interface

579

= server_interface)

591

580

try:

592

581

mandos_clients = (self.mandos_serv

593

582

.GetAllClientsWithProperties())

594

583

if not mandos_clients:

595

self.log_message_raw(("bold",

596

"Note: Server has no clients."))

584

self.log_message_raw(("bold", "Note: Server has no clients."))

597

585

except dbus.exceptions.DBusException:

598

self.log_message_raw(("bold",

599

"Note: No Mandos server running."))

586

self.log_message_raw(("bold", "Note: No Mandos server running."))

600

587

mandos_clients = dbus.Dictionary()

601

588

602

589

(self.mandos_serv

603

.connect_to_signal("InterfacesRemoved",

590

.connect_to_signal("ClientRemoved",

604

591

self.find_and_remove_client,

605

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

592

dbus_interface=server_interface,

606

593

byte_arrays=True))

607

594

(self.mandos_serv

608

.connect_to_signal("InterfacesAdded",

595

.connect_to_signal("ClientAdded",

609

596

self.add_new_client,

610

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

597

dbus_interface=server_interface,

611

598

byte_arrays=True))

612

599

(self.mandos_serv

613

600

.connect_to_signal("ClientNotFound",

617

604

for path, client in mandos_clients.items():

618

605

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

619

606

path)

620

self.add_client(MandosClientWidget(

621

server_proxy_object=self.mandos_serv,

622

proxy_object=client_proxy_object,

623

properties=client,

624

update_hook=self.refresh,

625

delete_hook=self.remove_client,

626

logger=self.log_message),

607

self.add_client(MandosClientWidget(server_proxy_object

608

=self.mandos_serv,

609

proxy_object

610

=client_proxy_object,

611

properties=client,

612

update_hook

613

=self.refresh,

614

delete_hook

615

=self.remove_client,

616

logger

617

=self.log_message),

627

618

path=path)

628

619

629

620

self.refresh()

630

self._input_callback_tag = (GLib.io_add_watch

621

self._input_callback_tag = (gobject.io_add_watch

631

622

(sys.stdin.fileno(),

632

GLib.IO_IN,

623

gobject.IO_IN,

633

624

self.process_input))

634

625

self.main_loop.run()

635

626

# Main loop has finished, we should close everything now

636

GLib.source_remove(self._input_callback_tag)

627

gobject.source_remove(self._input_callback_tag)

637

628

self.screen.stop()

638

629

639

630

def stop(self):

640

631

self.main_loop.quit()

641

632

642

633

def process_input(self, source, condition):

643

634

keys = self.screen.get_input()

644

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

645

"ctrl p": "up", # Emacs

646

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

647

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

648

" ": "page down", # less

649

"f": "page down", # less

650

"b": "page up", # less

651

"j": "down", # vi

652

"k": "up", # vi

653

}

635

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

636

"ctrl p": "up", # Emacs

637

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

638

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

639

" ": "page down", # less

640

"f": "page down", # less

641

"b": "page up", # less

642

"j": "down", # vi

643

"k": "up", # vi

644

}

654

645

for key in keys:

655

646

try:

656

647

key = translations[key]

657

648

except KeyError: # :-)

658

649

pass

659

650

660

651

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

661

652

self.stop()

662

653

break

710

701

else:

711

702

self.log_level = 0

712

703

self.log_message("Verbose mode: On")

713

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

714

# or key == ">"):

715

# pass # xxx end-of-buffer

716

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

717

# or key == "<"):

718

# pass # xxx beginning-of-buffer

719

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

720

# pass # xxx move-end-of-line

721

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

722

# pass # xxx move-beginning-of-line

723

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

724

# pass # xxx left

725

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

726

# pass # xxx right

727

# elif key == "a":

728

# pass # scroll up log

729

# elif key == "z":

730

# pass # scroll down log

704

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

705

# or key == ">"):

706

# pass # xxx end-of-buffer

707

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

708

# or key == "<"):

709

# pass # xxx beginning-of-buffer

710

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

711

# pass # xxx move-end-of-line

712

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

713

# pass # xxx move-beginning-of-line

714

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

715

# pass # xxx left

716

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

717

# pass # xxx right

718

#elif key == "a":

719

# pass # scroll up log

720

#elif key == "z":

721

# pass # scroll down log

731

722

elif self.topwidget.selectable():

732

723

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

733

724

self.refresh()

734

725

return True

735

726

736

737

727

ui = UserInterface()

738

728

try:

739

729

ui.run()