/mandos/trunk : revision 237.4.85

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

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

180

176

181

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

177

182

if exitstatus == 0:

178

183

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

191

196

' killed by signal {}'

192

197

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

193

198

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

202

199

self.update()

203

200

204

201

def checker_started(self, command):

205

202

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

206

203

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

207

204

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

208

205

command), level=0)

209

206

210

207

def got_secret(self):

211

208

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

212

209

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

213

210

214

211

def need_approval(self, timeout, default):

215

212

if not default:

216

213

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

218

215

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

219

216

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

220

217

timeout/1000))

221

218

222

219

def rejected(self, reason):

223

220

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

224

221

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

225

222

226

223

def selectable(self):

227

224

"""Make this a "selectable" widget.

228

225

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

229

226

return True

230

227

231

228

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

232

229

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

233

230

whether we have focus or not.

234

231

This overrides the method from urwid.FlowWidget"""

235

232

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

236

233

237

234

def current_widget(self, focus=False):

238

235

if focus or self.opened:

239

236

return self._focus_widget

240

237

return self._widget

241

238

242

239

def update(self):

243

240

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

244

241

# How to add standout mode to a style

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

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

253

250

# Rebuild focus and non-focus widgets using current properties

254

251

255

252

# Base part of a client. Name!

256

253

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

257

254

if not self.properties["Enabled"]:

258

255

message = "DISABLED"

259

256

self.using_timer(False)

260

257

elif self.properties["ApprovalPending"]:

261

timeout = datetime.timedelta(milliseconds

262

= self.properties

263

["ApprovalDelay"])

258

timeout = datetime.timedelta(

259

milliseconds=self.properties["ApprovalDelay"])

264

260

last_approval_request = isoformat_to_datetime(

265

261

self.properties["LastApprovalRequest"])

266

262

if last_approval_request is not None:

293

289

message = "enabled"

294

290

self.using_timer(False)

295

291

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

296

292

297

293

if not urwid.supports_unicode():

298

294

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

299

295

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

309

305

# Run update hook, if any

310

306

if self.update_hook is not None:

311

307

self.update_hook()

312

308

313

309

def update_timer(self):

314

"""called by gobject. Will indefinitely loop until

315

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

310

"""called by GLib. Will indefinitely loop until

311

GLib.source_remove() on tag is called

312

"""

316

313

self.update()

317

314

return True # Keep calling this

318

315

319

316

def delete(self, **kwargs):

320

317

if self._update_timer_callback_tag is not None:

321

gobject.source_remove(self._update_timer_callback_tag)

318

GLib.source_remove(self._update_timer_callback_tag)

322

319

self._update_timer_callback_tag = None

323

320

for match in self.match_objects:

324

321

match.remove()

326

323

if self.delete_hook is not None:

327

324

self.delete_hook(self)

328

325

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

329

326

330

327

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

331

328

"""Render differently if we have focus.

332

329

This overrides the method from urwid.FlowWidget"""

333

330

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

334

331

focus=focus)

335

332

336

333

def keypress(self, maxcolrow, key):

337

334

"""Handle keys.

338

335

This overrides the method from urwid.FlowWidget"""

339

336

if key == "+":

340

self.proxy.Enable(dbus_interface = client_interface,

341

ignore_reply=True)

337

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

338

dbus.Boolean(True), ignore_reply=True,

339

dbus_interface=dbus.PROPERTIES_IFACE)

342

340

elif key == "-":

343

self.proxy.Disable(dbus_interface = client_interface,

344

ignore_reply=True)

341

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

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

355

354

.object_path,

356

355

ignore_reply=True)

357

356

elif key == "s":

358

self.proxy.StartChecker(dbus_interface = client_interface,

359

ignore_reply=True)

357

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

358

dbus.Boolean(True), ignore_reply=True,

359

dbus_interface=dbus.PROPERTIES_IFACE)

360

elif key == "S":

361

self.proxy.StopChecker(dbus_interface = client_interface,

362

ignore_reply=True)

361

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

362

dbus.Boolean(False), ignore_reply=True,

363

dbus_interface=dbus.PROPERTIES_IFACE)

363

364

elif key == "C":

364

self.proxy.CheckedOK(dbus_interface = client_interface,

365

self.proxy.CheckedOK(dbus_interface=client_interface,

365

366

ignore_reply=True)

366

367

# xxx

367

368

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

372

373

# self.open()

373

374

else:

374

375

return key

375

376

377

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

377

378

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

378

379

This overrides the method from MandosClientPropertyCache"""

379

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

380

for key in properties.keys() }

380

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

381

for key in properties.keys()}

381

382

super(MandosClientWidget, self).properties_changed(

382

383

interface, properties, invalidated)

383

384

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

391

392

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

392

393

"""

393

394

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

394

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

395

ret = (super(ConstrainedListBox, self)

396

.keypress(*args, **kwargs))

395

397

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

396

398

return

397

399

return ret

403

405

"""

404

406

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

405

407

DBusGMainLoop(set_as_default=True)

406

408

407

409

self.screen = urwid.curses_display.Screen()

408

410

409

411

self.screen.register_palette((

410

412

("normal",

411

413

"default", "default", None),

416

418

("standout",

417

419

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

418

420

("bold-underline-blink",

419

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

421

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

422

"bold,underline,blink"),

420

423

("bold-standout",

421

424

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

422

425

("underline-blink-standout",

426

429

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

427

430

"bold,underline,blink,standout"),

428

431

))

429

432

430

433

if urwid.supports_unicode():

431

self.divider = "─" # \u2500

432

#self.divider = "━" # \u2501

434

self.divider = "─" # \u2500

433

435

else:

434

#self.divider = "-" # \u002d

435

self.divider = "_" # \u005f

436

self.divider = "_" # \u005f

437

438

self.screen.start()

438

439

440

self.size = self.screen.get_cols_rows()

440

441

442

self.clients = urwid.SimpleListWalker([])

442

443

self.clients_dict = {}

443

444

445

# We will add Text widgets to this list

445

446

self.log = []

446

447

self.max_log_length = max_log_length

447

448

449

self.log_level = log_level

449

450

451

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

451

452

# from the ListWalker without it getting destroyed

452

453

self.logbox = ConstrainedListBox(self.log)

453

454

455

# This keeps track of whether self.uilist currently has

455

456

# self.logbox in it or not

456

457

self.log_visible = True

457

458

self.log_wrap = "any"

458

459

460

self.rebuild()

460

461

self.log_message_raw(("bold",

461

462

"Mandos Monitor version " + version))

462

463

self.log_message_raw(("bold",

463

464

"q: Quit ?: Help"))

464

465

466

self.busname = domain + '.Mandos'

466

self.main_loop = gobject.MainLoop()

467

self.main_loop = GLib.MainLoop()

468

469

def client_not_found(self, fingerprint, address):

469

470

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

470

471

" could not be found"

471

472

.format(address, fingerprint))

472

473

474

def rebuild(self):

474

475

"""This rebuilds the User Interface.

475

476

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

476

477

self.uilist = []

477

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

478

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

478

479

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

479

480

clients),

480

#header=urwid.Divider(),

481

# header=urwid.Divider(),

481

482

header=None,

482

footer=

483

urwid.Divider(div_char=

484

self.divider)))

483

footer=urwid.Divider(

484

div_char=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

and 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

if 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, name):

527

528

def find_and_remove_client(self, path, interfaces):

529

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

530

531

This is connected to the ClientRemoved signal from the

530

531

This is connected to the InterfacesRemoved signal from the

532

Mandos server object."""

533

if client_interface not in interfaces:

534

# Not a Mandos client object; ignore

535

return

533

536

try:

534

537

client = self.clients_dict[path]

535

538

except KeyError:

536

539

# not found?

537

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

538

.format(name, path))

540

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

541

.format(path))

539

542

return

540

543

client.delete()

541

542

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

543

554

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

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

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

554

562

path=path)

555

563

556

564

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

557

565

self.clients.append(client)

558

566

if path is None:

560

568

self.clients_dict[path] = client

561

569

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

562

570

self.refresh()

563

571

564

572

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

565

573

self.clients.remove(client)

566

574

if path is None:

567

575

path = client.proxy.object_path

568

576

del self.clients_dict[path]

569

577

self.refresh()

570

578

571

579

def refresh(self):

572

580

"""Redraw the screen"""

573

581

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

574

582

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

575

583

576

584

def run(self):

577

585

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

578

586

self.bus = dbus.SystemBus()

579

587

mandos_dbus_objc = self.bus.get_object(

580

588

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

581

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

582

dbus_interface

583

= server_interface)

589

self.mandos_serv = dbus.Interface(

590

mandos_dbus_objc, dbus_interface=server_interface)

584

591

try:

585

592

mandos_clients = (self.mandos_serv

586

593

.GetAllClientsWithProperties())

587

594

if not mandos_clients:

588

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

595

self.log_message_raw(("bold",

596

"Note: Server has no clients."))

589

597

except dbus.exceptions.DBusException:

590

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

598

self.log_message_raw(("bold",

599

"Note: No Mandos server running."))

591

600

mandos_clients = dbus.Dictionary()

592

601

593

602

(self.mandos_serv

594

.connect_to_signal("ClientRemoved",

603

.connect_to_signal("InterfacesRemoved",

595

604

self.find_and_remove_client,

596

dbus_interface=server_interface,

605

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

597

606

byte_arrays=True))

598

607

(self.mandos_serv

599

.connect_to_signal("ClientAdded",

608

.connect_to_signal("InterfacesAdded",

600

609

self.add_new_client,

601

dbus_interface=server_interface,

610

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

602

611

byte_arrays=True))

603

612

(self.mandos_serv

604

613

.connect_to_signal("ClientNotFound",

608

617

for path, client in mandos_clients.items():

609

618

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

610

619

path)

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

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

622

627

path=path)

623

628

624

629

self.refresh()

625

self._input_callback_tag = (gobject.io_add_watch

630

self._input_callback_tag = (GLib.io_add_watch

626

631

(sys.stdin.fileno(),

627

gobject.IO_IN,

632

GLib.IO_IN,

628

633

self.process_input))

629

634

self.main_loop.run()

630

635

# Main loop has finished, we should close everything now

631

gobject.source_remove(self._input_callback_tag)

636

GLib.source_remove(self._input_callback_tag)

632

637

self.screen.stop()

633

638

634

639

def stop(self):

635

640

self.main_loop.quit()

636

641

637

642

def process_input(self, source, condition):

638

643

keys = self.screen.get_input()

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

}

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

}

649

654

for key in keys:

650

655

try:

651

656

key = translations[key]

652

657

except KeyError: # :-)

653

658

pass

654

659

655

660

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

656

661

self.stop()

657

662

break

705

710

else:

706

711

self.log_level = 0

707

712

self.log_message("Verbose mode: On")

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

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

731

elif self.topwidget.selectable():

727

732

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

728

733

self.refresh()