/mandos/release : revision 237.2.176

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.last_checker_failed = False

106

107

83

# The widget shown normally

108

84

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

109

85

# The widget shown when we have focus

125

101

self.got_secret,

126

102

client_interface,

127

103

byte_arrays=True)

128

self.proxy.connect_to_signal(u"NeedApproval",

129

self.need_approval,

130

client_interface,

131

byte_arrays=True)

132

104

self.proxy.connect_to_signal(u"Rejected",

133

105

self.rejected,

134

106

client_interface,

135

107

byte_arrays=True)

136

last_checked_ok = isoformat_to_datetime(self.properties

137

[u"LastCheckedOK"])

138

if last_checked_ok is None:

139

self.last_checker_failed = True

140

else:

141

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

142

- last_checked_ok)

143

> datetime.timedelta

144

(milliseconds=

145

self.properties

146

[u"Interval"]))

147

if self.last_checker_failed:

148

self._update_timer_callback_tag = (gobject.timeout_add

149

(1000,

150

self.update_timer))

151

108

152

109

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

153

110

if exitstatus == 0:

154

if self.last_checker_failed:

155

self.last_checker_failed = False

156

gobject.source_remove(self._update_timer_callback_tag)

157

self._update_timer_callback_tag = None

158

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

159

# u' was successful'

160

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

161

self.update()

111

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

112

u' was successful'

113

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

162

114

return

163

# Checker failed

164

if not self.last_checker_failed:

165

self.last_checker_failed = True

166

self._update_timer_callback_tag = (gobject.timeout_add

167

(1000,

168

self.update_timer))

169

115

if os.WIFEXITED(condition):

170

116

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

171

117

u' failed with exit code %s'

172

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

118

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

173

119

os.WEXITSTATUS(condition)))

174

elif os.WIFSIGNALED(condition):

120

return

121

if os.WIFSIGNALED(condition):

175

122

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

176

123

u' was killed by signal %s'

177

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

124

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

178

125

os.WTERMSIG(condition)))

179

elif os.WCOREDUMP(condition):

126

return

127

if os.WCOREDUMP(condition):

180

128

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

181

129

u' dumped core'

182

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

183

else:

184

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

185

u' mysteriously')

186

self.update()

130

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

131

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

187

132

188

133

def checker_started(self, command):

189

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

190

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

191

pass

134

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

135

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

192

136

193

137

def got_secret(self):

194

self.last_checker_failed = False

195

138

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

196

% self.properties[u"Name"])

197

198

def need_approval(self, timeout, default):

199

if not default:

200

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

201

else:

202

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

203

self.logger(message

204

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

205

206

def rejected(self, reason):

207

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

208

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

209

144

210

145

def selectable(self):

211

146

"""Make this a "selectable" widget.

233

168

u"bold-underline-blink":

234

169

u"bold-underline-blink-standout",

235

170

}

236

171

237

172

# Rebuild focus and non-focus widgets using current properties

238

239

# Base part of a client. Name!

240

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

241

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

242

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

243

message = u"DISABLED"

244

elif self.properties[u"ApprovalPending"]:

245

if self.properties[u"ApprovedByDefault"]:

246

message = u"Connection established to client. (d)eny?"

247

else:

248

message = u"Seeks approval to send secret. (a)pprove?"

249

elif self.last_checker_failed:

250

timeout = datetime.timedelta(milliseconds

251

= self.properties

252

[u"Timeout"])

253

last_ok = isoformat_to_datetime(

254

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

255

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

256

self.properties[u"LastEnabled"]))

257

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

258

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

259

u' gets diabled: %s'

260

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

261

else:

262

message = u"enabled"

263

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

264

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

265

179

if not urwid.supports_unicode():

266

180

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

267

181

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

278

192

if self.update_hook is not None:

279

193

self.update_hook()

280

194

281

def update_timer(self):

282

"called by gobject"

283

self.update()

284

return True # Keep calling this

285

286

195

def delete(self):

287

if self._update_timer_callback_tag is not None:

288

gobject.source_remove(self._update_timer_callback_tag)

289

self._update_timer_callback_tag = None

290

196

if self.delete_hook is not None:

291

197

self.delete_hook(self)

292

198

299

205

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

300

206

"""Handle keys.

301

207

This overrides the method from urwid.FlowWidget"""

302

if key == u"+":

303

self.proxy.Enable(dbus_interface = client_interface)

304

elif key == u"-":

305

self.proxy.Disable(dbus_interface = client_interface)

306

elif key == u"a":

307

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

308

dbus_interface = client_interface)

309

elif key == u"d":

310

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

311

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

312

212

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

313

213

self.server_proxy_object.RemoveClient(self.proxy

314

214

.object_path)

315

215

elif key == u"s":

316

self.proxy.StartChecker(dbus_interface = client_interface)

216

self.proxy.StartChecker()

317

217

elif key == u"S":

318

self.proxy.StopChecker(dbus_interface = client_interface)

218

self.proxy.StopChecker()

319

219

elif key == u"C":

320

self.proxy.CheckedOK(dbus_interface = client_interface)

220

self.proxy.CheckedOK()

321

221

# xxx

322

222

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

323

223

# self.proxy.pause()

346

246

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

347

247

"""

348

248

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

349

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

350

maxrow), key)

249

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

351

250

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

352

251

return

353

252

return ret

470

369

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

471

370

self.uilist = []

472

371

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

473

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

474

clients),

372

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

475

373

#header=urwid.Divider(),

476

374

header=None,

477

footer=

478

urwid.Divider(div_char=

479

self.divider)))

375

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

480

376

if self.log_visible:

481

377

self.uilist.append(self.logbox)

482

378

pass

500

396

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

501

397

self.log_visible = not self.log_visible

502

398

self.rebuild()

503

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

504

# + unicode(self.log_visible))

399

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

400

+ unicode(self.log_visible))

505

401

506

402

def change_log_display(self):

507

403

"""Change type of log display.

512

408

self.log_wrap = u"clip"

513

409

for textwidget in self.log:

514

410

textwidget.set_wrap_mode(self.log_wrap)

515

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

411

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

516

412

517

413

def find_and_remove_client(self, path, name):

518

414

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

545

441

if path is None:

546

442

path = client.proxy.object_path

547

443

self.clients_dict[path] = client

548

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

444

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

549

445

self.refresh()

550

446

551

447

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

626

522

self.log_message_raw((u"bold",

627

523

u" "

628

524

.join((u"Clients:",

629

u"+: Enable",

630

u"-: Disable",

525

u"e: Enable",

526

u"d: Disable",

631

527

u"r: Remove",

632

528

u"s: Start new checker",

633

529

u"S: Stop checker",

634

u"C: Checker OK",

635

u"a: Approve",

636

u"d: Deny"))))

530

u"C: Checker OK"))))

637

531

self.refresh()

638

532

elif key == u"tab":

639

533

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

667

561

ui = UserInterface()

668

562

try:

669

563

ui.run()

670

except KeyboardInterrupt:

671

ui.screen.stop()

672

564

except Exception, e:

673

565

ui.log_message(unicode(e))

674

566

ui.screen.stop()