/mandos/release : revision 237.2.173

1

#!/usr/bin/python

2

# -*- mode: python; coding: utf-8 -*-

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

5

#

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

11

# the Free Software Foundation, either version 3 of the License, or

12

# (at your option) any later version.

13

#

14

# This program is distributed in the hope that it will be useful,

15

# but WITHOUT ANY WARRANTY; without even the implied warranty of

16

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

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

21

#

22

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

23

#

24

3

25

4

from __future__ import division, absolute_import, with_statement

26

5

40

19

41

20

import UserList

42

21

43

import locale

44

45

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

46

47

import logging

48

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

49

50

22

# Some useful constants

51

23

domain = 'se.bsnet.fukt'

52

24

server_interface = domain + '.Mandos'

53

25

client_interface = domain + '.Mandos.Client'

54

version = "1.0.15"

26

version = "1.0.14"

55

27

56

28

# Always run in monochrome mode

57

29

urwid.curses_display.curses.has_colors = lambda : False

61

33

urwid.curses_display.curses.A_UNDERLINE |= (

62

34

urwid.curses_display.curses.A_BLINK)

63

35

64

def isoformat_to_datetime(iso):

65

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

66

if not iso:

67

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)

71

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

72

return datetime.datetime(int(year),

73

int(month),

74

int(day),

75

int(hour),

76

int(minute),

77

int(second), # Whole seconds

78

int(fraction*1000000)) # Microseconds

79

80

36

class MandosClientPropertyCache(object):

81

37

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

82

38

properties and calls a hook function when any of them are

83

39

changed.

84

40

"""

85

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

41

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

42

**kwargs):

86

43

self.proxy = proxy_object # Mandos Client proxy object

87

44

88

self.properties = dict()

45

if properties is None:

46

self.properties = dict()

47

else:

48

self.properties = properties

89

49

self.proxy.connect_to_signal(u"PropertyChanged",

90

50

self.property_changed,

91

51

client_interface,

92

52

byte_arrays=True)

93

53

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)

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)

101

61

102

62

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

103

63

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

122

82

# Logger

123

83

self.logger = logger

124

84

125

self._update_timer_callback_tag = None

126

self._update_timer_callback_lock = 0

127

self.last_checker_failed = False

128

129

85

# The widget shown normally

130

86

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

131

87

# The widget shown when we have focus

135

91

*args, **kwargs)

136

92

self.update()

137

93

self.opened = False

138

139

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

150

151

if self.last_checker_failed:

152

self.using_timer(True)

153

154

if self.need_approval:

155

self.using_timer(True)

156

157

94

self.proxy.connect_to_signal(u"CheckerCompleted",

158

95

self.checker_completed,

159

96

client_interface,

166

103

self.got_secret,

167

104

client_interface,

168

105

byte_arrays=True)

169

self.proxy.connect_to_signal(u"NeedApproval",

170

self.need_approval,

171

client_interface,

172

byte_arrays=True)

173

106

self.proxy.connect_to_signal(u"Rejected",

174

107

self.rejected,

175

108

client_interface,

176

109

byte_arrays=True)

177

110

178

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

179

super(self, MandosClientWidget).property_changed(property,

180

value)

181

if property == u"ApprovalPending":

182

using_timer(bool(value))

183

184

def using_timer(self, flag):

185

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

186

activated or deactivated.

187

"""

188

old = self._update_timer_callback_lock

189

if flag:

190

self._update_timer_callback_lock += 1

191

else:

192

self._update_timer_callback_lock -= 1

193

if old == 0 and self._update_timer_callback_lock:

194

self._update_timer_callback_tag = (gobject.timeout_add

195

(1000,

196

self.update_timer))

197

elif old and self._update_timer_callback_lock == 0:

198

gobject.source_remove(self._update_timer_callback_tag)

199

self._update_timer_callback_tag = None

200

201

111

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

202

112

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

self.update()

113

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

114

u' was successful'

115

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

210

116

return

211

# Checker failed

212

if not self.last_checker_failed:

213

self.last_checker_failed = True

214

self.using_timer(True)

215

117

if os.WIFEXITED(condition):

216

118

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

217

119

u' failed with exit code %s'

218

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

120

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

219

121

os.WEXITSTATUS(condition)))

220

elif os.WIFSIGNALED(condition):

122

return

123

if os.WIFSIGNALED(condition):

221

124

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

222

125

u' was killed by signal %s'

223

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

126

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

224

127

os.WTERMSIG(condition)))

225

elif os.WCOREDUMP(condition):

128

return

129

if os.WCOREDUMP(condition):

226

130

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

227

131

u' dumped core'

228

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

229

else:

230

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

231

u' mysteriously')

232

self.update()

132

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

133

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

233

134

234

135

def checker_started(self, command):

235

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

236

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

237

pass

136

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

137

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

238

138

239

139

def got_secret(self):

240

self.last_checker_failed = False

241

140

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

242

% self.properties[u"Name"])

243

244

def need_approval(self, timeout, default):

245

if not default:

246

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

247

else:

248

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

249

self.logger(message

250

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

251

self.using_timer(True)

252

253

def rejected(self, reason):

254

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

255

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

141

% self.properties[u"name"])

142

143

def rejected(self):

144

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

145

% self.properties[u"name"])

256

146

257

147

def selectable(self):

258

148

"""Make this a "selectable" widget.

280

170

u"bold-underline-blink":

281

171

u"bold-underline-blink-standout",

282

172

}

283

173

284

174

# Rebuild focus and non-focus widgets using current properties

285

286

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

292

timeout = datetime.timedelta(milliseconds

293

= self.properties

294

[u"ApprovalDelay"])

295

last_approval_request = isoformat_to_datetime(

296

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

319

else:

320

message = u"enabled"

321

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

322

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

323

181

if not urwid.supports_unicode():

324

182

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

325

183

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

336

194

if self.update_hook is not None:

337

195

self.update_hook()

338

196

339

def update_timer(self):

340

"called by gobject"

341

self.update()

342

return True # Keep calling this

343

344

197

def delete(self):

345

if self._update_timer_callback_tag is not None:

346

gobject.source_remove(self._update_timer_callback_tag)

347

self._update_timer_callback_tag = None

348

198

if self.delete_hook is not None:

349

199

self.delete_hook(self)

350

200

357

207

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

358

208

"""Handle keys.

359

209

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

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

366

dbus_interface = client_interface)

367

elif key == u"d":

368

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

210

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

211

self.proxy.Enable()

212

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

213

self.proxy.Disable()

214

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

371

215

self.server_proxy_object.RemoveClient(self.proxy

372

216

.object_path)

373

217

elif key == u"s":

374

self.proxy.StartChecker(dbus_interface = client_interface)

218

self.proxy.StartChecker()

375

219

elif key == u"S":

376

self.proxy.StopChecker(dbus_interface = client_interface)

220

self.proxy.StopChecker()

377

221

elif key == u"C":

378

self.proxy.CheckedOK(dbus_interface = client_interface)

222

self.proxy.CheckedOK()

379

223

# xxx

380

224

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

381

225

# self.proxy.pause()

404

248

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

405

249

"""

406

250

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

407

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

408

maxrow), key)

251

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

409

252

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

410

253

return

411

254

return ret

528

371

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

529

372

self.uilist = []

530

373

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

531

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

532

clients),

374

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

533

375

#header=urwid.Divider(),

534

376

header=None,

535

footer=

536

urwid.Divider(div_char=

537

self.divider)))

377

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

538

378

if self.log_visible:

539

379

self.uilist.append(self.logbox)

540

380

pass

558

398

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

559

399

self.log_visible = not self.log_visible

560

400

self.rebuild()

561

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

562

# + unicode(self.log_visible))

401

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

402

+ unicode(self.log_visible))

563

403

564

404

def change_log_display(self):

565

405

"""Change type of log display.

570

410

self.log_wrap = u"clip"

571

411

for textwidget in self.log:

572

412

textwidget.set_wrap_mode(self.log_wrap)

573

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

413

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

574

414

575

415

def find_and_remove_client(self, path, name):

576

416

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

584

424

return

585

425

self.remove_client(client, path)

586

426

587

def add_new_client(self, path):

427

def add_new_client(self, path, properties):

588

428

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

589

429

self.add_client(MandosClientWidget(server_proxy_object

590

430

=self.mandos_serv,

591

431

proxy_object

592

432

=client_proxy_object,

433

properties=properties,

593

434

update_hook

594

435

=self.refresh,

595

436

delete_hook

596

=self.remove_client,

597

logger

598

=self.log_message),

437

=self.remove_client),

599

438

path=path)

600

439

601

440

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

603

442

if path is None:

604

443

path = client.proxy.object_path

605

444

self.clients_dict[path] = client

606

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

445

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

607

446

self.refresh()

608

447

609

448

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

684

523

self.log_message_raw((u"bold",

685

524

u" "

686

525

.join((u"Clients:",

687

u"+: Enable",

688

u"-: Disable",

689

u"R: Remove",

526

u"e: Enable",

527

u"d: Disable",

528

u"r: Remove",

690

529

u"s: Start new checker",

691

530

u"S: Stop checker",

692

u"C: Checker OK",

693

u"a: Approve",

694

u"d: Deny"))))

531

u"C: Checker OK"))))

695

532

self.refresh()

696

533

elif key == u"tab":

697

534

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

725

562

ui = UserInterface()

726

563

try:

727

564

ui.run()

728

except KeyboardInterrupt:

729

ui.screen.stop()

730

except Exception, e:

731

ui.log_message(unicode(e))

565

except:

732

566

ui.screen.stop()

733

567

raise