451
429
def entry_group_state_changed(self, state, error):
452
430
"""Derived from the Avahi example code"""
453
log.debug("Avahi entry group state change: %i", state)
431
logger.debug("Avahi entry group state change: %i", state)
455
433
if state == avahi.ENTRY_GROUP_ESTABLISHED:
456
log.debug("Zeroconf service established.")
434
logger.debug("Zeroconf service established.")
457
435
elif state == avahi.ENTRY_GROUP_COLLISION:
458
log.info("Zeroconf service name collision.")
436
logger.info("Zeroconf service name collision.")
460
438
elif state == avahi.ENTRY_GROUP_FAILURE:
461
log.critical("Avahi: Error in group state changed %s",
439
logger.critical("Avahi: Error in group state changed %s",
463
441
raise AvahiGroupError("State changed: {!s}".format(error))
465
443
def cleanup(self):
495
473
except dbus.exceptions.DBusException as error:
496
474
if (error.get_dbus_name()
497
475
== "org.freedesktop.Avahi.CollisionError"):
498
log.info("Local Zeroconf service name collision.")
476
logger.info("Local Zeroconf service name"
499
478
return self.rename(remove=False)
501
log.critical("D-Bus Exception", exc_info=error)
480
logger.critical("D-Bus Exception", exc_info=error)
505
484
if error is None:
506
log.debug("Unknown state: %r", state)
485
logger.debug("Unknown state: %r", state)
508
log.debug("Unknown state: %r: %r", state, error)
487
logger.debug("Unknown state: %r: %r", state, error)
510
489
def activate(self):
511
490
"""Derived from the Avahi example code"""
593
571
# gnutls.strerror()
595
573
if message is None and code is not None:
596
message = gnutls.strerror(code).decode(
597
"utf-8", errors="replace")
574
message = gnutls.strerror(code)
598
575
return super(gnutls.Error, self).__init__(
601
578
class CertificateSecurityError(Error):
605
def __init__(self, cls):
608
def from_param(self, obj):
609
if not isinstance(obj, self.cls):
610
raise TypeError("Not of type {}: {!r}"
611
.format(self.cls.__name__, obj))
612
return ctypes.byref(obj.from_param(obj))
614
class CastToVoidPointer:
615
def __init__(self, cls):
618
def from_param(self, obj):
619
if not isinstance(obj, self.cls):
620
raise TypeError("Not of type {}: {!r}"
621
.format(self.cls.__name__, obj))
622
return ctypes.cast(obj.from_param(obj), ctypes.c_void_p)
624
class With_from_param:
626
def from_param(cls, obj):
627
return obj._as_parameter_
630
class Credentials(With_from_param):
631
583
def __init__(self):
632
self._as_parameter_ = gnutls.certificate_credentials_t()
633
gnutls.certificate_allocate_credentials(self)
584
self._c_object = gnutls.certificate_credentials_t()
585
gnutls.certificate_allocate_credentials(
586
ctypes.byref(self._c_object))
634
587
self.type = gnutls.CRD_CERTIFICATE
636
589
def __del__(self):
637
gnutls.certificate_free_credentials(self)
590
gnutls.certificate_free_credentials(self._c_object)
639
class ClientSession(With_from_param):
640
593
def __init__(self, socket, credentials=None):
641
self._as_parameter_ = gnutls.session_t()
594
self._c_object = gnutls.session_t()
642
595
gnutls_flags = gnutls.CLIENT
643
596
if gnutls.check_version(b"3.5.6"):
644
597
gnutls_flags |= gnutls.NO_TICKETS
645
598
if gnutls.has_rawpk:
646
599
gnutls_flags |= gnutls.ENABLE_RAWPK
647
gnutls.init(self, gnutls_flags)
600
gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
649
gnutls.set_default_priority(self)
650
gnutls.transport_set_ptr(self, socket.fileno())
651
gnutls.handshake_set_private_extensions(self, True)
602
gnutls.set_default_priority(self._c_object)
603
gnutls.transport_set_ptr(self._c_object, socket.fileno())
604
gnutls.handshake_set_private_extensions(self._c_object,
652
606
self.socket = socket
653
607
if credentials is None:
654
608
credentials = gnutls.Credentials()
655
gnutls.credentials_set(self, credentials.type,
609
gnutls.credentials_set(self._c_object, credentials.type,
610
ctypes.cast(credentials._c_object,
657
612
self.credentials = credentials
659
614
def __del__(self):
615
gnutls.deinit(self._c_object)
662
617
def handshake(self):
663
return gnutls.handshake(self)
618
return gnutls.handshake(self._c_object)
665
620
def send(self, data):
666
621
data = bytes(data)
667
622
data_len = len(data)
668
623
while data_len > 0:
669
data_len -= gnutls.record_send(self, data[-data_len:],
624
data_len -= gnutls.record_send(self._c_object,
673
return gnutls.bye(self, gnutls.SHUT_RDWR)
629
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
675
631
# Error handling functions
676
632
def _error_code(result):
677
633
"""A function to raise exceptions on errors, suitable
678
for the "restype" attribute on ctypes functions"""
679
if result >= gnutls.E_SUCCESS:
634
for the 'restype' attribute on ctypes functions"""
681
637
if result == gnutls.E_NO_CERTIFICATE_FOUND:
682
638
raise gnutls.CertificateSecurityError(code=result)
683
639
raise gnutls.Error(code=result)
685
def _retry_on_error(result, func, arguments,
686
_error_code=_error_code):
641
def _retry_on_error(result, func, arguments):
687
642
"""A function to retry on some errors, suitable
688
for the "errcheck" attribute on ctypes functions"""
689
while result < gnutls.E_SUCCESS:
643
for the 'errcheck' attribute on ctypes functions"""
690
645
if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
691
646
return _error_code(result)
692
647
result = func(*arguments)
699
654
priority_set_direct = _library.gnutls_priority_set_direct
700
priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,
655
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
701
656
ctypes.POINTER(ctypes.c_char_p)]
702
657
priority_set_direct.restype = _error_code
704
659
init = _library.gnutls_init
705
init.argtypes = [PointerTo(ClientSession), ctypes.c_int]
660
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
706
661
init.restype = _error_code
708
663
set_default_priority = _library.gnutls_set_default_priority
709
set_default_priority.argtypes = [ClientSession]
664
set_default_priority.argtypes = [session_t]
710
665
set_default_priority.restype = _error_code
712
667
record_send = _library.gnutls_record_send
713
record_send.argtypes = [ClientSession, ctypes.c_void_p,
668
record_send.argtypes = [session_t, ctypes.c_void_p,
715
670
record_send.restype = ctypes.c_ssize_t
716
671
record_send.errcheck = _retry_on_error
718
673
certificate_allocate_credentials = (
719
674
_library.gnutls_certificate_allocate_credentials)
720
675
certificate_allocate_credentials.argtypes = [
721
PointerTo(Credentials)]
676
ctypes.POINTER(certificate_credentials_t)]
722
677
certificate_allocate_credentials.restype = _error_code
724
679
certificate_free_credentials = (
725
680
_library.gnutls_certificate_free_credentials)
726
certificate_free_credentials.argtypes = [Credentials]
681
certificate_free_credentials.argtypes = [
682
certificate_credentials_t]
727
683
certificate_free_credentials.restype = None
729
685
handshake_set_private_extensions = (
730
686
_library.gnutls_handshake_set_private_extensions)
731
handshake_set_private_extensions.argtypes = [ClientSession,
687
handshake_set_private_extensions.argtypes = [session_t,
733
689
handshake_set_private_extensions.restype = None
735
691
credentials_set = _library.gnutls_credentials_set
736
credentials_set.argtypes = [ClientSession, credentials_type_t,
737
CastToVoidPointer(Credentials)]
692
credentials_set.argtypes = [session_t, credentials_type_t,
738
694
credentials_set.restype = _error_code
740
696
strerror = _library.gnutls_strerror
759
715
global_set_log_function.restype = None
761
717
deinit = _library.gnutls_deinit
762
deinit.argtypes = [ClientSession]
718
deinit.argtypes = [session_t]
763
719
deinit.restype = None
765
721
handshake = _library.gnutls_handshake
766
handshake.argtypes = [ClientSession]
767
handshake.restype = ctypes.c_int
722
handshake.argtypes = [session_t]
723
handshake.restype = _error_code
768
724
handshake.errcheck = _retry_on_error
770
726
transport_set_ptr = _library.gnutls_transport_set_ptr
771
transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]
727
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
772
728
transport_set_ptr.restype = None
774
730
bye = _library.gnutls_bye
775
bye.argtypes = [ClientSession, close_request_t]
776
bye.restype = ctypes.c_int
731
bye.argtypes = [session_t, close_request_t]
732
bye.restype = _error_code
777
733
bye.errcheck = _retry_on_error
779
735
check_version = _library.gnutls_check_version
1079
1024
def __del__(self):
1082
def init_checker(self, randomize_start=False):
1083
# Schedule a new checker to be started a randomly selected
1084
# time (a fraction of 'interval') from now. This spreads out
1085
# the startup of checkers over time when the server is
1027
def init_checker(self):
1028
# Schedule a new checker to be started an 'interval' from now,
1029
# and every interval from then on.
1087
1030
if self.checker_initiator_tag is not None:
1088
1031
GLib.source_remove(self.checker_initiator_tag)
1089
interval_milliseconds = int(self.interval.total_seconds()
1092
delay_milliseconds = random.randrange(
1093
interval_milliseconds + 1)
1095
delay_milliseconds = interval_milliseconds
1096
1032
self.checker_initiator_tag = GLib.timeout_add(
1097
delay_milliseconds, self.start_checker, randomize_start)
1098
delay = datetime.timedelta(0, 0, 0, delay_milliseconds)
1099
# A checker might take up to an 'interval' of time, so we can
1100
# expire at the soonest one interval after a checker was
1101
# started. Since the initial checker is delayed, the expire
1102
# time might have to be extended.
1103
now = datetime.datetime.utcnow()
1104
self.expires = now + delay + self.interval
1105
# Schedule a disable() at expire time
1033
int(self.interval.total_seconds() * 1000),
1035
# Schedule a disable() when 'timeout' has passed
1106
1036
if self.disable_initiator_tag is not None:
1107
1037
GLib.source_remove(self.disable_initiator_tag)
1108
1038
self.disable_initiator_tag = GLib.timeout_add(
1109
int((self.expires - now).total_seconds() * 1000),
1039
int(self.timeout.total_seconds() * 1000), self.disable)
1040
# Also start a new checker *right now*.
1041
self.start_checker()
1112
1043
def checker_callback(self, source, condition, connection,
1173
1105
if self.checker is not None and not self.checker.is_alive():
1174
log.warning("Checker was not alive; joining")
1106
logger.warning("Checker was not alive; joining")
1175
1107
self.checker.join()
1176
1108
self.checker = None
1177
1109
# Start a new checker if needed
1178
1110
if self.checker is None:
1179
1111
# Escape attributes for the shell
1180
1112
escaped_attrs = {
1181
attr: shlex.quote(str(getattr(self, attr)))
1113
attr: re.escape(str(getattr(self, attr)))
1182
1114
for attr in self.runtime_expansions}
1184
1116
command = self.checker_command % escaped_attrs
1185
1117
except TypeError as error:
1186
log.error('Could not format string "%s"',
1187
self.checker_command, exc_info=error)
1118
logger.error('Could not format string "%s"',
1119
self.checker_command,
1188
1121
return True # Try again later
1189
1122
self.current_checker_command = command
1190
log.info("Starting checker %r for %s", command, self.name)
1123
logger.info("Starting checker %r for %s", command,
1191
1125
# We don't need to redirect stdout and stderr, since
1192
1126
# in normal mode, that is already done by daemon(),
1193
1127
# and in debug mode we don't want to. (Stdin is
1209
1143
kwargs=popen_args)
1210
1144
self.checker.start()
1211
1145
self.checker_callback_tag = GLib.io_add_watch(
1212
GLib.IOChannel.unix_new(pipe[0].fileno()),
1213
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1146
pipe[0].fileno(), GLib.IO_IN,
1214
1147
self.checker_callback, pipe[0], command)
1215
if start_was_randomized:
1216
# We were started after a random delay; Schedule a new
1217
# checker to be started an 'interval' from now, and every
1218
# interval from then on.
1219
now = datetime.datetime.utcnow()
1220
self.checker_initiator_tag = GLib.timeout_add(
1221
int(self.interval.total_seconds() * 1000),
1223
self.expires = max(self.expires, now + self.interval)
1224
# Don't start a new checker again after same random delay
1226
1148
# Re-run this periodically if run by GLib.timeout_add
2296
2219
class ProxyClient:
2297
2220
def __init__(self, child_pipe, key_id, fpr, address):
2298
2221
self._pipe = child_pipe
2299
self._pipe.send(("init", key_id, fpr, address))
2222
self._pipe.send(('init', key_id, fpr, address))
2300
2223
if not self._pipe.recv():
2301
2224
raise KeyError(key_id or fpr)
2303
2226
def __getattribute__(self, name):
2305
2228
return super(ProxyClient, self).__getattribute__(name)
2306
self._pipe.send(("getattr", name))
2229
self._pipe.send(('getattr', name))
2307
2230
data = self._pipe.recv()
2308
if data[0] == "data":
2231
if data[0] == 'data':
2310
if data[0] == "function":
2233
if data[0] == 'function':
2312
2235
def func(*args, **kwargs):
2313
self._pipe.send(("funcall", name, args, kwargs))
2236
self._pipe.send(('funcall', name, args, kwargs))
2314
2237
return self._pipe.recv()[1]
2318
2241
def __setattr__(self, name, value):
2320
2243
return super(ProxyClient, self).__setattr__(name, value)
2321
self._pipe.send(("setattr", name, value))
2244
self._pipe.send(('setattr', name, value))
2324
2247
class ClientHandler(socketserver.BaseRequestHandler, object):
2330
2253
def handle(self):
2331
2254
with contextlib.closing(self.server.child_pipe) as child_pipe:
2332
log.info("TCP connection from: %s",
2333
str(self.client_address))
2334
log.debug("Pipe FD: %d", self.server.child_pipe.fileno())
2255
logger.info("TCP connection from: %s",
2256
str(self.client_address))
2257
logger.debug("Pipe FD: %d",
2258
self.server.child_pipe.fileno())
2336
2260
session = gnutls.ClientSession(self.request)
2338
# priority = ":".join(("NONE", "+VERS-TLS1.1",
2262
# priority = ':'.join(("NONE", "+VERS-TLS1.1",
2339
2263
# "+AES-256-CBC", "+SHA1",
2340
2264
# "+COMP-NULL", "+CTYPE-OPENPGP",
2343
2267
priority = self.server.gnutls_priority
2344
2268
if priority is None:
2345
2269
priority = "NORMAL"
2346
gnutls.priority_set_direct(session,
2347
priority.encode("utf-8"), None)
2270
gnutls.priority_set_direct(session._c_object,
2271
priority.encode("utf-8"),
2349
2274
# Start communication using the Mandos protocol
2350
2275
# Get protocol number
2351
2276
line = self.request.makefile().readline()
2352
log.debug("Protocol version: %r", line)
2277
logger.debug("Protocol version: %r", line)
2354
2279
if int(line.strip().split()[0]) > 1:
2355
2280
raise RuntimeError(line)
2356
2281
except (ValueError, IndexError, RuntimeError) as error:
2357
log.error("Unknown protocol version: %s", error)
2282
logger.error("Unknown protocol version: %s", error)
2360
2285
# Start GnuTLS connection
2362
2287
session.handshake()
2363
2288
except gnutls.Error as error:
2364
log.warning("Handshake failed: %s", error)
2289
logger.warning("Handshake failed: %s", error)
2365
2290
# Do not run session.bye() here: the session is not
2366
2291
# established. Just abandon the request.
2368
log.debug("Handshake succeeded")
2293
logger.debug("Handshake succeeded")
2370
2295
approval_required = False
2470
2395
except gnutls.Error as error:
2471
log.warning("GnuTLS bye failed", exc_info=error)
2396
logger.warning("GnuTLS bye failed",
2474
2400
def peer_certificate(session):
2475
2401
"Return the peer's certificate as a bytestring"
2477
cert_type = gnutls.certificate_type_get2(
2478
session, gnutls.CTYPE_PEERS)
2403
cert_type = gnutls.certificate_type_get2(session._c_object,
2479
2405
except AttributeError:
2480
cert_type = gnutls.certificate_type_get(session)
2406
cert_type = gnutls.certificate_type_get(session._c_object)
2481
2407
if gnutls.has_rawpk:
2482
2408
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2484
2410
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2485
2411
# If not a valid certificate type...
2486
2412
if cert_type not in valid_cert_types:
2487
log.info("Cert type %r not in %r", cert_type,
2413
logger.info("Cert type %r not in %r", cert_type,
2489
2415
# ...return invalid data
2491
2417
list_size = ctypes.c_uint(1)
2492
2418
cert_list = (gnutls.certificate_get_peers
2493
(session, ctypes.byref(list_size)))
2419
(session._c_object, ctypes.byref(list_size)))
2494
2420
if not bool(cert_list) and list_size.value != 0:
2495
2421
raise gnutls.Error("error getting peer certificate")
2496
2422
if list_size.value == 0:
2675
2600
(self.interface + "\0").encode("utf-8"))
2676
2601
except socket.error as error:
2677
2602
if error.errno == errno.EPERM:
2678
log.error("No permission to bind to interface %s",
2603
logger.error("No permission to bind to"
2604
" interface %s", self.interface)
2680
2605
elif error.errno == errno.ENOPROTOOPT:
2681
log.error("SO_BINDTODEVICE not available; cannot"
2682
" bind to interface %s", self.interface)
2606
logger.error("SO_BINDTODEVICE not available;"
2607
" cannot bind to interface %s",
2683
2609
elif error.errno == errno.ENODEV:
2684
log.error("Interface %s does not exist, cannot"
2685
" bind", self.interface)
2610
logger.error("Interface %s does not exist,"
2611
" cannot bind", self.interface)
2688
2614
# Only bind(2) the socket if we really need to.
2832
2757
def rfc3339_duration_to_delta(duration):
2833
2758
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2835
>>> timedelta = datetime.timedelta
2836
>>> rfc3339_duration_to_delta("P7D") == timedelta(7)
2838
>>> rfc3339_duration_to_delta("PT60S") == timedelta(0, 60)
2840
>>> rfc3339_duration_to_delta("PT60M") == timedelta(0, 3600)
2842
>>> rfc3339_duration_to_delta("PT24H") == timedelta(1)
2844
>>> rfc3339_duration_to_delta("P1W") == timedelta(7)
2846
>>> rfc3339_duration_to_delta("PT5M30S") == timedelta(0, 330)
2848
>>> rfc3339_duration_to_delta("P1DT3M20S") == timedelta(1, 200)
2760
>>> rfc3339_duration_to_delta("P7D")
2761
datetime.timedelta(7)
2762
>>> rfc3339_duration_to_delta("PT60S")
2763
datetime.timedelta(0, 60)
2764
>>> rfc3339_duration_to_delta("PT60M")
2765
datetime.timedelta(0, 3600)
2766
>>> rfc3339_duration_to_delta("PT24H")
2767
datetime.timedelta(1)
2768
>>> rfc3339_duration_to_delta("P1W")
2769
datetime.timedelta(7)
2770
>>> rfc3339_duration_to_delta("PT5M30S")
2771
datetime.timedelta(0, 330)
2772
>>> rfc3339_duration_to_delta("P1DT3M20S")
2773
datetime.timedelta(1, 200)
2853
2776
# Parsing an RFC 3339 duration with regular expressions is not
2933
2856
def string_to_delta(interval):
2934
2857
"""Parse a string and return a datetime.timedelta
2936
>>> string_to_delta("7d") == datetime.timedelta(7)
2938
>>> string_to_delta("60s") == datetime.timedelta(0, 60)
2940
>>> string_to_delta("60m") == datetime.timedelta(0, 3600)
2942
>>> string_to_delta("24h") == datetime.timedelta(1)
2944
>>> string_to_delta("1w") == datetime.timedelta(7)
2946
>>> string_to_delta("5m 30s") == datetime.timedelta(0, 330)
2859
>>> string_to_delta('7d')
2860
datetime.timedelta(7)
2861
>>> string_to_delta('60s')
2862
datetime.timedelta(0, 60)
2863
>>> string_to_delta('60m')
2864
datetime.timedelta(0, 3600)
2865
>>> string_to_delta('24h')
2866
datetime.timedelta(1)
2867
>>> string_to_delta('1w')
2868
datetime.timedelta(7)
2869
>>> string_to_delta('5m 30s')
2870
datetime.timedelta(0, 330)
3337
3265
for key, value in
3338
3266
bytes_old_client_settings.items()}
3339
3267
del bytes_old_client_settings
3340
# .host and .checker_command
3341
3269
for value in old_client_settings.values():
3342
for attribute in ("host", "checker_command"):
3343
if isinstance(value[attribute], bytes):
3344
value[attribute] = (value[attribute]
3270
if isinstance(value["host"], bytes):
3271
value["host"] = (value["host"]
3346
3273
os.remove(stored_state_path)
3347
3274
except IOError as e:
3348
3275
if e.errno == errno.ENOENT:
3349
log.warning("Could not load persistent state:"
3350
" %s", os.strerror(e.errno))
3276
logger.warning("Could not load persistent state:"
3277
" {}".format(os.strerror(e.errno)))
3352
log.critical("Could not load persistent state:",
3279
logger.critical("Could not load persistent state:",
3355
3282
except EOFError as e:
3356
log.warning("Could not load persistent state: EOFError:",
3283
logger.warning("Could not load persistent state: "
3359
3287
with PGPEngine() as pgp:
3360
3288
for client_name, client in clients_data.items():
3387
3315
if client["enabled"]:
3388
3316
if datetime.datetime.utcnow() >= client["expires"]:
3389
3317
if not client["last_checked_ok"]:
3390
log.warning("disabling client %s - Client"
3391
" never performed a successful"
3392
" checker", client_name)
3319
"disabling client {} - Client never "
3320
"performed a successful checker".format(
3393
3322
client["enabled"] = False
3394
3323
elif client["last_checker_status"] != 0:
3395
log.warning("disabling client %s - Client"
3396
" last checker failed with error"
3397
" code %s", client_name,
3398
client["last_checker_status"])
3325
"disabling client {} - Client last"
3326
" checker failed with error code"
3329
client["last_checker_status"]))
3399
3330
client["enabled"] = False
3401
3332
client["expires"] = (
3402
3333
datetime.datetime.utcnow()
3403
3334
+ client["timeout"])
3404
log.debug("Last checker succeeded, keeping %s"
3405
" enabled", client_name)
3335
logger.debug("Last checker succeeded,"
3336
" keeping {} enabled".format(
3407
3339
client["secret"] = pgp.decrypt(
3408
3340
client["encrypted_secret"],
3409
3341
client_settings[client_name]["secret"])
3410
3342
except PGPError:
3411
3343
# If decryption fails, we use secret from new settings
3412
log.debug("Failed to decrypt %s old secret",
3344
logger.debug("Failed to decrypt {} old secret".format(
3414
3346
client["secret"] = (client_settings[client_name]
3649
3581
service.port = tcp_server.socket.getsockname()[1]
3651
log.info("Now listening on address %r, port %d, flowinfo %d,"
3652
" scope_id %d", *tcp_server.socket.getsockname())
3583
logger.info("Now listening on address %r, port %d,"
3584
" flowinfo %d, scope_id %d",
3585
*tcp_server.socket.getsockname())
3654
log.info("Now listening on address %r, port %d",
3655
*tcp_server.socket.getsockname())
3587
logger.info("Now listening on address %r, port %d",
3588
*tcp_server.socket.getsockname())
3657
3590
# service.interface = tcp_server.socket.getsockname()[3]
3663
3596
service.activate()
3664
3597
except dbus.exceptions.DBusException as error:
3665
log.critical("D-Bus Exception", exc_info=error)
3598
logger.critical("D-Bus Exception", exc_info=error)
3668
3601
# End of Avahi example code
3671
GLib.IOChannel.unix_new(tcp_server.fileno()),
3672
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
3673
lambda *args, **kwargs: (tcp_server.handle_request
3674
(*args[2:], **kwargs) or True))
3603
GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3604
lambda *args, **kwargs:
3605
(tcp_server.handle_request
3606
(*args[2:], **kwargs) or True))
3676
log.debug("Starting main loop")
3608
logger.debug("Starting main loop")
3677
3609
main_loop.run()
3678
3610
except AvahiError as error:
3679
log.critical("Avahi Error", exc_info=error)
3611
logger.critical("Avahi Error", exc_info=error)
3682
3614
except KeyboardInterrupt:
3684
3616
print("", file=sys.stderr)
3685
log.debug("Server received KeyboardInterrupt")
3686
log.debug("Server exiting")
3617
logger.debug("Server received KeyboardInterrupt")
3618
logger.debug("Server exiting")
3687
3619
# Must run before the D-Bus bus name gets deregistered
3691
def parse_test_args():
3692
# type: () -> argparse.Namespace
3693
parser = argparse.ArgumentParser(add_help=False)
3694
parser.add_argument("--check", action="store_true")
3695
parser.add_argument("--prefix", )
3696
args, unknown_args = parser.parse_known_args()
3698
# Remove test options from sys.argv
3699
sys.argv[1:] = unknown_args
3702
# Add all tests from doctest strings
3703
def load_tests(loader, tests, none):
3705
tests.addTests(doctest.DocTestSuite())
3708
if __name__ == "__main__":
3709
options = parse_test_args()
3712
extra_test_prefix = options.prefix
3713
if extra_test_prefix is not None:
3714
if not (unittest.main(argv=[""], exit=False)
3715
.result.wasSuccessful()):
3717
class ExtraTestLoader(unittest.TestLoader):
3718
testMethodPrefix = extra_test_prefix
3719
# Call using ./scriptname --test [--verbose]
3720
unittest.main(argv=[""], testLoader=ExtraTestLoader())
3722
unittest.main(argv=[""])
3730
# (lambda (&optional extra)
3731
# (if (not (funcall run-tests-in-test-buffer default-directory
3733
# (funcall show-test-buffer-in-test-window)
3734
# (funcall remove-test-window)
3735
# (if extra (message "Extra tests run successfully!"))))
3736
# run-tests-in-test-buffer:
3737
# (lambda (dir &optional extra)
3738
# (with-current-buffer (get-buffer-create "*Test*")
3739
# (setq buffer-read-only nil
3740
# default-directory dir)
3742
# (compilation-mode))
3743
# (let ((process-result
3744
# (let ((inhibit-read-only t))
3745
# (process-file-shell-command
3746
# (funcall get-command-line extra) nil "*Test*"))))
3747
# (and (numberp process-result)
3748
# (= process-result 0))))
3750
# (lambda (&optional extra)
3751
# (let ((quoted-script
3752
# (shell-quote-argument (funcall get-script-name))))
3754
# (concat "%s --check" (if extra " --prefix=atest" ""))
3758
# (if (fboundp 'file-local-name)
3759
# (file-local-name (buffer-file-name))
3760
# (or (file-remote-p (buffer-file-name) 'localname)
3761
# (buffer-file-name))))
3762
# remove-test-window:
3764
# (let ((test-window (get-buffer-window "*Test*")))
3765
# (if test-window (delete-window test-window))))
3766
# show-test-buffer-in-test-window:
3768
# (when (not (get-buffer-window-list "*Test*"))
3769
# (setq next-error-last-buffer (get-buffer "*Test*"))
3770
# (let* ((side (if (>= (window-width) 146) 'right 'bottom))
3771
# (display-buffer-overriding-action
3772
# `((display-buffer-in-side-window) (side . ,side)
3773
# (window-height . fit-window-to-buffer)
3774
# (window-width . fit-window-to-buffer))))
3775
# (display-buffer "*Test*"))))
3778
# (let* ((run-extra-tests (lambda () (interactive)
3779
# (funcall run-tests t)))
3780
# (inner-keymap `(keymap (116 . ,run-extra-tests))) ; t
3781
# (outer-keymap `(keymap (3 . ,inner-keymap)))) ; C-c
3782
# (setq minor-mode-overriding-map-alist
3783
# (cons `(run-tests . ,outer-keymap)
3784
# minor-mode-overriding-map-alist)))
3785
# (add-hook 'after-save-hook run-tests 90 t))
3623
if __name__ == '__main__':