/mandos/release : revision 361

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

#

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

5

#

6

7

8

#

9

# This file is part of Mandos.

10

#

11

# Mandos is free software: you can redistribute it and/or modify it

12

# under the terms of the GNU General Public License as published by

11

13

# the Free Software Foundation, either version 3 of the License, or

12

14

# (at your option) any later version.

13

15

#

14

# This program is distributed in the hope that it will be useful,

15

# but WITHOUT ANY WARRANTY; without even the implied warranty of

16

# Mandos is distributed in the hope that it will be useful, but

17

# WITHOUT ANY WARRANTY; without even the implied warranty of

16

18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

17

19

# GNU General Public License for more details.

18

#

20

#

19

21

# 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

# along with Mandos. If not, see <http://www.gnu.org/licenses/>.

23

#

23

24

# Contact the authors at <mandos@recompile.se>.

24

#

25

#

25

26

27

from __future__ import (division, absolute_import, print_function,

27

28

unicode_literals)

39

40

import urwid

40

41

42

from dbus.mainloop.glib import DBusGMainLoop

42

try:

43

import gobject

44

except ImportError:

45

from gi.repository import GObject as gobject

43

from gi.repository import GLib

46

44

47

45

import dbus

48

46

49

47

import locale

50

48

49

import logging

50

51

if sys.version_info.major == 2:

52

str = unicode

53

54

locale.setlocale(locale.LC_ALL, '')

55

56

import logging

57

56

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

58

57

59

58

# Some useful constants

60

59

domain = 'se.recompile'

61

60

server_interface = domain + '.Mandos'

62

61

client_interface = domain + '.Mandos.Client'

63

version = "1.6.9"

62

version = "1.7.16"

63

64

try:

65

dbus.OBJECT_MANAGER_IFACE

66

except AttributeError:

67

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

68

64

69

65

70

def isoformat_to_datetime(iso):

66

71

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

75

80

int(day),

76

81

int(hour),

77

82

int(minute),

78

int(second), # Whole seconds

79

int(fraction*1000000)) # Microseconds

83

int(second), # Whole seconds

84

int(fraction*1000000)) # Microseconds

85

80

86

81

87

class MandosClientPropertyCache(object):

82

88

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

84

90

changed.

85

91

"""

86

92

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

87

self.proxy = proxy_object # Mandos Client proxy object

93

self.proxy = proxy_object # Mandos Client proxy object

88

94

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

89

95

self.property_changed_match = (

90

96

self.proxy.connect_to_signal("PropertiesChanged",

91

97

self.properties_changed,

92

98

dbus.PROPERTIES_IFACE,

93

99

byte_arrays=True))

94

100

95

101

if properties is None:

96

self.properties.update(

97

self.proxy.GetAll(client_interface,

98

dbus_interface

99

= dbus.PROPERTIES_IFACE))

100

102

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

103

client_interface,

104

dbus_interface=dbus.PROPERTIES_IFACE))

105

101

106

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

102

107

103

108

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

104

109

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

105

110

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

106

111

"""

107

112

# Update properties dict with new value

108

self.properties.update(properties)

109

113

if interface == client_interface:

114

self.properties.update(properties)

115

110

116

def delete(self):

111

117

self.property_changed_match.remove()

112

118

114

120

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

115

121

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

116

122

"""

117

123

118

124

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

119

125

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

120

126

# Called on update

125

131

self.server_proxy_object = server_proxy_object

126

132

# Logger

127

133

self.logger = logger

128

134

129

135

self._update_timer_callback_tag = None

130

136

131

137

# The widget shown normally

132

138

self._text_widget = urwid.Text("")

133

139

# The widget shown when we have focus

135

141

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

136

142

self.update()

137

143

self.opened = False

138

144

139

145

self.match_objects = (

140

146

self.proxy.connect_to_signal("CheckerCompleted",

141

147

self.checker_completed,

159

165

byte_arrays=True))

160

166

self.logger('Created client {}'

161

167

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

162

168

163

169

def using_timer(self, flag):

164

170

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

165

171

activated or deactivated.

166

172

"""

167

173

if flag and self._update_timer_callback_tag is None:

168

174

# Will update the shown timer value every second

169

self._update_timer_callback_tag = (gobject.timeout_add

175

self._update_timer_callback_tag = (GLib.timeout_add

170

176

(1000,

171

177

self.update_timer))

172

178

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

173

gobject.source_remove(self._update_timer_callback_tag)

179

GLib.source_remove(self._update_timer_callback_tag)

174

180

self._update_timer_callback_tag = None

175

176

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

181

182

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

177

183

if exitstatus == 0:

178

184

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

179

185

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

181

187

self.update()

182

188

return

183

189

# Checker failed

184

if exitstatus >= 0:

190

if os.WIFEXITED(condition):

185

191

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

186

192

' with exit code {}'

187

193

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

188

exitstatus))

189

elif signal != 0:

194

os.WEXITSTATUS(condition)))

195

elif os.WIFSIGNALED(condition):

190

196

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

191

197

' killed by signal {}'

192

198

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

193

signal))

194

else:

195

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

196

' mysteriously'

197

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

199

os.WTERMSIG(condition)))

198

200

self.update()

199

201

200

202

def checker_started(self, command):

201

203

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

202

204

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

203

205

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

204

206

command), level=0)

205

207

206

208

def got_secret(self):

207

209

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

208

210

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

209

211

210

212

def need_approval(self, timeout, default):

211

213

if not default:

212

214

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

214

216

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

215

217

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

216

218

timeout/1000))

217

219

218

220

def rejected(self, reason):

219

221

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

220

222

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

221

223

222

224

def selectable(self):

223

225

"""Make this a "selectable" widget.

224

226

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

225

227

return True

226

228

227

229

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

228

230

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

229

231

whether we have focus or not.

230

232

This overrides the method from urwid.FlowWidget"""

231

233

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

232

234

233

235

def current_widget(self, focus=False):

234

236

if focus or self.opened:

235

237

return self._focus_widget

236

238

return self._widget

237

239

238

240

def update(self):

239

241

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

240

242

# 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

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

249

251

# Rebuild focus and non-focus widgets using current properties

250

252

251

253

# Base part of a client. Name!

252

254

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

253

255

if not self.properties["Enabled"]:

254

256

message = "DISABLED"

255

257

self.using_timer(False)

256

258

elif self.properties["ApprovalPending"]:

257

timeout = datetime.timedelta(milliseconds

258

= self.properties

259

["ApprovalDelay"])

259

timeout = datetime.timedelta(

260

milliseconds=self.properties["ApprovalDelay"])

260

261

last_approval_request = isoformat_to_datetime(

261

262

self.properties["LastApprovalRequest"])

262

263

if last_approval_request is not None:

289

290

message = "enabled"

290

291

self.using_timer(False)

291

292

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

292

293

294

if not urwid.supports_unicode():

294

295

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

295

296

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

305

306

# Run update hook, if any

306

307

if self.update_hook is not None:

307

308

self.update_hook()

308

309

310

def update_timer(self):

310

"""called by gobject. Will indefinitely loop until

311

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

311

"""called by GLib. Will indefinitely loop until

312

GLib.source_remove() on tag is called

313

"""

312

314

self.update()

313

315

return True # Keep calling this

314

316

315

317

def delete(self, **kwargs):

316

318

if self._update_timer_callback_tag is not None:

317

gobject.source_remove(self._update_timer_callback_tag)

319

GLib.source_remove(self._update_timer_callback_tag)

318

320

self._update_timer_callback_tag = None

319

321

for match in self.match_objects:

320

322

match.remove()

322

324

if self.delete_hook is not None:

323

325

self.delete_hook(self)

324

326

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

325

327

326

328

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

327

329

"""Render differently if we have focus.

328

330

This overrides the method from urwid.FlowWidget"""

329

331

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

330

332

focus=focus)

331

333

332

334

def keypress(self, maxcolrow, key):

333

335

"""Handle keys.

334

336

This overrides the method from urwid.FlowWidget"""

335

337

if key == "+":

336

self.proxy.Enable(dbus_interface = client_interface,

337

ignore_reply=True)

338

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

339

dbus.Boolean(True), ignore_reply=True,

340

dbus_interface=dbus.PROPERTIES_IFACE)

338

341

elif key == "-":

339

self.proxy.Disable(dbus_interface = client_interface,

340

ignore_reply=True)

342

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

343

ignore_reply=True,

344

dbus_interface=dbus.PROPERTIES_IFACE)

341

345

elif key == "a":

342

346

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

343

dbus_interface = client_interface,

347

dbus_interface=client_interface,

344

348

ignore_reply=True)

345

349

elif key == "d":

346

350

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

347

dbus_interface = client_interface,

351

dbus_interface=client_interface,

348

352

ignore_reply=True)

349

353

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

350

354

self.server_proxy_object.RemoveClient(self.proxy

351

355

.object_path,

352

356

ignore_reply=True)

353

357

elif key == "s":

354

self.proxy.StartChecker(dbus_interface = client_interface,

355

ignore_reply=True)

358

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

359

dbus.Boolean(True), ignore_reply=True,

360

dbus_interface=dbus.PROPERTIES_IFACE)

356

361

elif key == "S":

357

self.proxy.StopChecker(dbus_interface = client_interface,

358

ignore_reply=True)

362

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

363

dbus.Boolean(False), ignore_reply=True,

364

dbus_interface=dbus.PROPERTIES_IFACE)

359

365

elif key == "C":

360

self.proxy.CheckedOK(dbus_interface = client_interface,

366

self.proxy.CheckedOK(dbus_interface=client_interface,

361

367

ignore_reply=True)

362

368

# xxx

363

369

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

368

374

# self.open()

369

375

else:

370

376

return key

371

377

372

378

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

373

379

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

374

380

This overrides the method from MandosClientPropertyCache"""

375

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

376

for key in properties.keys() }

381

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

382

for key in properties.keys()}

377

383

super(MandosClientWidget, self).properties_changed(

378

384

interface, properties, invalidated)

379

385

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

387

393

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

388

394

"""

389

395

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

390

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

396

ret = (super(ConstrainedListBox, self)

397

.keypress(*args, **kwargs))

391

398

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

392

399

return

393

400

return ret

399

406

"""

400

407

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

401

408

DBusGMainLoop(set_as_default=True)

402

409

403

410

self.screen = urwid.curses_display.Screen()

404

411

405

412

self.screen.register_palette((

406

413

("normal",

407

414

"default", "default", None),

412

419

("standout",

413

420

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

414

421

("bold-underline-blink",

415

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

422

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

423

"bold,underline,blink"),

416

424

("bold-standout",

417

425

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

418

426

("underline-blink-standout",

422

430

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

423

431

"bold,underline,blink,standout"),

424

432

))

425

433

426

434

if urwid.supports_unicode():

427

self.divider = "─" # \u2500

428

#self.divider = "━" # \u2501

435

self.divider = "─" # \u2500

429

436

else:

430

#self.divider = "-" # \u002d

431

self.divider = "_" # \u005f

432

437

self.divider = "_" # \u005f

438

433

439

self.screen.start()

434

440

435

441

self.size = self.screen.get_cols_rows()

436

442

437

443

self.clients = urwid.SimpleListWalker([])

438

444

self.clients_dict = {}

439

445

440

446

# We will add Text widgets to this list

441

447

self.log = []

442

448

self.max_log_length = max_log_length

443

449

444

450

self.log_level = log_level

445

451

446

452

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

447

453

# from the ListWalker without it getting destroyed

448

454

self.logbox = ConstrainedListBox(self.log)

449

455

450

456

# This keeps track of whether self.uilist currently has

451

457

# self.logbox in it or not

452

458

self.log_visible = True

453

459

self.log_wrap = "any"

454

460

455

461

self.rebuild()

456

462

self.log_message_raw(("bold",

457

463

"Mandos Monitor version " + version))

458

464

self.log_message_raw(("bold",

459

465

"q: Quit ?: Help"))

460

466

461

467

self.busname = domain + '.Mandos'

462

self.main_loop = gobject.MainLoop()

463

468

self.main_loop = GLib.MainLoop()

469

464

470

def client_not_found(self, fingerprint, address):

465

471

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

466

472

" could not be found"

467

473

.format(address, fingerprint))

468

474

469

475

def rebuild(self):

470

476

"""This rebuilds the User Interface.

471

477

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

472

478

self.uilist = []

473

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

479

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

474

480

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

475

481

clients),

476

#header=urwid.Divider(),

482

# header=urwid.Divider(),

477

483

header=None,

478

footer=

479

urwid.Divider(div_char=

480

self.divider)))

484

footer=urwid.Divider(

485

div_char=self.divider)))

481

486

if self.log_visible:

482

487

self.uilist.append(self.logbox)

483

488

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

484

489

485

490

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

486

491

"""Log message formatted with timestamp"""

487

492

if level < self.log_level:

489

494

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

490

495

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

491

496

level=level)

492

497

493

498

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

494

499

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

495

500

if level < self.log_level:

496

501

return

497

502

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]

503

if self.max_log_length:

504

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

505

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

501

506

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

502

507

coming_from="above")

503

508

self.refresh()

504

509

505

510

def toggle_log_display(self):

506

511

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

507

512

self.log_visible = not self.log_visible

508

513

self.rebuild()

509

514

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

510

515

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

511

516

512

517

def change_log_display(self):

513

518

"""Change type of log display.

514

519

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

520

525

textwidget.set_wrap_mode(self.log_wrap)

521

526

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

522

527

level=0)

523

524

def find_and_remove_client(self, path, name):

528

529

def find_and_remove_client(self, path, interfaces):

525

530

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

526

527

This is connected to the ClientRemoved signal from the

531

532

This is connected to the InterfacesRemoved signal from the

528

533

Mandos server object."""

534

if client_interface not in interfaces:

535

# Not a Mandos client object; ignore

536

return

529

537

try:

530

538

client = self.clients_dict[path]

531

539

except KeyError:

532

540

# not found?

533

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

534

.format(name, path))

541

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

542

.format(path))

535

543

return

536

544

client.delete()

537

538

def add_new_client(self, path):

545

546

def add_new_client(self, path, ifs_and_props):

547

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

548

549

This is connected to the InterfacesAdded signal from the

550

Mandos server object.

551

"""

552

if client_interface not in ifs_and_props:

553

# Not a Mandos client object; ignore

554

return

539

555

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

556

self.add_client(MandosClientWidget(

557

server_proxy_object=self.mandos_serv,

558

proxy_object=client_proxy_object,

559

update_hook=self.refresh,

560

delete_hook=self.remove_client,

561

logger=self.log_message,

562

properties=dict(ifs_and_props[client_interface])),

550

563

path=path)

551

564

552

565

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

553

566

self.clients.append(client)

554

567

if path is None:

556

569

self.clients_dict[path] = client

557

570

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

558

571

self.refresh()

559

572

560

573

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

561

574

self.clients.remove(client)

562

575

if path is None:

563

576

path = client.proxy.object_path

564

577

del self.clients_dict[path]

565

578

self.refresh()

566

579

567

580

def refresh(self):

568

581

"""Redraw the screen"""

569

582

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

570

583

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

571

584

572

585

def run(self):

573

586

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

574

587

self.bus = dbus.SystemBus()

575

588

mandos_dbus_objc = self.bus.get_object(

576

589

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

577

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

578

dbus_interface

579

= server_interface)

590

self.mandos_serv = dbus.Interface(

591

mandos_dbus_objc, dbus_interface=server_interface)

580

592

try:

581

593

mandos_clients = (self.mandos_serv

582

594

.GetAllClientsWithProperties())

583

595

if not mandos_clients:

584

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

596

self.log_message_raw(("bold",

597

"Note: Server has no clients."))

585

598

except dbus.exceptions.DBusException:

586

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

599

self.log_message_raw(("bold",

600

"Note: No Mandos server running."))

587

601

mandos_clients = dbus.Dictionary()

588

602

589

603

(self.mandos_serv

590

.connect_to_signal("ClientRemoved",

604

.connect_to_signal("InterfacesRemoved",

591

605

self.find_and_remove_client,

592

dbus_interface=server_interface,

606

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

593

607

byte_arrays=True))

594

608

(self.mandos_serv

595

.connect_to_signal("ClientAdded",

609

.connect_to_signal("InterfacesAdded",

596

610

self.add_new_client,

597

dbus_interface=server_interface,

611

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

598

612

byte_arrays=True))

599

613

(self.mandos_serv

600

614

.connect_to_signal("ClientNotFound",

604

618

for path, client in mandos_clients.items():

605

619

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

606

620

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

621

self.add_client(MandosClientWidget(

622

server_proxy_object=self.mandos_serv,

623

proxy_object=client_proxy_object,

624

properties=client,

625

update_hook=self.refresh,

626

delete_hook=self.remove_client,

627

logger=self.log_message),

618

628

path=path)

619

629

620

630

self.refresh()

621

self._input_callback_tag = (gobject.io_add_watch

631

self._input_callback_tag = (GLib.io_add_watch

622

632

(sys.stdin.fileno(),

623

gobject.IO_IN,

633

GLib.IO_IN,

624

634

self.process_input))

625

635

self.main_loop.run()

626

636

# Main loop has finished, we should close everything now

627

gobject.source_remove(self._input_callback_tag)

637

GLib.source_remove(self._input_callback_tag)

628

638

self.screen.stop()

629

639

630

640

def stop(self):

631

641

self.main_loop.quit()

632

642

633

643

def process_input(self, source, condition):

634

644

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

}

645

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

646

"ctrl p": "up", # Emacs

647

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

648

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

649

" ": "page down", # less

650

"f": "page down", # less

651

"b": "page up", # less

652

"j": "down", # vi

653

"k": "up", # vi

654

}

645

655

for key in keys:

646

656

try:

647

657

key = translations[key]

648

658

except KeyError: # :-)

649

659

pass

650

660

651

661

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

652

662

self.stop()

653

663

break

701

711

else:

702

712

self.log_level = 0

703

713

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

714

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

715

# or key == ">"):

716

# pass # xxx end-of-buffer

717

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

718

# or key == "<"):

719

# pass # xxx beginning-of-buffer

720

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

721

# pass # xxx move-end-of-line

722

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

723

# pass # xxx move-beginning-of-line

724

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

725

# pass # xxx left

726

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

727

# pass # xxx right

728

# elif key == "a":

729

# pass # scroll up log

730

# elif key == "z":

731

# pass # scroll down log

722

732

elif self.topwidget.selectable():

723

733

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

724

734

self.refresh()

725

735

return True

726

736

737

727

738

ui = UserInterface()

728

739

try:

729

740

ui.run()