/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.5.2"

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

131

124

132

125

self._update_timer_callback_tag = None

133

126

self._update_timer_callback_lock = 0

127

self.last_checker_failed = False

134

128

135

129

# The widget shown normally

136

self._text_widget = urwid.Text("")

130

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

137

131

# The widget shown when we have focus

138

self._focus_text_widget = urwid.Text("")

132

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

139

133

super(MandosClientWidget, self).__init__(

140

134

update_hook=update_hook, delete_hook=delete_hook,

141

135

*args, **kwargs)

143

137

self.opened = False

144

138

145

139

last_checked_ok = isoformat_to_datetime(self.properties

146

["LastCheckedOK"])

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

147

150

148

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

151

if self.last_checker_failed:

149

152

self.using_timer(True)

150

153

151

154

if self.need_approval:

152

155

self.using_timer(True)

153

156

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

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)

176

177

178

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

178

179

super(self, MandosClientWidget).property_changed(property,

179

180

value)

180

if property == "ApprovalPending":

181

if property == u"ApprovalPending":

181

182

using_timer(bool(value))

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

183

188

184

def using_timer(self, flag):

189

185

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

190

186

activated or deactivated.

195

191

else:

196

192

self._update_timer_callback_lock -= 1

197

193

if old == 0 and self._update_timer_callback_lock:

198

# Will update the shown timer value every second

199

194

self._update_timer_callback_tag = (gobject.timeout_add

200

195

(1000,

201

196

self.update_timer))

205

200

206

201

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

207

202

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

208

209

self.update()

209

210

return

210

211

# Checker failed

212

if not self.last_checker_failed:

213

self.last_checker_failed = True

214

self.using_timer(True)

211

215

if os.WIFEXITED(condition):

212

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

213

' failed with exit code %s'

214

% (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,

215

219

os.WEXITSTATUS(condition)))

216

220

elif os.WIFSIGNALED(condition):

217

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

218

' was killed by signal %s'

219

% (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,

220

224

os.WTERMSIG(condition)))

221

225

elif os.WCOREDUMP(condition):

222

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

223

' dumped core'

224

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

226

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

227

u' dumped core'

228

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

225

229

else:

226

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

227

' mysteriously')

230

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

231

u' mysteriously')

228

232

self.update()

229

233

230

234

def checker_started(self, 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)))

235

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

236

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

235

237

pass

236

238

237

239

def got_secret(self):

238

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

239

% self.properties["Name"])

240

self.last_checker_failed = False

241

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

242

% self.properties[u"Name"])

240

243

241

244

def need_approval(self, timeout, default):

242

245

if not default:

243

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

246

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

244

247

else:

245

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

248

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

246

249

self.logger(message

247

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

250

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

248

251

self.using_timer(True)

249

252

250

253

def rejected(self, reason):

251

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

252

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

254

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

255

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

253

256

254

257

def selectable(self):

255

258

"""Make this a "selectable" widget.

256

259

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

257

260

return True

258

261

259

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

262

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

260

263

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

261

264

whether we have focus or not.

262

265

This overrides the method from urwid.FlowWidget"""

263

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

266

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

264

267

265

268

def current_widget(self, focus=False):

266

269

if focus or self.opened:

270

273

def update(self):

271

274

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

272

275

# How to add standout mode to a style

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

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

279

282

}

280

283

281

284

# Rebuild focus and non-focus widgets using current properties

282

285

283

286

# Base part of a client. Name!

284

base = ('%(name)s: '

285

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

286

if not self.properties["Enabled"]:

287

message = "DISABLED"

288

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

289

292

timeout = datetime.timedelta(milliseconds

290

293

= self.properties

291

["ApprovalDelay"])

294

[u"ApprovalDelay"])

292

295

last_approval_request = isoformat_to_datetime(

293

self.properties["LastApprovalRequest"])

296

self.properties[u"LastApprovalRequest"])

294

297

if last_approval_request is not None:

295

298

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

296

299

- last_approval_request)

297

300

else:

298

301

timer = datetime.timedelta()

299

if self.properties["ApprovedByDefault"]:

300

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

302

if self.properties[u"ApprovedByDefault"]:

303

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

301

304

else:

302

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

305

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

303

306

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

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'

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'

315

318

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

316

319

else:

317

message = "enabled"

320

message = u"enabled"

318

321

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

319

322

320

323

if not urwid.supports_unicode():

321

324

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

322

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

325

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

323

326

self._text_widget.set_text(textlist)

324

327

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

325

328

text[1])

334

337

self.update_hook()

335

338

336

339

def update_timer(self):

337

"""called by gobject. Will indefinitely loop until

338

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

340

"called by gobject"

339

341

self.update()

340

342

return True # Keep calling this

341

343

342

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

344

def delete(self):

343

345

if self._update_timer_callback_tag is not None:

344

346

gobject.source_remove(self._update_timer_callback_tag)

345

347

self._update_timer_callback_tag = None

346

for match in self.match_objects:

347

match.remove()

348

self.match_objects = ()

349

348

if self.delete_hook is not None:

350

349

self.delete_hook(self)

351

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

352

350

353

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

351

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

354

352

"""Render differently if we have focus.

355

353

This overrides the method from urwid.FlowWidget"""

356

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

354

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

357

355

focus=focus)

358

356

359

def keypress(self, maxcolrow, key):

357

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

360

358

"""Handle keys.

361

359

This overrides the method from urwid.FlowWidget"""

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

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

369

365

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

370

dbus_interface = client_interface,

371

ignore_reply=True)

372

elif key == "d":

366

dbus_interface = client_interface)

367

elif key == u"d":

373

368

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

374

dbus_interface = client_interface,

375

ignore_reply=True)

376

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

377

371

self.server_proxy_object.RemoveClient(self.proxy

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)

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)

389

379

# xxx

390

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

380

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

391

381

# self.proxy.pause()

392

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

382

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

393

383

# self.proxy.unpause()

394

# elif key == "RET":

384

# elif key == u"RET":

395

385

# self.open()

396

386

else:

397

387

return key

413

403

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

414

404

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

415

405

"""

416

def keypress(self, maxcolrow, key):

417

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

418

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

419

410

return

420

411

return ret

421

412

430

421

self.screen = urwid.curses_display.Screen()

431

422

432

423

self.screen.register_palette((

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

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

450

441

))

451

442

452

443

if urwid.supports_unicode():

453

self.divider = "─" # \u2500

454

#self.divider = "━" # \u2501

444

self.divider = u"─" # \u2500

445

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

455

446

else:

456

#self.divider = "-" # \u002d

457

self.divider = "_" # \u005f

447

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

448

self.divider = u"_" # \u005f

458

449

459

450

self.screen.start()

460

451

474

465

# This keeps track of whether self.uilist currently has

475

466

# self.logbox in it or not

476

467

self.log_visible = True

477

self.log_wrap = "any"

468

self.log_wrap = u"any"

478

469

479

470

self.rebuild()

480

self.log_message_raw(("bold",

481

"Mandos Monitor version " + version))

482

self.log_message_raw(("bold",

483

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

484

475

485

476

self.busname = domain + '.Mandos'

486

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)

487

520

488

521

def client_not_found(self, fingerprint, address):

489

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

490

" could not be found" % (address,

522

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

523

u" could not be found" % (address,

491

524

fingerprint)))

492

525

493

526

def rebuild(self):

504

537

self.divider)))

505

538

if self.log_visible:

506

539

self.uilist.append(self.logbox)

540

pass

507

541

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

508

542

509

543

def log_message(self, message):

510

544

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

511

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

545

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

512

546

513

547

def log_message_raw(self, markup):

514

548

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

517

551

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

518

552

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

519

553

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

520

coming_from="above")

554

coming_from=u"above")

521

555

self.refresh()

522

556

523

557

def toggle_log_display(self):

524

558

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

525

559

self.log_visible = not self.log_visible

526

560

self.rebuild()

527

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

561

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

528

562

# + unicode(self.log_visible))

529

563

530

564

def change_log_display(self):

531

565

"""Change type of log display.

532

566

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

533

if self.log_wrap == "clip":

534

self.log_wrap = "any"

567

if self.log_wrap == u"clip":

568

self.log_wrap = u"any"

535

569

else:

536

self.log_wrap = "clip"

570

self.log_wrap = u"clip"

537

571

for textwidget in self.log:

538

572

textwidget.set_wrap_mode(self.log_wrap)

539

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

573

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

540

574

541

575

def find_and_remove_client(self, path, name):

542

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

576

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

543

577

544

578

This is connected to the ClientRemoved signal from the

545

579

Mandos server object."""

547

581

client = self.clients_dict[path]

548

582

except KeyError:

549

583

# not found?

550

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

551

path)

552

584

return

553

client.delete()

585

self.remove_client(client, path)

554

586

555

587

def add_new_client(self, path):

556

588

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

571

603

if path is None:

572

604

path = client.proxy.object_path

573

605

self.clients_dict[path] = client

574

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

606

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

575

607

self.refresh()

576

608

577

609

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

593

625

594

626

def run(self):

595

627

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

639

628

self.refresh()

640

629

self._input_callback_tag = (gobject.io_add_watch

641

630

(sys.stdin.fileno(),

651

640

652

641

def process_input(self, source, condition):

653

642

keys = self.screen.get_input()

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

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

663

652

}

664

653

for key in keys:

665

654

try:

667

656

except KeyError: # :-)

668

657

pass

669

658

670

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

659

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

671

660

self.stop()

672

661

break

673

elif key == "window resize":

662

elif key == u"window resize":

674

663

self.size = self.screen.get_cols_rows()

675

664

self.refresh()

676

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

665

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

677

666

self.refresh()

678

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

667

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

679

668

self.toggle_log_display()

680

669

self.refresh()

681

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

670

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

682

671

self.change_log_display()

683

672

self.refresh()

684

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

673

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

685

674

if not self.log_visible:

686

675

self.log_visible = True

687

676

self.rebuild()

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

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

706

695

self.refresh()

707

elif key == "tab":

696

elif key == u"tab":

708

697

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

709

698

self.topwidget.set_focus(0)

710

699

else:

711

700

self.topwidget.set_focus(self.logbox)

712

701

self.refresh()

713

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

714

# or key == ">"):

702

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

703

# or key == u">"):

715

704

# pass # xxx end-of-buffer

716

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

717

# or key == "<"):

705

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

706

# or key == u"<"):

718

707

# pass # xxx beginning-of-buffer

719

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

708

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

720

709

# pass # xxx move-end-of-line

721

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

710

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

722

711

# pass # xxx move-beginning-of-line

723

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

712

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

724

713

# pass # xxx left

725

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

714

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

726

715

# pass # xxx right

727

#elif key == "a":

716

#elif key == u"a":

728

717

# pass # scroll up log

729

#elif key == "z":

718

#elif key == u"z":

730

719

# pass # scroll down log

731

720

elif self.topwidget.selectable():

732

721

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