/mandos/trunk : revision 572

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 <http://www.gnu.org/licenses/>.

20

# along with this program. If not, see

21

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

21

22

#

22

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

23

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

23

24

#

24

25

from __future__ import division, absolute_import, with_statement

26

from __future__ import (division, absolute_import, print_function,

27

unicode_literals)

26

28

27

29

import sys

28

30

import os

42

44

43

45

import locale

44

46

45

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

47

locale.setlocale(locale.LC_ALL, '')

46

48

47

49

import logging

48

50

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

49

51

50

52

# Some useful constants

51

domain = 'se.bsnet.fukt'

53

domain = 'se.recompile'

52

54

server_interface = domain + '.Mandos'

53

55

client_interface = domain + '.Mandos.Client'

54

version = "1.0.15"

56

version = "1.5.3"

55

57

56

58

# Always run in monochrome mode

57

59

urwid.curses_display.curses.has_colors = lambda : False

65

67

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

66

68

if not iso:

67

69

return None

68

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

69

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

70

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)

71

73

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

72

74

return datetime.datetime(int(year),

73

75

int(month),

86

88

self.proxy = proxy_object # Mandos Client proxy object

87

89

88

90

self.properties = dict()

89

self.proxy.connect_to_signal(u"PropertyChanged",

90

self.property_changed,

91

client_interface,

92

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

93

96

94

97

self.properties.update(

95

98

self.proxy.GetAll(client_interface,

96

99

dbus_interface = dbus.PROPERTIES_IFACE))

97

100

98

#XXX This break good super behaviour!

101

#XXX This breaks good super behaviour

99

102

# super(MandosClientPropertyCache, self).__init__(

100

103

# *args, **kwargs)

101

104

105

108

"""

106

109

# Update properties dict with new value

107

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)

108

116

109

117

110

118

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

124

132

125

133

self._update_timer_callback_tag = None

126

134

self._update_timer_callback_lock = 0

127

self.last_checker_failed = False

128

135

129

136

# The widget shown normally

130

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

137

self._text_widget = urwid.Text("")

131

138

# The widget shown when we have focus

132

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

139

self._focus_text_widget = urwid.Text("")

133

140

super(MandosClientWidget, self).__init__(

134

141

update_hook=update_hook, delete_hook=delete_hook,

135

142

*args, **kwargs)

137

144

self.opened = False

138

145

139

146

last_checked_ok = isoformat_to_datetime(self.properties

140

[u"LastCheckedOK"])

141

if last_checked_ok is None:

142

self.last_checker_failed = True

143

else:

144

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

145

- last_checked_ok)

146

> datetime.timedelta

147

(milliseconds=

148

self.properties

149

[u"Interval"]))

147

["LastCheckedOK"])

150

148

151

if self.last_checker_failed:

149

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

152

150

self.using_timer(True)

153

151

154

152

if self.need_approval:

155

153

self.using_timer(True)

156

154

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)

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

177

178

179

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

179

180

super(self, MandosClientWidget).property_changed(property,

180

181

value)

181

if property == u"ApprovalPending":

182

if property == "ApprovalPending":

182

183

using_timer(bool(value))

183

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

184

190

def using_timer(self, flag):

185

191

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

186

192

activated or deactivated.

191

197

else:

192

198

self._update_timer_callback_lock -= 1

193

199

if old == 0 and self._update_timer_callback_lock:

200

# Will update the shown timer value every second

194

201

self._update_timer_callback_tag = (gobject.timeout_add

195

202

(1000,

196

203

self.update_timer))

200

207

201

208

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

202

209

if exitstatus == 0:

203

if self.last_checker_failed:

204

self.last_checker_failed = False

205

self.using_timer(False)

206

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

207

# u' was successful'

208

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

209

210

self.update()

210

211

return

211

212

# Checker failed

212

if not self.last_checker_failed:

213

self.last_checker_failed = True

214

self.using_timer(True)

215

213

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

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

220

218

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

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

225

223

elif os.WCOREDUMP(condition):

226

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

227

u' dumped core'

228

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

224

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

225

' dumped core'

226

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

229

227

else:

230

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

231

u' mysteriously')

228

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

229

' mysteriously'

230

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

232

231

self.update()

233

232

234

233

def checker_started(self, command):

235

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

236

# % (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)))

237

239

pass

238

240

239

241

def got_secret(self):

240

self.last_checker_failed = False

241

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

242

% self.properties[u"Name"])

242

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

243

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

243

244

245

def need_approval(self, timeout, default):

245

246

if not default:

246

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

247

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

247

248

else:

248

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

249

self.logger(message

250

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

251

252

self.using_timer(True)

252

253

254

def rejected(self, reason):

254

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

255

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

255

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

256

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

256

257

258

def selectable(self):

258

259

"""Make this a "selectable" widget.

259

260

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

260

261

return True

261

262

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

263

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

263

264

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

264

265

whether we have focus or not.

265

266

This overrides the method from urwid.FlowWidget"""

266

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

267

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

267

268

269

def current_widget(self, focus=False):

269

270

if focus or self.opened:

273

274

def update(self):

274

275

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

275

276

# How to add standout mode to a style

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

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

282

283

}

283

284

285

# Rebuild focus and non-focus widgets using current properties

285

286

287

# Base part of a client. Name!

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

288

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

289

if not self.properties["Enabled"]:

290

message = "DISABLED"

291

elif self.properties["ApprovalPending"]:

292

timeout = datetime.timedelta(milliseconds

293

= self.properties

294

[u"ApprovalDelay"])

294

["ApprovalDelay"])

295

last_approval_request = isoformat_to_datetime(

296

self.properties[u"LastApprovalRequest"])

296

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

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

319

else:

320

message = u"enabled"

321

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

320

message = "enabled"

321

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

322

323

if not urwid.supports_unicode():

324

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

325

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

325

textlist = [("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"

340

"""called by gobject. Will indefinitely loop until

341

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

341

342

self.update()

342

343

return True # Keep calling this

343

344

def delete(self):

345

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

345

346

if self._update_timer_callback_tag is not None:

346

347

gobject.source_remove(self._update_timer_callback_tag)

347

348

self._update_timer_callback_tag = None

349

for match in self.match_objects:

350

match.remove()

351

self.match_objects = ()

348

352

if self.delete_hook is not None:

349

353

self.delete_hook(self)

354

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

350

355

351

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

356

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

352

357

"""Render differently if we have focus.

353

358

This overrides the method from urwid.FlowWidget"""

354

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

359

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

355

360

focus=focus)

356

361

357

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

362

def keypress(self, maxcolrow, key):

358

363

"""Handle keys.

359

364

This overrides the method from urwid.FlowWidget"""

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

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

365

372

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

366

dbus_interface = client_interface)

367

elif key == u"d":

373

dbus_interface = client_interface,

374

ignore_reply=True)

375

elif key == "d":

368

376

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

369

dbus_interface = client_interface)

370

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

371

380

self.server_proxy_object.RemoveClient(self.proxy

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)

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)

379

392

# xxx

380

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

393

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

381

394

# self.proxy.pause()

382

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

395

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

383

396

# self.proxy.unpause()

384

# elif key == u"RET":

397

# elif key == "RET":

385

398

# self.open()

386

399

else:

387

400

return key

403

416

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

404

417

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

405

418

"""

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

419

def keypress(self, maxcolrow, key):

420

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

421

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

410

422

return

411

423

return ret

412

424

421

433

self.screen = urwid.curses_display.Screen()

422

434

423

435

self.screen.register_palette((

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

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

441

453

))

442

454

443

455

if urwid.supports_unicode():

444

self.divider = u"─" # \u2500

445

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

456

self.divider = "─" # \u2500

457

#self.divider = "━" # \u2501

446

458

else:

447

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

448

self.divider = u"_" # \u005f

459

#self.divider = "-" # \u002d

460

self.divider = "_" # \u005f

449

461

450

462

self.screen.start()

451

463

465

477

# This keeps track of whether self.uilist currently has

466

478

# self.logbox in it or not

467

479

self.log_visible = True

468

self.log_wrap = u"any"

480

self.log_wrap = "any"

469

481

470

482

self.rebuild()

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

483

self.log_message_raw(("bold",

484

"Mandos Monitor version " + version))

485

self.log_message_raw(("bold",

486

"q: Quit ?: Help"))

475

487

476

488

self.busname = domain + '.Mandos'

477

489

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)

520

490

521

491

def client_not_found(self, fingerprint, address):

522

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

523

u" could not be found" % (address,

524

fingerprint)))

492

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

493

" {1} could not be found"

494

.format(address, fingerprint))

525

495

526

496

def rebuild(self):

527

497

"""This rebuilds the User Interface.

537

507

self.divider)))

538

508

if self.log_visible:

539

509

self.uilist.append(self.logbox)

540

pass

541

510

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

542

511

543

512

def log_message(self, message):

544

513

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

545

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

514

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

546

515

547

516

def log_message_raw(self, markup):

548

517

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

551

520

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

552

521

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

553

522

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

554

coming_from=u"above")

523

coming_from="above")

555

524

self.refresh()

556

525

557

526

def toggle_log_display(self):

558

527

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

559

528

self.log_visible = not self.log_visible

560

529

self.rebuild()

561

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

530

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

562

531

# + unicode(self.log_visible))

563

532

564

533

def change_log_display(self):

565

534

"""Change type of log display.

566

535

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

567

if self.log_wrap == u"clip":

568

self.log_wrap = u"any"

536

if self.log_wrap == "clip":

537

self.log_wrap = "any"

569

538

else:

570

self.log_wrap = u"clip"

539

self.log_wrap = "clip"

571

540

for textwidget in self.log:

572

541

textwidget.set_wrap_mode(self.log_wrap)

573

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

542

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

574

543

575

544

def find_and_remove_client(self, path, name):

576

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

545

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

577

546

578

547

This is connected to the ClientRemoved signal from the

579

548

Mandos server object."""

581

550

client = self.clients_dict[path]

582

551

except KeyError:

583

552

# not found?

553

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

554

.format(name, path))

584

555

return

585

self.remove_client(client, path)

556

client.delete()

586

557

587

558

def add_new_client(self, path):

588

559

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

603

574

if path is None:

604

575

path = client.proxy.object_path

605

576

self.clients_dict[path] = client

606

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

577

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

607

578

self.refresh()

608

579

609

580

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

625

596

626

597

def run(self):

627

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

628

642

self.refresh()

629

643

self._input_callback_tag = (gobject.io_add_watch

630

644

(sys.stdin.fileno(),

640

654

641

655

def process_input(self, source, condition):

642

656

keys = self.screen.get_input()

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

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

652

666

}

653

667

for key in keys:

654

668

try:

656

670

except KeyError: # :-)

657

671

pass

658

672

659

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

673

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

660

674

self.stop()

661

675

break

662

elif key == u"window resize":

676

elif key == "window resize":

663

677

self.size = self.screen.get_cols_rows()

664

678

self.refresh()

665

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

679

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

666

680

self.refresh()

667

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

681

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

668

682

self.toggle_log_display()

669

683

self.refresh()

670

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

684

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

671

685

self.change_log_display()

672

686

self.refresh()

673

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

687

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

674

688

if not self.log_visible:

675

689

self.log_visible = True

676

690

self.rebuild()

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

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

695

709

self.refresh()

696

elif key == u"tab":

710

elif key == "tab":

697

711

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

698

712

self.topwidget.set_focus(0)

699

713

else:

700

714

self.topwidget.set_focus(self.logbox)

701

715

self.refresh()

702

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

703

# or key == u">"):

716

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

717

# or key == ">"):

704

718

# pass # xxx end-of-buffer

705

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

706

# or key == u"<"):

719

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

720

# or key == "<"):

707

721

# pass # xxx beginning-of-buffer

708

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

722

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

709

723

# pass # xxx move-end-of-line

710

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

724

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

711

725

# pass # xxx move-beginning-of-line

712

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

726

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

713

727

# pass # xxx left

714

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

728

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

715

729

# pass # xxx right

716

#elif key == u"a":

730

#elif key == "a":

717

731

# pass # scroll up log

718

#elif key == u"z":

732

#elif key == "z":

719

733

# pass # scroll down log

720

734

elif self.topwidget.selectable():

721

735

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