/mandos/trunk : revision 24

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

439

line = self.request.makefile().readline()

440

logger.debug(u"Protocol version: %r", line)

441

try:

442

if int(line.strip().split()[0]) > 1:

443

raise RuntimeError

444

except (ValueError, IndexError, RuntimeError), error:

445

logger.error(u"Unknown protocol version: %s", error)

446

return

447

448

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

449

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

450

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

451

# using OpenPGP certificates.

373

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

374

gnutls.connection.\

375

X509Credentials())

452

376

453

377

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

454

378

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

455

379

# "+DHE-DSS"))

456

priority = "NORMAL" # Fallback default, since this

457

# MUST be set.

458

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

459

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

380

priority = "SECURE256"

381

460

382

gnutls.library.functions.gnutls_priority_set_direct\

461

383

(session._c_object, priority, None);

462

384

479

401

if c.fingerprint == fpr:

480

402

client = c

481

403

break

482

if not client:

483

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

484

session.bye()

485

return

486

404

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

487

405

# that the client timed out while establishing the GnuTLS

488

406

# session.

489

if not client.still_valid():

490

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)

491

414

session.bye()

492

415

return

493

416

sent_size = 0

503

426

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

504

427

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

505

428

Attributes:

506

settings: Server settings

429

options: Command line options

507

430

clients: Set() of Client objects

508

431

"""

509

432

address_family = socket.AF_INET6

510

433

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

511

if "settings" in kwargs:

512

self.settings = kwargs["settings"]

513

del kwargs["settings"]

434

if "options" in kwargs:

435

self.options = kwargs["options"]

436

del kwargs["options"]

514

437

if "clients" in kwargs:

515

438

self.clients = kwargs["clients"]

516

439

del kwargs["clients"]

519

442

"""This overrides the normal server_bind() function

520

443

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

521

444

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

522

if self.settings["interface"]:

523

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

524

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

525

449

try:

526

450

self.socket.setsockopt(socket.SOL_SOCKET,

527

SO_BINDTODEVICE,

528

self.settings["interface"])

451

socket.SO_BINDTODEVICE,

452

self.options.interface)

529

453

except socket.error, error:

530

454

if error[0] == errno.EPERM:

531

455

logger.warning(u"No permission to"

532

456

u" bind to interface %s",

533

self.settings["interface"])

457

self.options.interface)

534

458

else:

535

459

raise error

536

460

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

579

503

return delta

580

504

581

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

582

539

def server_state_changed(state):

583

540

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

584

541

if state == avahi.SERVER_COLLISION:

585

542

logger.warning(u"Server name collision")

586

service.remove()

543

remove_service()

587

544

elif state == avahi.SERVER_RUNNING:

588

service.add()

545

add_service()

589

546

590

547

591

548

def entry_group_state_changed(state, error):

592

549

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

550

global serviceName, server, rename_count

551

593

552

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

594

553

595

554

if state == avahi.ENTRY_GROUP_ESTABLISHED:

596

555

logger.debug(u"Service established.")

597

556

elif state == avahi.ENTRY_GROUP_COLLISION:

598

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

599

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)

600

570

elif state == avahi.ENTRY_GROUP_FAILURE:

601

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

602

unicode(error))

603

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

571

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

572

unicode(error))

573

killme(1)

574

604

575

605

576

def if_nametoindex(interface):

606

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

607

global if_nametoindex

577

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

608

578

try:

609

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

610

import ctypes.util

611

if_nametoindex = ctypes.cdll.LoadLibrary\

612

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

579

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

580

return libc.if_nametoindex(interface)

613

581

except (OSError, AttributeError):

614

582

if "struct" not in sys.modules:

615

583

import struct

616

584

if "fcntl" not in sys.modules:

617

585

import fcntl

618

def if_nametoindex(interface):

619

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

620

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

621

s = socket.socket()

622

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

623

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

624

s.close()

625

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

626

return interface_index

627

return if_nametoindex(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

628

593

629

594

630

595

def daemon(nochdir, noclose):

637

602

os.chdir("/")

638

603

if not noclose:

639

604

# Close all standard open file descriptors

640

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

605

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

641

606

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

642

607

raise OSError(errno.ENODEV,

643

608

"/dev/null not a character device")

648

613

os.close(null)

649

614

650

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

651

625

def main():

626

global exitstatus

627

exitstatus = 0

652

628

global main_loop_started

653

629

main_loop_started = False

654

630

655

631

parser = OptionParser()

656

632

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

657

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

658

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,

659

636

help="Address to listen for requests on")

660

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

637

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

661

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

662

645

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

663

646

help="Run self-test")

664

647

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

665

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

666

" terminal")

667

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

668

" priority string (see GnuTLS documentation)")

669

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

670

help="Zeroconf service name")

671

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

672

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

673

help="Directory to search for configuration"

674

" files")

648

help="Debug mode")

675

649

(options, args) = parser.parse_args()

676

650

677

651

if options.check:

679

653

doctest.testmod()

680

654

sys.exit()

681

655

682

# Default values for config file for server-global settings

683

server_defaults = { "interface": "",

684

"address": "",

685

"port": "",

686

"debug": "False",

687

"priority":

688

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

689

"servicename": "Mandos",

690

}

691

692

# Parse config file for server-global settings

693

server_config = ConfigParser.SafeConfigParser(server_defaults)

694

del server_defaults

695

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

696

server_section = "server"

697

# Convert the SafeConfigParser object to a dict

698

server_settings = dict(server_config.items(server_section))

699

# Use getboolean on the boolean config option

700

server_settings["debug"] = server_config.getboolean\

701

(server_section, "debug")

702

del server_config

703

704

# Override the settings from the config file with command line

705

# options, if set.

706

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

707

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

708

value = getattr(options, option)

709

if value is not None:

710

server_settings[option] = value

711

del options

712

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

713

714

# Parse config file with clients

715

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

716

"interval": "5m",

717

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

718

}

719

client_config = ConfigParser.SafeConfigParser(client_defaults)

720

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

721

"clients.conf"))

722

723

global service

724

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

725

type = "_mandos._tcp", );

726

if server_settings["interface"]:

727

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

728

671

729

672

global main_loop

730

673

global bus

738

681

avahi.DBUS_INTERFACE_SERVER )

739

682

# End of Avahi example code

740

683

741

debug = server_settings["debug"]

684

debug = options.debug

742

685

743

686

if debug:

744

687

console = logging.StreamHandler()

753

696

clients.remove(client)

754

697

if not clients:

755

698

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

756

sys.exit()

699

killme()

757

700

758

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

701

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

759

702

stop_hook = remove_from_clients,

760

703

**(dict(client_config\

761

704

.items(section))))

782

725

783

726

if not debug:

784

727

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

785

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

786

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

787

730

788

731

for client in clients:

789

732

client.start()

790

733

791

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

792

server_settings["port"]),

734

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

793

735

tcp_handler,

794

settings=server_settings,

736

options=options,

795

737

clients=clients)

796

# Find out what port we got

797

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

798

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

799

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

800

801

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

802

803

try:

804

# From the Avahi example code

805

server.connect_to_signal("StateChanged", server_state_changed)

806

try:

807

server_state_changed(server.GetState())

808

except dbus.exceptions.DBusException, error:

809

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

810

sys.exit(1)

811

# End of Avahi example code

812

813

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

814

lambda *args, **kwargs:

815

tcp_server.handle_request\

816

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

817

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:

818

761

logger.debug("Starting main loop")

819

762

main_loop_started = True

820

763

main_loop.run()

821

except AvahiError, error:

822

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

823

sys.exit(1)

824

764

except KeyboardInterrupt:

825

765

if debug:

826

766

print

767

768

sys.exit(exitstatus)

827

769

828

770

if __name__ == '__main__':

829

771

main()