/mandos/release : revision 237.25.5

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

175

181

176

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

182

177

if exitstatus == 0:

183

178

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

196

191

' killed by signal {}'

197

192

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

198

193

os.WTERMSIG(condition)))

194

elif os.WCOREDUMP(condition):

195

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

196

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

197

command))

198

else:

199

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

200

' mysteriously'

201

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

199

202

self.update()

200

203

201

204

def checker_started(self, command):

202

205

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

203

206

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

204

207

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

205

208

command), level=0)

206

209

207

210

def got_secret(self):

208

211

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

209

212

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

210

213

211

214

def need_approval(self, timeout, default):

212

215

if not default:

213

216

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

215

218

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

216

219

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

217

220

timeout/1000))

218

221

219

222

def rejected(self, reason):

220

223

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

221

224

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

222

225

223

226

def selectable(self):

224

227

"""Make this a "selectable" widget.

225

228

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

226

229

return True

227

230

228

231

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

229

232

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

230

233

whether we have focus or not.

231

234

This overrides the method from urwid.FlowWidget"""

232

235

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

233

236

234

237

def current_widget(self, focus=False):

235

238

if focus or self.opened:

236

239

return self._focus_widget

237

240

return self._widget

238

241

239

242

def update(self):

240

243

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

241

244

# 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

245

with_standout = { "normal": "standout",

246

"bold": "bold-standout",

247

"underline-blink":

248

"underline-blink-standout",

249

"bold-underline-blink":

250

"bold-underline-blink-standout",

251

}

252

250

253

# Rebuild focus and non-focus widgets using current properties

251

254

252

255

# Base part of a client. Name!

253

256

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

254

257

if not self.properties["Enabled"]:

255

258

message = "DISABLED"

256

259

self.using_timer(False)

257

260

elif self.properties["ApprovalPending"]:

258

timeout = datetime.timedelta(

259

milliseconds=self.properties["ApprovalDelay"])

261

timeout = datetime.timedelta(milliseconds

262

= self.properties

263

["ApprovalDelay"])

260

264

last_approval_request = isoformat_to_datetime(

261

265

self.properties["LastApprovalRequest"])

262

266

if last_approval_request is not None:

289

293

message = "enabled"

290

294

self.using_timer(False)

291

295

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

292

296

293

297

if not urwid.supports_unicode():

294

298

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

295

299

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

305

309

# Run update hook, if any

306

310

if self.update_hook is not None:

307

311

self.update_hook()

308

312

309

313

def update_timer(self):

310

"""called by GLib. Will indefinitely loop until

311

GLib.source_remove() on tag is called

312

"""

314

"""called by gobject. Will indefinitely loop until

315

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

313

316

self.update()

314

317

return True # Keep calling this

315

318

316

319

def delete(self, **kwargs):

317

320

if self._update_timer_callback_tag is not None:

318

GLib.source_remove(self._update_timer_callback_tag)

321

gobject.source_remove(self._update_timer_callback_tag)

319

322

self._update_timer_callback_tag = None

320

323

for match in self.match_objects:

321

324

match.remove()

323

326

if self.delete_hook is not None:

324

327

self.delete_hook(self)

325

328

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

326

329

327

330

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

328

331

"""Render differently if we have focus.

329

332

This overrides the method from urwid.FlowWidget"""

330

333

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

331

334

focus=focus)

332

335

333

336

def keypress(self, maxcolrow, key):

334

337

"""Handle keys.

335

338

This overrides the method from urwid.FlowWidget"""

336

339

if key == "+":

337

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

338

dbus.Boolean(True), ignore_reply=True,

339

dbus_interface=dbus.PROPERTIES_IFACE)

340

self.proxy.Enable(dbus_interface = client_interface,

341

ignore_reply=True)

340

342

elif key == "-":

341

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

342

ignore_reply=True,

343

dbus_interface=dbus.PROPERTIES_IFACE)

343

self.proxy.Disable(dbus_interface = client_interface,

344

ignore_reply=True)

344

345

elif key == "a":

345

346

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

346

dbus_interface=client_interface,

347

dbus_interface = client_interface,

347

348

ignore_reply=True)

348

349

elif key == "d":

349

350

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

350

dbus_interface=client_interface,

351

dbus_interface = client_interface,

351

352

ignore_reply=True)

352

353

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

353

354

self.server_proxy_object.RemoveClient(self.proxy

354

355

.object_path,

355

356

ignore_reply=True)

356

357

elif key == "s":

357

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

358

dbus.Boolean(True), ignore_reply=True,

359

dbus_interface=dbus.PROPERTIES_IFACE)

358

self.proxy.StartChecker(dbus_interface = client_interface,

359

ignore_reply=True)

360

elif key == "S":

361

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

362

dbus.Boolean(False), ignore_reply=True,

363

dbus_interface=dbus.PROPERTIES_IFACE)

361

self.proxy.StopChecker(dbus_interface = client_interface,

362

ignore_reply=True)

364

363

elif key == "C":

365

self.proxy.CheckedOK(dbus_interface=client_interface,

364

self.proxy.CheckedOK(dbus_interface = client_interface,

366

365

ignore_reply=True)

367

366

# xxx

368

367

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

373

372

# self.open()

374

373

else:

375

374

return key

376

375

377

376

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

378

377

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

379

378

This overrides the method from MandosClientPropertyCache"""

380

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

381

for key in properties.keys()}

379

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

380

for key in properties.keys() }

382

381

super(MandosClientWidget, self).properties_changed(

383

382

interface, properties, invalidated)

384

383

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

392

391

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

393

392

"""

394

393

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

395

ret = (super(ConstrainedListBox, self)

396

.keypress(*args, **kwargs))

394

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

397

395

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

398

396

return

399

397

return ret

405

403

"""

406

404

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

407

405

DBusGMainLoop(set_as_default=True)

408

406

409

407

self.screen = urwid.curses_display.Screen()

410

408

411

409

self.screen.register_palette((

412

410

("normal",

413

411

"default", "default", None),

418

416

("standout",

419

417

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

420

418

("bold-underline-blink",

421

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

422

"bold,underline,blink"),

419

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

423

420

("bold-standout",

424

421

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

425

422

("underline-blink-standout",

429

426

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

430

427

"bold,underline,blink,standout"),

431

428

))

432

429

433

430

if urwid.supports_unicode():

434

self.divider = "─" # \u2500

431

self.divider = "─" # \u2500

432

#self.divider = "━" # \u2501

435

433

else:

436

self.divider = "_" # \u005f

437

434

#self.divider = "-" # \u002d

435

self.divider = "_" # \u005f

436

438

437

self.screen.start()

439

438

440

439

self.size = self.screen.get_cols_rows()

441

440

442

441

self.clients = urwid.SimpleListWalker([])

443

442

self.clients_dict = {}

444

443

445

444

# We will add Text widgets to this list

446

445

self.log = []

447

446

self.max_log_length = max_log_length

448

447

449

448

self.log_level = log_level

450

449

451

450

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

452

451

# from the ListWalker without it getting destroyed

453

452

self.logbox = ConstrainedListBox(self.log)

454

453

455

454

# This keeps track of whether self.uilist currently has

456

455

# self.logbox in it or not

457

456

self.log_visible = True

458

457

self.log_wrap = "any"

459

458

460

459

self.rebuild()

461

460

self.log_message_raw(("bold",

462

461

"Mandos Monitor version " + version))

463

462

self.log_message_raw(("bold",

464

463

"q: Quit ?: Help"))

465

464

466

465

self.busname = domain + '.Mandos'

467

self.main_loop = GLib.MainLoop()

468

466

self.main_loop = gobject.MainLoop()

467

469

468

def client_not_found(self, fingerprint, address):

470

469

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

471

470

" could not be found"

472

471

.format(address, fingerprint))

473

472

474

473

def rebuild(self):

475

474

"""This rebuilds the User Interface.

476

475

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

477

476

self.uilist = []

478

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

477

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

479

478

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

480

479

clients),

481

# header=urwid.Divider(),

480

#header=urwid.Divider(),

482

481

header=None,

483

footer=urwid.Divider(

484

div_char=self.divider)))

482

footer=

483

urwid.Divider(div_char=

484

self.divider)))

485

if self.log_visible:

486

self.uilist.append(self.logbox)

487

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

488

489

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

490

"""Log message formatted with timestamp"""

491

if level < self.log_level:

493

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

494

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

495

level=level)

496

497

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

498

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

499

if level < self.log_level:

500

return

501

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]

502

if (self.max_log_length

503

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

504

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

505

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

506

coming_from="above")

507

self.refresh()

508

509

def toggle_log_display(self):

510

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

511

self.log_visible = not self.log_visible

512

self.rebuild()

513

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

514

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

515

516

def change_log_display(self):

517

"""Change type of log display.

518

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

524

textwidget.set_wrap_mode(self.log_wrap)

525

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

526

level=0)

527

528

def find_and_remove_client(self, path, interfaces):

527

528

def find_and_remove_client(self, path, name):

529

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

530

531

This is connected to the InterfacesRemoved signal from the

530

531

This is connected to the ClientRemoved signal from the

532

Mandos server object."""

533

if client_interface not in interfaces:

534

# Not a Mandos client object; ignore

535

return

536

533

try:

537

534

client = self.clients_dict[path]

538

535

except KeyError:

539

536

# not found?

540

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

541

.format(path))

537

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

538

.format(name, path))

542

539

return

543

540

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

541

542

def add_new_client(self, path):

554

543

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

544

self.add_client(MandosClientWidget(server_proxy_object

545

=self.mandos_serv,

546

proxy_object

547

=client_proxy_object,

548

update_hook

549

=self.refresh,

550

delete_hook

551

=self.remove_client,

552

logger

553

=self.log_message),

562

554

path=path)

563

555

564

556

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

565

557

self.clients.append(client)

566

558

if path is None:

568

560

self.clients_dict[path] = client

569

561

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

570

562

self.refresh()

571

563

572

564

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

573

565

self.clients.remove(client)

574

566

if path is None:

575

567

path = client.proxy.object_path

576

568

del self.clients_dict[path]

577

569

self.refresh()

578

570

579

571

def refresh(self):

580

572

"""Redraw the screen"""

581

573

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

582

574

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

583

575

584

576

def run(self):

585

577

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

586

578

self.bus = dbus.SystemBus()

587

579

mandos_dbus_objc = self.bus.get_object(

588

580

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

589

self.mandos_serv = dbus.Interface(

590

mandos_dbus_objc, dbus_interface=server_interface)

581

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

582

dbus_interface

583

= server_interface)

591

584

try:

592

585

mandos_clients = (self.mandos_serv

593

586

.GetAllClientsWithProperties())

594

587

if not mandos_clients:

595

self.log_message_raw(("bold",

596

"Note: Server has no clients."))

588

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

597

589

except dbus.exceptions.DBusException:

598

self.log_message_raw(("bold",

599

"Note: No Mandos server running."))

590

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

600

591

mandos_clients = dbus.Dictionary()

601

592

602

593

(self.mandos_serv

603

.connect_to_signal("InterfacesRemoved",

594

.connect_to_signal("ClientRemoved",

604

595

self.find_and_remove_client,

605

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

596

dbus_interface=server_interface,

606

597

byte_arrays=True))

607

598

(self.mandos_serv

608

.connect_to_signal("InterfacesAdded",

599

.connect_to_signal("ClientAdded",

609

600

self.add_new_client,

610

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

601

dbus_interface=server_interface,

611

602

byte_arrays=True))

612

603

(self.mandos_serv

613

604

.connect_to_signal("ClientNotFound",

617

608

for path, client in mandos_clients.items():

618

609

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

619

610

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

611

self.add_client(MandosClientWidget(server_proxy_object

612

=self.mandos_serv,

613

proxy_object

614

=client_proxy_object,

615

properties=client,

616

update_hook

617

=self.refresh,

618

delete_hook

619

=self.remove_client,

620

logger

621

=self.log_message),

627

622

path=path)

628

623

629

624

self.refresh()

630

self._input_callback_tag = (GLib.io_add_watch

625

self._input_callback_tag = (gobject.io_add_watch

631

626

(sys.stdin.fileno(),

632

GLib.IO_IN,

627

gobject.IO_IN,

633

628

self.process_input))

634

629

self.main_loop.run()

635

630

# Main loop has finished, we should close everything now

636

GLib.source_remove(self._input_callback_tag)

631

gobject.source_remove(self._input_callback_tag)

637

632

self.screen.stop()

638

633

639

634

def stop(self):

640

635

self.main_loop.quit()

641

636

642

637

def process_input(self, source, condition):

643

638

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

}

639

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

640

"ctrl p": "up", # Emacs

641

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

642

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

643

" ": "page down", # less

644

"f": "page down", # less

645

"b": "page up", # less

646

"j": "down", # vi

647

"k": "up", # vi

648

}

654

649

for key in keys:

655

650

try:

656

651

key = translations[key]

657

652

except KeyError: # :-)

658

653

pass

659

654

660

655

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

661

656

self.stop()

662

657

break

710

705

else:

711

706

self.log_level = 0

712

707

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

708

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

709

# or key == ">"):

710

# pass # xxx end-of-buffer

711

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

712

# or key == "<"):

713

# pass # xxx beginning-of-buffer

714

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

715

# pass # xxx move-end-of-line

716

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

717

# pass # xxx move-beginning-of-line

718

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

719

# pass # xxx left

720

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

721

# pass # xxx right

722

#elif key == "a":

723

# pass # scroll up log

724

#elif key == "z":

725

# pass # scroll down log

731

726

elif self.topwidget.selectable():

732

727

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

733

728

self.refresh()

734

729

return True

735

730

736

737

731

ui = UserInterface()

738

732

try:

739

733

ui.run()