/mandos/trunk : revision 572

1

#!/usr/bin/python

2

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

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

#

3

25

4

from __future__ import division, absolute_import, with_statement

26

from __future__ import (division, absolute_import, print_function,

27

unicode_literals)

5

28

6

29

import sys

7

30

import os

21

44

22

45

import locale

23

46

24

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

47

locale.setlocale(locale.LC_ALL, '')

25

48

26

49

import logging

27

50

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

28

51

29

52

# Some useful constants

30

domain = 'se.bsnet.fukt'

53

domain = 'se.recompile'

31

54

server_interface = domain + '.Mandos'

32

55

client_interface = domain + '.Mandos.Client'

33

version = "1.0.15"

56

version = "1.5.3"

34

57

35

58

# Always run in monochrome mode

36

59

urwid.curses_display.curses.has_colors = lambda : False

44

67

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

45

68

if not iso:

46

69

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)

70

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

71

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

72

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

50

73

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

51

74

return datetime.datetime(int(year),

52

75

int(month),

65

88

self.proxy = proxy_object # Mandos Client proxy object

66

89

67

90

self.properties = dict()

68

self.proxy.connect_to_signal(u"PropertyChanged",

69

self.property_changed,

70

client_interface,

71

byte_arrays=True)

91

self.property_changed_match = (

92

self.proxy.connect_to_signal("PropertyChanged",

93

self.property_changed,

94

client_interface,

95

byte_arrays=True))

72

96

73

97

self.properties.update(

74

98

self.proxy.GetAll(client_interface,

75

99

dbus_interface = dbus.PROPERTIES_IFACE))

76

100

77

#XXX This break good super behaviour!

101

#XXX This breaks good super behaviour

78

102

# super(MandosClientPropertyCache, self).__init__(

79

103

# *args, **kwargs)

80

104

84

108

"""

85

109

# Update properties dict with new value

86

110

self.properties[property] = value

111

112

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

113

self.property_changed_match.remove()

114

super(MandosClientPropertyCache, self).__init__(

115

*args, **kwargs)

87

116

88

117

89

118

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

103

132

104

133

self._update_timer_callback_tag = None

105

134

self._update_timer_callback_lock = 0

106

self.last_checker_failed = False

107

135

108

136

# The widget shown normally

109

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

137

self._text_widget = urwid.Text("")

110

138

# The widget shown when we have focus

111

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

139

self._focus_text_widget = urwid.Text("")

112

140

super(MandosClientWidget, self).__init__(

113

141

update_hook=update_hook, delete_hook=delete_hook,

114

142

*args, **kwargs)

116

144

self.opened = False

117

145

118

146

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

147

["LastCheckedOK"])

129

148

130

if self.last_checker_failed:

149

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

131

150

self.using_timer(True)

132

151

133

152

if self.need_approval:

134

153

self.using_timer(True)

135

154

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)

155

self.match_objects = (

156

self.proxy.connect_to_signal("CheckerCompleted",

157

self.checker_completed,

158

client_interface,

159

byte_arrays=True),

160

self.proxy.connect_to_signal("CheckerStarted",

161

self.checker_started,

162

client_interface,

163

byte_arrays=True),

164

self.proxy.connect_to_signal("GotSecret",

165

self.got_secret,

166

client_interface,

167

byte_arrays=True),

168

self.proxy.connect_to_signal("NeedApproval",

169

self.need_approval,

170

client_interface,

171

byte_arrays=True),

172

self.proxy.connect_to_signal("Rejected",

173

self.rejected,

174

client_interface,

175

byte_arrays=True))

176

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

177

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

156

178

157

179

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

158

180

super(self, MandosClientWidget).property_changed(property,

159

181

value)

160

if property == u"ApprovalPending":

182

if property == "ApprovalPending":

161

183

using_timer(bool(value))

162

184

if property == "LastCheckerStatus":

185

using_timer(value != 0)

186

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

187

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

188

# command))

189

163

190

def using_timer(self, flag):

164

191

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

165

192

activated or deactivated.

170

197

else:

171

198

self._update_timer_callback_lock -= 1

172

199

if old == 0 and self._update_timer_callback_lock:

200

# Will update the shown timer value every second

173

201

self._update_timer_callback_tag = (gobject.timeout_add

174

202

(1000,

175

203

self.update_timer))

179

207

180

208

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

181

209

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

210

self.update()

189

211

return

190

212

# Checker failed

191

if not self.last_checker_failed:

192

self.last_checker_failed = True

193

self.using_timer(True)

194

213

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

214

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

215

' failed with exit code {2}'

216

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

217

os.WEXITSTATUS(condition)))

199

218

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

219

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

220

' killed by signal {2}'

221

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

222

os.WTERMSIG(condition)))

204

223

elif os.WCOREDUMP(condition):

205

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

206

u' dumped core'

207

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

224

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

225

' dumped core'

226

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

208

227

else:

209

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

210

u' mysteriously')

228

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

229

' mysteriously'

230

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

211

231

self.update()

212

232

213

233

def checker_started(self, command):

214

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

215

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

234

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

235

to log in the future. """

236

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

237

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

238

# unicode(command)))

216

239

pass

217

240

218

241

def got_secret(self):

219

self.last_checker_failed = False

220

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

221

% self.properties[u"Name"])

242

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

243

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

222

244

223

245

def need_approval(self, timeout, default):

224

246

if not default:

225

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

247

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

226

248

else:

227

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

228

self.logger(message

229

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

249

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

250

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

251

timeout/1000))

230

252

self.using_timer(True)

231

253

232

254

def rejected(self, reason):

233

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

234

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

255

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

256

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

235

257

236

258

def selectable(self):

237

259

"""Make this a "selectable" widget.

238

260

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

239

261

return True

240

262

241

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

263

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

242

264

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

243

265

whether we have focus or not.

244

266

This overrides the method from urwid.FlowWidget"""

245

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

267

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

246

268

247

269

def current_widget(self, focus=False):

248

270

if focus or self.opened:

252

274

def update(self):

253

275

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

254

276

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

277

with_standout = { "normal": "standout",

278

"bold": "bold-standout",

279

"underline-blink":

280

"underline-blink-standout",

281

"bold-underline-blink":

282

"bold-underline-blink-standout",

261

283

}

262

284

263

285

# Rebuild focus and non-focus widgets using current properties

264

286

265

287

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

288

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

289

if not self.properties["Enabled"]:

290

message = "DISABLED"

291

elif self.properties["ApprovalPending"]:

271

292

timeout = datetime.timedelta(milliseconds

272

293

= self.properties

273

[u"ApprovalDelay"])

294

["ApprovalDelay"])

274

295

last_approval_request = isoformat_to_datetime(

275

self.properties[u"LastApprovalRequest"])

296

self.properties["LastApprovalRequest"])

276

297

if last_approval_request is not None:

277

298

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

278

299

- last_approval_request)

279

300

else:

280

301

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

302

if self.properties["ApprovedByDefault"]:

303

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

304

else:

305

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

306

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

307

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

308

# When checker has failed, show timer until client expires

309

expires = self.properties["Expires"]

310

if expires == "":

311

timer = datetime.timedelta(0)

312

else:

313

expires = (datetime.datetime.strptime

314

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

315

timer = expires - datetime.datetime.utcnow()

316

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

317

' gets disabled: {0}'

318

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

298

319

else:

299

message = u"enabled"

300

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

320

message = "enabled"

321

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

301

322

302

323

if not urwid.supports_unicode():

303

324

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

304

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

325

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

305

326

self._text_widget.set_text(textlist)

306

327

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

307

328

text[1])

316

337

self.update_hook()

317

338

318

339

def update_timer(self):

319

"called by gobject"

340

"""called by gobject. Will indefinitely loop until

341

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

320

342

self.update()

321

343

return True # Keep calling this

322

344

323

def delete(self):

345

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

324

346

if self._update_timer_callback_tag is not None:

325

347

gobject.source_remove(self._update_timer_callback_tag)

326

348

self._update_timer_callback_tag = None

349

for match in self.match_objects:

350

match.remove()

351

self.match_objects = ()

327

352

if self.delete_hook is not None:

328

353

self.delete_hook(self)

354

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

329

355

330

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

356

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

331

357

"""Render differently if we have focus.

332

358

This overrides the method from urwid.FlowWidget"""

333

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

359

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

334

360

focus=focus)

335

361

336

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

362

def keypress(self, maxcolrow, key):

337

363

"""Handle keys.

338

364

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

365

if key == "+":

366

self.proxy.Enable(dbus_interface = client_interface,

367

ignore_reply=True)

368

elif key == "-":

369

self.proxy.Disable(dbus_interface = client_interface,

370

ignore_reply=True)

371

elif key == "a":

344

372

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

345

dbus_interface = client_interface)

346

elif key == u"d":

373

dbus_interface = client_interface,

374

ignore_reply=True)

375

elif key == "d":

347

376

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

377

dbus_interface = client_interface,

378

ignore_reply=True)

379

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

350

380

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)

381

.object_path,

382

ignore_reply=True)

383

elif key == "s":

384

self.proxy.StartChecker(dbus_interface = client_interface,

385

ignore_reply=True)

386

elif key == "S":

387

self.proxy.StopChecker(dbus_interface = client_interface,

388

ignore_reply=True)

389

elif key == "C":

390

self.proxy.CheckedOK(dbus_interface = client_interface,

391

ignore_reply=True)

358

392

# xxx

359

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

393

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

360

394

# self.proxy.pause()

361

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

395

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

362

396

# self.proxy.unpause()

363

# elif key == u"RET":

397

# elif key == "RET":

364

398

# self.open()

365

399

else:

366

400

return key

382

416

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

383

417

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

384

418

"""

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

419

def keypress(self, maxcolrow, key):

420

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

421

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

389

422

return

390

423

return ret

391

424

400

433

self.screen = urwid.curses_display.Screen()

401

434

402

435

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

436

("normal",

437

"default", "default", None),

438

("bold",

439

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

440

("underline-blink",

441

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

442

("standout",

443

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

444

("bold-underline-blink",

445

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

446

("bold-standout",

447

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

448

("underline-blink-standout",

449

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

450

("bold-underline-blink-standout",

451

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

452

"standout")),

420

453

))

421

454

422

455

if urwid.supports_unicode():

423

self.divider = u"─" # \u2500

424

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

456

self.divider = "─" # \u2500

457

#self.divider = "━" # \u2501

425

458

else:

426

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

427

self.divider = u"_" # \u005f

459

#self.divider = "-" # \u002d

460

self.divider = "_" # \u005f

428

461

429

462

self.screen.start()

430

463

444

477

# This keeps track of whether self.uilist currently has

445

478

# self.logbox in it or not

446

479

self.log_visible = True

447

self.log_wrap = u"any"

480

self.log_wrap = "any"

448

481

449

482

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

483

self.log_message_raw(("bold",

484

"Mandos Monitor version " + version))

485

self.log_message_raw(("bold",

486

"q: Quit ?: Help"))

454

487

455

488

self.busname = domain + '.Mandos'

456

489

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

490

500

491

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

492

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

493

" {1} could not be found"

494

.format(address, fingerprint))

504

495

505

496

def rebuild(self):

506

497

"""This rebuilds the User Interface.

516

507

self.divider)))

517

508

if self.log_visible:

518

509

self.uilist.append(self.logbox)

519

pass

520

510

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

521

511

522

512

def log_message(self, message):

523

513

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

524

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

514

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

525

515

526

516

def log_message_raw(self, markup):

527

517

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

530

520

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

531

521

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

532

522

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

533

coming_from=u"above")

523

coming_from="above")

534

524

self.refresh()

535

525

536

526

def toggle_log_display(self):

537

527

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

538

528

self.log_visible = not self.log_visible

539

529

self.rebuild()

540

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

530

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

541

531

# + unicode(self.log_visible))

542

532

543

533

def change_log_display(self):

544

534

"""Change type of log display.

545

535

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

546

if self.log_wrap == u"clip":

547

self.log_wrap = u"any"

536

if self.log_wrap == "clip":

537

self.log_wrap = "any"

548

538

else:

549

self.log_wrap = u"clip"

539

self.log_wrap = "clip"

550

540

for textwidget in self.log:

551

541

textwidget.set_wrap_mode(self.log_wrap)

552

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

542

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

553

543

554

544

def find_and_remove_client(self, path, name):

555

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

545

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

556

546

557

547

This is connected to the ClientRemoved signal from the

558

548

Mandos server object."""

560

550

client = self.clients_dict[path]

561

551

except KeyError:

562

552

# not found?

553

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

554

.format(name, path))

563

555

return

564

self.remove_client(client, path)

556

client.delete()

565

557

566

558

def add_new_client(self, path):

567

559

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

582

574

if path is None:

583

575

path = client.proxy.object_path

584

576

self.clients_dict[path] = client

585

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

577

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

586

578

self.refresh()

587

579

588

580

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

604

596

605

597

def run(self):

606

598

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

599

self.bus = dbus.SystemBus()

600

mandos_dbus_objc = self.bus.get_object(

601

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

602

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

603

dbus_interface

604

= server_interface)

605

try:

606

mandos_clients = (self.mandos_serv

607

.GetAllClientsWithProperties())

608

except dbus.exceptions.DBusException:

609

mandos_clients = dbus.Dictionary()

610

611

(self.mandos_serv

612

.connect_to_signal("ClientRemoved",

613

self.find_and_remove_client,

614

dbus_interface=server_interface,

615

byte_arrays=True))

616

(self.mandos_serv

617

.connect_to_signal("ClientAdded",

618

self.add_new_client,

619

dbus_interface=server_interface,

620

byte_arrays=True))

621

(self.mandos_serv

622

.connect_to_signal("ClientNotFound",

623

self.client_not_found,

624

dbus_interface=server_interface,

625

byte_arrays=True))

626

for path, client in mandos_clients.iteritems():

627

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

628

path)

629

self.add_client(MandosClientWidget(server_proxy_object

630

=self.mandos_serv,

631

proxy_object

632

=client_proxy_object,

633

properties=client,

634

update_hook

635

=self.refresh,

636

delete_hook

637

=self.remove_client,

638

logger

639

=self.log_message),

640

path=path)

641

607

642

self.refresh()

608

643

self._input_callback_tag = (gobject.io_add_watch

609

644

(sys.stdin.fileno(),

619

654

620

655

def process_input(self, source, condition):

621

656

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

657

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

658

"ctrl p": "up", # Emacs

659

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

660

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

661

" ": "page down", # less

662

"f": "page down", # less

663

"b": "page up", # less

664

"j": "down", # vi

665

"k": "up", # vi

631

666

}

632

667

for key in keys:

633

668

try:

635

670

except KeyError: # :-)

636

671

pass

637

672

638

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

673

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

639

674

self.stop()

640

675

break

641

elif key == u"window resize":

676

elif key == "window resize":

642

677

self.size = self.screen.get_cols_rows()

643

678

self.refresh()

644

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

679

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

645

680

self.refresh()

646

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

681

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

647

682

self.toggle_log_display()

648

683

self.refresh()

649

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

684

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

650

685

self.change_log_display()

651

686

self.refresh()

652

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

687

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

653

688

if not self.log_visible:

654

689

self.log_visible = True

655

690

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

691

self.log_message_raw(("bold",

692

" ".

693

join(("q: Quit",

694

"?: Help",

695

"l: Log window toggle",

696

"TAB: Switch window",

697

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

698

self.log_message_raw(("bold",

699

" "

700

.join(("Clients:",

701

"+: Enable",

702

"-: Disable",

703

"R: Remove",

704

"s: Start new checker",

705

"S: Stop checker",

706

"C: Checker OK",

707

"a: Approve",

708

"d: Deny"))))

674

709

self.refresh()

675

elif key == u"tab":

710

elif key == "tab":

676

711

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

677

712

self.topwidget.set_focus(0)

678

713

else:

679

714

self.topwidget.set_focus(self.logbox)

680

715

self.refresh()

681

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

682

# or key == u">"):

716

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

717

# or key == ">"):

683

718

# pass # xxx end-of-buffer

684

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

685

# or key == u"<"):

719

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

720

# or key == "<"):

686

721

# pass # xxx beginning-of-buffer

687

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

722

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

688

723

# pass # xxx move-end-of-line

689

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

724

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

690

725

# pass # xxx move-beginning-of-line

691

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

726

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

692

727

# pass # xxx left

693

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

728

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

694

729

# pass # xxx right

695

#elif key == u"a":

730

#elif key == "a":

696

731

# pass # scroll up log

697

#elif key == u"z":

732

#elif key == "z":

698

733

# pass # scroll down log

699

734

elif self.topwidget.selectable():

700

735

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