/mandos/trunk : revision 724

1

#!/usr/bin/python

1

#!/usr/bin/python2.7

2

# -*- mode: python; coding: utf-8 -*-

3

#

4

# Mandos server - give out binary blobs to connecting clients.

11

# "AvahiService" class, and some lines in "main".

12

#

13

# Everything else is

14

15

14

15

16

#

17

# This program is free software: you can redistribute it and/or modify

18

# it under the terms of the GNU General Public License as published by

88

except ImportError:

89

SO_BINDTODEVICE = None

90

91

version = "1.6.2"

91

version = "1.6.7"

92

stored_state_file = "clients.pickle"

93

94

logger = logging.getLogger()

95

syslogger = (logging.handlers.SysLogHandler

96

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

97

address = str("/dev/log")))

95

syslogger = None

98

96

99

97

try:

100

98

if_nametoindex = (ctypes.cdll.LoadLibrary

116

114

def initlogger(debug, level=logging.WARNING):

117

115

"""init logger and add loglevel"""

118

116

117

global syslogger

118

syslogger = (logging.handlers.SysLogHandler

119

(facility =

120

logging.handlers.SysLogHandler.LOG_DAEMON,

121

address = str("/dev/log")))

119

122

syslogger.setFormatter(logging.Formatter

120

123

('Mandos [%(process)d]: %(levelname)s:'

121

124

' %(message)s'))

335

338

elif state == avahi.ENTRY_GROUP_FAILURE:

336

339

logger.critical("Avahi: Error in group state changed %s",

337

340

unicode(error))

338

raise AvahiGroupError("State changed: {0!s}"

341

raise AvahiGroupError("State changed: {!s}"

339

342

.format(error))

340

343

341

344

def cleanup(self):

392

395

"""Add the new name to the syslog messages"""

393

396

ret = AvahiService.rename(self)

394

397

syslogger.setFormatter(logging.Formatter

395

('Mandos ({0}) [%(process)d]:'

398

('Mandos ({}) [%(process)d]:'

396

399

' %(levelname)s: %(message)s'

397

400

.format(self.name)))

398

401

return ret

399

402

400

403

401

def timedelta_to_milliseconds(td):

402

"Convert a datetime.timedelta() to milliseconds"

403

return ((td.days * 24 * 60 * 60 * 1000)

404

+ (td.seconds * 1000)

405

+ (td.microseconds // 1000))

406

407

408

404

class Client(object):

409

405

"""A representation of a client host served by this server.

410

406

465

461

"enabled": "True",

466

462

}

467

463

468

def timeout_milliseconds(self):

469

"Return the 'timeout' attribute in milliseconds"

470

return timedelta_to_milliseconds(self.timeout)

471

472

def extended_timeout_milliseconds(self):

473

"Return the 'extended_timeout' attribute in milliseconds"

474

return timedelta_to_milliseconds(self.extended_timeout)

475

476

def interval_milliseconds(self):

477

"Return the 'interval' attribute in milliseconds"

478

return timedelta_to_milliseconds(self.interval)

479

480

def approval_delay_milliseconds(self):

481

return timedelta_to_milliseconds(self.approval_delay)

482

483

464

@staticmethod

484

465

def config_parser(config):

485

466

"""Construct a new dict of client settings of this form:

510

491

"rb") as secfile:

511

492

client["secret"] = secfile.read()

512

493

else:

513

raise TypeError("No secret or secfile for section {0}"

494

raise TypeError("No secret or secfile for section {}"

514

495

.format(section))

515

496

client["timeout"] = string_to_delta(section["timeout"])

516

497

client["extended_timeout"] = string_to_delta(

533

514

server_settings = {}

534

515

self.server_settings = server_settings

535

516

# adding all client settings

536

for setting, value in settings.iteritems():

517

for setting, value in settings.items():

537

518

setattr(self, setting, value)

538

519

539

520

if self.enabled:

622

603

if self.checker_initiator_tag is not None:

623

604

gobject.source_remove(self.checker_initiator_tag)

624

605

self.checker_initiator_tag = (gobject.timeout_add

625

(self.interval_milliseconds(),

606

(int(self.interval

607

.total_seconds() * 1000),

626

608

self.start_checker))

627

609

# Schedule a disable() when 'timeout' has passed

628

610

if self.disable_initiator_tag is not None:

629

611

gobject.source_remove(self.disable_initiator_tag)

630

612

self.disable_initiator_tag = (gobject.timeout_add

631

(self.timeout_milliseconds(),

632

self.disable))

613

(int(self.timeout

614

.total_seconds() * 1000),

615

self.disable))

633

616

# Also start a new checker *right now*.

634

617

self.start_checker()

635

618

666

649

self.disable_initiator_tag = None

667

650

if getattr(self, "enabled", False):

668

651

self.disable_initiator_tag = (gobject.timeout_add

669

(timedelta_to_milliseconds

670

(timeout), self.disable))

652

(int(timeout.total_seconds()

653

* 1000), self.disable))

671

654

self.expires = datetime.datetime.utcnow() + timeout

672

655

673

656

def need_approval(self):

704

687

# Start a new checker if needed

705

688

if self.checker is None:

706

689

# Escape attributes for the shell

707

escaped_attrs = dict(

708

(attr, re.escape(unicode(getattr(self, attr))))

709

for attr in

710

self.runtime_expansions)

690

escaped_attrs = { attr:

691

re.escape(unicode(getattr(self,

692

attr)))

693

for attr in self.runtime_expansions }

711

694

try:

712

695

command = self.checker_command % escaped_attrs

713

696

except TypeError as error:

794

777

# "Set" method, so we fail early here:

795

778

if byte_arrays and signature != "ay":

796

779

raise ValueError("Byte arrays not supported for non-'ay'"

797

" signature {0!r}".format(signature))

780

" signature {!r}".format(signature))

798

781

def decorator(func):

799

782

func._dbus_is_property = True

800

783

func._dbus_interface = dbus_interface

879

862

If called like _is_dbus_thing("method") it returns a function

880

863

suitable for use as predicate to inspect.getmembers().

881

864

"""

882

return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),

865

return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),

883

866

False)

884

867

885

868

def _get_all_dbus_things(self, thing):

934

917

# The byte_arrays option is not supported yet on

935

918

# signatures other than "ay".

936

919

if prop._dbus_signature != "ay":

937

raise ValueError

920

raise ValueError("Byte arrays not supported for non-"

921

"'ay' signature {!r}"

922

.format(prop._dbus_signature))

938

923

value = dbus.ByteArray(b''.join(chr(byte)

939

924

for byte in value))

940

925

prop(value)

1004

989

(prop,

1005

990

"_dbus_annotations",

1006

991

{}))

1007

for name, value in annots.iteritems():

992

for name, value in annots.items():

1008

993

ann_tag = document.createElement(

1009

994

"annotation")

1010

995

ann_tag.setAttribute("name", name)

1013

998

# Add interface annotation tags

1014

999

for annotation, value in dict(

1015

1000

itertools.chain.from_iterable(

1016

annotations().iteritems()

1001

annotations().items()

1017

1002

for name, annotations in

1018

1003

self._get_all_dbus_things("interface")

1019

1004

if name == if_tag.getAttribute("name")

1020

)).iteritems():

1005

)).items():

1021

1006

ann_tag = document.createElement("annotation")

1022

1007

ann_tag.setAttribute("name", annotation)

1023

1008

ann_tag.setAttribute("value", value)

1079

1064

"""

1080

1065

def wrapper(cls):

1081

1066

for orig_interface_name, alt_interface_name in (

1082

alt_interface_names.iteritems()):

1067

alt_interface_names.items()):

1083

1068

attr = {}

1084

1069

interface_names = set()

1085

1070

# Go though all attributes of the class

1202

1187

attribute.func_closure)))

1203

1188

if deprecate:

1204

1189

# Deprecate all alternate interfaces

1205

iname="_AlternateDBusNames_interface_annotation{0}"

1190

iname="_AlternateDBusNames_interface_annotation{}"

1206

1191

for interface_name in interface_names:

1207

1192

@dbus_interface_annotations(interface_name)

1208

1193

def func(self):

1217

1202

if interface_names:

1218

1203

# Replace the class with a new subclass of it with

1219

1204

# methods, signals, etc. as created above.

1220

cls = type(b"{0}Alternate".format(cls.__name__),

1205

cls = type(b"{}Alternate".format(cls.__name__),

1221

1206

(cls,), attr)

1222

1207

return cls

1223

1208

return wrapper

1264

1249

to the D-Bus. Default: no transform

1265

1250

variant_level: D-Bus variant level. Default: 1

1266

1251

"""

1267

attrname = "_{0}".format(dbus_name)

1252

attrname = "_{}".format(dbus_name)

1268

1253

def setter(self, value):

1269

1254

if hasattr(self, "dbus_object_path"):

1270

1255

if (not hasattr(self, attrname) or

1300

1285

approval_delay = notifychangeproperty(dbus.UInt64,

1301

1286

"ApprovalDelay",

1302

1287

type_func =

1303

timedelta_to_milliseconds)

1288

lambda td: td.total_seconds()

1289

* 1000)

1304

1290

approval_duration = notifychangeproperty(

1305

1291

dbus.UInt64, "ApprovalDuration",

1306

type_func = timedelta_to_milliseconds)

1292

type_func = lambda td: td.total_seconds() * 1000)

1307

1293

host = notifychangeproperty(dbus.String, "Host")

1308

1294

timeout = notifychangeproperty(dbus.UInt64, "Timeout",

1309

type_func =

1310

timedelta_to_milliseconds)

1295

type_func = lambda td:

1296

td.total_seconds() * 1000)

1311

1297

extended_timeout = notifychangeproperty(

1312

1298

dbus.UInt64, "ExtendedTimeout",

1313

type_func = timedelta_to_milliseconds)

1299

type_func = lambda td: td.total_seconds() * 1000)

1314

1300

interval = notifychangeproperty(dbus.UInt64,

1315

1301

"Interval",

1316

1302

type_func =

1317

timedelta_to_milliseconds)

1303

lambda td: td.total_seconds()

1304

* 1000)

1318

1305

checker_command = notifychangeproperty(dbus.String, "Checker")

1319

1306

1320

1307

del notifychangeproperty

1348

1335

*args, **kwargs)

1349

1336

1350

1337

def start_checker(self, *args, **kwargs):

1351

old_checker = self.checker

1352

if self.checker is not None:

1353

old_checker_pid = self.checker.pid

1354

else:

1355

old_checker_pid = None

1338

old_checker_pid = getattr(self.checker, "pid", None)

1356

1339

r = Client.start_checker(self, *args, **kwargs)

1357

1340

# Only if new checker process was started

1358

1341

if (self.checker is not None

1367

1350

1368

1351

def approve(self, value=True):

1369

1352

self.approved = value

1370

gobject.timeout_add(timedelta_to_milliseconds

1371

(self.approval_duration),

1372

self._reset_approved)

1353

gobject.timeout_add(int(self.approval_duration.total_seconds()

1354

* 1000), self._reset_approved)

1373

1355

self.send_changedstate()

1374

1356

1375

1357

## D-Bus methods, signals & properties

1478

1460

access="readwrite")

1479

1461

def ApprovalDelay_dbus_property(self, value=None):

1480

1462

if value is None: # get

1481

return dbus.UInt64(self.approval_delay_milliseconds())

1463

return dbus.UInt64(self.approval_delay.total_seconds()

1464

* 1000)

1482

1465

self.approval_delay = datetime.timedelta(0, 0, 0, value)

1483

1466

1484

1467

# ApprovalDuration - property

1486

1469

access="readwrite")

1487

1470

def ApprovalDuration_dbus_property(self, value=None):

1488

1471

if value is None: # get

1489

return dbus.UInt64(timedelta_to_milliseconds(

1490

self.approval_duration))

1472

return dbus.UInt64(self.approval_duration.total_seconds()

1473

* 1000)

1491

1474

self.approval_duration = datetime.timedelta(0, 0, 0, value)

1492

1475

1493

1476

# Name - property

1559

1542

access="readwrite")

1560

1543

def Timeout_dbus_property(self, value=None):

1561

1544

if value is None: # get

1562

return dbus.UInt64(self.timeout_milliseconds())

1545

return dbus.UInt64(self.timeout.total_seconds() * 1000)

1563

1546

old_timeout = self.timeout

1564

1547

self.timeout = datetime.timedelta(0, 0, 0, value)

1565

1548

# Reschedule disabling

1576

1559

gobject.source_remove(self.disable_initiator_tag)

1577

1560

self.disable_initiator_tag = (

1578

1561

gobject.timeout_add(

1579

timedelta_to_milliseconds(self.expires - now),

1580

self.disable))

1562

int((self.expires - now).total_seconds()

1563

* 1000), self.disable))

1581

1564

1582

1565

# ExtendedTimeout - property

1583

1566

@dbus_service_property(_interface, signature="t",

1584

1567

access="readwrite")

1585

1568

def ExtendedTimeout_dbus_property(self, value=None):

1586

1569

if value is None: # get

1587

return dbus.UInt64(self.extended_timeout_milliseconds())

1570

return dbus.UInt64(self.extended_timeout.total_seconds()

1571

* 1000)

1588

1572

self.extended_timeout = datetime.timedelta(0, 0, 0, value)

1589

1573

1590

1574

# Interval - property

1592

1576

access="readwrite")

1593

1577

def Interval_dbus_property(self, value=None):

1594

1578

if value is None: # get

1595

return dbus.UInt64(self.interval_milliseconds())

1579

return dbus.UInt64(self.interval.total_seconds() * 1000)

1596

1580

self.interval = datetime.timedelta(0, 0, 0, value)

1597

1581

if getattr(self, "checker_initiator_tag", None) is None:

1598

1582

return

1758

1742

if self.server.use_dbus:

1759

1743

# Emit D-Bus signal

1760

1744

client.NeedApproval(

1761

client.approval_delay_milliseconds(),

1762

client.approved_by_default)

1745

client.approval_delay.total_seconds()

1746

* 1000, client.approved_by_default)

1763

1747

else:

1764

1748

logger.warning("Client %s was not approved",

1765

1749

client.name)

1771

1755

#wait until timeout or approved

1772

1756

time = datetime.datetime.now()

1773

1757

client.changedstate.acquire()

1774

client.changedstate.wait(

1775

float(timedelta_to_milliseconds(delay)

1776

/ 1000))

1758

client.changedstate.wait(delay.total_seconds())

1777

1759

client.changedstate.release()

1778

1760

time2 = datetime.datetime.now()

1779

1761

if (time2 - time) >= delay:

2187

2169

token_duration = Token(re.compile(r"P"), None,

2188

2170

frozenset((token_year, token_month,

2189

2171

token_day, token_time,

2190

token_week))),

2172

token_week)))

2191

2173

# Define starting values

2192

2174

value = datetime.timedelta() # Value so far

2193

2175

found_token = None

2194

followers = frozenset(token_duration,) # Following valid tokens

2176

followers = frozenset((token_duration,)) # Following valid tokens

2195

2177

s = duration # String left to parse

2196

2178

# Loop until end token is found

2197

2179

while found_token is not token_end:

2257

2239

elif suffix == "w":

2258

2240

delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)

2259

2241

else:

2260

raise ValueError("Unknown suffix {0!r}"

2242

raise ValueError("Unknown suffix {!r}"

2261

2243

.format(suffix))

2262

2244

except IndexError as e:

2263

2245

raise ValueError(*(e.args))

2280

2262

# Close all standard open file descriptors

2281

2263

null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)

2282

2264

if not stat.S_ISCHR(os.fstat(null).st_mode):

2283

raise OSError(errno.ENODEV,

2284

"{0} not a character device"

2265

raise OSError(errno.ENODEV, "{} not a character device"

2285

2266

.format(os.devnull))

2286

2267

os.dup2(null, sys.stdin.fileno())

2287

2268

os.dup2(null, sys.stdout.fileno())

2297

2278

2298

2279

parser = argparse.ArgumentParser()

2299

2280

parser.add_argument("-v", "--version", action="version",

2300

version = "%(prog)s {0}".format(version),

2281

version = "%(prog)s {}".format(version),

2301

2282

help="show version number and exit")

2302

2283

parser.add_argument("-i", "--interface", metavar="IF",

2303

2284

help="Bind to interface IF")

2336

2317

help="Directory to save/restore state in")

2337

2318

parser.add_argument("--foreground", action="store_true",

2338

2319

help="Run in foreground", default=None)

2320

parser.add_argument("--no-zeroconf", action="store_false",

2321

dest="zeroconf", help="Do not use Zeroconf",

2322

default=None)

2339

2323

2340

2324

options = parser.parse_args()

2341

2325

2342

2326

if options.check:

2343

2327

import doctest

2344

doctest.testmod()

2345

sys.exit()

2328

fail_count, test_count = doctest.testmod()

2329

sys.exit(os.EX_OK if fail_count == 0 else 1)

2346

2330

2347

2331

# Default values for config file for server-global settings

2348

2332

server_defaults = { "interface": "",

2359

2343

"socket": "",

2360

2344

"statedir": "/var/lib/mandos",

2361

2345

"foreground": "False",

2346

"zeroconf": "True",

2362

2347

}

2363

2348

2364

2349

# Parse config file for server-global settings

2391

2376

for option in ("interface", "address", "port", "debug",

2392

2377

"priority", "servicename", "configdir",

2393

2378

"use_dbus", "use_ipv6", "debuglevel", "restore",

2394

"statedir", "socket", "foreground"):

2379

"statedir", "socket", "foreground", "zeroconf"):

2395

2380

value = getattr(options, option)

2396

2381

if value is not None:

2397

2382

server_settings[option] = value

2402

2387

server_settings[option] = unicode(server_settings[option])

2403

2388

# Force all boolean options to be boolean

2404

2389

for option in ("debug", "use_dbus", "use_ipv6", "restore",

2405

"foreground"):

2390

"foreground", "zeroconf"):

2406

2391

server_settings[option] = bool(server_settings[option])

2407

2392

# Debug implies foreground

2408

2393

if server_settings["debug"]:

2411

2396

2412

2397

##################################################################

2413

2398

2399

if (not server_settings["zeroconf"] and

2400

not (server_settings["port"]

2401

or server_settings["socket"] != "")):

2402

parser.error("Needs port or socket to work without"

2403

" Zeroconf")

2404

2414

2405

# For convenience

2415

2406

debug = server_settings["debug"]

2416

2407

debuglevel = server_settings["debuglevel"]

2419

2410

stored_state_path = os.path.join(server_settings["statedir"],

2420

2411

stored_state_file)

2421

2412

foreground = server_settings["foreground"]

2413

zeroconf = server_settings["zeroconf"]

2422

2414

2423

2415

if debug:

2424

2416

initlogger(debug, logging.DEBUG)

2431

2423

2432

2424

if server_settings["servicename"] != "Mandos":

2433

2425

syslogger.setFormatter(logging.Formatter

2434

('Mandos ({0}) [%(process)d]:'

2426

('Mandos ({}) [%(process)d]:'

2435

2427

' %(levelname)s: %(message)s'

2436

2428

.format(server_settings

2437

2429

["servicename"])))

2445

2437

global mandos_dbus_service

2446

2438

mandos_dbus_service = None

2447

2439

2440

socketfd = None

2441

if server_settings["socket"] != "":

2442

socketfd = server_settings["socket"]

2448

2443

tcp_server = MandosServer((server_settings["address"],

2449

2444

server_settings["port"]),

2450

2445

ClientHandler,

2454

2449

gnutls_priority=

2455

2450

server_settings["priority"],

2456

2451

use_dbus=use_dbus,

2457

socketfd=(server_settings["socket"]

2458

or None))

2452

socketfd=socketfd)

2459

2453

if not foreground:

2460

2454

pidfilename = "/run/mandos.pid"

2461

2455

if not os.path.isdir("/run/."):

2531

2525

use_dbus = False

2532

2526

server_settings["use_dbus"] = False

2533

2527

tcp_server.use_dbus = False

2534

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2535

service = AvahiServiceToSyslog(name =

2536

server_settings["servicename"],

2537

servicetype = "_mandos._tcp",

2538

protocol = protocol, bus = bus)

2539

if server_settings["interface"]:

2540

service.interface = (if_nametoindex

2541

(str(server_settings["interface"])))

2528

if zeroconf:

2529

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2530

service = AvahiServiceToSyslog(name =

2531

server_settings["servicename"],

2532

servicetype = "_mandos._tcp",

2533

protocol = protocol, bus = bus)

2534

if server_settings["interface"]:

2535

service.interface = (if_nametoindex

2536

(str(server_settings["interface"])))

2542

2537

2543

2538

global multiprocessing_manager

2544

2539

multiprocessing_manager = multiprocessing.Manager()

2568

2563

os.remove(stored_state_path)

2569

2564

except IOError as e:

2570

2565

if e.errno == errno.ENOENT:

2571

logger.warning("Could not load persistent state: {0}"

2566

logger.warning("Could not load persistent state: {}"

2572

2567

.format(os.strerror(e.errno)))

2573

2568

else:

2574

2569

logger.critical("Could not load persistent state:",

2579

2574

"EOFError:", exc_info=e)

2580

2575

2581

2576

with PGPEngine() as pgp:

2582

for client_name, client in clients_data.iteritems():

2577

for client_name, client in clients_data.items():

2583

2578

# Skip removed clients

2584

2579

if client_name not in client_settings:

2585

2580

continue

2610

2605

if datetime.datetime.utcnow() >= client["expires"]:

2611

2606

if not client["last_checked_ok"]:

2612

2607

logger.warning(

2613

"disabling client {0} - Client never "

2608

"disabling client {} - Client never "

2614

2609

"performed a successful checker"

2615

2610

.format(client_name))

2616

2611

client["enabled"] = False

2617

2612

elif client["last_checker_status"] != 0:

2618

2613

logger.warning(

2619

"disabling client {0} - Client "

2620

"last checker failed with error code {1}"

2614

"disabling client {} - Client last"

2615

" checker failed with error code {}"

2621

2616

.format(client_name,

2622

2617

client["last_checker_status"]))

2623

2618

client["enabled"] = False

2626

2621

.utcnow()

2627

2622

+ client["timeout"])

2628

2623

logger.debug("Last checker succeeded,"

2629

" keeping {0} enabled"

2624

" keeping {} enabled"

2630

2625

.format(client_name))

2631

2626

try:

2632

2627

client["secret"] = (

2635

2630

["secret"]))

2636

2631

except PGPError:

2637

2632

# If decryption fails, we use secret from new settings

2638

logger.debug("Failed to decrypt {0} old secret"

2633

logger.debug("Failed to decrypt {} old secret"

2639

2634

.format(client_name))

2640

2635

client["secret"] = (

2641

2636

client_settings[client_name]["secret"])

2649

2644

clients_data[client_name] = client_settings[client_name]

2650

2645

2651

2646

# Create all client objects

2652

for client_name, client in clients_data.iteritems():

2647

for client_name, client in clients_data.items():

2653

2648

tcp_server.clients[client_name] = client_class(

2654

2649

name = client_name, settings = client,

2655

2650

server_settings = server_settings)

2738

2733

2739

2734

def cleanup():

2740

2735

"Cleanup function; run on exit"

2741

service.cleanup()

2736

if zeroconf:

2737

service.cleanup()

2742

2738

2743

2739

multiprocessing.active_children()

2744

2740

wnull.close()

2758

2754

2759

2755

# A list of attributes that can not be pickled

2760

2756

# + secret.

2761

exclude = set(("bus", "changedstate", "secret",

2762

"checker", "server_settings"))

2757

exclude = { "bus", "changedstate", "secret",

2758

"checker", "server_settings" }

2763

2759

for name, typ in (inspect.getmembers

2764

2760

(dbus.service.Object)):

2765

2761

exclude.add(name)

2788

2784

except NameError:

2789

2785

pass

2790

2786

if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):

2791

logger.warning("Could not save persistent state: {0}"

2787

logger.warning("Could not save persistent state: {}"

2792

2788

.format(os.strerror(e.errno)))

2793

2789

else:

2794

2790

logger.warning("Could not save persistent state:",

2823

2819

tcp_server.server_activate()

2824

2820

2825

2821

# Find out what port we got

2826

service.port = tcp_server.socket.getsockname()[1]

2822

if zeroconf:

2823

service.port = tcp_server.socket.getsockname()[1]

2827

2824

if use_ipv6:

2828

2825

logger.info("Now listening on address %r, port %d,"

2829

2826

" flowinfo %d, scope_id %d",

2835

2832

#service.interface = tcp_server.socket.getsockname()[3]

2836

2833

2837

2834

try:

2838

# From the Avahi example code

2839

try:

2840

service.activate()

2841

except dbus.exceptions.DBusException as error:

2842

logger.critical("D-Bus Exception", exc_info=error)

2843

cleanup()

2844

sys.exit(1)

2845

# End of Avahi example code

2835

if zeroconf:

2836

# From the Avahi example code

2837

try:

2838

service.activate()

2839

except dbus.exceptions.DBusException as error:

2840

logger.critical("D-Bus Exception", exc_info=error)

2841

cleanup()

2842

sys.exit(1)

2843

# End of Avahi example code

2846

2844

2847

2845

gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,

2848

2846

lambda *args, **kwargs: