/mandos/release : revision 23

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

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

221

152

interval = property(lambda self: self._interval,

222

153

_set_interval)

223

154

del _set_interval

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

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

227

158

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

228

159

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

229

160

self.name = name

230

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

231

161

# Uppercase and remove spaces from fingerprint

232

162

# for later comparison purposes with return value of

233

163

# the fingerprint() function

234

164

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

235

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

236

165

if secret:

237

166

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

238

167

elif secfile:

240

169

self.secret = sf.read()

241

170

sf.close()

242

171

else:

243

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

244

% self.name)

245

self.fqdn = fqdn

172

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

173

% self.name)

174

self.fqdn = fqdn # string

246

175

self.created = datetime.datetime.now()

247

self.last_checked_ok = None

248

self.timeout = string_to_delta(timeout)

249

self.interval = string_to_delta(interval)

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)

250

185

self.stop_hook = stop_hook

251

186

self.checker = None

252

187

self.checker_initiator_tag = None

268

203

self.stop)

269

204

def stop(self):

270

205

"""Stop this client.

271

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

272

but not currently used."""

206

The possibility that this client might be restarted is left

207

open, but not currently used."""

273

208

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

274

209

if self.secret:

275

210

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

276

211

self.secret = None

277

212

else:

278

213

return False

279

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

214

if hasattr(self, "stop_initiator_tag") \

215

and self.stop_initiator_tag:

280

216

gobject.source_remove(self.stop_initiator_tag)

281

217

self.stop_initiator_tag = None

282

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

218

if hasattr(self, "checker_initiator_tag") \

219

and self.checker_initiator_tag:

283

220

gobject.source_remove(self.checker_initiator_tag)

284

221

self.checker_initiator_tag = None

285

222

self.stop_checker()

299

236

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

300

237

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

301

238

vars(self))

302

self.last_checked_ok = now

239

self.last_seen = now

303

240

gobject.source_remove(self.stop_initiator_tag)

304

241

self.stop_initiator_tag = gobject.timeout_add\

305

242

(self._timeout_milliseconds,

324

261

# is as it should be.

325

262

if self.checker is None:

326

263

try:

327

# In case check_command has exactly one % operator

328

264

command = self.check_command % self.fqdn

329

265

except TypeError:

330

# Escape attributes for the shell

331

266

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

332

267

for key, val in

333

268

vars(self).iteritems())

334

269

try:

335

270

command = self.check_command % escaped_attrs

336

271

except TypeError, error:

337

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

338

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

272

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

273

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

339

274

return True # Try again later

340

275

try:

341

276

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

342

277

command, self.name)

343

self.checker = subprocess.Popen(command,

344

close_fds=True,

345

shell=True, cwd="/")

278

self.checker = subprocess.\

279

Popen(command,

280

close_fds=True, shell=True,

281

cwd="/")

346

282

self.checker_callback_tag = gobject.child_watch_add\

347

283

(self.checker.pid,

348

284

self.checker_callback)

356

292

if self.checker_callback_tag:

357

293

gobject.source_remove(self.checker_callback_tag)

358

294

self.checker_callback_tag = None

359

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

295

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

360

296

return

361

297

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

362

298

try:

365

301

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

366

302

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

367

303

except OSError, error:

368

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

304

if error.errno != errno.ESRCH:

369

305

raise

370

306

self.checker = None

371

def still_valid(self):

307

def still_valid(self, now=None):

372

308

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

373

now = datetime.datetime.now()

374

if self.last_checked_ok is None:

309

if now is None:

310

now = datetime.datetime.now()

311

if self.last_seen is None:

375

312

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

376

313

else:

377

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

314

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

378

315

379

316

380

317

def peer_certificate(session):

433

370

def handle(self):

434

371

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

435

372

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.

373

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

374

gnutls.connection.\

375

X509Credentials())

442

376

443

377

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

444

378

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

445

379

# "+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"]

380

priority = "SECURE256"

381

450

382

gnutls.library.functions.gnutls_priority_set_direct\

451

383

(session._c_object, priority, None);

452

384

469

401

if c.fingerprint == fpr:

470

402

client = c

471

403

break

472

if not client:

473

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

474

session.bye()

475

return

476

404

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

477

405

# that the client timed out while establishing the GnuTLS

478

406

# session.

479

if not client.still_valid():

480

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

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)

481

414

session.bye()

482

415

return

483

416

sent_size = 0

493

426

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

494

427

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

495

428

Attributes:

496

settings: Server settings

429

options: Command line options

497

430

clients: Set() of Client objects

498

431

"""

499

432

address_family = socket.AF_INET6

500

433

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

501

if "settings" in kwargs:

502

self.settings = kwargs["settings"]

503

del kwargs["settings"]

434

if "options" in kwargs:

435

self.options = kwargs["options"]

436

del kwargs["options"]

504

437

if "clients" in kwargs:

505

438

self.clients = kwargs["clients"]

506

439

del kwargs["clients"]

509

442

"""This overrides the normal server_bind() function

510

443

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

511

444

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)

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

515

449

try:

516

450

self.socket.setsockopt(socket.SOL_SOCKET,

517

SO_BINDTODEVICE,

518

self.settings["interface"])

451

socket.SO_BINDTODEVICE,

452

self.options.interface)

519

453

except socket.error, error:

520

454

if error[0] == errno.EPERM:

521

455

logger.warning(u"No permission to"

522

456

u" bind to interface %s",

523

self.settings["interface"])

457

self.options.interface)

524

458

else:

525

459

raise error

526

460

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

569

503

return delta

570

504

571

505

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

572

539

def server_state_changed(state):

573

540

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

574

541

if state == avahi.SERVER_COLLISION:

575

542

logger.warning(u"Server name collision")

576

service.remove()

543

remove_service()

577

544

elif state == avahi.SERVER_RUNNING:

578

service.add()

545

add_service()

579

546

580

547

581

548

def entry_group_state_changed(state, error):

582

549

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

550

global serviceName, server, rename_count

551

583

552

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

584

553

585

554

if state == avahi.ENTRY_GROUP_ESTABLISHED:

586

555

logger.debug(u"Service established.")

587

556

elif state == avahi.ENTRY_GROUP_COLLISION:

588

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

589

service.rename()

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)

590

570

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)

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

599

578

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

579

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

580

return libc.if_nametoindex(interface)

611

581

except (OSError, AttributeError):

612

582

if "struct" not in sys.modules:

613

583

import struct

614

584

if "fcntl" not in sys.modules:

615

585

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)

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

627

593

628

594

629

595

def daemon(nochdir, noclose):

636

602

os.chdir("/")

637

603

if not noclose:

638

604

# Close all standard open file descriptors

639

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

605

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

640

606

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

641

607

raise OSError(errno.ENODEV,

642

608

"/dev/null not a character device")

647

613

os.close(null)

648

614

649

615

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

650

625

def main():

626

global exitstatus

627

exitstatus = 0

651

628

global main_loop_started

652

629

main_loop_started = False

653

630

654

631

parser = OptionParser()

655

632

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

656

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

657

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

633

default=None, metavar="IF",

634

help="Bind to interface IF")

635

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

658

636

help="Address to listen for requests on")

659

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

637

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

660

638

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

661

645

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

662

646

help="Run self-test")

663

647

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

648

help="Debug mode")

674

649

(options, args) = parser.parse_args()

675

650

676

651

if options.check:

678

653

doctest.testmod()

679

654

sys.exit()

680

655

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

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

727

671

728

672

global main_loop

729

673

global bus

737

681

avahi.DBUS_INTERFACE_SERVER )

738

682

# End of Avahi example code

739

683

740

debug = server_settings["debug"]

684

debug = options.debug

741

685

742

686

if debug:

743

687

console = logging.StreamHandler()

752

696

clients.remove(client)

753

697

if not clients:

754

698

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

755

sys.exit()

699

killme()

756

700

757

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

701

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

758

702

stop_hook = remove_from_clients,

759

703

**(dict(client_config\

760

704

.items(section))))

781

725

782

726

if not debug:

783

727

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

728

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

729

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

786

730

787

731

for client in clients:

788

732

client.start()

789

733

790

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

791

server_settings["port"]),

734

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

792

735

tcp_handler,

793

settings=server_settings,

736

options=options,

794

737

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

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:

817

761

logger.debug("Starting main loop")

818

762

main_loop_started = True

819

763

main_loop.run()

820

except AvahiError, error:

821

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

822

sys.exit(1)

823

764

except KeyboardInterrupt:

824

765

if debug:

825

766

print

767

768

sys.exit(exitstatus)

826

769

827

770

if __name__ == '__main__':

828

771

main()