77
83
seconds = td.seconds % 60,
87
def rfc3339_duration_to_delta(duration):
88
"""Parse a RFC 3339 "duration" and return a datetime.timedelta
90
>>> rfc3339_duration_to_delta("P7D")
92
>>> rfc3339_duration_to_delta("PT60S")
93
datetime.timedelta(0, 60)
94
>>> rfc3339_duration_to_delta("PT60M")
95
datetime.timedelta(0, 3600)
96
>>> rfc3339_duration_to_delta("PT24H")
98
>>> rfc3339_duration_to_delta("P1W")
100
>>> rfc3339_duration_to_delta("PT5M30S")
101
datetime.timedelta(0, 330)
102
>>> rfc3339_duration_to_delta("P1DT3M20S")
103
datetime.timedelta(1, 200)
106
# Parsing a RFC 3339 duration with regular expressions is not
107
# possible - there would have to be multiple places for the same
108
# values, like seconds. This, while more esoteric, is cleaner
109
# without depending on a parsing library. If Python had a
110
# built-in library for parsing we would use it, but we'd like to
111
# avoid excessive use of external libraries.
113
# New type for defining tokens, syntax, and semantics all-in-one
114
Token = collections.namedtuple("Token",
115
("regexp", # To match token; if
116
# "value" is not None,
117
# must have a "group"
119
"value", # datetime.timedelta or
121
"followers")) # Tokens valid after
123
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
124
# the "duration" ABNF definition in RFC 3339, Appendix A.
125
token_end = Token(re.compile(r"$"), None, frozenset())
126
token_second = Token(re.compile(r"(\d+)S"),
127
datetime.timedelta(seconds=1),
128
frozenset((token_end,)))
129
token_minute = Token(re.compile(r"(\d+)M"),
130
datetime.timedelta(minutes=1),
131
frozenset((token_second, token_end)))
132
token_hour = Token(re.compile(r"(\d+)H"),
133
datetime.timedelta(hours=1),
134
frozenset((token_minute, token_end)))
135
token_time = Token(re.compile(r"T"),
137
frozenset((token_hour, token_minute,
139
token_day = Token(re.compile(r"(\d+)D"),
140
datetime.timedelta(days=1),
141
frozenset((token_time, token_end)))
142
token_month = Token(re.compile(r"(\d+)M"),
143
datetime.timedelta(weeks=4),
144
frozenset((token_day, token_end)))
145
token_year = Token(re.compile(r"(\d+)Y"),
146
datetime.timedelta(weeks=52),
147
frozenset((token_month, token_end)))
148
token_week = Token(re.compile(r"(\d+)W"),
149
datetime.timedelta(weeks=1),
150
frozenset((token_end,)))
151
token_duration = Token(re.compile(r"P"), None,
152
frozenset((token_year, token_month,
153
token_day, token_time,
155
# Define starting values
156
value = datetime.timedelta() # Value so far
158
followers = frozenset(token_duration,) # Following valid tokens
159
s = duration # String left to parse
160
# Loop until end token is found
161
while found_token is not token_end:
162
# Search for any currently valid tokens
163
for token in followers:
164
match = token.regexp.match(s)
165
if match is not None:
167
if token.value is not None:
168
# Value found, parse digits
169
factor = int(match.group(1), 10)
170
# Add to value so far
171
value += factor * token.value
172
# Strip token from string
173
s = token.regexp.sub("", s, 1)
176
# Set valid next tokens
177
followers = found_token.followers
180
# No currently valid tokens were found
181
raise ValueError("Invalid RFC 3339 duration")
80
186
def string_to_delta(interval):
81
187
"""Parse a string and return a datetime.timedelta
204
315
help="Approve any current client request")
205
316
parser.add_argument("-D", "--deny", action="store_true",
206
317
help="Deny any current client request")
318
parser.add_argument("--check", action="store_true",
319
help="Run self-test")
207
320
parser.add_argument("client", nargs="*", help="Client name")
208
321
options = parser.parse_args()
210
if has_actions(options) and not options.client and not options.all:
323
if has_actions(options) and not (options.client or options.all):
211
324
parser.error("Options require clients names or --all.")
212
325
if options.verbose and has_actions(options):
213
326
parser.error("--verbose can only be used alone or with"
215
328
if options.all and not has_actions(options):
216
329
parser.error("--all requires an action.")
332
fail_count, test_count = doctest.testmod()
333
sys.exit(0 if fail_count == 0 else 1)
219
336
bus = dbus.SystemBus()
280
397
# Process each client in the list by all selected options
281
398
for client in clients:
399
def set_client_prop(prop, value):
400
"""Set a Client D-Bus property"""
401
client.Set(client_interface, prop, value,
402
dbus_interface=dbus.PROPERTIES_IFACE)
403
def set_client_prop_ms(prop, value):
404
"""Set a Client D-Bus property, converted
405
from a string to milliseconds."""
406
set_client_prop(prop,
407
timedelta_to_milliseconds
408
(string_to_delta(value)))
282
409
if options.remove:
283
410
mandos_serv.RemoveClient(client.__dbus_object_path__)
284
411
if options.enable:
285
client.Enable(dbus_interface=client_interface)
412
set_client_prop("Enabled", dbus.Boolean(True))
286
413
if options.disable:
287
client.Disable(dbus_interface=client_interface)
414
set_client_prop("Enabled", dbus.Boolean(False))
288
415
if options.bump_timeout:
289
client.CheckedOK(dbus_interface=client_interface)
416
set_client_prop("LastCheckedOK", "")
290
417
if options.start_checker:
291
client.StartChecker(dbus_interface=client_interface)
418
set_client_prop("CheckerRunning", dbus.Boolean(True))
292
419
if options.stop_checker:
293
client.StopChecker(dbus_interface=client_interface)
420
set_client_prop("CheckerRunning", dbus.Boolean(False))
294
421
if options.is_enabled:
295
422
sys.exit(0 if client.Get(client_interface,
298
425
dbus.PROPERTIES_IFACE)
300
427
if options.checker is not None:
301
client.Set(client_interface, "Checker",
303
dbus_interface=dbus.PROPERTIES_IFACE)
428
set_client_prop("Checker", options.checker)
304
429
if options.host is not None:
305
client.Set(client_interface, "Host", options.host,
306
dbus_interface=dbus.PROPERTIES_IFACE)
430
set_client_prop("Host", options.host)
307
431
if options.interval is not None:
308
client.Set(client_interface, "Interval",
309
timedelta_to_milliseconds
310
(string_to_delta(options.interval)),
311
dbus_interface=dbus.PROPERTIES_IFACE)
432
set_client_prop_ms("Interval", options.interval)
312
433
if options.approval_delay is not None:
313
client.Set(client_interface, "ApprovalDelay",
314
timedelta_to_milliseconds
315
(string_to_delta(options.
317
dbus_interface=dbus.PROPERTIES_IFACE)
434
set_client_prop_ms("ApprovalDelay",
435
options.approval_delay)
318
436
if options.approval_duration is not None:
319
client.Set(client_interface, "ApprovalDuration",
320
timedelta_to_milliseconds
321
(string_to_delta(options.
323
dbus_interface=dbus.PROPERTIES_IFACE)
437
set_client_prop_ms("ApprovalDuration",
438
options.approval_duration)
324
439
if options.timeout is not None:
325
client.Set(client_interface, "Timeout",
326
timedelta_to_milliseconds
327
(string_to_delta(options.timeout)),
328
dbus_interface=dbus.PROPERTIES_IFACE)
440
set_client_prop_ms("Timeout", options.timeout)
329
441
if options.extended_timeout is not None:
330
client.Set(client_interface, "ExtendedTimeout",
331
timedelta_to_milliseconds
332
(string_to_delta(options.extended_timeout)),
333
dbus_interface=dbus.PROPERTIES_IFACE)
442
set_client_prop_ms("ExtendedTimeout",
443
options.extended_timeout)
334
444
if options.secret is not None:
335
client.Set(client_interface, "Secret",
336
dbus.ByteArray(options.secret.read()),
337
dbus_interface=dbus.PROPERTIES_IFACE)
445
set_client_prop("Secret",
446
dbus.ByteArray(options.secret.read()))
338
447
if options.approved_by_default is not None:
339
client.Set(client_interface, "ApprovedByDefault",
341
.approved_by_default),
342
dbus_interface=dbus.PROPERTIES_IFACE)
448
set_client_prop("ApprovedByDefault",
450
.approved_by_default))
343
451
if options.approve:
344
452
client.Approve(dbus.Boolean(True),
345
453
dbus_interface=client_interface)