/mandos/trunk : revision 445

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

54

version = "1.0.15"

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

176

# .format(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)

177

178

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

179

super(self, MandosClientWidget).property_changed(property,

180

value)

181

if property == "ApprovalPending":

181

if property == u"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

183

189

184

def using_timer(self, flag):

190

185

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

191

186

activated or deactivated.

196

191

else:

197

192

self._update_timer_callback_lock -= 1

198

193

if old == 0 and self._update_timer_callback_lock:

199

# Will update the shown timer value every second

200

194

self._update_timer_callback_tag = (gobject.timeout_add

201

195

(1000,

202

196

self.update_timer))

206

200

207

201

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

208

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

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)

212

215

if os.WIFEXITED(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)))

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

217

220

elif os.WIFSIGNALED(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)))

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

222

225

elif os.WCOREDUMP(condition):

223

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

224

' dumped core'

225

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

226

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

227

u' dumped core'

228

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

226

229

else:

227

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

228

' mysteriously'

229

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

230

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

231

u' mysteriously')

230

232

self.update()

231

233

232

234

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

235

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

236

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

238

237

pass

239

238

240

239

def got_secret(self):

241

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

242

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

240

self.last_checker_failed = False

241

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

242

% self.properties[u"Name"])

243

244

def need_approval(self, timeout, default):

245

if not default:

246

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

246

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

247

else:

248

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

249

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

250

timeout/1000))

248

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

249

self.logger(message

250

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

251

self.using_timer(True)

252

253

def rejected(self, reason):

254

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

255

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

254

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

255

% (self.properties[u"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, maxcolrow, focus=False):

262

def rows(self, (maxcol,), 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(maxcolrow, focus=focus)

266

return self.current_widget(focus).rows((maxcol,), 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 = { "normal": "standout",

277

"bold": "bold-standout",

278

"underline-blink":

279

"underline-blink-standout",

280

"bold-underline-blink":

281

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

282

}

283

284

# Rebuild focus and non-focus widgets using current properties

285

286

# Base part of a client. Name!

287

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

288

if not self.properties["Enabled"]:

289

message = "DISABLED"

290

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

291

292

timeout = datetime.timedelta(milliseconds

292

293

= self.properties

293

["ApprovalDelay"])

294

[u"ApprovalDelay"])

294

295

last_approval_request = isoformat_to_datetime(

295

self.properties["LastApprovalRequest"])

296

self.properties[u"LastApprovalRequest"])

296

297

if last_approval_request is not None:

297

298

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

298

299

- last_approval_request)

299

300

else:

300

301

timer = datetime.timedelta()

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

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

318

319

else:

319

message = "enabled"

320

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

320

message = u"enabled"

321

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

321

322

323

if not urwid.supports_unicode():

323

324

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

324

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

325

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

325

326

self._text_widget.set_text(textlist)

326

327

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

327

328

text[1])

336

337

self.update_hook()

337

338

339

def update_timer(self):

339

"""called by gobject. Will indefinitely loop until

340

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

340

"called by gobject"

341

self.update()

342

return True # Keep calling this

343

344

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

344

def delete(self):

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

351

348

if self.delete_hook is not None:

352

349

self.delete_hook(self)

353

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

354

350

355

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

351

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

356

352

"""Render differently if we have focus.

357

353

This overrides the method from urwid.FlowWidget"""

358

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

354

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

359

355

focus=focus)

360

356

361

def keypress(self, maxcolrow, key):

357

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

362

358

"""Handle keys.

363

359

This overrides the method from urwid.FlowWidget"""

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

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

371

365

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

372

dbus_interface = client_interface,

373

ignore_reply=True)

374

elif key == "d":

366

dbus_interface = client_interface)

367

elif key == u"d":

375

368

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

376

dbus_interface = client_interface,

377

ignore_reply=True)

378

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

379

371

self.server_proxy_object.RemoveClient(self.proxy

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)

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)

391

379

# xxx

392

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

380

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

393

381

# self.proxy.pause()

394

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

382

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

395

383

# self.proxy.unpause()

396

# elif key == "RET":

384

# elif key == u"RET":

397

385

# self.open()

398

386

else:

399

387

return key

415

403

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

416

404

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

417

405

"""

418

def keypress(self, maxcolrow, key):

419

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

420

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

421

410

return

422

411

return ret

423

412

432

421

self.screen = urwid.curses_display.Screen()

433

422

434

423

self.screen.register_palette((

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

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

452

441

))

453

442

454

443

if urwid.supports_unicode():

455

self.divider = "─" # \u2500

456

#self.divider = "━" # \u2501

444

self.divider = u"─" # \u2500

445

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

457

446

else:

458

#self.divider = "-" # \u002d

459

self.divider = "_" # \u005f

447

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

448

self.divider = u"_" # \u005f

460

449

461

450

self.screen.start()

462

451

476

465

# This keeps track of whether self.uilist currently has

477

466

# self.logbox in it or not

478

467

self.log_visible = True

479

self.log_wrap = "any"

468

self.log_wrap = u"any"

480

469

481

470

self.rebuild()

482

self.log_message_raw(("bold",

483

"Mandos Monitor version " + version))

484

self.log_message_raw(("bold",

485

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

486

475

487

476

self.busname = domain + '.Mandos'

488

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)

489

520

490

521

def client_not_found(self, fingerprint, address):

491

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

492

" {1} could not be found"

493

.format(address, fingerprint))

522

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

523

u" could not be found" % (address,

524

fingerprint)))

494

525

495

526

def rebuild(self):

496

527

"""This rebuilds the User Interface.

506

537

self.divider)))

507

538

if self.log_visible:

508

539

self.uilist.append(self.logbox)

540

pass

509

541

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

510

542

511

543

def log_message(self, message):

512

544

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

513

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

545

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

514

546

515

547

def log_message_raw(self, markup):

516

548

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

519

551

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

520

552

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

521

553

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

522

coming_from="above")

554

coming_from=u"above")

523

555

self.refresh()

524

556

525

557

def toggle_log_display(self):

526

558

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

527

559

self.log_visible = not self.log_visible

528

560

self.rebuild()

529

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

561

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

530

562

# + unicode(self.log_visible))

531

563

532

564

def change_log_display(self):

533

565

"""Change type of log display.

534

566

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

535

if self.log_wrap == "clip":

536

self.log_wrap = "any"

567

if self.log_wrap == u"clip":

568

self.log_wrap = u"any"

537

569

else:

538

self.log_wrap = "clip"

570

self.log_wrap = u"clip"

539

571

for textwidget in self.log:

540

572

textwidget.set_wrap_mode(self.log_wrap)

541

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

573

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

542

574

543

575

def find_and_remove_client(self, path, name):

544

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

576

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

545

577

546

578

This is connected to the ClientRemoved signal from the

547

579

Mandos server object."""

549

581

client = self.clients_dict[path]

550

582

except KeyError:

551

583

# not found?

552

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

553

.format(name, path))

554

584

return

555

client.delete()

585

self.remove_client(client, path)

556

586

557

587

def add_new_client(self, path):

558

588

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

573

603

if path is None:

574

604

path = client.proxy.object_path

575

605

self.clients_dict[path] = client

576

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

606

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

577

607

self.refresh()

578

608

579

609

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

595

625

596

626

def run(self):

597

627

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

641

628

self.refresh()

642

629

self._input_callback_tag = (gobject.io_add_watch

643

630

(sys.stdin.fileno(),

653

640

654

641

def process_input(self, source, condition):

655

642

keys = self.screen.get_input()

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

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

665

652

}

666

653

for key in keys:

667

654

try:

669

656

except KeyError: # :-)

670

657

pass

671

658

672

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

659

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

673

660

self.stop()

674

661

break

675

elif key == "window resize":

662

elif key == u"window resize":

676

663

self.size = self.screen.get_cols_rows()

677

664

self.refresh()

678

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

665

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

679

666

self.refresh()

680

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

667

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

681

668

self.toggle_log_display()

682

669

self.refresh()

683

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

670

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

684

671

self.change_log_display()

685

672

self.refresh()

686

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

673

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

687

674

if not self.log_visible:

688

675

self.log_visible = True

689

676

self.rebuild()

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

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

708

695

self.refresh()

709

elif key == "tab":

696

elif key == u"tab":

710

697

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

711

698

self.topwidget.set_focus(0)

712

699

else:

713

700

self.topwidget.set_focus(self.logbox)

714

701

self.refresh()

715

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

716

# or key == ">"):

702

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

703

# or key == u">"):

717

704

# pass # xxx end-of-buffer

718

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

719

# or key == "<"):

705

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

706

# or key == u"<"):

720

707

# pass # xxx beginning-of-buffer

721

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

708

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

722

709

# pass # xxx move-end-of-line

723

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

710

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

724

711

# pass # xxx move-beginning-of-line

725

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

712

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

726

713

# pass # xxx left

727

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

714

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

728

715

# pass # xxx right

729

#elif key == "a":

716

#elif key == u"a":

730

717

# pass # scroll up log

731

#elif key == "z":

718

#elif key == u"z":

732

719

# pass # scroll down log

733

720

elif self.topwidget.selectable():

734

721

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