83
77
seconds = td.seconds % 60,
87
def rfc3339_duration_to_delta(duration):
88
"""Parse an 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 an RFC 3339 duration with regular expressions is not
107
# possible - there would have to be multiple places for the same
108
# values, like seconds. The current code, while more esoteric, is
109
# cleaner 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")
186
80
def string_to_delta(interval):
187
81
"""Parse a string and return a datetime.timedelta
315
204
help="Approve any current client request")
316
205
parser.add_argument("-D", "--deny", action="store_true",
317
206
help="Deny any current client request")
318
parser.add_argument("--check", action="store_true",
319
help="Run self-test")
320
207
parser.add_argument("client", nargs="*", help="Client name")
321
208
options = parser.parse_args()
323
if has_actions(options) and not (options.client or options.all):
210
if has_actions(options) and not options.client and not options.all:
324
211
parser.error("Options require clients names or --all.")
325
212
if options.verbose and has_actions(options):
326
213
parser.error("--verbose can only be used alone or with"
328
215
if options.all and not has_actions(options):
329
216
parser.error("--all requires an action.")
332
fail_count, test_count = doctest.testmod()
333
sys.exit(0 if fail_count == 0 else 1)
336
219
bus = dbus.SystemBus()
397
280
# Process each client in the list by all selected options
398
281
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)))
409
282
if options.remove:
410
283
mandos_serv.RemoveClient(client.__dbus_object_path__)
411
284
if options.enable:
412
set_client_prop("Enabled", dbus.Boolean(True))
285
client.Enable(dbus_interface=client_interface)
413
286
if options.disable:
414
set_client_prop("Enabled", dbus.Boolean(False))
287
client.Disable(dbus_interface=client_interface)
415
288
if options.bump_timeout:
416
set_client_prop("LastCheckedOK", "")
289
client.CheckedOK(dbus_interface=client_interface)
417
290
if options.start_checker:
418
set_client_prop("CheckerRunning", dbus.Boolean(True))
291
client.StartChecker(dbus_interface=client_interface)
419
292
if options.stop_checker:
420
set_client_prop("CheckerRunning", dbus.Boolean(False))
293
client.StopChecker(dbus_interface=client_interface)
421
294
if options.is_enabled:
422
295
sys.exit(0 if client.Get(client_interface,
425
298
dbus.PROPERTIES_IFACE)
427
300
if options.checker is not None:
428
set_client_prop("Checker", options.checker)
301
client.Set(client_interface, "Checker",
303
dbus_interface=dbus.PROPERTIES_IFACE)
429
304
if options.host is not None:
430
set_client_prop("Host", options.host)
305
client.Set(client_interface, "Host", options.host,
306
dbus_interface=dbus.PROPERTIES_IFACE)
431
307
if options.interval is not None:
432
set_client_prop_ms("Interval", options.interval)
308
client.Set(client_interface, "Interval",
309
timedelta_to_milliseconds
310
(string_to_delta(options.interval)),
311
dbus_interface=dbus.PROPERTIES_IFACE)
433
312
if options.approval_delay is not None:
434
set_client_prop_ms("ApprovalDelay",
435
options.approval_delay)
313
client.Set(client_interface, "ApprovalDelay",
314
timedelta_to_milliseconds
315
(string_to_delta(options.
317
dbus_interface=dbus.PROPERTIES_IFACE)
436
318
if options.approval_duration is not None:
437
set_client_prop_ms("ApprovalDuration",
438
options.approval_duration)
319
client.Set(client_interface, "ApprovalDuration",
320
timedelta_to_milliseconds
321
(string_to_delta(options.
323
dbus_interface=dbus.PROPERTIES_IFACE)
439
324
if options.timeout is not None:
440
set_client_prop_ms("Timeout", options.timeout)
325
client.Set(client_interface, "Timeout",
326
timedelta_to_milliseconds
327
(string_to_delta(options.timeout)),
328
dbus_interface=dbus.PROPERTIES_IFACE)
441
329
if options.extended_timeout is not None:
442
set_client_prop_ms("ExtendedTimeout",
443
options.extended_timeout)
330
client.Set(client_interface, "ExtendedTimeout",
331
timedelta_to_milliseconds
332
(string_to_delta(options.extended_timeout)),
333
dbus_interface=dbus.PROPERTIES_IFACE)
444
334
if options.secret is not None:
445
set_client_prop("Secret",
446
dbus.ByteArray(options.secret.read()))
335
client.Set(client_interface, "Secret",
336
dbus.ByteArray(options.secret.read()),
337
dbus_interface=dbus.PROPERTIES_IFACE)
447
338
if options.approved_by_default is not None:
448
set_client_prop("ApprovedByDefault",
450
.approved_by_default))
339
client.Set(client_interface, "ApprovedByDefault",
341
.approved_by_default),
342
dbus_interface=dbus.PROPERTIES_IFACE)
451
343
if options.approve:
452
344
client.Approve(dbus.Boolean(True),
453
345
dbus_interface=client_interface)