/mandos/trunk : revision 579

1

#!/usr/bin/python

2

# -*- mode: python; coding: utf-8 -*-

3

4

from __future__ import division, absolute_import, with_statement

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

5

#

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

11

# the Free Software Foundation, either version 3 of the License, or

12

# (at your option) any later version.

13

#

14

# This program is distributed in the hope that it will be useful,

15

# but WITHOUT ANY WARRANTY; without even the implied warranty of

16

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

17

# GNU General Public License for more details.

18

#

19

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

20

# along with this program. If not, see

21

# <http://www.gnu.org/licenses/>.

22

#

23

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

24

#

25

26

from __future__ import (division, absolute_import, print_function,

27

unicode_literals)

28

29

from future_builtins import *

5

30

6

31

import sys

7

32

import os

21

46

22

47

import locale

23

48

24

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

49

locale.setlocale(locale.LC_ALL, '')

25

50

26

51

import logging

27

52

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

28

53

29

54

# Some useful constants

30

domain = 'se.bsnet.fukt'

55

domain = 'se.recompile'

31

56

server_interface = domain + '.Mandos'

32

57

client_interface = domain + '.Mandos.Client'

33

version = "1.0.15"

58

version = "1.5.3"

34

59

35

60

# Always run in monochrome mode

36

61

urwid.curses_display.curses.has_colors = lambda : False

44

69

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

45

70

if not iso:

46

71

return None

47

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

48

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

49

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

72

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

73

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

74

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

50

75

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

51

76

return datetime.datetime(int(year),

52

77

int(month),

65

90

self.proxy = proxy_object # Mandos Client proxy object

66

91

67

92

self.properties = dict()

68

self.proxy.connect_to_signal(u"PropertyChanged",

69

self.property_changed,

70

client_interface,

71

byte_arrays=True)

93

self.property_changed_match = (

94

self.proxy.connect_to_signal("PropertyChanged",

95

self.property_changed,

96

client_interface,

97

byte_arrays=True))

72

98

73

99

self.properties.update(

74

100

self.proxy.GetAll(client_interface,

75

101

dbus_interface = dbus.PROPERTIES_IFACE))

76

102

77

#XXX This break good super behaviour!

103

#XXX This breaks good super behaviour

78

104

# super(MandosClientPropertyCache, self).__init__(

79

105

# *args, **kwargs)

80

106

84

110

"""

85

111

# Update properties dict with new value

86

112

self.properties[property] = value

113

114

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

115

self.property_changed_match.remove()

116

super(MandosClientPropertyCache, self).__init__(

117

*args, **kwargs)

87

118

88

119

89

120

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

103

134

104

135

self._update_timer_callback_tag = None

105

136

self._update_timer_callback_lock = 0

106

self.last_checker_failed = False

107

137

108

138

# The widget shown normally

109

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

139

self._text_widget = urwid.Text("")

110

140

# The widget shown when we have focus

111

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

141

self._focus_text_widget = urwid.Text("")

112

142

super(MandosClientWidget, self).__init__(

113

143

update_hook=update_hook, delete_hook=delete_hook,

114

144

*args, **kwargs)

116

146

self.opened = False

117

147

118

148

last_checked_ok = isoformat_to_datetime(self.properties

119

[u"LastCheckedOK"])

120

if last_checked_ok is None:

121

self.last_checker_failed = True

122

else:

123

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

124

- last_checked_ok)

125

> datetime.timedelta

126

(milliseconds=

127

self.properties

128

[u"Interval"]))

149

["LastCheckedOK"])

129

150

130

if self.last_checker_failed:

151

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

131

152

self.using_timer(True)

132

153

133

154

if self.need_approval:

134

155

self.using_timer(True)

135

156

136

self.proxy.connect_to_signal(u"CheckerCompleted",

137

self.checker_completed,

138

client_interface,

139

byte_arrays=True)

140

self.proxy.connect_to_signal(u"CheckerStarted",

141

self.checker_started,

142

client_interface,

143

byte_arrays=True)

144

self.proxy.connect_to_signal(u"GotSecret",

145

self.got_secret,

146

client_interface,

147

byte_arrays=True)

148

self.proxy.connect_to_signal(u"NeedApproval",

149

self.need_approval,

150

client_interface,

151

byte_arrays=True)

152

self.proxy.connect_to_signal(u"Rejected",

153

self.rejected,

154

client_interface,

155

byte_arrays=True)

157

self.match_objects = (

158

self.proxy.connect_to_signal("CheckerCompleted",

159

self.checker_completed,

160

client_interface,

161

byte_arrays=True),

162

self.proxy.connect_to_signal("CheckerStarted",

163

self.checker_started,

164

client_interface,

165

byte_arrays=True),

166

self.proxy.connect_to_signal("GotSecret",

167

self.got_secret,

168

client_interface,

169

byte_arrays=True),

170

self.proxy.connect_to_signal("NeedApproval",

171

self.need_approval,

172

client_interface,

173

byte_arrays=True),

174

self.proxy.connect_to_signal("Rejected",

175

self.rejected,

176

client_interface,

177

byte_arrays=True))

178

#self.logger('Created client {0}'

179

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

156

180

157

181

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

158

182

super(self, MandosClientWidget).property_changed(property,

159

183

value)

160

if property == u"ApprovalPending":

184

if property == "ApprovalPending":

161

185

using_timer(bool(value))

162

186

if property == "LastCheckerStatus":

187

using_timer(value != 0)

188

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

189

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

190

# command))

191

163

192

def using_timer(self, flag):

164

193

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

165

194

activated or deactivated.

170

199

else:

171

200

self._update_timer_callback_lock -= 1

172

201

if old == 0 and self._update_timer_callback_lock:

202

# Will update the shown timer value every second

173

203

self._update_timer_callback_tag = (gobject.timeout_add

174

204

(1000,

175

205

self.update_timer))

179

209

180

210

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

181

211

if exitstatus == 0:

182

if self.last_checker_failed:

183

self.last_checker_failed = False

184

self.using_timer(False)

185

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

186

# u' was successful'

187

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

188

212

self.update()

189

213

return

190

214

# Checker failed

191

if not self.last_checker_failed:

192

self.last_checker_failed = True

193

self.using_timer(True)

194

215

if os.WIFEXITED(condition):

195

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

196

u' failed with exit code %s'

197

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

198

os.WEXITSTATUS(condition)))

216

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

217

' failed with exit code {2}'

218

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

219

os.WEXITSTATUS(condition)))

199

220

elif os.WIFSIGNALED(condition):

200

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

201

u' was killed by signal %s'

202

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

203

os.WTERMSIG(condition)))

221

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

222

' killed by signal {2}'

223

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

224

os.WTERMSIG(condition)))

204

225

elif os.WCOREDUMP(condition):

205

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

206

u' dumped core'

207

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

226

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

227

' dumped core'

228

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

208

229

else:

209

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

210

u' mysteriously')

230

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

231

' mysteriously'

232

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

211

233

self.update()

212

234

213

235

def checker_started(self, command):

214

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

215

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

236

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

237

to log in the future. """

238

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

239

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

240

# unicode(command)))

216

241

pass

217

242

218

243

def got_secret(self):

219

self.last_checker_failed = False

220

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

221

% self.properties[u"Name"])

244

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

245

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

222

246

223

247

def need_approval(self, timeout, default):

224

248

if not default:

225

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

249

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

226

250

else:

227

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

228

self.logger(message

229

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

251

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

252

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

253

timeout/1000))

230

254

self.using_timer(True)

231

255

232

256

def rejected(self, reason):

233

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

234

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

257

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

258

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

235

259

236

260

def selectable(self):

237

261

"""Make this a "selectable" widget.

238

262

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

239

263

return True

240

264

241

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

265

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

242

266

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

243

267

whether we have focus or not.

244

268

This overrides the method from urwid.FlowWidget"""

245

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

269

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

246

270

247

271

def current_widget(self, focus=False):

248

272

if focus or self.opened:

252

276

def update(self):

253

277

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

254

278

# How to add standout mode to a style

255

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

256

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

257

u"underline-blink":

258

u"underline-blink-standout",

259

u"bold-underline-blink":

260

u"bold-underline-blink-standout",

279

with_standout = { "normal": "standout",

280

"bold": "bold-standout",

281

"underline-blink":

282

"underline-blink-standout",

283

"bold-underline-blink":

284

"bold-underline-blink-standout",

261

285

}

262

286

263

287

# Rebuild focus and non-focus widgets using current properties

264

288

265

289

# Base part of a client. Name!

266

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

267

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

268

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

269

message = u"DISABLED"

270

elif self.properties[u"ApprovalPending"]:

290

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

291

if not self.properties["Enabled"]:

292

message = "DISABLED"

293

elif self.properties["ApprovalPending"]:

271

294

timeout = datetime.timedelta(milliseconds

272

295

= self.properties

273

[u"ApprovalDelay"])

296

["ApprovalDelay"])

274

297

last_approval_request = isoformat_to_datetime(

275

self.properties[u"LastApprovalRequest"])

298

self.properties["LastApprovalRequest"])

276

299

if last_approval_request is not None:

277

300

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

278

301

- last_approval_request)

279

302

else:

280

303

timer = datetime.timedelta()

281

if self.properties[u"ApprovedByDefault"]:

282

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

283

else:

284

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

285

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

286

elif self.last_checker_failed:

287

timeout = datetime.timedelta(milliseconds

288

= self.properties

289

[u"Timeout"])

290

last_ok = isoformat_to_datetime(

291

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

292

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

293

self.properties[u"LastEnabled"]))

294

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

295

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

296

u' gets disabled: %s'

297

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

304

if self.properties["ApprovedByDefault"]:

305

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

306

else:

307

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

308

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

309

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

310

# When checker has failed, show timer until client expires

311

expires = self.properties["Expires"]

312

if expires == "":

313

timer = datetime.timedelta(0)

314

else:

315

expires = (datetime.datetime.strptime

316

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

317

timer = expires - datetime.datetime.utcnow()

318

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

319

' gets disabled: {0}'

320

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

298

321

else:

299

message = u"enabled"

300

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

322

message = "enabled"

323

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

301

324

302

325

if not urwid.supports_unicode():

303

326

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

304

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

327

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

305

328

self._text_widget.set_text(textlist)

306

329

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

307

330

text[1])

316

339

self.update_hook()

317

340

318

341

def update_timer(self):

319

"called by gobject"

342

"""called by gobject. Will indefinitely loop until

343

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

320

344

self.update()

321

345

return True # Keep calling this

322

346

323

def delete(self):

347

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

324

348

if self._update_timer_callback_tag is not None:

325

349

gobject.source_remove(self._update_timer_callback_tag)

326

350

self._update_timer_callback_tag = None

351

for match in self.match_objects:

352

match.remove()

353

self.match_objects = ()

327

354

if self.delete_hook is not None:

328

355

self.delete_hook(self)

356

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

329

357

330

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

358

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

331

359

"""Render differently if we have focus.

332

360

This overrides the method from urwid.FlowWidget"""

333

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

361

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

334

362

focus=focus)

335

363

336

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

364

def keypress(self, maxcolrow, key):

337

365

"""Handle keys.

338

366

This overrides the method from urwid.FlowWidget"""

339

if key == u"+":

340

self.proxy.Enable(dbus_interface = client_interface)

341

elif key == u"-":

342

self.proxy.Disable(dbus_interface = client_interface)

343

elif key == u"a":

367

if key == "+":

368

self.proxy.Enable(dbus_interface = client_interface,

369

ignore_reply=True)

370

elif key == "-":

371

self.proxy.Disable(dbus_interface = client_interface,

372

ignore_reply=True)

373

elif key == "a":

344

374

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

345

dbus_interface = client_interface)

346

elif key == u"d":

375

dbus_interface = client_interface,

376

ignore_reply=True)

377

elif key == "d":

347

378

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

348

dbus_interface = client_interface)

349

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

379

dbus_interface = client_interface,

380

ignore_reply=True)

381

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

350

382

self.server_proxy_object.RemoveClient(self.proxy

351

.object_path)

352

elif key == u"s":

353

self.proxy.StartChecker(dbus_interface = client_interface)

354

elif key == u"S":

355

self.proxy.StopChecker(dbus_interface = client_interface)

356

elif key == u"C":

357

self.proxy.CheckedOK(dbus_interface = client_interface)

383

.object_path,

384

ignore_reply=True)

385

elif key == "s":

386

self.proxy.StartChecker(dbus_interface = client_interface,

387

ignore_reply=True)

388

elif key == "S":

389

self.proxy.StopChecker(dbus_interface = client_interface,

390

ignore_reply=True)

391

elif key == "C":

392

self.proxy.CheckedOK(dbus_interface = client_interface,

393

ignore_reply=True)

358

394

# xxx

359

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

395

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

360

396

# self.proxy.pause()

361

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

397

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

362

398

# self.proxy.unpause()

363

# elif key == u"RET":

399

# elif key == "RET":

364

400

# self.open()

365

401

else:

366

402

return key

382

418

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

383

419

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

384

420

"""

385

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

386

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

387

maxrow), key)

388

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

421

def keypress(self, maxcolrow, key):

422

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

423

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

389

424

return

390

425

return ret

391

426

400

435

self.screen = urwid.curses_display.Screen()

401

436

402

437

self.screen.register_palette((

403

(u"normal",

404

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

405

(u"bold",

406

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

407

(u"underline-blink",

408

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

409

(u"standout",

410

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

411

(u"bold-underline-blink",

412

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

413

(u"bold-standout",

414

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

415

(u"underline-blink-standout",

416

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

417

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

418

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

419

u"standout")),

438

("normal",

439

"default", "default", None),

440

("bold",

441

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

442

("underline-blink",

443

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

444

("standout",

445

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

446

("bold-underline-blink",

447

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

448

("bold-standout",

449

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

450

("underline-blink-standout",

451

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

452

("bold-underline-blink-standout",

453

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

454

"standout")),

420

455

))

421

456

422

457

if urwid.supports_unicode():

423

self.divider = u"─" # \u2500

424

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

458

self.divider = "─" # \u2500

459

#self.divider = "━" # \u2501

425

460

else:

426

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

427

self.divider = u"_" # \u005f

461

#self.divider = "-" # \u002d

462

self.divider = "_" # \u005f

428

463

429

464

self.screen.start()

430

465

444

479

# This keeps track of whether self.uilist currently has

445

480

# self.logbox in it or not

446

481

self.log_visible = True

447

self.log_wrap = u"any"

482

self.log_wrap = "any"

448

483

449

484

self.rebuild()

450

self.log_message_raw((u"bold",

451

u"Mandos Monitor version " + version))

452

self.log_message_raw((u"bold",

453

u"q: Quit ?: Help"))

485

self.log_message_raw(("bold",

486

"Mandos Monitor version " + version))

487

self.log_message_raw(("bold",

488

"q: Quit ?: Help"))

454

489

455

490

self.busname = domain + '.Mandos'

456

491

self.main_loop = gobject.MainLoop()

457

self.bus = dbus.SystemBus()

458

mandos_dbus_objc = self.bus.get_object(

459

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

460

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

461

dbus_interface

462

= server_interface)

463

try:

464

mandos_clients = (self.mandos_serv

465

.GetAllClientsWithProperties())

466

except dbus.exceptions.DBusException:

467

mandos_clients = dbus.Dictionary()

468

469

(self.mandos_serv

470

.connect_to_signal(u"ClientRemoved",

471

self.find_and_remove_client,

472

dbus_interface=server_interface,

473

byte_arrays=True))

474

(self.mandos_serv

475

.connect_to_signal(u"ClientAdded",

476

self.add_new_client,

477

dbus_interface=server_interface,

478

byte_arrays=True))

479

(self.mandos_serv

480

.connect_to_signal(u"ClientNotFound",

481

self.client_not_found,

482

dbus_interface=server_interface,

483

byte_arrays=True))

484

for path, client in mandos_clients.iteritems():

485

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

486

path)

487

self.add_client(MandosClientWidget(server_proxy_object

488

=self.mandos_serv,

489

proxy_object

490

=client_proxy_object,

491

properties=client,

492

update_hook

493

=self.refresh,

494

delete_hook

495

=self.remove_client,

496

logger

497

=self.log_message),

498

path=path)

499

492

500

493

def client_not_found(self, fingerprint, address):

501

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

502

u" could not be found" % (address,

503

fingerprint)))

494

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

495

" {1} could not be found"

496

.format(address, fingerprint))

504

497

505

498

def rebuild(self):

506

499

"""This rebuilds the User Interface.

516

509

self.divider)))

517

510

if self.log_visible:

518

511

self.uilist.append(self.logbox)

519

pass

520

512

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

521

513

522

514

def log_message(self, message):

523

515

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

524

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

516

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

525

517

526

518

def log_message_raw(self, markup):

527

519

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

530

522

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

531

523

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

532

524

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

533

coming_from=u"above")

525

coming_from="above")

534

526

self.refresh()

535

527

536

528

def toggle_log_display(self):

537

529

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

538

530

self.log_visible = not self.log_visible

539

531

self.rebuild()

540

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

532

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

541

533

# + unicode(self.log_visible))

542

534

543

535

def change_log_display(self):

544

536

"""Change type of log display.

545

537

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

546

if self.log_wrap == u"clip":

547

self.log_wrap = u"any"

538

if self.log_wrap == "clip":

539

self.log_wrap = "any"

548

540

else:

549

self.log_wrap = u"clip"

541

self.log_wrap = "clip"

550

542

for textwidget in self.log:

551

543

textwidget.set_wrap_mode(self.log_wrap)

552

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

544

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

553

545

554

546

def find_and_remove_client(self, path, name):

555

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

547

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

556

548

557

549

This is connected to the ClientRemoved signal from the

558

550

Mandos server object."""

560

552

client = self.clients_dict[path]

561

553

except KeyError:

562

554

# not found?

555

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

556

.format(name, path))

563

557

return

564

self.remove_client(client, path)

558

client.delete()

565

559

566

560

def add_new_client(self, path):

567

561

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

582

576

if path is None:

583

577

path = client.proxy.object_path

584

578

self.clients_dict[path] = client

585

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

579

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

586

580

self.refresh()

587

581

588

582

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

604

598

605

599

def run(self):

606

600

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

601

self.bus = dbus.SystemBus()

602

mandos_dbus_objc = self.bus.get_object(

603

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

604

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

605

dbus_interface

606

= server_interface)

607

try:

608

mandos_clients = (self.mandos_serv

609

.GetAllClientsWithProperties())

610

except dbus.exceptions.DBusException:

611

mandos_clients = dbus.Dictionary()

612

613

(self.mandos_serv

614

.connect_to_signal("ClientRemoved",

615

self.find_and_remove_client,

616

dbus_interface=server_interface,

617

byte_arrays=True))

618

(self.mandos_serv

619

.connect_to_signal("ClientAdded",

620

self.add_new_client,

621

dbus_interface=server_interface,

622

byte_arrays=True))

623

(self.mandos_serv

624

.connect_to_signal("ClientNotFound",

625

self.client_not_found,

626

dbus_interface=server_interface,

627

byte_arrays=True))

628

for path, client in mandos_clients.iteritems():

629

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

630

path)

631

self.add_client(MandosClientWidget(server_proxy_object

632

=self.mandos_serv,

633

proxy_object

634

=client_proxy_object,

635

properties=client,

636

update_hook

637

=self.refresh,

638

delete_hook

639

=self.remove_client,

640

logger

641

=self.log_message),

642

path=path)

643

607

644

self.refresh()

608

645

self._input_callback_tag = (gobject.io_add_watch

609

646

(sys.stdin.fileno(),

619

656

620

657

def process_input(self, source, condition):

621

658

keys = self.screen.get_input()

622

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

623

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

624

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

625

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

626

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

627

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

628

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

629

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

630

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

659

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

660

"ctrl p": "up", # Emacs

661

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

662

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

663

" ": "page down", # less

664

"f": "page down", # less

665

"b": "page up", # less

666

"j": "down", # vi

667

"k": "up", # vi

631

668

}

632

669

for key in keys:

633

670

try:

635

672

except KeyError: # :-)

636

673

pass

637

674

638

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

675

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

639

676

self.stop()

640

677

break

641

elif key == u"window resize":

678

elif key == "window resize":

642

679

self.size = self.screen.get_cols_rows()

643

680

self.refresh()

644

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

681

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

645

682

self.refresh()

646

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

683

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

647

684

self.toggle_log_display()

648

685

self.refresh()

649

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

686

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

650

687

self.change_log_display()

651

688

self.refresh()

652

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

689

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

653

690

if not self.log_visible:

654

691

self.log_visible = True

655

692

self.rebuild()

656

self.log_message_raw((u"bold",

657

u" ".

658

join((u"q: Quit",

659

u"?: Help",

660

u"l: Log window toggle",

661

u"TAB: Switch window",

662

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

663

self.log_message_raw((u"bold",

664

u" "

665

.join((u"Clients:",

666

u"+: Enable",

667

u"-: Disable",

668

u"r: Remove",

669

u"s: Start new checker",

670

u"S: Stop checker",

671

u"C: Checker OK",

672

u"a: Approve",

673

u"d: Deny"))))

693

self.log_message_raw(("bold",

694

" ".

695

join(("q: Quit",

696

"?: Help",

697

"l: Log window toggle",

698

"TAB: Switch window",

699

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

700

self.log_message_raw(("bold",

701

" "

702

.join(("Clients:",

703

"+: Enable",

704

"-: Disable",

705

"R: Remove",

706

"s: Start new checker",

707

"S: Stop checker",

708

"C: Checker OK",

709

"a: Approve",

710

"d: Deny"))))

674

711

self.refresh()

675

elif key == u"tab":

712

elif key == "tab":

676

713

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

677

714

self.topwidget.set_focus(0)

678

715

else:

679

716

self.topwidget.set_focus(self.logbox)

680

717

self.refresh()

681

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

682

# or key == u">"):

718

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

719

# or key == ">"):

683

720

# pass # xxx end-of-buffer

684

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

685

# or key == u"<"):

721

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

722

# or key == "<"):

686

723

# pass # xxx beginning-of-buffer

687

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

724

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

688

725

# pass # xxx move-end-of-line

689

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

726

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

690

727

# pass # xxx move-beginning-of-line

691

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

728

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

692

729

# pass # xxx left

693

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

730

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

694

731

# pass # xxx right

695

#elif key == u"a":

732

#elif key == "a":

696

733

# pass # scroll up log

697

#elif key == u"z":

734

#elif key == "z":

698

735

# pass # scroll down log

699

736

elif self.topwidget.selectable():

700

737

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