/mandos/release : revision 358

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

try:

43

import gobject

44

except ImportError:

45

from gi.repository import GObject as gobject

42

from gi.repository import GLib

46

43

47

44

import dbus

48

45

49

46

import locale

50

47

48

import logging

49

51

50

if sys.version_info.major == 2:

52

51

str = unicode

53

52

54

53

locale.setlocale(locale.LC_ALL, '')

55

54

56

import logging

57

55

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

58

56

59

57

# Some useful constants

60

58

domain = 'se.recompile'

61

59

server_interface = domain + '.Mandos'

62

60

client_interface = domain + '.Mandos.Client'

63

version = "1.7.1"

61

version = "1.7.14"

64

62

65

63

try:

66

64

dbus.OBJECT_MANAGER_IFACE

67

65

except AttributeError:

68

66

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

69

67

68

70

69

def isoformat_to_datetime(iso):

71

70

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

72

71

if not iso:

80

79

int(day),

81

80

int(hour),

82

81

int(minute),

83

int(second), # Whole seconds

84

int(fraction*1000000)) # Microseconds

82

int(second), # Whole seconds

83

int(fraction*1000000)) # Microseconds

84

85

86

class MandosClientPropertyCache(object):

87

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

89

changed.

90

"""

91

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

92

self.proxy = proxy_object # Mandos Client proxy object

92

self.proxy = proxy_object # Mandos Client proxy object

93

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

94

self.property_changed_match = (

95

self.proxy.connect_to_signal("PropertiesChanged",

96

self.properties_changed,

97

dbus.PROPERTIES_IFACE,

98

byte_arrays=True))

99

100

if properties is None:

101

self.properties.update(

102

self.proxy.GetAll(client_interface,

103

dbus_interface

104

= dbus.PROPERTIES_IFACE))

105

101

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

102

client_interface,

103

dbus_interface=dbus.PROPERTIES_IFACE))

104

106

105

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

107

106

108

107

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

109

108

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

110

109

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

112

111

# Update properties dict with new value

113

112

if interface == client_interface:

114

113

self.properties.update(properties)

115

114

116

115

def delete(self):

117

116

self.property_changed_match.remove()

118

117

120

119

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

121

120

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

122

121

"""

123

122

124

123

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

125

124

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

126

125

# Called on update

131

130

self.server_proxy_object = server_proxy_object

132

131

# Logger

133

132

self.logger = logger

134

133

135

134

self._update_timer_callback_tag = None

136

135

137

136

# The widget shown normally

138

137

self._text_widget = urwid.Text("")

139

138

# The widget shown when we have focus

141

140

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

142

141

self.update()

143

142

self.opened = False

144

143

145

144

self.match_objects = (

146

145

self.proxy.connect_to_signal("CheckerCompleted",

147

146

self.checker_completed,

165

164

byte_arrays=True))

166

165

self.logger('Created client {}'

167

166

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

168

167

169

168

def using_timer(self, flag):

170

169

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

171

170

activated or deactivated.

172

171

"""

173

172

if flag and self._update_timer_callback_tag is None:

174

173

# Will update the shown timer value every second

175

self._update_timer_callback_tag = (gobject.timeout_add

174

self._update_timer_callback_tag = (GLib.timeout_add

176

175

(1000,

177

176

self.update_timer))

178

177

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

179

gobject.source_remove(self._update_timer_callback_tag)

178

GLib.source_remove(self._update_timer_callback_tag)

180

179

self._update_timer_callback_tag = None

181

180

182

181

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

183

182

if exitstatus == 0:

184

183

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

198

197

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

199

198

os.WTERMSIG(condition)))

200

199

self.update()

201

200

202

201

def checker_started(self, command):

203

202

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

204

203

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

205

204

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

206

205

command), level=0)

207

206

208

207

def got_secret(self):

209

208

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

210

209

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

211

210

212

211

def need_approval(self, timeout, default):

213

212

if not default:

214

213

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

216

215

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

217

216

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

218

217

timeout/1000))

219

218

220

219

def rejected(self, reason):

221

220

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

222

221

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

223

222

224

223

def selectable(self):

225

224

"""Make this a "selectable" widget.

226

225

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

227

226

return True

228

227

229

228

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

230

229

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

231

230

whether we have focus or not.

232

231

This overrides the method from urwid.FlowWidget"""

233

232

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

234

233

235

234

def current_widget(self, focus=False):

236

235

if focus or self.opened:

237

236

return self._focus_widget

238

237

return self._widget

239

238

240

239

def update(self):

241

240

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

242

241

# How to add standout mode to a style

243

with_standout = { "normal": "standout",

244

"bold": "bold-standout",

245

"underline-blink":

246

"underline-blink-standout",

247

"bold-underline-blink":

248

"bold-underline-blink-standout",

249

}

250

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

251

250

# Rebuild focus and non-focus widgets using current properties

252

251

253

252

# Base part of a client. Name!

254

253

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

255

254

if not self.properties["Enabled"]:

256

255

message = "DISABLED"

257

256

self.using_timer(False)

258

257

elif self.properties["ApprovalPending"]:

259

timeout = datetime.timedelta(milliseconds

260

= self.properties

261

["ApprovalDelay"])

258

timeout = datetime.timedelta(

259

milliseconds=self.properties["ApprovalDelay"])

262

260

last_approval_request = isoformat_to_datetime(

263

261

self.properties["LastApprovalRequest"])

264

262

if last_approval_request is not None:

291

289

message = "enabled"

292

290

self.using_timer(False)

293

291

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

294

292

295

293

if not urwid.supports_unicode():

296

294

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

297

295

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

307

305

# Run update hook, if any

308

306

if self.update_hook is not None:

309

307

self.update_hook()

310

308

311

309

def update_timer(self):

312

"""called by gobject. Will indefinitely loop until

313

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

310

"""called by GLib. Will indefinitely loop until

311

GLib.source_remove() on tag is called

312

"""

314

313

self.update()

315

314

return True # Keep calling this

316

315

317

316

def delete(self, **kwargs):

318

317

if self._update_timer_callback_tag is not None:

319

gobject.source_remove(self._update_timer_callback_tag)

318

GLib.source_remove(self._update_timer_callback_tag)

320

319

self._update_timer_callback_tag = None

321

320

for match in self.match_objects:

322

321

match.remove()

324

323

if self.delete_hook is not None:

325

324

self.delete_hook(self)

326

325

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

327

326

328

327

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

329

328

"""Render differently if we have focus.

330

329

This overrides the method from urwid.FlowWidget"""

331

330

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

332

331

focus=focus)

333

332

334

333

def keypress(self, maxcolrow, key):

335

334

"""Handle keys.

336

335

This overrides the method from urwid.FlowWidget"""

337

336

if key == "+":

338

337

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

339

dbus.Boolean(True), ignore_reply = True,

340

dbus_interface = dbus.PROPERTIES_IFACE)

338

dbus.Boolean(True), ignore_reply=True,

339

dbus_interface=dbus.PROPERTIES_IFACE)

341

340

elif key == "-":

342

341

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

343

ignore_reply = True,

344

dbus_interface = dbus.PROPERTIES_IFACE)

342

ignore_reply=True,

343

dbus_interface=dbus.PROPERTIES_IFACE)

345

344

elif key == "a":

346

345

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

347

dbus_interface = client_interface,

346

dbus_interface=client_interface,

348

347

ignore_reply=True)

349

348

elif key == "d":

350

349

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

351

dbus_interface = client_interface,

350

dbus_interface=client_interface,

352

351

ignore_reply=True)

353

352

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

354

353

self.server_proxy_object.RemoveClient(self.proxy

356

355

ignore_reply=True)

357

356

elif key == "s":

358

357

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

359

dbus.Boolean(True), ignore_reply = True,

360

dbus_interface = dbus.PROPERTIES_IFACE)

358

dbus.Boolean(True), ignore_reply=True,

359

dbus_interface=dbus.PROPERTIES_IFACE)

361

360

elif key == "S":

362

361

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

363

dbus.Boolean(False), ignore_reply = True,

364

dbus_interface = dbus.PROPERTIES_IFACE)

362

dbus.Boolean(False), ignore_reply=True,

363

dbus_interface=dbus.PROPERTIES_IFACE)

365

364

elif key == "C":

366

self.proxy.CheckedOK(dbus_interface = client_interface,

365

self.proxy.CheckedOK(dbus_interface=client_interface,

367

366

ignore_reply=True)

368

367

# xxx

369

368

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

374

373

# self.open()

375

374

else:

376

375

return key

377

376

378

377

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

379

378

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

380

379

This overrides the method from MandosClientPropertyCache"""

381

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

382

for key in properties.keys() }

380

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

381

for key in properties.keys()}

383

382

super(MandosClientWidget, self).properties_changed(

384

383

interface, properties, invalidated)

385

384

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

393

392

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

394

393

"""

395

394

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

396

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

395

ret = (super(ConstrainedListBox, self)

396

.keypress(*args, **kwargs))

397

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

398

return

399

return ret

405

"""

406

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

407

DBusGMainLoop(set_as_default=True)

408

409

self.screen = urwid.curses_display.Screen()

410

411

self.screen.register_palette((

412

("normal",

413

"default", "default", None),

418

("standout",

419

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

420

("bold-underline-blink",

421

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

421

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

422

"bold,underline,blink"),

422

423

("bold-standout",

423

424

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

424

425

("underline-blink-standout",

428

429

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

429

430

"bold,underline,blink,standout"),

430

431

))

431

432

433

if urwid.supports_unicode():

433

self.divider = "─" # \u2500

434

#self.divider = "━" # \u2501

434

self.divider = "─" # \u2500

435

else:

436

#self.divider = "-" # \u002d

437

self.divider = "_" # \u005f

438

436

self.divider = "_" # \u005f

437

439

438

self.screen.start()

440

439

441

440

self.size = self.screen.get_cols_rows()

442

441

443

442

self.clients = urwid.SimpleListWalker([])

444

443

self.clients_dict = {}

445

444

446

445

# We will add Text widgets to this list

447

446

self.log = []

448

447

self.max_log_length = max_log_length

449

448

450

449

self.log_level = log_level

451

450

452

451

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

453

452

# from the ListWalker without it getting destroyed

454

453

self.logbox = ConstrainedListBox(self.log)

455

454

456

455

# This keeps track of whether self.uilist currently has

457

456

# self.logbox in it or not

458

457

self.log_visible = True

459

458

self.log_wrap = "any"

460

459

461

460

self.rebuild()

462

461

self.log_message_raw(("bold",

463

462

"Mandos Monitor version " + version))

464

463

self.log_message_raw(("bold",

465

464

"q: Quit ?: Help"))

466

465

467

466

self.busname = domain + '.Mandos'

468

self.main_loop = gobject.MainLoop()

469

467

self.main_loop = GLib.MainLoop()

468

470

469

def client_not_found(self, fingerprint, address):

471

470

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

472

471

" could not be found"

473

472

.format(address, fingerprint))

474

473

475

474

def rebuild(self):

476

475

"""This rebuilds the User Interface.

477

476

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

478

477

self.uilist = []

479

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

478

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

480

479

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

481

480

clients),

482

#header=urwid.Divider(),

481

# header=urwid.Divider(),

483

482

header=None,

484

footer=

485

urwid.Divider(div_char=

486

self.divider)))

483

footer=urwid.Divider(

484

div_char=self.divider)))

487

485

if self.log_visible:

488

486

self.uilist.append(self.logbox)

489

487

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

490

488

491

489

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

492

490

"""Log message formatted with timestamp"""

493

491

if level < self.log_level:

495

493

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

496

494

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

497

495

level=level)

498

496

499

497

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

500

498

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

501

499

if level < self.log_level:

502

500

return

503

501

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

504

if (self.max_log_length

505

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

506

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

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]

507

505

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

508

506

coming_from="above")

509

507

self.refresh()

510

508

511

509

def toggle_log_display(self):

512

510

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

513

511

self.log_visible = not self.log_visible

514

512

self.rebuild()

515

513

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

516

514

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

517

515

518

516

def change_log_display(self):

519

517

"""Change type of log display.

520

518

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

526

524

textwidget.set_wrap_mode(self.log_wrap)

527

525

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

528

526

level=0)

529

527

530

528

def find_and_remove_client(self, path, interfaces):

531

529

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

532

530

533

531

This is connected to the InterfacesRemoved signal from the

534

532

Mandos server object."""

535

533

if client_interface not in interfaces:

543

541

.format(path))

544

542

return

545

543

client.delete()

546

544

547

545

def add_new_client(self, path, ifs_and_props):

548

546

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

549

547

550

548

This is connected to the InterfacesAdded signal from the

551

549

Mandos server object.

552

550

"""

554

552

# Not a Mandos client object; ignore

555

553

return

556

554

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

557

self.add_client(MandosClientWidget(server_proxy_object

558

=self.mandos_serv,

559

proxy_object

560

=client_proxy_object,

561

update_hook

562

=self.refresh,

563

delete_hook

564

=self.remove_client,

565

logger

566

=self.log_message,

567

properties

568

= dict(ifs_and_props[

569

client_interface])),

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

570

562

path=path)

571

563

572

564

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

573

565

self.clients.append(client)

574

566

if path is None:

576

568

self.clients_dict[path] = client

577

569

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

578

570

self.refresh()

579

571

580

572

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

581

573

self.clients.remove(client)

582

574

if path is None:

583

575

path = client.proxy.object_path

584

576

del self.clients_dict[path]

585

577

self.refresh()

586

578

587

579

def refresh(self):

588

580

"""Redraw the screen"""

589

581

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

590

582

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

591

583

592

584

def run(self):

593

585

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

594

586

self.bus = dbus.SystemBus()

595

587

mandos_dbus_objc = self.bus.get_object(

596

588

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

597

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

598

dbus_interface

599

= server_interface)

589

self.mandos_serv = dbus.Interface(

590

mandos_dbus_objc, dbus_interface=server_interface)

600

591

try:

601

592

mandos_clients = (self.mandos_serv

602

593

.GetAllClientsWithProperties())

603

594

if not mandos_clients:

604

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

595

self.log_message_raw(("bold",

596

"Note: Server has no clients."))

605

597

except dbus.exceptions.DBusException:

606

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

598

self.log_message_raw(("bold",

599

"Note: No Mandos server running."))

607

600

mandos_clients = dbus.Dictionary()

608

601

609

602

(self.mandos_serv

610

603

.connect_to_signal("InterfacesRemoved",

611

604

self.find_and_remove_client,

612

dbus_interface

613

= dbus.OBJECT_MANAGER_IFACE,

605

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

614

606

byte_arrays=True))

615

607

(self.mandos_serv

616

608

.connect_to_signal("InterfacesAdded",

617

609

self.add_new_client,

618

dbus_interface

619

= dbus.OBJECT_MANAGER_IFACE,

610

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

620

611

byte_arrays=True))

621

612

(self.mandos_serv

622

613

.connect_to_signal("ClientNotFound",

626

617

for path, client in mandos_clients.items():

627

618

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

628

619

path)

629

self.add_client(MandosClientWidget(server_proxy_object

630

=self.mandos_serv,

631

proxy_object

632

=client_proxy_object,

633

properties=client,

634

update_hook

635

=self.refresh,

636

delete_hook

637

=self.remove_client,

638

logger

639

=self.log_message),

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

640

627

path=path)

641

628

642

629

self.refresh()

643

self._input_callback_tag = (gobject.io_add_watch

630

self._input_callback_tag = (GLib.io_add_watch

644

631

(sys.stdin.fileno(),

645

gobject.IO_IN,

632

GLib.IO_IN,

646

633

self.process_input))

647

634

self.main_loop.run()

648

635

# Main loop has finished, we should close everything now

649

gobject.source_remove(self._input_callback_tag)

636

GLib.source_remove(self._input_callback_tag)

650

637

self.screen.stop()

651

638

652

639

def stop(self):

653

640

self.main_loop.quit()

654

641

655

642

def process_input(self, source, condition):

656

643

keys = self.screen.get_input()

657

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

658

"ctrl p": "up", # Emacs

659

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

660

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

661

" ": "page down", # less

662

"f": "page down", # less

663

"b": "page up", # less

664

"j": "down", # vi

665

"k": "up", # vi

666

}

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

}

667

654

for key in keys:

668

655

try:

669

656

key = translations[key]

670

657

except KeyError: # :-)

671

658

pass

672

659

673

660

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

674

661

self.stop()

675

662

break

723

710

else:

724

711

self.log_level = 0

725

712

self.log_message("Verbose mode: On")

726

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

727

# or key == ">"):

728

# pass # xxx end-of-buffer

729

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

730

# or key == "<"):

731

# pass # xxx beginning-of-buffer

732

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

733

# pass # xxx move-end-of-line

734

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

735

# pass # xxx move-beginning-of-line

736

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

737

# pass # xxx left

738

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

739

# pass # xxx right

740

#elif key == "a":

741

# pass # scroll up log

742

#elif key == "z":

743

# pass # scroll down log

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

744

731

elif self.topwidget.selectable():

745

732

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

746

733

self.refresh()

747

734

return True

748

735

736

749

737

ui = UserInterface()

750

738

try:

751

739

ui.run()