/mandos/release : revision 24.1.8

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: "add_service", "remove_service",

9

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

10

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

11

# in "main".

12

#

13

14

# Påhlsson.

13

# Everything else is

14

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 <https://www.fukt.bsnet.se/~belorn/> and

30

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

29

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

31

30

#

32

31

33

32

from __future__ import division

66

65

#

67

66

# This server announces itself as a Zeroconf service. Connecting

68

67

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

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

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

71

70

# supply an OpenPGP certificate, and the fingerprint of this

72

71

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

73

72

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

82

81

logger.addHandler(syslogger)

83

82

del syslogger

84

83

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

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

89

166

# From the Avahi example code:

90

serviceName = "Mandos"

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

167

group = None # our entry group

99

168

# End of Avahi example code

100

169

101

170

107

176

uniquely identify the client

108

177

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

109

178

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

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

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

114

183

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

115

184

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

116

185

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

117

186

to see if the client lives.

118

Is None if no process is running.

187

'None' if no process is running.

119

188

checker_initiator_tag: a gobject event source tag, or None

120

189

stop_initiator_tag: - '' -

121

190

checker_callback_tag: - '' -

122

191

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

123

client lives. %()s expansions are done at

192

client lives. %() expansions are done at

124

193

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

125

194

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

126

195

Private attibutes:

127

196

_timeout: Real variable for 'timeout'

128

197

_interval: Real variable for 'interval'

129

_timeout_milliseconds: Used by gobject.timeout_add()

198

_timeout_milliseconds: Used when calling gobject.timeout_add()

130

199

_interval_milliseconds: - '' -

131

200

"""

132

201

def _set_timeout(self, timeout):

152

221

interval = property(lambda self: self._interval,

153

222

_set_interval)

154

223

del _set_interval

155

def __init__(self, name=None, options=None, stop_hook=None,

156

fingerprint=None, secret=None, secfile=None,

157

fqdn=None, timeout=None, interval=-1, checker=None):

224

def __init__(self, name=None, stop_hook=None, fingerprint=None,

225

secret=None, secfile=None, fqdn=None, timeout=None,

226

interval=-1, checker=None):

158

227

"""Note: the 'checker' argument sets the 'checker_command'

159

228

attribute and not the 'checker' attribute.."""

160

229

self.name = name

230

logger.debug(u"Creating client %r", self.name)

161

231

# Uppercase and remove spaces from fingerprint

162

232

# for later comparison purposes with return value of

163

233

# the fingerprint() function

164

234

self.fingerprint = fingerprint.upper().replace(u" ", u"")

235

logger.debug(u" Fingerprint: %s", self.fingerprint)

165

236

if secret:

166

237

self.secret = secret.decode(u"base64")

167

238

elif secfile:

169

240

self.secret = sf.read()

170

241

sf.close()

171

242

else:

172

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

173

% self.name)

174

self.fqdn = fqdn # string

243

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

244

% self.name)

245

self.fqdn = fqdn

175

246

self.created = datetime.datetime.now()

176

self.last_seen = None

177

if timeout is None:

178

self.timeout = options.timeout

179

else:

180

self.timeout = string_to_delta(timeout)

181

if interval == -1:

182

self.interval = options.interval

183

else:

184

self.interval = string_to_delta(interval)

247

self.last_checked_ok = None

248

self.timeout = string_to_delta(timeout)

249

self.interval = string_to_delta(interval)

185

250

self.stop_hook = stop_hook

186

251

self.checker = None

187

252

self.checker_initiator_tag = None

203

268

self.stop)

204

269

def stop(self):

205

270

"""Stop this client.

206

The possibility that this client might be restarted is left

207

open, but not currently used."""

271

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

272

but not currently used."""

208

273

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

209

274

if self.secret:

210

275

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

211

276

self.secret = None

212

277

else:

213

278

return False

214

if hasattr(self, "stop_initiator_tag") \

215

and self.stop_initiator_tag:

279

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

216

280

gobject.source_remove(self.stop_initiator_tag)

217

281

self.stop_initiator_tag = None

218

if hasattr(self, "checker_initiator_tag") \

219

and self.checker_initiator_tag:

282

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

220

283

gobject.source_remove(self.checker_initiator_tag)

221

284

self.checker_initiator_tag = None

222

285

self.stop_checker()

236

299

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

237

300

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

238

301

vars(self))

239

self.last_seen = now

302

self.last_checked_ok = now

240

303

gobject.source_remove(self.stop_initiator_tag)

241

304

self.stop_initiator_tag = gobject.timeout_add\

242

305

(self._timeout_milliseconds,

261

324

# is as it should be.

262

325

if self.checker is None:

263

326

try:

327

# In case check_command has exactly one % operator

264

328

command = self.check_command % self.fqdn

265

329

except TypeError:

330

# Escape attributes for the shell

266

331

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

267

332

for key, val in

268

333

vars(self).iteritems())

269

334

try:

270

335

command = self.check_command % escaped_attrs

271

336

except TypeError, error:

272

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

273

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

337

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

338

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

274

339

return True # Try again later

275

340

try:

276

341

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

277

342

command, self.name)

278

self.checker = subprocess.\

279

Popen(command,

280

close_fds=True, shell=True,

281

cwd="/")

343

self.checker = subprocess.Popen(command,

344

close_fds=True,

345

shell=True, cwd="/")

282

346

self.checker_callback_tag = gobject.child_watch_add\

283

347

(self.checker.pid,

284

348

self.checker_callback)

292

356

if self.checker_callback_tag:

293

357

gobject.source_remove(self.checker_callback_tag)

294

358

self.checker_callback_tag = None

295

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

359

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

296

360

return

297

361

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

298

362

try:

301

365

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

302

366

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

303

367

except OSError, error:

304

if error.errno != errno.ESRCH:

368

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

305

369

raise

306

370

self.checker = None

307

def still_valid(self, now=None):

371

def still_valid(self):

308

372

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

309

if now is None:

310

now = datetime.datetime.now()

311

if self.last_seen is None:

373

now = datetime.datetime.now()

374

if self.last_checked_ok is None:

312

375

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

313

376

else:

314

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

377

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

315

378

316

379

317

380

def peer_certificate(session):

370

433

def handle(self):

371

434

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

372

435

unicode(self.client_address))

373

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

374

gnutls.connection.\

375

X509Credentials())

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.

376

442

377

443

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

378

444

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

379

445

# "+DHE-DSS"))

380

priority = "SECURE256"

381

446

priority = "NORMAL" # Fallback default, since this

447

# MUST be set.

448

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

449

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

382

450

gnutls.library.functions.gnutls_priority_set_direct\

383

451

(session._c_object, priority, None);

384

452

401

469

if c.fingerprint == fpr:

402

470

client = c

403

471

break

472

if not client:

473

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

474

session.bye()

475

return

404

476

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

405

477

# that the client timed out while establishing the GnuTLS

406

478

# session.

407

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

408

if client:

409

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

410

vars(client))

411

else:

412

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

413

fpr)

479

if not client.still_valid():

480

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

414

481

session.bye()

415

482

return

416

483

sent_size = 0

426

493

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

427

494

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

428

495

Attributes:

429

options: Command line options

496

settings: Server settings

430

497

clients: Set() of Client objects

431

498

"""

432

499

address_family = socket.AF_INET6

433

500

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

434

if "options" in kwargs:

435

self.options = kwargs["options"]

436

del kwargs["options"]

501

if "settings" in kwargs:

502

self.settings = kwargs["settings"]

503

del kwargs["settings"]

437

504

if "clients" in kwargs:

438

505

self.clients = kwargs["clients"]

439

506

del kwargs["clients"]

442

509

"""This overrides the normal server_bind() function

443

510

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

444

511

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

445

if self.options.interface:

446

if not hasattr(socket, "SO_BINDTODEVICE"):

447

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

448

socket.SO_BINDTODEVICE = 25

512

if self.settings["interface"]:

513

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

514

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

449

515

try:

450

516

self.socket.setsockopt(socket.SOL_SOCKET,

451

socket.SO_BINDTODEVICE,

452

self.options.interface)

517

SO_BINDTODEVICE,

518

self.settings["interface"])

453

519

except socket.error, error:

454

520

if error[0] == errno.EPERM:

455

521

logger.warning(u"No permission to"

456

522

u" bind to interface %s",

457

self.options.interface)

523

self.settings["interface"])

458

524

else:

459

525

raise error

460

526

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

503

569

return delta

504

570

505

571

506

def add_service():

507

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

508

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

509

domain, host

510

if group is None:

511

group = dbus.Interface(

512

bus.get_object( avahi.DBUS_NAME,

513

server.EntryGroupNew()),

514

avahi.DBUS_INTERFACE_ENTRY_GROUP)

515

group.connect_to_signal('StateChanged',

516

entry_group_state_changed)

517

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

518

serviceName, serviceType)

519

520

group.AddService(

521

serviceInterface, # interface

522

avahi.PROTO_INET6, # protocol

523

dbus.UInt32(0), # flags

524

serviceName, serviceType,

525

domain, host,

526

dbus.UInt16(servicePort),

527

avahi.string_array_to_txt_array(serviceTXT))

528

group.Commit()

529

530

531

def remove_service():

532

"""From the Avahi example code"""

533

global group

534

535

if not group is None:

536

group.Reset()

537

538

539

572

def server_state_changed(state):

540

573

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

541

574

if state == avahi.SERVER_COLLISION:

542

575

logger.warning(u"Server name collision")

543

remove_service()

576

service.remove()

544

577

elif state == avahi.SERVER_RUNNING:

545

add_service()

578

service.add()

546

579

547

580

548

581

def entry_group_state_changed(state, error):

549

582

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

550

global serviceName, server, rename_count

551

552

583

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

553

584

554

585

if state == avahi.ENTRY_GROUP_ESTABLISHED:

555

586

logger.debug(u"Service established.")

556

587

elif state == avahi.ENTRY_GROUP_COLLISION:

557

558

rename_count = rename_count - 1

559

if rename_count > 0:

560

name = server.GetAlternativeServiceName(name)

561

logger.warning(u"Service name collision, "

562

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

563

remove_service()

564

add_service()

565

566

else:

567

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

568

u" retries, exiting.", n_rename)

569

killme(1)

588

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

589

service.rename()

570

590

elif state == avahi.ENTRY_GROUP_FAILURE:

571

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

572

unicode(error))

573

killme(1)

574

575

576

def if_nametoindex(interface):

577

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

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)

578

599

try:

579

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

580

return libc.if_nametoindex(interface)

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

581

611

except (OSError, AttributeError):

582

612

if "struct" not in sys.modules:

583

613

import struct

584

614

if "fcntl" not in sys.modules:

585

615

import fcntl

586

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

587

s = socket.socket()

588

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

589

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

590

s.close()

591

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

592

return interface_index

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)

593

627

594

628

595

629

def daemon(nochdir, noclose):

602

636

os.chdir("/")

603

637

if not noclose:

604

638

# Close all standard open file descriptors

605

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

639

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

606

640

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

607

641

raise OSError(errno.ENODEV,

608

642

"/dev/null not a character device")

613

647

os.close(null)

614

648

615

649

616

def killme(status = 0):

617

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

618

exitstatus = status

619

if main_loop_started:

620

main_loop.quit()

621

else:

622

sys.exit(status)

623

624

625

650

def main():

626

global exitstatus

627

exitstatus = 0

628

651

global main_loop_started

629

652

main_loop_started = False

630

653

631

654

parser = OptionParser()

632

655

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

633

default=None, metavar="IF",

634

help="Bind to interface IF")

635

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

656

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

657

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

636

658

help="Address to listen for requests on")

637

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

659

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

638

660

help="Port number to receive requests on")

639

parser.add_option("--timeout", type="string", # Parsed later

640

default="1h",

641

help="Amount of downtime allowed for clients")

642

parser.add_option("--interval", type="string", # Parsed later

643

default="5m",

644

help="How often to check that a client is up")

645

661

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

646

662

help="Run self-test")

647

663

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

648

help="Debug mode")

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")

649

674

(options, args) = parser.parse_args()

650

675

651

676

if options.check:

653

678

doctest.testmod()

654

679

sys.exit()

655

680

656

# Parse the time arguments

657

try:

658

options.timeout = string_to_delta(options.timeout)

659

except ValueError:

660

parser.error("option --timeout: Unparseable time")

661

try:

662

options.interval = string_to_delta(options.interval)

663

except ValueError:

664

parser.error("option --interval: Unparseable time")

665

666

# Parse config file

667

defaults = { "checker": "fping -q -- %%(fqdn)s" }

668

client_config = ConfigParser.SafeConfigParser(defaults)

669

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

670

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

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"])

671

727

672

728

global main_loop

673

729

global bus

681

737

avahi.DBUS_INTERFACE_SERVER )

682

738

# End of Avahi example code

683

739

684

debug = options.debug

740

debug = server_settings["debug"]

685

741

686

742

if debug:

687

743

console = logging.StreamHandler()

696

752

clients.remove(client)

697

753

if not clients:

698

754

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

699

killme()

755

sys.exit()

700

756

701

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

757

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

702

758

stop_hook = remove_from_clients,

703

759

**(dict(client_config\

704

760

.items(section))))

725

781

726

782

if not debug:

727

783

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

728

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

729

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

784

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

785

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

730

786

731

787

for client in clients:

732

788

client.start()

733

789

734

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

790

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

791

server_settings["port"]),

735

792

tcp_handler,

736

options=options,

793

settings=server_settings,

737

794

clients=clients)

738

# Find out what random port we got

739

global servicePort

740

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

741

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

742

743

if options.interface is not None:

744

global serviceInterface

745

serviceInterface = if_nametoindex(options.interface)

746

747

# From the Avahi example code

748

server.connect_to_signal("StateChanged", server_state_changed)

749

try:

750

server_state_changed(server.GetState())

751

except dbus.exceptions.DBusException, error:

752

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

753

killme(1)

754

# End of Avahi example code

755

756

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

757

lambda *args, **kwargs:

758

tcp_server.handle_request(*args[2:],

759

**kwargs) or True)

760

try:

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

761

817

logger.debug("Starting main loop")

762

818

main_loop_started = True

763

819

main_loop.run()

820

except AvahiError, error:

821

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

822

sys.exit(1)

764

823

except KeyboardInterrupt:

765

824

if debug:

766

825

print

767

768

sys.exit(exitstatus)

769

826

770

827

if __name__ == '__main__':

771

828

main()