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

22

#

23

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

24

#

25

26

from __future__ import (division, absolute_import, print_function,

27

unicode_literals)

28

29

from future_builtins import *

20

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

21

#

22

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

23

#

24

25

from __future__ import division, absolute_import, with_statement

30

26

31

27

import sys

32

28

import os

46

42

47

43

import locale

48

44

49

locale.setlocale(locale.LC_ALL, '')

45

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

50

46

51

47

import logging

52

48

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

53

49

54

50

# Some useful constants

55

domain = 'se.recompile'

51

domain = 'se.bsnet.fukt'

56

52

server_interface = domain + '.Mandos'

57

53

client_interface = domain + '.Mandos.Client'

58

version = "1.5.3"

54

version = "1.2"

59

55

60

56

# Always run in monochrome mode

61

57

urwid.curses_display.curses.has_colors = lambda : False

69

65

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

70

66

if not iso:

71

67

return None

72

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

73

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

74

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)

75

71

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

76

72

return datetime.datetime(int(year),

77

73

int(month),

86

82

properties and calls a hook function when any of them are

87

83

changed.

88

84

"""

89

def __init__(self, proxy_object=None, properties=None, **kwargs):

85

def __init__(self, proxy_object=None, *args, **kwargs):

90

86

self.proxy = proxy_object # Mandos Client proxy object

91

self.properties = dict() if properties is None else properties

92

self.property_changed_match = (

93

self.proxy.connect_to_signal("PropertyChanged",

94

self._property_changed,

95

client_interface,

96

byte_arrays=True))

97

98

if properties is None:

99

self.properties.update(

100

self.proxy.GetAll(client_interface,

101

dbus_interface

102

= dbus.PROPERTIES_IFACE))

103

104

super(MandosClientPropertyCache, self).__init__(**kwargs)

105

106

def _property_changed(self, property, value):

107

"""Helper which takes positional arguments"""

108

return self.property_changed(property=property, value=value)

87

88

self.properties = dict()

89

self.proxy.connect_to_signal(u"PropertyChanged",

90

self.property_changed,

91

client_interface,

92

byte_arrays=True)

93

94

self.properties.update(

95

self.proxy.GetAll(client_interface,

96

dbus_interface = dbus.PROPERTIES_IFACE))

97

98

#XXX This break good super behaviour!

99

# super(MandosClientPropertyCache, self).__init__(

100

# *args, **kwargs)

109

101

110

102

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

111

103

"""This is called whenever we get a PropertyChanged signal

113

105

"""

114

106

# Update properties dict with new value

115

107

self.properties[property] = value

116

117

def delete(self):

118

self.property_changed_match.remove()

119

108

120

109

121

110

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

123

112

"""

124

113

125

114

def __init__(self, server_proxy_object=None, update_hook=None,

126

delete_hook=None, logger=None, **kwargs):

115

delete_hook=None, logger=None, *args, **kwargs):

127

116

# Called on update

128

117

self.update_hook = update_hook

129

118

# Called on delete

135

124

136

125

self._update_timer_callback_tag = None

137

126

self._update_timer_callback_lock = 0

127

self.last_checker_failed = False

138

128

139

129

# The widget shown normally

140

self._text_widget = urwid.Text("")

130

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

141

131

# The widget shown when we have focus

142

self._focus_text_widget = urwid.Text("")

143

super(MandosClientWidget, self).__init__(**kwargs)

132

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

133

super(MandosClientWidget, self).__init__(

134

update_hook=update_hook, delete_hook=delete_hook,

135

*args, **kwargs)

144

136

self.update()

145

137

self.opened = False

146

138

147

139

last_checked_ok = isoformat_to_datetime(self.properties

148

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

149

150

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

151

if self.last_checker_failed:

151

152

self.using_timer(True)

152

153

154

if self.need_approval:

154

155

self.using_timer(True)

155

156

self.match_objects = (

157

self.proxy.connect_to_signal("CheckerCompleted",

158

self.checker_completed,

159

client_interface,

160

byte_arrays=True),

161

self.proxy.connect_to_signal("CheckerStarted",

162

self.checker_started,

163

client_interface,

164

byte_arrays=True),

165

self.proxy.connect_to_signal("GotSecret",

166

self.got_secret,

167

client_interface,

168

byte_arrays=True),

169

self.proxy.connect_to_signal("NeedApproval",

170

self.need_approval,

171

client_interface,

172

byte_arrays=True),

173

self.proxy.connect_to_signal("Rejected",

174

self.rejected,

175

client_interface,

176

byte_arrays=True))

177

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

178

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

179

177

180

178

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

181

179

super(self, MandosClientWidget).property_changed(property,

182

180

value)

183

if property == "ApprovalPending":

181

if property == u"ApprovalPending":

184

182

using_timer(bool(value))

185

if property == "LastCheckerStatus":

186

using_timer(value != 0)

187

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

188

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

189

# command))

190

183

191

184

def using_timer(self, flag):

192

185

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

193

186

activated or deactivated.

198

191

else:

199

192

self._update_timer_callback_lock -= 1

200

193

if old == 0 and self._update_timer_callback_lock:

201

# Will update the shown timer value every second

202

194

self._update_timer_callback_tag = (gobject.timeout_add

203

195

(1000,

204

196

self.update_timer))

208

200

209

201

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

210

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

211

209

self.update()

212

210

return

213

211

# Checker failed

212

if not self.last_checker_failed:

213

self.last_checker_failed = True

214

self.using_timer(True)

214

215

if os.WIFEXITED(condition):

215

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

216

' failed with exit code {2}'

217

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

218

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

219

220

elif os.WIFSIGNALED(condition):

220

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

221

' killed by signal {2}'

222

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

223

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

224

225

elif os.WCOREDUMP(condition):

225

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

226

' dumped core'

227

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

228

229

else:

229

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

230

' mysteriously'

231

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

230

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

231

u' mysteriously')

232

self.update()

233

234

def checker_started(self, command):

235

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

236

to log in the future. """

237

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

238

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

239

# unicode(command)))

235

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

236

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

240

237

pass

241

238

242

239

def got_secret(self):

243

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

244

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

240

self.last_checker_failed = False

241

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

242

% self.properties[u"Name"])

245

243

246

244

def need_approval(self, timeout, default):

247

245

if not default:

248

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

246

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

249

247

else:

250

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

251

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

252

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

253

251

self.using_timer(True)

254

252

255

253

def rejected(self, reason):

256

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

257

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

254

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

255

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

258

256

259

257

def selectable(self):

260

258

"""Make this a "selectable" widget.

261

259

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

262

260

return True

263

261

264

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

262

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

265

263

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

266

264

whether we have focus or not.

267

265

This overrides the method from urwid.FlowWidget"""

268

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

266

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

269

267

270

268

def current_widget(self, focus=False):

271

269

if focus or self.opened:

275

273

def update(self):

276

274

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

277

275

# How to add standout mode to a style

278

with_standout = { "normal": "standout",

279

"bold": "bold-standout",

280

"underline-blink":

281

"underline-blink-standout",

282

"bold-underline-blink":

283

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

284

282

}

285

283

286

284

# Rebuild focus and non-focus widgets using current properties

287

285

288

286

# Base part of a client. Name!

289

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

290

if not self.properties["Enabled"]:

291

message = "DISABLED"

292

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

293

292

timeout = datetime.timedelta(milliseconds

294

293

= self.properties

295

["ApprovalDelay"])

294

[u"ApprovalDelay"])

296

295

last_approval_request = isoformat_to_datetime(

297

self.properties["LastApprovalRequest"])

296

self.properties[u"LastApprovalRequest"])

298

297

if last_approval_request is not None:

299

298

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

300

299

- last_approval_request)

301

300

else:

302

301

timer = datetime.timedelta()

303

if self.properties["ApprovedByDefault"]:

304

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

305

else:

306

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

307

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

308

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

309

# When checker has failed, show timer until client expires

310

expires = self.properties["Expires"]

311

if expires == "":

312

timer = datetime.timedelta(0)

313

else:

314

expires = (datetime.datetime.strptime

315

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

316

timer = expires - datetime.datetime.utcnow()

317

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

318

' gets disabled: {0}'

319

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

320

319

else:

321

message = "enabled"

322

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

320

message = u"enabled"

321

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

323

322

324

323

if not urwid.supports_unicode():

325

324

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

326

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

325

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

327

326

self._text_widget.set_text(textlist)

328

327

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

329

328

text[1])

338

337

self.update_hook()

339

338

340

339

def update_timer(self):

341

"""called by gobject. Will indefinitely loop until

342

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

340

"called by gobject"

343

341

self.update()

344

342

return True # Keep calling this

345

343

346

def delete(self, **kwargs):

344

def delete(self):

347

345

if self._update_timer_callback_tag is not None:

348

346

gobject.source_remove(self._update_timer_callback_tag)

349

347

self._update_timer_callback_tag = None

350

for match in self.match_objects:

351

match.remove()

352

self.match_objects = ()

353

348

if self.delete_hook is not None:

354

349

self.delete_hook(self)

355

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

356

350

357

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

351

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

358

352

"""Render differently if we have focus.

359

353

This overrides the method from urwid.FlowWidget"""

360

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

354

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

361

355

focus=focus)

362

356

363

def keypress(self, maxcolrow, key):

357

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

364

358

"""Handle keys.

365

359

This overrides the method from urwid.FlowWidget"""

366

if key == "+":

367

self.proxy.Enable(dbus_interface = client_interface,

368

ignore_reply=True)

369

elif key == "-":

370

self.proxy.Disable(dbus_interface = client_interface,

371

ignore_reply=True)

372

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

373

365

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

374

dbus_interface = client_interface,

375

ignore_reply=True)

376

elif key == "d":

366

dbus_interface = client_interface)

367

elif key == u"d":

377

368

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

378

dbus_interface = client_interface,

379

ignore_reply=True)

380

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

381

371

self.server_proxy_object.RemoveClient(self.proxy

382

.object_path,

383

ignore_reply=True)

384

elif key == "s":

385

self.proxy.StartChecker(dbus_interface = client_interface,

386

ignore_reply=True)

387

elif key == "S":

388

self.proxy.StopChecker(dbus_interface = client_interface,

389

ignore_reply=True)

390

elif key == "C":

391

self.proxy.CheckedOK(dbus_interface = client_interface,

392

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)

393

379

# xxx

394

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

380

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

395

381

# self.proxy.pause()

396

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

382

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

397

383

# self.proxy.unpause()

398

# elif key == "RET":

384

# elif key == u"RET":

399

385

# self.open()

400

386

else:

401

387

return key

402

388

403

def property_changed(self, property=None, **kwargs):

389

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

390

*args, **kwargs):

404

391

"""Call self.update() if old value is not new value.

405

392

This overrides the method from MandosClientPropertyCache"""

406

393

property_name = unicode(property)

407

394

old_value = self.properties.get(property_name)

408

395

super(MandosClientWidget, self).property_changed(

409

property=property, **kwargs)

396

property=property, value=value, *args, **kwargs)

410

397

if self.properties.get(property_name) != old_value:

411

398

self.update()

412

399

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, *args, **kwargs):

420

ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)

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)