11
11
# "AvahiService" class, and some lines in "main".
13
13
# Everything else is
14
# Copyright © 2008-2011 Teddy Hogeborn
15
# Copyright © 2008-2011 Björn Påhlsson
14
# Copyright © 2008-2012 Teddy Hogeborn
15
# Copyright © 2008-2012 Björn Påhlsson
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
175
177
def encrypt(self, data, password):
176
178
self.gnupg.passphrase = self.password_encode(password)
177
with open(os.devnull) as devnull:
179
with open(os.devnull, "w") as devnull:
179
181
proc = self.gnupg.run(['--symmetric'],
180
182
create_fhs=['stdin', 'stdout'],
192
194
def decrypt(self, data, password):
193
195
self.gnupg.passphrase = self.password_encode(password)
194
with open(os.devnull) as devnull:
196
with open(os.devnull, "w") as devnull:
196
198
proc = self.gnupg.run(['--decrypt'],
197
199
create_fhs=['stdin', 'stdout'],
198
200
attach_fhs={'stderr': devnull})
199
with contextlib.closing(proc.handles['stdin'] ) as f:
201
with contextlib.closing(proc.handles['stdin']) as f:
201
203
with contextlib.closing(proc.handles['stdout']) as f:
202
204
decrypted_plaintext = f.read()
373
382
"""Add the new name to the syslog messages"""
374
383
ret = AvahiService.rename(self)
375
384
syslogger.setFormatter(logging.Formatter
376
('Mandos (%s) [%%(process)d]:'
377
' %%(levelname)s: %%(message)s'
385
('Mandos ({0}) [%(process)d]:'
386
' %(levelname)s: %(message)s'
381
390
def timedelta_to_milliseconds(td):
414
423
last_checked_ok: datetime.datetime(); (UTC) or None
415
424
last_checker_status: integer between 0 and 255 reflecting exit
416
425
status of last checker. -1 reflects crashed
426
checker, -2 means no checker completed yet.
418
427
last_enabled: datetime.datetime(); (UTC) or None
419
428
name: string; from the config file, used in log messages and
420
429
D-Bus identifiers
421
430
secret: bytestring; sent verbatim (over TLS) to client
422
431
timeout: datetime.timedelta(); How long from last_checked_ok
423
432
until this client is disabled
424
extended_timeout: extra long timeout when password has been sent
433
extended_timeout: extra long timeout when secret has been sent
425
434
runtime_expansions: Allowed attributes for runtime expansion.
426
435
expires: datetime.datetime(); time (UTC) when a client will be
427
436
disabled, or None
457
466
def approval_delay_milliseconds(self):
458
467
return timedelta_to_milliseconds(self.approval_delay)
461
470
def config_parser(config):
462
""" Construct a new dict of client settings of this form:
471
"""Construct a new dict of client settings of this form:
463
472
{ client_name: {setting_name: value, ...}, ...}
464
with exceptions for any special settings as defined above"""
473
with exceptions for any special settings as defined above.
474
NOTE: Must be a pure function. Must return the same result
475
value given the same arguments.
466
478
for client_name in config.sections():
467
479
section = dict(config.items(client_name))
496
509
client["checker_command"] = section["checker"]
497
510
client["last_approval_request"] = None
498
511
client["last_checked_ok"] = None
499
client["last_checker_status"] = None
500
if client["enabled"]:
501
client["last_enabled"] = datetime.datetime.utcnow()
502
client["expires"] = (datetime.datetime.utcnow()
505
client["last_enabled"] = None
506
client["expires"] = None
512
client["last_checker_status"] = -2
511
516
def __init__(self, settings, name = None):
512
"""Note: the 'checker' key in 'config' sets the
513
'checker_command' attribute and *not* the 'checker'
516
518
# adding all client settings
517
519
for setting, value in settings.iteritems():
518
520
setattr(self, setting, value)
523
if not hasattr(self, "last_enabled"):
524
self.last_enabled = datetime.datetime.utcnow()
525
if not hasattr(self, "expires"):
526
self.expires = (datetime.datetime.utcnow()
529
self.last_enabled = None
520
532
logger.debug("Creating client %r", self.name)
521
533
# Uppercase and remove spaces from fingerprint for later
522
534
# comparison purposes with return value from the fingerprint()
524
536
logger.debug(" Fingerprint: %s", self.fingerprint)
525
self.created = settings.get("created", datetime.datetime.utcnow())
537
self.created = settings.get("created",
538
datetime.datetime.utcnow())
527
540
# attributes specific for this server instance
528
541
self.checker = None
529
542
self.checker_initiator_tag = None
617
630
logger.warning("Checker for %(name)s crashed?",
620
def checked_ok(self, timeout=None):
621
"""Bump up the timeout for this client.
623
This should only be called when the client has been seen,
633
def checked_ok(self):
634
"""Assert that the client has been seen, alive and well."""
635
self.last_checked_ok = datetime.datetime.utcnow()
636
self.last_checker_status = 0
639
def bump_timeout(self, timeout=None):
640
"""Bump up the timeout for this client."""
626
641
if timeout is None:
627
642
timeout = self.timeout
628
self.last_checked_ok = datetime.datetime.utcnow()
629
643
if self.disable_initiator_tag is not None:
630
644
gobject.source_remove(self.disable_initiator_tag)
631
645
if getattr(self, "enabled", False):
683
697
command = self.checker_command % escaped_attrs
684
698
except TypeError as error:
685
logger.error('Could not format string "%s":'
686
' %s', self.checker_command, error)
699
logger.error('Could not format string "%s"',
700
self.checker_command, exc_info=error)
687
701
return True # Try again later
688
702
self.current_checker_command = command
778
def dbus_interface_annotations(dbus_interface):
779
"""Decorator for marking functions returning interface annotations
783
@dbus_interface_annotations("org.example.Interface")
784
def _foo(self): # Function name does not matter
785
return {"org.freedesktop.DBus.Deprecated": "true",
786
"org.freedesktop.DBus.Property.EmitsChangedSignal":
790
func._dbus_is_interface = True
791
func._dbus_interface = dbus_interface
792
func._dbus_name = dbus_interface
797
def dbus_annotations(annotations):
798
"""Decorator to annotate D-Bus methods, signals or properties
801
@dbus_service_property("org.example.Interface", signature="b",
803
@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
804
"org.freedesktop.DBus.Property."
805
"EmitsChangedSignal": "false"})
806
def Property_dbus_property(self):
807
return dbus.Boolean(False)
810
func._dbus_annotations = annotations
764
815
class DBusPropertyException(dbus.exceptions.DBusException):
765
816
"""A base class for D-Bus property-related exceptions
792
def _is_dbus_property(obj):
793
return getattr(obj, "_dbus_is_property", False)
843
def _is_dbus_thing(thing):
844
"""Returns a function testing if an attribute is a D-Bus thing
846
If called like _is_dbus_thing("method") it returns a function
847
suitable for use as predicate to inspect.getmembers().
849
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
795
def _get_all_dbus_properties(self):
852
def _get_all_dbus_things(self, thing):
796
853
"""Returns a generator of (name, attribute) pairs
798
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
855
return ((getattr(athing.__get__(self), "_dbus_name",
857
athing.__get__(self))
799
858
for cls in self.__class__.__mro__
801
inspect.getmembers(cls, self._is_dbus_property))
860
inspect.getmembers(cls,
861
self._is_dbus_thing(thing)))
803
863
def _get_dbus_property(self, interface_name, property_name):
804
864
"""Returns a bound method if one exists which is a D-Bus
807
867
for cls in self.__class__.__mro__:
808
868
for name, value in (inspect.getmembers
809
(cls, self._is_dbus_property)):
870
self._is_dbus_thing("property"))):
810
871
if (value._dbus_name == property_name
811
872
and value._dbus_interface == interface_name):
812
873
return value.__get__(self)
875
936
path_keyword='object_path',
876
937
connection_keyword='connection')
877
938
def Introspect(self, object_path, connection):
878
"""Standard D-Bus method, overloaded to insert property tags.
939
"""Overloading of standard D-Bus method.
941
Inserts property tags and interface annotation tags.
880
943
xmlstring = dbus.service.Object.Introspect(self, object_path,
888
951
e.setAttribute("access", prop._dbus_access)
890
953
for if_tag in document.getElementsByTagName("interface"):
891
955
for tag in (make_tag(document, name, prop)
893
in self._get_all_dbus_properties()
957
in self._get_all_dbus_things("property")
894
958
if prop._dbus_interface
895
959
== if_tag.getAttribute("name")):
896
960
if_tag.appendChild(tag)
961
# Add annotation tags
962
for typ in ("method", "signal", "property"):
963
for tag in if_tag.getElementsByTagName(typ):
965
for name, prop in (self.
966
_get_all_dbus_things(typ)):
967
if (name == tag.getAttribute("name")
968
and prop._dbus_interface
969
== if_tag.getAttribute("name")):
970
annots.update(getattr
974
for name, value in annots.iteritems():
975
ann_tag = document.createElement(
977
ann_tag.setAttribute("name", name)
978
ann_tag.setAttribute("value", value)
979
tag.appendChild(ann_tag)
980
# Add interface annotation tags
981
for annotation, value in dict(
982
itertools.chain.from_iterable(
983
annotations().iteritems()
984
for name, annotations in
985
self._get_all_dbus_things("interface")
986
if name == if_tag.getAttribute("name")
988
ann_tag = document.createElement("annotation")
989
ann_tag.setAttribute("name", annotation)
990
ann_tag.setAttribute("value", value)
991
if_tag.appendChild(ann_tag)
897
992
# Add the names to the return values for the
898
993
# "org.freedesktop.DBus.Properties" methods
899
994
if (if_tag.getAttribute("name")
926
1021
variant_level=variant_level)
929
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
931
"""Applied to an empty subclass of a D-Bus object, this metaclass
932
will add additional D-Bus attributes matching a certain pattern.
1024
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1025
"""A class decorator; applied to a subclass of
1026
dbus.service.Object, it will add alternate D-Bus attributes with
1027
interface names according to the "alt_interface_names" mapping.
1030
@alternate_dbus_names({"org.example.Interface":
1031
"net.example.AlternateInterface"})
1032
class SampleDBusObject(dbus.service.Object):
1033
@dbus.service.method("org.example.Interface")
1034
def SampleDBusMethod():
1037
The above "SampleDBusMethod" on "SampleDBusObject" will be
1038
reachable via two interfaces: "org.example.Interface" and
1039
"net.example.AlternateInterface", the latter of which will have
1040
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1041
"true", unless "deprecate" is passed with a False value.
1043
This works for methods and signals, and also for D-Bus properties
1044
(from DBusObjectWithProperties) and interfaces (from the
1045
dbus_interface_annotations decorator).
934
def __new__(mcs, name, bases, attr):
935
# Go through all the base classes which could have D-Bus
936
# methods, signals, or properties in them
937
for base in (b for b in bases
938
if issubclass(b, dbus.service.Object)):
939
# Go though all attributes of the base class
940
for attrname, attribute in inspect.getmembers(base):
1048
for orig_interface_name, alt_interface_name in (
1049
alt_interface_names.iteritems()):
1051
interface_names = set()
1052
# Go though all attributes of the class
1053
for attrname, attribute in inspect.getmembers(cls):
941
1054
# Ignore non-D-Bus attributes, and D-Bus attributes
942
1055
# with the wrong interface name
943
1056
if (not hasattr(attribute, "_dbus_interface")
944
1057
or not attribute._dbus_interface
945
.startswith("se.recompile.Mandos")):
1058
.startswith(orig_interface_name)):
947
1060
# Create an alternate D-Bus interface name based on
948
1061
# the current name
949
1062
alt_interface = (attribute._dbus_interface
950
.replace("se.recompile.Mandos",
951
"se.bsnet.fukt.Mandos"))
1063
.replace(orig_interface_name,
1064
alt_interface_name))
1065
interface_names.add(alt_interface)
952
1066
# Is this a D-Bus signal?
953
1067
if getattr(attribute, "_dbus_is_signal", False):
954
1068
# Extract the original non-method function by
969
1083
nonmethod_func.func_name,
970
1084
nonmethod_func.func_defaults,
971
1085
nonmethod_func.func_closure)))
1086
# Copy annotations, if any
1088
new_function._dbus_annotations = (
1089
dict(attribute._dbus_annotations))
1090
except AttributeError:
972
1092
# Define a creator of a function to call both the
973
# old and new functions, so both the old and new
974
# signals gets sent when the function is called
1093
# original and alternate functions, so both the
1094
# original and alternate signals gets sent when
1095
# the function is called
975
1096
def fixscope(func1, func2):
976
1097
"""This function is a scope container to pass
977
1098
func1 and func2 to the "call_both" function
984
1105
return call_both
985
1106
# Create the "call_both" function and add it to
987
attr[attrname] = fixscope(attribute,
1108
attr[attrname] = fixscope(attribute, new_function)
989
1109
# Is this a D-Bus method?
990
1110
elif getattr(attribute, "_dbus_is_method", False):
991
1111
# Create a new, but exactly alike, function
1002
1122
attribute.func_name,
1003
1123
attribute.func_defaults,
1004
1124
attribute.func_closure)))
1125
# Copy annotations, if any
1127
attr[attrname]._dbus_annotations = (
1128
dict(attribute._dbus_annotations))
1129
except AttributeError:
1005
1131
# Is this a D-Bus property?
1006
1132
elif getattr(attribute, "_dbus_is_property", False):
1007
1133
# Create a new, but exactly alike, function
1021
1147
attribute.func_name,
1022
1148
attribute.func_defaults,
1023
1149
attribute.func_closure)))
1024
return type.__new__(mcs, name, bases, attr)
1150
# Copy annotations, if any
1152
attr[attrname]._dbus_annotations = (
1153
dict(attribute._dbus_annotations))
1154
except AttributeError:
1156
# Is this a D-Bus interface?
1157
elif getattr(attribute, "_dbus_is_interface", False):
1158
# Create a new, but exactly alike, function
1159
# object. Decorate it to be a new D-Bus interface
1160
# with the alternate D-Bus interface name. Add it
1162
attr[attrname] = (dbus_interface_annotations
1165
(attribute.func_code,
1166
attribute.func_globals,
1167
attribute.func_name,
1168
attribute.func_defaults,
1169
attribute.func_closure)))
1171
# Deprecate all alternate interfaces
1172
iname="_AlternateDBusNames_interface_annotation{0}"
1173
for interface_name in interface_names:
1174
@dbus_interface_annotations(interface_name)
1176
return { "org.freedesktop.DBus.Deprecated":
1178
# Find an unused name
1179
for aname in (iname.format(i)
1180
for i in itertools.count()):
1181
if aname not in attr:
1185
# Replace the class with a new subclass of it with
1186
# methods, signals, etc. as created above.
1187
cls = type(b"{0}Alternate".format(cls.__name__),
1193
@alternate_dbus_interfaces({"se.recompile.Mandos":
1194
"se.bsnet.fukt.Mandos"})
1027
1195
class ClientDBus(Client, DBusObjectWithProperties):
1028
1196
"""A Client class using D-Bus
1040
1208
def __init__(self, bus = None, *args, **kwargs):
1042
1210
Client.__init__(self, *args, **kwargs)
1043
self._approvals_pending = 0
1045
self._approvals_pending = 0
1046
1211
# Only now, when this client is initialized, can it show up on
1048
1213
client_object_name = unicode(self.name).translate(
1342
1506
return datetime_to_dbus(self.last_checked_ok)
1508
# LastCheckerStatus - property
1509
@dbus_service_property(_interface, signature="n",
1511
def LastCheckerStatus_dbus_property(self):
1512
return dbus.Int16(self.last_checker_status)
1344
1514
# Expires - property
1345
1515
@dbus_service_property(_interface, signature="s", access="read")
1346
1516
def Expires_dbus_property(self):
1358
1528
if value is None: # get
1359
1529
return dbus.UInt64(self.timeout_milliseconds())
1360
1530
self.timeout = datetime.timedelta(0, 0, 0, value)
1361
if getattr(self, "disable_initiator_tag", None) is None:
1363
1531
# Reschedule timeout
1364
gobject.source_remove(self.disable_initiator_tag)
1365
self.disable_initiator_tag = None
1367
time_to_die = timedelta_to_milliseconds((self
1372
if time_to_die <= 0:
1373
# The timeout has passed
1376
self.expires = (datetime.datetime.utcnow()
1377
+ datetime.timedelta(milliseconds =
1379
self.disable_initiator_tag = (gobject.timeout_add
1380
(time_to_die, self.disable))
1533
now = datetime.datetime.utcnow()
1534
time_to_die = timedelta_to_milliseconds(
1535
(self.last_checked_ok + self.timeout) - now)
1536
if time_to_die <= 0:
1537
# The timeout has passed
1540
self.expires = (now +
1541
datetime.timedelta(milliseconds =
1543
if (getattr(self, "disable_initiator_tag", None)
1546
gobject.source_remove(self.disable_initiator_tag)
1547
self.disable_initiator_tag = (gobject.timeout_add
1382
1551
# ExtendedTimeout - property
1383
1552
@dbus_service_property(_interface, signature="t",
1941
2104
elif suffix == "w":
1942
2105
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1944
raise ValueError("Unknown suffix %r" % suffix)
2107
raise ValueError("Unknown suffix {0!r}"
1945
2109
except (ValueError, IndexError) as e:
1946
2110
raise ValueError(*(e.args))
1947
2111
timevalue += delta
1962
2126
if not noclose:
1963
2127
# Close all standard open file descriptors
1964
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2128
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1965
2129
if not stat.S_ISCHR(os.fstat(null).st_mode):
1966
2130
raise OSError(errno.ENODEV,
1967
"%s not a character device"
2131
"{0} not a character device"
2132
.format(os.devnull))
1969
2133
os.dup2(null, sys.stdin.fileno())
1970
2134
os.dup2(null, sys.stdout.fileno())
1971
2135
os.dup2(null, sys.stderr.fileno())
1981
2145
parser = argparse.ArgumentParser()
1982
2146
parser.add_argument("-v", "--version", action="version",
1983
version = "%%(prog)s %s" % version,
2147
version = "%(prog)s {0}".format(version),
1984
2148
help="show version number and exit")
1985
2149
parser.add_argument("-i", "--interface", metavar="IF",
1986
2150
help="Bind to interface IF")
2090
2254
if server_settings["servicename"] != "Mandos":
2091
2255
syslogger.setFormatter(logging.Formatter
2092
('Mandos (%s) [%%(process)d]:'
2093
' %%(levelname)s: %%(message)s'
2094
% server_settings["servicename"]))
2256
('Mandos ({0}) [%(process)d]:'
2257
' %(levelname)s: %(message)s'
2258
.format(server_settings
2096
2261
# Parse config file with clients
2097
client_config = configparser.SafeConfigParser(Client.client_defaults)
2262
client_config = configparser.SafeConfigParser(Client
2098
2264
client_config.read(os.path.join(server_settings["configdir"],
2099
2265
"clients.conf"))
2114
2280
pidfilename = "/var/run/mandos.pid"
2116
2282
pidfile = open(pidfilename, "w")
2118
logger.error("Could not open file %r", pidfilename)
2283
except IOError as e:
2284
logger.error("Could not open file %r", pidfilename,
2121
uid = pwd.getpwnam("_mandos").pw_uid
2122
gid = pwd.getpwnam("_mandos").pw_gid
2287
for name in ("_mandos", "mandos", "nobody"):
2125
uid = pwd.getpwnam("mandos").pw_uid
2126
gid = pwd.getpwnam("mandos").pw_gid
2289
uid = pwd.getpwnam(name).pw_uid
2290
gid = pwd.getpwnam(name).pw_gid
2127
2292
except KeyError:
2129
uid = pwd.getpwnam("nobody").pw_uid
2130
gid = pwd.getpwnam("nobody").pw_gid
2212
2374
(stored_state))
2213
2375
os.remove(stored_state_path)
2214
2376
except IOError as e:
2215
logger.warning("Could not load persistent state: {0}"
2217
if e.errno != errno.ENOENT:
2377
if e.errno == errno.ENOENT:
2378
logger.warning("Could not load persistent state: {0}"
2379
.format(os.strerror(e.errno)))
2381
logger.critical("Could not load persistent state:",
2219
2384
except EOFError as e:
2220
2385
logger.warning("Could not load persistent state: "
2221
"EOFError: {0}".format(e))
2386
"EOFError:", exc_info=e)
2223
2388
with PGPEngine() as pgp:
2224
2389
for client_name, client in clients_data.iteritems():
2242
2407
# Clients who has passed its expire date can still be
2243
2408
# enabled if its last checker was successful. Clients
2244
# whose checker failed before we stored its state is
2245
# assumed to have failed all checkers during downtime.
2409
# whose checker succeeded before we stored its state is
2410
# assumed to have successfully run all checkers during
2246
2412
if client["enabled"]:
2247
2413
if datetime.datetime.utcnow() >= client["expires"]:
2248
2414
if not client["last_checked_ok"]:
2249
2415
logger.warning(
2250
2416
"disabling client {0} - Client never "
2251
"performed a successfull checker"
2252
.format(client["name"]))
2417
"performed a successful checker"
2418
.format(client_name))
2253
2419
client["enabled"] = False
2254
2420
elif client["last_checker_status"] != 0:
2255
2421
logger.warning(
2256
2422
"disabling client {0} - Client "
2257
2423
"last checker failed with error code {1}"
2258
.format(client["name"],
2424
.format(client_name,
2259
2425
client["last_checker_status"]))
2260
2426
client["enabled"] = False
2262
2428
client["expires"] = (datetime.datetime
2264
2430
+ client["timeout"])
2431
logger.debug("Last checker succeeded,"
2432
" keeping {0} enabled"
2433
.format(client_name))
2267
2435
client["secret"] = (
2268
2436
pgp.decrypt(client["encrypted_secret"],
2274
2442
.format(client_name))
2275
2443
client["secret"] = (
2276
2444
client_settings[client_name]["secret"])
2279
2446
# Add/remove clients based on new changes made to config
2280
for client_name in set(old_client_settings) - set(client_settings):
2447
for client_name in (set(old_client_settings)
2448
- set(client_settings)):
2281
2449
del clients_data[client_name]
2282
for client_name in set(client_settings) - set(old_client_settings):
2450
for client_name in (set(client_settings)
2451
- set(old_client_settings)):
2283
2452
clients_data[client_name] = client_settings[client_name]
2285
# Create clients all clients
2454
# Create all client objects
2286
2455
for client_name, client in clients_data.iteritems():
2287
2456
tcp_server.clients[client_name] = client_class(
2288
2457
name = client_name, settings = client)
2290
2459
if not tcp_server.clients:
2291
2460
logger.warning("No clients defined")
2309
2478
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2312
class MandosDBusService(dbus.service.Object):
2481
@alternate_dbus_interfaces({"se.recompile.Mandos":
2482
"se.bsnet.fukt.Mandos"})
2483
class MandosDBusService(DBusObjectWithProperties):
2313
2484
"""A D-Bus proxy object"""
2314
2485
def __init__(self):
2315
2486
dbus.service.Object.__init__(self, bus, "/")
2316
2487
_interface = "se.recompile.Mandos"
2489
@dbus_interface_annotations(_interface)
2491
return { "org.freedesktop.DBus.Property"
2492
".EmitsChangedSignal":
2318
2495
@dbus.service.signal(_interface, signature="o")
2319
2496
def ClientAdded(self, objpath):
2411
2586
pickle.dump((clients, client_settings), stored_state)
2412
2587
os.rename(tempname, stored_state_path)
2413
2588
except (IOError, OSError) as e:
2414
logger.warning("Could not save persistent state: {0}"
2418
2591
os.remove(tempname)
2419
2592
except NameError:
2421
if e.errno not in set((errno.ENOENT, errno.EACCES,
2594
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2595
logger.warning("Could not save persistent state: {0}"
2596
.format(os.strerror(e.errno)))
2598
logger.warning("Could not save persistent state:",
2425
2602
# Delete all clients, and settings from config
2453
2630
service.port = tcp_server.socket.getsockname()[1]
2455
2632
logger.info("Now listening on address %r, port %d,"
2456
" flowinfo %d, scope_id %d"
2457
% tcp_server.socket.getsockname())
2633
" flowinfo %d, scope_id %d",
2634
*tcp_server.socket.getsockname())
2459
logger.info("Now listening on address %r, port %d"
2460
% tcp_server.socket.getsockname())
2636
logger.info("Now listening on address %r, port %d",
2637
*tcp_server.socket.getsockname())
2462
2639
#service.interface = tcp_server.socket.getsockname()[3]