To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos-monitor
- browse files at revision 890
- compare with another revision
- download diff
- download tarball
- view history from revision 890
- Committer: Teddy Hogeborn
- Date: 2016-12-12 18:25:02 UTC
- Revision ID: teddy@recompile.se-20161212182502-72seb9hxiu65cgwa
Add spaces around all '=' signs in all C code.
* plugin-runner.c: Add white space around all '=' signs.
* plugins.d/mandos-client.c: - '' -
* plugins.d/plymouth.c: - '' -
* plugin-runner.c: Add white space around all '=' signs.
* plugins.d/mandos-client.c: - '' -
* plugins.d/plymouth.c: - '' -
- files added:
- bugs.xml
- debian/source
- debian/upstream
- network-hooks.d
- plugin-helpers
- files modified:
- .bzrignore
added
removed
mandos-monitor
1
1
#!/usr/bin/python
2
2
# -*- mode: python; coding: utf-8 -*-
3
#
4
# Mandos Monitor - Control and monitor the Mandos server
5
#
6
# Copyright © 2009-2016 Teddy Hogeborn
7
# Copyright © 2009-2016 Björn Påhlsson
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
21
# <http://www.gnu.org/licenses/>.
22
#
23
# Contact the authors at <mandos@recompile.se>.
24
#
3
25
4
from __future__ import division, absolute_import, with_statement
26
from __future__ import (division, absolute_import, print_function,
27
unicode_literals)
28
try:
29
from future_builtins import *
30
except ImportError:
31
pass
5
32
6
33
import sys
7
34
import os
8
import signal
9
35
10
36
import datetime
11
37
13
39
import urwid
14
40
15
41
from dbus.mainloop.glib import DBusGMainLoop
16
import gobject
42
from gi.repository import GLib
17
43
18
44
import dbus
19
45
20
import UserList
21
22
46
import locale
23
47
24
locale.setlocale(locale.LC_ALL, u'')
25
26
48
import logging
49
50
if sys.version_info.major == 2:
51
str = unicode
52
53
locale.setlocale(locale.LC_ALL, '')
54
27
55
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
28
56
29
57
# Some useful constants
30
domain = 'se.bsnet.fukt'
58
domain = 'se.recompile'
31
59
server_interface = domain + '.Mandos'
32
60
client_interface = domain + '.Mandos.Client'
33
version = "1.0.15"
34
35
# Always run in monochrome mode
36
urwid.curses_display.curses.has_colors = lambda : False
37
38
# Urwid doesn't support blinking, but we want it. Since we have no
39
# use for underline on its own, we make underline also always blink.
40
urwid.curses_display.curses.A_UNDERLINE |= (
41
urwid.curses_display.curses.A_BLINK)
61
version = "1.7.13"
62
63
try:
64
dbus.OBJECT_MANAGER_IFACE
65
except AttributeError:
66
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
67
42
68
43
69
def isoformat_to_datetime(iso):
44
70
"Parse an ISO 8601 date string to a datetime.datetime()"
45
71
if not iso:
46
72
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)
73
d, t = iso.split("T", 1)
74
year, month, day = d.split("-", 2)
75
hour, minute, second = t.split(":", 2)
50
76
second, fraction = divmod(float(second), 1)
51
77
return datetime.datetime(int(year),
52
78
int(month),
53
79
int(day),
54
80
int(hour),
55
81
int(minute),
56
int(second), # Whole seconds
57
int(fraction*1000000)) # Microseconds
82
int(second), # Whole seconds
83
int(fraction*1000000)) # Microseconds
84
58
85
59
86
class MandosClientPropertyCache(object):
60
87
"""This wraps a Mandos Client D-Bus proxy object, caches the
61
88
properties and calls a hook function when any of them are
62
89
changed.
63
90
"""
64
def __init__(self, proxy_object=None, *args, **kwargs):
65
self.proxy = proxy_object # Mandos Client proxy object
66
67
self.properties = dict()
68
self.proxy.connect_to_signal(u"PropertyChanged",
69
self.property_changed,
70
client_interface,
71
byte_arrays=True)
72
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)
80
81
def property_changed(self, property=None, value=None):
82
"""This is called whenever we get a PropertyChanged signal
83
It updates the changed property in the "properties" dict.
91
def __init__(self, proxy_object=None, properties=None, **kwargs):
92
self.proxy = proxy_object # Mandos Client proxy object
93
self.properties = dict() if properties is None else properties
94
self.property_changed_match = (
95
self.proxy.connect_to_signal("PropertiesChanged",
96
self.properties_changed,
97
dbus.PROPERTIES_IFACE,
98
byte_arrays=True))
99
100
if properties is None:
101
self.properties.update(self.proxy.GetAll(
102
client_interface,
103
dbus_interface=dbus.PROPERTIES_IFACE))
104
105
super(MandosClientPropertyCache, self).__init__(**kwargs)
106
107
def properties_changed(self, interface, properties, invalidated):
108
"""This is called whenever we get a PropertiesChanged signal
109
It updates the changed properties in the "properties" dict.
84
110
"""
85
111
# Update properties dict with new value
86
self.properties[property] = value
112
if interface == client_interface:
113
self.properties.update(properties)
114
115
def delete(self):
116
self.property_changed_match.remove()
87
117
88
118
89
119
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
90
120
"""A Mandos Client which is visible on the screen.
91
121
"""
92
122
93
123
def __init__(self, server_proxy_object=None, update_hook=None,
94
delete_hook=None, logger=None, *args, **kwargs):
124
delete_hook=None, logger=None, **kwargs):
95
125
# Called on update
96
126
self.update_hook = update_hook
97
127
# Called on delete
100
130
self.server_proxy_object = server_proxy_object
101
131
# Logger
102
132
self.logger = logger
103
133
104
134
self._update_timer_callback_tag = None
105
self._update_timer_callback_lock = 0
106
self.last_checker_failed = False
107
135
108
136
# The widget shown normally
109
self._text_widget = urwid.Text(u"")
137
self._text_widget = urwid.Text("")
110
138
# The widget shown when we have focus
111
self._focus_text_widget = urwid.Text(u"")
112
super(MandosClientWidget, self).__init__(
113
update_hook=update_hook, delete_hook=delete_hook,
114
*args, **kwargs)
139
self._focus_text_widget = urwid.Text("")
140
super(MandosClientWidget, self).__init__(**kwargs)
115
141
self.update()
116
142
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
self.proxy.connect_to_signal(u"CheckerCompleted",
137
self.checker_completed,
138
client_interface,
139
byte_arrays=True)
140
self.proxy.connect_to_signal(u"CheckerStarted",
141
self.checker_started,
142
client_interface,
143
byte_arrays=True)
144
self.proxy.connect_to_signal(u"GotSecret",
145
self.got_secret,
146
client_interface,
147
byte_arrays=True)
148
self.proxy.connect_to_signal(u"NeedApproval",
149
self.need_approval,
150
client_interface,
151
byte_arrays=True)
152
self.proxy.connect_to_signal(u"Rejected",
153
self.rejected,
154
client_interface,
155
byte_arrays=True)
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
143
144
self.match_objects = (
145
self.proxy.connect_to_signal("CheckerCompleted",
146
self.checker_completed,
147
client_interface,
148
byte_arrays=True),
149
self.proxy.connect_to_signal("CheckerStarted",
150
self.checker_started,
151
client_interface,
152
byte_arrays=True),
153
self.proxy.connect_to_signal("GotSecret",
154
self.got_secret,
155
client_interface,
156
byte_arrays=True),
157
self.proxy.connect_to_signal("NeedApproval",
158
self.need_approval,
159
client_interface,
160
byte_arrays=True),
161
self.proxy.connect_to_signal("Rejected",
162
self.rejected,
163
client_interface,
164
byte_arrays=True))
165
self.logger('Created client {}'
166
.format(self.properties["Name"]), level=0)
167
163
168
def using_timer(self, flag):
164
169
"""Call this method with True or False when timer should be
165
170
activated or deactivated.
166
171
"""
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
172
if flag and self._update_timer_callback_tag is None:
173
# Will update the shown timer value every second
174
self._update_timer_callback_tag = (GLib.timeout_add
174
175
(1000,
175
176
self.update_timer))
176
elif old and self._update_timer_callback_lock == 0:
177
gobject.source_remove(self._update_timer_callback_tag)
177
elif not (flag or self._update_timer_callback_tag is None):
178
GLib.source_remove(self._update_timer_callback_tag)
178
179
self._update_timer_callback_tag = None
179
180
180
181
def checker_completed(self, exitstatus, condition, command):
181
182
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))
183
self.logger('Checker for client {} (command "{}")'
184
' succeeded'.format(self.properties["Name"],
185
command), level=0)
188
186
self.update()
189
187
return
190
188
# Checker failed
191
if not self.last_checker_failed:
192
self.last_checker_failed = True
193
self.using_timer(True)
194
189
if os.WIFEXITED(condition):
195
self.logger(u'Checker for client %s (command "%s")'
196
u' failed with exit code %s'
197
% (self.properties[u"Name"], command,
198
os.WEXITSTATUS(condition)))
190
self.logger('Checker for client {} (command "{}") failed'
191
' with exit code {}'
192
.format(self.properties["Name"], command,
193
os.WEXITSTATUS(condition)))
199
194
elif os.WIFSIGNALED(condition):
200
self.logger(u'Checker for client %s (command "%s")'
201
u' was killed by signal %s'
202
% (self.properties[u"Name"], command,
203
os.WTERMSIG(condition)))
204
elif os.WCOREDUMP(condition):
205
self.logger(u'Checker for client %s (command "%s")'
206
u' dumped core'
207
% (self.properties[u"Name"], command))
208
else:
209
self.logger(u'Checker for client %s completed'
210
u' mysteriously')
195
self.logger('Checker for client {} (command "{}") was'
196
' killed by signal {}'
197
.format(self.properties["Name"], command,
198
os.WTERMSIG(condition)))
211
199
self.update()
212
200
213
201
def checker_started(self, command):
214
#self.logger(u'Client %s started checker "%s"'
215
# % (self.properties[u"Name"], unicode(command)))
216
pass
217
202
"""Server signals that a checker started."""
203
self.logger('Client {} started checker "{}"'
204
.format(self.properties["Name"],
205
command), level=0)
206
218
207
def got_secret(self):
219
self.last_checker_failed = False
220
self.logger(u'Client %s received its secret'
221
% self.properties[u"Name"])
222
208
self.logger('Client {} received its secret'
209
.format(self.properties["Name"]))
210
223
211
def need_approval(self, timeout, default):
224
212
if not default:
225
message = u'Client %s needs approval within %s seconds'
213
message = 'Client {} needs approval within {} seconds'
226
214
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
215
message = 'Client {} will get its secret in {} seconds'
216
self.logger(message.format(self.properties["Name"],
217
timeout/1000))
218
232
219
def rejected(self, reason):
233
self.logger(u'Client %s was rejected; reason: %s'
234
% (self.properties[u"Name"], reason))
235
220
self.logger('Client {} was rejected; reason: {}'
221
.format(self.properties["Name"], reason))
222
236
223
def selectable(self):
237
224
"""Make this a "selectable" widget.
238
225
This overrides the method from urwid.FlowWidget."""
239
226
return True
240
241
def rows(self, (maxcol,), focus=False):
227
228
def rows(self, maxcolrow, focus=False):
242
229
"""How many rows this widget will occupy might depend on
243
230
whether we have focus or not.
244
231
This overrides the method from urwid.FlowWidget"""
245
return self.current_widget(focus).rows((maxcol,), focus=focus)
246
232
return self.current_widget(focus).rows(maxcolrow, focus=focus)
233
247
234
def current_widget(self, focus=False):
248
235
if focus or self.opened:
249
236
return self._focus_widget
250
237
return self._widget
251
238
252
239
def update(self):
253
240
"Called when what is visible on the screen should be updated."
254
241
# How to add standout mode to a style
255
with_standout = { u"normal": u"standout",
256
u"bold": u"bold-standout",
257
u"underline-blink":
258
u"underline-blink-standout",
259
u"bold-underline-blink":
260
u"bold-underline-blink-standout",
261
}
242
with_standout = {"normal": "standout",
243
"bold": "bold-standout",
244
"underline-blink":
245
"underline-blink-standout",
246
"bold-underline-blink":
247
"bold-underline-blink-standout",
248
}
262
249
263
250
# Rebuild focus and non-focus widgets using current properties
264
251
265
252
# 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"])
253
base = '{name}: '.format(name=self.properties["Name"])
254
if not self.properties["Enabled"]:
255
message = "DISABLED"
256
self.using_timer(False)
257
elif self.properties["ApprovalPending"]:
258
timeout = datetime.timedelta(
259
milliseconds=self.properties["ApprovalDelay"])
274
260
last_approval_request = isoformat_to_datetime(
275
self.properties[u"LastApprovalRequest"])
261
self.properties["LastApprovalRequest"])
276
262
if last_approval_request is not None:
277
timer = timeout - (datetime.datetime.utcnow()
278
- last_approval_request)
263
timer = max(timeout - (datetime.datetime.utcnow()
264
- last_approval_request),
265
datetime.timedelta())
279
266
else:
280
267
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])
268
if self.properties["ApprovedByDefault"]:
269
message = "Approval in {}. (d)eny?"
270
else:
271
message = "Denial in {}. (a)pprove?"
272
message = message.format(str(timer).rsplit(".", 1)[0])
273
self.using_timer(True)
274
elif self.properties["LastCheckerStatus"] != 0:
275
# When checker has failed, show timer until client expires
276
expires = self.properties["Expires"]
277
if expires == "":
278
timer = datetime.timedelta(0)
279
else:
280
expires = (datetime.datetime.strptime
281
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
282
timer = max(expires - datetime.datetime.utcnow(),
283
datetime.timedelta())
284
message = ('A checker has failed! Time until client'
285
' gets disabled: {}'
286
.format(str(timer).rsplit(".", 1)[0]))
287
self.using_timer(True)
298
288
else:
299
message = u"enabled"
300
self._text = "%s%s" % (base, message)
301
289
message = "enabled"
290
self.using_timer(False)
291
self._text = "{}{}".format(base, message)
292
302
293
if not urwid.supports_unicode():
303
294
self._text = self._text.encode("ascii", "replace")
304
textlist = [(u"normal", self._text)]
295
textlist = [("normal", self._text)]
305
296
self._text_widget.set_text(textlist)
306
297
self._focus_text_widget.set_text([(with_standout[text[0]],
307
298
text[1])
314
305
# Run update hook, if any
315
306
if self.update_hook is not None:
316
307
self.update_hook()
317
308
318
309
def update_timer(self):
319
"called by gobject"
310
"""called by GLib. Will indefinitely loop until
311
GLib.source_remove() on tag is called
312
"""
320
313
self.update()
321
314
return True # Keep calling this
322
323
def delete(self):
315
316
def delete(self, **kwargs):
324
317
if self._update_timer_callback_tag is not None:
325
gobject.source_remove(self._update_timer_callback_tag)
318
GLib.source_remove(self._update_timer_callback_tag)
326
319
self._update_timer_callback_tag = None
320
for match in self.match_objects:
321
match.remove()
322
self.match_objects = ()
327
323
if self.delete_hook is not None:
328
324
self.delete_hook(self)
329
330
def render(self, (maxcol,), focus=False):
325
return super(MandosClientWidget, self).delete(**kwargs)
326
327
def render(self, maxcolrow, focus=False):
331
328
"""Render differently if we have focus.
332
329
This overrides the method from urwid.FlowWidget"""
333
return self.current_widget(focus).render((maxcol,),
330
return self.current_widget(focus).render(maxcolrow,
334
331
focus=focus)
335
336
def keypress(self, (maxcol,), key):
332
333
def keypress(self, maxcolrow, key):
337
334
"""Handle keys.
338
335
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":
336
if key == "+":
337
self.proxy.Set(client_interface, "Enabled",
338
dbus.Boolean(True), ignore_reply=True,
339
dbus_interface=dbus.PROPERTIES_IFACE)
340
elif key == "-":
341
self.proxy.Set(client_interface, "Enabled", False,
342
ignore_reply=True,
343
dbus_interface=dbus.PROPERTIES_IFACE)
344
elif key == "a":
344
345
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
345
dbus_interface = client_interface)
346
elif key == u"d":
346
dbus_interface=client_interface,
347
ignore_reply=True)
348
elif key == "d":
347
349
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
348
dbus_interface = client_interface)
349
elif key == u"r" or key == u"_" or key == u"ctrl k":
350
dbus_interface=client_interface,
351
ignore_reply=True)
352
elif key == "R" or key == "_" or key == "ctrl k":
350
353
self.server_proxy_object.RemoveClient(self.proxy
351
.object_path)
352
elif key == u"s":
353
self.proxy.StartChecker(dbus_interface = client_interface)
354
elif key == u"S":
355
self.proxy.StopChecker(dbus_interface = client_interface)
356
elif key == u"C":
357
self.proxy.CheckedOK(dbus_interface = client_interface)
354
.object_path,
355
ignore_reply=True)
356
elif key == "s":
357
self.proxy.Set(client_interface, "CheckerRunning",
358
dbus.Boolean(True), ignore_reply=True,
359
dbus_interface=dbus.PROPERTIES_IFACE)
360
elif key == "S":
361
self.proxy.Set(client_interface, "CheckerRunning",
362
dbus.Boolean(False), ignore_reply=True,
363
dbus_interface=dbus.PROPERTIES_IFACE)
364
elif key == "C":
365
self.proxy.CheckedOK(dbus_interface=client_interface,
366
ignore_reply=True)
358
367
# xxx
359
# elif key == u"p" or key == "=":
368
# elif key == "p" or key == "=":
360
369
# self.proxy.pause()
361
# elif key == u"u" or key == ":":
370
# elif key == "u" or key == ":":
362
371
# self.proxy.unpause()
363
# elif key == u"RET":
372
# elif key == "RET":
364
373
# self.open()
365
374
else:
366
375
return key
367
368
def property_changed(self, property=None, value=None,
369
*args, **kwargs):
370
"""Call self.update() if old value is not new value.
376
377
def properties_changed(self, interface, properties, invalidated):
378
"""Call self.update() if any properties changed.
371
379
This overrides the method from MandosClientPropertyCache"""
372
property_name = unicode(property)
373
old_value = self.properties.get(property_name)
374
super(MandosClientWidget, self).property_changed(
375
property=property, value=value, *args, **kwargs)
376
if self.properties.get(property_name) != old_value:
380
old_values = {key: self.properties.get(key)
381
for key in properties.keys()}
382
super(MandosClientWidget, self).properties_changed(
383
interface, properties, invalidated)
384
if any(old_values[key] != self.properties.get(key)
385
for key in old_values):
377
386
self.update()
378
387
379
388
382
391
"down" key presses, thus not allowing any containing widgets to
383
392
use them as an excuse to shift focus away from this widget.
384
393
"""
385
def keypress(self, (maxcol, maxrow), key):
386
ret = super(ConstrainedListBox, self).keypress((maxcol,
387
maxrow), key)
388
if ret in (u"up", u"down"):
394
def keypress(self, *args, **kwargs):
395
ret = (super(ConstrainedListBox, self)
396
.keypress(*args, **kwargs))
397
if ret in ("up", "down"):
389
398
return
390
399
return ret
391
400
394
403
"""This is the entire user interface - the whole screen
395
404
with boxes, lists of client widgets, etc.
396
405
"""
397
def __init__(self, max_log_length=1000):
406
def __init__(self, max_log_length=1000, log_level=1):
398
407
DBusGMainLoop(set_as_default=True)
399
408
400
409
self.screen = urwid.curses_display.Screen()
401
410
402
411
self.screen.register_palette((
403
(u"normal",
404
u"default", u"default", None),
405
(u"bold",
406
u"default", u"default", u"bold"),
407
(u"underline-blink",
408
u"default", u"default", u"underline"),
409
(u"standout",
410
u"default", u"default", u"standout"),
411
(u"bold-underline-blink",
412
u"default", u"default", (u"bold", u"underline")),
413
(u"bold-standout",
414
u"default", u"default", (u"bold", u"standout")),
415
(u"underline-blink-standout",
416
u"default", u"default", (u"underline", u"standout")),
417
(u"bold-underline-blink-standout",
418
u"default", u"default", (u"bold", u"underline",
419
u"standout")),
412
("normal",
413
"default", "default", None),
414
("bold",
415
"bold", "default", "bold"),
416
("underline-blink",
417
"underline,blink", "default", "underline,blink"),
418
("standout",
419
"standout", "default", "standout"),
420
("bold-underline-blink",
421
"bold,underline,blink", "default",
422
"bold,underline,blink"),
423
("bold-standout",
424
"bold,standout", "default", "bold,standout"),
425
("underline-blink-standout",
426
"underline,blink,standout", "default",
427
"underline,blink,standout"),
428
("bold-underline-blink-standout",
429
"bold,underline,blink,standout", "default",
430
"bold,underline,blink,standout"),
420
431
))
421
432
422
433
if urwid.supports_unicode():
423
self.divider = u"─" # \u2500
424
#self.divider = u"━" # \u2501
434
self.divider = "─" # \u2500
425
435
else:
426
#self.divider = u"-" # \u002d
427
self.divider = u"_" # \u005f
428
436
self.divider = "_" # \u005f
437
429
438
self.screen.start()
430
439
431
440
self.size = self.screen.get_cols_rows()
432
441
433
442
self.clients = urwid.SimpleListWalker([])
434
443
self.clients_dict = {}
435
444
436
445
# We will add Text widgets to this list
437
446
self.log = []
438
447
self.max_log_length = max_log_length
439
448
449
self.log_level = log_level
450
440
451
# We keep a reference to the log widget so we can remove it
441
452
# from the ListWalker without it getting destroyed
442
453
self.logbox = ConstrainedListBox(self.log)
443
454
444
455
# This keeps track of whether self.uilist currently has
445
456
# self.logbox in it or not
446
457
self.log_visible = True
447
self.log_wrap = u"any"
448
458
self.log_wrap = "any"
459
449
460
self.rebuild()
450
self.log_message_raw((u"bold",
451
u"Mandos Monitor version " + version))
452
self.log_message_raw((u"bold",
453
u"q: Quit ?: Help"))
454
461
self.log_message_raw(("bold",
462
"Mandos Monitor version " + version))
463
self.log_message_raw(("bold",
464
"q: Quit ?: Help"))
465
455
466
self.busname = domain + '.Mandos'
456
self.main_loop = gobject.MainLoop()
457
self.bus = dbus.SystemBus()
458
mandos_dbus_objc = self.bus.get_object(
459
self.busname, u"/", follow_name_owner_changes=True)
460
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
461
dbus_interface
462
= server_interface)
463
try:
464
mandos_clients = (self.mandos_serv
465
.GetAllClientsWithProperties())
466
except dbus.exceptions.DBusException:
467
mandos_clients = dbus.Dictionary()
468
469
(self.mandos_serv
470
.connect_to_signal(u"ClientRemoved",
471
self.find_and_remove_client,
472
dbus_interface=server_interface,
473
byte_arrays=True))
474
(self.mandos_serv
475
.connect_to_signal(u"ClientAdded",
476
self.add_new_client,
477
dbus_interface=server_interface,
478
byte_arrays=True))
479
(self.mandos_serv
480
.connect_to_signal(u"ClientNotFound",
481
self.client_not_found,
482
dbus_interface=server_interface,
483
byte_arrays=True))
484
for path, client in mandos_clients.iteritems():
485
client_proxy_object = self.bus.get_object(self.busname,
486
path)
487
self.add_client(MandosClientWidget(server_proxy_object
488
=self.mandos_serv,
489
proxy_object
490
=client_proxy_object,
491
properties=client,
492
update_hook
493
=self.refresh,
494
delete_hook
495
=self.remove_client,
496
logger
497
=self.log_message),
498
path=path)
499
467
self.main_loop = GLib.MainLoop()
468
500
469
def client_not_found(self, fingerprint, address):
501
self.log_message((u"Client with address %s and fingerprint %s"
502
u" could not be found" % (address,
503
fingerprint)))
504
470
self.log_message("Client with address {} and fingerprint {}"
471
" could not be found"
472
.format(address, fingerprint))
473
505
474
def rebuild(self):
506
475
"""This rebuilds the User Interface.
507
476
Call this when the widget layout needs to change"""
508
477
self.uilist = []
509
#self.uilist.append(urwid.ListBox(self.clients))
478
# self.uilist.append(urwid.ListBox(self.clients))
510
479
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
511
480
clients),
512
#header=urwid.Divider(),
481
# header=urwid.Divider(),
513
482
header=None,
514
footer=
515
urwid.Divider(div_char=
516
self.divider)))
483
footer=urwid.Divider(
484
div_char=self.divider)))
517
485
if self.log_visible:
518
486
self.uilist.append(self.logbox)
519
pass
520
487
self.topwidget = urwid.Pile(self.uilist)
521
522
def log_message(self, message):
488
489
def log_message(self, message, level=1):
490
"""Log message formatted with timestamp"""
491
if level < self.log_level:
492
return
523
493
timestamp = datetime.datetime.now().isoformat()
524
self.log_message_raw(timestamp + u": " + message)
525
526
def log_message_raw(self, markup):
494
self.log_message_raw("{}: {}".format(timestamp, message),
495
level=level)
496
497
def log_message_raw(self, markup, level=1):
527
498
"""Add a log message to the log buffer."""
499
if level < self.log_level:
500
return
528
501
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
529
if (self.max_log_length
530
and len(self.log) > self.max_log_length):
531
del self.log[0:len(self.log)-self.max_log_length-1]
502
if self.max_log_length:
503
if len(self.log) > self.max_log_length:
504
del self.log[0:len(self.log)-self.max_log_length-1]
532
505
self.logbox.set_focus(len(self.logbox.body.contents),
533
coming_from=u"above")
506
coming_from="above")
534
507
self.refresh()
535
508
536
509
def toggle_log_display(self):
537
510
"""Toggle visibility of the log buffer."""
538
511
self.log_visible = not self.log_visible
539
512
self.rebuild()
540
#self.log_message(u"Log visibility changed to: "
541
# + unicode(self.log_visible))
542
513
self.log_message("Log visibility changed to: {}"
514
.format(self.log_visible), level=0)
515
543
516
def change_log_display(self):
544
517
"""Change type of log display.
545
518
Currently, this toggles wrapping of text lines."""
546
if self.log_wrap == u"clip":
547
self.log_wrap = u"any"
519
if self.log_wrap == "clip":
520
self.log_wrap = "any"
548
521
else:
549
self.log_wrap = u"clip"
522
self.log_wrap = "clip"
550
523
for textwidget in self.log:
551
524
textwidget.set_wrap_mode(self.log_wrap)
552
#self.log_message(u"Wrap mode: " + self.log_wrap)
553
554
def find_and_remove_client(self, path, name):
555
"""Find an client from its object path and remove it.
556
557
This is connected to the ClientRemoved signal from the
525
self.log_message("Wrap mode: {}".format(self.log_wrap),
526
level=0)
527
528
def find_and_remove_client(self, path, interfaces):
529
"""Find a client by its object path and remove it.
530
531
This is connected to the InterfacesRemoved signal from the
558
532
Mandos server object."""
533
if client_interface not in interfaces:
534
# Not a Mandos client object; ignore
535
return
559
536
try:
560
537
client = self.clients_dict[path]
561
538
except KeyError:
562
539
# not found?
563
return
564
self.remove_client(client, path)
565
566
def add_new_client(self, path):
540
self.log_message("Unknown client {!r} removed"
541
.format(path))
542
return
543
client.delete()
544
545
def add_new_client(self, path, ifs_and_props):
546
"""Find a client by its object path and remove it.
547
548
This is connected to the InterfacesAdded signal from the
549
Mandos server object.
550
"""
551
if client_interface not in ifs_and_props:
552
# Not a Mandos client object; ignore
553
return
567
554
client_proxy_object = self.bus.get_object(self.busname, path)
568
self.add_client(MandosClientWidget(server_proxy_object
569
=self.mandos_serv,
570
proxy_object
571
=client_proxy_object,
572
update_hook
573
=self.refresh,
574
delete_hook
575
=self.remove_client,
576
logger
577
=self.log_message),
555
self.add_client(MandosClientWidget(
556
server_proxy_object=self.mandos_serv,
557
proxy_object=client_proxy_object,
558
update_hook=self.refresh,
559
delete_hook=self.remove_client,
560
logger=self.log_message,
561
properties=dict(ifs_and_props[client_interface])),
578
562
path=path)
579
563
580
564
def add_client(self, client, path=None):
581
565
self.clients.append(client)
582
566
if path is None:
583
567
path = client.proxy.object_path
584
568
self.clients_dict[path] = client
585
self.clients.sort(None, lambda c: c.properties[u"Name"])
569
self.clients.sort(key=lambda c: c.properties["Name"])
586
570
self.refresh()
587
571
588
572
def remove_client(self, client, path=None):
589
573
self.clients.remove(client)
590
574
if path is None:
591
575
path = client.proxy.object_path
592
576
del self.clients_dict[path]
593
if not self.clients_dict:
594
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
595
# is completely emptied, we need to recreate it.
596
self.clients = urwid.SimpleListWalker([])
597
self.rebuild()
598
577
self.refresh()
599
578
600
579
def refresh(self):
601
580
"""Redraw the screen"""
602
581
canvas = self.topwidget.render(self.size, focus=True)
603
582
self.screen.draw_screen(self.size, canvas)
604
583
605
584
def run(self):
606
585
"""Start the main loop and exit when it's done."""
586
self.bus = dbus.SystemBus()
587
mandos_dbus_objc = self.bus.get_object(
588
self.busname, "/", follow_name_owner_changes=True)
589
self.mandos_serv = dbus.Interface(
590
mandos_dbus_objc, dbus_interface=server_interface)
591
try:
592
mandos_clients = (self.mandos_serv
593
.GetAllClientsWithProperties())
594
if not mandos_clients:
595
self.log_message_raw(("bold",
596
"Note: Server has no clients."))
597
except dbus.exceptions.DBusException:
598
self.log_message_raw(("bold",
599
"Note: No Mandos server running."))
600
mandos_clients = dbus.Dictionary()
601
602
(self.mandos_serv
603
.connect_to_signal("InterfacesRemoved",
604
self.find_and_remove_client,
605
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
606
byte_arrays=True))
607
(self.mandos_serv
608
.connect_to_signal("InterfacesAdded",
609
self.add_new_client,
610
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
611
byte_arrays=True))
612
(self.mandos_serv
613
.connect_to_signal("ClientNotFound",
614
self.client_not_found,
615
dbus_interface=server_interface,
616
byte_arrays=True))
617
for path, client in mandos_clients.items():
618
client_proxy_object = self.bus.get_object(self.busname,
619
path)
620
self.add_client(MandosClientWidget(
621
server_proxy_object=self.mandos_serv,
622
proxy_object=client_proxy_object,
623
properties=client,
624
update_hook=self.refresh,
625
delete_hook=self.remove_client,
626
logger=self.log_message),
627
path=path)
628
607
629
self.refresh()
608
self._input_callback_tag = (gobject.io_add_watch
630
self._input_callback_tag = (GLib.io_add_watch
609
631
(sys.stdin.fileno(),
610
gobject.IO_IN,
632
GLib.IO_IN,
611
633
self.process_input))
612
634
self.main_loop.run()
613
635
# Main loop has finished, we should close everything now
614
gobject.source_remove(self._input_callback_tag)
636
GLib.source_remove(self._input_callback_tag)
615
637
self.screen.stop()
616
638
617
639
def stop(self):
618
640
self.main_loop.quit()
619
641
620
642
def process_input(self, source, condition):
621
643
keys = self.screen.get_input()
622
translations = { u"ctrl n": u"down", # Emacs
623
u"ctrl p": u"up", # Emacs
624
u"ctrl v": u"page down", # Emacs
625
u"meta v": u"page up", # Emacs
626
u" ": u"page down", # less
627
u"f": u"page down", # less
628
u"b": u"page up", # less
629
u"j": u"down", # vi
630
u"k": u"up", # vi
631
}
644
translations = {"ctrl n": "down", # Emacs
645
"ctrl p": "up", # Emacs
646
"ctrl v": "page down", # Emacs
647
"meta v": "page up", # Emacs
648
" ": "page down", # less
649
"f": "page down", # less
650
"b": "page up", # less
651
"j": "down", # vi
652
"k": "up", # vi
653
}
632
654
for key in keys:
633
655
try:
634
656
key = translations[key]
635
657
except KeyError: # :-)
636
658
pass
637
638
if key == u"q" or key == u"Q":
659
660
if key == "q" or key == "Q":
639
661
self.stop()
640
662
break
641
elif key == u"window resize":
663
elif key == "window resize":
642
664
self.size = self.screen.get_cols_rows()
643
665
self.refresh()
644
elif key == u"\f": # Ctrl-L
666
elif key == "ctrl l":
667
self.screen.clear()
645
668
self.refresh()
646
elif key == u"l" or key == u"D":
669
elif key == "l" or key == "D":
647
670
self.toggle_log_display()
648
671
self.refresh()
649
elif key == u"w" or key == u"i":
672
elif key == "w" or key == "i":
650
673
self.change_log_display()
651
674
self.refresh()
652
elif key == u"?" or key == u"f1" or key == u"esc":
675
elif key == "?" or key == "f1" or key == "esc":
653
676
if not self.log_visible:
654
677
self.log_visible = True
655
678
self.rebuild()
656
self.log_message_raw((u"bold",
657
u" ".
658
join((u"q: Quit",
659
u"?: Help",
660
u"l: Log window toggle",
661
u"TAB: Switch window",
662
u"w: Wrap (log)"))))
663
self.log_message_raw((u"bold",
664
u" "
665
.join((u"Clients:",
666
u"+: Enable",
667
u"-: Disable",
668
u"r: Remove",
669
u"s: Start new checker",
670
u"S: Stop checker",
671
u"C: Checker OK",
672
u"a: Approve",
673
u"d: Deny"))))
679
self.log_message_raw(("bold",
680
" ".
681
join(("q: Quit",
682
"?: Help",
683
"l: Log window toggle",
684
"TAB: Switch window",
685
"w: Wrap (log lines)",
686
"v: Toggle verbose log",
687
))))
688
self.log_message_raw(("bold",
689
" "
690
.join(("Clients:",
691
"+: Enable",
692
"-: Disable",
693
"R: Remove",
694
"s: Start new checker",
695
"S: Stop checker",
696
"C: Checker OK",
697
"a: Approve",
698
"d: Deny"))))
674
699
self.refresh()
675
elif key == u"tab":
700
elif key == "tab":
676
701
if self.topwidget.get_focus() is self.logbox:
677
702
self.topwidget.set_focus(0)
678
703
else:
679
704
self.topwidget.set_focus(self.logbox)
680
705
self.refresh()
681
#elif (key == u"end" or key == u"meta >" or key == u"G"
682
# or key == u">"):
683
# pass # xxx end-of-buffer
684
#elif (key == u"home" or key == u"meta <" or key == u"g"
685
# or key == u"<"):
686
# pass # xxx beginning-of-buffer
687
#elif key == u"ctrl e" or key == u"$":
688
# pass # xxx move-end-of-line
689
#elif key == u"ctrl a" or key == u"^":
690
# pass # xxx move-beginning-of-line
691
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
692
# pass # xxx left
693
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
694
# pass # xxx right
695
#elif key == u"a":
696
# pass # scroll up log
697
#elif key == u"z":
698
# pass # scroll down log
706
elif key == "v":
707
if self.log_level == 0:
708
self.log_level = 1
709
self.log_message("Verbose mode: Off")
710
else:
711
self.log_level = 0
712
self.log_message("Verbose mode: On")
713
# elif (key == "end" or key == "meta >" or key == "G"
714
# or key == ">"):
715
# pass # xxx end-of-buffer
716
# elif (key == "home" or key == "meta <" or key == "g"
717
# or key == "<"):
718
# pass # xxx beginning-of-buffer
719
# elif key == "ctrl e" or key == "$":
720
# pass # xxx move-end-of-line
721
# elif key == "ctrl a" or key == "^":
722
# pass # xxx move-beginning-of-line
723
# elif key == "ctrl b" or key == "meta (" or key == "h":
724
# pass # xxx left
725
# elif key == "ctrl f" or key == "meta )" or key == "l":
726
# pass # xxx right
727
# elif key == "a":
728
# pass # scroll up log
729
# elif key == "z":
730
# pass # scroll down log
699
731
elif self.topwidget.selectable():
700
732
self.topwidget.keypress(self.size, key)
701
733
self.refresh()
702
734
return True
703
735
736
704
737
ui = UserInterface()
705
738
try:
706
739
ui.run()
707
740
except KeyboardInterrupt:
708
741
ui.screen.stop()
709
except Exception, e:
710
ui.log_message(unicode(e))
742
except Exception as e:
743
ui.log_message(str(e))
711
744
ui.screen.stop()
712
745
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0