/mandos/release : revision 237.7.424

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

61

version = "1.7.11"

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

self.proxy.connect_to_signal("PropertyChanged",

91

self._property_changed,

92

client_interface,

95

self.proxy.connect_to_signal("PropertiesChanged",

96

self.properties_changed,

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

103

def _property_changed(self, property, value):

104

"""Helper which takes positional arguments"""

105

return self.property_changed(property=property, value=value)

106

107

def property_changed(self, property=None, value=None):

108

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

109

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

106

107

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

108

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

109

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

110

"""

111

# Update properties dict with new value

112

self.properties[property] = value

113

112

if interface == client_interface:

113

self.properties.update(properties)

114

115

def delete(self):

115

116

self.property_changed_match.remove()

116

117

118

119

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

119

120

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

120

121

"""

121

122

123

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

123

124

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

124

125

# Called on update

129

130

self.server_proxy_object = server_proxy_object

130

131

# Logger

131

132

self.logger = logger

132

133

134

self._update_timer_callback_tag = None

134

135

136

# The widget shown normally

136

137

self._text_widget = urwid.Text("")

137

138

# The widget shown when we have focus

139

140

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

140

141

self.update()

141

142

self.opened = False

142

143

144

self.match_objects = (

144

145

self.proxy.connect_to_signal("CheckerCompleted",

145

146

self.checker_completed,

163

164

byte_arrays=True))

164

165

self.logger('Created client {}'

165

166

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

166

167

168

def using_timer(self, flag):

168

169

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

169

170

activated or deactivated.

170

171

"""

171

172

if flag and self._update_timer_callback_tag is None:

172

173

# Will update the shown timer value every second

173

self._update_timer_callback_tag = (gobject.timeout_add

174

self._update_timer_callback_tag = (GLib.timeout_add

174

175

(1000,

175

176

self.update_timer))

176

177

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

177

gobject.source_remove(self._update_timer_callback_tag)

178

GLib.source_remove(self._update_timer_callback_tag)

178

179

self._update_timer_callback_tag = None

179

180

181

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

181

182

if exitstatus == 0:

182

183

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

195

196

' killed by signal {}'

196

197

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

197

198

os.WTERMSIG(condition)))

198

elif os.WCOREDUMP(condition):

199

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

200

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

201

command))

202

else:

203

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

204

' mysteriously'

205

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

206

199

self.update()

207

200

208

201

def checker_started(self, command):

209

202

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

210

203

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

211

204

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

212

205

command), level=0)

213

206

214

207

def got_secret(self):

215

208

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

216

209

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

217

210

218

211

def need_approval(self, timeout, default):

219

212

if not default:

220

213

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

222

215

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

223

216

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

224

217

timeout/1000))

225

218

226

219

def rejected(self, reason):

227

220

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

228

221

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

229

222

230

223

def selectable(self):

231

224

"""Make this a "selectable" widget.

232

225

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

233

226

return True

234

227

235

228

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

236

229

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

237

230

whether we have focus or not.

238

231

This overrides the method from urwid.FlowWidget"""

239

232

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

240

233

241

234

def current_widget(self, focus=False):

242

235

if focus or self.opened:

243

236

return self._focus_widget

244

237

return self._widget

245

238

246

239

def update(self):

247

240

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

248

241

# How to add standout mode to a style

249

with_standout = { "normal": "standout",

250

"bold": "bold-standout",

251

"underline-blink":

252

"underline-blink-standout",

253

"bold-underline-blink":

254

"bold-underline-blink-standout",

255

}

256

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

257

250

# Rebuild focus and non-focus widgets using current properties

258

251

259

252

# Base part of a client. Name!

260

253

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

261

254

if not self.properties["Enabled"]:

262

255

message = "DISABLED"

263

256

self.using_timer(False)

264

257

elif self.properties["ApprovalPending"]:

265

timeout = datetime.timedelta(milliseconds

266

= self.properties

267

["ApprovalDelay"])

258

timeout = datetime.timedelta(

259

milliseconds=self.properties["ApprovalDelay"])

268

260

last_approval_request = isoformat_to_datetime(

269

261

self.properties["LastApprovalRequest"])

270

262

if last_approval_request is not None:

297

289

message = "enabled"

298

290

self.using_timer(False)

299

291

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

300

292

301

293

if not urwid.supports_unicode():

302

294

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

303

295

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

313

305

# Run update hook, if any

314

306

if self.update_hook is not None:

315

307

self.update_hook()

316

308

317

309

def update_timer(self):

318

"""called by gobject. Will indefinitely loop until

319

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

310

"""called by GLib. Will indefinitely loop until

311

GLib.source_remove() on tag is called

312

"""

320

313

self.update()

321

314

return True # Keep calling this

322

315

323

316

def delete(self, **kwargs):

324

317

if self._update_timer_callback_tag is not None:

325

gobject.source_remove(self._update_timer_callback_tag)

318

GLib.source_remove(self._update_timer_callback_tag)

326

319

self._update_timer_callback_tag = None

327

320

for match in self.match_objects:

328

321

match.remove()

330

323

if self.delete_hook is not None:

331

324

self.delete_hook(self)

332

325

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

333

326

334

327

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

335

328

"""Render differently if we have focus.

336

329

This overrides the method from urwid.FlowWidget"""

337

330

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

338

331

focus=focus)

339

332

340

333

def keypress(self, maxcolrow, key):

341

334

"""Handle keys.

342

335

This overrides the method from urwid.FlowWidget"""

343

336

if key == "+":

344

self.proxy.Enable(dbus_interface = client_interface,

345

ignore_reply=True)

337

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

338

dbus.Boolean(True), ignore_reply=True,

339

dbus_interface=dbus.PROPERTIES_IFACE)

346

340

elif key == "-":

347

self.proxy.Disable(dbus_interface = client_interface,

348

ignore_reply=True)

341

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

342

ignore_reply=True,

343

dbus_interface=dbus.PROPERTIES_IFACE)

349

344

elif key == "a":

350

345

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

351

dbus_interface = client_interface,

346

dbus_interface=client_interface,

352

347

ignore_reply=True)

353

348

elif key == "d":

354

349

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

355

dbus_interface = client_interface,

350

dbus_interface=client_interface,

356

351

ignore_reply=True)

357

352

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

358

353

self.server_proxy_object.RemoveClient(self.proxy

359

354

.object_path,

360

355

ignore_reply=True)

361

356

elif key == "s":

362

self.proxy.StartChecker(dbus_interface = client_interface,

363

ignore_reply=True)

357

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

358

dbus.Boolean(True), ignore_reply=True,

359

dbus_interface=dbus.PROPERTIES_IFACE)

364

360

elif key == "S":

365

self.proxy.StopChecker(dbus_interface = client_interface,

366

ignore_reply=True)

361

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

362

dbus.Boolean(False), ignore_reply=True,

363

dbus_interface=dbus.PROPERTIES_IFACE)

367

364

elif key == "C":

368

self.proxy.CheckedOK(dbus_interface = client_interface,

365

self.proxy.CheckedOK(dbus_interface=client_interface,

369

366

ignore_reply=True)

370

367

# xxx

371

368

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

376

373

# self.open()

377

374

else:

378

375

return key

379

380

def property_changed(self, property=None, **kwargs):

381

"""Call self.update() if old value is not new value.

376

377

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

378

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

382

379

This overrides the method from MandosClientPropertyCache"""

383

property_name = str(property)

384

old_value = self.properties.get(property_name)

385

super(MandosClientWidget, self).property_changed(

386

property=property, **kwargs)

387

if self.properties.get(property_name) != old_value:

380

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

381

for key in properties.keys()}

382

super(MandosClientWidget, self).properties_changed(

383

interface, properties, invalidated)

384

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

385

for key in old_values):

388

386

self.update()

389

387

390

388

394

392

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

395

393

"""

396

394

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

397

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

395

ret = (super(ConstrainedListBox, self)

396

.keypress(*args, **kwargs))

398

397

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

399

398

return

400

399

return ret

406

405

"""

407

406

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

408

407

DBusGMainLoop(set_as_default=True)

409

408

410

409

self.screen = urwid.curses_display.Screen()

411

410

412

411

self.screen.register_palette((

413

412

("normal",

414

413

"default", "default", None),

419

418

("standout",

420

419

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

421

420

("bold-underline-blink",

422

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

421

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

422

"bold,underline,blink"),

423

("bold-standout",

424

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

425

("underline-blink-standout",

429

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

430

"bold,underline,blink,standout"),

431

))

432

433

if urwid.supports_unicode():

434

self.divider = "─" # \u2500

435

#self.divider = "━" # \u2501

434

self.divider = "─" # \u2500

436

435

else:

437

#self.divider = "-" # \u002d

438

self.divider = "_" # \u005f

439

436

self.divider = "_" # \u005f

437

440

438

self.screen.start()

441

439

442

440

self.size = self.screen.get_cols_rows()

443

441

444

442

self.clients = urwid.SimpleListWalker([])

445

443

self.clients_dict = {}

446

444

447

445

# We will add Text widgets to this list

448

446

self.log = []

449

447

self.max_log_length = max_log_length

450

448

451

449

self.log_level = log_level

452

450

453

451

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

454

452

# from the ListWalker without it getting destroyed

455

453

self.logbox = ConstrainedListBox(self.log)

456

454

457

455

# This keeps track of whether self.uilist currently has

458

456

# self.logbox in it or not

459

457

self.log_visible = True

460

458

self.log_wrap = "any"

461

459

462

460

self.rebuild()

463

461

self.log_message_raw(("bold",

464

462

"Mandos Monitor version " + version))

465

463

self.log_message_raw(("bold",

466

464

"q: Quit ?: Help"))

467

465

468

466

self.busname = domain + '.Mandos'

469

self.main_loop = gobject.MainLoop()

470

467

self.main_loop = GLib.MainLoop()

468

471

469

def client_not_found(self, fingerprint, address):

472

470

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

473

471

" could not be found"

474

472

.format(address, fingerprint))

475

473

476

474

def rebuild(self):

477

475

"""This rebuilds the User Interface.

478

476

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

479

477

self.uilist = []

480

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

478

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

481

479

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

482

480

clients),

483

#header=urwid.Divider(),

481

# header=urwid.Divider(),

484

482

header=None,

485

footer=

486

urwid.Divider(div_char=

487

self.divider)))

483

footer=urwid.Divider(

484

div_char=self.divider)))

488

485

if self.log_visible:

489

486

self.uilist.append(self.logbox)

490

487

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

491

488

492

489

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

493

490

"""Log message formatted with timestamp"""

494

491

if level < self.log_level:

496

493

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

497

494

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

498

495

level=level)

499

496

500

497

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

501

498

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

502

499

if level < self.log_level:

503

500

return

504

501

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

505

if (self.max_log_length

506

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

507

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]

508

505

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

509

506

coming_from="above")

510

507

self.refresh()

511

508

512

509

def toggle_log_display(self):

513

510

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

514

511

self.log_visible = not self.log_visible

515

512

self.rebuild()

516

513

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

517

514

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

518

515

519

516

def change_log_display(self):

520

517

"""Change type of log display.

521

518

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

527

524

textwidget.set_wrap_mode(self.log_wrap)

528

525

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

529

526

level=0)

530

531

def find_and_remove_client(self, path, name):

527

528

def find_and_remove_client(self, path, interfaces):

532

529

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

533

534

This is connected to the ClientRemoved signal from the

530

531

This is connected to the InterfacesRemoved signal from the

535

532

Mandos server object."""

533

if client_interface not in interfaces:

534

# Not a Mandos client object; ignore

535

return

536

try:

537

client = self.clients_dict[path]

538

except KeyError:

539

# not found?

540

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

541

.format(name, path))

540

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

541

.format(path))

542

return

543

client.delete()

544

545

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

546

554

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

547

self.add_client(MandosClientWidget(server_proxy_object

548

=self.mandos_serv,

549

proxy_object

550

=client_proxy_object,

551

update_hook

552

=self.refresh,

553

delete_hook

554

=self.remove_client,

555

logger

556

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

557

562

path=path)

558

563

559

564

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

560

565

self.clients.append(client)

561

566

if path is None:

563

568

self.clients_dict[path] = client

564

569

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

565

570

self.refresh()

566

571

567

572

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

568

573

self.clients.remove(client)

569

574

if path is None:

570

575

path = client.proxy.object_path

571

576

del self.clients_dict[path]

572

577

self.refresh()

573

578

574

579

def refresh(self):

575

580

"""Redraw the screen"""

576

581

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

577

582

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

578

583

579

584

def run(self):

580

585

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

581

586

self.bus = dbus.SystemBus()

582

587

mandos_dbus_objc = self.bus.get_object(

583

588

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

584

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

585

dbus_interface

586

= server_interface)

589

self.mandos_serv = dbus.Interface(

590

mandos_dbus_objc, dbus_interface=server_interface)

587

591

try:

588

592

mandos_clients = (self.mandos_serv

589

593

.GetAllClientsWithProperties())

590

594

if not mandos_clients:

591

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

595

self.log_message_raw(("bold",

596

"Note: Server has no clients."))

592

597

except dbus.exceptions.DBusException:

593

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

598

self.log_message_raw(("bold",

599

"Note: No Mandos server running."))

594

600

mandos_clients = dbus.Dictionary()

595

601

596

602

(self.mandos_serv

597

.connect_to_signal("ClientRemoved",

603

.connect_to_signal("InterfacesRemoved",

598

604

self.find_and_remove_client,

599

dbus_interface=server_interface,

605

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

600

606

byte_arrays=True))

601

607

(self.mandos_serv

602

.connect_to_signal("ClientAdded",

608

.connect_to_signal("InterfacesAdded",

603

609

self.add_new_client,

604

dbus_interface=server_interface,

610

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

605

611

byte_arrays=True))

606

612

(self.mandos_serv

607

613

.connect_to_signal("ClientNotFound",

611

617

for path, client in mandos_clients.items():

612

618

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

613

619

path)

614

self.add_client(MandosClientWidget(server_proxy_object

615

=self.mandos_serv,

616

proxy_object

617

=client_proxy_object,

618

properties=client,

619

update_hook

620

=self.refresh,

621

delete_hook

622

=self.remove_client,

623

logger

624

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

625

627

path=path)

626

628

627

629

self.refresh()

628

self._input_callback_tag = (gobject.io_add_watch

630

self._input_callback_tag = (GLib.io_add_watch

629

631

(sys.stdin.fileno(),

630

gobject.IO_IN,

632

GLib.IO_IN,

631

633

self.process_input))

632

634

self.main_loop.run()

633

635

# Main loop has finished, we should close everything now

634

gobject.source_remove(self._input_callback_tag)

636

GLib.source_remove(self._input_callback_tag)

635

637

self.screen.stop()

636

638

637

639

def stop(self):

638

640

self.main_loop.quit()

639

641

640

642

def process_input(self, source, condition):

641

643

keys = self.screen.get_input()

642

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

643

"ctrl p": "up", # Emacs

644

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

645

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

646

" ": "page down", # less

647

"f": "page down", # less

648

"b": "page up", # less

649

"j": "down", # vi

650

"k": "up", # vi

651

}

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

}

652

654

for key in keys:

653

655

try:

654

656

key = translations[key]

655

657

except KeyError: # :-)

656

658

pass

657

659

658

660

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

659

661

self.stop()

660

662

break

708

710

else:

709

711

self.log_level = 0

710

712

self.log_message("Verbose mode: On")

711

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

712

# or key == ">"):

713

# pass # xxx end-of-buffer

714

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

715

# or key == "<"):

716

# pass # xxx beginning-of-buffer

717

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

718

# pass # xxx move-end-of-line

719

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

720

# pass # xxx move-beginning-of-line

721

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

722

# pass # xxx left

723

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

724

# pass # xxx right

725

#elif key == "a":

726

# pass # scroll up log

727

#elif key == "z":

728

# 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

729

731

elif self.topwidget.selectable():

730

732

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

731

733

self.refresh()