/mandos/release : revision 237.2.179

23

24

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

25

26

import logging

27

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

28

29

26

# Some useful constants

30

27

domain = 'se.bsnet.fukt'

31

28

server_interface = domain + '.Mandos'

32

29

client_interface = domain + '.Mandos.Client'

33

version = "1.0.15"

30

version = "1.0.14"

34

31

35

32

# Always run in monochrome mode

36

33

urwid.curses_display.curses.has_colors = lambda : False

40

37

urwid.curses_display.curses.A_UNDERLINE |= (

41

38

urwid.curses_display.curses.A_BLINK)

42

39

43

def isoformat_to_datetime(iso):

44

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

45

if not iso:

46

return None

47

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

48

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

49

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

50

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

51

return datetime.datetime(int(year),

52

int(month),

53

int(day),

54

int(hour),

55

int(minute),

56

int(second), # Whole seconds

57

int(fraction*1000000)) # Microseconds

58

59

40

class MandosClientPropertyCache(object):

60

41

"""This wraps a Mandos Client D-Bus proxy object, caches the

61

42

properties and calls a hook function when any of them are

69

50

self.property_changed,

70

51

client_interface,

71

52

byte_arrays=True)

72

53

73

54

self.properties.update(

74

55

self.proxy.GetAll(client_interface,

75

56

dbus_interface = dbus.PROPERTIES_IFACE))

76

77

#XXX This break good super behaviour!

78

# super(MandosClientPropertyCache, self).__init__(

79

# *args, **kwargs)

57

super(MandosClientPropertyCache, self).__init__(

58

proxy_object=proxy_object, *args, **kwargs)

80

59

81

60

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

82

61

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

101

80

# Logger

102

81

self.logger = logger

103

82

104

self._update_timer_callback_tag = None

105

self._update_timer_callback_lock = 0

106

self.last_checker_failed = False

107

108

83

# The widget shown normally

109

84

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

110

85

# The widget shown when we have focus

114

89

*args, **kwargs)

115

90

self.update()

116

91

self.opened = False

117

118

last_checked_ok = isoformat_to_datetime(self.properties

119

[u"LastCheckedOK"])

120

if last_checked_ok is None:

121

self.last_checker_failed = True

122

else:

123

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

124

- last_checked_ok)

125

> datetime.timedelta

126

(milliseconds=

127

self.properties

128

[u"Interval"]))

129

130

if self.last_checker_failed:

131

self.using_timer(True)

132

133

if self.need_approval:

134

self.using_timer(True)

135

136

92

self.proxy.connect_to_signal(u"CheckerCompleted",

137

93

self.checker_completed,

138

94

client_interface,

145

101

self.got_secret,

146

102

client_interface,

147

103

byte_arrays=True)

148

self.proxy.connect_to_signal(u"NeedApproval",

149

self.need_approval,

150

client_interface,

151

byte_arrays=True)

152

104

self.proxy.connect_to_signal(u"Rejected",

153

105

self.rejected,

154

106

client_interface,

155

107

byte_arrays=True)

156

108

157

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

158

super(self, MandosClientWidget).property_changed(property,

159

value)

160

if property == u"ApprovalPending":

161

using_timer(bool(value))

162

163

def using_timer(self, flag):

164

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

165

activated or deactivated.

166

"""

167

old = self._update_timer_callback_lock

168

if flag:

169

self._update_timer_callback_lock += 1

170

else:

171

self._update_timer_callback_lock -= 1

172

if old == 0 and self._update_timer_callback_lock:

173

self._update_timer_callback_tag = (gobject.timeout_add

174

(1000,

175

self.update_timer))

176

elif old and self._update_timer_callback_lock == 0:

177

gobject.source_remove(self._update_timer_callback_tag)

178

self._update_timer_callback_tag = None

179

180

109

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

181

110

if exitstatus == 0:

182

if self.last_checker_failed:

183

self.last_checker_failed = False

184

self.using_timer(False)

185

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

186

# u' was successful'

187

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

188

self.update()

111

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

112

u' was successful'

113

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

189

114

return

190

# Checker failed

191

if not self.last_checker_failed:

192

self.last_checker_failed = True

193

self.using_timer(True)

194

115

if os.WIFEXITED(condition):

195

116

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

196

117

u' failed with exit code %s'

197

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

118

% (self.properties[u"name"], command,

198

119

os.WEXITSTATUS(condition)))

199

elif os.WIFSIGNALED(condition):

120

return

121

if os.WIFSIGNALED(condition):

200

122

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

201

123

u' was killed by signal %s'

202

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

124

% (self.properties[u"name"], command,

203

125

os.WTERMSIG(condition)))

204

elif os.WCOREDUMP(condition):

126

return

127

if os.WCOREDUMP(condition):

205

128

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

206

129

u' dumped core'

207

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

208

else:

209

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

210

u' mysteriously')

211

self.update()

130

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

131

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

212

132

213

133

def checker_started(self, command):

214

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

215

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

216

pass

134

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

135

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

217

136

218

137

def got_secret(self):

219

self.last_checker_failed = False

220

138

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

221

% self.properties[u"Name"])

222

223

def need_approval(self, timeout, default):

224

if not default:

225

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

226

else:

227

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

228

self.logger(message

229

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

230

self.using_timer(True)

231

232

def rejected(self, reason):

233

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

234

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

139

% self.properties[u"name"])

140

141

def rejected(self):

142

self.logger(u'Client %s was rejected'

143

% self.properties[u"name"])

235

144

236

145

def selectable(self):

237

146

"""Make this a "selectable" widget.

259

168

u"bold-underline-blink":

260

169

u"bold-underline-blink-standout",

261

170

}

262

171

263

172

# Rebuild focus and non-focus widgets using current properties

264

265

# Base part of a client. Name!

266

base = (u'%(name)s: '

267

% {u"name": self.properties[u"Name"]})

268

if not self.properties[u"Enabled"]:

269

message = u"DISABLED"

270

elif self.properties[u"ApprovalPending"]:

271

timeout = datetime.timedelta(milliseconds

272

= self.properties

273

[u"ApprovalDelay"])

274

last_approval_request = isoformat_to_datetime(

275

self.properties[u"LastApprovalRequest"])

276

if last_approval_request is not None:

277

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

278

- last_approval_request)

279

else:

280

timer = datetime.timedelta()

281

if self.properties[u"ApprovedByDefault"]:

282

message = u"Approval in %s. (d)eny?"

283

else:

284

message = u"Denial in %s. (a)pprove?"

285

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

286

elif self.last_checker_failed:

287

timeout = datetime.timedelta(milliseconds

288

= self.properties

289

[u"Timeout"])

290

last_ok = isoformat_to_datetime(

291

max((self.properties[u"LastCheckedOK"]

292

or self.properties[u"Created"]),

293

self.properties[u"LastEnabled"]))

294

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

295

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

296

u' gets disabled: %s'

297

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

298

else:

299

message = u"enabled"

300

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

301

173

self._text = (u'%(name)s: %(enabled)s'

174

% { u"name": self.properties[u"name"],

175

u"enabled":

176

(u"enabled"

177

if self.properties[u"enabled"]

178

else u"DISABLED")})

302

179

if not urwid.supports_unicode():

303

180

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

304

181

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

315

192

if self.update_hook is not None:

316

193

self.update_hook()

317

194

318

def update_timer(self):

319

"called by gobject"

320

self.update()

321

return True # Keep calling this

322

323

195

def delete(self):

324

if self._update_timer_callback_tag is not None:

325

gobject.source_remove(self._update_timer_callback_tag)

326

self._update_timer_callback_tag = None

327

196

if self.delete_hook is not None:

328

197

self.delete_hook(self)

329

198

336

205

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

337

206

"""Handle keys.

338

207

This overrides the method from urwid.FlowWidget"""

339

if key == u"+":

340

self.proxy.Enable(dbus_interface = client_interface)

341

elif key == u"-":

342

self.proxy.Disable(dbus_interface = client_interface)

343

elif key == u"a":

344

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

345

dbus_interface = client_interface)

346

elif key == u"d":

347

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

348

dbus_interface = client_interface)

208

if key == u"e" or key == u"+":

209

self.proxy.Enable()

210

elif key == u"d" or key == u"-":

211

self.proxy.Disable()

349

212

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

350

213

self.server_proxy_object.RemoveClient(self.proxy

351

214

.object_path)

352

215

elif key == u"s":

353

self.proxy.StartChecker(dbus_interface = client_interface)

216

self.proxy.StartChecker()

354

217

elif key == u"S":

355

self.proxy.StopChecker(dbus_interface = client_interface)

218

self.proxy.StopChecker()

356

219

elif key == u"C":

357

self.proxy.CheckedOK(dbus_interface = client_interface)

220

self.proxy.CheckedOK()

358

221

# xxx

359

222

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

360

223

# self.proxy.pause()

383

246

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

384

247

"""

385

248

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

386

ret = super(ConstrainedListBox, self).keypress((maxcol,

387

maxrow), key)

249

ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)

388

250

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

389

251

return

390

252

return ret

507

369

Call this when the widget layout needs to change"""

508

370

self.uilist = []

509

371

#self.uilist.append(urwid.ListBox(self.clients))

510

self.uilist.append(urwid.Frame(ConstrainedListBox(self.

511

clients),

372

self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),

512

373

#header=urwid.Divider(),

513

374

header=None,

514

footer=

515

urwid.Divider(div_char=

516

self.divider)))

375

footer=urwid.Divider(div_char=self.divider)))

517

376

if self.log_visible:

518

377

self.uilist.append(self.logbox)

519

378

pass

537

396

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

538

397

self.log_visible = not self.log_visible

539

398

self.rebuild()

540

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

541

# + unicode(self.log_visible))

399

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

400

+ unicode(self.log_visible))

542

401

543

402

def change_log_display(self):

544

403

"""Change type of log display.

549

408

self.log_wrap = u"clip"

550

409

for textwidget in self.log:

551

410

textwidget.set_wrap_mode(self.log_wrap)

552

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

411

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

553

412

554

413

def find_and_remove_client(self, path, name):

555

414

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

582

441

if path is None:

583

442

path = client.proxy.object_path

584

443

self.clients_dict[path] = client

585

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

444

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

586

445

self.refresh()

587

446

588

447

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

663

522

self.log_message_raw((u"bold",

664

523

u" "

665

524

.join((u"Clients:",

666

u"+: Enable",

667

u"-: Disable",

525

u"e: Enable",

526

u"d: Disable",

668

527

u"r: Remove",

669

528

u"s: Start new checker",

670

529

u"S: Stop checker",

671

u"C: Checker OK",

672

u"a: Approve",

673

u"d: Deny"))))

530

u"C: Checker OK"))))

674

531

self.refresh()

675

532

elif key == u"tab":

676

533

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

704

561

ui = UserInterface()

705

562

try:

706

563

ui.run()

707

except KeyboardInterrupt:

708

ui.screen.stop()

709

564

except Exception, e:

710

565

ui.log_message(unicode(e))

711

566

ui.screen.stop()