/mandos/trunk : revision 443

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

#

25

3

26

from __future__ import (division, absolute_import, print_function,

27

unicode_literals)

4

from __future__ import division, absolute_import, with_statement

28

5

29

6

import sys

30

7

import os

44

21

45

22

import locale

46

23

47

locale.setlocale(locale.LC_ALL, '')

24

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

48

25

49

26

import logging

50

27

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

51

28

52

29

# Some useful constants

53

domain = 'se.recompile'

30

domain = 'se.bsnet.fukt'

54

31

server_interface = domain + '.Mandos'

55

32

client_interface = domain + '.Mandos.Client'

56

version = "1.5.3"

33

version = "1.0.15"

57

34

58

35

# Always run in monochrome mode

59

36

urwid.curses_display.curses.has_colors = lambda : False

67

44

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

68

45

if not iso:

69

46

return None

70

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

71

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

72

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

47

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

48

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

49

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

73

50

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

74

51

return datetime.datetime(int(year),

75

52

int(month),

88

65

self.proxy = proxy_object # Mandos Client proxy object

89

66

90

67

self.properties = dict()

91

self.property_changed_match = (

92

self.proxy.connect_to_signal("PropertyChanged",

93

self.property_changed,

94

client_interface,

95

byte_arrays=True))

68

self.proxy.connect_to_signal(u"PropertyChanged",

69

self.property_changed,

70

client_interface,

71

byte_arrays=True)

96

72

97

73

self.properties.update(

98

74

self.proxy.GetAll(client_interface,

99

75

dbus_interface = dbus.PROPERTIES_IFACE))

100

76

101

#XXX This breaks good super behaviour

77

#XXX This break good super behaviour!

102

78

# super(MandosClientPropertyCache, self).__init__(

103

79

# *args, **kwargs)

104

80

108

84

"""

109

85

# Update properties dict with new value

110

86

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)

116

87

117

88

118

89

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

132

103

133

104

self._update_timer_callback_tag = None

134

105

self._update_timer_callback_lock = 0

106

self.last_checker_failed = False

135

107

136

108

# The widget shown normally

137

self._text_widget = urwid.Text("")

109

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

138

110

# The widget shown when we have focus

139

self._focus_text_widget = urwid.Text("")

111

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

140

112

super(MandosClientWidget, self).__init__(

141

113

update_hook=update_hook, delete_hook=delete_hook,

142

114

*args, **kwargs)

144

116

self.opened = False

145

117

146

118

last_checked_ok = isoformat_to_datetime(self.properties

147

["LastCheckedOK"])

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

148

129

149

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

130

if self.last_checker_failed:

150

131

self.using_timer(True)

151

132

152

133

if self.need_approval:

153

134

self.using_timer(True)

154

135

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

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)

178

156

179

157

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

180

158

super(self, MandosClientWidget).property_changed(property,

181

159

value)

182

if property == "ApprovalPending":

160

if property == u"ApprovalPending":

183

161

using_timer(bool(value))

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

162

190

163

def using_timer(self, flag):

191

164

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

192

165

activated or deactivated.

197

170

else:

198

171

self._update_timer_callback_lock -= 1

199

172

if old == 0 and self._update_timer_callback_lock:

200

# Will update the shown timer value every second

201

173

self._update_timer_callback_tag = (gobject.timeout_add

202

174

(1000,

203

175

self.update_timer))

207

179

208

180

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

209

181

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

210

188

self.update()

211

189

return

212

190

# Checker failed

191

if not self.last_checker_failed:

192

self.last_checker_failed = True

193

self.using_timer(True)

213

194

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

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

218

199

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

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

223

204

elif os.WCOREDUMP(condition):

224

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

225

' dumped core'

226

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

205

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

206

u' dumped core'

207

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

227

208

else:

228

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

229

' mysteriously'

230

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

209

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

210

u' mysteriously')

231

211

self.update()

232

212

233

213

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

214

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

215

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

239

216

pass

240

217

241

218

def got_secret(self):

242

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

243

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

219

self.last_checker_failed = False

220

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

221

% self.properties[u"Name"])

244

222

245

223

def need_approval(self, timeout, default):

246

224

if not default:

247

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

225

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

248

226

else:

249

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

250

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

251

timeout/1000))

227

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

228

self.logger(message

229

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

252

230

self.using_timer(True)

253

231

254

232

def rejected(self, reason):

255

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

256

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

233

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

234

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

257

235

258

236

def selectable(self):

259

237

"""Make this a "selectable" widget.

260

238

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

261

239

return True

262

240

263

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

241

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

264

242

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

265

243

whether we have focus or not.

266

244

This overrides the method from urwid.FlowWidget"""

267

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

245

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

268

246

269

247

def current_widget(self, focus=False):

270

248

if focus or self.opened:

274

252

def update(self):

275

253

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

276

254

# How to add standout mode to a style

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

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

283

261

}

284

262

285

263

# Rebuild focus and non-focus widgets using current properties

286

264

287

265

# Base part of a client. Name!

288

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

289

if not self.properties["Enabled"]:

290

message = "DISABLED"

291

elif self.properties["ApprovalPending"]:

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

292

271

timeout = datetime.timedelta(milliseconds

293

272

= self.properties

294

["ApprovalDelay"])

273

[u"ApprovalDelay"])

295

274

last_approval_request = isoformat_to_datetime(

296

self.properties["LastApprovalRequest"])

275

self.properties[u"LastApprovalRequest"])

297

276

if last_approval_request is not None:

298

277

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

299

278

- last_approval_request)

300

279

else:

301

280

timer = datetime.timedelta()

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

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

319

298

else:

320

message = "enabled"

321

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

299

message = u"enabled"

300

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

322

301

323

302

if not urwid.supports_unicode():

324

303

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

325

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

304

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

326

305

self._text_widget.set_text(textlist)

327

306

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

328

307

text[1])

337

316

self.update_hook()

338

317

339

318

def update_timer(self):

340

"""called by gobject. Will indefinitely loop until

341

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

319

"called by gobject"

342

320

self.update()

343

321

return True # Keep calling this

344

322

345

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

323

def delete(self):

346

324

if self._update_timer_callback_tag is not None:

347

325

gobject.source_remove(self._update_timer_callback_tag)

348

326

self._update_timer_callback_tag = None

349

for match in self.match_objects:

350

match.remove()

351

self.match_objects = ()

352

327

if self.delete_hook is not None:

353

328

self.delete_hook(self)

354

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

355

329

356

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

330

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

357

331

"""Render differently if we have focus.

358

332

This overrides the method from urwid.FlowWidget"""

359

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

333

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

360

334

focus=focus)

361

335

362

def keypress(self, maxcolrow, key):

336

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

363

337

"""Handle keys.

364

338

This overrides the method from urwid.FlowWidget"""

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

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

372

344

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

373

dbus_interface = client_interface,

374

ignore_reply=True)

375

elif key == "d":

345

dbus_interface = client_interface)

346

elif key == u"d":

376

347

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

377

dbus_interface = client_interface,

378

ignore_reply=True)

379

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

348

dbus_interface = client_interface)

349

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

380

350

self.server_proxy_object.RemoveClient(self.proxy

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)

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)

392

358

# xxx

393

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

359

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

394

360

# self.proxy.pause()

395

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

361

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

396

362

# self.proxy.unpause()

397

# elif key == "RET":

363

# elif key == u"RET":

398

364

# self.open()

399

365

else:

400

366

return key

416

382

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

417

383

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

418

384

"""

419

def keypress(self, maxcolrow, key):

420

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

421

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

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

422

389

return

423

390

return ret

424

391

433

400

self.screen = urwid.curses_display.Screen()

434

401

435

402

self.screen.register_palette((

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

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

453

420

))

454

421

455

422

if urwid.supports_unicode():

456

self.divider = "─" # \u2500

457

#self.divider = "━" # \u2501

423

self.divider = u"─" # \u2500

424

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

458

425

else:

459

#self.divider = "-" # \u002d

460

self.divider = "_" # \u005f

426

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

427

self.divider = u"_" # \u005f

461

428

462

429

self.screen.start()

463

430

477

444

# This keeps track of whether self.uilist currently has

478

445

# self.logbox in it or not

479

446

self.log_visible = True

480

self.log_wrap = "any"

447

self.log_wrap = u"any"

481

448

482

449

self.rebuild()

483

self.log_message_raw(("bold",

484

"Mandos Monitor version " + version))

485

self.log_message_raw(("bold",

486

"q: Quit ?: Help"))

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

487

454

488

455

self.busname = domain + '.Mandos'

489

456

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)

490

499

491

500

def client_not_found(self, fingerprint, address):

492

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

493

" {1} could not be found"

494

.format(address, fingerprint))

501

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

502

u" could not be found" % (address,

503

fingerprint)))

495

504

496

505

def rebuild(self):

497

506

"""This rebuilds the User Interface.

507

516

self.divider)))

508

517

if self.log_visible:

509

518

self.uilist.append(self.logbox)

519

pass

510

520

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

511

521

512

522

def log_message(self, message):

513

523

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

514

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

524

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

515

525

516

526

def log_message_raw(self, markup):

517

527

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

520

530

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

521

531

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

522

532

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

523

coming_from="above")

533

coming_from=u"above")

524

534

self.refresh()

525

535

526

536

def toggle_log_display(self):

527

537

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

528

538

self.log_visible = not self.log_visible

529

539

self.rebuild()

530

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

540

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

531

541

# + unicode(self.log_visible))

532

542

533

543

def change_log_display(self):

534

544

"""Change type of log display.

535

545

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

536

if self.log_wrap == "clip":

537

self.log_wrap = "any"

546

if self.log_wrap == u"clip":

547

self.log_wrap = u"any"

538

548

else:

539

self.log_wrap = "clip"

549

self.log_wrap = u"clip"

540

550

for textwidget in self.log:

541

551

textwidget.set_wrap_mode(self.log_wrap)

542

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

552

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

543

553

544

554

def find_and_remove_client(self, path, name):

545

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

555

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

546

556

547

557

This is connected to the ClientRemoved signal from the

548

558

Mandos server object."""

550

560

client = self.clients_dict[path]

551

561

except KeyError:

552

562

# not found?

553

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

554

.format(name, path))

555

563

return

556

client.delete()

564

self.remove_client(client, path)

557

565

558

566

def add_new_client(self, path):

559

567

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

574

582

if path is None:

575

583

path = client.proxy.object_path

576

584

self.clients_dict[path] = client

577

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

585

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

578

586

self.refresh()

579

587

580

588

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

596

604

597

605

def run(self):

598

606

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

642

607

self.refresh()

643

608

self._input_callback_tag = (gobject.io_add_watch

644

609

(sys.stdin.fileno(),

654

619

655

620

def process_input(self, source, condition):

656

621

keys = self.screen.get_input()

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

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

666

631

}

667

632

for key in keys:

668

633

try:

670

635

except KeyError: # :-)

671

636

pass

672

637

673

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

638

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

674

639

self.stop()

675

640

break

676

elif key == "window resize":

641

elif key == u"window resize":

677

642

self.size = self.screen.get_cols_rows()

678

643

self.refresh()

679

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

644

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

680

645

self.refresh()

681

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

646

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

682

647

self.toggle_log_display()

683

648

self.refresh()

684

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

649

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

685

650

self.change_log_display()

686

651

self.refresh()

687

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

652

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

688

653

if not self.log_visible:

689

654

self.log_visible = True

690

655

self.rebuild()

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

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

709

674

self.refresh()

710

elif key == "tab":

675

elif key == u"tab":

711

676

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

712

677

self.topwidget.set_focus(0)

713

678

else:

714

679

self.topwidget.set_focus(self.logbox)

715

680

self.refresh()

716

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

717

# or key == ">"):

681

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

682

# or key == u">"):

718

683

# pass # xxx end-of-buffer

719

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

720

# or key == "<"):

684

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

685

# or key == u"<"):

721

686

# pass # xxx beginning-of-buffer

722

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

687

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

723

688

# pass # xxx move-end-of-line

724

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

689

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

725

690

# pass # xxx move-beginning-of-line

726

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

691

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

727

692

# pass # xxx left

728

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

693

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

729

694

# pass # xxx right

730

#elif key == "a":

695

#elif key == u"a":

731

696

# pass # scroll up log

732

#elif key == "z":

697

#elif key == u"z":

733

698

# pass # scroll down log

734

699

elif self.topwidget.selectable():

735

700

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