/mandos/release : revision 237.7.437

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.6.9"

61

version = "1.7.13"

62

63

try:

64

dbus.OBJECT_MANAGER_IFACE

65

except AttributeError:

66

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

67

64

68

65

69

def isoformat_to_datetime(iso):

66

70

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

75

79

int(day),

76

80

int(hour),

77

81

int(minute),

78

int(second), # Whole seconds

79

int(fraction*1000000)) # Microseconds

82

int(second), # Whole seconds

83

int(fraction*1000000)) # Microseconds

84

80

85

81

86

class MandosClientPropertyCache(object):

82

87

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

84

89

changed.

85

90

"""

86

91

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

87

self.proxy = proxy_object # Mandos Client proxy object

92

self.proxy = proxy_object # Mandos Client proxy object

88

93

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

89

94

self.property_changed_match = (

90

95

self.proxy.connect_to_signal("PropertiesChanged",

91

96

self.properties_changed,

92

97

dbus.PROPERTIES_IFACE,

93

98

byte_arrays=True))

94

99

95

100

if properties is None:

96

self.properties.update(

97

self.proxy.GetAll(client_interface,

98

dbus_interface

99

= dbus.PROPERTIES_IFACE))

100

101

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

102

client_interface,

103

dbus_interface=dbus.PROPERTIES_IFACE))

104

101

105

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

102

106

103

107

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

104

108

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

105

109

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

106

110

"""

107

111

# Update properties dict with new value

108

self.properties.update(properties)

109

112

if interface == client_interface:

113

self.properties.update(properties)

114

110

115

def delete(self):

111

116

self.property_changed_match.remove()

112

117

114

119

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

115

120

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

116

121

"""

117

122

118

123

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

119

124

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

120

125

# Called on update

125

130

self.server_proxy_object = server_proxy_object

126

131

# Logger

127

132

self.logger = logger

128

133

129

134

self._update_timer_callback_tag = None

130

135

131

136

# The widget shown normally

132

137

self._text_widget = urwid.Text("")

133

138

# The widget shown when we have focus

135

140

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

136

141

self.update()

137

142

self.opened = False

138

143

139

144

self.match_objects = (

140

145

self.proxy.connect_to_signal("CheckerCompleted",

141

146

self.checker_completed,

159

164

byte_arrays=True))

160

165

self.logger('Created client {}'

161

166

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

162

167

163

168

def using_timer(self, flag):

164

169

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

165

170

activated or deactivated.

166

171

"""

167

172

if flag and self._update_timer_callback_tag is None:

168

173

# Will update the shown timer value every second

169

self._update_timer_callback_tag = (gobject.timeout_add

174

self._update_timer_callback_tag = (GLib.timeout_add

170

175

(1000,

171

176

self.update_timer))

172

177

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

173

gobject.source_remove(self._update_timer_callback_tag)

178

GLib.source_remove(self._update_timer_callback_tag)

174

179

self._update_timer_callback_tag = None

175

176

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

180

181

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

177

182

if exitstatus == 0:

178

183

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

179

184

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

181

186

self.update()

182

187

return

183

188

# Checker failed

184

if exitstatus >= 0:

189

if os.WIFEXITED(condition):

185

190

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

186

191

' with exit code {}'

187

192

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

188

exitstatus))

189

elif signal != 0:

193

os.WEXITSTATUS(condition)))

194

elif os.WIFSIGNALED(condition):

190

195

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

191

196

' killed by signal {}'

192

197

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

193

signal))

194

else:

195

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

196

' mysteriously'

197

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

198

os.WTERMSIG(condition)))

198

199

self.update()

199

200

201

def checker_started(self, command):

201

202

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

202

203

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

203

204

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

204

205

command), level=0)

205

206

207

def got_secret(self):

207

208

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

208

209

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

209

210

211

def need_approval(self, timeout, default):

211

212

if not default:

212

213

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

214

215

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

215

216

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

216

217

timeout/1000))

217

218

219

def rejected(self, reason):

219

220

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

220

221

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

221

222

223

def selectable(self):

223

224

"""Make this a "selectable" widget.

224

225

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

225

226

return True

226

227

228

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

228

229

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

229

230

whether we have focus or not.

230

231

This overrides the method from urwid.FlowWidget"""

231

232

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

232

233

234

def current_widget(self, focus=False):

234

235

if focus or self.opened:

235

236

return self._focus_widget

236

237

return self._widget

237

238

239

def update(self):

239

240

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

240

241

# How to add standout mode to a style

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

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

250

# Rebuild focus and non-focus widgets using current properties

250

251

252

# Base part of a client. Name!

252

253

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

253

254

if not self.properties["Enabled"]:

254

255

message = "DISABLED"

255

256

self.using_timer(False)

256

257

elif self.properties["ApprovalPending"]:

257

timeout = datetime.timedelta(milliseconds

258

= self.properties

259

["ApprovalDelay"])

258

timeout = datetime.timedelta(

259

milliseconds=self.properties["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 gobject. Will indefinitely loop until

311

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

310

"""called by GLib. Will indefinitely loop until

311

GLib.source_remove() on tag is called

312

"""

312

313

self.update()

313

314

return True # Keep calling this

314

315

316

def delete(self, **kwargs):

316

317

if self._update_timer_callback_tag is not None:

317

gobject.source_remove(self._update_timer_callback_tag)

318

GLib.source_remove(self._update_timer_callback_tag)

318

319

self._update_timer_callback_tag = None

319

320

for match in self.match_objects:

320

321

match.remove()

322

323

if self.delete_hook is not None:

323

324

self.delete_hook(self)

324

325

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

325

326

327

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

327

328

"""Render differently if we have focus.

328

329

This overrides the method from urwid.FlowWidget"""

329

330

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

330

331

focus=focus)

331

332

333

def keypress(self, maxcolrow, key):

333

334

"""Handle keys.

334

335

This overrides the method from urwid.FlowWidget"""

335

336

if key == "+":

336

self.proxy.Enable(dbus_interface = client_interface,

337

ignore_reply=True)

337

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

338

dbus.Boolean(True), ignore_reply=True,

339

dbus_interface=dbus.PROPERTIES_IFACE)

338

340

elif key == "-":

339

self.proxy.Disable(dbus_interface = client_interface,

340

ignore_reply=True)

341

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

342

ignore_reply=True,

343

dbus_interface=dbus.PROPERTIES_IFACE)

341

344

elif key == "a":

342

345

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

343

dbus_interface = client_interface,

346

dbus_interface=client_interface,

344

347

ignore_reply=True)

345

348

elif key == "d":

346

349

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

347

dbus_interface = client_interface,

350

dbus_interface=client_interface,

348

351

ignore_reply=True)

349

352

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

350

353

self.server_proxy_object.RemoveClient(self.proxy

351

354

.object_path,

352

355

ignore_reply=True)

353

356

elif key == "s":

354

self.proxy.StartChecker(dbus_interface = client_interface,

355

ignore_reply=True)

357

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

358

dbus.Boolean(True), ignore_reply=True,

359

dbus_interface=dbus.PROPERTIES_IFACE)

356

360

elif key == "S":

357

self.proxy.StopChecker(dbus_interface = client_interface,

358

ignore_reply=True)

361

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

362

dbus.Boolean(False), ignore_reply=True,

363

dbus_interface=dbus.PROPERTIES_IFACE)

359

364

elif key == "C":

360

self.proxy.CheckedOK(dbus_interface = client_interface,

365

self.proxy.CheckedOK(dbus_interface=client_interface,

361

366

ignore_reply=True)

362

367

# xxx

363

368

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

368

373

# self.open()

369

374

else:

370

375

return key

371

376

372

377

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

373

378

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

374

379

This overrides the method from MandosClientPropertyCache"""

375

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

376

for key in properties.keys() }

380

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

381

for key in properties.keys()}

377

382

super(MandosClientWidget, self).properties_changed(

378

383

interface, properties, invalidated)

379

384

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

387

392

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

388

393

"""

389

394

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

390

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

395

ret = (super(ConstrainedListBox, self)

396

.keypress(*args, **kwargs))

391

397

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

392

398

return

393

399

return ret

399

405

"""

400

406

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

401

407

DBusGMainLoop(set_as_default=True)

402

408

403

409

self.screen = urwid.curses_display.Screen()

404

410

405

411

self.screen.register_palette((

406

412

("normal",

407

413

"default", "default", None),

412

418

("standout",

413

419

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

414

420

("bold-underline-blink",

415

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

421

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

422

"bold,underline,blink"),

416

423

("bold-standout",

417

424

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

418

425

("underline-blink-standout",

422

429

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

423

430

"bold,underline,blink,standout"),

424

431

))

425

432

426

433

if urwid.supports_unicode():

427

self.divider = "─" # \u2500

428

#self.divider = "━" # \u2501

434

self.divider = "─" # \u2500

429

435

else:

430

#self.divider = "-" # \u002d

431

self.divider = "_" # \u005f

432

436

self.divider = "_" # \u005f

437

433

438

self.screen.start()

434

439

435

440

self.size = self.screen.get_cols_rows()

436

441

437

442

self.clients = urwid.SimpleListWalker([])

438

443

self.clients_dict = {}

439

444

440

445

# We will add Text widgets to this list

441

446

self.log = []

442

447

self.max_log_length = max_log_length

443

448

444

449

self.log_level = log_level

445

450

446

451

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

447

452

# from the ListWalker without it getting destroyed

448

453

self.logbox = ConstrainedListBox(self.log)

449

454

450

455

# This keeps track of whether self.uilist currently has

451

456

# self.logbox in it or not

452

457

self.log_visible = True

453

458

self.log_wrap = "any"

454

459

455

460

self.rebuild()

456

461

self.log_message_raw(("bold",

457

462

"Mandos Monitor version " + version))

458

463

self.log_message_raw(("bold",

459

464

"q: Quit ?: Help"))

460

465

461

466

self.busname = domain + '.Mandos'

462

self.main_loop = gobject.MainLoop()

463

467

self.main_loop = GLib.MainLoop()

468

464

469

def client_not_found(self, fingerprint, address):

465

470

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

466

471

" could not be found"

467

472

.format(address, fingerprint))

468

473

469

474

def rebuild(self):

470

475

"""This rebuilds the User Interface.

471

476

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

472

477

self.uilist = []

473

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

478

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

474

479

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

475

480

clients),

476

#header=urwid.Divider(),

481

# header=urwid.Divider(),

477

482

header=None,

478

footer=

479

urwid.Divider(div_char=

480

self.divider)))

483

footer=urwid.Divider(

484

div_char=self.divider)))

481

485

if self.log_visible:

482

486

self.uilist.append(self.logbox)

483

487

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

484

488

485

489

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

486

490

"""Log message formatted with timestamp"""

487

491

if level < self.log_level:

489

493

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

490

494

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

491

495

level=level)

492

496

493

497

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

494

498

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

495

499

if level < self.log_level:

496

500

return

497

501

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

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]

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]

501

505

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

502

506

coming_from="above")

503

507

self.refresh()

504

508

505

509

def toggle_log_display(self):

506

510

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

507

511

self.log_visible = not self.log_visible

508

512

self.rebuild()

509

513

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

510

514

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

511

515

512

516

def change_log_display(self):

513

517

"""Change type of log display.

514

518

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

520

524

textwidget.set_wrap_mode(self.log_wrap)

521

525

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

522

526

level=0)

523

524

def find_and_remove_client(self, path, name):

527

528

def find_and_remove_client(self, path, interfaces):

525

529

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

526

527

This is connected to the ClientRemoved signal from the

530

531

This is connected to the InterfacesRemoved signal from the

528

532

Mandos server object."""

533

if client_interface not in interfaces:

534

# Not a Mandos client object; ignore

535

return

529

536

try:

530

537

client = self.clients_dict[path]

531

538

except KeyError:

532

539

# not found?

533

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

534

.format(name, path))

540

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

541

.format(path))

535

542

return

536

543

client.delete()

537

538

def add_new_client(self, path):

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

539

554

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

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

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

550

562

path=path)

551

563

552

564

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

553

565

self.clients.append(client)

554

566

if path is None:

556

568

self.clients_dict[path] = client

557

569

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

558

570

self.refresh()

559

571

560

572

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

561

573

self.clients.remove(client)

562

574

if path is None:

563

575

path = client.proxy.object_path

564

576

del self.clients_dict[path]

565

577

self.refresh()

566

578

567

579

def refresh(self):

568

580

"""Redraw the screen"""

569

581

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

570

582

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

571

583

572

584

def run(self):

573

585

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

574

586

self.bus = dbus.SystemBus()

575

587

mandos_dbus_objc = self.bus.get_object(

576

588

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

577

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

578

dbus_interface

579

= server_interface)

589

self.mandos_serv = dbus.Interface(

590

mandos_dbus_objc, dbus_interface=server_interface)

580

591

try:

581

592

mandos_clients = (self.mandos_serv

582

593

.GetAllClientsWithProperties())

583

594

if not mandos_clients:

584

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

595

self.log_message_raw(("bold",

596

"Note: Server has no clients."))

585

597

except dbus.exceptions.DBusException:

586

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

598

self.log_message_raw(("bold",

599

"Note: No Mandos server running."))

587

600

mandos_clients = dbus.Dictionary()

588

601

589

602

(self.mandos_serv

590

.connect_to_signal("ClientRemoved",

603

.connect_to_signal("InterfacesRemoved",

591

604

self.find_and_remove_client,

592

dbus_interface=server_interface,

605

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

593

606

byte_arrays=True))

594

607

(self.mandos_serv

595

.connect_to_signal("ClientAdded",

608

.connect_to_signal("InterfacesAdded",

596

609

self.add_new_client,

597

dbus_interface=server_interface,

610

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

598

611

byte_arrays=True))

599

612

(self.mandos_serv

600

613

.connect_to_signal("ClientNotFound",

604

617

for path, client in mandos_clients.items():

605

618

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

606

619

path)

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

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

618

627

path=path)

619

628

620

629

self.refresh()

621

self._input_callback_tag = (gobject.io_add_watch

630

self._input_callback_tag = (GLib.io_add_watch

622

631

(sys.stdin.fileno(),

623

gobject.IO_IN,

632

GLib.IO_IN,

624

633

self.process_input))

625

634

self.main_loop.run()

626

635

# Main loop has finished, we should close everything now

627

gobject.source_remove(self._input_callback_tag)

636

GLib.source_remove(self._input_callback_tag)

628

637

self.screen.stop()

629

638

630

639

def stop(self):

631

640

self.main_loop.quit()

632

641

633

642

def process_input(self, source, condition):

634

643

keys = self.screen.get_input()

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

}

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

}

645

654

for key in keys:

646

655

try:

647

656

key = translations[key]

648

657

except KeyError: # :-)

649

658

pass

650

659

651

660

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

652

661

self.stop()

653

662

break

701

710

else:

702

711

self.log_level = 0

703

712

self.log_message("Verbose mode: On")

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

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

722

731

elif self.topwidget.selectable():

723

732

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

724

733

self.refresh()

725

734

return True

726

735

736

727

737

ui = UserInterface()

728

738

try:

729

739

ui.run()