/mandos/release : revision 237.2.206

19

20

import UserList

21

22

import locale

23

24

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

25

26

import logging

27

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

28

22

29

# Some useful constants

23

30

domain = 'se.bsnet.fukt'

24

31

server_interface = domain + '.Mandos'

25

32

client_interface = domain + '.Mandos.Client'

26

version = "1.0.14"

33

version = "1.0.15"

27

34

28

35

# Always run in monochrome mode

29

36

urwid.curses_display.curses.has_colors = lambda : False

33

40

urwid.curses_display.curses.A_UNDERLINE |= (

34

41

urwid.curses_display.curses.A_BLINK)

35

42

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

36

59

class MandosClientPropertyCache(object):

37

60

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

38

61

properties and calls a hook function when any of them are

39

62

changed.

40

63

"""

41

def __init__(self, proxy_object=None, properties=None, *args,

42

**kwargs):

64

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

43

65

self.proxy = proxy_object # Mandos Client proxy object

44

66

45

if properties is None:

46

self.properties = dict()

47

else:

48

self.properties = properties

67

self.properties = dict()

49

68

self.proxy.connect_to_signal(u"PropertyChanged",

50

69

self.property_changed,

51

70

client_interface,

52

71

byte_arrays=True)

53

72

54

if properties is None:

55

self.properties.update(self.proxy.GetAll(client_interface,

56

dbus_interface =

57

dbus.PROPERTIES_IFACE))

58

super(MandosClientPropertyCache, self).__init__(

59

proxy_object=proxy_object,

60

properties=properties, *args, **kwargs)

73

self.properties.update(

74

self.proxy.GetAll(client_interface,

75

dbus_interface = dbus.PROPERTIES_IFACE))

76

77

#XXX This break good super behaviour!

78

# super(MandosClientPropertyCache, self).__init__(

79

# *args, **kwargs)

61

80

62

81

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

63

82

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

82

101

# Logger

83

102

self.logger = logger

84

103

104

self._update_timer_callback_tag = None

105

self._update_timer_callback_lock = 0

106

self.last_checker_failed = False

107

85

108

# The widget shown normally

86

109

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

87

110

# The widget shown when we have focus

91

114

*args, **kwargs)

92

115

self.update()

93

116

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

94

136

self.proxy.connect_to_signal(u"CheckerCompleted",

95

137

self.checker_completed,

96

138

client_interface,

103

145

self.got_secret,

104

146

client_interface,

105

147

byte_arrays=True)

148

self.proxy.connect_to_signal(u"NeedApproval",

149

self.need_approval,

150

client_interface,

151

byte_arrays=True)

106

152

self.proxy.connect_to_signal(u"Rejected",

107

153

self.rejected,

108

154

client_interface,

109

155

byte_arrays=True)

110

156

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

111

180

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

112

181

if exitstatus == 0:

113

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

114

u' was successful'

115

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

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

116

189

return

190

# Checker failed

191

if not self.last_checker_failed:

192

self.last_checker_failed = True

193

self.using_timer(True)

117

194

if os.WIFEXITED(condition):

118

195

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

119

196

u' failed with exit code %s'

120

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

197

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

121

198

os.WEXITSTATUS(condition)))

122

return

123

if os.WIFSIGNALED(condition):

199

elif os.WIFSIGNALED(condition):

124

200

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

125

201

u' was killed by signal %s'

126

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

202

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

127

203

os.WTERMSIG(condition)))

128

return

129

if os.WCOREDUMP(condition):

204

elif os.WCOREDUMP(condition):

130

205

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

131

206

u' dumped core'

132

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

133

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

207

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

208

else:

209

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

210

u' mysteriously')

211

self.update()

134

212

135

213

def checker_started(self, command):

136

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

137

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

214

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

215

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

216

pass

138

217

139

218

def got_secret(self):

219

self.last_checker_failed = False

140

220

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

141

% self.properties[u"name"])

142

143

def rejected(self):

144

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

145

% self.properties[u"name"])

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

146

235

147

236

def selectable(self):

148

237

"""Make this a "selectable" widget.

170

259

u"bold-underline-blink":

171

260

u"bold-underline-blink-standout",

172

261

}

173

262

174

263

# Rebuild focus and non-focus widgets using current properties

175

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

176

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

177

u"enabled":

178

(u"enabled"

179

if self.properties[u"enabled"]

180

else u"DISABLED")})

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

181

302

if not urwid.supports_unicode():

182

303

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

183

304

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

194

315

if self.update_hook is not None:

195

316

self.update_hook()

196

317

318

def update_timer(self):

319

"called by gobject"

320

self.update()

321

return True # Keep calling this

322

197

323

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

198

327

if self.delete_hook is not None:

199

328

self.delete_hook(self)

200

329

207

336

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

208

337

"""Handle keys.

209

338

This overrides the method from urwid.FlowWidget"""

210

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

211

self.proxy.Enable()

212

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

213

self.proxy.Disable()

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)

214

349

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

215

350

self.server_proxy_object.RemoveClient(self.proxy

216

351

.object_path)

217

352

elif key == u"s":

218

self.proxy.StartChecker()

353

self.proxy.StartChecker(dbus_interface = client_interface)

219

354

elif key == u"S":

220

self.proxy.StopChecker()

355

self.proxy.StopChecker(dbus_interface = client_interface)

221

356

elif key == u"C":

222

self.proxy.CheckedOK()

357

self.proxy.CheckedOK(dbus_interface = client_interface)

223

358

# xxx

224

359

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

225

360

# self.proxy.pause()

248

383

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

249

384

"""

250

385

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

251

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

386

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

387

maxrow), key)

252

388

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

253

389

return

254

390

return ret

371

507

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

372

508

self.uilist = []

373

509

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

374

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

510

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

511

clients),

375

512

#header=urwid.Divider(),

376

513

header=None,

377

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

514

footer=

515

urwid.Divider(div_char=

516

self.divider)))

378

517

if self.log_visible:

379

518

self.uilist.append(self.logbox)

380

519

pass

398

537

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

399

538

self.log_visible = not self.log_visible

400

539

self.rebuild()

401

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

402

+ unicode(self.log_visible))

540

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

541

# + unicode(self.log_visible))

403

542

404

543

def change_log_display(self):

405

544

"""Change type of log display.

410

549

self.log_wrap = u"clip"

411

550

for textwidget in self.log:

412

551

textwidget.set_wrap_mode(self.log_wrap)

413

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

552

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

414

553

415

554

def find_and_remove_client(self, path, name):

416

555

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

424

563

return

425

564

self.remove_client(client, path)

426

565

427

def add_new_client(self, path, properties):

566

def add_new_client(self, path):

428

567

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

429

568

self.add_client(MandosClientWidget(server_proxy_object

430

569

=self.mandos_serv,

431

570

proxy_object

432

571

=client_proxy_object,

433

properties=properties,

434

572

update_hook

435

573

=self.refresh,

436

574

delete_hook

437

=self.remove_client),

575

=self.remove_client,

576

logger

577

=self.log_message),

438

578

path=path)

439

579

440

580

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

442

582

if path is None:

443

583

path = client.proxy.object_path

444

584

self.clients_dict[path] = client

445

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

585

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

446

586

self.refresh()

447

587

448

588

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

523

663

self.log_message_raw((u"bold",

524

664

u" "

525

665

.join((u"Clients:",

526

u"e: Enable",

527

u"d: Disable",

666

u"+: Enable",

667

u"-: Disable",

528

668

u"r: Remove",

529

669

u"s: Start new checker",

530

670

u"S: Stop checker",

531

u"C: Checker OK"))))

671

u"C: Checker OK",

672

u"a: Approve",

673

u"d: Deny"))))

532

674

self.refresh()

533

675

elif key == u"tab":

534

676

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

562

704

ui = UserInterface()

563

705

try:

564

706

ui.run()

565

except:

707

except KeyboardInterrupt:

708

ui.screen.stop()

709

except Exception, e:

710

ui.log_message(unicode(e))

566

711

ui.screen.stop()

567

712

raise