/mandos/trunk : revision 452.1.1

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

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/>.

20

# along with this program. If not, see <http://www.gnu.org/licenses/>.

22

21

#

23

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

22

# Contact the authors at <mandos@fukt.bsnet.se>.

24

23

#

25

24

26

from __future__ import (division, absolute_import, print_function,

27

unicode_literals)

25

from __future__ import division, absolute_import, with_statement

28

26

29

27

import sys

30

28

import os

44

42

45

43

import locale

46

44

47

locale.setlocale(locale.LC_ALL, '')

45

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

48

46

49

47

import logging

50

48

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

51

49

52

50

# Some useful constants

53

domain = 'se.recompile'

51

domain = 'se.bsnet.fukt'

54

52

server_interface = domain + '.Mandos'

55

53

client_interface = domain + '.Mandos.Client'

56

version = "1.5.3"

54

version = "1.2"

57

55

58

56

# Always run in monochrome mode

59

57

urwid.curses_display.curses.has_colors = lambda : False

67

65

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

68

66

if not iso:

69

67

return None

70

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

71

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

72

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)

73

71

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

74

72

return datetime.datetime(int(year),

75

73

int(month),

88

86

self.proxy = proxy_object # Mandos Client proxy object

89

87

90

88

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

89

self.proxy.connect_to_signal(u"PropertyChanged",

90

self.property_changed,

91

client_interface,

92

byte_arrays=True)

96

93

97

94

self.properties.update(

98

95

self.proxy.GetAll(client_interface,

99

96

dbus_interface = dbus.PROPERTIES_IFACE))

100

97

101

#XXX This breaks good super behaviour

98

#XXX This break good super behaviour!

102

99

# super(MandosClientPropertyCache, self).__init__(

103

100

# *args, **kwargs)

104

101

108

105

"""

109

106

# Update properties dict with new value

110

107

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

108

117

109

118

110

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

132

124

133

125

self._update_timer_callback_tag = None

134

126

self._update_timer_callback_lock = 0

127

self.last_checker_failed = False

135

128

136

129

# The widget shown normally

137

self._text_widget = urwid.Text("")

130

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

138

131

# The widget shown when we have focus

139

self._focus_text_widget = urwid.Text("")

132

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

140

133

super(MandosClientWidget, self).__init__(

141

134

update_hook=update_hook, delete_hook=delete_hook,

142

135

*args, **kwargs)

144

137

self.opened = False

145

138

146

139

last_checked_ok = isoformat_to_datetime(self.properties

147

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

148

150

149

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

151

if self.last_checker_failed:

150

152

self.using_timer(True)

151

153

152

154

if self.need_approval:

153

155

self.using_timer(True)

154

156

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

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)

178

177

179

178

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

180

179

super(self, MandosClientWidget).property_changed(property,

181

180

value)

182

if property == "ApprovalPending":

181

if property == u"ApprovalPending":

183

182

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

183

190

184

def using_timer(self, flag):

191

185

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

192

186

activated or deactivated.

197

191

else:

198

192

self._update_timer_callback_lock -= 1

199

193

if old == 0 and self._update_timer_callback_lock:

200

# Will update the shown timer value every second

201

194

self._update_timer_callback_tag = (gobject.timeout_add

202

195

(1000,

203

196

self.update_timer))

207

200

208

201

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

209

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

210

209

self.update()

211

210

return

212

211

# Checker failed

212

if not self.last_checker_failed:

213

self.last_checker_failed = True

214

self.using_timer(True)

213

215

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

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

218

220

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

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

223

225

elif os.WCOREDUMP(condition):

224

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

225

' dumped core'

226

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

227

229

else:

228

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

229

' mysteriously'

230

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

230

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

231

u' mysteriously')

231

232

self.update()

232

233

234

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

235

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

236

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

239

237

pass

240

238

241

239

def got_secret(self):

242

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

243

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

240

self.last_checker_failed = False

241

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

242

% self.properties[u"Name"])

244

243

245

244

def need_approval(self, timeout, default):

246

245

if not default:

247

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

246

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

248

247

else:

249

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

250

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

251

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

252

251

self.using_timer(True)

253

252

254

253

def rejected(self, reason):

255

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

256

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

254

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

255

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

257

256

258

257

def selectable(self):

259

258

"""Make this a "selectable" widget.

260

259

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

261

260

return True

262

261

263

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

262

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

264

263

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

265

264

whether we have focus or not.

266

265

This overrides the method from urwid.FlowWidget"""

267

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

266

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

268

267

269

268

def current_widget(self, focus=False):

270

269

if focus or self.opened:

274

273

def update(self):

275

274

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

276

275

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

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

283

282

}

284

283

285

284

# Rebuild focus and non-focus widgets using current properties

286

285

287

286

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

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

292

timeout = datetime.timedelta(milliseconds

293

= self.properties

294

["ApprovalDelay"])

294

[u"ApprovalDelay"])

295

last_approval_request = isoformat_to_datetime(

296

self.properties["LastApprovalRequest"])

296

self.properties[u"LastApprovalRequest"])

297

if last_approval_request is not None:

298

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

299

- last_approval_request)

300

else:

301

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

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

319

else:

320

message = "enabled"

321

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

320

message = u"enabled"

321

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

322

323

if not urwid.supports_unicode():

324

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

325

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

325

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

326

self._text_widget.set_text(textlist)

327

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

328

text[1])

337

self.update_hook()

338

339

def update_timer(self):

340

"""called by gobject. Will indefinitely loop until

341

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

340

"called by gobject"

342

341

self.update()

343

342

return True # Keep calling this

344

343

345

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

344

def delete(self):

346

345

if self._update_timer_callback_tag is not None:

347

346

gobject.source_remove(self._update_timer_callback_tag)

348

347

self._update_timer_callback_tag = None

349

for match in self.match_objects:

350

match.remove()

351

self.match_objects = ()

352

348

if self.delete_hook is not None:

353

349

self.delete_hook(self)

354

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

355

350

356

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

351

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

357

352

"""Render differently if we have focus.

358

353

This overrides the method from urwid.FlowWidget"""

359

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

354

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

360

355

focus=focus)

361

356

362

def keypress(self, maxcolrow, key):

357

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

363

358

"""Handle keys.

364

359

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

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

372

365

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

373

dbus_interface = client_interface,

374

ignore_reply=True)

375

elif key == "d":

366

dbus_interface = client_interface)

367

elif key == u"d":

376

368

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

369

dbus_interface = client_interface)

370

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

380

371

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)

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)

392

379

# xxx

393

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

380

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

394

381

# self.proxy.pause()

395

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

382

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

396

383

# self.proxy.unpause()

397

# elif key == "RET":

384

# elif key == u"RET":

398

385

# self.open()

399

386

else:

400

387

return key

416

403

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

417

404

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

418

405

"""

419

def keypress(self, maxcolrow, key):

420

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

421

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

422

410

return

423

411

return ret

424

412

433

421

self.screen = urwid.curses_display.Screen()

434

422

435

423

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

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

453

441

))

454

442

455

443

if urwid.supports_unicode():

456

self.divider = "─" # \u2500

457

#self.divider = "━" # \u2501

444

self.divider = u"─" # \u2500

445

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

458

446

else:

459

#self.divider = "-" # \u002d

460

self.divider = "_" # \u005f

447

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

448

self.divider = u"_" # \u005f

461

449

462

450

self.screen.start()

463

451

477

465

# This keeps track of whether self.uilist currently has

478

466

# self.logbox in it or not

479

467

self.log_visible = True

480

self.log_wrap = "any"

468

self.log_wrap = u"any"

481

469

482

470

self.rebuild()

483

self.log_message_raw(("bold",

484

"Mandos Monitor version " + version))

485

self.log_message_raw(("bold",

486

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

487

475

488

476

self.busname = domain + '.Mandos'

489

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)

490

520

491

521

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

522

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

523

u" could not be found" % (address,

524

fingerprint)))

495

525

496

526

def rebuild(self):

497

527

"""This rebuilds the User Interface.

507

537

self.divider)))

508

538

if self.log_visible:

509

539

self.uilist.append(self.logbox)

540

pass

510

541

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

511

542

512

543

def log_message(self, message):

513

544

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

514

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

545

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

515

546

516

547

def log_message_raw(self, markup):

517

548

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

520

551

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

521

552

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

522

553

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

523

coming_from="above")

554

coming_from=u"above")

524

555

self.refresh()

525

556

526

557

def toggle_log_display(self):

527

558

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

528

559

self.log_visible = not self.log_visible

529

560

self.rebuild()

530

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

561

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

531

562

# + unicode(self.log_visible))

532

563

533

564

def change_log_display(self):

534

565

"""Change type of log display.

535

566

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

536

if self.log_wrap == "clip":

537

self.log_wrap = "any"

567

if self.log_wrap == u"clip":

568

self.log_wrap = u"any"

538

569

else:

539

self.log_wrap = "clip"

570

self.log_wrap = u"clip"

540

571

for textwidget in self.log:

541

572

textwidget.set_wrap_mode(self.log_wrap)

542

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

573

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

543

574

544

575

def find_and_remove_client(self, path, name):

545

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

576

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

546

577

547

578

This is connected to the ClientRemoved signal from the

548

579

Mandos server object."""

550

581

client = self.clients_dict[path]

551

582

except KeyError:

552

583

# not found?

553

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

554

.format(name, path))

555

584

return

556

client.delete()

585

self.remove_client(client, path)

557

586

558

587

def add_new_client(self, path):

559

588

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

574

603

if path is None:

575

604

path = client.proxy.object_path

576

605

self.clients_dict[path] = client

577

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

606

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

578

607

self.refresh()

579

608

580

609

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

596

625

597

626

def run(self):

598

627

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

628

self.refresh()

643

629

self._input_callback_tag = (gobject.io_add_watch

644

630

(sys.stdin.fileno(),

654

640

655

641

def process_input(self, source, condition):

656

642

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

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

666

652

}

667

653

for key in keys:

668

654

try:

670

656

except KeyError: # :-)

671

657

pass

672

658

673

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

659

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

674

660

self.stop()

675

661

break

676

elif key == "window resize":

662

elif key == u"window resize":

677

663

self.size = self.screen.get_cols_rows()

678

664

self.refresh()

679

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

665

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

680

666

self.refresh()

681

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

667

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

682

668

self.toggle_log_display()

683

669

self.refresh()

684

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

670

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

685

671

self.change_log_display()

686

672

self.refresh()

687

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

673

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

688

674

if not self.log_visible:

689

675

self.log_visible = True

690

676

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

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

709

695

self.refresh()

710

elif key == "tab":

696

elif key == u"tab":

711

697

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

712

698

self.topwidget.set_focus(0)

713

699

else:

714

700

self.topwidget.set_focus(self.logbox)

715

701

self.refresh()

716

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

717

# or key == ">"):

702

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

703

# or key == u">"):

718

704

# pass # xxx end-of-buffer

719

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

720

# or key == "<"):

705

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

706

# or key == u"<"):

721

707

# pass # xxx beginning-of-buffer

722

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

708

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

723

709

# pass # xxx move-end-of-line

724

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

710

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

725

711

# pass # xxx move-beginning-of-line

726

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

712

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

727

713

# pass # xxx left

728

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

714

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

729

715

# pass # xxx right

730

#elif key == "a":

716

#elif key == u"a":

731

717

# pass # scroll up log

732

#elif key == "z":

718

#elif key == u"z":

733

719

# pass # scroll down log

734

720

elif self.topwidget.selectable():

735

721

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