/mandos/trunk : revision 47

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

10

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

11

# in "main".

9

# methods "add" and "remove" in the "AvahiService" class, the

10

# "server_state_changed" and "entry_group_state_changed" functions,

11

# and some lines 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

62

61

from dbus.mainloop.glib import DBusGMainLoop

63

62

import ctypes

64

63

65

# Brief description of the operation of this program:

66

#

67

# This server announces itself as a Zeroconf service. Connecting

68

# 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

71

# supply an OpenPGP certificate, and the fingerprint of this

72

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

73

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

74

# authentication or authorization is done by this server.

75

76

64

77

65

logger = logging.Logger('mandos')

78

66

syslogger = logging.handlers.SysLogHandler\

82

70

logger.addHandler(syslogger)

83

71

del syslogger

84

72

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

73

74

class AvahiError(Exception):

75

def __init__(self, value):

76

self.value = value

77

def __str__(self):

78

return repr(self.value)

79

80

class AvahiServiceError(AvahiError):

81

pass

82

83

class AvahiGroupError(AvahiError):

84

pass

85

86

87

class AvahiService(object):

88

"""An Avahi (Zeroconf) service.

89

Attributes:

90

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

91

Used to optionally bind to the specified interface.

92

name: string; Example: 'Mandos'

93

type: string; Example: '_mandos._tcp'.

94

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

95

port: integer; what port to announce

96

TXT: list of strings; TXT record for the service

97

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

98

host: string; Host to publish records for, default is localhost

99

max_renames: integer; maximum number of renames

100

rename_count: integer; counter so we only rename after collisions

101

a sensible number of times

102

"""

103

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

104

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

105

host = "", max_renames = 12):

106

self.interface = interface

107

self.name = name

108

self.type = type

109

self.port = port

110

if TXT is None:

111

self.TXT = []

112

else:

113

self.TXT = TXT

114

self.domain = domain

115

self.host = host

116

self.rename_count = 0

117

def rename(self):

118

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

119

if self.rename_count >= self.max_renames:

120

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

121

u" retries, exiting.", rename_count)

122

raise AvahiServiceError("Too many renames")

123

name = server.GetAlternativeServiceName(name)

124

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

125

self.remove()

126

self.add()

127

self.rename_count += 1

128

def remove(self):

129

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

130

if group is not None:

131

group.Reset()

132

def add(self):

133

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

134

global group

135

if group is None:

136

group = dbus.Interface\

137

(bus.get_object(avahi.DBUS_NAME,

138

server.EntryGroupNew()),

139

avahi.DBUS_INTERFACE_ENTRY_GROUP)

140

group.connect_to_signal('StateChanged',

141

entry_group_state_changed)

142

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

143

service.name, service.type)

144

group.AddService(

145

self.interface, # interface

146

avahi.PROTO_INET6, # protocol

147

dbus.UInt32(0), # flags

148

self.name, self.type,

149

self.domain, self.host,

150

dbus.UInt16(self.port),

151

avahi.string_array_to_txt_array(self.TXT))

152

group.Commit()

153

89

154

# 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

155

group = None # our entry group

99

156

# End of Avahi example code

100

157

101

158

107

164

uniquely identify the client

108

165

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

109

166

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

167

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

168

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

169

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

170

until this client is invalid

114

171

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

115

172

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

116

173

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

117

174

to see if the client lives.

118

Is None if no process is running.

175

'None' if no process is running.

119

176

checker_initiator_tag: a gobject event source tag, or None

120

177

stop_initiator_tag: - '' -

121

178

checker_callback_tag: - '' -

122

179

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

123

client lives. %()s expansions are done at

180

client lives. %() expansions are done at

124

181

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

125

182

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

126

183

Private attibutes:

127

184

_timeout: Real variable for 'timeout'

128

185

_interval: Real variable for 'interval'

129

_timeout_milliseconds: Used by gobject.timeout_add()

186

_timeout_milliseconds: Used when calling gobject.timeout_add()

130

187

_interval_milliseconds: - '' -

131

188

"""

132

189

def _set_timeout(self, timeout):

152

209

interval = property(lambda self: self._interval,

153

210

_set_interval)

154

211

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

158

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

159

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

212

def __init__(self, name = None, stop_hook=None, config={}):

213

"""Note: the 'checker' key in 'config' sets the

214

'checker_command' attribute and *not* the 'checker'

215

attribute."""

160

216

self.name = name

161

# Uppercase and remove spaces from fingerprint

162

# for later comparison purposes with return value of

163

# the fingerprint() function

164

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

165

if secret:

166

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

167

elif secfile:

168

sf = open(secfile)

217

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

218

# Uppercase and remove spaces from fingerprint for later

219

# comparison purposes with return value from the fingerprint()

220

# function

221

self.fingerprint = config["fingerprint"].upper()\

222

.replace(u" ", u"")

223

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

224

if "secret" in config:

225

self.secret = config["secret"].decode(u"base64")

226

elif "secfile" in config:

227

sf = open(config["secfile"])

169

228

self.secret = sf.read()

170

229

sf.close()

171

230

else:

172

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

173

% self.name)

174

self.fqdn = fqdn # string

231

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

232

% self.name)

233

self.fqdn = config.get("fqdn", "")

175

234

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)

235

self.last_checked_ok = None

236

self.timeout = string_to_delta(config["timeout"])

237

self.interval = string_to_delta(config["interval"])

185

238

self.stop_hook = stop_hook

186

239

self.checker = None

187

240

self.checker_initiator_tag = None

188

241

self.stop_initiator_tag = None

189

242

self.checker_callback_tag = None

190

self.check_command = checker

243

self.check_command = config["checker"]

191

244

def start(self):

192

245

"""Start this client's checker and timeout hooks"""

193

246

# Schedule a new checker to be started an 'interval' from now,

203

256

self.stop)

204

257

def stop(self):

205

258

"""Stop this client.

206

The possibility that this client might be restarted is left

207

open, but not currently used."""

259

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

260

but not currently used."""

208

261

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

209

262

if self.secret:

210

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

263

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

211

264

self.secret = None

212

265

else:

213

266

return False

214

if hasattr(self, "stop_initiator_tag") \

215

and self.stop_initiator_tag:

267

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

216

268

gobject.source_remove(self.stop_initiator_tag)

217

269

self.stop_initiator_tag = None

218

if hasattr(self, "checker_initiator_tag") \

219

and self.checker_initiator_tag:

270

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

220

271

gobject.source_remove(self.checker_initiator_tag)

221

272

self.checker_initiator_tag = None

222

273

self.stop_checker()

234

285

self.checker = None

235

286

if os.WIFEXITED(condition) \

236

287

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

237

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

238

vars(self))

239

self.last_seen = now

288

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

289

vars(self))

290

self.last_checked_ok = now

240

291

gobject.source_remove(self.stop_initiator_tag)

241

292

self.stop_initiator_tag = gobject.timeout_add\

242

293

(self._timeout_milliseconds,

245

296

logger.warning(u"Checker for %(name)s crashed?",

246

297

vars(self))

247

298

else:

248

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

249

vars(self))

299

logger.info(u"Checker for %(name)s failed",

300

vars(self))

250

301

def start_checker(self):

251

302

"""Start a new checker subprocess if one is not running.

252

303

If a checker already exists, leave it running and do

261

312

# is as it should be.

262

313

if self.checker is None:

263

314

try:

315

# In case check_command has exactly one % operator

264

316

command = self.check_command % self.fqdn

265

317

except TypeError:

318

# Escape attributes for the shell

266

319

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

267

320

for key, val in

268

321

vars(self).iteritems())

269

322

try:

270

323

command = self.check_command % escaped_attrs

271

324

except TypeError, error:

272

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

273

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

325

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

326

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

274

327

return True # Try again later

275

328

try:

276

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

277

command, self.name)

278

self.checker = subprocess.\

279

Popen(command,

280

close_fds=True, shell=True,

281

cwd="/")

329

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

330

command, self.name)

331

self.checker = subprocess.Popen(command,

332

close_fds=True,

333

shell=True, cwd="/")

282

334

self.checker_callback_tag = gobject.child_watch_add\

283

335

(self.checker.pid,

284

336

self.checker_callback)

292

344

if self.checker_callback_tag:

293

345

gobject.source_remove(self.checker_callback_tag)

294

346

self.checker_callback_tag = None

295

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

347

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

296

348

return

297

349

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

298

350

try:

301

353

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

302

354

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

303

355

except OSError, error:

304

if error.errno != errno.ESRCH:

356

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

305

357

raise

306

358

self.checker = None

307

def still_valid(self, now=None):

359

def still_valid(self):

308

360

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

361

now = datetime.datetime.now()

362

if self.last_checked_ok is None:

312

363

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

313

364

else:

314

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

365

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

315

366

316

367

317

368

def peer_certificate(session):

333

384

334

385

def fingerprint(openpgp):

335

386

"Convert an OpenPGP bytestring to a hexdigit fingerprint string"

336

# New empty GnuTLS certificate

337

crt = gnutls.library.types.gnutls_openpgp_crt_t()

338

gnutls.library.functions.gnutls_openpgp_crt_init\

339

(ctypes.byref(crt))

340

387

# New GnuTLS "datum" with the OpenPGP public key

341

388

datum = gnutls.library.types.gnutls_datum_t\

342

389

(ctypes.cast(ctypes.c_char_p(openpgp),

343

390

ctypes.POINTER(ctypes.c_ubyte)),

344

391

ctypes.c_uint(len(openpgp)))

392

# New empty GnuTLS certificate

393

crt = gnutls.library.types.gnutls_openpgp_crt_t()

394

gnutls.library.functions.gnutls_openpgp_crt_init\

395

(ctypes.byref(crt))

345

396

# Import the OpenPGP public key into the certificate

346

ret = gnutls.library.functions.gnutls_openpgp_crt_import\

347

(crt,

348

ctypes.byref(datum),

349

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

397

gnutls.library.functions.gnutls_openpgp_crt_import\

398

(crt, ctypes.byref(datum),

399

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

350

400

# New buffer for the fingerprint

351

401

buffer = ctypes.create_string_buffer(20)

352

402

buffer_length = ctypes.c_size_t()

368

418

Note: This will run in its own forked process."""

369

419

370

420

def handle(self):

371

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

421

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

372

422

unicode(self.client_address))

373

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

374

gnutls.connection.\

375

X509Credentials())

423

session = gnutls.connection.ClientSession\

424

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

425

426

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

427

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

428

try:

429

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

430

raise RuntimeError

431

except (ValueError, IndexError, RuntimeError), error:

432

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

433

return

434

435

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

436

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

437

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

438

# using OpenPGP certificates.

376

439

377

440

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

378

441

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

379

442

# "+DHE-DSS"))

380

priority = "SECURE256"

381

443

priority = "NORMAL" # Fallback default, since this

444

# MUST be set.

445

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

446

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

382

447

gnutls.library.functions.gnutls_priority_set_direct\

383

448

(session._c_object, priority, None);

384

449

385

450

try:

386

451

session.handshake()

387

452

except gnutls.errors.GNUTLSError, error:

388

logger.debug(u"Handshake failed: %s", error)

453

logger.warning(u"Handshake failed: %s", error)

389

454

# Do not run session.bye() here: the session is not

390

455

# established. Just abandon the request.

391

456

return

392

457

try:

393

458

fpr = fingerprint(peer_certificate(session))

394

459

except (TypeError, gnutls.errors.GNUTLSError), error:

395

logger.debug(u"Bad certificate: %s", error)

460

logger.warning(u"Bad certificate: %s", error)

396

461

session.bye()

397

462

return

398

463

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

401

466

if c.fingerprint == fpr:

402

467

client = c

403

468

break

469

if not client:

470

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

471

fpr)

472

session.bye()

473

return

404

474

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

405

475

# that the client timed out while establishing the GnuTLS

406

476

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

477

if not client.still_valid():

478

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

479

vars(client))

414

480

session.bye()

415

481

return

416

482

sent_size = 0

426

492

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

427

493

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

428

494

Attributes:

429

options: Command line options

495

settings: Server settings

430

496

clients: Set() of Client objects

431

497

"""

432

498

address_family = socket.AF_INET6

433

499

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

434

if "options" in kwargs:

435

self.options = kwargs["options"]

436

del kwargs["options"]

500

if "settings" in kwargs:

501

self.settings = kwargs["settings"]

502

del kwargs["settings"]

437

503

if "clients" in kwargs:

438

504

self.clients = kwargs["clients"]

439

505

del kwargs["clients"]

442

508

"""This overrides the normal server_bind() function

443

509

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

444

510

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

511

if self.settings["interface"]:

512

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

513

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

449

514

try:

450

515

self.socket.setsockopt(socket.SOL_SOCKET,

451

socket.SO_BINDTODEVICE,

452

self.options.interface)

516

SO_BINDTODEVICE,

517

self.settings["interface"])

453

518

except socket.error, error:

454

519

if error[0] == errno.EPERM:

455

logger.warning(u"No permission to"

456

u" bind to interface %s",

457

self.options.interface)

520

logger.error(u"No permission to"

521

u" bind to interface %s",

522

self.settings["interface"])

458

523

else:

459

524

raise error

460

525

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

503

568

return delta

504

569

505

570

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

571

def server_state_changed(state):

540

572

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

541

573

if state == avahi.SERVER_COLLISION:

542

logger.warning(u"Server name collision")

543

remove_service()

574

logger.error(u"Server name collision")

575

service.remove()

544

576

elif state == avahi.SERVER_RUNNING:

545

add_service()

577

service.add()

546

578

547

579

548

580

def entry_group_state_changed(state, error):

549

581

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

550

global serviceName, server, rename_count

551

552

582

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

553

583

554

584

if state == avahi.ENTRY_GROUP_ESTABLISHED:

555

585

logger.debug(u"Service established.")

556

586

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)

587

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

588

service.rename()

570

589

elif state == avahi.ENTRY_GROUP_FAILURE:

571

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

572

unicode(error))

573

killme(1)

574

590

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

591

unicode(error))

592

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

575

593

576

594

def if_nametoindex(interface):

577

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

595

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

596

global if_nametoindex

578

597

try:

579

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

580

return libc.if_nametoindex(interface)

598

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

599

import ctypes.util

600

if_nametoindex = ctypes.cdll.LoadLibrary\

601

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

581

602

except (OSError, AttributeError):

582

603

if "struct" not in sys.modules:

583

604

import struct

584

605

if "fcntl" not in sys.modules:

585

606

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

593

594

595

def daemon(nochdir, noclose):

607

def if_nametoindex(interface):

608

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

609

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

610

s = socket.socket()

611

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

612

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

613

s.close()

614

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

615

return interface_index

616

return if_nametoindex(interface)

617

618

619

def daemon(nochdir = False, noclose = False):

596

620

"""See daemon(3). Standard BSD Unix function.

597

621

This should really exist as os.daemon, but it doesn't (yet)."""

598

622

if os.fork():

600

624

os.setsid()

601

625

if not nochdir:

602

626

os.chdir("/")

627

if os.fork():

628

sys.exit()

603

629

if not noclose:

604

630

# Close all standard open file descriptors

605

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

631

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

606

632

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

607

633

raise OSError(errno.ENODEV,

608

634

"/dev/null not a character device")

613

639

os.close(null)

614

640

615

641

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

642

def main():

626

global exitstatus

627

exitstatus = 0

628

643

global main_loop_started

629

644

main_loop_started = False

630

645

631

646

parser = OptionParser()

632

647

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,

648

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

649

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

636

650

help="Address to listen for requests on")

637

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

651

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

638

652

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

653

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

646

654

help="Run self-test")

647

655

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

648

help="Debug mode")

656

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

657

" terminal")

658

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

659

" priority string (see GnuTLS documentation)")

660

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

661

help="Zeroconf service name")

662

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

663

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

664

help="Directory to search for configuration"

665

" files")

649

666

(options, args) = parser.parse_args()

650

667

651

668

if options.check:

653

670

doctest.testmod()

654

671

sys.exit()

655

672

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

673

# Default values for config file for server-global settings

674

server_defaults = { "interface": "",

675

"address": "",

676

"port": "",

677

"debug": "False",

678

"priority":

679

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

680

"servicename": "Mandos",

681

}

682

683

# Parse config file for server-global settings

684

server_config = ConfigParser.SafeConfigParser(server_defaults)

685

del server_defaults

686

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

687

server_section = "server"

688

# Convert the SafeConfigParser object to a dict

689

server_settings = dict(server_config.items(server_section))

690

# Use getboolean on the boolean config option

691

server_settings["debug"] = server_config.getboolean\

692

(server_section, "debug")

693

del server_config

694

695

# Override the settings from the config file with command line

696

# options, if set.

697

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

698

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

699

value = getattr(options, option)

700

if value is not None:

701

server_settings[option] = value

702

del options

703

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

704

705

# Parse config file with clients

706

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

707

"interval": "5m",

708

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

709

}

710

client_config = ConfigParser.SafeConfigParser(client_defaults)

711

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

712

"clients.conf"))

713

714

global service

715

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

716

type = "_mandos._tcp", );

717

if server_settings["interface"]:

718

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

671

719

672

720

global main_loop

673

721

global bus

681

729

avahi.DBUS_INTERFACE_SERVER )

682

730

# End of Avahi example code

683

731

684

debug = options.debug

732

debug = server_settings["debug"]

685

733

686

734

if debug:

687

735

console = logging.StreamHandler()

695

743

def remove_from_clients(client):

696

744

clients.remove(client)

697

745

if not clients:

698

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

699

killme()

746

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

747

sys.exit()

700

748

701

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

749

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

702

750

stop_hook = remove_from_clients,

703

**(dict(client_config\

704

.items(section))))

751

config

752

= dict(client_config.items(section)))

705

753

for section in client_config.sections()))

706

754

707

755

if not debug:

708

daemon(False, False)

756

daemon()

709

757

710

758

def cleanup():

711

759

"Cleanup function; run on exit"

725

773

726

774

if not debug:

727

775

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

776

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

777

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

730

778

731

779

for client in clients:

732

780

client.start()

733

781

734

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

782

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

783

server_settings["port"]),

735

784

tcp_handler,

736

options=options,

785

settings=server_settings,

737

786

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:

787

# Find out what port we got

788

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

789

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

790

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

791

792

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

793

794

try:

795

# From the Avahi example code

796

server.connect_to_signal("StateChanged", server_state_changed)

797

try:

798

server_state_changed(server.GetState())

799

except dbus.exceptions.DBusException, error:

800

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

801

sys.exit(1)

802

# End of Avahi example code

803

804

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

805

lambda *args, **kwargs:

806

tcp_server.handle_request\

807

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

808

761

809

logger.debug("Starting main loop")

762

810

main_loop_started = True

763

811

main_loop.run()

812

except AvahiError, error:

813

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

814

sys.exit(1)

764

815

except KeyboardInterrupt:

765

816

if debug:

766

817

print

767

768

sys.exit(exitstatus)

769

818

770

819

if __name__ == '__main__':

771

820

main()