/mandos/trunk : revision 26

6

# This program is partly derived from an example program for an Avahi

7

# service publisher, downloaded from

8

# <http://avahi.org/wiki/PythonPublishExample>. This includes the

9

# following functions: "AvahiService.add", "AvahiService.remove",

9

# following functions: "add_service", "remove_service",

10

# "server_state_changed", "entry_group_state_changed", and some lines

11

# in "main".

12

#

13

# Everything else is

14

13

14

# Påhlsson.

15

#

16

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

17

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

26

# You should have received a copy of the GNU General Public License

27

# along with this program. If not, see <http://www.gnu.org/licenses/>.

28

#

29

# Contact the authors at <mandos@fukt.bsnet.se>.

29

# Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and

30

# <https://www.fukt.bsnet.se/~teddy/>.

30

31

#

31

32

33

from __future__ import division

65

66

#

66

67

# This server announces itself as a Zeroconf service. Connecting

67

68

# clients use the TLS protocol, with the unusual quirk that this

68

# server program acts as a TLS "client" while a connecting client acts

69

# as a TLS "server". The client (acting as a TLS "server") must

69

# server program acts as a TLS "client" while the connecting clients

70

# acts as a TLS "server". The clients (acting as a TLS "server") must

70

71

# supply an OpenPGP certificate, and the fingerprint of this

71

72

# certificate is used by this server to look up (in a list read from a

72

73

# file at start time) which binary blob to give the client. No other

81

82

logger.addHandler(syslogger)

82

83

del syslogger

83

84

85

class AvahiError(Exception):

86

def __init__(self, value):

87

self.value = value

88

def __str__(self):

89

return repr(self.value)

90

91

class AvahiServiceError(AvahiError):

92

pass

93

94

class AvahiGroupError(AvahiError):

95

pass

96

97

98

class AvahiService(object):

99

"""

100

interface: integer; avahi.IF_UNSPEC or an interface index.

101

Used to optionally bind to the specified interface.

102

name = string; Example: "Mandos"

103

type = string; Example: "_mandos._tcp".

104

See <http://www.dns-sd.org/ServiceTypes.html>

105

port = integer; what port to announce

106

TXT = list of strings; TXT record for the service

107

domain = string; Domain to publish on, default to .local if empty.

108

host = string; Host to publish records for, default to localhost

109

if empty.

110

max_renames = integer; maximum number of renames

111

rename_count = integer; counter so we only rename after collisions

112

a sensible number of times

113

"""

114

def __init__(self, interface = avahi.IF_UNSPEC, name = None,

115

type = None, port = None, TXT = None, domain = "",

116

host = "", max_renames = 12):

117

"""An Avahi (Zeroconf) service. """

118

self.interface = interface

119

self.name = name

120

self.type = type

121

self.port = port

122

if TXT is None:

123

self.TXT = []

124

else:

125

self.TXT = TXT

126

self.domain = domain

127

self.host = host

128

self.rename_count = 0

129

def rename(self):

130

"""Derived from the Avahi example code"""

131

if self.rename_count >= self.max_renames:

132

logger.critical(u"No suitable service name found after %i"

133

u" retries, exiting.", rename_count)

134

raise AvahiServiceError("Too many renames")

135

name = server.GetAlternativeServiceName(name)

136

logger.notice(u"Changing name to %r ...", name)

137

self.remove()

138

self.add()

139

self.rename_count += 1

140

def remove(self):

141

"""Derived from the Avahi example code"""

142

if group is not None:

143

group.Reset()

144

def add(self):

145

"""Derived from the Avahi example code"""

146

global group

147

if group is None:

148

group = dbus.Interface\

149

(bus.get_object(avahi.DBUS_NAME,

150

server.EntryGroupNew()),

151

avahi.DBUS_INTERFACE_ENTRY_GROUP)

152

group.connect_to_signal('StateChanged',

153

entry_group_state_changed)

154

logger.debug(u"Adding service '%s' of type '%s' ...",

155

service.name, service.type)

156

group.AddService(

157

self.interface, # interface

158

avahi.PROTO_INET6, # protocol

159

dbus.UInt32(0), # flags

160

self.name, self.type,

161

self.domain, self.host,

162

dbus.UInt16(self.port),

163

avahi.string_array_to_txt_array(self.TXT))

164

group.Commit()

165

85

# This variable is used to optionally bind to a specified interface.

86

# It is a global variable to fit in with the other variables from the

87

# Avahi example code.

88

serviceInterface = avahi.IF_UNSPEC

166

89

# From the Avahi example code:

167

group = None # our entry group

90

serviceName = None

91

serviceType = "_mandos._tcp" # http://www.dns-sd.org/ServiceTypes.html

92

servicePort = None # Not known at startup

93

serviceTXT = [] # TXT record for the service

94

domain = "" # Domain to publish on, default to .local

95

host = "" # Host to publish records for, default to localhost

96

group = None #our entry group

97

rename_count = 12 # Counter so we only rename after collisions a

98

# sensible number of times

168

99

# End of Avahi example code

169

100

170

101

176

107

uniquely identify the client

177

108

secret: bytestring; sent verbatim (over TLS) to client

178

109

fqdn: string (FQDN); available for use by the checker command

179

created: datetime.datetime(); object creation, not client host

180

last_checked_ok: datetime.datetime() or None if not yet checked OK

181

timeout: datetime.timedelta(); How long from last_checked_ok

182

until this client is invalid

110

created: datetime.datetime()

111

last_seen: datetime.datetime() or None if not yet seen

112

timeout: datetime.timedelta(); How long from last_seen until

113

this client is invalid

183

114

interval: datetime.timedelta(); How often to start a new checker

184

115

stop_hook: If set, called by stop() as stop_hook(self)

185

116

checker: subprocess.Popen(); a running checker process used

186

117

to see if the client lives.

187

'None' if no process is running.

118

Is None if no process is running.

188

119

checker_initiator_tag: a gobject event source tag, or None

189

120

stop_initiator_tag: - '' -

190

121

checker_callback_tag: - '' -

191

122

checker_command: string; External command which is run to check if

192

client lives. %() expansions are done at

123

client lives. %()s expansions are done at

193

124

runtime with vars(self) as dict, so that for

194

125

instance %(name)s can be used in the command.

195

126

Private attibutes:

196

127

_timeout: Real variable for 'timeout'

197

128

_interval: Real variable for 'interval'

198

_timeout_milliseconds: Used when calling gobject.timeout_add()

129

_timeout_milliseconds: Used by gobject.timeout_add()

199

130

_interval_milliseconds: - '' -

200

131

"""

201

132

def _set_timeout(self, timeout):

240

171

self.secret = sf.read()

241

172

sf.close()

242

173

else:

243

raise TypeError(u"No secret or secfile for client %s"

244

% self.name)

245

self.fqdn = fqdn

174

raise RuntimeError(u"No secret or secfile for client %s"

175

% self.name)

176

self.fqdn = fqdn # string

246

177

self.created = datetime.datetime.now()

247

self.last_checked_ok = None

178

self.last_seen = None

248

179

self.timeout = string_to_delta(timeout)

249

180

self.interval = string_to_delta(interval)

250

181

self.stop_hook = stop_hook

268

199

self.stop)

269

200

def stop(self):

270

201

"""Stop this client.

271

The possibility that a client might be restarted is left open,

272

but not currently used."""

202

The possibility that this client might be restarted is left

203

open, but not currently used."""

273

204

# If this client doesn't have a secret, it is already stopped.

274

205

if self.secret:

275

206

logger.debug(u"Stopping client %s", self.name)

276

207

self.secret = None

277

208

else:

278

209

return False

279

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

210

if hasattr(self, "stop_initiator_tag") \

211

and self.stop_initiator_tag:

280

212

gobject.source_remove(self.stop_initiator_tag)

281

213

self.stop_initiator_tag = None

282

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

214

if hasattr(self, "checker_initiator_tag") \

215

and self.checker_initiator_tag:

283

216

gobject.source_remove(self.checker_initiator_tag)

284

217

self.checker_initiator_tag = None

285

218

self.stop_checker()

299

232

and (os.WEXITSTATUS(condition) == 0):

300

233

logger.debug(u"Checker for %(name)s succeeded",

301

234

vars(self))

302

self.last_checked_ok = now

235

self.last_seen = now

303

236

gobject.source_remove(self.stop_initiator_tag)

304

237

self.stop_initiator_tag = gobject.timeout_add\

305

238

(self._timeout_milliseconds,

324

257

# is as it should be.

325

258

if self.checker is None:

326

259

try:

327

# In case check_command has exactly one % operator

328

260

command = self.check_command % self.fqdn

329

261

except TypeError:

330

# Escape attributes for the shell

331

262

escaped_attrs = dict((key, re.escape(str(val)))

332

263

for key, val in

333

264

vars(self).iteritems())

334

265

try:

335

266

command = self.check_command % escaped_attrs

336

267

except TypeError, error:

337

logger.error(u'Could not format string "%s":'

338

u' %s', self.check_command, error)

268

logger.critical(u'Could not format string "%s":'

269

u' %s', self.check_command, error)

339

270

return True # Try again later

340

271

try:

341

272

logger.debug(u"Starting checker %r for %s",

342

273

command, self.name)

343

self.checker = subprocess.Popen(command,

344

close_fds=True,

345

shell=True, cwd="/")

274

self.checker = subprocess.\

275

Popen(command,

276

close_fds=True, shell=True,

277

cwd="/")

346

278

self.checker_callback_tag = gobject.child_watch_add\

347

279

(self.checker.pid,

348

280

self.checker_callback)

356

288

if self.checker_callback_tag:

357

289

gobject.source_remove(self.checker_callback_tag)

358

290

self.checker_callback_tag = None

359

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

291

if not hasattr(self, "checker") or self.checker is None:

360

292

return

361

293

logger.debug("Stopping checker for %(name)s", vars(self))

362

294

try:

365

297

#if self.checker.poll() is None:

366

298

# os.kill(self.checker.pid, signal.SIGKILL)

367

299

except OSError, error:

368

if error.errno != errno.ESRCH: # No such process

300

if error.errno != errno.ESRCH:

369

301

raise

370

302

self.checker = None

371

def still_valid(self):

303

def still_valid(self, now=None):

372

304

"""Has the timeout not yet passed for this client?"""

373

now = datetime.datetime.now()

374

if self.last_checked_ok is None:

305

if now is None:

306

now = datetime.datetime.now()

307

if self.last_seen is None:

375

308

return now < (self.created + self.timeout)

376

309

else:

377

return now < (self.last_checked_ok + self.timeout)

310

return now < (self.last_seen + self.timeout)

378

311

379

312

380

313

def peer_certificate(session):

433

366

def handle(self):

434

367

logger.debug(u"TCP connection from: %s",

435

368

unicode(self.client_address))

436

session = gnutls.connection.ClientSession\

437

(self.request, gnutls.connection.X509Credentials())

438

# Note: gnutls.connection.X509Credentials is really a generic

439

# GnuTLS certificate credentials object so long as no X.509

440

# keys are added to it. Therefore, we can use it here despite

441

# using OpenPGP certificates.

369

session = gnutls.connection.ClientSession(self.request,

370

gnutls.connection.\

371

X509Credentials())

442

372

443

373

#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",

444

374

# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",

445

375

# "+DHE-DSS"))

446

priority = "NORMAL" # Fallback default, since this

447

# MUST be set.

448

if self.server.settings["priority"]:

449

priority = self.server.settings["priority"]

376

priority = "NORMAL"

377

if self.server.options.priority:

378

priority = self.server.options.priority

450

379

gnutls.library.functions.gnutls_priority_set_direct\

451

380

(session._c_object, priority, None);

452

381

469

398

if c.fingerprint == fpr:

470

399

client = c

471

400

break

472

if not client:

473

logger.debug(u"Client not found for fingerprint: %s", fpr)

474

session.bye()

475

return

476

401

# Have to check if client.still_valid(), since it is possible

477

402

# that the client timed out while establishing the GnuTLS

478

403

# session.

479

if not client.still_valid():

480

logger.debug(u"Client %(name)s is invalid", vars(client))

404

if (not client) or (not client.still_valid()):

405

if client:

406

logger.debug(u"Client %(name)s is invalid",

407

vars(client))

408

else:

409

logger.debug(u"Client not found for fingerprint: %s",

410

fpr)

481

411

session.bye()

482

412

return

483

413

sent_size = 0

493

423

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

494

424

"""IPv6 TCP server. Accepts 'None' as address and/or port.

495

425

Attributes:

496

settings: Server settings

426

options: Command line options

497

427

clients: Set() of Client objects

498

428

"""

499

429

address_family = socket.AF_INET6

500

430

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

501

if "settings" in kwargs:

502

self.settings = kwargs["settings"]

503

del kwargs["settings"]

431

if "options" in kwargs:

432

self.options = kwargs["options"]

433

del kwargs["options"]

504

434

if "clients" in kwargs:

505

435

self.clients = kwargs["clients"]

506

436

del kwargs["clients"]

509

439

"""This overrides the normal server_bind() function

510

440

to bind to an interface if one was specified, and also NOT to

511

441

bind to an address or port if they were not specified."""

512

if self.settings["interface"]:

513

# 25 is from /usr/include/asm-i486/socket.h

514

SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)

442

if self.options.interface:

443

if not hasattr(socket, "SO_BINDTODEVICE"):

444

# From /usr/include/asm-i486/socket.h

445

socket.SO_BINDTODEVICE = 25

515

446

try:

516

447

self.socket.setsockopt(socket.SOL_SOCKET,

517

SO_BINDTODEVICE,

518

self.settings["interface"])

448

socket.SO_BINDTODEVICE,

449

self.options.interface)

519

450

except socket.error, error:

520

451

if error[0] == errno.EPERM:

521

452

logger.warning(u"No permission to"

522

453

u" bind to interface %s",

523

self.settings["interface"])

454

self.options.interface)

524

455

else:

525

456

raise error

526

457

# Only bind(2) the socket if we really need to.

569

500

return delta

570

501

571

502

503

def add_service():

504

"""Derived from the Avahi example code"""

505

global group, serviceName, serviceType, servicePort, serviceTXT, \

506

domain, host

507

if group is None:

508

group = dbus.Interface(

509

bus.get_object( avahi.DBUS_NAME,

510

server.EntryGroupNew()),

511

avahi.DBUS_INTERFACE_ENTRY_GROUP)

512

group.connect_to_signal('StateChanged',

513

entry_group_state_changed)

514

logger.debug(u"Adding service '%s' of type '%s' ...",

515

serviceName, serviceType)

516

517

group.AddService(

518

serviceInterface, # interface

519

avahi.PROTO_INET6, # protocol

520

dbus.UInt32(0), # flags

521

serviceName, serviceType,

522

domain, host,

523

dbus.UInt16(servicePort),

524

avahi.string_array_to_txt_array(serviceTXT))

525

group.Commit()

526

527

528

def remove_service():

529

"""From the Avahi example code"""

530

global group

531

532

if not group is None:

533

group.Reset()

534

535

572

536

def server_state_changed(state):

573

537

"""Derived from the Avahi example code"""

574

538

if state == avahi.SERVER_COLLISION:

575

539

logger.warning(u"Server name collision")

576

service.remove()

540

remove_service()

577

541

elif state == avahi.SERVER_RUNNING:

578

service.add()

542

add_service()

579

543

580

544

581

545

def entry_group_state_changed(state, error):

582

546

"""Derived from the Avahi example code"""

547

global serviceName, server, rename_count

548

583

549

logger.debug(u"state change: %i", state)

584

550

585

551

if state == avahi.ENTRY_GROUP_ESTABLISHED:

586

552

logger.debug(u"Service established.")

587

553

elif state == avahi.ENTRY_GROUP_COLLISION:

588

logger.warning(u"Service name collision.")

589

service.rename()

554

555

rename_count = rename_count - 1

556

if rename_count > 0:

557

name = server.GetAlternativeServiceName(name)

558

logger.warning(u"Service name collision, "

559

u"changing name to '%s' ...", name)

560

remove_service()

561

add_service()

562

563

else:

564

logger.error(u"No suitable service name found after %i"

565

u" retries, exiting.", n_rename)

566

killme(1)

590

567

elif state == avahi.ENTRY_GROUP_FAILURE:

591

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

592

unicode(error))

593

raise AvahiGroupError("State changed: %s", str(error))

594

595

def if_nametoindex(interface, _func=[None]):

596

"""Call the C function if_nametoindex(), or equivalent"""

597

if _func[0] is not None:

598

return _func[0](interface)

568

logger.error(u"Error in group state changed %s",

569

unicode(error))

570

killme(1)

571

572

573

def if_nametoindex(interface):

574

"""Call the C function if_nametoindex()"""

599

575

try:

600

if "ctypes.util" not in sys.modules:

601

import ctypes.util

602

while True:

603

try:

604

libc = ctypes.cdll.LoadLibrary\

605

(ctypes.util.find_library("c"))

606

_func[0] = libc.if_nametoindex

607

return _func[0](interface)

608

except IOError, e:

609

if e != errno.EINTR:

610

raise

576

libc = ctypes.cdll.LoadLibrary("libc.so.6")

577

return libc.if_nametoindex(interface)

611

578

except (OSError, AttributeError):

612

579

if "struct" not in sys.modules:

613

580

import struct

614

581

if "fcntl" not in sys.modules:

615

582

import fcntl

616

def the_hard_way(interface):

617

"Get an interface index the hard way, i.e. using fcntl()"

618

SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h

619

s = socket.socket()

620

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

621

struct.pack("16s16x", interface))

622

s.close()

623

interface_index = struct.unpack("I", ifreq[16:20])[0]

624

return interface_index

625

_func[0] = the_hard_way

626

return _func[0](interface)

583

SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h

584

s = socket.socket()

585

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

586

struct.pack("16s16x", interface))

587

s.close()

588

interface_index = struct.unpack("I", ifreq[16:20])[0]

589

return interface_index

627

590

628

591

629

592

def daemon(nochdir, noclose):

636

599

os.chdir("/")

637

600

if not noclose:

638

601

# Close all standard open file descriptors

639

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

602

null = os.open("/dev/null", os.O_NOCTTY | os.O_RDWR)

640

603

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

641

604

raise OSError(errno.ENODEV,

642

605

"/dev/null not a character device")

647

610

os.close(null)

648

611

649

612

613

def killme(status = 0):

614

logger.debug("Stopping server with exit status %d", status)

615

exitstatus = status

616

if main_loop_started:

617

main_loop.quit()

618

else:

619

sys.exit(status)

620

621

650

622

def main():

623

global exitstatus

624

exitstatus = 0

651

625

global main_loop_started

652

626

main_loop_started = False

653

627

654

628

parser = OptionParser()

655

629

parser.add_option("-i", "--interface", type="string",

656

metavar="IF", help="Bind to interface IF")

657

parser.add_option("-a", "--address", type="string",

630

default=None, metavar="IF",

631

help="Bind to interface IF")

632

parser.add_option("-a", "--address", type="string", default=None,

658

633

help="Address to listen for requests on")

659

parser.add_option("-p", "--port", type="int",

634

parser.add_option("-p", "--port", type="int", default=None,

660

635

help="Port number to receive requests on")

661

636

parser.add_option("--check", action="store_true", default=False,

662

637

help="Run self-test")

663

638

parser.add_option("--debug", action="store_true", default=False,

664

help="Debug mode; run in foreground and log to"

665

" terminal")

666

parser.add_option("--priority", type="string", help="GnuTLS"

667

" priority string (see GnuTLS documentation)")

668

parser.add_option("--servicename", type="string", metavar="NAME",

669

help="Zeroconf service name")

670

parser.add_option("--configdir", type="string",

671

default="/etc/mandos", metavar="DIR",

672

help="Directory to search for configuration"

673

" files")

639

help="Debug mode")

640

parser.add_option("--priority", type="string",

641

default="SECURE256",

642

help="GnuTLS priority string"

643

" (see GnuTLS documentation)")

644

parser.add_option("--servicename", type="string",

645

default="Mandos", help="Zeroconf service name")

674

646

(options, args) = parser.parse_args()

675

647

676

648

if options.check:

678

650

doctest.testmod()

679

651

sys.exit()

680

652

681

# Default values for config file for server-global settings

682

server_defaults = { "interface": "",

683

"address": "",

684

"port": "",

685

"debug": "False",

686

"priority":

687

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",

688

"servicename": "Mandos",

689

}

690

691

# Parse config file for server-global settings

692

server_config = ConfigParser.SafeConfigParser(server_defaults)

693

del server_defaults

694

server_config.read(os.path.join(options.configdir, "server.conf"))

695

server_section = "server"

696

# Convert the SafeConfigParser object to a dict

697

server_settings = dict(server_config.items(server_section))

698

# Use getboolean on the boolean config option

699

server_settings["debug"] = server_config.getboolean\

700

(server_section, "debug")

701

del server_config

702

703

# Override the settings from the config file with command line

704

# options, if set.

705

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

706

"priority", "servicename", "configdir"):

707

value = getattr(options, option)

708

if value is not None:

709

server_settings[option] = value

710

del options

711

# Now we have our good server settings in "server_settings"

712

713

# Parse config file with clients

714

client_defaults = { "timeout": "1h",

715

"interval": "5m",

716

"checker": "fping -q -- %%(fqdn)s",

717

}

718

client_config = ConfigParser.SafeConfigParser(client_defaults)

719

client_config.read(os.path.join(server_settings["configdir"],

720

"clients.conf"))

721

722

global service

723

service = AvahiService(name = server_settings["servicename"],

724

type = "_mandos._tcp", );

725

if server_settings["interface"]:

726

service.interface = if_nametoindex(server_settings["interface"])

653

# Parse config file

654

defaults = { "timeout": "1h",

655

"interval": "5m",

656

"checker": "fping -q -- %%(fqdn)s",

657

}

658

client_config = ConfigParser.SafeConfigParser(defaults)

659

#client_config.readfp(open("global.conf"), "global.conf")

660

client_config.read("mandos-clients.conf")

661

662

global serviceName

663

serviceName = options.servicename;

727

664

728

665

global main_loop

729

666

global bus

737

674

avahi.DBUS_INTERFACE_SERVER )

738

675

# End of Avahi example code

739

676

740

debug = server_settings["debug"]

677

debug = options.debug

741

678

742

679

if debug:

743

680

console = logging.StreamHandler()

752

689

clients.remove(client)

753

690

if not clients:

754

691

logger.debug(u"No clients left, exiting")

755

sys.exit()

692

killme()

756

693

757

694

clients.update(Set(Client(name=section,

758

695

stop_hook = remove_from_clients,

781

718

782

719

if not debug:

783

720

signal.signal(signal.SIGINT, signal.SIG_IGN)

784

signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())

785

signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())

721

signal.signal(signal.SIGHUP, lambda signum, frame: killme())

722

signal.signal(signal.SIGTERM, lambda signum, frame: killme())

786

723

787

724

for client in clients:

788

725

client.start()

789

726

790

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

791

server_settings["port"]),

727

tcp_server = IPv6_TCPServer((options.address, options.port),

792

728

tcp_handler,

793

settings=server_settings,

729

options=options,

794

730

clients=clients)

795

# Find out what port we got

796

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

797

logger.debug(u"Now listening on address %r, port %d, flowinfo %d,"

798

u" scope_id %d" % tcp_server.socket.getsockname())

799

800

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

801

802

try:

803

# From the Avahi example code

804

server.connect_to_signal("StateChanged", server_state_changed)

805

try:

806

server_state_changed(server.GetState())

807

except dbus.exceptions.DBusException, error:

808

logger.critical(u"DBusException: %s", error)

809

sys.exit(1)

810

# End of Avahi example code

811

812

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

813

lambda *args, **kwargs:

814

tcp_server.handle_request\

815

(*args[2:], **kwargs) or True)

816

731

# Find out what random port we got

732

global servicePort

733

servicePort = tcp_server.socket.getsockname()[1]

734

logger.debug(u"Now listening on port %d", servicePort)

735

736

if options.interface is not None:

737

global serviceInterface

738

serviceInterface = if_nametoindex(options.interface)

739

740

# From the Avahi example code

741

server.connect_to_signal("StateChanged", server_state_changed)

742

try:

743

server_state_changed(server.GetState())

744

except dbus.exceptions.DBusException, error:

745

logger.critical(u"DBusException: %s", error)

746

killme(1)

747

# End of Avahi example code

748

749

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

750

lambda *args, **kwargs:

751

tcp_server.handle_request(*args[2:],

752

**kwargs) or True)

753

try:

817

754

logger.debug("Starting main loop")

818

755

main_loop_started = True

819

756

main_loop.run()

820

except AvahiError, error:

821

logger.critical(u"AvahiError: %s" + unicode(error))

822

sys.exit(1)

823

757

except KeyboardInterrupt:

824

758

if debug:

825

759

print

760

761

sys.exit(exitstatus)

826

762

827

763

if __name__ == '__main__':

828

764

main()