/mandos/release : revision 237.7.318

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

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

13

11

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

14

12

# (at your option) any later version.

15

13

#

16

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

17

# WITHOUT ANY WARRANTY; without even the implied warranty of

14

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

15

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

18

16

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

19

17

# GNU General Public License for more details.

20

#

18

#

21

19

# You should have received a copy of the GNU General Public License

22

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

23

#

20

# along with this program. If not, see

21

# <http://www.gnu.org/licenses/>.

22

#

24

23

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

25

#

24

#

26

25

27

26

from __future__ import (division, absolute_import, print_function,

28

27

unicode_literals)

40

39

import urwid

41

40

42

41

from dbus.mainloop.glib import DBusGMainLoop

43

from gi.repository import GLib

42

try:

43

import gobject

44

except ImportError:

45

from gi.repository import GObject as gobject

44

46

45

47

import dbus

46

48

47

49

import locale

48

50

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

56

57

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

57

58

59

# Some useful constants

59

60

domain = 'se.recompile'

60

61

server_interface = domain + '.Mandos'

61

62

client_interface = domain + '.Mandos.Client'

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

63

version = "1.6.9"

69

64

70

65

def isoformat_to_datetime(iso):

71

66

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

80

75

int(day),

81

76

int(hour),

82

77

int(minute),

83

int(second), # Whole seconds

84

int(fraction*1000000)) # Microseconds

85

78

int(second), # Whole seconds

79

int(fraction*1000000)) # Microseconds

86

80

87

81

class MandosClientPropertyCache(object):

88

82

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

90

84

changed.

91

85

"""

92

86

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

93

self.proxy = proxy_object # Mandos Client proxy object

87

self.proxy = proxy_object # Mandos Client proxy object

94

88

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

95

89

self.property_changed_match = (

96

90

self.proxy.connect_to_signal("PropertiesChanged",

97

91

self.properties_changed,

98

92

dbus.PROPERTIES_IFACE,

99

93

byte_arrays=True))

100

94

101

95

if properties is None:

102

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

103

client_interface,

104

dbus_interface=dbus.PROPERTIES_IFACE))

105

96

self.properties.update(

97

self.proxy.GetAll(client_interface,

98

dbus_interface

99

= dbus.PROPERTIES_IFACE))

100

106

101

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

107

102

108

103

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

109

104

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

110

105

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

111

106

"""

112

107

# Update properties dict with new value

113

if interface == client_interface:

114

self.properties.update(properties)

115

108

self.properties.update(properties)

109

116

110

def delete(self):

117

111

self.property_changed_match.remove()

118

112

120

114

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

121

115

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

122

116

"""

123

117

124

118

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

125

119

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

126

120

# Called on update

131

125

self.server_proxy_object = server_proxy_object

132

126

# Logger

133

127

self.logger = logger

134

128

135

129

self._update_timer_callback_tag = None

136

130

137

131

# The widget shown normally

138

132

self._text_widget = urwid.Text("")

139

133

# The widget shown when we have focus

141

135

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

142

136

self.update()

143

137

self.opened = False

144

138

145

139

self.match_objects = (

146

140

self.proxy.connect_to_signal("CheckerCompleted",

147

141

self.checker_completed,

165

159

byte_arrays=True))

166

160

self.logger('Created client {}'

167

161

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

168

162

169

163

def using_timer(self, flag):

170

164

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

171

165

activated or deactivated.

172

166

"""

173

167

if flag and self._update_timer_callback_tag is None:

174

168

# Will update the shown timer value every second

175

self._update_timer_callback_tag = (GLib.timeout_add

169

self._update_timer_callback_tag = (gobject.timeout_add

176

170

(1000,

177

171

self.update_timer))

178

172

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

179

GLib.source_remove(self._update_timer_callback_tag)

173

gobject.source_remove(self._update_timer_callback_tag)

180

174

self._update_timer_callback_tag = None

181

182

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

175

176

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

183

177

if exitstatus == 0:

184

178

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

185

179

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

187

181

self.update()

188

182

return

189

183

# Checker failed

190

if os.WIFEXITED(condition):

184

if exitstatus >= 0:

191

185

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

192

186

' with exit code {}'

193

187

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

194

os.WEXITSTATUS(condition)))

195

elif os.WIFSIGNALED(condition):

188

exitstatus))

189

elif signal != 0:

196

190

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

197

191

' killed by signal {}'

198

192

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

199

os.WTERMSIG(condition)))

193

signal))

194

else:

195

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

196

' mysteriously'

197

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

200

198

self.update()

201

199

202

200

def checker_started(self, command):

203

201

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

204

202

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

205

203

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

206

204

command), level=0)

207

205

208

206

def got_secret(self):

209

207

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

210

208

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

211

209

212

210

def need_approval(self, timeout, default):

213

211

if not default:

214

212

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

216

214

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

217

215

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

218

216

timeout/1000))

219

217

220

218

def rejected(self, reason):

221

219

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

222

220

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

223

221

224

222

def selectable(self):

225

223

"""Make this a "selectable" widget.

226

224

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

227

225

return True

228

226

229

227

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

230

228

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

231

229

whether we have focus or not.

232

230

This overrides the method from urwid.FlowWidget"""

233

231

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

234

232

235

233

def current_widget(self, focus=False):

236

234

if focus or self.opened:

237

235

return self._focus_widget

238

236

return self._widget

239

237

240

238

def update(self):

241

239

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

242

240

# How to add standout mode to a style

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

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

251

249

# Rebuild focus and non-focus widgets using current properties

252

250

253

251

# Base part of a client. Name!

254

252

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

255

253

if not self.properties["Enabled"]:

256

254

message = "DISABLED"

257

255

self.using_timer(False)

258

256

elif self.properties["ApprovalPending"]:

259

timeout = datetime.timedelta(

260

milliseconds=self.properties["ApprovalDelay"])

257

timeout = datetime.timedelta(milliseconds

258

= self.properties

259

["ApprovalDelay"])

261

260

last_approval_request = isoformat_to_datetime(

262

261

self.properties["LastApprovalRequest"])

263

262

if last_approval_request is not None:

290

289

message = "enabled"

291

290

self.using_timer(False)

292

291

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

293

292

294

293

if not urwid.supports_unicode():

295

294

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

296

295

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

306

305

# Run update hook, if any

307

306

if self.update_hook is not None:

308

307

self.update_hook()

309

308

310

309

def update_timer(self):

311

"""called by GLib. Will indefinitely loop until

312

GLib.source_remove() on tag is called

313

"""

310

"""called by gobject. Will indefinitely loop until

311

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

314

312

self.update()

315

313

return True # Keep calling this

316

314

317

315

def delete(self, **kwargs):

318

316

if self._update_timer_callback_tag is not None:

319

GLib.source_remove(self._update_timer_callback_tag)

317

gobject.source_remove(self._update_timer_callback_tag)

320

318

self._update_timer_callback_tag = None

321

319

for match in self.match_objects:

322

320

match.remove()

324

322

if self.delete_hook is not None:

325

323

self.delete_hook(self)

326

324

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

327

325

328

326

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

329

327

"""Render differently if we have focus.

330

328

This overrides the method from urwid.FlowWidget"""

331

329

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

332

330

focus=focus)

333

331

334

332

def keypress(self, maxcolrow, key):

335

333

"""Handle keys.

336

334

This overrides the method from urwid.FlowWidget"""

337

335

if key == "+":

338

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

339

dbus.Boolean(True), ignore_reply=True,

340

dbus_interface=dbus.PROPERTIES_IFACE)

336

self.proxy.Enable(dbus_interface = client_interface,

337

ignore_reply=True)

341

338

elif key == "-":

342

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

343

ignore_reply=True,

344

dbus_interface=dbus.PROPERTIES_IFACE)

339

self.proxy.Disable(dbus_interface = client_interface,

340

ignore_reply=True)

345

341

elif key == "a":

346

342

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

347

dbus_interface=client_interface,

343

dbus_interface = client_interface,

348

344

ignore_reply=True)

349

345

elif key == "d":

350

346

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

351

dbus_interface=client_interface,

347

dbus_interface = client_interface,

352

348

ignore_reply=True)

353

349

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

354

350

self.server_proxy_object.RemoveClient(self.proxy

355

351

.object_path,

356

352

ignore_reply=True)

357

353

elif key == "s":

358

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

359

dbus.Boolean(True), ignore_reply=True,

360

dbus_interface=dbus.PROPERTIES_IFACE)

354

self.proxy.StartChecker(dbus_interface = client_interface,

355

ignore_reply=True)

361

356

elif key == "S":

362

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

363

dbus.Boolean(False), ignore_reply=True,

364

dbus_interface=dbus.PROPERTIES_IFACE)

357

self.proxy.StopChecker(dbus_interface = client_interface,

358

ignore_reply=True)

365

359

elif key == "C":

366

self.proxy.CheckedOK(dbus_interface=client_interface,

360

self.proxy.CheckedOK(dbus_interface = client_interface,

367

361

ignore_reply=True)

368

362

# xxx

369

363

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

374

368

# self.open()

375

369

else:

376

370

return key

377

371

378

372

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

379

373

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

380

374

This overrides the method from MandosClientPropertyCache"""

381

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

382

for key in properties.keys()}

375

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

376

for key in properties.keys() }

383

377

super(MandosClientWidget, self).properties_changed(

384

378

interface, properties, invalidated)

385

379

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

393

387

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

394

388

"""

395

389

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

396

ret = (super(ConstrainedListBox, self)

397

.keypress(*args, **kwargs))

390

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

398

391

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

399

392

return

400

393

return ret

406

399

"""

407

400

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

408

401

DBusGMainLoop(set_as_default=True)

409

402

410

403

self.screen = urwid.curses_display.Screen()

411

404

412

405

self.screen.register_palette((

413

406

("normal",

414

407

"default", "default", None),

419

412

("standout",

420

413

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

421

414

("bold-underline-blink",

422

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

423

"bold,underline,blink"),

415

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

424

416

("bold-standout",

425

417

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

426

418

("underline-blink-standout",

430

422

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

431

423

"bold,underline,blink,standout"),

432

424

))

433

425

434

426

if urwid.supports_unicode():

435

self.divider = "─" # \u2500

427

self.divider = "─" # \u2500

428

#self.divider = "━" # \u2501

436

429

else:

437

self.divider = "_" # \u005f

438

430

#self.divider = "-" # \u002d

431

self.divider = "_" # \u005f

432

439

433

self.screen.start()

440

434

441

435

self.size = self.screen.get_cols_rows()

442

436

443

437

self.clients = urwid.SimpleListWalker([])

444

438

self.clients_dict = {}

445

439

446

440

# We will add Text widgets to this list

447

441

self.log = []

448

442

self.max_log_length = max_log_length

449

443

450

444

self.log_level = log_level

451

445

452

446

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

453

447

# from the ListWalker without it getting destroyed

454

448

self.logbox = ConstrainedListBox(self.log)

455

449

456

450

# This keeps track of whether self.uilist currently has

457

451

# self.logbox in it or not

458

452

self.log_visible = True

459

453

self.log_wrap = "any"

460

454

461

455

self.rebuild()

462

456

self.log_message_raw(("bold",

463

457

"Mandos Monitor version " + version))

464

458

self.log_message_raw(("bold",

465

459

"q: Quit ?: Help"))

466

460

467

461

self.busname = domain + '.Mandos'

468

self.main_loop = GLib.MainLoop()

469

462

self.main_loop = gobject.MainLoop()

463

470

464

def client_not_found(self, fingerprint, address):

471

465

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

472

466

" could not be found"

473

467

.format(address, fingerprint))

474

468

475

469

def rebuild(self):

476

470

"""This rebuilds the User Interface.

477

471

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

478

472

self.uilist = []

479

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

473

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

480

474

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

481

475

clients),

482

# header=urwid.Divider(),

476

#header=urwid.Divider(),

483

477

header=None,

484

footer=urwid.Divider(

485

div_char=self.divider)))

478

footer=

479

urwid.Divider(div_char=

480

self.divider)))

486

481

if self.log_visible:

487

482

self.uilist.append(self.logbox)

488

483

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

489

484

490

485

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

491

486

"""Log message formatted with timestamp"""

492

487

if level < self.log_level:

494

489

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

495

490

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

496

491

level=level)

497

492

498

493

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

499

494

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

500

495

if level < self.log_level:

501

496

return

502

497

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

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]

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]

506

501

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

507

502

coming_from="above")

508

503

self.refresh()

509

504

510

505

def toggle_log_display(self):

511

506

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

512

507

self.log_visible = not self.log_visible

513

508

self.rebuild()

514

509

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

515

510

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

516

511

517

512

def change_log_display(self):

518

513

"""Change type of log display.

519

514

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

525

520

textwidget.set_wrap_mode(self.log_wrap)

526

521

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

527

522

level=0)

528

529

def find_and_remove_client(self, path, interfaces):

523

524

def find_and_remove_client(self, path, name):

530

525

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

531

532

This is connected to the InterfacesRemoved signal from the

526

527

This is connected to the ClientRemoved signal from the

533

528

Mandos server object."""

534

if client_interface not in interfaces:

535

# Not a Mandos client object; ignore

536

return

537

529

try:

538

530

client = self.clients_dict[path]

539

531

except KeyError:

540

532

# not found?

541

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

542

.format(path))

533

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

534

.format(name, path))

543

535

return

544

536

client.delete()

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

537

538

def add_new_client(self, path):

555

539

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

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

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

563

550

path=path)

564

551

565

552

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

566

553

self.clients.append(client)

567

554

if path is None:

569

556

self.clients_dict[path] = client

570

557

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

571

558

self.refresh()

572

559

573

560

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

574

561

self.clients.remove(client)

575

562

if path is None:

576

563

path = client.proxy.object_path

577

564

del self.clients_dict[path]

578

565

self.refresh()

579

566

580

567

def refresh(self):

581

568

"""Redraw the screen"""

582

569

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

583

570

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

584

571

585

572

def run(self):

586

573

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

587

574

self.bus = dbus.SystemBus()

588

575

mandos_dbus_objc = self.bus.get_object(

589

576

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

590

self.mandos_serv = dbus.Interface(

591

mandos_dbus_objc, dbus_interface=server_interface)

577

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

578

dbus_interface

579

= server_interface)

592

580

try:

593

581

mandos_clients = (self.mandos_serv

594

582

.GetAllClientsWithProperties())

595

583

if not mandos_clients:

596

self.log_message_raw(("bold",

597

"Note: Server has no clients."))

584

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

598

585

except dbus.exceptions.DBusException:

599

self.log_message_raw(("bold",

600

"Note: No Mandos server running."))

586

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

601

587

mandos_clients = dbus.Dictionary()

602

588

603

589

(self.mandos_serv

604

.connect_to_signal("InterfacesRemoved",

590

.connect_to_signal("ClientRemoved",

605

591

self.find_and_remove_client,

606

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

592

dbus_interface=server_interface,

607

593

byte_arrays=True))

608

594

(self.mandos_serv

609

.connect_to_signal("InterfacesAdded",

595

.connect_to_signal("ClientAdded",

610

596

self.add_new_client,

611

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

597

dbus_interface=server_interface,

612

598

byte_arrays=True))

613

599

(self.mandos_serv

614

600

.connect_to_signal("ClientNotFound",

618

604

for path, client in mandos_clients.items():

619

605

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

620

606

path)

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

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

628

618

path=path)

629

619

630

620

self.refresh()

631

self._input_callback_tag = (GLib.io_add_watch

621

self._input_callback_tag = (gobject.io_add_watch

632

622

(sys.stdin.fileno(),

633

GLib.IO_IN,

623

gobject.IO_IN,

634

624

self.process_input))

635

625

self.main_loop.run()

636

626

# Main loop has finished, we should close everything now

637

GLib.source_remove(self._input_callback_tag)

627

gobject.source_remove(self._input_callback_tag)

638

628

self.screen.stop()

639

629

640

630

def stop(self):

641

631

self.main_loop.quit()

642

632

643

633

def process_input(self, source, condition):

644

634

keys = self.screen.get_input()

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

}

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

}

655

645

for key in keys:

656

646

try:

657

647

key = translations[key]

658

648

except KeyError: # :-)

659

649

pass

660

650

661

651

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

662

652

self.stop()

663

653

break

711

701

else:

712

702

self.log_level = 0

713

703

self.log_message("Verbose mode: On")

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

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

732

722

elif self.topwidget.selectable():

733

723

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

734

724

self.refresh()

735

725

return True

736

726

737

738

727

ui = UserInterface()

739

728

try:

740

729

ui.run()