/mandos/trunk : revision 567

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

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 {0}'

176

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

177

178

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

179

super(self, MandosClientWidget).property_changed(property,

180

value)

181

if property == u"ApprovalPending":

181

if property == "ApprovalPending":

182

using_timer(bool(value))

183

if property == "LastCheckerStatus":

184

using_timer(value != 0)

185

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

186

# ' successful'.format(self.properties["Name"],

187

# command))

188

184

189

def using_timer(self, flag):

185

190

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

186

191

activated or deactivated.

191

196

else:

192

197

self._update_timer_callback_lock -= 1

193

198

if old == 0 and self._update_timer_callback_lock:

199

# Will update the shown timer value every second

194

200

self._update_timer_callback_tag = (gobject.timeout_add

195

201

(1000,

196

202

self.update_timer))

200

206

201

207

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

202

208

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

self.update()

210

return

211

# Checker failed

212

if not self.last_checker_failed:

213

self.last_checker_failed = True

214

self.using_timer(True)

215

212

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,

219

os.WEXITSTATUS(condition)))

213

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

214

' failed with exit code {2}'

215

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

216

os.WEXITSTATUS(condition)))

220

217

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,

224

os.WTERMSIG(condition)))

218

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

219

' killed by signal {2}'

220

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

221

os.WTERMSIG(condition)))

225

222

elif os.WCOREDUMP(condition):

226

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

227

u' dumped core'

228

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

223

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

224

' dumped core'

225

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

229

226

else:

230

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

231

u' mysteriously')

227

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

228

' mysteriously'

229

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

232

230

self.update()

233

231

234

232

def checker_started(self, command):

235

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

236

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

233

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

234

to log in the future. """

235

#self.logger('Client {0} started checker "{1}"'

236

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

237

# unicode(command)))

237

238

pass

238

239

240

def got_secret(self):

240

self.last_checker_failed = False

241

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

242

% self.properties[u"Name"])

241

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

242

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

243

244

def need_approval(self, timeout, default):

245

if not default:

246

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

246

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

247

else:

248

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

249

self.logger(message

250

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

248

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

249

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

250

timeout/1000))

251

self.using_timer(True)

252

253

def rejected(self, reason):

254

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

255

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

254

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

255

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

256

257

def selectable(self):

258

"""Make this a "selectable" widget.

259

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

260

return True

261

262

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

262

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

263

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

264

whether we have focus or not.

265

This overrides the method from urwid.FlowWidget"""

266

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

266

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

267

268

def current_widget(self, focus=False):

269

if focus or self.opened:

273

def update(self):

274

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

275

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

276

with_standout = { "normal": "standout",

277

"bold": "bold-standout",

278

"underline-blink":

279

"underline-blink-standout",

280

"bold-underline-blink":

281

"bold-underline-blink-standout",

282

}

283

284

# Rebuild focus and non-focus widgets using current properties

285

286

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

287

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

288

if not self.properties["Enabled"]:

289

message = "DISABLED"

290

elif self.properties["ApprovalPending"]:

292

291

timeout = datetime.timedelta(milliseconds

293

292

= self.properties

294

[u"ApprovalDelay"])

293

["ApprovalDelay"])

295

294

last_approval_request = isoformat_to_datetime(

296

self.properties[u"LastApprovalRequest"])

295

self.properties["LastApprovalRequest"])

297

296

if last_approval_request is not None:

298

297

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

299

298

- last_approval_request)

300

299

else:

301

300

timer = datetime.timedelta()

302

if self.properties[u"ApprovedByDefault"]:

303

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

304

else:

305

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

306

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'

318

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

301

if self.properties["ApprovedByDefault"]:

302

message = "Approval in {0}. (d)eny?"

303

else:

304

message = "Denial in {0}. (a)pprove?"

305

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

306

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

307

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

308

expires = self.properties["Expires"]

309

if expires == "":

310

timer = datetime.timedelta(0)

311

else:

312

expires = datetime.datetime.strptime(expires,

313

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

314

timer = expires - datetime.datetime.utcnow()

315

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

316

' gets disabled: {0}'

317

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

319

318

else:

320

message = u"enabled"

321

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

319

message = "enabled"

320

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

322

321

323

322

if not urwid.supports_unicode():

324

323

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

325

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

324

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

326

325

self._text_widget.set_text(textlist)

327

326

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

328

327

text[1])

337

336

self.update_hook()

338

337

339

338

def update_timer(self):

340

"called by gobject"

339

"""called by gobject. Will indefinitely loop until

340

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

341

self.update()

342

return True # Keep calling this

343

344

def delete(self):

344

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

345

if self._update_timer_callback_tag is not None:

346

gobject.source_remove(self._update_timer_callback_tag)

347

self._update_timer_callback_tag = None

348

for match in self.match_objects:

349

match.remove()

350

self.match_objects = ()

348

351

if self.delete_hook is not None:

349

352

self.delete_hook(self)

353

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

350

354

351

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

355

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

352

356

"""Render differently if we have focus.

353

357

This overrides the method from urwid.FlowWidget"""

354

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

358

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

355

359

focus=focus)

356

360

357

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

361

def keypress(self, maxcolrow, key):

358

362

"""Handle keys.

359

363

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

364

if key == "+":

365

self.proxy.Enable(dbus_interface = client_interface,

366

ignore_reply=True)

367

elif key == "-":

368

self.proxy.Disable(dbus_interface = client_interface,

369

ignore_reply=True)

370

elif key == "a":

365

371

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

366

dbus_interface = client_interface)

367

elif key == u"d":

372

dbus_interface = client_interface,

373

ignore_reply=True)

374

elif key == "d":

368

375

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

376

dbus_interface = client_interface,

377

ignore_reply=True)

378

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

371

379

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)

380

.object_path,

381

ignore_reply=True)

382

elif key == "s":

383

self.proxy.StartChecker(dbus_interface = client_interface,

384

ignore_reply=True)

385

elif key == "S":

386

self.proxy.StopChecker(dbus_interface = client_interface,

387

ignore_reply=True)

388

elif key == "C":

389

self.proxy.CheckedOK(dbus_interface = client_interface,

390

ignore_reply=True)

379

391

# xxx

380

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

392

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

381

393

# self.proxy.pause()

382

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

394

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

383

395

# self.proxy.unpause()

384

# elif key == u"RET":

396

# elif key == "RET":

385

397

# self.open()

386

398

else:

387

399

return key

403

415

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

404

416

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

405

417

"""

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

418

def keypress(self, maxcolrow, key):

419

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

420

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

410

421

return

411

422

return ret

412

423

421

432

self.screen = urwid.curses_display.Screen()

422

433

423

434

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

435

("normal",

436

"default", "default", None),

437

("bold",

438

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

439

("underline-blink",

440

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

441

("standout",

442

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

443

("bold-underline-blink",

444

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

445

("bold-standout",

446

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

447

("underline-blink-standout",

448

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

449

("bold-underline-blink-standout",

450

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

451

"standout")),

441

452

))

442

453

443

454

if urwid.supports_unicode():

444

self.divider = u"─" # \u2500

445

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

455

self.divider = "─" # \u2500

456

#self.divider = "━" # \u2501

446

457

else:

447

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

448

self.divider = u"_" # \u005f

458

#self.divider = "-" # \u002d

459

self.divider = "_" # \u005f

449

460

450

461

self.screen.start()

451

462

465

476

# This keeps track of whether self.uilist currently has

466

477

# self.logbox in it or not

467

478

self.log_visible = True

468

self.log_wrap = u"any"

479

self.log_wrap = "any"

469

480

470

481

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

482

self.log_message_raw(("bold",

483

"Mandos Monitor version " + version))

484

self.log_message_raw(("bold",

485

"q: Quit ?: Help"))

475

486

476

487

self.busname = domain + '.Mandos'

477

488

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

489

521

490

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,

524

fingerprint)))

491

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

492

" {1} could not be found"

493

.format(address, fingerprint))

525

494

526

495

def rebuild(self):

527

496

"""This rebuilds the User Interface.

537

506

self.divider)))

538

507

if self.log_visible:

539

508

self.uilist.append(self.logbox)

540

pass

541

509

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

542

510

543

511

def log_message(self, message):

544

512

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

545

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

513

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

546

514

547

515

def log_message_raw(self, markup):

548

516

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

551

519

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

552

520

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

553

521

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

554

coming_from=u"above")

522

coming_from="above")

555

523

self.refresh()

556

524

557

525

def toggle_log_display(self):

558

526

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

559

527

self.log_visible = not self.log_visible

560

528

self.rebuild()

561

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

529

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

562

530

# + unicode(self.log_visible))

563

531

564

532

def change_log_display(self):

565

533

"""Change type of log display.

566

534

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

567

if self.log_wrap == u"clip":

568

self.log_wrap = u"any"

535

if self.log_wrap == "clip":

536

self.log_wrap = "any"

569

537

else:

570

self.log_wrap = u"clip"

538

self.log_wrap = "clip"

571

539

for textwidget in self.log:

572

540

textwidget.set_wrap_mode(self.log_wrap)

573

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

541

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

574

542

575

543

def find_and_remove_client(self, path, name):

576

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

544

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

577

545

578

546

This is connected to the ClientRemoved signal from the

579

547

Mandos server object."""

581

549

client = self.clients_dict[path]

582

550

except KeyError:

583

551

# not found?

552

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

553

.format(name, path))

584

554

return

585

self.remove_client(client, path)

555

client.delete()

586

556

587

557

def add_new_client(self, path):

588

558

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

603

573

if path is None:

604

574

path = client.proxy.object_path

605

575

self.clients_dict[path] = client

606

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

576

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

607

577

self.refresh()

608

578

609

579

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

625

595

626

596

def run(self):

627

597

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

598

self.bus = dbus.SystemBus()

599

mandos_dbus_objc = self.bus.get_object(

600

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

601

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

602

dbus_interface

603

= server_interface)

604

try:

605

mandos_clients = (self.mandos_serv

606

.GetAllClientsWithProperties())

607

except dbus.exceptions.DBusException:

608

mandos_clients = dbus.Dictionary()

609

610

(self.mandos_serv

611

.connect_to_signal("ClientRemoved",

612

self.find_and_remove_client,

613

dbus_interface=server_interface,

614

byte_arrays=True))

615

(self.mandos_serv

616

.connect_to_signal("ClientAdded",

617

self.add_new_client,

618

dbus_interface=server_interface,

619

byte_arrays=True))

620

(self.mandos_serv

621

.connect_to_signal("ClientNotFound",

622

self.client_not_found,

623

dbus_interface=server_interface,

624

byte_arrays=True))

625

for path, client in mandos_clients.iteritems():

626

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

627

path)

628

self.add_client(MandosClientWidget(server_proxy_object

629

=self.mandos_serv,

630

proxy_object

631

=client_proxy_object,

632

properties=client,

633

update_hook

634

=self.refresh,

635

delete_hook

636

=self.remove_client,

637

logger

638

=self.log_message),

639

path=path)

640

628

641

self.refresh()

629

642

self._input_callback_tag = (gobject.io_add_watch

630

643

(sys.stdin.fileno(),

640

653

641

654

def process_input(self, source, condition):

642

655

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

656

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

657

"ctrl p": "up", # Emacs

658

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

659

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

660

" ": "page down", # less

661

"f": "page down", # less

662

"b": "page up", # less

663

"j": "down", # vi

664

"k": "up", # vi

652

665

}

653

666

for key in keys:

654

667

try:

656

669

except KeyError: # :-)

657

670

pass

658

671

659

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

672

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

660

673

self.stop()

661

674

break

662

elif key == u"window resize":

675

elif key == "window resize":

663

676

self.size = self.screen.get_cols_rows()

664

677

self.refresh()

665

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

678

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

666

679

self.refresh()

667

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

680

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

668

681

self.toggle_log_display()

669

682

self.refresh()

670

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

683

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

671

684

self.change_log_display()

672

685

self.refresh()

673

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

686

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

674

687

if not self.log_visible:

675

688

self.log_visible = True

676

689

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

690

self.log_message_raw(("bold",

691

" ".

692

join(("q: Quit",

693

"?: Help",

694

"l: Log window toggle",

695

"TAB: Switch window",

696

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

697

self.log_message_raw(("bold",

698

" "

699

.join(("Clients:",

700

"+: Enable",

701

"-: Disable",

702

"R: Remove",

703

"s: Start new checker",

704

"S: Stop checker",

705

"C: Checker OK",

706

"a: Approve",

707

"d: Deny"))))

695

708

self.refresh()

696

elif key == u"tab":

709

elif key == "tab":

697

710

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

698

711

self.topwidget.set_focus(0)

699

712

else:

700

713

self.topwidget.set_focus(self.logbox)

701

714

self.refresh()

702

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

703

# or key == u">"):

715

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

716

# or key == ">"):

704

717

# pass # xxx end-of-buffer

705

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

706

# or key == u"<"):

718

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

719

# or key == "<"):

707

720

# pass # xxx beginning-of-buffer

708

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

721

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

709

722

# pass # xxx move-end-of-line

710

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

723

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

711

724

# pass # xxx move-beginning-of-line

712

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

725

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

713

726

# pass # xxx left

714

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

727

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

715

728

# pass # xxx right

716

#elif key == u"a":

729

#elif key == "a":

717

730

# pass # scroll up log

718

#elif key == u"z":

731

#elif key == "z":

719

732

# pass # scroll down log

720

733

elif self.topwidget.selectable():

721

734

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