/mandos/trunk : revision 795

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"

63

version = "1.7.1"

62

64

63

65

try:

64

66

dbus.OBJECT_MANAGER_IFACE

65

67

except AttributeError:

66

68

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

67

69

68

69

70

def isoformat_to_datetime(iso):

70

71

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

71

72

if not iso:

79

80

int(day),

80

81

int(hour),

81

82

int(minute),

82

int(second), # Whole seconds

83

int(fraction*1000000)) # Microseconds

84

83

int(second), # Whole seconds

84

int(fraction*1000000)) # Microseconds

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(self.proxy.GetAll(

102

client_interface,

103

dbus_interface=dbus.PROPERTIES_IFACE))

104

101

self.properties.update(

102

self.proxy.GetAll(client_interface,

103

dbus_interface

104

= dbus.PROPERTIES_IFACE))

105

106

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

106

107

108

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

108

109

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

109

110

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

111

112

# Update properties dict with new value

112

113

if interface == client_interface:

113

114

self.properties.update(properties)

114

115

116

def delete(self):

116

117

self.property_changed_match.remove()

117

118

119

120

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

120

121

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

121

122

"""

122

123

124

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

124

125

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

125

126

# Called on update

130

131

self.server_proxy_object = server_proxy_object

131

132

# Logger

132

133

self.logger = logger

133

134

135

self._update_timer_callback_tag = None

135

136

137

# The widget shown normally

137

138

self._text_widget = urwid.Text("")

138

139

# The widget shown when we have focus

140

141

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

141

142

self.update()

142

143

self.opened = False

143

144

145

self.match_objects = (

145

146

self.proxy.connect_to_signal("CheckerCompleted",

146

147

self.checker_completed,

164

165

byte_arrays=True))

165

166

self.logger('Created client {}'

166

167

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

167

168

169

def using_timer(self, flag):

169

170

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

170

171

activated or deactivated.

171

172

"""

172

173

if flag and self._update_timer_callback_tag is None:

173

174

# Will update the shown timer value every second

174

self._update_timer_callback_tag = (GLib.timeout_add

175

self._update_timer_callback_tag = (gobject.timeout_add

175

176

(1000,

176

177

self.update_timer))

177

178

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

178

GLib.source_remove(self._update_timer_callback_tag)

179

gobject.source_remove(self._update_timer_callback_tag)

179

180

self._update_timer_callback_tag = None

180

181

182

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

182

183

if exitstatus == 0:

183

184

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

197

198

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

198

199

os.WTERMSIG(condition)))

199

200

self.update()

200

201

202

def checker_started(self, command):

202

203

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

203

204

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

204

205

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

205

206

command), level=0)

206

207

208

def got_secret(self):

208

209

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

209

210

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

210

211

212

def need_approval(self, timeout, default):

212

213

if not default:

213

214

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

215

216

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

216

217

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

217

218

timeout/1000))

218

219

220

def rejected(self, reason):

220

221

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

221

222

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

222

223

224

def selectable(self):

224

225

"""Make this a "selectable" widget.

225

226

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

226

227

return True

227

228

229

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

229

230

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

230

231

whether we have focus or not.

231

232

This overrides the method from urwid.FlowWidget"""

232

233

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

233

234

235

def current_widget(self, focus=False):

235

236

if focus or self.opened:

236

237

return self._focus_widget

237

238

return self._widget

238

239

240

def update(self):

240

241

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

241

242

# 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

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

251

# Rebuild focus and non-focus widgets using current properties

251

252

253

# Base part of a client. Name!

253

254

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

254

255

if not self.properties["Enabled"]:

255

256

message = "DISABLED"

256

257

self.using_timer(False)

257

258

elif self.properties["ApprovalPending"]:

258

timeout = datetime.timedelta(

259

milliseconds=self.properties["ApprovalDelay"])

259

timeout = datetime.timedelta(milliseconds

260

= self.properties

261

["ApprovalDelay"])

260

262

last_approval_request = isoformat_to_datetime(

261

263

self.properties["LastApprovalRequest"])

262

264

if last_approval_request is not None:

289

291

message = "enabled"

290

292

self.using_timer(False)

291

293

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

292

294

293

295

if not urwid.supports_unicode():

294

296

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

295

297

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

305

307

# Run update hook, if any

306

308

if self.update_hook is not None:

307

309

self.update_hook()

308

310

309

311

def update_timer(self):

310

"""called by GLib. Will indefinitely loop until

311

GLib.source_remove() on tag is called

312

"""

312

"""called by gobject. Will indefinitely loop until

313

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

313

314

self.update()

314

315

return True # Keep calling this

315

316

317

def delete(self, **kwargs):

317

318

if self._update_timer_callback_tag is not None:

318

GLib.source_remove(self._update_timer_callback_tag)

319

gobject.source_remove(self._update_timer_callback_tag)

319

320

self._update_timer_callback_tag = None

320

321

for match in self.match_objects:

321

322

match.remove()

323

324

if self.delete_hook is not None:

324

325

self.delete_hook(self)

325

326

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

326

327

328

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

328

329

"""Render differently if we have focus.

329

330

This overrides the method from urwid.FlowWidget"""

330

331

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

331

332

focus=focus)

332

333

334

def keypress(self, maxcolrow, key):

334

335

"""Handle keys.

335

336

This overrides the method from urwid.FlowWidget"""

336

337

if key == "+":

337

338

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

338

dbus.Boolean(True), ignore_reply=True,

339

dbus_interface=dbus.PROPERTIES_IFACE)

339

dbus.Boolean(True), ignore_reply = True,

340

dbus_interface = dbus.PROPERTIES_IFACE)

340

341

elif key == "-":

341

342

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

342

ignore_reply=True,

343

dbus_interface=dbus.PROPERTIES_IFACE)

343

ignore_reply = True,

344

dbus_interface = dbus.PROPERTIES_IFACE)

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

355

356

ignore_reply=True)

356

357

elif key == "s":

357

358

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

358

dbus.Boolean(True), ignore_reply=True,

359

dbus_interface=dbus.PROPERTIES_IFACE)

359

dbus.Boolean(True), ignore_reply = True,

360

dbus_interface = dbus.PROPERTIES_IFACE)

360

361

elif key == "S":

361

362

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

362

dbus.Boolean(False), ignore_reply=True,

363

dbus_interface=dbus.PROPERTIES_IFACE)

363

dbus.Boolean(False), ignore_reply = True,

364

dbus_interface = dbus.PROPERTIES_IFACE)

364

365

elif key == "C":

365

self.proxy.CheckedOK(dbus_interface=client_interface,

366

self.proxy.CheckedOK(dbus_interface = client_interface,

366

367

ignore_reply=True)

367

368

# xxx

368

369

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

373

374

# self.open()

374

375

else:

375

376

return key

376

377

378

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

378

379

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

379

380

This overrides the method from MandosClientPropertyCache"""

380

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

381

for key in properties.keys()}

381

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

382

for key in properties.keys() }

382

383

super(MandosClientWidget, self).properties_changed(

383

384

interface, properties, invalidated)

384

385

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

392

393

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

393

394

"""

394

395

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

395

ret = (super(ConstrainedListBox, self)

396

.keypress(*args, **kwargs))

396

ret = super(ConstrainedListBox, self).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",

422

"bold,underline,blink"),

421

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

423

422

("bold-standout",

424

423

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

425

424

("underline-blink-standout",

429

428

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

430

429

"bold,underline,blink,standout"),

431

430

))

432

431

433

432

if urwid.supports_unicode():

434

self.divider = "─" # \u2500

433

self.divider = "─" # \u2500

434

#self.divider = "━" # \u2501

435

else:

436

self.divider = "_" # \u005f

437

436

#self.divider = "-" # \u002d

437

self.divider = "_" # \u005f

438

439

self.screen.start()

439

440

441

self.size = self.screen.get_cols_rows()

441

442

443

self.clients = urwid.SimpleListWalker([])

443

444

self.clients_dict = {}

444

445

446

# We will add Text widgets to this list

446

447

self.log = []

447

448

self.max_log_length = max_log_length

448

449

450

self.log_level = log_level

450

451

452

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

452

453

# from the ListWalker without it getting destroyed

453

454

self.logbox = ConstrainedListBox(self.log)

454

455

456

# This keeps track of whether self.uilist currently has

456

457

# self.logbox in it or not

457

458

self.log_visible = True

458

459

self.log_wrap = "any"

459

460

461

self.rebuild()

461

462

self.log_message_raw(("bold",

462

463

"Mandos Monitor version " + version))

463

464

self.log_message_raw(("bold",

464

465

"q: Quit ?: Help"))

465

466

467

self.busname = domain + '.Mandos'

467

self.main_loop = GLib.MainLoop()

468

self.main_loop = gobject.MainLoop()

469

470

def client_not_found(self, fingerprint, address):

470

471

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

471

472

" could not be found"

472

473

.format(address, fingerprint))

473

474

475

def rebuild(self):

475

476

"""This rebuilds the User Interface.

476

477

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

477

478

self.uilist = []

478

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

479

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

479

480

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

480

481

clients),

481

# header=urwid.Divider(),

482

#header=urwid.Divider(),

482

483

header=None,

483

footer=urwid.Divider(

484

div_char=self.divider)))

484

footer=

485

urwid.Divider(div_char=

486

self.divider)))

485

487

if self.log_visible:

486

488

self.uilist.append(self.logbox)

487

489

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

488

490

489

491

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

490

492

"""Log message formatted with timestamp"""

491

493

if level < self.log_level:

493

495

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

494

496

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

495

497

level=level)

496

498

497

499

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

498

500

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

499

501

if level < self.log_level:

500

502

return

501

503

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]

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]

505

507

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

506

508

coming_from="above")

507

509

self.refresh()

508

510

509

511

def toggle_log_display(self):

510

512

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

511

513

self.log_visible = not self.log_visible

512

514

self.rebuild()

513

515

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

514

516

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

515

517

516

518

def change_log_display(self):

517

519

"""Change type of log display.

518

520

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

524

526

textwidget.set_wrap_mode(self.log_wrap)

525

527

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

526

528

level=0)

527

529

528

530

def find_and_remove_client(self, path, interfaces):

529

531

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

530

532

531

533

This is connected to the InterfacesRemoved signal from the

532

534

Mandos server object."""

533

535

if client_interface not in interfaces:

541

543

.format(path))

542

544

return

543

545

client.delete()

544

546

545

547

def add_new_client(self, path, ifs_and_props):

546

548

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

547

549

548

550

This is connected to the InterfacesAdded signal from the

549

551

Mandos server object.

550

552

"""

552

554

# Not a Mandos client object; ignore

553

555

return

554

556

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

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

562

570

path=path)

563

571

564

572

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

565

573

self.clients.append(client)

566

574

if path is None:

568

576

self.clients_dict[path] = client

569

577

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

570

578

self.refresh()

571

579

572

580

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

573

581

self.clients.remove(client)

574

582

if path is None:

575

583

path = client.proxy.object_path

576

584

del self.clients_dict[path]

577

585

self.refresh()

578

586

579

587

def refresh(self):

580

588

"""Redraw the screen"""

581

589

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

582

590

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

583

591

584

592

def run(self):

585

593

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

586

594

self.bus = dbus.SystemBus()

587

595

mandos_dbus_objc = self.bus.get_object(

588

596

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

589

self.mandos_serv = dbus.Interface(

590

mandos_dbus_objc, dbus_interface=server_interface)

597

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

598

dbus_interface

599

= server_interface)

591

600

try:

592

601

mandos_clients = (self.mandos_serv

593

602

.GetAllClientsWithProperties())

594

603

if not mandos_clients:

595

self.log_message_raw(("bold",

596

"Note: Server has no clients."))

604

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

597

605

except dbus.exceptions.DBusException:

598

self.log_message_raw(("bold",

599

"Note: No Mandos server running."))

606

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

600

607

mandos_clients = dbus.Dictionary()

601

608

602

609

(self.mandos_serv

603

610

.connect_to_signal("InterfacesRemoved",

604

611

self.find_and_remove_client,

605

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

612

dbus_interface

613

= dbus.OBJECT_MANAGER_IFACE,

606

614

byte_arrays=True))

607

615

(self.mandos_serv

608

616

.connect_to_signal("InterfacesAdded",

609

617

self.add_new_client,

610

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

618

dbus_interface

619

= dbus.OBJECT_MANAGER_IFACE,

611

620

byte_arrays=True))

612

621

(self.mandos_serv

613

622

.connect_to_signal("ClientNotFound",

617

626

for path, client in mandos_clients.items():

618

627

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

619

628

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

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

627

640

path=path)

628

641

629

642

self.refresh()

630

self._input_callback_tag = (GLib.io_add_watch

643

self._input_callback_tag = (gobject.io_add_watch

631

644

(sys.stdin.fileno(),

632

GLib.IO_IN,

645

gobject.IO_IN,

633

646

self.process_input))

634

647

self.main_loop.run()

635

648

# Main loop has finished, we should close everything now

636

GLib.source_remove(self._input_callback_tag)

649

gobject.source_remove(self._input_callback_tag)

637

650

self.screen.stop()

638

651

639

652

def stop(self):

640

653

self.main_loop.quit()

641

654

642

655

def process_input(self, source, condition):

643

656

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

}

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

}

654

667

for key in keys:

655

668

try:

656

669

key = translations[key]

657

670

except KeyError: # :-)

658

671

pass

659

672

660

673

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

661

674

self.stop()

662

675

break

710

723

else:

711

724

self.log_level = 0

712

725

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

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

731

744

elif self.topwidget.selectable():

732

745

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

733

746

self.refresh()

734

747

return True

735

748

736

737

749

ui = UserInterface()

738

750

try:

739

751

ui.run()