394
394
def rename(self, remove=True):
395
395
"""Derived from the Avahi example code"""
396
396
if self.rename_count >= self.max_renames:
397
log.critical("No suitable Zeroconf service name found"
398
" after %i retries, exiting.",
397
logger.critical("No suitable Zeroconf service name found"
398
" after %i retries, exiting.",
400
400
raise AvahiServiceError("Too many renames")
402
402
self.server.GetAlternativeServiceName(self.name))
403
403
self.rename_count += 1
404
log.info("Changing Zeroconf service name to %r ...",
404
logger.info("Changing Zeroconf service name to %r ...",
451
451
def entry_group_state_changed(self, state, error):
452
452
"""Derived from the Avahi example code"""
453
log.debug("Avahi entry group state change: %i", state)
453
logger.debug("Avahi entry group state change: %i", state)
455
455
if state == avahi.ENTRY_GROUP_ESTABLISHED:
456
log.debug("Zeroconf service established.")
456
logger.debug("Zeroconf service established.")
457
457
elif state == avahi.ENTRY_GROUP_COLLISION:
458
log.info("Zeroconf service name collision.")
458
logger.info("Zeroconf service name collision.")
460
460
elif state == avahi.ENTRY_GROUP_FAILURE:
461
log.critical("Avahi: Error in group state changed %s",
461
logger.critical("Avahi: Error in group state changed %s",
463
463
raise AvahiGroupError("State changed: {!s}".format(error))
465
465
def cleanup(self):
495
495
except dbus.exceptions.DBusException as error:
496
496
if (error.get_dbus_name()
497
497
== "org.freedesktop.Avahi.CollisionError"):
498
log.info("Local Zeroconf service name collision.")
498
logger.info("Local Zeroconf service name"
499
500
return self.rename(remove=False)
501
log.critical("D-Bus Exception", exc_info=error)
502
logger.critical("D-Bus Exception", exc_info=error)
505
506
if error is None:
506
log.debug("Unknown state: %r", state)
507
logger.debug("Unknown state: %r", state)
508
log.debug("Unknown state: %r: %r", state, error)
509
logger.debug("Unknown state: %r: %r", state, error)
510
511
def activate(self):
511
512
"""Derived from the Avahi example code"""
573
574
certificate_type_t = ctypes.c_int
575
576
class datum_t(ctypes.Structure):
576
_fields_ = [("data", ctypes.POINTER(ctypes.c_ubyte)),
577
("size", ctypes.c_uint)]
577
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
578
('size', ctypes.c_uint)]
579
class _openpgp_crt_int(ctypes.Structure):
580
class openpgp_crt_int(ctypes.Structure):
581
openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)
582
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
582
583
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
583
584
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
584
585
credentials_type_t = ctypes.c_int
593
594
# gnutls.strerror()
595
596
if message is None and code is not None:
596
message = gnutls.strerror(code).decode(
597
"utf-8", errors="replace")
597
message = gnutls.strerror(code)
598
598
return super(gnutls.Error, self).__init__(
601
601
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
606
def __init__(self):
632
self._as_parameter_ = gnutls.certificate_credentials_t()
633
gnutls.certificate_allocate_credentials(self)
607
self._c_object = gnutls.certificate_credentials_t()
608
gnutls.certificate_allocate_credentials(
609
ctypes.byref(self._c_object))
634
610
self.type = gnutls.CRD_CERTIFICATE
636
612
def __del__(self):
637
gnutls.certificate_free_credentials(self)
613
gnutls.certificate_free_credentials(self._c_object)
639
class ClientSession(With_from_param):
640
616
def __init__(self, socket, credentials=None):
641
self._as_parameter_ = gnutls.session_t()
617
self._c_object = gnutls.session_t()
642
618
gnutls_flags = gnutls.CLIENT
643
619
if gnutls.check_version(b"3.5.6"):
644
620
gnutls_flags |= gnutls.NO_TICKETS
645
621
if gnutls.has_rawpk:
646
622
gnutls_flags |= gnutls.ENABLE_RAWPK
647
gnutls.init(self, gnutls_flags)
623
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)
625
gnutls.set_default_priority(self._c_object)
626
gnutls.transport_set_ptr(self._c_object, socket.fileno())
627
gnutls.handshake_set_private_extensions(self._c_object,
652
629
self.socket = socket
653
630
if credentials is None:
654
631
credentials = gnutls.Credentials()
655
gnutls.credentials_set(self, credentials.type,
632
gnutls.credentials_set(self._c_object, credentials.type,
633
ctypes.cast(credentials._c_object,
657
635
self.credentials = credentials
659
637
def __del__(self):
638
gnutls.deinit(self._c_object)
662
640
def handshake(self):
663
return gnutls.handshake(self)
641
return gnutls.handshake(self._c_object)
665
643
def send(self, data):
666
644
data = bytes(data)
667
645
data_len = len(data)
668
646
while data_len > 0:
669
data_len -= gnutls.record_send(self, data[-data_len:],
647
data_len -= gnutls.record_send(self._c_object,
673
return gnutls.bye(self, gnutls.SHUT_RDWR)
652
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
675
654
# Error handling functions
676
655
def _error_code(result):
677
656
"""A function to raise exceptions on errors, suitable
678
for the "restype" attribute on ctypes functions"""
679
if result >= gnutls.E_SUCCESS:
657
for the 'restype' attribute on ctypes functions"""
681
660
if result == gnutls.E_NO_CERTIFICATE_FOUND:
682
661
raise gnutls.CertificateSecurityError(code=result)
699
678
priority_set_direct = _library.gnutls_priority_set_direct
700
priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,
679
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
701
680
ctypes.POINTER(ctypes.c_char_p)]
702
681
priority_set_direct.restype = _error_code
704
683
init = _library.gnutls_init
705
init.argtypes = [PointerTo(ClientSession), ctypes.c_int]
684
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
706
685
init.restype = _error_code
708
687
set_default_priority = _library.gnutls_set_default_priority
709
set_default_priority.argtypes = [ClientSession]
688
set_default_priority.argtypes = [session_t]
710
689
set_default_priority.restype = _error_code
712
691
record_send = _library.gnutls_record_send
713
record_send.argtypes = [ClientSession, ctypes.c_void_p,
692
record_send.argtypes = [session_t, ctypes.c_void_p,
715
694
record_send.restype = ctypes.c_ssize_t
716
695
record_send.errcheck = _retry_on_error
718
697
certificate_allocate_credentials = (
719
698
_library.gnutls_certificate_allocate_credentials)
720
699
certificate_allocate_credentials.argtypes = [
721
PointerTo(Credentials)]
700
ctypes.POINTER(certificate_credentials_t)]
722
701
certificate_allocate_credentials.restype = _error_code
724
703
certificate_free_credentials = (
725
704
_library.gnutls_certificate_free_credentials)
726
certificate_free_credentials.argtypes = [Credentials]
705
certificate_free_credentials.argtypes = [
706
certificate_credentials_t]
727
707
certificate_free_credentials.restype = None
729
709
handshake_set_private_extensions = (
730
710
_library.gnutls_handshake_set_private_extensions)
731
handshake_set_private_extensions.argtypes = [ClientSession,
711
handshake_set_private_extensions.argtypes = [session_t,
733
713
handshake_set_private_extensions.restype = None
735
715
credentials_set = _library.gnutls_credentials_set
736
credentials_set.argtypes = [ClientSession, credentials_type_t,
737
CastToVoidPointer(Credentials)]
716
credentials_set.argtypes = [session_t, credentials_type_t,
738
718
credentials_set.restype = _error_code
740
720
strerror = _library.gnutls_strerror
759
739
global_set_log_function.restype = None
761
741
deinit = _library.gnutls_deinit
762
deinit.argtypes = [ClientSession]
742
deinit.argtypes = [session_t]
763
743
deinit.restype = None
765
745
handshake = _library.gnutls_handshake
766
handshake.argtypes = [ClientSession]
767
handshake.restype = ctypes.c_int
746
handshake.argtypes = [session_t]
747
handshake.restype = _error_code
768
748
handshake.errcheck = _retry_on_error
770
750
transport_set_ptr = _library.gnutls_transport_set_ptr
771
transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]
751
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
772
752
transport_set_ptr.restype = None
774
754
bye = _library.gnutls_bye
775
bye.argtypes = [ClientSession, close_request_t]
776
bye.restype = ctypes.c_int
755
bye.argtypes = [session_t, close_request_t]
756
bye.restype = _error_code
777
757
bye.errcheck = _retry_on_error
779
759
check_version = _library.gnutls_check_version
1106
1086
self.last_checker_status = returncode
1107
1087
self.last_checker_signal = None
1108
1088
if self.last_checker_status == 0:
1109
log.info("Checker for %(name)s succeeded", vars(self))
1089
logger.info("Checker for %(name)s succeeded",
1110
1091
self.checked_ok()
1112
log.info("Checker for %(name)s failed", vars(self))
1093
logger.info("Checker for %(name)s failed", vars(self))
1114
1095
self.last_checker_status = -1
1115
1096
self.last_checker_signal = -returncode
1116
log.warning("Checker for %(name)s crashed?", vars(self))
1097
logger.warning("Checker for %(name)s crashed?",
1119
1101
def checked_ok(self):
1166
1148
command = self.checker_command % escaped_attrs
1167
1149
except TypeError as error:
1168
log.error('Could not format string "%s"',
1169
self.checker_command, exc_info=error)
1150
logger.error('Could not format string "%s"',
1151
self.checker_command,
1170
1153
return True # Try again later
1171
1154
self.current_checker_command = command
1172
log.info("Starting checker %r for %s", command, self.name)
1155
logger.info("Starting checker %r for %s", command,
1173
1157
# We don't need to redirect stdout and stderr, since
1174
1158
# in normal mode, that is already done by daemon(),
1175
1159
# and in debug mode we don't want to. (Stdin is
2267
2251
class ProxyClient:
2268
2252
def __init__(self, child_pipe, key_id, fpr, address):
2269
2253
self._pipe = child_pipe
2270
self._pipe.send(("init", key_id, fpr, address))
2254
self._pipe.send(('init', key_id, fpr, address))
2271
2255
if not self._pipe.recv():
2272
2256
raise KeyError(key_id or fpr)
2274
2258
def __getattribute__(self, name):
2276
2260
return super(ProxyClient, self).__getattribute__(name)
2277
self._pipe.send(("getattr", name))
2261
self._pipe.send(('getattr', name))
2278
2262
data = self._pipe.recv()
2279
if data[0] == "data":
2263
if data[0] == 'data':
2281
if data[0] == "function":
2265
if data[0] == 'function':
2283
2267
def func(*args, **kwargs):
2284
self._pipe.send(("funcall", name, args, kwargs))
2268
self._pipe.send(('funcall', name, args, kwargs))
2285
2269
return self._pipe.recv()[1]
2289
2273
def __setattr__(self, name, value):
2291
2275
return super(ProxyClient, self).__setattr__(name, value)
2292
self._pipe.send(("setattr", name, value))
2276
self._pipe.send(('setattr', name, value))
2295
2279
class ClientHandler(socketserver.BaseRequestHandler, object):
2301
2285
def handle(self):
2302
2286
with contextlib.closing(self.server.child_pipe) as child_pipe:
2303
log.info("TCP connection from: %s",
2304
str(self.client_address))
2305
log.debug("Pipe FD: %d", self.server.child_pipe.fileno())
2287
logger.info("TCP connection from: %s",
2288
str(self.client_address))
2289
logger.debug("Pipe FD: %d",
2290
self.server.child_pipe.fileno())
2307
2292
session = gnutls.ClientSession(self.request)
2309
# priority = ":".join(("NONE", "+VERS-TLS1.1",
2294
# priority = ':'.join(("NONE", "+VERS-TLS1.1",
2310
2295
# "+AES-256-CBC", "+SHA1",
2311
2296
# "+COMP-NULL", "+CTYPE-OPENPGP",
2314
2299
priority = self.server.gnutls_priority
2315
2300
if priority is None:
2316
2301
priority = "NORMAL"
2317
gnutls.priority_set_direct(session,
2318
priority.encode("utf-8"), None)
2302
gnutls.priority_set_direct(session._c_object,
2303
priority.encode("utf-8"),
2320
2306
# Start communication using the Mandos protocol
2321
2307
# Get protocol number
2322
2308
line = self.request.makefile().readline()
2323
log.debug("Protocol version: %r", line)
2309
logger.debug("Protocol version: %r", line)
2325
2311
if int(line.strip().split()[0]) > 1:
2326
2312
raise RuntimeError(line)
2327
2313
except (ValueError, IndexError, RuntimeError) as error:
2328
log.error("Unknown protocol version: %s", error)
2314
logger.error("Unknown protocol version: %s", error)
2331
2317
# Start GnuTLS connection
2333
2319
session.handshake()
2334
2320
except gnutls.Error as error:
2335
log.warning("Handshake failed: %s", error)
2321
logger.warning("Handshake failed: %s", error)
2336
2322
# Do not run session.bye() here: the session is not
2337
2323
# established. Just abandon the request.
2339
log.debug("Handshake succeeded")
2325
logger.debug("Handshake succeeded")
2341
2327
approval_required = False
2441
2427
except gnutls.Error as error:
2442
log.warning("GnuTLS bye failed", exc_info=error)
2428
logger.warning("GnuTLS bye failed",
2445
2432
def peer_certificate(session):
2446
2433
"Return the peer's certificate as a bytestring"
2448
cert_type = gnutls.certificate_type_get2(
2449
session, gnutls.CTYPE_PEERS)
2435
cert_type = gnutls.certificate_type_get2(session._c_object,
2450
2437
except AttributeError:
2451
cert_type = gnutls.certificate_type_get(session)
2438
cert_type = gnutls.certificate_type_get(session._c_object)
2452
2439
if gnutls.has_rawpk:
2453
2440
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2455
2442
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2456
2443
# If not a valid certificate type...
2457
2444
if cert_type not in valid_cert_types:
2458
log.info("Cert type %r not in %r", cert_type,
2445
logger.info("Cert type %r not in %r", cert_type,
2460
2447
# ...return invalid data
2462
2449
list_size = ctypes.c_uint(1)
2463
2450
cert_list = (gnutls.certificate_get_peers
2464
(session, ctypes.byref(list_size)))
2451
(session._c_object, ctypes.byref(list_size)))
2465
2452
if not bool(cert_list) and list_size.value != 0:
2466
2453
raise gnutls.Error("error getting peer certificate")
2467
2454
if list_size.value == 0:
2646
2633
(self.interface + "\0").encode("utf-8"))
2647
2634
except socket.error as error:
2648
2635
if error.errno == errno.EPERM:
2649
log.error("No permission to bind to interface %s",
2636
logger.error("No permission to bind to"
2637
" interface %s", self.interface)
2651
2638
elif error.errno == errno.ENOPROTOOPT:
2652
log.error("SO_BINDTODEVICE not available; cannot"
2653
" bind to interface %s", self.interface)
2639
logger.error("SO_BINDTODEVICE not available;"
2640
" cannot bind to interface %s",
2654
2642
elif error.errno == errno.ENODEV:
2655
log.error("Interface %s does not exist, cannot"
2656
" bind", self.interface)
2643
logger.error("Interface %s does not exist,"
2644
" cannot bind", self.interface)
2659
2647
# Only bind(2) the socket if we really need to.
2774
2762
# remove the old hook in favor of the new above hook on
2777
if command == "funcall":
2765
if command == 'funcall':
2778
2766
funcname = request[1]
2779
2767
args = request[2]
2780
2768
kwargs = request[3]
2782
parent_pipe.send(("data", getattr(client_object,
2770
parent_pipe.send(('data', getattr(client_object,
2783
2771
funcname)(*args,
2786
if command == "getattr":
2774
if command == 'getattr':
2787
2775
attrname = request[1]
2788
2776
if isinstance(client_object.__getattribute__(attrname),
2789
2777
collections.abc.Callable):
2790
parent_pipe.send(("function", ))
2778
parent_pipe.send(('function', ))
2792
2780
parent_pipe.send((
2793
"data", client_object.__getattribute__(attrname)))
2781
'data', client_object.__getattribute__(attrname)))
2795
if command == "setattr":
2783
if command == 'setattr':
2796
2784
attrname = request[1]
2797
2785
value = request[2]
2798
2786
setattr(client_object, attrname, value)
2904
2892
def string_to_delta(interval):
2905
2893
"""Parse a string and return a datetime.timedelta
2907
>>> string_to_delta("7d") == datetime.timedelta(7)
2909
>>> string_to_delta("60s") == datetime.timedelta(0, 60)
2911
>>> string_to_delta("60m") == datetime.timedelta(0, 3600)
2913
>>> string_to_delta("24h") == datetime.timedelta(1)
2915
>>> string_to_delta("1w") == datetime.timedelta(7)
2917
>>> string_to_delta("5m 30s") == datetime.timedelta(0, 330)
2895
>>> string_to_delta('7d') == datetime.timedelta(7)
2897
>>> string_to_delta('60s') == datetime.timedelta(0, 60)
2899
>>> string_to_delta('60m') == datetime.timedelta(0, 3600)
2901
>>> string_to_delta('24h') == datetime.timedelta(1)
2903
>>> string_to_delta('1w') == datetime.timedelta(7)
2905
>>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
3316
3305
os.remove(stored_state_path)
3317
3306
except IOError as e:
3318
3307
if e.errno == errno.ENOENT:
3319
log.warning("Could not load persistent state:"
3320
" %s", os.strerror(e.errno))
3308
logger.warning("Could not load persistent state:"
3309
" {}".format(os.strerror(e.errno)))
3322
log.critical("Could not load persistent state:",
3311
logger.critical("Could not load persistent state:",
3325
3314
except EOFError as e:
3326
log.warning("Could not load persistent state: EOFError:",
3315
logger.warning("Could not load persistent state: "
3329
3319
with PGPEngine() as pgp:
3330
3320
for client_name, client in clients_data.items():
3357
3347
if client["enabled"]:
3358
3348
if datetime.datetime.utcnow() >= client["expires"]:
3359
3349
if not client["last_checked_ok"]:
3360
log.warning("disabling client %s - Client"
3361
" never performed a successful"
3362
" checker", client_name)
3351
"disabling client {} - Client never "
3352
"performed a successful checker".format(
3363
3354
client["enabled"] = False
3364
3355
elif client["last_checker_status"] != 0:
3365
log.warning("disabling client %s - Client"
3366
" last checker failed with error"
3367
" code %s", client_name,
3368
client["last_checker_status"])
3357
"disabling client {} - Client last"
3358
" checker failed with error code"
3361
client["last_checker_status"]))
3369
3362
client["enabled"] = False
3371
3364
client["expires"] = (
3372
3365
datetime.datetime.utcnow()
3373
3366
+ client["timeout"])
3374
log.debug("Last checker succeeded, keeping %s"
3375
" enabled", client_name)
3367
logger.debug("Last checker succeeded,"
3368
" keeping {} enabled".format(
3377
3371
client["secret"] = pgp.decrypt(
3378
3372
client["encrypted_secret"],
3379
3373
client_settings[client_name]["secret"])
3380
3374
except PGPError:
3381
3375
# If decryption fails, we use secret from new settings
3382
log.debug("Failed to decrypt %s old secret",
3376
logger.debug("Failed to decrypt {} old secret".format(
3384
3378
client["secret"] = (client_settings[client_name]
3619
3613
service.port = tcp_server.socket.getsockname()[1]
3621
log.info("Now listening on address %r, port %d, flowinfo %d,"
3622
" scope_id %d", *tcp_server.socket.getsockname())
3615
logger.info("Now listening on address %r, port %d,"
3616
" flowinfo %d, scope_id %d",
3617
*tcp_server.socket.getsockname())
3624
log.info("Now listening on address %r, port %d",
3625
*tcp_server.socket.getsockname())
3619
logger.info("Now listening on address %r, port %d",
3620
*tcp_server.socket.getsockname())
3627
3622
# service.interface = tcp_server.socket.getsockname()[3]
3643
3638
lambda *args, **kwargs: (tcp_server.handle_request
3644
3639
(*args[2:], **kwargs) or True))
3646
log.debug("Starting main loop")
3641
logger.debug("Starting main loop")
3647
3642
main_loop.run()
3648
3643
except AvahiError as error:
3649
log.critical("Avahi Error", exc_info=error)
3644
logger.critical("Avahi Error", exc_info=error)
3652
3647
except KeyboardInterrupt:
3654
3649
print("", file=sys.stderr)
3655
log.debug("Server received KeyboardInterrupt")
3656
log.debug("Server exiting")
3650
logger.debug("Server received KeyboardInterrupt")
3651
logger.debug("Server exiting")
3657
3652
# Must run before the D-Bus bus name gets deregistered
3661
def parse_test_args():
3662
# type: () -> argparse.Namespace
3656
def should_only_run_tests():
3663
3657
parser = argparse.ArgumentParser(add_help=False)
3664
parser.add_argument("--check", action="store_true")
3665
parser.add_argument("--prefix", )
3658
parser.add_argument("--check", action='store_true')
3666
3659
args, unknown_args = parser.parse_known_args()
3668
# Remove test options from sys.argv
3660
run_tests = args.check
3662
# Remove --check argument from sys.argv
3669
3663
sys.argv[1:] = unknown_args
3672
3666
# Add all tests from doctest strings
3673
3667
def load_tests(loader, tests, none):
3675
3669
tests.addTests(doctest.DocTestSuite())
3678
if __name__ == "__main__":
3679
options = parse_test_args()
3672
if __name__ == '__main__':
3682
extra_test_prefix = options.prefix
3683
if extra_test_prefix is not None:
3684
if not (unittest.main(argv=[""], exit=False)
3685
.result.wasSuccessful()):
3687
class ExtraTestLoader(unittest.TestLoader):
3688
testMethodPrefix = extra_test_prefix
3689
# Call using ./scriptname --test [--verbose]
3690
unittest.main(argv=[""], testLoader=ExtraTestLoader())
3692
unittest.main(argv=[""])
3674
if should_only_run_tests():
3675
# Call using ./mandos --check [--verbose]
3696
3680
logging.shutdown()
3700
# (lambda (&optional extra)
3701
# (if (not (funcall run-tests-in-test-buffer default-directory
3703
# (funcall show-test-buffer-in-test-window)
3704
# (funcall remove-test-window)
3705
# (if extra (message "Extra tests run successfully!"))))
3706
# run-tests-in-test-buffer:
3707
# (lambda (dir &optional extra)
3708
# (with-current-buffer (get-buffer-create "*Test*")
3709
# (setq buffer-read-only nil
3710
# default-directory dir)
3712
# (compilation-mode))
3713
# (let ((process-result
3714
# (let ((inhibit-read-only t))
3715
# (process-file-shell-command
3716
# (funcall get-command-line extra) nil "*Test*"))))
3717
# (and (numberp process-result)
3718
# (= process-result 0))))
3720
# (lambda (&optional extra)
3721
# (let ((quoted-script
3722
# (shell-quote-argument (funcall get-script-name))))
3724
# (concat "%s --check" (if extra " --prefix=atest" ""))
3728
# (if (fboundp 'file-local-name)
3729
# (file-local-name (buffer-file-name))
3730
# (or (file-remote-p (buffer-file-name) 'localname)
3731
# (buffer-file-name))))
3732
# remove-test-window:
3734
# (let ((test-window (get-buffer-window "*Test*")))
3735
# (if test-window (delete-window test-window))))
3736
# show-test-buffer-in-test-window:
3738
# (when (not (get-buffer-window-list "*Test*"))
3739
# (setq next-error-last-buffer (get-buffer "*Test*"))
3740
# (let* ((side (if (>= (window-width) 146) 'right 'bottom))
3741
# (display-buffer-overriding-action
3742
# `((display-buffer-in-side-window) (side . ,side)
3743
# (window-height . fit-window-to-buffer)
3744
# (window-width . fit-window-to-buffer))))
3745
# (display-buffer "*Test*"))))
3748
# (let* ((run-extra-tests (lambda () (interactive)
3749
# (funcall run-tests t)))
3750
# (inner-keymap `(keymap (116 . ,run-extra-tests))) ; t
3751
# (outer-keymap `(keymap (3 . ,inner-keymap)))) ; C-c
3752
# (setq minor-mode-overriding-map-alist
3753
# (cons `(run-tests . ,outer-keymap)
3754
# minor-mode-overriding-map-alist)))
3755
# (add-hook 'after-save-hook run-tests 90 t))