To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to server.py
- browse files at revision 27
- compare with another revision
- download diff
- download tarball
- view history from revision 27
- Committer: Teddy Hogeborn
- Date: 2008-07-22 06:25:35 UTC
- mfrom: (24.1.2 mandos)
- Revision ID: teddy@fukt.bsnet.se-20080722062535-whz5do0b3dzw6m08
Merge.
- files added:
- plugbasedclient.c
- plugins.d
- files removed:
- client.cpp
- files modified:
- Makefile
added
removed
server.py
1
1
#!/usr/bin/python
2
# -*- mode: python; coding: utf-8 -*-
3
#
4
# Mandos server - give out binary blobs to connecting clients.
5
#
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".
12
#
13
# Everything else is Copyright © 2007-2008 Teddy Hogeborn and Björn
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
18
# the Free Software Foundation, either version 3 of the License, or
19
# (at your option) any later version.
20
#
21
# This program is distributed in the hope that it will be useful,
22
# but WITHOUT ANY WARRANTY; without even the implied warranty of
23
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24
# GNU General Public License for more details.
25
#
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/>.
31
#
2
32
3
33
from __future__ import division
4
34
21
51
import signal
22
52
from sets import Set
23
53
import subprocess
54
import atexit
55
import stat
56
import logging
57
import logging.handlers
24
58
25
59
import dbus
26
60
import gobject
28
62
from dbus.mainloop.glib import DBusGMainLoop
29
63
import ctypes
30
64
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
77
logger = logging.Logger('mandos')
78
syslogger = logging.handlers.SysLogHandler\
79
(facility = logging.handlers.SysLogHandler.LOG_DAEMON)
80
syslogger.setFormatter(logging.Formatter\
81
('%(levelname)s: %(message)s'))
82
logger.addHandler(syslogger)
83
del syslogger
84
31
85
# This variable is used to optionally bind to a specified interface.
32
86
# It is a global variable to fit in with the other variables from the
33
# Avahi server example code.
87
# Avahi example code.
34
88
serviceInterface = avahi.IF_UNSPEC
35
# From the Avahi server example code:
36
serviceName = "Mandos"
89
# From the Avahi example code:
90
serviceName = None
37
91
serviceType = "_mandos._tcp" # http://www.dns-sd.org/ServiceTypes.html
38
92
servicePort = None # Not known at startup
39
93
serviceTXT = [] # TXT record for the service
98
152
interval = property(lambda self: self._interval,
99
153
_set_interval)
100
154
del _set_interval
101
def __init__(self, name=None, options=None, stop_hook=None,
102
fingerprint=None, secret=None, secfile=None, fqdn=None,
103
timeout=None, interval=-1, checker=None):
155
def __init__(self, name=None, stop_hook=None, fingerprint=None,
156
secret=None, secfile=None, fqdn=None, timeout=None,
157
interval=-1, checker=None):
158
"""Note: the 'checker' argument sets the 'checker_command'
159
attribute and not the 'checker' attribute.."""
104
160
self.name = name
161
logger.debug(u"Creating client %r", self.name)
105
162
# Uppercase and remove spaces from fingerprint
106
163
# for later comparison purposes with return value of
107
164
# the fingerprint() function
108
165
self.fingerprint = fingerprint.upper().replace(u" ", u"")
166
logger.debug(u" Fingerprint: %s", self.fingerprint)
109
167
if secret:
110
168
self.secret = secret.decode(u"base64")
111
169
elif secfile:
118
176
self.fqdn = fqdn # string
119
177
self.created = datetime.datetime.now()
120
178
self.last_seen = None
121
if timeout is None:
122
timeout = options.timeout
123
self.timeout = timeout
124
if interval == -1:
125
interval = options.interval
126
else:
127
interval = string_to_delta(interval)
128
self.interval = interval
179
self.timeout = string_to_delta(timeout)
180
self.interval = string_to_delta(interval)
129
181
self.stop_hook = stop_hook
130
182
self.checker = None
131
183
self.checker_initiator_tag = None
133
185
self.checker_callback_tag = None
134
186
self.check_command = checker
135
187
def start(self):
136
"""Start this clients checker and timeout hooks"""
188
"""Start this client's checker and timeout hooks"""
137
189
# Schedule a new checker to be started an 'interval' from now,
138
190
# and every interval from then on.
139
191
self.checker_initiator_tag = gobject.timeout_add\
149
201
"""Stop this client.
150
202
The possibility that this client might be restarted is left
151
203
open, but not currently used."""
152
if debug:
153
sys.stderr.write(u"Stopping client %s\n" % self.name)
154
self.secret = None
155
if self.stop_initiator_tag:
204
# If this client doesn't have a secret, it is already stopped.
205
if self.secret:
206
logger.debug(u"Stopping client %s", self.name)
207
self.secret = None
208
else:
209
return False
210
if hasattr(self, "stop_initiator_tag") \
211
and self.stop_initiator_tag:
156
212
gobject.source_remove(self.stop_initiator_tag)
157
213
self.stop_initiator_tag = None
158
if self.checker_initiator_tag:
214
if hasattr(self, "checker_initiator_tag") \
215
and self.checker_initiator_tag:
159
216
gobject.source_remove(self.checker_initiator_tag)
160
217
self.checker_initiator_tag = None
161
218
self.stop_checker()
164
221
# Do not run this again if called by a gobject.timeout_add
165
222
return False
166
223
def __del__(self):
167
# Some code duplication here and in stop()
168
if hasattr(self, "stop_initiator_tag") \
169
and self.stop_initiator_tag:
170
gobject.source_remove(self.stop_initiator_tag)
171
self.stop_initiator_tag = None
172
if hasattr(self, "checker_initiator_tag") \
173
and self.checker_initiator_tag:
174
gobject.source_remove(self.checker_initiator_tag)
175
self.checker_initiator_tag = None
176
self.stop_checker()
224
self.stop_hook = None
225
self.stop()
177
226
def checker_callback(self, pid, condition):
178
227
"""The checker has completed, so take appropriate actions."""
179
228
now = datetime.datetime.now()
229
self.checker_callback_tag = None
230
self.checker = None
180
231
if os.WIFEXITED(condition) \
181
232
and (os.WEXITSTATUS(condition) == 0):
182
if debug:
183
sys.stderr.write(u"Checker for %(name)s succeeded\n"
184
% vars(self))
233
logger.debug(u"Checker for %(name)s succeeded",
234
vars(self))
185
235
self.last_seen = now
186
236
gobject.source_remove(self.stop_initiator_tag)
187
237
self.stop_initiator_tag = gobject.timeout_add\
188
238
(self._timeout_milliseconds,
189
239
self.stop)
190
elif debug:
191
if not os.WIFEXITED(condition):
192
sys.stderr.write(u"Checker for %(name)s crashed?\n"
193
% vars(self))
194
else:
195
sys.stderr.write(u"Checker for %(name)s failed\n"
196
% vars(self))
197
self.checker = None
198
self.checker_callback_tag = None
240
elif not os.WIFEXITED(condition):
241
logger.warning(u"Checker for %(name)s crashed?",
242
vars(self))
243
else:
244
logger.debug(u"Checker for %(name)s failed",
245
vars(self))
199
246
def start_checker(self):
200
247
"""Start a new checker subprocess if one is not running.
201
248
If a checker already exists, leave it running and do
202
249
nothing."""
250
# The reason for not killing a running checker is that if we
251
# did that, then if a checker (for some reason) started
252
# running slowly and taking more than 'interval' time, the
253
# client would inevitably timeout, since no checker would get
254
# a chance to run to completion. If we instead leave running
255
# checkers alone, the checker would have to take more time
256
# than 'timeout' for the client to be declared invalid, which
257
# is as it should be.
203
258
if self.checker is None:
204
if debug:
205
sys.stderr.write(u"Starting checker for %s\n"
206
% self.name)
207
259
try:
208
260
command = self.check_command % self.fqdn
209
261
except TypeError:
210
262
escaped_attrs = dict((key, re.escape(str(val)))
211
263
for key, val in
212
264
vars(self).iteritems())
213
command = self.check_command % escaped_attrs
265
try:
266
command = self.check_command % escaped_attrs
267
except TypeError, error:
268
logger.critical(u'Could not format string "%s":'
269
u' %s', self.check_command, error)
270
return True # Try again later
214
271
try:
272
logger.debug(u"Starting checker %r for %s",
273
command, self.name)
215
274
self.checker = subprocess.\
216
275
Popen(command,
217
stdout=subprocess.PIPE,
218
276
close_fds=True, shell=True,
219
277
cwd="/")
220
self.checker_callback_tag = gobject.\
221
child_watch_add(self.checker.pid,
222
self.\
223
checker_callback)
278
self.checker_callback_tag = gobject.child_watch_add\
279
(self.checker.pid,
280
self.checker_callback)
224
281
except subprocess.OSError, error:
225
sys.stderr.write(u"Failed to start subprocess: %s\n"
226
% error)
282
logger.error(u"Failed to start subprocess: %s",
283
error)
227
284
# Re-run this periodically if run by gobject.timeout_add
228
285
return True
229
286
def stop_checker(self):
230
287
"""Force the checker process, if any, to stop."""
288
if self.checker_callback_tag:
289
gobject.source_remove(self.checker_callback_tag)
290
self.checker_callback_tag = None
231
291
if not hasattr(self, "checker") or self.checker is None:
232
292
return
233
gobject.source_remove(self.checker_callback_tag)
234
self.checker_callback_tag = None
235
os.kill(self.checker.pid, signal.SIGTERM)
236
if self.checker.poll() is None:
237
os.kill(self.checker.pid, signal.SIGKILL)
293
logger.debug("Stopping checker for %(name)s", vars(self))
294
try:
295
os.kill(self.checker.pid, signal.SIGTERM)
296
#os.sleep(0.5)
297
#if self.checker.poll() is None:
298
# os.kill(self.checker.pid, signal.SIGKILL)
299
except OSError, error:
300
if error.errno != errno.ESRCH:
301
raise
238
302
self.checker = None
239
303
def still_valid(self, now=None):
240
304
"""Has the timeout not yet passed for this client?"""
247
311
248
312
249
313
def peer_certificate(session):
314
"Return the peer's OpenPGP certificate as a bytestring"
250
315
# If not an OpenPGP certificate...
251
316
if gnutls.library.functions.gnutls_certificate_type_get\
252
317
(session._c_object) \
263
328
264
329
265
330
def fingerprint(openpgp):
331
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
266
332
# New empty GnuTLS certificate
267
333
crt = gnutls.library.types.gnutls_openpgp_crt_t()
268
334
gnutls.library.functions.gnutls_openpgp_crt_init\
298
364
Note: This will run in its own forked process."""
299
365
300
366
def handle(self):
301
if debug:
302
sys.stderr.write(u"TCP request came\n")
303
sys.stderr.write(u"Request: %s\n" % self.request)
304
sys.stderr.write(u"Client Address: %s\n"
305
% unicode(self.client_address))
306
sys.stderr.write(u"Server: %s\n" % self.server)
367
logger.debug(u"TCP connection from: %s",
368
unicode(self.client_address))
307
369
session = gnutls.connection.ClientSession(self.request,
308
370
gnutls.connection.\
309
371
X509Credentials())
311
373
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
312
374
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
313
375
# "+DHE-DSS"))
314
priority = "SECURE256"
315
376
priority = "NORMAL"
377
if self.server.options.priority:
378
priority = self.server.options.priority
316
379
gnutls.library.functions.gnutls_priority_set_direct\
317
380
(session._c_object, priority, None);
318
381
319
382
try:
320
383
session.handshake()
321
384
except gnutls.errors.GNUTLSError, error:
322
if debug:
323
sys.stderr.write(u"Handshake failed: %s\n" % error)
385
logger.debug(u"Handshake failed: %s", error)
324
386
# Do not run session.bye() here: the session is not
325
387
# established. Just abandon the request.
326
388
return
327
389
try:
328
390
fpr = fingerprint(peer_certificate(session))
329
391
except (TypeError, gnutls.errors.GNUTLSError), error:
330
if debug:
331
sys.stderr.write(u"Bad certificate: %s\n" % error)
392
logger.debug(u"Bad certificate: %s", error)
332
393
session.bye()
333
394
return
334
if debug:
335
sys.stderr.write(u"Fingerprint: %s\n" % fpr)
395
logger.debug(u"Fingerprint: %s", fpr)
336
396
client = None
337
for c in clients:
397
for c in self.server.clients:
338
398
if c.fingerprint == fpr:
339
399
client = c
340
400
break
342
402
# that the client timed out while establishing the GnuTLS
343
403
# session.
344
404
if (not client) or (not client.still_valid()):
345
if debug:
346
if client:
347
sys.stderr.write(u"Client %(name)s is invalid\n"
348
% vars(client))
349
else:
350
sys.stderr.write(u"Client not found for "
351
u"fingerprint: %s\n" % fpr)
405
if client:
406
logger.debug(u"Client %(name)s is invalid",
407
vars(client))
408
else:
409
logger.debug(u"Client not found for fingerprint: %s",
410
fpr)
352
411
session.bye()
353
412
return
354
413
sent_size = 0
355
414
while sent_size < len(client.secret):
356
415
sent = session.send(client.secret[sent_size:])
357
if debug:
358
sys.stderr.write(u"Sent: %d, remaining: %d\n"
359
% (sent, len(client.secret)
360
- (sent_size + sent)))
416
logger.debug(u"Sent: %d, remaining: %d",
417
sent, len(client.secret)
418
- (sent_size + sent))
361
419
sent_size += sent
362
420
session.bye()
363
421
391
449
self.options.interface)
392
450
except socket.error, error:
393
451
if error[0] == errno.EPERM:
394
sys.stderr.write(u"Warning: No permission to" \
395
u" bind to interface %s\n"
396
% self.options.interface)
452
logger.warning(u"No permission to"
453
u" bind to interface %s",
454
self.options.interface)
397
455
else:
398
456
raise error
399
457
# Only bind(2) the socket if we really need to.
443
501
444
502
445
503
def add_service():
446
"""From the Avahi server example code"""
504
"""Derived from the Avahi example code"""
447
505
global group, serviceName, serviceType, servicePort, serviceTXT, \
448
506
domain, host
449
507
if group is None:
453
511
avahi.DBUS_INTERFACE_ENTRY_GROUP)
454
512
group.connect_to_signal('StateChanged',
455
513
entry_group_state_changed)
456
if debug:
457
sys.stderr.write(u"Adding service '%s' of type '%s' ...\n"
458
% (serviceName, serviceType))
514
logger.debug(u"Adding service '%s' of type '%s' ...",
515
serviceName, serviceType)
459
516
460
517
group.AddService(
461
518
serviceInterface, # interface
469
526
470
527
471
528
def remove_service():
472
"""From the Avahi server example code"""
529
"""From the Avahi example code"""
473
530
global group
474
531
475
532
if not group is None:
477
534
478
535
479
536
def server_state_changed(state):
480
"""From the Avahi server example code"""
537
"""Derived from the Avahi example code"""
481
538
if state == avahi.SERVER_COLLISION:
482
sys.stderr.write(u"WARNING: Server name collision\n")
539
logger.warning(u"Server name collision")
483
540
remove_service()
484
541
elif state == avahi.SERVER_RUNNING:
485
542
add_service()
486
543
487
544
488
545
def entry_group_state_changed(state, error):
489
"""From the Avahi server example code"""
546
"""Derived from the Avahi example code"""
490
547
global serviceName, server, rename_count
491
548
492
if debug:
493
sys.stderr.write(u"state change: %i\n" % state)
549
logger.debug(u"state change: %i", state)
494
550
495
551
if state == avahi.ENTRY_GROUP_ESTABLISHED:
496
if debug:
497
sys.stderr.write(u"Service established.\n")
552
logger.debug(u"Service established.")
498
553
elif state == avahi.ENTRY_GROUP_COLLISION:
499
554
500
555
rename_count = rename_count - 1
501
556
if rename_count > 0:
502
557
name = server.GetAlternativeServiceName(name)
503
sys.stderr.write(u"WARNING: Service name collision, "
504
u"changing name to '%s' ...\n" % name)
558
logger.warning(u"Service name collision, "
559
u"changing name to '%s' ...", name)
505
560
remove_service()
506
561
add_service()
507
562
508
563
else:
509
sys.stderr.write(u"ERROR: No suitable service name found "
510
u"after %i retries, exiting.\n"
511
% n_rename)
512
main_loop.quit()
564
logger.error(u"No suitable service name found after %i"
565
u" retries, exiting.", n_rename)
566
killme(1)
513
567
elif state == avahi.ENTRY_GROUP_FAILURE:
514
sys.stderr.write(u"Error in group state changed %s\n"
515
% unicode(error))
516
main_loop.quit()
517
return
568
logger.error(u"Error in group state changed %s",
569
unicode(error))
570
killme(1)
518
571
519
572
520
573
def if_nametoindex(interface):
536
589
return interface_index
537
590
538
591
539
if __name__ == '__main__':
592
def daemon(nochdir, noclose):
593
"""See daemon(3). Standard BSD Unix function.
594
This should really exist as os.daemon, but it doesn't (yet)."""
595
if os.fork():
596
sys.exit()
597
os.setsid()
598
if not nochdir:
599
os.chdir("/")
600
if not noclose:
601
# Close all standard open file descriptors
602
null = os.open("/dev/null", os.O_NOCTTY | os.O_RDWR)
603
if not stat.S_ISCHR(os.fstat(null).st_mode):
604
raise OSError(errno.ENODEV,
605
"/dev/null not a character device")
606
os.dup2(null, sys.stdin.fileno())
607
os.dup2(null, sys.stdout.fileno())
608
os.dup2(null, sys.stderr.fileno())
609
if null > 2:
610
os.close(null)
611
612
613
def killme(status = 0):
614
logger.debug("Stopping server with exit status %d", status)
615
exitstatus = status
616
if main_loop_started:
617
main_loop.quit()
618
else:
619
sys.exit(status)
620
621
622
def main():
623
global exitstatus
624
exitstatus = 0
625
global main_loop_started
626
main_loop_started = False
627
540
628
parser = OptionParser()
541
629
parser.add_option("-i", "--interface", type="string",
542
630
default=None, metavar="IF",
543
631
help="Bind to interface IF")
544
parser.add_option("--cert", type="string", default="cert.pem",
545
metavar="FILE",
546
help="Public key certificate PEM file to use")
547
parser.add_option("--key", type="string", default="key.pem",
548
metavar="FILE",
549
help="Private key PEM file to use")
550
parser.add_option("--ca", type="string", default="ca.pem",
551
metavar="FILE",
552
help="Certificate Authority certificate PEM file to use")
553
parser.add_option("--crl", type="string", default="crl.pem",
554
metavar="FILE",
555
help="Certificate Revokation List PEM file to use")
632
parser.add_option("-a", "--address", type="string", default=None,
633
help="Address to listen for requests on")
556
634
parser.add_option("-p", "--port", type="int", default=None,
557
635
help="Port number to receive requests on")
558
parser.add_option("--timeout", type="string", # Parsed later
559
default="1h",
560
help="Amount of downtime allowed for clients")
561
parser.add_option("--interval", type="string", # Parsed later
562
default="5m",
563
help="How often to check that a client is up")
564
636
parser.add_option("--check", action="store_true", default=False,
565
637
help="Run self-test")
566
638
parser.add_option("--debug", action="store_true", default=False,
567
639
help="Debug mode")
640
parser.add_option("--priority", type="string",
641
default="SECURE256",
642
help="GnuTLS priority string"
643
" (see GnuTLS documentation)")
644
parser.add_option("--servicename", type="string",
645
default="Mandos", help="Zeroconf service name")
568
646
(options, args) = parser.parse_args()
569
647
570
648
if options.check:
572
650
doctest.testmod()
573
651
sys.exit()
574
652
575
# Parse the time arguments
576
try:
577
options.timeout = string_to_delta(options.timeout)
578
except ValueError:
579
parser.error("option --timeout: Unparseable time")
580
try:
581
options.interval = string_to_delta(options.interval)
582
except ValueError:
583
parser.error("option --interval: Unparseable time")
584
585
653
# Parse config file
586
defaults = { "checker": "sleep 1; fping -q -- %%(fqdn)s" }
654
defaults = { "timeout": "1h",
655
"interval": "5m",
656
"checker": "fping -q -- %%(fqdn)s",
657
}
587
658
client_config = ConfigParser.SafeConfigParser(defaults)
588
#client_config.readfp(open("secrets.conf"), "secrets.conf")
659
#client_config.readfp(open("global.conf"), "global.conf")
589
660
client_config.read("mandos-clients.conf")
590
661
591
# From the Avahi server example code
662
global serviceName
663
serviceName = options.servicename;
664
665
global main_loop
666
global bus
667
global server
668
# From the Avahi example code
592
669
DBusGMainLoop(set_as_default=True )
593
670
main_loop = gobject.MainLoop()
594
671
bus = dbus.SystemBus()
599
676
600
677
debug = options.debug
601
678
679
if debug:
680
console = logging.StreamHandler()
681
# console.setLevel(logging.DEBUG)
682
console.setFormatter(logging.Formatter\
683
('%(levelname)s: %(message)s'))
684
logger.addHandler(console)
685
del console
686
602
687
clients = Set()
603
688
def remove_from_clients(client):
604
689
clients.remove(client)
605
690
if not clients:
606
if debug:
607
sys.stderr.write(u"No clients left, exiting\n")
608
main_loop.quit()
691
logger.debug(u"No clients left, exiting")
692
killme()
609
693
610
clients.update(Set(Client(name=section, options=options,
694
clients.update(Set(Client(name=section,
611
695
stop_hook = remove_from_clients,
612
696
**(dict(client_config\
613
697
.items(section))))
614
698
for section in client_config.sections()))
699
700
if not debug:
701
daemon(False, False)
702
703
def cleanup():
704
"Cleanup function; run on exit"
705
global group
706
# From the Avahi example code
707
if not group is None:
708
group.Free()
709
group = None
710
# End of Avahi example code
711
712
while clients:
713
client = clients.pop()
714
client.stop_hook = None
715
client.stop()
716
717
atexit.register(cleanup)
718
719
if not debug:
720
signal.signal(signal.SIGINT, signal.SIG_IGN)
721
signal.signal(signal.SIGHUP, lambda signum, frame: killme())
722
signal.signal(signal.SIGTERM, lambda signum, frame: killme())
723
615
724
for client in clients:
616
725
client.start()
617
726
618
tcp_server = IPv6_TCPServer((None, options.port),
727
tcp_server = IPv6_TCPServer((options.address, options.port),
619
728
tcp_handler,
620
729
options=options,
621
730
clients=clients)
622
731
# Find out what random port we got
732
global servicePort
623
733
servicePort = tcp_server.socket.getsockname()[1]
624
if debug:
625
sys.stderr.write(u"Now listening on port %d\n" % servicePort)
734
logger.debug(u"Now listening on port %d", servicePort)
626
735
627
736
if options.interface is not None:
737
global serviceInterface
628
738
serviceInterface = if_nametoindex(options.interface)
629
739
630
# From the Avahi server example code
740
# From the Avahi example code
631
741
server.connect_to_signal("StateChanged", server_state_changed)
632
server_state_changed(server.GetState())
742
try:
743
server_state_changed(server.GetState())
744
except dbus.exceptions.DBusException, error:
745
logger.critical(u"DBusException: %s", error)
746
killme(1)
633
747
# End of Avahi example code
634
748
635
749
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
637
751
tcp_server.handle_request(*args[2:],
638
752
**kwargs) or True)
639
753
try:
754
logger.debug("Starting main loop")
755
main_loop_started = True
640
756
main_loop.run()
641
757
except KeyboardInterrupt:
642
print
758
if debug:
759
print
643
760
644
# Cleanup here
761
sys.exit(exitstatus)
645
762
646
# From the Avahi server example code
647
if not group is None:
648
group.Free()
649
# End of Avahi example code
650
651
for client in clients:
652
client.stop_hook = None
653
client.stop()
763
if __name__ == '__main__':
764
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0