/mandos/trunk : revision 460

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

5

#

6

7

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

19

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

20

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

21

#

22

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

22

# Contact the authors at <mandos@fukt.bsnet.se>.

23

#

24

25

from __future__ import (division, absolute_import, print_function,

26

unicode_literals)

25

from __future__ import division, absolute_import, with_statement

27

26

28

27

import sys

29

28

import os

43

42

44

43

import locale

45

44

46

locale.setlocale(locale.LC_ALL, '')

45

locale.setlocale(locale.LC_ALL, u'')

47

46

48

47

import logging

49

48

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

50

49

51

50

# Some useful constants

52

domain = 'se.recompile'

51

domain = 'se.bsnet.fukt'

53

52

server_interface = domain + '.Mandos'

54

53

client_interface = domain + '.Mandos.Client'

55

version = "1.4.1"

54

version = "1.2.3"

56

55

57

56

# Always run in monochrome mode

58

57

urwid.curses_display.curses.has_colors = lambda : False

66

65

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

67

66

if not iso:

68

67

return None

69

d, t = iso.split("T", 1)

70

year, month, day = d.split("-", 2)

71

hour, minute, second = t.split(":", 2)

68

d, t = iso.split(u"T", 1)

69

year, month, day = d.split(u"-", 2)

70

hour, minute, second = t.split(u":", 2)

72

71

second, fraction = divmod(float(second), 1)

73

72

return datetime.datetime(int(year),

74

73

int(month),

87

86

self.proxy = proxy_object # Mandos Client proxy object

88

87

89

88

self.properties = dict()

90

self.property_changed_match = (

91

self.proxy.connect_to_signal("PropertyChanged",

92

self.property_changed,

93

client_interface,

94

byte_arrays=True))

89

self.proxy.connect_to_signal(u"PropertyChanged",

90

self.property_changed,

91

client_interface,

92

byte_arrays=True)

95

93

96

94

self.properties.update(

97

95

self.proxy.GetAll(client_interface,

98

96

dbus_interface = dbus.PROPERTIES_IFACE))

99

97

100

#XXX This breaks good super behaviour

98

#XXX This break good super behaviour!

101

99

# super(MandosClientPropertyCache, self).__init__(

102

100

# *args, **kwargs)

103

101

107

105

"""

108

106

# Update properties dict with new value

109

107

self.properties[property] = value

110

111

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

112

self.property_changed_match.remove()

113

super(MandosClientPropertyCache, self).__init__(

114

*args, **kwargs)

115

108

116

109

117

110

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

134

127

self.last_checker_failed = False

135

128

136

129

# The widget shown normally

137

self._text_widget = urwid.Text("")

130

self._text_widget = urwid.Text(u"")

138

131

# The widget shown when we have focus

139

self._focus_text_widget = urwid.Text("")

132

self._focus_text_widget = urwid.Text(u"")

140

133

super(MandosClientWidget, self).__init__(

141

134

update_hook=update_hook, delete_hook=delete_hook,

142

135

*args, **kwargs)

144

137

self.opened = False

145

138

146

139

last_checked_ok = isoformat_to_datetime(self.properties

147

["LastCheckedOK"])

140

[u"LastCheckedOK"])

148

141

if last_checked_ok is None:

149

142

self.last_checker_failed = True

150

143

else:

153

146

> datetime.timedelta

154

147

(milliseconds=

155

148

self.properties

156

["Interval"]))

149

[u"Interval"]))

157

150

158

151

if self.last_checker_failed:

159

152

self.using_timer(True)

161

154

if self.need_approval:

162

155

self.using_timer(True)

163

156

164

self.match_objects = (

165

self.proxy.connect_to_signal("CheckerCompleted",

166

self.checker_completed,

167

client_interface,

168

byte_arrays=True),

169

self.proxy.connect_to_signal("CheckerStarted",

170

self.checker_started,

171

client_interface,

172

byte_arrays=True),

173

self.proxy.connect_to_signal("GotSecret",

174

self.got_secret,

175

client_interface,

176

byte_arrays=True),

177

self.proxy.connect_to_signal("NeedApproval",

178

self.need_approval,

179

client_interface,

180

byte_arrays=True),

181

self.proxy.connect_to_signal("Rejected",

182

self.rejected,

183

client_interface,

184

byte_arrays=True))

185

#self.logger('Created client %s' % (self.properties["Name"]))

157

self.proxy.connect_to_signal(u"CheckerCompleted",

158

self.checker_completed,

159

client_interface,

160

byte_arrays=True)

161

self.proxy.connect_to_signal(u"CheckerStarted",

162

self.checker_started,

163

client_interface,

164

byte_arrays=True)

165

self.proxy.connect_to_signal(u"GotSecret",

166

self.got_secret,

167

client_interface,

168

byte_arrays=True)

169

self.proxy.connect_to_signal(u"NeedApproval",

170

self.need_approval,

171

client_interface,

172

byte_arrays=True)

173

self.proxy.connect_to_signal(u"Rejected",

174

self.rejected,

175

client_interface,

176

byte_arrays=True)

186

177

187

178

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

188

179

super(self, MandosClientWidget).property_changed(property,

189

180

value)

190

if property == "ApprovalPending":

181

if property == u"ApprovalPending":

191

182

using_timer(bool(value))

192

183

193

184

def using_timer(self, flag):

200

191

else:

201

192

self._update_timer_callback_lock -= 1

202

193

if old == 0 and self._update_timer_callback_lock:

203

# Will update the shown timer value every second

204

194

self._update_timer_callback_tag = (gobject.timeout_add

205

195

(1000,

206

196

self.update_timer))

213

203

if self.last_checker_failed:

214

204

self.last_checker_failed = False

215

205

self.using_timer(False)

216

#self.logger('Checker for client %s (command "%s")'

217

# ' was successful'

218

# % (self.properties["Name"], command))

206

#self.logger(u'Checker for client %s (command "%s")'

207

# u' was successful'

208

# % (self.properties[u"Name"], command))

219

209

self.update()

220

210

return

221

211

# Checker failed

223

213

self.last_checker_failed = True

224

214

self.using_timer(True)

225

215

if os.WIFEXITED(condition):

226

self.logger('Checker for client %s (command "%s")'

227

' failed with exit code %s'

228

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

216

self.logger(u'Checker for client %s (command "%s")'

217

u' failed with exit code %s'

218

% (self.properties[u"Name"], command,

229

219

os.WEXITSTATUS(condition)))

230

220

elif os.WIFSIGNALED(condition):

231

self.logger('Checker for client %s (command "%s")'

232

' was killed by signal %s'

233

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

221

self.logger(u'Checker for client %s (command "%s")'

222

u' was killed by signal %s'

223

% (self.properties[u"Name"], command,

234

224

os.WTERMSIG(condition)))

235

225

elif os.WCOREDUMP(condition):

236

self.logger('Checker for client %s (command "%s")'

237

' dumped core'

238

% (self.properties["Name"], command))

226

self.logger(u'Checker for client %s (command "%s")'

227

u' dumped core'

228

% (self.properties[u"Name"], command))

239

229

else:

240

self.logger('Checker for client %s completed'

241

' mysteriously')

230

self.logger(u'Checker for client %s completed'

231

u' mysteriously')

242

232

self.update()

243

233

244

234

def checker_started(self, command):

245

"""Server signals that a checker started. This could be useful

246

to log in the future. """

247

#self.logger('Client %s started checker "%s"'

248

# % (self.properties["Name"], unicode(command)))

235

#self.logger(u'Client %s started checker "%s"'

236

# % (self.properties[u"Name"], unicode(command)))

249

237

pass

250

238

251

239

def got_secret(self):

252

240

self.last_checker_failed = False

253

self.logger('Client %s received its secret'

254

% self.properties["Name"])

241

self.logger(u'Client %s received its secret'

242

% self.properties[u"Name"])

255

243

256

244

def need_approval(self, timeout, default):

257

245

if not default:

258

message = 'Client %s needs approval within %s seconds'

246

message = u'Client %s needs approval within %s seconds'

259

247

else:

260

message = 'Client %s will get its secret in %s seconds'

248

message = u'Client %s will get its secret in %s seconds'

261

249

self.logger(message

262

% (self.properties["Name"], timeout/1000))

250

% (self.properties[u"Name"], timeout/1000))

263

251

self.using_timer(True)

264

252

265

253

def rejected(self, reason):

266

self.logger('Client %s was rejected; reason: %s'

267

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

254

self.logger(u'Client %s was rejected; reason: %s'

255

% (self.properties[u"Name"], reason))

268

256

269

257

def selectable(self):

270

258

"""Make this a "selectable" widget.

271

259

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

272

260

return True

273

261

274

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

262

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

275

263

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

276

264

whether we have focus or not.

277

265

This overrides the method from urwid.FlowWidget"""

278

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

266

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

279

267

280

268

def current_widget(self, focus=False):

281

269

if focus or self.opened:

285

273

def update(self):

286

274

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

287

275

# How to add standout mode to a style

288

with_standout = { "normal": "standout",

289

"bold": "bold-standout",

290

"underline-blink":

291

"underline-blink-standout",

292

"bold-underline-blink":

293

"bold-underline-blink-standout",

276

with_standout = { u"normal": u"standout",

277

u"bold": u"bold-standout",

278

u"underline-blink":

279

u"underline-blink-standout",

280

u"bold-underline-blink":

281

u"bold-underline-blink-standout",

294

282

}

295

283

296

284

# Rebuild focus and non-focus widgets using current properties

297

285

298

286

# Base part of a client. Name!

299

base = ('%(name)s: '

300

% {"name": self.properties["Name"]})

301

if not self.properties["Enabled"]:

302

message = "DISABLED"

303

elif self.properties["ApprovalPending"]:

287

base = (u'%(name)s: '

288

% {u"name": self.properties[u"Name"]})

289

if not self.properties[u"Enabled"]:

290

message = u"DISABLED"

291

elif self.properties[u"ApprovalPending"]:

304

292

timeout = datetime.timedelta(milliseconds

305

293

= self.properties

306

["ApprovalDelay"])

294

[u"ApprovalDelay"])

307

295

last_approval_request = isoformat_to_datetime(

308

self.properties["LastApprovalRequest"])

296

self.properties[u"LastApprovalRequest"])

309

297

if last_approval_request is not None:

310

298

timer = timeout - (datetime.datetime.utcnow()

311

299

- last_approval_request)

312

300

else:

313

301

timer = datetime.timedelta()

314

if self.properties["ApprovedByDefault"]:

315

message = "Approval in %s. (d)eny?"

302

if self.properties[u"ApprovedByDefault"]:

303

message = u"Approval in %s. (d)eny?"

316

304

else:

317

message = "Denial in %s. (a)pprove?"

305

message = u"Denial in %s. (a)pprove?"

318

306

message = message % unicode(timer).rsplit(".", 1)[0]

319

307

elif self.last_checker_failed:

320

# When checker has failed, print a timer until client expires

321

expires = self.properties["Expires"]

322

if expires == "":

323

timer = datetime.timedelta(0)

324

else:

325

expires = datetime.datetime.strptime(expires,

326

'%Y-%m-%dT%H:%M:%S.%f')

327

timer = expires - datetime.datetime.utcnow()

328

message = ('A checker has failed! Time until client'

329

' gets disabled: %s'

308

timeout = datetime.timedelta(milliseconds

309

= self.properties

310

[u"Timeout"])

311

last_ok = isoformat_to_datetime(

312

max((self.properties[u"LastCheckedOK"]

313

or self.properties[u"Created"]),

314

self.properties[u"LastEnabled"]))

315

timer = timeout - (datetime.datetime.utcnow() - last_ok)

316

message = (u'A checker has failed! Time until client'

317

u' gets disabled: %s'

330

318

% unicode(timer).rsplit(".", 1)[0])

331

319

else:

332

message = "enabled"

320

message = u"enabled"

333

321

self._text = "%s%s" % (base, message)

334

322

335

323

if not urwid.supports_unicode():

336

324

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

337

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

325

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

338

326

self._text_widget.set_text(textlist)

339

327

self._focus_text_widget.set_text([(with_standout[text[0]],

340

328

text[1])

349

337

self.update_hook()

350

338

351

339

def update_timer(self):

352

"""called by gobject. Will indefinitely loop until

353

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

340

"called by gobject"

354

341

self.update()

355

342

return True # Keep calling this

356

343

357

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

344

def delete(self):

358

345

if self._update_timer_callback_tag is not None:

359

346

gobject.source_remove(self._update_timer_callback_tag)

360

347

self._update_timer_callback_tag = None

361

for match in self.match_objects:

362

match.remove()

363

self.match_objects = ()

364

348

if self.delete_hook is not None:

365

349

self.delete_hook(self)

366

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

367

350

368

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

351

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

369

352

"""Render differently if we have focus.

370

353

This overrides the method from urwid.FlowWidget"""

371

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

354

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

372

355

focus=focus)

373

356

374

def keypress(self, maxcolrow, key):

357

def keypress(self, (maxcol,), key):

375

358

"""Handle keys.

376

359

This overrides the method from urwid.FlowWidget"""

377

if key == "+":

378

self.proxy.Enable(dbus_interface = client_interface,

379

ignore_reply=True)

380

elif key == "-":

381

self.proxy.Disable(dbus_interface = client_interface,

382

ignore_reply=True)

383

elif key == "a":

360

if key == u"+":

361

self.proxy.Enable(dbus_interface = client_interface)

362

elif key == u"-":

363

self.proxy.Disable(dbus_interface = client_interface)

364

elif key == u"a":

384

365

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

385

dbus_interface = client_interface,

386

ignore_reply=True)

387

elif key == "d":

366

dbus_interface = client_interface)

367

elif key == u"d":

388

368

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

389

dbus_interface = client_interface,

390

ignore_reply=True)

391

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

369

dbus_interface = client_interface)

370

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

392

371

self.server_proxy_object.RemoveClient(self.proxy

393

.object_path,

394

ignore_reply=True)

395

elif key == "s":

396

self.proxy.StartChecker(dbus_interface = client_interface,

397

ignore_reply=True)

398

elif key == "S":

399

self.proxy.StopChecker(dbus_interface = client_interface,

400

ignore_reply=True)

401

elif key == "C":

402

self.proxy.CheckedOK(dbus_interface = client_interface,

403

ignore_reply=True)

372

.object_path)

373

elif key == u"s":

374

self.proxy.StartChecker(dbus_interface = client_interface)

375

elif key == u"S":

376

self.proxy.StopChecker(dbus_interface = client_interface)

377

elif key == u"C":

378

self.proxy.CheckedOK(dbus_interface = client_interface)

404

379

# xxx

405

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

380

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

406

381

# self.proxy.pause()

407

# elif key == "u" or key == ":":

382

# elif key == u"u" or key == ":":

408

383

# self.proxy.unpause()

409

# elif key == "RET":

384

# elif key == u"RET":

410

385

# self.open()

411

386

else:

412

387

return key

428

403

"down" key presses, thus not allowing any containing widgets to

429

404

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

430

405

"""

431

def keypress(self, maxcolrow, key):

432

ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)

433

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

406

def keypress(self, (maxcol, maxrow), key):

407

ret = super(ConstrainedListBox, self).keypress((maxcol,

408

maxrow), key)

409

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

434

410

return

435

411

return ret

436

412

445

421

self.screen = urwid.curses_display.Screen()

446

422

447

423

self.screen.register_palette((

448

("normal",

449

"default", "default", None),

450

("bold",

451

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

452

("underline-blink",

453

"default", "default", "underline"),

454

("standout",

455

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

456

("bold-underline-blink",

457

"default", "default", ("bold", "underline")),

458

("bold-standout",

459

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

460

("underline-blink-standout",

461

"default", "default", ("underline", "standout")),

462

("bold-underline-blink-standout",

463

"default", "default", ("bold", "underline",

464

"standout")),

424

(u"normal",

425

u"default", u"default", None),

426

(u"bold",

427

u"default", u"default", u"bold"),

428

(u"underline-blink",

429

u"default", u"default", u"underline"),

430

(u"standout",

431

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

432

(u"bold-underline-blink",

433

u"default", u"default", (u"bold", u"underline")),

434

(u"bold-standout",

435

u"default", u"default", (u"bold", u"standout")),

436

(u"underline-blink-standout",

437

u"default", u"default", (u"underline", u"standout")),

438

(u"bold-underline-blink-standout",

439

u"default", u"default", (u"bold", u"underline",

440

u"standout")),

465

441

))

466

442

467

443

if urwid.supports_unicode():

468

self.divider = "─" # \u2500

469

#self.divider = "━" # \u2501

444

self.divider = u"─" # \u2500

445

#self.divider = u"━" # \u2501

470

446

else:

471

#self.divider = "-" # \u002d

472

self.divider = "_" # \u005f

447

#self.divider = u"-" # \u002d

448

self.divider = u"_" # \u005f

473

449

474

450

self.screen.start()

475

451

489

465

# This keeps track of whether self.uilist currently has

490

466

# self.logbox in it or not

491

467

self.log_visible = True

492

self.log_wrap = "any"

468

self.log_wrap = u"any"

493

469

494

470

self.rebuild()

495

self.log_message_raw(("bold",

496

"Mandos Monitor version " + version))

497

self.log_message_raw(("bold",

498

"q: Quit ?: Help"))

471

self.log_message_raw((u"bold",

472

u"Mandos Monitor version " + version))

473

self.log_message_raw((u"bold",

474

u"q: Quit ?: Help"))

499

475

500

476

self.busname = domain + '.Mandos'

501

477

self.main_loop = gobject.MainLoop()

478

self.bus = dbus.SystemBus()

479

mandos_dbus_objc = self.bus.get_object(

480

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

481

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

482

dbus_interface

483

= server_interface)

484

try:

485

mandos_clients = (self.mandos_serv

486

.GetAllClientsWithProperties())

487

except dbus.exceptions.DBusException:

488

mandos_clients = dbus.Dictionary()

489

490

(self.mandos_serv

491

.connect_to_signal(u"ClientRemoved",

492

self.find_and_remove_client,

493

dbus_interface=server_interface,

494

byte_arrays=True))

495

(self.mandos_serv

496

.connect_to_signal(u"ClientAdded",

497

self.add_new_client,

498

dbus_interface=server_interface,

499

byte_arrays=True))

500

(self.mandos_serv

501

.connect_to_signal(u"ClientNotFound",

502

self.client_not_found,

503

dbus_interface=server_interface,

504

byte_arrays=True))

505

for path, client in mandos_clients.iteritems():

506

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

507

path)

508

self.add_client(MandosClientWidget(server_proxy_object

509

=self.mandos_serv,

510

proxy_object

511

=client_proxy_object,

512

properties=client,

513

update_hook

514

=self.refresh,

515

delete_hook

516

=self.remove_client,

517

logger

518

=self.log_message),

519

path=path)

502

520

503

521

def client_not_found(self, fingerprint, address):

504

self.log_message(("Client with address %s and fingerprint %s"

505

" could not be found" % (address,

522

self.log_message((u"Client with address %s and fingerprint %s"

523

u" could not be found" % (address,

506

524

fingerprint)))

507

525

508

526

def rebuild(self):

519

537

self.divider)))

520

538

if self.log_visible:

521

539

self.uilist.append(self.logbox)

540

pass

522

541

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

523

542

524

543

def log_message(self, message):

525

544

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

526

self.log_message_raw(timestamp + ": " + message)

545

self.log_message_raw(timestamp + u": " + message)

527

546

528

547

def log_message_raw(self, markup):

529

548

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

532

551

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

533

552

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

534

553

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

535

coming_from="above")

554

coming_from=u"above")

536

555

self.refresh()

537

556

538

557

def toggle_log_display(self):

539

558

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

540

559

self.log_visible = not self.log_visible

541

560

self.rebuild()

542

#self.log_message("Log visibility changed to: "

561

#self.log_message(u"Log visibility changed to: "

543

562

# + unicode(self.log_visible))

544

563

545

564

def change_log_display(self):

546

565

"""Change type of log display.

547

566

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

548

if self.log_wrap == "clip":

549

self.log_wrap = "any"

567

if self.log_wrap == u"clip":

568

self.log_wrap = u"any"

550

569

else:

551

self.log_wrap = "clip"

570

self.log_wrap = u"clip"

552

571

for textwidget in self.log:

553

572

textwidget.set_wrap_mode(self.log_wrap)

554

#self.log_message("Wrap mode: " + self.log_wrap)

573

#self.log_message(u"Wrap mode: " + self.log_wrap)

555

574

556

575

def find_and_remove_client(self, path, name):

557

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

576

"""Find an client from its object path and remove it.

558

577

559

578

This is connected to the ClientRemoved signal from the

560

579

Mandos server object."""

562

581

client = self.clients_dict[path]

563

582

except KeyError:

564

583

# not found?

565

self.log_message("Unknown client %r (%r) removed", name,

566

path)

567

584

return

568

client.delete()

585

self.remove_client(client, path)

569

586

570

587

def add_new_client(self, path):

571

588

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

586

603

if path is None:

587

604

path = client.proxy.object_path

588

605

self.clients_dict[path] = client

589

self.clients.sort(None, lambda c: c.properties["Name"])

606

self.clients.sort(None, lambda c: c.properties[u"Name"])

590

607

self.refresh()

591

608

592

609

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

608

625

609

626

def run(self):

610

627

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

611

self.bus = dbus.SystemBus()

612

mandos_dbus_objc = self.bus.get_object(

613

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

614

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

615

dbus_interface

616

= server_interface)

617

try:

618

mandos_clients = (self.mandos_serv

619

.GetAllClientsWithProperties())

620

except dbus.exceptions.DBusException:

621

mandos_clients = dbus.Dictionary()

622

623

(self.mandos_serv

624

.connect_to_signal("ClientRemoved",

625

self.find_and_remove_client,

626

dbus_interface=server_interface,

627

byte_arrays=True))

628

(self.mandos_serv

629

.connect_to_signal("ClientAdded",

630

self.add_new_client,

631

dbus_interface=server_interface,

632

byte_arrays=True))

633

(self.mandos_serv

634

.connect_to_signal("ClientNotFound",

635

self.client_not_found,

636

dbus_interface=server_interface,

637

byte_arrays=True))

638

for path, client in mandos_clients.iteritems():

639

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

640

path)

641

self.add_client(MandosClientWidget(server_proxy_object

642

=self.mandos_serv,

643

proxy_object

644

=client_proxy_object,

645

properties=client,

646

update_hook

647

=self.refresh,

648

delete_hook

649

=self.remove_client,

650

logger

651

=self.log_message),

652

path=path)

653

654

628

self.refresh()

655

629

self._input_callback_tag = (gobject.io_add_watch

656

630

(sys.stdin.fileno(),

666

640

667

641

def process_input(self, source, condition):

668

642

keys = self.screen.get_input()

669

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

670

"ctrl p": "up", # Emacs

671

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

672

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

673

" ": "page down", # less

674

"f": "page down", # less

675

"b": "page up", # less

676

"j": "down", # vi

677

"k": "up", # vi

643

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

644

u"ctrl p": u"up", # Emacs

645

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

646

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

647

u" ": u"page down", # less

648

u"f": u"page down", # less

649

u"b": u"page up", # less

650

u"j": u"down", # vi

651

u"k": u"up", # vi

678

652

}

679

653

for key in keys:

680

654

try:

682

656

except KeyError: # :-)

683

657

pass

684

658

685

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

659

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

686

660

self.stop()

687

661

break

688

elif key == "window resize":

662

elif key == u"window resize":

689

663

self.size = self.screen.get_cols_rows()

690

664

self.refresh()

691

elif key == "\f": # Ctrl-L

665

elif key == u"\f": # Ctrl-L

692

666

self.refresh()

693

elif key == "l" or key == "D":

667

elif key == u"l" or key == u"D":

694

668

self.toggle_log_display()

695

669

self.refresh()

696

elif key == "w" or key == "i":

670

elif key == u"w" or key == u"i":

697

671

self.change_log_display()

698

672

self.refresh()

699

elif key == "?" or key == "f1" or key == "esc":

673

elif key == u"?" or key == u"f1" or key == u"esc":

700

674

if not self.log_visible:

701

675

self.log_visible = True

702

676

self.rebuild()

703

self.log_message_raw(("bold",

704

" ".

705

join(("q: Quit",

706

"?: Help",

707

"l: Log window toggle",

708

"TAB: Switch window",

709

"w: Wrap (log)"))))

710

self.log_message_raw(("bold",

711

" "

712

.join(("Clients:",

713

"+: Enable",

714

"-: Disable",

715

"R: Remove",

716

"s: Start new checker",

717

"S: Stop checker",

718

"C: Checker OK",

719

"a: Approve",

720

"d: Deny"))))

677

self.log_message_raw((u"bold",

678

u" ".

679

join((u"q: Quit",

680

u"?: Help",

681

u"l: Log window toggle",

682

u"TAB: Switch window",

683

u"w: Wrap (log)"))))

684

self.log_message_raw((u"bold",

685

u" "

686

.join((u"Clients:",

687

u"+: Enable",

688

u"-: Disable",

689

u"R: Remove",

690

u"s: Start new checker",

691

u"S: Stop checker",

692

u"C: Checker OK",

693

u"a: Approve",

694

u"d: Deny"))))

721

695

self.refresh()

722

elif key == "tab":

696

elif key == u"tab":

723

697

if self.topwidget.get_focus() is self.logbox:

724

698

self.topwidget.set_focus(0)

725

699

else:

726

700

self.topwidget.set_focus(self.logbox)

727

701

self.refresh()

728

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

729

# or key == ">"):

702

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

703

# or key == u">"):

730

704

# pass # xxx end-of-buffer

731

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

732

# or key == "<"):

705

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

706

# or key == u"<"):

733

707

# pass # xxx beginning-of-buffer

734

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

708

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

735

709

# pass # xxx move-end-of-line

736

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

710

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

737

711

# pass # xxx move-beginning-of-line

738

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

712

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

739

713

# pass # xxx left

740

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

714

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

741

715

# pass # xxx right

742

#elif key == "a":

716

#elif key == u"a":

743

717

# pass # scroll up log

744

#elif key == "z":

718

#elif key == u"z":

745

719

# pass # scroll down log

746

720

elif self.topwidget.selectable():

747

721

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