/mandos/trunk : revision 560

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@fukt.bsnet.se>.

22

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

23

#

24

25

from __future__ import division, absolute_import, with_statement

25

from __future__ import (division, absolute_import, print_function,

26

unicode_literals)

26

27

28

import sys

28

29

import os

42

43

44

import locale

44

45

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

46

locale.setlocale(locale.LC_ALL, '')

46

47

48

import logging

48

49

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

49

50

51

# Some useful constants

51

domain = 'se.bsnet.fukt'

52

domain = 'se.recompile'

52

53

server_interface = domain + '.Mandos'

53

54

client_interface = domain + '.Mandos.Client'

54

version = "1.2.3"

55

version = "1.5.3"

55

56

57

# Always run in monochrome mode

57

58

urwid.curses_display.curses.has_colors = lambda : False

65

66

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

66

67

if not iso:

67

68

return None

68

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

69

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

70

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

69

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

70

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

71

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

71

72

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

72

73

return datetime.datetime(int(year),

73

74

int(month),

86

87

self.proxy = proxy_object # Mandos Client proxy object

87

88

89

self.properties = dict()

89

self.proxy.connect_to_signal(u"PropertyChanged",

90

self.property_changed,

91

client_interface,

92

byte_arrays=True)

90

self.property_changed_match = (

91

self.proxy.connect_to_signal("PropertyChanged",

92

self.property_changed,

93

client_interface,

94

byte_arrays=True))

93

95

94

96

self.properties.update(

95

97

self.proxy.GetAll(client_interface,

96

98

dbus_interface = dbus.PROPERTIES_IFACE))

97

99

98

#XXX This break good super behaviour!

100

#XXX This breaks good super behaviour

99

101

# super(MandosClientPropertyCache, self).__init__(

100

102

# *args, **kwargs)

101

103

105

107

"""

106

108

# Update properties dict with new value

107

109

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)

108

115

109

116

110

117

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

124

131

125

132

self._update_timer_callback_tag = None

126

133

self._update_timer_callback_lock = 0

127

self.last_checker_failed = False

128

134

129

135

# The widget shown normally

130

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

136

self._text_widget = urwid.Text("")

131

137

# The widget shown when we have focus

132

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

138

self._focus_text_widget = urwid.Text("")

133

139

super(MandosClientWidget, self).__init__(

134

140

update_hook=update_hook, delete_hook=delete_hook,

135

141

*args, **kwargs)

137

143

self.opened = False

138

144

139

145

last_checked_ok = isoformat_to_datetime(self.properties

140

[u"LastCheckedOK"])

141

if last_checked_ok is None:

142

self.last_checker_failed = True

143

else:

144

self.last_checker_failed = ((datetime.datetime.utcnow()

145

- last_checked_ok)

146

> datetime.timedelta

147

(milliseconds=

148

self.properties

149

[u"Interval"]))

146

["LastCheckedOK"])

150

147

151

if self.last_checker_failed:

148

if self.properties ["LastCheckerStatus"] != 0:

152

149

self.using_timer(True)

153

150

154

151

if self.need_approval:

155

152

self.using_timer(True)

156

153

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)

154

self.match_objects = (

155

self.proxy.connect_to_signal("CheckerCompleted",

156

self.checker_completed,

157

client_interface,

158

byte_arrays=True),

159

self.proxy.connect_to_signal("CheckerStarted",

160

self.checker_started,

161

client_interface,

162

byte_arrays=True),

163

self.proxy.connect_to_signal("GotSecret",

164

self.got_secret,

165

client_interface,

166

byte_arrays=True),

167

self.proxy.connect_to_signal("NeedApproval",

168

self.need_approval,

169

client_interface,

170

byte_arrays=True),

171

self.proxy.connect_to_signal("Rejected",

172

self.rejected,

173

client_interface,

174

byte_arrays=True))

175

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

177

176

178

177

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

179

178

super(self, MandosClientWidget).property_changed(property,

180

179

value)

181

if property == u"ApprovalPending":

180

if property == "ApprovalPending":

182

181

using_timer(bool(value))

183

182

if property == "LastCheckerStatus":

183

using_timer(value != 0)

184

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

185

# ' was successful'

186

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

187

184

188

def using_timer(self, flag):

185

189

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

186

190

activated or deactivated.

191

195

else:

192

196

self._update_timer_callback_lock -= 1

193

197

if old == 0 and self._update_timer_callback_lock:

198

# Will update the shown timer value every second

194

199

self._update_timer_callback_tag = (gobject.timeout_add

195

200

(1000,

196

201

self.update_timer))

200

205

201

206

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

202

207

if exitstatus == 0:

203

if self.last_checker_failed:

204

self.last_checker_failed = False

205

self.using_timer(False)

206

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

207

# u' was successful'

208

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

209

208

self.update()

210

209

return

211

210

# Checker failed

212

if not self.last_checker_failed:

213

self.last_checker_failed = True

214

self.using_timer(True)

215

211

if os.WIFEXITED(condition):

216

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

217

u' failed with exit code %s'

218

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

212

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

213

' failed with exit code %s'

214

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

219

215

os.WEXITSTATUS(condition)))

220

216

elif os.WIFSIGNALED(condition):

221

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

222

u' was killed by signal %s'

223

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

217

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

218

' was killed by signal %s'

219

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

224

220

os.WTERMSIG(condition)))

225

221

elif os.WCOREDUMP(condition):

226

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

227

u' dumped core'

228

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

222

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

223

' dumped core'

224

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

229

225

else:

230

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

231

u' mysteriously')

226

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

227

' mysteriously')

232

228

self.update()

233

229

234

230

def checker_started(self, command):

235

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

236

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

231

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

232

to log in the future. """

233

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

234

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

237

235

pass

238

236

239

237

def got_secret(self):

240

self.last_checker_failed = False

241

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

242

% self.properties[u"Name"])

238

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

239

% self.properties["Name"])

243

240

244

241

def need_approval(self, timeout, default):

245

242

if not default:

246

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

243

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

247

244

else:

248

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

245

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

249

246

self.logger(message

250

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

247

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

251

248

self.using_timer(True)

252

249

253

250

def rejected(self, reason):

254

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

255

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

251

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

252

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

256

253

257

254

def selectable(self):

258

255

"""Make this a "selectable" widget.

259

256

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

260

257

return True

261

258

262

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

259

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

263

260

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

264

261

whether we have focus or not.

265

262

This overrides the method from urwid.FlowWidget"""

266

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

263

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

267

264

268

265

def current_widget(self, focus=False):

269

266

if focus or self.opened:

273

270

def update(self):

274

271

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

275

272

# How to add standout mode to a style

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

273

with_standout = { "normal": "standout",

274

"bold": "bold-standout",

275

"underline-blink":

276

"underline-blink-standout",

277

"bold-underline-blink":

278

"bold-underline-blink-standout",

282

279

}

283

280

284

281

# Rebuild focus and non-focus widgets using current properties

285

282

286

283

# Base part of a client. Name!

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

284

base = ('%(name)s: '

285

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

286

if not self.properties["Enabled"]:

287

message = "DISABLED"

288

elif self.properties["ApprovalPending"]:

292

289

timeout = datetime.timedelta(milliseconds

293

290

= self.properties

294

[u"ApprovalDelay"])

291

["ApprovalDelay"])

295

292

last_approval_request = isoformat_to_datetime(

296

self.properties[u"LastApprovalRequest"])

293

self.properties["LastApprovalRequest"])

297

294

if last_approval_request is not None:

298

295

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

299

296

- last_approval_request)

300

297

else:

301

298

timer = datetime.timedelta()

302

if self.properties[u"ApprovedByDefault"]:

303

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

299

if self.properties["ApprovedByDefault"]:

300

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

304

301

else:

305

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

302

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

306

303

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

307

elif self.last_checker_failed:

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'

304

elif self.properties["LastCheckerStatus"] != 0:

305

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

306

expires = self.properties["Expires"]

307

if expires == "":

308

timer = datetime.timedelta(0)

309

else:

310

expires = datetime.datetime.strptime(expires,

311

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

312

timer = expires - datetime.datetime.utcnow()

313

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

314

' gets disabled: %s'

318

315

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

319

316

else:

320

message = u"enabled"

317

message = "enabled"

321

318

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

322

319

323

320

if not urwid.supports_unicode():

324

321

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

325

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

322

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

326

323

self._text_widget.set_text(textlist)

327

324

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

328

325

text[1])

337

334

self.update_hook()

338

335

339

336

def update_timer(self):

340

"called by gobject"

337

"""called by gobject. Will indefinitely loop until

338

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

341

339

self.update()

342

340

return True # Keep calling this

343

341

344

def delete(self):

342

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

345

343

if self._update_timer_callback_tag is not None:

346

344

gobject.source_remove(self._update_timer_callback_tag)

347

345

self._update_timer_callback_tag = None

346

for match in self.match_objects:

347

match.remove()

348

self.match_objects = ()

348

349

if self.delete_hook is not None:

349

350

self.delete_hook(self)

351

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

350

352

351

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

353

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

352

354

"""Render differently if we have focus.

353

355

This overrides the method from urwid.FlowWidget"""

354

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

356

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

355

357

focus=focus)

356

358

357

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

359

def keypress(self, maxcolrow, key):

358

360

"""Handle keys.

359

361

This overrides the method from urwid.FlowWidget"""

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

362

if key == "+":

363

self.proxy.Enable(dbus_interface = client_interface,

364

ignore_reply=True)

365

elif key == "-":

366

self.proxy.Disable(dbus_interface = client_interface,

367

ignore_reply=True)

368

elif key == "a":

365

369

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

366

dbus_interface = client_interface)

367

elif key == u"d":

370

dbus_interface = client_interface,

371

ignore_reply=True)

372

elif key == "d":

368

373

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

369

dbus_interface = client_interface)

370

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

374

dbus_interface = client_interface,

375

ignore_reply=True)

376

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

371

377

self.server_proxy_object.RemoveClient(self.proxy

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)

378

.object_path,

379

ignore_reply=True)

380

elif key == "s":

381

self.proxy.StartChecker(dbus_interface = client_interface,

382

ignore_reply=True)

383

elif key == "S":

384

self.proxy.StopChecker(dbus_interface = client_interface,

385

ignore_reply=True)

386

elif key == "C":

387

self.proxy.CheckedOK(dbus_interface = client_interface,

388

ignore_reply=True)

379

389

# xxx

380

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

390

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

381

391

# self.proxy.pause()

382

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

392

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

383

393

# self.proxy.unpause()

384

# elif key == u"RET":

394

# elif key == "RET":

385

395

# self.open()

386

396

else:

387

397

return key

403

413

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

404

414

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

405

415

"""

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

416

def keypress(self, maxcolrow, key):

417

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

418

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

410

419

return

411

420

return ret

412

421

430

self.screen = urwid.curses_display.Screen()

422

431

423

432

self.screen.register_palette((

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

433

("normal",

434

"default", "default", None),

435

("bold",

436

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

437

("underline-blink",

438

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

439

("standout",

440

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

441

("bold-underline-blink",

442

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

443

("bold-standout",

444

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

445

("underline-blink-standout",

446

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

447

("bold-underline-blink-standout",

448

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

449

"standout")),

441

450

))

442

451

443

452

if urwid.supports_unicode():

444

self.divider = u"─" # \u2500

445

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

453

self.divider = "─" # \u2500

454

#self.divider = "━" # \u2501

446

455

else:

447

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

448

self.divider = u"_" # \u005f

456

#self.divider = "-" # \u002d

457

self.divider = "_" # \u005f

449

458

450

459

self.screen.start()

451

460

465

474

# This keeps track of whether self.uilist currently has

466

475

# self.logbox in it or not

467

476

self.log_visible = True

468

self.log_wrap = u"any"

477

self.log_wrap = "any"

469

478

470

479

self.rebuild()

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

480

self.log_message_raw(("bold",

481

"Mandos Monitor version " + version))

482

self.log_message_raw(("bold",

483

"q: Quit ?: Help"))

475

484

476

485

self.busname = domain + '.Mandos'

477

486

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)

520

487

521

488

def client_not_found(self, fingerprint, address):

522

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

523

u" could not be found" % (address,

489

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

490

" could not be found" % (address,

524

491

fingerprint)))

525

492

526

493

def rebuild(self):

537

504

self.divider)))

538

505

if self.log_visible:

539

506

self.uilist.append(self.logbox)

540

pass

541

507

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

542

508

543

509

def log_message(self, message):

544

510

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

545

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

511

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

546

512

547

513

def log_message_raw(self, markup):

548

514

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

551

517

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

552

518

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

553

519

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

554

coming_from=u"above")

520

coming_from="above")

555

521

self.refresh()

556

522

557

523

def toggle_log_display(self):

558

524

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

559

525

self.log_visible = not self.log_visible

560

526

self.rebuild()

561

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

527

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

562

528

# + unicode(self.log_visible))

563

529

564

530

def change_log_display(self):

565

531

"""Change type of log display.

566

532

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

567

if self.log_wrap == u"clip":

568

self.log_wrap = u"any"

533

if self.log_wrap == "clip":

534

self.log_wrap = "any"

569

535

else:

570

self.log_wrap = u"clip"

536

self.log_wrap = "clip"

571

537

for textwidget in self.log:

572

538

textwidget.set_wrap_mode(self.log_wrap)

573

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

539

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

574

540

575

541

def find_and_remove_client(self, path, name):

576

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

542

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

577

543

578

544

This is connected to the ClientRemoved signal from the

579

545

Mandos server object."""

581

547

client = self.clients_dict[path]

582

548

except KeyError:

583

549

# not found?

550

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

551

path)

584

552

return

585

self.remove_client(client, path)

553

client.delete()

586

554

587

555

def add_new_client(self, path):

588

556

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

603

571

if path is None:

604

572

path = client.proxy.object_path

605

573

self.clients_dict[path] = client

606

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

574

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

607

575

self.refresh()

608

576

609

577

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

625

593

626

594

def run(self):

627

595

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

596

self.bus = dbus.SystemBus()

597

mandos_dbus_objc = self.bus.get_object(

598

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

599

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

600

dbus_interface

601

= server_interface)

602

try:

603

mandos_clients = (self.mandos_serv

604

.GetAllClientsWithProperties())

605

except dbus.exceptions.DBusException:

606

mandos_clients = dbus.Dictionary()

607

608

(self.mandos_serv

609

.connect_to_signal("ClientRemoved",

610

self.find_and_remove_client,

611

dbus_interface=server_interface,

612

byte_arrays=True))

613

(self.mandos_serv

614

.connect_to_signal("ClientAdded",

615

self.add_new_client,

616

dbus_interface=server_interface,

617

byte_arrays=True))

618

(self.mandos_serv

619

.connect_to_signal("ClientNotFound",

620

self.client_not_found,

621

dbus_interface=server_interface,

622

byte_arrays=True))

623

for path, client in mandos_clients.iteritems():

624

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

625

path)

626

self.add_client(MandosClientWidget(server_proxy_object

627

=self.mandos_serv,

628

proxy_object

629

=client_proxy_object,

630

properties=client,

631

update_hook

632

=self.refresh,

633

delete_hook

634

=self.remove_client,

635

logger

636

=self.log_message),

637

path=path)

638

628

639

self.refresh()

629

640

self._input_callback_tag = (gobject.io_add_watch

630

641

(sys.stdin.fileno(),

640

651

641

652

def process_input(self, source, condition):

642

653

keys = self.screen.get_input()

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

654

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

655

"ctrl p": "up", # Emacs

656

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

657

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

658

" ": "page down", # less

659

"f": "page down", # less

660

"b": "page up", # less

661

"j": "down", # vi

662

"k": "up", # vi

652

663

}

653

664

for key in keys:

654

665

try:

656

667

except KeyError: # :-)

657

668

pass

658

669

659

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

670

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

660

671

self.stop()

661

672

break

662

elif key == u"window resize":

673

elif key == "window resize":

663

674

self.size = self.screen.get_cols_rows()

664

675

self.refresh()

665

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

676

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

666

677

self.refresh()

667

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

678

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

668

679

self.toggle_log_display()

669

680

self.refresh()

670

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

681

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

671

682

self.change_log_display()

672

683

self.refresh()

673

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

684

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

674

685

if not self.log_visible:

675

686

self.log_visible = True

676

687

self.rebuild()

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

688

self.log_message_raw(("bold",

689

" ".

690

join(("q: Quit",

691

"?: Help",

692

"l: Log window toggle",

693

"TAB: Switch window",

694

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

695

self.log_message_raw(("bold",

696

" "

697

.join(("Clients:",

698

"+: Enable",

699

"-: Disable",

700

"R: Remove",

701

"s: Start new checker",

702

"S: Stop checker",

703

"C: Checker OK",

704

"a: Approve",

705

"d: Deny"))))

695

706

self.refresh()

696

elif key == u"tab":

707

elif key == "tab":

697

708

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

698

709

self.topwidget.set_focus(0)

699

710

else:

700

711

self.topwidget.set_focus(self.logbox)

701

712

self.refresh()

702

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

703

# or key == u">"):

713

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

714

# or key == ">"):

704

715

# pass # xxx end-of-buffer

705

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

706

# or key == u"<"):

716

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

717

# or key == "<"):

707

718

# pass # xxx beginning-of-buffer

708

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

719

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

709

720

# pass # xxx move-end-of-line

710

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

721

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

711

722

# pass # xxx move-beginning-of-line

712

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

723

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

713

724

# pass # xxx left

714

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

725

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

715

726

# pass # xxx right

716

#elif key == u"a":

727

#elif key == "a":

717

728

# pass # scroll up log

718

#elif key == u"z":

729

#elif key == "z":

719

730

# pass # scroll down log

720

731

elif self.topwidget.selectable():

721

732

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