/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2010-09-12 03:00:40 UTC
  • Revision ID: teddy@fukt.bsnet.se-20100912030040-b0uopyennste9fdh
Documentation changes:

* DBUS-API: New file documenting the server D-Bus interface.

* clients.conf: Add examples of new approval settings.

* debian/mandos.docs: Added "DBUS-API".

* mandos-clients.conf.xml (OPTIONS): Added "approved_by_default",
                                     "approval_delay", and
                                     "approval_duration".
* mandos.xml (D-BUS INTERFACE): Refer to the "DBUS-API" file.
  (BUGS): Remove mention of lack of a remote query interface.

Show diffs side-by-side

added added

removed removed

Lines of Context:
11
11
# "AvahiService" class, and some lines in "main".
12
12
13
13
# Everything else is
14
 
# Copyright © 2008-2011 Teddy Hogeborn
15
 
# Copyright © 2008-2011 Björn Påhlsson
 
14
# Copyright © 2008,2009 Teddy Hogeborn
 
15
# Copyright © 2008,2009 Björn Påhlsson
16
16
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
31
31
# Contact the authors at <mandos@fukt.bsnet.se>.
32
32
33
33
 
34
 
from __future__ import (division, absolute_import, print_function,
35
 
                        unicode_literals)
 
34
from __future__ import division, with_statement, absolute_import
36
35
 
37
36
import SocketServer as socketserver
38
37
import socket
39
 
import argparse
 
38
import optparse
40
39
import datetime
41
40
import errno
42
41
import gnutls.crypto
82
81
        SO_BINDTODEVICE = None
83
82
 
84
83
 
85
 
version = "1.3.0"
 
84
version = "1.0.14"
86
85
 
87
 
#logger = logging.getLogger('mandos')
88
 
logger = logging.Logger('mandos')
 
86
#logger = logging.getLogger(u'mandos')
 
87
logger = logging.Logger(u'mandos')
89
88
syslogger = (logging.handlers.SysLogHandler
90
89
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
91
 
              address = str("/dev/log")))
 
90
              address = "/dev/log"))
92
91
syslogger.setFormatter(logging.Formatter
93
 
                       ('Mandos [%(process)d]: %(levelname)s:'
94
 
                        ' %(message)s'))
 
92
                       (u'Mandos [%(process)d]: %(levelname)s:'
 
93
                        u' %(message)s'))
95
94
logger.addHandler(syslogger)
96
95
 
97
96
console = logging.StreamHandler()
98
 
console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'
99
 
                                       ' %(levelname)s:'
100
 
                                       ' %(message)s'))
 
97
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
 
98
                                       u' %(levelname)s:'
 
99
                                       u' %(message)s'))
101
100
logger.addHandler(console)
102
101
 
103
102
class AvahiError(Exception):
120
119
    Attributes:
121
120
    interface: integer; avahi.IF_UNSPEC or an interface index.
122
121
               Used to optionally bind to the specified interface.
123
 
    name: string; Example: 'Mandos'
124
 
    type: string; Example: '_mandos._tcp'.
 
122
    name: string; Example: u'Mandos'
 
123
    type: string; Example: u'_mandos._tcp'.
125
124
                  See <http://www.dns-sd.org/ServiceTypes.html>
126
125
    port: integer; what port to announce
127
126
    TXT: list of strings; TXT record for the service
136
135
    """
137
136
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
138
137
                 servicetype = None, port = None, TXT = None,
139
 
                 domain = "", host = "", max_renames = 32768,
 
138
                 domain = u"", host = u"", max_renames = 32768,
140
139
                 protocol = avahi.PROTO_UNSPEC, bus = None):
141
140
        self.interface = interface
142
141
        self.name = name
151
150
        self.group = None       # our entry group
152
151
        self.server = None
153
152
        self.bus = bus
154
 
        self.entry_group_state_changed_match = None
155
153
    def rename(self):
156
154
        """Derived from the Avahi example code"""
157
155
        if self.rename_count >= self.max_renames:
158
 
            logger.critical("No suitable Zeroconf service name found"
159
 
                            " after %i retries, exiting.",
 
156
            logger.critical(u"No suitable Zeroconf service name found"
 
157
                            u" after %i retries, exiting.",
160
158
                            self.rename_count)
161
 
            raise AvahiServiceError("Too many renames")
 
159
            raise AvahiServiceError(u"Too many renames")
162
160
        self.name = unicode(self.server.GetAlternativeServiceName(self.name))
163
 
        logger.info("Changing Zeroconf service name to %r ...",
 
161
        logger.info(u"Changing Zeroconf service name to %r ...",
164
162
                    self.name)
165
163
        syslogger.setFormatter(logging.Formatter
166
 
                               ('Mandos (%s) [%%(process)d]:'
167
 
                                ' %%(levelname)s: %%(message)s'
 
164
                               (u'Mandos (%s) [%%(process)d]:'
 
165
                                u' %%(levelname)s: %%(message)s'
168
166
                                % self.name))
169
167
        self.remove()
170
168
        try:
171
169
            self.add()
172
 
        except dbus.exceptions.DBusException as error:
173
 
            logger.critical("DBusException: %s", error)
 
170
        except dbus.exceptions.DBusException, error:
 
171
            logger.critical(u"DBusException: %s", error)
174
172
            self.cleanup()
175
173
            os._exit(1)
176
174
        self.rename_count += 1
177
175
    def remove(self):
178
176
        """Derived from the Avahi example code"""
179
 
        if self.entry_group_state_changed_match is not None:
180
 
            self.entry_group_state_changed_match.remove()
181
 
            self.entry_group_state_changed_match = None
182
177
        if self.group is not None:
183
178
            self.group.Reset()
184
179
    def add(self):
185
180
        """Derived from the Avahi example code"""
186
 
        self.remove()
187
181
        if self.group is None:
188
182
            self.group = dbus.Interface(
189
183
                self.bus.get_object(avahi.DBUS_NAME,
190
184
                                    self.server.EntryGroupNew()),
191
185
                avahi.DBUS_INTERFACE_ENTRY_GROUP)
192
 
        self.entry_group_state_changed_match = (
193
 
            self.group.connect_to_signal(
194
 
                'StateChanged', self .entry_group_state_changed))
195
 
        logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
 
186
            self.group.connect_to_signal('StateChanged',
 
187
                                         self
 
188
                                         .entry_group_state_changed)
 
189
        logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
196
190
                     self.name, self.type)
197
191
        self.group.AddService(
198
192
            self.interface,
205
199
        self.group.Commit()
206
200
    def entry_group_state_changed(self, state, error):
207
201
        """Derived from the Avahi example code"""
208
 
        logger.debug("Avahi entry group state change: %i", state)
 
202
        logger.debug(u"Avahi entry group state change: %i", state)
209
203
        
210
204
        if state == avahi.ENTRY_GROUP_ESTABLISHED:
211
 
            logger.debug("Zeroconf service established.")
 
205
            logger.debug(u"Zeroconf service established.")
212
206
        elif state == avahi.ENTRY_GROUP_COLLISION:
213
 
            logger.info("Zeroconf service name collision.")
 
207
            logger.warning(u"Zeroconf service name collision.")
214
208
            self.rename()
215
209
        elif state == avahi.ENTRY_GROUP_FAILURE:
216
 
            logger.critical("Avahi: Error in group state changed %s",
 
210
            logger.critical(u"Avahi: Error in group state changed %s",
217
211
                            unicode(error))
218
 
            raise AvahiGroupError("State changed: %s"
 
212
            raise AvahiGroupError(u"State changed: %s"
219
213
                                  % unicode(error))
220
214
    def cleanup(self):
221
215
        """Derived from the Avahi example code"""
222
216
        if self.group is not None:
223
 
            try:
224
 
                self.group.Free()
225
 
            except (dbus.exceptions.UnknownMethodException,
226
 
                    dbus.exceptions.DBusException) as e:
227
 
                pass
 
217
            self.group.Free()
228
218
            self.group = None
229
 
        self.remove()
230
 
    def server_state_changed(self, state, error=None):
 
219
    def server_state_changed(self, state):
231
220
        """Derived from the Avahi example code"""
232
 
        logger.debug("Avahi server state change: %i", state)
233
 
        bad_states = { avahi.SERVER_INVALID:
234
 
                           "Zeroconf server invalid",
235
 
                       avahi.SERVER_REGISTERING: None,
236
 
                       avahi.SERVER_COLLISION:
237
 
                           "Zeroconf server name collision",
238
 
                       avahi.SERVER_FAILURE:
239
 
                           "Zeroconf server failure" }
240
 
        if state in bad_states:
241
 
            if bad_states[state] is not None:
242
 
                if error is None:
243
 
                    logger.error(bad_states[state])
244
 
                else:
245
 
                    logger.error(bad_states[state] + ": %r", error)
246
 
            self.cleanup()
 
221
        logger.debug(u"Avahi server state change: %i", state)
 
222
        if state == avahi.SERVER_COLLISION:
 
223
            logger.error(u"Zeroconf server name collision")
 
224
            self.remove()
247
225
        elif state == avahi.SERVER_RUNNING:
248
226
            self.add()
249
 
        else:
250
 
            if error is None:
251
 
                logger.debug("Unknown state: %r", state)
252
 
            else:
253
 
                logger.debug("Unknown state: %r: %r", state, error)
254
227
    def activate(self):
255
228
        """Derived from the Avahi example code"""
256
229
        if self.server is None:
257
230
            self.server = dbus.Interface(
258
231
                self.bus.get_object(avahi.DBUS_NAME,
259
 
                                    avahi.DBUS_PATH_SERVER,
260
 
                                    follow_name_owner_changes=True),
 
232
                                    avahi.DBUS_PATH_SERVER),
261
233
                avahi.DBUS_INTERFACE_SERVER)
262
 
        self.server.connect_to_signal("StateChanged",
 
234
        self.server.connect_to_signal(u"StateChanged",
263
235
                                 self.server_state_changed)
264
236
        self.server_state_changed(self.server.GetState())
265
237
 
268
240
    """A representation of a client host served by this server.
269
241
    
270
242
    Attributes:
271
 
    _approved:   bool(); 'None' if not yet approved/disapproved
272
 
    approval_delay: datetime.timedelta(); Time to wait for approval
273
 
    approval_duration: datetime.timedelta(); Duration of one approval
 
243
    name:       string; from the config file, used in log messages and
 
244
                        D-Bus identifiers
 
245
    fingerprint: string (40 or 32 hexadecimal digits); used to
 
246
                 uniquely identify the client
 
247
    secret:     bytestring; sent verbatim (over TLS) to client
 
248
    host:       string; available for use by the checker command
 
249
    created:    datetime.datetime(); (UTC) object creation
 
250
    last_enabled: datetime.datetime(); (UTC)
 
251
    enabled:    bool()
 
252
    last_checked_ok: datetime.datetime(); (UTC) or None
 
253
    timeout:    datetime.timedelta(); How long from last_checked_ok
 
254
                                      until this client is disabled
 
255
    interval:   datetime.timedelta(); How often to start a new checker
 
256
    disable_hook:  If set, called by disable() as disable_hook(self)
274
257
    checker:    subprocess.Popen(); a running checker process used
275
258
                                    to see if the client lives.
276
259
                                    'None' if no process is running.
277
 
    checker_callback_tag: a gobject event source tag, or None
278
 
    checker_command: string; External command which is run to check
279
 
                     if client lives.  %() expansions are done at
 
260
    checker_initiator_tag: a gobject event source tag, or None
 
261
    disable_initiator_tag: - '' -
 
262
    checker_callback_tag:  - '' -
 
263
    checker_command: string; External command which is run to check if
 
264
                     client lives.  %() expansions are done at
280
265
                     runtime with vars(self) as dict, so that for
281
266
                     instance %(name)s can be used in the command.
282
 
    checker_initiator_tag: a gobject event source tag, or None
283
 
    created:    datetime.datetime(); (UTC) object creation
284
267
    current_checker_command: string; current running checker_command
285
 
    disable_hook:  If set, called by disable() as disable_hook(self)
286
 
    disable_initiator_tag: a gobject event source tag, or None
287
 
    enabled:    bool()
288
 
    fingerprint: string (40 or 32 hexadecimal digits); used to
289
 
                 uniquely identify the client
290
 
    host:       string; available for use by the checker command
291
 
    interval:   datetime.timedelta(); How often to start a new checker
292
 
    last_approval_request: datetime.datetime(); (UTC) or None
293
 
    last_checked_ok: datetime.datetime(); (UTC) or None
294
 
    last_enabled: datetime.datetime(); (UTC)
295
 
    name:       string; from the config file, used in log messages and
296
 
                        D-Bus identifiers
297
 
    secret:     bytestring; sent verbatim (over TLS) to client
298
 
    timeout:    datetime.timedelta(); How long from last_checked_ok
299
 
                                      until this client is disabled
300
 
    runtime_expansions: Allowed attributes for runtime expansion.
 
268
    approval_delay: datetime.timedelta(); Time to wait for approval
 
269
    _approved:   bool(); 'None' if not yet approved/disapproved
 
270
    approval_duration: datetime.timedelta(); Duration of one approval
301
271
    """
302
272
    
303
 
    runtime_expansions = ("approval_delay", "approval_duration",
304
 
                          "created", "enabled", "fingerprint",
305
 
                          "host", "interval", "last_checked_ok",
306
 
                          "last_enabled", "name", "timeout")
307
 
    
308
273
    @staticmethod
309
274
    def _timedelta_to_milliseconds(td):
310
275
        "Convert a datetime.timedelta() to milliseconds"
330
295
        self.name = name
331
296
        if config is None:
332
297
            config = {}
333
 
        logger.debug("Creating client %r", self.name)
 
298
        logger.debug(u"Creating client %r", self.name)
334
299
        # Uppercase and remove spaces from fingerprint for later
335
300
        # comparison purposes with return value from the fingerprint()
336
301
        # function
337
 
        self.fingerprint = (config["fingerprint"].upper()
338
 
                            .replace(" ", ""))
339
 
        logger.debug("  Fingerprint: %s", self.fingerprint)
340
 
        if "secret" in config:
341
 
            self.secret = config["secret"].decode("base64")
342
 
        elif "secfile" in config:
 
302
        self.fingerprint = (config[u"fingerprint"].upper()
 
303
                            .replace(u" ", u""))
 
304
        logger.debug(u"  Fingerprint: %s", self.fingerprint)
 
305
        if u"secret" in config:
 
306
            self.secret = config[u"secret"].decode(u"base64")
 
307
        elif u"secfile" in config:
343
308
            with open(os.path.expanduser(os.path.expandvars
344
 
                                         (config["secfile"])),
 
309
                                         (config[u"secfile"])),
345
310
                      "rb") as secfile:
346
311
                self.secret = secfile.read()
347
312
        else:
348
 
            raise TypeError("No secret or secfile for client %s"
 
313
            raise TypeError(u"No secret or secfile for client %s"
349
314
                            % self.name)
350
 
        self.host = config.get("host", "")
 
315
        self.host = config.get(u"host", u"")
351
316
        self.created = datetime.datetime.utcnow()
352
317
        self.enabled = False
353
 
        self.last_approval_request = None
354
318
        self.last_enabled = None
355
319
        self.last_checked_ok = None
356
 
        self.timeout = string_to_delta(config["timeout"])
357
 
        self.interval = string_to_delta(config["interval"])
 
320
        self.timeout = string_to_delta(config[u"timeout"])
 
321
        self.interval = string_to_delta(config[u"interval"])
358
322
        self.disable_hook = disable_hook
359
323
        self.checker = None
360
324
        self.checker_initiator_tag = None
361
325
        self.disable_initiator_tag = None
362
326
        self.checker_callback_tag = None
363
 
        self.checker_command = config["checker"]
 
327
        self.checker_command = config[u"checker"]
364
328
        self.current_checker_command = None
365
329
        self.last_connect = None
366
330
        self._approved = None
367
 
        self.approved_by_default = config.get("approved_by_default",
 
331
        self.approved_by_default = config.get(u"approved_by_default",
368
332
                                              True)
369
333
        self.approvals_pending = 0
370
334
        self.approval_delay = string_to_delta(
371
 
            config["approval_delay"])
 
335
            config[u"approval_delay"])
372
336
        self.approval_duration = string_to_delta(
373
 
            config["approval_duration"])
 
337
            config[u"approval_duration"])
374
338
        self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
375
339
    
376
340
    def send_changedstate(self):
380
344
        
381
345
    def enable(self):
382
346
        """Start this client's checker and timeout hooks"""
383
 
        if getattr(self, "enabled", False):
 
347
        if getattr(self, u"enabled", False):
384
348
            # Already enabled
385
349
            return
386
350
        self.send_changedstate()
405
369
        if not quiet:
406
370
            self.send_changedstate()
407
371
        if not quiet:
408
 
            logger.info("Disabling client %s", self.name)
409
 
        if getattr(self, "disable_initiator_tag", False):
 
372
            logger.info(u"Disabling client %s", self.name)
 
373
        if getattr(self, u"disable_initiator_tag", False):
410
374
            gobject.source_remove(self.disable_initiator_tag)
411
375
            self.disable_initiator_tag = None
412
 
        if getattr(self, "checker_initiator_tag", False):
 
376
        if getattr(self, u"checker_initiator_tag", False):
413
377
            gobject.source_remove(self.checker_initiator_tag)
414
378
            self.checker_initiator_tag = None
415
379
        self.stop_checker()
430
394
        if os.WIFEXITED(condition):
431
395
            exitstatus = os.WEXITSTATUS(condition)
432
396
            if exitstatus == 0:
433
 
                logger.info("Checker for %(name)s succeeded",
 
397
                logger.info(u"Checker for %(name)s succeeded",
434
398
                            vars(self))
435
399
                self.checked_ok()
436
400
            else:
437
 
                logger.info("Checker for %(name)s failed",
 
401
                logger.info(u"Checker for %(name)s failed",
438
402
                            vars(self))
439
403
        else:
440
 
            logger.warning("Checker for %(name)s crashed?",
 
404
            logger.warning(u"Checker for %(name)s crashed?",
441
405
                           vars(self))
442
406
    
443
407
    def checked_ok(self):
452
416
                                      (self.timeout_milliseconds(),
453
417
                                       self.disable))
454
418
    
455
 
    def need_approval(self):
456
 
        self.last_approval_request = datetime.datetime.utcnow()
457
 
    
458
419
    def start_checker(self):
459
420
        """Start a new checker subprocess if one is not running.
460
421
        
472
433
        # If a checker exists, make sure it is not a zombie
473
434
        try:
474
435
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
475
 
        except (AttributeError, OSError) as error:
 
436
        except (AttributeError, OSError), error:
476
437
            if (isinstance(error, OSError)
477
438
                and error.errno != errno.ECHILD):
478
439
                raise error
479
440
        else:
480
441
            if pid:
481
 
                logger.warning("Checker was a zombie")
 
442
                logger.warning(u"Checker was a zombie")
482
443
                gobject.source_remove(self.checker_callback_tag)
483
444
                self.checker_callback(pid, status,
484
445
                                      self.current_checker_command)
489
450
                command = self.checker_command % self.host
490
451
            except TypeError:
491
452
                # Escape attributes for the shell
492
 
                escaped_attrs = dict(
493
 
                    (attr,
494
 
                     re.escape(unicode(str(getattr(self, attr, "")),
495
 
                                       errors=
496
 
                                       'replace')))
497
 
                    for attr in
498
 
                    self.runtime_expansions)
499
 
 
 
453
                escaped_attrs = dict((key,
 
454
                                      re.escape(unicode(str(val),
 
455
                                                        errors=
 
456
                                                        u'replace')))
 
457
                                     for key, val in
 
458
                                     vars(self).iteritems())
500
459
                try:
501
460
                    command = self.checker_command % escaped_attrs
502
 
                except TypeError as error:
503
 
                    logger.error('Could not format string "%s":'
504
 
                                 ' %s', self.checker_command, error)
 
461
                except TypeError, error:
 
462
                    logger.error(u'Could not format string "%s":'
 
463
                                 u' %s', self.checker_command, error)
505
464
                    return True # Try again later
506
465
            self.current_checker_command = command
507
466
            try:
508
 
                logger.info("Starting checker %r for %s",
 
467
                logger.info(u"Starting checker %r for %s",
509
468
                            command, self.name)
510
469
                # We don't need to redirect stdout and stderr, since
511
470
                # in normal mode, that is already done by daemon(),
513
472
                # always replaced by /dev/null.)
514
473
                self.checker = subprocess.Popen(command,
515
474
                                                close_fds=True,
516
 
                                                shell=True, cwd="/")
 
475
                                                shell=True, cwd=u"/")
517
476
                self.checker_callback_tag = (gobject.child_watch_add
518
477
                                             (self.checker.pid,
519
478
                                              self.checker_callback,
524
483
                if pid:
525
484
                    gobject.source_remove(self.checker_callback_tag)
526
485
                    self.checker_callback(pid, status, command)
527
 
            except OSError as error:
528
 
                logger.error("Failed to start subprocess: %s",
 
486
            except OSError, error:
 
487
                logger.error(u"Failed to start subprocess: %s",
529
488
                             error)
530
489
        # Re-run this periodically if run by gobject.timeout_add
531
490
        return True
535
494
        if self.checker_callback_tag:
536
495
            gobject.source_remove(self.checker_callback_tag)
537
496
            self.checker_callback_tag = None
538
 
        if getattr(self, "checker", None) is None:
 
497
        if getattr(self, u"checker", None) is None:
539
498
            return
540
 
        logger.debug("Stopping checker for %(name)s", vars(self))
 
499
        logger.debug(u"Stopping checker for %(name)s", vars(self))
541
500
        try:
542
501
            os.kill(self.checker.pid, signal.SIGTERM)
543
502
            #time.sleep(0.5)
544
503
            #if self.checker.poll() is None:
545
504
            #    os.kill(self.checker.pid, signal.SIGKILL)
546
 
        except OSError as error:
 
505
        except OSError, error:
547
506
            if error.errno != errno.ESRCH: # No such process
548
507
                raise
549
508
        self.checker = None
550
509
 
551
 
def dbus_service_property(dbus_interface, signature="v",
552
 
                          access="readwrite", byte_arrays=False):
 
510
def dbus_service_property(dbus_interface, signature=u"v",
 
511
                          access=u"readwrite", byte_arrays=False):
553
512
    """Decorators for marking methods of a DBusObjectWithProperties to
554
513
    become properties on the D-Bus.
555
514
    
562
521
    """
563
522
    # Encoding deeply encoded byte arrays is not supported yet by the
564
523
    # "Set" method, so we fail early here:
565
 
    if byte_arrays and signature != "ay":
566
 
        raise ValueError("Byte arrays not supported for non-'ay'"
567
 
                         " signature %r" % signature)
 
524
    if byte_arrays and signature != u"ay":
 
525
        raise ValueError(u"Byte arrays not supported for non-'ay'"
 
526
                         u" signature %r" % signature)
568
527
    def decorator(func):
569
528
        func._dbus_is_property = True
570
529
        func._dbus_interface = dbus_interface
571
530
        func._dbus_signature = signature
572
531
        func._dbus_access = access
573
532
        func._dbus_name = func.__name__
574
 
        if func._dbus_name.endswith("_dbus_property"):
 
533
        if func._dbus_name.endswith(u"_dbus_property"):
575
534
            func._dbus_name = func._dbus_name[:-14]
576
 
        func._dbus_get_args_options = {'byte_arrays': byte_arrays }
 
535
        func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
577
536
        return func
578
537
    return decorator
579
538
 
607
566
    
608
567
    @staticmethod
609
568
    def _is_dbus_property(obj):
610
 
        return getattr(obj, "_dbus_is_property", False)
 
569
        return getattr(obj, u"_dbus_is_property", False)
611
570
    
612
571
    def _get_all_dbus_properties(self):
613
572
        """Returns a generator of (name, attribute) pairs
621
580
        property with the specified name and interface.
622
581
        """
623
582
        for name in (property_name,
624
 
                     property_name + "_dbus_property"):
 
583
                     property_name + u"_dbus_property"):
625
584
            prop = getattr(self, name, None)
626
585
            if (prop is None
627
586
                or not self._is_dbus_property(prop)
631
590
                continue
632
591
            return prop
633
592
        # No such property
634
 
        raise DBusPropertyNotFound(self.dbus_object_path + ":"
635
 
                                   + interface_name + "."
 
593
        raise DBusPropertyNotFound(self.dbus_object_path + u":"
 
594
                                   + interface_name + u"."
636
595
                                   + property_name)
637
596
    
638
 
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
639
 
                         out_signature="v")
 
597
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
 
598
                         out_signature=u"v")
640
599
    def Get(self, interface_name, property_name):
641
600
        """Standard D-Bus property Get() method, see D-Bus standard.
642
601
        """
643
602
        prop = self._get_dbus_property(interface_name, property_name)
644
 
        if prop._dbus_access == "write":
 
603
        if prop._dbus_access == u"write":
645
604
            raise DBusPropertyAccessException(property_name)
646
605
        value = prop()
647
 
        if not hasattr(value, "variant_level"):
 
606
        if not hasattr(value, u"variant_level"):
648
607
            return value
649
608
        return type(value)(value, variant_level=value.variant_level+1)
650
609
    
651
 
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
 
610
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
652
611
    def Set(self, interface_name, property_name, value):
653
612
        """Standard D-Bus property Set() method, see D-Bus standard.
654
613
        """
655
614
        prop = self._get_dbus_property(interface_name, property_name)
656
 
        if prop._dbus_access == "read":
 
615
        if prop._dbus_access == u"read":
657
616
            raise DBusPropertyAccessException(property_name)
658
 
        if prop._dbus_get_args_options["byte_arrays"]:
 
617
        if prop._dbus_get_args_options[u"byte_arrays"]:
659
618
            # The byte_arrays option is not supported yet on
660
619
            # signatures other than "ay".
661
 
            if prop._dbus_signature != "ay":
 
620
            if prop._dbus_signature != u"ay":
662
621
                raise ValueError
663
622
            value = dbus.ByteArray(''.join(unichr(byte)
664
623
                                           for byte in value))
665
624
        prop(value)
666
625
    
667
 
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
668
 
                         out_signature="a{sv}")
 
626
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
 
627
                         out_signature=u"a{sv}")
669
628
    def GetAll(self, interface_name):
670
629
        """Standard D-Bus property GetAll() method, see D-Bus
671
630
        standard.
679
638
                # Interface non-empty but did not match
680
639
                continue
681
640
            # Ignore write-only properties
682
 
            if prop._dbus_access == "write":
 
641
            if prop._dbus_access == u"write":
683
642
                continue
684
643
            value = prop()
685
 
            if not hasattr(value, "variant_level"):
 
644
            if not hasattr(value, u"variant_level"):
686
645
                all[name] = value
687
646
                continue
688
647
            all[name] = type(value)(value, variant_level=
689
648
                                    value.variant_level+1)
690
 
        return dbus.Dictionary(all, signature="sv")
 
649
        return dbus.Dictionary(all, signature=u"sv")
691
650
    
692
651
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
693
 
                         out_signature="s",
 
652
                         out_signature=u"s",
694
653
                         path_keyword='object_path',
695
654
                         connection_keyword='connection')
696
655
    def Introspect(self, object_path, connection):
701
660
        try:
702
661
            document = xml.dom.minidom.parseString(xmlstring)
703
662
            def make_tag(document, name, prop):
704
 
                e = document.createElement("property")
705
 
                e.setAttribute("name", name)
706
 
                e.setAttribute("type", prop._dbus_signature)
707
 
                e.setAttribute("access", prop._dbus_access)
 
663
                e = document.createElement(u"property")
 
664
                e.setAttribute(u"name", name)
 
665
                e.setAttribute(u"type", prop._dbus_signature)
 
666
                e.setAttribute(u"access", prop._dbus_access)
708
667
                return e
709
 
            for if_tag in document.getElementsByTagName("interface"):
 
668
            for if_tag in document.getElementsByTagName(u"interface"):
710
669
                for tag in (make_tag(document, name, prop)
711
670
                            for name, prop
712
671
                            in self._get_all_dbus_properties()
713
672
                            if prop._dbus_interface
714
 
                            == if_tag.getAttribute("name")):
 
673
                            == if_tag.getAttribute(u"name")):
715
674
                    if_tag.appendChild(tag)
716
675
                # Add the names to the return values for the
717
676
                # "org.freedesktop.DBus.Properties" methods
718
 
                if (if_tag.getAttribute("name")
719
 
                    == "org.freedesktop.DBus.Properties"):
720
 
                    for cn in if_tag.getElementsByTagName("method"):
721
 
                        if cn.getAttribute("name") == "Get":
722
 
                            for arg in cn.getElementsByTagName("arg"):
723
 
                                if (arg.getAttribute("direction")
724
 
                                    == "out"):
725
 
                                    arg.setAttribute("name", "value")
726
 
                        elif cn.getAttribute("name") == "GetAll":
727
 
                            for arg in cn.getElementsByTagName("arg"):
728
 
                                if (arg.getAttribute("direction")
729
 
                                    == "out"):
730
 
                                    arg.setAttribute("name", "props")
731
 
            xmlstring = document.toxml("utf-8")
 
677
                if (if_tag.getAttribute(u"name")
 
678
                    == u"org.freedesktop.DBus.Properties"):
 
679
                    for cn in if_tag.getElementsByTagName(u"method"):
 
680
                        if cn.getAttribute(u"name") == u"Get":
 
681
                            for arg in cn.getElementsByTagName(u"arg"):
 
682
                                if (arg.getAttribute(u"direction")
 
683
                                    == u"out"):
 
684
                                    arg.setAttribute(u"name", u"value")
 
685
                        elif cn.getAttribute(u"name") == u"GetAll":
 
686
                            for arg in cn.getElementsByTagName(u"arg"):
 
687
                                if (arg.getAttribute(u"direction")
 
688
                                    == u"out"):
 
689
                                    arg.setAttribute(u"name", u"props")
 
690
            xmlstring = document.toxml(u"utf-8")
732
691
            document.unlink()
733
692
        except (AttributeError, xml.dom.DOMException,
734
 
                xml.parsers.expat.ExpatError) as error:
735
 
            logger.error("Failed to override Introspection method",
 
693
                xml.parsers.expat.ExpatError), error:
 
694
            logger.error(u"Failed to override Introspection method",
736
695
                         error)
737
696
        return xmlstring
738
697
 
744
703
    dbus_object_path: dbus.ObjectPath
745
704
    bus: dbus.SystemBus()
746
705
    """
747
 
    
748
 
    runtime_expansions = (Client.runtime_expansions
749
 
                          + ("dbus_object_path",))
750
 
    
751
706
    # dbus.service.Object doesn't use super(), so we can't either.
752
707
    
753
708
    def __init__(self, bus = None, *args, **kwargs):
756
711
        Client.__init__(self, *args, **kwargs)
757
712
        # Only now, when this client is initialized, can it show up on
758
713
        # the D-Bus
759
 
        client_object_name = unicode(self.name).translate(
760
 
            {ord("."): ord("_"),
761
 
             ord("-"): ord("_")})
762
714
        self.dbus_object_path = (dbus.ObjectPath
763
 
                                 ("/clients/" + client_object_name))
 
715
                                 (u"/clients/"
 
716
                                  + self.name.replace(u".", u"_")))
764
717
        DBusObjectWithProperties.__init__(self, self.bus,
765
718
                                          self.dbus_object_path)
766
719
        
773
726
        if (hasattr(self, "dbus_object_path")
774
727
            and bval is not bool(old_value)):
775
728
            dbus_bool = dbus.Boolean(bval, variant_level=1)
776
 
            self.PropertyChanged(dbus.String("ApprovalPending"),
 
729
            self.PropertyChanged(dbus.String(u"ApprovalPending"),
777
730
                                 dbus_bool)
778
731
 
779
732
    approvals_pending = property(_get_approvals_pending,
787
740
                           variant_level=variant_level)
788
741
    
789
742
    def enable(self):
790
 
        oldstate = getattr(self, "enabled", False)
 
743
        oldstate = getattr(self, u"enabled", False)
791
744
        r = Client.enable(self)
792
745
        if oldstate != self.enabled:
793
746
            # Emit D-Bus signals
794
 
            self.PropertyChanged(dbus.String("Enabled"),
 
747
            self.PropertyChanged(dbus.String(u"Enabled"),
795
748
                                 dbus.Boolean(True, variant_level=1))
796
749
            self.PropertyChanged(
797
 
                dbus.String("LastEnabled"),
 
750
                dbus.String(u"LastEnabled"),
798
751
                self._datetime_to_dbus(self.last_enabled,
799
752
                                       variant_level=1))
800
753
        return r
801
754
    
802
755
    def disable(self, quiet = False):
803
 
        oldstate = getattr(self, "enabled", False)
 
756
        oldstate = getattr(self, u"enabled", False)
804
757
        r = Client.disable(self, quiet=quiet)
805
758
        if not quiet and oldstate != self.enabled:
806
759
            # Emit D-Bus signal
807
 
            self.PropertyChanged(dbus.String("Enabled"),
 
760
            self.PropertyChanged(dbus.String(u"Enabled"),
808
761
                                 dbus.Boolean(False, variant_level=1))
809
762
        return r
810
763
    
813
766
            self.remove_from_connection()
814
767
        except LookupError:
815
768
            pass
816
 
        if hasattr(DBusObjectWithProperties, "__del__"):
 
769
        if hasattr(DBusObjectWithProperties, u"__del__"):
817
770
            DBusObjectWithProperties.__del__(self, *args, **kwargs)
818
771
        Client.__del__(self, *args, **kwargs)
819
772
    
822
775
        self.checker_callback_tag = None
823
776
        self.checker = None
824
777
        # Emit D-Bus signal
825
 
        self.PropertyChanged(dbus.String("CheckerRunning"),
 
778
        self.PropertyChanged(dbus.String(u"CheckerRunning"),
826
779
                             dbus.Boolean(False, variant_level=1))
827
780
        if os.WIFEXITED(condition):
828
781
            exitstatus = os.WEXITSTATUS(condition)
840
793
                                       *args, **kwargs)
841
794
    
842
795
    def checked_ok(self, *args, **kwargs):
843
 
        Client.checked_ok(self, *args, **kwargs)
 
796
        r = Client.checked_ok(self, *args, **kwargs)
844
797
        # Emit D-Bus signal
845
798
        self.PropertyChanged(
846
 
            dbus.String("LastCheckedOK"),
 
799
            dbus.String(u"LastCheckedOK"),
847
800
            (self._datetime_to_dbus(self.last_checked_ok,
848
801
                                    variant_level=1)))
849
 
    
850
 
    def need_approval(self, *args, **kwargs):
851
 
        r = Client.need_approval(self, *args, **kwargs)
852
 
        # Emit D-Bus signal
853
 
        self.PropertyChanged(
854
 
            dbus.String("LastApprovalRequest"),
855
 
            (self._datetime_to_dbus(self.last_approval_request,
856
 
                                    variant_level=1)))
857
802
        return r
858
803
    
859
804
    def start_checker(self, *args, **kwargs):
869
814
            # Emit D-Bus signal
870
815
            self.CheckerStarted(self.current_checker_command)
871
816
            self.PropertyChanged(
872
 
                dbus.String("CheckerRunning"),
 
817
                dbus.String(u"CheckerRunning"),
873
818
                dbus.Boolean(True, variant_level=1))
874
819
        return r
875
820
    
876
821
    def stop_checker(self, *args, **kwargs):
877
 
        old_checker = getattr(self, "checker", None)
 
822
        old_checker = getattr(self, u"checker", None)
878
823
        r = Client.stop_checker(self, *args, **kwargs)
879
824
        if (old_checker is not None
880
 
            and getattr(self, "checker", None) is None):
881
 
            self.PropertyChanged(dbus.String("CheckerRunning"),
 
825
            and getattr(self, u"checker", None) is None):
 
826
            self.PropertyChanged(dbus.String(u"CheckerRunning"),
882
827
                                 dbus.Boolean(False, variant_level=1))
883
828
        return r
884
829
 
895
840
    
896
841
    
897
842
    ## D-Bus methods, signals & properties
898
 
    _interface = "se.bsnet.fukt.Mandos.Client"
 
843
    _interface = u"se.bsnet.fukt.Mandos.Client"
899
844
    
900
845
    ## Signals
901
846
    
902
847
    # CheckerCompleted - signal
903
 
    @dbus.service.signal(_interface, signature="nxs")
 
848
    @dbus.service.signal(_interface, signature=u"nxs")
904
849
    def CheckerCompleted(self, exitcode, waitstatus, command):
905
850
        "D-Bus signal"
906
851
        pass
907
852
    
908
853
    # CheckerStarted - signal
909
 
    @dbus.service.signal(_interface, signature="s")
 
854
    @dbus.service.signal(_interface, signature=u"s")
910
855
    def CheckerStarted(self, command):
911
856
        "D-Bus signal"
912
857
        pass
913
858
    
914
859
    # PropertyChanged - signal
915
 
    @dbus.service.signal(_interface, signature="sv")
 
860
    @dbus.service.signal(_interface, signature=u"sv")
916
861
    def PropertyChanged(self, property, value):
917
862
        "D-Bus signal"
918
863
        pass
927
872
        pass
928
873
    
929
874
    # Rejected - signal
930
 
    @dbus.service.signal(_interface, signature="s")
 
875
    @dbus.service.signal(_interface, signature=u"s")
931
876
    def Rejected(self, reason):
932
877
        "D-Bus signal"
933
878
        pass
934
879
    
935
880
    # NeedApproval - signal
936
 
    @dbus.service.signal(_interface, signature="tb")
 
881
    @dbus.service.signal(_interface, signature=u"tb")
937
882
    def NeedApproval(self, timeout, default):
938
883
        "D-Bus signal"
939
 
        return self.need_approval()
 
884
        pass
940
885
    
941
886
    ## Methods
942
 
    
 
887
 
943
888
    # Approve - method
944
 
    @dbus.service.method(_interface, in_signature="b")
 
889
    @dbus.service.method(_interface, in_signature=u"b")
945
890
    def Approve(self, value):
946
891
        self.approve(value)
947
 
    
 
892
 
948
893
    # CheckedOK - method
949
894
    @dbus.service.method(_interface)
950
895
    def CheckedOK(self):
951
 
        self.checked_ok()
 
896
        return self.checked_ok()
952
897
    
953
898
    # Enable - method
954
899
    @dbus.service.method(_interface)
976
921
    ## Properties
977
922
    
978
923
    # ApprovalPending - property
979
 
    @dbus_service_property(_interface, signature="b", access="read")
 
924
    @dbus_service_property(_interface, signature=u"b", access=u"read")
980
925
    def ApprovalPending_dbus_property(self):
981
926
        return dbus.Boolean(bool(self.approvals_pending))
982
927
    
983
928
    # ApprovedByDefault - property
984
 
    @dbus_service_property(_interface, signature="b",
985
 
                           access="readwrite")
 
929
    @dbus_service_property(_interface, signature=u"b",
 
930
                           access=u"readwrite")
986
931
    def ApprovedByDefault_dbus_property(self, value=None):
987
932
        if value is None:       # get
988
933
            return dbus.Boolean(self.approved_by_default)
989
934
        self.approved_by_default = bool(value)
990
935
        # Emit D-Bus signal
991
 
        self.PropertyChanged(dbus.String("ApprovedByDefault"),
 
936
        self.PropertyChanged(dbus.String(u"ApprovedByDefault"),
992
937
                             dbus.Boolean(value, variant_level=1))
993
938
    
994
939
    # ApprovalDelay - property
995
 
    @dbus_service_property(_interface, signature="t",
996
 
                           access="readwrite")
 
940
    @dbus_service_property(_interface, signature=u"t",
 
941
                           access=u"readwrite")
997
942
    def ApprovalDelay_dbus_property(self, value=None):
998
943
        if value is None:       # get
999
944
            return dbus.UInt64(self.approval_delay_milliseconds())
1000
945
        self.approval_delay = datetime.timedelta(0, 0, 0, value)
1001
946
        # Emit D-Bus signal
1002
 
        self.PropertyChanged(dbus.String("ApprovalDelay"),
 
947
        self.PropertyChanged(dbus.String(u"ApprovalDelay"),
1003
948
                             dbus.UInt64(value, variant_level=1))
1004
949
    
1005
950
    # ApprovalDuration - property
1006
 
    @dbus_service_property(_interface, signature="t",
1007
 
                           access="readwrite")
 
951
    @dbus_service_property(_interface, signature=u"t",
 
952
                           access=u"readwrite")
1008
953
    def ApprovalDuration_dbus_property(self, value=None):
1009
954
        if value is None:       # get
1010
955
            return dbus.UInt64(self._timedelta_to_milliseconds(
1011
956
                    self.approval_duration))
1012
957
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
1013
958
        # Emit D-Bus signal
1014
 
        self.PropertyChanged(dbus.String("ApprovalDuration"),
 
959
        self.PropertyChanged(dbus.String(u"ApprovalDuration"),
1015
960
                             dbus.UInt64(value, variant_level=1))
1016
961
    
1017
962
    # Name - property
1018
 
    @dbus_service_property(_interface, signature="s", access="read")
 
963
    @dbus_service_property(_interface, signature=u"s", access=u"read")
1019
964
    def Name_dbus_property(self):
1020
965
        return dbus.String(self.name)
1021
966
    
1022
967
    # Fingerprint - property
1023
 
    @dbus_service_property(_interface, signature="s", access="read")
 
968
    @dbus_service_property(_interface, signature=u"s", access=u"read")
1024
969
    def Fingerprint_dbus_property(self):
1025
970
        return dbus.String(self.fingerprint)
1026
971
    
1027
972
    # Host - property
1028
 
    @dbus_service_property(_interface, signature="s",
1029
 
                           access="readwrite")
 
973
    @dbus_service_property(_interface, signature=u"s",
 
974
                           access=u"readwrite")
1030
975
    def Host_dbus_property(self, value=None):
1031
976
        if value is None:       # get
1032
977
            return dbus.String(self.host)
1033
978
        self.host = value
1034
979
        # Emit D-Bus signal
1035
 
        self.PropertyChanged(dbus.String("Host"),
 
980
        self.PropertyChanged(dbus.String(u"Host"),
1036
981
                             dbus.String(value, variant_level=1))
1037
982
    
1038
983
    # Created - property
1039
 
    @dbus_service_property(_interface, signature="s", access="read")
 
984
    @dbus_service_property(_interface, signature=u"s", access=u"read")
1040
985
    def Created_dbus_property(self):
1041
986
        return dbus.String(self._datetime_to_dbus(self.created))
1042
987
    
1043
988
    # LastEnabled - property
1044
 
    @dbus_service_property(_interface, signature="s", access="read")
 
989
    @dbus_service_property(_interface, signature=u"s", access=u"read")
1045
990
    def LastEnabled_dbus_property(self):
1046
991
        if self.last_enabled is None:
1047
 
            return dbus.String("")
 
992
            return dbus.String(u"")
1048
993
        return dbus.String(self._datetime_to_dbus(self.last_enabled))
1049
994
    
1050
995
    # Enabled - property
1051
 
    @dbus_service_property(_interface, signature="b",
1052
 
                           access="readwrite")
 
996
    @dbus_service_property(_interface, signature=u"b",
 
997
                           access=u"readwrite")
1053
998
    def Enabled_dbus_property(self, value=None):
1054
999
        if value is None:       # get
1055
1000
            return dbus.Boolean(self.enabled)
1059
1004
            self.disable()
1060
1005
    
1061
1006
    # LastCheckedOK - property
1062
 
    @dbus_service_property(_interface, signature="s",
1063
 
                           access="readwrite")
 
1007
    @dbus_service_property(_interface, signature=u"s",
 
1008
                           access=u"readwrite")
1064
1009
    def LastCheckedOK_dbus_property(self, value=None):
1065
1010
        if value is not None:
1066
1011
            self.checked_ok()
1067
1012
            return
1068
1013
        if self.last_checked_ok is None:
1069
 
            return dbus.String("")
 
1014
            return dbus.String(u"")
1070
1015
        return dbus.String(self._datetime_to_dbus(self
1071
1016
                                                  .last_checked_ok))
1072
1017
    
1073
 
    # LastApprovalRequest - property
1074
 
    @dbus_service_property(_interface, signature="s", access="read")
1075
 
    def LastApprovalRequest_dbus_property(self):
1076
 
        if self.last_approval_request is None:
1077
 
            return dbus.String("")
1078
 
        return dbus.String(self.
1079
 
                           _datetime_to_dbus(self
1080
 
                                             .last_approval_request))
1081
 
    
1082
1018
    # Timeout - property
1083
 
    @dbus_service_property(_interface, signature="t",
1084
 
                           access="readwrite")
 
1019
    @dbus_service_property(_interface, signature=u"t",
 
1020
                           access=u"readwrite")
1085
1021
    def Timeout_dbus_property(self, value=None):
1086
1022
        if value is None:       # get
1087
1023
            return dbus.UInt64(self.timeout_milliseconds())
1088
1024
        self.timeout = datetime.timedelta(0, 0, 0, value)
1089
1025
        # Emit D-Bus signal
1090
 
        self.PropertyChanged(dbus.String("Timeout"),
 
1026
        self.PropertyChanged(dbus.String(u"Timeout"),
1091
1027
                             dbus.UInt64(value, variant_level=1))
1092
 
        if getattr(self, "disable_initiator_tag", None) is None:
 
1028
        if getattr(self, u"disable_initiator_tag", None) is None:
1093
1029
            return
1094
1030
        # Reschedule timeout
1095
1031
        gobject.source_remove(self.disable_initiator_tag)
1108
1044
                                          (time_to_die, self.disable))
1109
1045
    
1110
1046
    # Interval - property
1111
 
    @dbus_service_property(_interface, signature="t",
1112
 
                           access="readwrite")
 
1047
    @dbus_service_property(_interface, signature=u"t",
 
1048
                           access=u"readwrite")
1113
1049
    def Interval_dbus_property(self, value=None):
1114
1050
        if value is None:       # get
1115
1051
            return dbus.UInt64(self.interval_milliseconds())
1116
1052
        self.interval = datetime.timedelta(0, 0, 0, value)
1117
1053
        # Emit D-Bus signal
1118
 
        self.PropertyChanged(dbus.String("Interval"),
 
1054
        self.PropertyChanged(dbus.String(u"Interval"),
1119
1055
                             dbus.UInt64(value, variant_level=1))
1120
 
        if getattr(self, "checker_initiator_tag", None) is None:
 
1056
        if getattr(self, u"checker_initiator_tag", None) is None:
1121
1057
            return
1122
1058
        # Reschedule checker run
1123
1059
        gobject.source_remove(self.checker_initiator_tag)
1126
1062
        self.start_checker()    # Start one now, too
1127
1063
 
1128
1064
    # Checker - property
1129
 
    @dbus_service_property(_interface, signature="s",
1130
 
                           access="readwrite")
 
1065
    @dbus_service_property(_interface, signature=u"s",
 
1066
                           access=u"readwrite")
1131
1067
    def Checker_dbus_property(self, value=None):
1132
1068
        if value is None:       # get
1133
1069
            return dbus.String(self.checker_command)
1134
1070
        self.checker_command = value
1135
1071
        # Emit D-Bus signal
1136
 
        self.PropertyChanged(dbus.String("Checker"),
 
1072
        self.PropertyChanged(dbus.String(u"Checker"),
1137
1073
                             dbus.String(self.checker_command,
1138
1074
                                         variant_level=1))
1139
1075
    
1140
1076
    # CheckerRunning - property
1141
 
    @dbus_service_property(_interface, signature="b",
1142
 
                           access="readwrite")
 
1077
    @dbus_service_property(_interface, signature=u"b",
 
1078
                           access=u"readwrite")
1143
1079
    def CheckerRunning_dbus_property(self, value=None):
1144
1080
        if value is None:       # get
1145
1081
            return dbus.Boolean(self.checker is not None)
1149
1085
            self.stop_checker()
1150
1086
    
1151
1087
    # ObjectPath - property
1152
 
    @dbus_service_property(_interface, signature="o", access="read")
 
1088
    @dbus_service_property(_interface, signature=u"o", access=u"read")
1153
1089
    def ObjectPath_dbus_property(self):
1154
1090
        return self.dbus_object_path # is already a dbus.ObjectPath
1155
1091
    
1156
1092
    # Secret = property
1157
 
    @dbus_service_property(_interface, signature="ay",
1158
 
                           access="write", byte_arrays=True)
 
1093
    @dbus_service_property(_interface, signature=u"ay",
 
1094
                           access=u"write", byte_arrays=True)
1159
1095
    def Secret_dbus_property(self, value):
1160
1096
        self.secret = str(value)
1161
1097
    
1196
1132
    
1197
1133
    def handle(self):
1198
1134
        with contextlib.closing(self.server.child_pipe) as child_pipe:
1199
 
            logger.info("TCP connection from: %s",
 
1135
            logger.info(u"TCP connection from: %s",
1200
1136
                        unicode(self.client_address))
1201
 
            logger.debug("Pipe FD: %d",
 
1137
            logger.debug(u"Pipe FD: %d",
1202
1138
                         self.server.child_pipe.fileno())
1203
1139
 
1204
1140
            session = (gnutls.connection
1211
1147
            # no X.509 keys are added to it.  Therefore, we can use it
1212
1148
            # here despite using OpenPGP certificates.
1213
1149
 
1214
 
            #priority = ':'.join(("NONE", "+VERS-TLS1.1",
1215
 
            #                      "+AES-256-CBC", "+SHA1",
1216
 
            #                      "+COMP-NULL", "+CTYPE-OPENPGP",
1217
 
            #                      "+DHE-DSS"))
 
1150
            #priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
 
1151
            #                      u"+AES-256-CBC", u"+SHA1",
 
1152
            #                      u"+COMP-NULL", u"+CTYPE-OPENPGP",
 
1153
            #                      u"+DHE-DSS"))
1218
1154
            # Use a fallback default, since this MUST be set.
1219
1155
            priority = self.server.gnutls_priority
1220
1156
            if priority is None:
1221
 
                priority = "NORMAL"
 
1157
                priority = u"NORMAL"
1222
1158
            (gnutls.library.functions
1223
1159
             .gnutls_priority_set_direct(session._c_object,
1224
1160
                                         priority, None))
1226
1162
            # Start communication using the Mandos protocol
1227
1163
            # Get protocol number
1228
1164
            line = self.request.makefile().readline()
1229
 
            logger.debug("Protocol version: %r", line)
 
1165
            logger.debug(u"Protocol version: %r", line)
1230
1166
            try:
1231
1167
                if int(line.strip().split()[0]) > 1:
1232
1168
                    raise RuntimeError
1233
 
            except (ValueError, IndexError, RuntimeError) as error:
1234
 
                logger.error("Unknown protocol version: %s", error)
 
1169
            except (ValueError, IndexError, RuntimeError), error:
 
1170
                logger.error(u"Unknown protocol version: %s", error)
1235
1171
                return
1236
1172
 
1237
1173
            # Start GnuTLS connection
1238
1174
            try:
1239
1175
                session.handshake()
1240
 
            except gnutls.errors.GNUTLSError as error:
1241
 
                logger.warning("Handshake failed: %s", error)
 
1176
            except gnutls.errors.GNUTLSError, error:
 
1177
                logger.warning(u"Handshake failed: %s", error)
1242
1178
                # Do not run session.bye() here: the session is not
1243
1179
                # established.  Just abandon the request.
1244
1180
                return
1245
 
            logger.debug("Handshake succeeded")
 
1181
            logger.debug(u"Handshake succeeded")
1246
1182
 
1247
1183
            approval_required = False
1248
1184
            try:
1249
1185
                try:
1250
1186
                    fpr = self.fingerprint(self.peer_certificate
1251
1187
                                           (session))
1252
 
                except (TypeError,
1253
 
                        gnutls.errors.GNUTLSError) as error:
1254
 
                    logger.warning("Bad certificate: %s", error)
 
1188
                except (TypeError, gnutls.errors.GNUTLSError), error:
 
1189
                    logger.warning(u"Bad certificate: %s", error)
1255
1190
                    return
1256
 
                logger.debug("Fingerprint: %s", fpr)
 
1191
                logger.debug(u"Fingerprint: %s", fpr)
1257
1192
 
1258
1193
                try:
1259
1194
                    client = ProxyClient(child_pipe, fpr,
1268
1203
                
1269
1204
                while True:
1270
1205
                    if not client.enabled:
1271
 
                        logger.info("Client %s is disabled",
 
1206
                        logger.warning(u"Client %s is disabled",
1272
1207
                                       client.name)
1273
1208
                        if self.server.use_dbus:
1274
1209
                            # Emit D-Bus signal
1279
1214
                        #We are approved or approval is disabled
1280
1215
                        break
1281
1216
                    elif client._approved is None:
1282
 
                        logger.info("Client %s needs approval",
 
1217
                        logger.info(u"Client %s needs approval",
1283
1218
                                    client.name)
1284
1219
                        if self.server.use_dbus:
1285
1220
                            # Emit D-Bus signal
1287
1222
                                client.approval_delay_milliseconds(),
1288
1223
                                client.approved_by_default)
1289
1224
                    else:
1290
 
                        logger.warning("Client %s was not approved",
 
1225
                        logger.warning(u"Client %s was not approved",
1291
1226
                                       client.name)
1292
1227
                        if self.server.use_dbus:
1293
1228
                            # Emit D-Bus signal
1308
1243
                                           client.name)
1309
1244
                            if self.server.use_dbus:
1310
1245
                                # Emit D-Bus signal
1311
 
                                client.Rejected("Approval timed out")
 
1246
                                client.Rejected("Timed out")
1312
1247
                            return
1313
1248
                        else:
1314
1249
                            break
1319
1254
                while sent_size < len(client.secret):
1320
1255
                    try:
1321
1256
                        sent = session.send(client.secret[sent_size:])
1322
 
                    except gnutls.errors.GNUTLSError as error:
 
1257
                    except (gnutls.errors.GNUTLSError), error:
1323
1258
                        logger.warning("gnutls send failed")
1324
1259
                        return
1325
 
                    logger.debug("Sent: %d, remaining: %d",
 
1260
                    logger.debug(u"Sent: %d, remaining: %d",
1326
1261
                                 sent, len(client.secret)
1327
1262
                                 - (sent_size + sent))
1328
1263
                    sent_size += sent
1329
1264
 
1330
 
                logger.info("Sending secret to %s", client.name)
 
1265
                logger.info(u"Sending secret to %s", client.name)
1331
1266
                # bump the timeout as if seen
1332
1267
                client.checked_ok()
1333
1268
                if self.server.use_dbus:
1339
1274
                    client.approvals_pending -= 1
1340
1275
                try:
1341
1276
                    session.bye()
1342
 
                except gnutls.errors.GNUTLSError as error:
 
1277
                except (gnutls.errors.GNUTLSError), error:
1343
1278
                    logger.warning("GnuTLS bye failed")
1344
1279
    
1345
1280
    @staticmethod
1356
1291
                     .gnutls_certificate_get_peers
1357
1292
                     (session._c_object, ctypes.byref(list_size)))
1358
1293
        if not bool(cert_list) and list_size.value != 0:
1359
 
            raise gnutls.errors.GNUTLSError("error getting peer"
1360
 
                                            " certificate")
 
1294
            raise gnutls.errors.GNUTLSError(u"error getting peer"
 
1295
                                            u" certificate")
1361
1296
        if list_size.value == 0:
1362
1297
            return None
1363
1298
        cert = cert_list[0]
1389
1324
        if crtverify.value != 0:
1390
1325
            gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1391
1326
            raise (gnutls.errors.CertificateSecurityError
1392
 
                   ("Verify failed"))
 
1327
                   (u"Verify failed"))
1393
1328
        # New buffer for the fingerprint
1394
1329
        buf = ctypes.create_string_buffer(20)
1395
1330
        buf_len = ctypes.c_size_t()
1402
1337
        # Convert the buffer to a Python bytestring
1403
1338
        fpr = ctypes.string_at(buf, buf_len.value)
1404
1339
        # Convert the bytestring to hexadecimal notation
1405
 
        hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
 
1340
        hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1406
1341
        return hex_fpr
1407
1342
 
1408
1343
 
1436
1371
 
1437
1372
    def add_pipe(self, parent_pipe):
1438
1373
        """Dummy function; override as necessary"""
1439
 
        raise NotImplementedError
 
1374
        pass
1440
1375
 
1441
1376
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1442
1377
                     socketserver.TCPServer, object):
1460
1395
        bind to an address or port if they were not specified."""
1461
1396
        if self.interface is not None:
1462
1397
            if SO_BINDTODEVICE is None:
1463
 
                logger.error("SO_BINDTODEVICE does not exist;"
1464
 
                             " cannot bind to interface %s",
 
1398
                logger.error(u"SO_BINDTODEVICE does not exist;"
 
1399
                             u" cannot bind to interface %s",
1465
1400
                             self.interface)
1466
1401
            else:
1467
1402
                try:
1468
1403
                    self.socket.setsockopt(socket.SOL_SOCKET,
1469
1404
                                           SO_BINDTODEVICE,
1470
1405
                                           str(self.interface
1471
 
                                               + '\0'))
1472
 
                except socket.error as error:
 
1406
                                               + u'\0'))
 
1407
                except socket.error, error:
1473
1408
                    if error[0] == errno.EPERM:
1474
 
                        logger.error("No permission to"
1475
 
                                     " bind to interface %s",
 
1409
                        logger.error(u"No permission to"
 
1410
                                     u" bind to interface %s",
1476
1411
                                     self.interface)
1477
1412
                    elif error[0] == errno.ENOPROTOOPT:
1478
 
                        logger.error("SO_BINDTODEVICE not available;"
1479
 
                                     " cannot bind to interface %s",
 
1413
                        logger.error(u"SO_BINDTODEVICE not available;"
 
1414
                                     u" cannot bind to interface %s",
1480
1415
                                     self.interface)
1481
1416
                    else:
1482
1417
                        raise
1484
1419
        if self.server_address[0] or self.server_address[1]:
1485
1420
            if not self.server_address[0]:
1486
1421
                if self.address_family == socket.AF_INET6:
1487
 
                    any_address = "::" # in6addr_any
 
1422
                    any_address = u"::" # in6addr_any
1488
1423
                else:
1489
1424
                    any_address = socket.INADDR_ANY
1490
1425
                self.server_address = (any_address,
1539
1474
    def handle_ipc(self, source, condition, parent_pipe=None,
1540
1475
                   client_object=None):
1541
1476
        condition_names = {
1542
 
            gobject.IO_IN: "IN",   # There is data to read.
1543
 
            gobject.IO_OUT: "OUT", # Data can be written (without
 
1477
            gobject.IO_IN: u"IN",   # There is data to read.
 
1478
            gobject.IO_OUT: u"OUT", # Data can be written (without
1544
1479
                                    # blocking).
1545
 
            gobject.IO_PRI: "PRI", # There is urgent data to read.
1546
 
            gobject.IO_ERR: "ERR", # Error condition.
1547
 
            gobject.IO_HUP: "HUP"  # Hung up (the connection has been
 
1480
            gobject.IO_PRI: u"PRI", # There is urgent data to read.
 
1481
            gobject.IO_ERR: u"ERR", # Error condition.
 
1482
            gobject.IO_HUP: u"HUP"  # Hung up (the connection has been
1548
1483
                                    # broken, usually for pipes and
1549
1484
                                    # sockets).
1550
1485
            }
1552
1487
                                       for cond, name in
1553
1488
                                       condition_names.iteritems()
1554
1489
                                       if cond & condition)
 
1490
        logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
 
1491
                     conditions_string)
 
1492
 
1555
1493
        # error or the other end of multiprocessing.Pipe has closed
1556
1494
        if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1557
1495
            return False
1558
1496
        
1559
1497
        # Read a request from the child
1560
1498
        request = parent_pipe.recv()
 
1499
        logger.debug(u"IPC request: %s", repr(request))
1561
1500
        command = request[0]
1562
1501
        
1563
1502
        if command == 'init':
1569
1508
                    client = c
1570
1509
                    break
1571
1510
            else:
1572
 
                logger.info("Client not found for fingerprint: %s, ad"
1573
 
                            "dress: %s", fpr, address)
 
1511
                logger.warning(u"Client not found for fingerprint: %s, ad"
 
1512
                               u"dress: %s", fpr, address)
1574
1513
                if self.use_dbus:
1575
1514
                    # Emit D-Bus signal
1576
 
                    mandos_dbus_service.ClientNotFound(fpr, address[0])
 
1515
                    mandos_dbus_service.ClientNotFound(fpr, address)
1577
1516
                parent_pipe.send(False)
1578
1517
                return False
1579
1518
            
1610
1549
def string_to_delta(interval):
1611
1550
    """Parse a string and return a datetime.timedelta
1612
1551
    
1613
 
    >>> string_to_delta('7d')
 
1552
    >>> string_to_delta(u'7d')
1614
1553
    datetime.timedelta(7)
1615
 
    >>> string_to_delta('60s')
 
1554
    >>> string_to_delta(u'60s')
1616
1555
    datetime.timedelta(0, 60)
1617
 
    >>> string_to_delta('60m')
 
1556
    >>> string_to_delta(u'60m')
1618
1557
    datetime.timedelta(0, 3600)
1619
 
    >>> string_to_delta('24h')
 
1558
    >>> string_to_delta(u'24h')
1620
1559
    datetime.timedelta(1)
1621
 
    >>> string_to_delta('1w')
 
1560
    >>> string_to_delta(u'1w')
1622
1561
    datetime.timedelta(7)
1623
 
    >>> string_to_delta('5m 30s')
 
1562
    >>> string_to_delta(u'5m 30s')
1624
1563
    datetime.timedelta(0, 330)
1625
1564
    """
1626
1565
    timevalue = datetime.timedelta(0)
1628
1567
        try:
1629
1568
            suffix = unicode(s[-1])
1630
1569
            value = int(s[:-1])
1631
 
            if suffix == "d":
 
1570
            if suffix == u"d":
1632
1571
                delta = datetime.timedelta(value)
1633
 
            elif suffix == "s":
 
1572
            elif suffix == u"s":
1634
1573
                delta = datetime.timedelta(0, value)
1635
 
            elif suffix == "m":
 
1574
            elif suffix == u"m":
1636
1575
                delta = datetime.timedelta(0, 0, 0, 0, value)
1637
 
            elif suffix == "h":
 
1576
            elif suffix == u"h":
1638
1577
                delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1639
 
            elif suffix == "w":
 
1578
            elif suffix == u"w":
1640
1579
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1641
1580
            else:
1642
 
                raise ValueError("Unknown suffix %r" % suffix)
1643
 
        except (ValueError, IndexError) as e:
1644
 
            raise ValueError(*(e.args))
 
1581
                raise ValueError(u"Unknown suffix %r" % suffix)
 
1582
        except (ValueError, IndexError), e:
 
1583
            raise ValueError(e.message)
1645
1584
        timevalue += delta
1646
1585
    return timevalue
1647
1586
 
1653
1592
    global if_nametoindex
1654
1593
    try:
1655
1594
        if_nametoindex = (ctypes.cdll.LoadLibrary
1656
 
                          (ctypes.util.find_library("c"))
 
1595
                          (ctypes.util.find_library(u"c"))
1657
1596
                          .if_nametoindex)
1658
1597
    except (OSError, AttributeError):
1659
 
        logger.warning("Doing if_nametoindex the hard way")
 
1598
        logger.warning(u"Doing if_nametoindex the hard way")
1660
1599
        def if_nametoindex(interface):
1661
1600
            "Get an interface index the hard way, i.e. using fcntl()"
1662
1601
            SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
1663
1602
            with contextlib.closing(socket.socket()) as s:
1664
1603
                ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1665
 
                                    struct.pack(str("16s16x"),
 
1604
                                    struct.pack(str(u"16s16x"),
1666
1605
                                                interface))
1667
 
            interface_index = struct.unpack(str("I"),
 
1606
            interface_index = struct.unpack(str(u"I"),
1668
1607
                                            ifreq[16:20])[0]
1669
1608
            return interface_index
1670
1609
    return if_nametoindex(interface)
1678
1617
        sys.exit()
1679
1618
    os.setsid()
1680
1619
    if not nochdir:
1681
 
        os.chdir("/")
 
1620
        os.chdir(u"/")
1682
1621
    if os.fork():
1683
1622
        sys.exit()
1684
1623
    if not noclose:
1686
1625
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1687
1626
        if not stat.S_ISCHR(os.fstat(null).st_mode):
1688
1627
            raise OSError(errno.ENODEV,
1689
 
                          "%s not a character device"
 
1628
                          u"%s not a character device"
1690
1629
                          % os.path.devnull)
1691
1630
        os.dup2(null, sys.stdin.fileno())
1692
1631
        os.dup2(null, sys.stdout.fileno())
1700
1639
    ##################################################################
1701
1640
    # Parsing of options, both command line and config file
1702
1641
    
1703
 
    parser = argparse.ArgumentParser()
1704
 
    parser.add_argument("-v", "--version", action="version",
1705
 
                        version = "%%(prog)s %s" % version,
1706
 
                        help="show version number and exit")
1707
 
    parser.add_argument("-i", "--interface", metavar="IF",
1708
 
                        help="Bind to interface IF")
1709
 
    parser.add_argument("-a", "--address",
1710
 
                        help="Address to listen for requests on")
1711
 
    parser.add_argument("-p", "--port", type=int,
1712
 
                        help="Port number to receive requests on")
1713
 
    parser.add_argument("--check", action="store_true",
1714
 
                        help="Run self-test")
1715
 
    parser.add_argument("--debug", action="store_true",
1716
 
                        help="Debug mode; run in foreground and log"
1717
 
                        " to terminal")
1718
 
    parser.add_argument("--debuglevel", metavar="LEVEL",
1719
 
                        help="Debug level for stdout output")
1720
 
    parser.add_argument("--priority", help="GnuTLS"
1721
 
                        " priority string (see GnuTLS documentation)")
1722
 
    parser.add_argument("--servicename",
1723
 
                        metavar="NAME", help="Zeroconf service name")
1724
 
    parser.add_argument("--configdir",
1725
 
                        default="/etc/mandos", metavar="DIR",
1726
 
                        help="Directory to search for configuration"
1727
 
                        " files")
1728
 
    parser.add_argument("--no-dbus", action="store_false",
1729
 
                        dest="use_dbus", help="Do not provide D-Bus"
1730
 
                        " system bus interface")
1731
 
    parser.add_argument("--no-ipv6", action="store_false",
1732
 
                        dest="use_ipv6", help="Do not use IPv6")
1733
 
    options = parser.parse_args()
 
1642
    parser = optparse.OptionParser(version = "%%prog %s" % version)
 
1643
    parser.add_option("-i", u"--interface", type=u"string",
 
1644
                      metavar="IF", help=u"Bind to interface IF")
 
1645
    parser.add_option("-a", u"--address", type=u"string",
 
1646
                      help=u"Address to listen for requests on")
 
1647
    parser.add_option("-p", u"--port", type=u"int",
 
1648
                      help=u"Port number to receive requests on")
 
1649
    parser.add_option("--check", action=u"store_true",
 
1650
                      help=u"Run self-test")
 
1651
    parser.add_option("--debug", action=u"store_true",
 
1652
                      help=u"Debug mode; run in foreground and log to"
 
1653
                      u" terminal")
 
1654
    parser.add_option("--debuglevel", type=u"string", metavar="Level",
 
1655
                      help=u"Debug level for stdout output")
 
1656
    parser.add_option("--priority", type=u"string", help=u"GnuTLS"
 
1657
                      u" priority string (see GnuTLS documentation)")
 
1658
    parser.add_option("--servicename", type=u"string",
 
1659
                      metavar=u"NAME", help=u"Zeroconf service name")
 
1660
    parser.add_option("--configdir", type=u"string",
 
1661
                      default=u"/etc/mandos", metavar=u"DIR",
 
1662
                      help=u"Directory to search for configuration"
 
1663
                      u" files")
 
1664
    parser.add_option("--no-dbus", action=u"store_false",
 
1665
                      dest=u"use_dbus", help=u"Do not provide D-Bus"
 
1666
                      u" system bus interface")
 
1667
    parser.add_option("--no-ipv6", action=u"store_false",
 
1668
                      dest=u"use_ipv6", help=u"Do not use IPv6")
 
1669
    options = parser.parse_args()[0]
1734
1670
    
1735
1671
    if options.check:
1736
1672
        import doctest
1738
1674
        sys.exit()
1739
1675
    
1740
1676
    # Default values for config file for server-global settings
1741
 
    server_defaults = { "interface": "",
1742
 
                        "address": "",
1743
 
                        "port": "",
1744
 
                        "debug": "False",
1745
 
                        "priority":
1746
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1747
 
                        "servicename": "Mandos",
1748
 
                        "use_dbus": "True",
1749
 
                        "use_ipv6": "True",
1750
 
                        "debuglevel": "",
 
1677
    server_defaults = { u"interface": u"",
 
1678
                        u"address": u"",
 
1679
                        u"port": u"",
 
1680
                        u"debug": u"False",
 
1681
                        u"priority":
 
1682
                        u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
 
1683
                        u"servicename": u"Mandos",
 
1684
                        u"use_dbus": u"True",
 
1685
                        u"use_ipv6": u"True",
 
1686
                        u"debuglevel": u"",
1751
1687
                        }
1752
1688
    
1753
1689
    # Parse config file for server-global settings
1754
1690
    server_config = configparser.SafeConfigParser(server_defaults)
1755
1691
    del server_defaults
1756
1692
    server_config.read(os.path.join(options.configdir,
1757
 
                                    "mandos.conf"))
 
1693
                                    u"mandos.conf"))
1758
1694
    # Convert the SafeConfigParser object to a dict
1759
1695
    server_settings = server_config.defaults()
1760
1696
    # Use the appropriate methods on the non-string config options
1761
 
    for option in ("debug", "use_dbus", "use_ipv6"):
1762
 
        server_settings[option] = server_config.getboolean("DEFAULT",
 
1697
    for option in (u"debug", u"use_dbus", u"use_ipv6"):
 
1698
        server_settings[option] = server_config.getboolean(u"DEFAULT",
1763
1699
                                                           option)
1764
1700
    if server_settings["port"]:
1765
 
        server_settings["port"] = server_config.getint("DEFAULT",
1766
 
                                                       "port")
 
1701
        server_settings["port"] = server_config.getint(u"DEFAULT",
 
1702
                                                       u"port")
1767
1703
    del server_config
1768
1704
    
1769
1705
    # Override the settings from the config file with command line
1770
1706
    # options, if set.
1771
 
    for option in ("interface", "address", "port", "debug",
1772
 
                   "priority", "servicename", "configdir",
1773
 
                   "use_dbus", "use_ipv6", "debuglevel"):
 
1707
    for option in (u"interface", u"address", u"port", u"debug",
 
1708
                   u"priority", u"servicename", u"configdir",
 
1709
                   u"use_dbus", u"use_ipv6", u"debuglevel"):
1774
1710
        value = getattr(options, option)
1775
1711
        if value is not None:
1776
1712
            server_settings[option] = value
1784
1720
    ##################################################################
1785
1721
    
1786
1722
    # For convenience
1787
 
    debug = server_settings["debug"]
1788
 
    debuglevel = server_settings["debuglevel"]
1789
 
    use_dbus = server_settings["use_dbus"]
1790
 
    use_ipv6 = server_settings["use_ipv6"]
 
1723
    debug = server_settings[u"debug"]
 
1724
    debuglevel = server_settings[u"debuglevel"]
 
1725
    use_dbus = server_settings[u"use_dbus"]
 
1726
    use_ipv6 = server_settings[u"use_ipv6"]
1791
1727
 
1792
 
    if server_settings["servicename"] != "Mandos":
 
1728
    if server_settings[u"servicename"] != u"Mandos":
1793
1729
        syslogger.setFormatter(logging.Formatter
1794
 
                               ('Mandos (%s) [%%(process)d]:'
1795
 
                                ' %%(levelname)s: %%(message)s'
1796
 
                                % server_settings["servicename"]))
 
1730
                               (u'Mandos (%s) [%%(process)d]:'
 
1731
                                u' %%(levelname)s: %%(message)s'
 
1732
                                % server_settings[u"servicename"]))
1797
1733
    
1798
1734
    # Parse config file with clients
1799
 
    client_defaults = { "timeout": "1h",
1800
 
                        "interval": "5m",
1801
 
                        "checker": "fping -q -- %%(host)s",
1802
 
                        "host": "",
1803
 
                        "approval_delay": "0s",
1804
 
                        "approval_duration": "1s",
 
1735
    client_defaults = { u"timeout": u"1h",
 
1736
                        u"interval": u"5m",
 
1737
                        u"checker": u"fping -q -- %%(host)s",
 
1738
                        u"host": u"",
 
1739
                        u"approval_delay": u"0s",
 
1740
                        u"approval_duration": u"1s",
1805
1741
                        }
1806
1742
    client_config = configparser.SafeConfigParser(client_defaults)
1807
 
    client_config.read(os.path.join(server_settings["configdir"],
1808
 
                                    "clients.conf"))
 
1743
    client_config.read(os.path.join(server_settings[u"configdir"],
 
1744
                                    u"clients.conf"))
1809
1745
    
1810
1746
    global mandos_dbus_service
1811
1747
    mandos_dbus_service = None
1812
1748
    
1813
 
    tcp_server = MandosServer((server_settings["address"],
1814
 
                               server_settings["port"]),
 
1749
    tcp_server = MandosServer((server_settings[u"address"],
 
1750
                               server_settings[u"port"]),
1815
1751
                              ClientHandler,
1816
 
                              interface=(server_settings["interface"]
 
1752
                              interface=(server_settings[u"interface"]
1817
1753
                                         or None),
1818
1754
                              use_ipv6=use_ipv6,
1819
1755
                              gnutls_priority=
1820
 
                              server_settings["priority"],
 
1756
                              server_settings[u"priority"],
1821
1757
                              use_dbus=use_dbus)
1822
 
    if not debug:
1823
 
        pidfilename = "/var/run/mandos.pid"
1824
 
        try:
1825
 
            pidfile = open(pidfilename, "w")
1826
 
        except IOError:
1827
 
            logger.error("Could not open file %r", pidfilename)
 
1758
    pidfilename = u"/var/run/mandos.pid"
 
1759
    try:
 
1760
        pidfile = open(pidfilename, u"w")
 
1761
    except IOError:
 
1762
        logger.error(u"Could not open file %r", pidfilename)
1828
1763
    
1829
1764
    try:
1830
 
        uid = pwd.getpwnam("_mandos").pw_uid
1831
 
        gid = pwd.getpwnam("_mandos").pw_gid
 
1765
        uid = pwd.getpwnam(u"_mandos").pw_uid
 
1766
        gid = pwd.getpwnam(u"_mandos").pw_gid
1832
1767
    except KeyError:
1833
1768
        try:
1834
 
            uid = pwd.getpwnam("mandos").pw_uid
1835
 
            gid = pwd.getpwnam("mandos").pw_gid
 
1769
            uid = pwd.getpwnam(u"mandos").pw_uid
 
1770
            gid = pwd.getpwnam(u"mandos").pw_gid
1836
1771
        except KeyError:
1837
1772
            try:
1838
 
                uid = pwd.getpwnam("nobody").pw_uid
1839
 
                gid = pwd.getpwnam("nobody").pw_gid
 
1773
                uid = pwd.getpwnam(u"nobody").pw_uid
 
1774
                gid = pwd.getpwnam(u"nobody").pw_gid
1840
1775
            except KeyError:
1841
1776
                uid = 65534
1842
1777
                gid = 65534
1843
1778
    try:
1844
1779
        os.setgid(gid)
1845
1780
        os.setuid(uid)
1846
 
    except OSError as error:
 
1781
    except OSError, error:
1847
1782
        if error[0] != errno.EPERM:
1848
1783
            raise error
1849
1784
    
1864
1799
        
1865
1800
        @gnutls.library.types.gnutls_log_func
1866
1801
        def debug_gnutls(level, string):
1867
 
            logger.debug("GnuTLS: %s", string[:-1])
 
1802
            logger.debug(u"GnuTLS: %s", string[:-1])
1868
1803
        
1869
1804
        (gnutls.library.functions
1870
1805
         .gnutls_global_set_log_function(debug_gnutls))
1878
1813
        # No console logging
1879
1814
        logger.removeHandler(console)
1880
1815
    
1881
 
    # Need to fork before connecting to D-Bus
1882
 
    if not debug:
1883
 
        # Close all input and output, do double fork, etc.
1884
 
        daemon()
1885
1816
    
1886
1817
    global main_loop
1887
1818
    # From the Avahi example code
1891
1822
    # End of Avahi example code
1892
1823
    if use_dbus:
1893
1824
        try:
1894
 
            bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",
 
1825
            bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
1895
1826
                                            bus, do_not_queue=True)
1896
 
        except dbus.exceptions.NameExistsException as e:
1897
 
            logger.error(unicode(e) + ", disabling D-Bus")
 
1827
        except dbus.exceptions.NameExistsException, e:
 
1828
            logger.error(unicode(e) + u", disabling D-Bus")
1898
1829
            use_dbus = False
1899
 
            server_settings["use_dbus"] = False
 
1830
            server_settings[u"use_dbus"] = False
1900
1831
            tcp_server.use_dbus = False
1901
1832
    protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1902
 
    service = AvahiService(name = server_settings["servicename"],
1903
 
                           servicetype = "_mandos._tcp",
 
1833
    service = AvahiService(name = server_settings[u"servicename"],
 
1834
                           servicetype = u"_mandos._tcp",
1904
1835
                           protocol = protocol, bus = bus)
1905
1836
    if server_settings["interface"]:
1906
1837
        service.interface = (if_nametoindex
1907
 
                             (str(server_settings["interface"])))
1908
 
    
 
1838
                             (str(server_settings[u"interface"])))
 
1839
 
 
1840
    if not debug:
 
1841
        # Close all input and output, do double fork, etc.
 
1842
        daemon()
 
1843
        
1909
1844
    global multiprocessing_manager
1910
1845
    multiprocessing_manager = multiprocessing.Manager()
1911
1846
    
1930
1865
                        client_config, section)))
1931
1866
            for section in client_config.sections()))
1932
1867
    if not tcp_server.clients:
1933
 
        logger.warning("No clients defined")
 
1868
        logger.warning(u"No clients defined")
1934
1869
        
 
1870
    try:
 
1871
        with pidfile:
 
1872
            pid = os.getpid()
 
1873
            pidfile.write(str(pid) + "\n")
 
1874
        del pidfile
 
1875
    except IOError:
 
1876
        logger.error(u"Could not write to file %r with PID %d",
 
1877
                     pidfilename, pid)
 
1878
    except NameError:
 
1879
        # "pidfile" was never created
 
1880
        pass
 
1881
    del pidfilename
 
1882
    
1935
1883
    if not debug:
1936
 
        try:
1937
 
            with pidfile:
1938
 
                pid = os.getpid()
1939
 
                pidfile.write(str(pid) + "\n".encode("utf-8"))
1940
 
            del pidfile
1941
 
        except IOError:
1942
 
            logger.error("Could not write to file %r with PID %d",
1943
 
                         pidfilename, pid)
1944
 
        except NameError:
1945
 
            # "pidfile" was never created
1946
 
            pass
1947
 
        del pidfilename
1948
 
        
1949
1884
        signal.signal(signal.SIGINT, signal.SIG_IGN)
1950
 
 
1951
1885
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1952
1886
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1953
1887
    
1955
1889
        class MandosDBusService(dbus.service.Object):
1956
1890
            """A D-Bus proxy object"""
1957
1891
            def __init__(self):
1958
 
                dbus.service.Object.__init__(self, bus, "/")
1959
 
            _interface = "se.bsnet.fukt.Mandos"
 
1892
                dbus.service.Object.__init__(self, bus, u"/")
 
1893
            _interface = u"se.bsnet.fukt.Mandos"
1960
1894
            
1961
 
            @dbus.service.signal(_interface, signature="o")
 
1895
            @dbus.service.signal(_interface, signature=u"o")
1962
1896
            def ClientAdded(self, objpath):
1963
1897
                "D-Bus signal"
1964
1898
                pass
1965
1899
            
1966
 
            @dbus.service.signal(_interface, signature="ss")
 
1900
            @dbus.service.signal(_interface, signature=u"ss")
1967
1901
            def ClientNotFound(self, fingerprint, address):
1968
1902
                "D-Bus signal"
1969
1903
                pass
1970
1904
            
1971
 
            @dbus.service.signal(_interface, signature="os")
 
1905
            @dbus.service.signal(_interface, signature=u"os")
1972
1906
            def ClientRemoved(self, objpath, name):
1973
1907
                "D-Bus signal"
1974
1908
                pass
1975
1909
            
1976
 
            @dbus.service.method(_interface, out_signature="ao")
 
1910
            @dbus.service.method(_interface, out_signature=u"ao")
1977
1911
            def GetAllClients(self):
1978
1912
                "D-Bus method"
1979
1913
                return dbus.Array(c.dbus_object_path
1980
1914
                                  for c in tcp_server.clients)
1981
1915
            
1982
1916
            @dbus.service.method(_interface,
1983
 
                                 out_signature="a{oa{sv}}")
 
1917
                                 out_signature=u"a{oa{sv}}")
1984
1918
            def GetAllClientsWithProperties(self):
1985
1919
                "D-Bus method"
1986
1920
                return dbus.Dictionary(
1987
 
                    ((c.dbus_object_path, c.GetAll(""))
 
1921
                    ((c.dbus_object_path, c.GetAll(u""))
1988
1922
                     for c in tcp_server.clients),
1989
 
                    signature="oa{sv}")
 
1923
                    signature=u"oa{sv}")
1990
1924
            
1991
 
            @dbus.service.method(_interface, in_signature="o")
 
1925
            @dbus.service.method(_interface, in_signature=u"o")
1992
1926
            def RemoveClient(self, object_path):
1993
1927
                "D-Bus method"
1994
1928
                for c in tcp_server.clients:
2036
1970
    # Find out what port we got
2037
1971
    service.port = tcp_server.socket.getsockname()[1]
2038
1972
    if use_ipv6:
2039
 
        logger.info("Now listening on address %r, port %d,"
 
1973
        logger.info(u"Now listening on address %r, port %d,"
2040
1974
                    " flowinfo %d, scope_id %d"
2041
1975
                    % tcp_server.socket.getsockname())
2042
1976
    else:                       # IPv4
2043
 
        logger.info("Now listening on address %r, port %d"
 
1977
        logger.info(u"Now listening on address %r, port %d"
2044
1978
                    % tcp_server.socket.getsockname())
2045
1979
    
2046
1980
    #service.interface = tcp_server.socket.getsockname()[3]
2049
1983
        # From the Avahi example code
2050
1984
        try:
2051
1985
            service.activate()
2052
 
        except dbus.exceptions.DBusException as error:
2053
 
            logger.critical("DBusException: %s", error)
 
1986
        except dbus.exceptions.DBusException, error:
 
1987
            logger.critical(u"DBusException: %s", error)
2054
1988
            cleanup()
2055
1989
            sys.exit(1)
2056
1990
        # End of Avahi example code
2060
1994
                             (tcp_server.handle_request
2061
1995
                              (*args[2:], **kwargs) or True))
2062
1996
        
2063
 
        logger.debug("Starting main loop")
 
1997
        logger.debug(u"Starting main loop")
2064
1998
        main_loop.run()
2065
 
    except AvahiError as error:
2066
 
        logger.critical("AvahiError: %s", error)
 
1999
    except AvahiError, error:
 
2000
        logger.critical(u"AvahiError: %s", error)
2067
2001
        cleanup()
2068
2002
        sys.exit(1)
2069
2003
    except KeyboardInterrupt:
2070
2004
        if debug:
2071
 
            print("", file=sys.stderr)
2072
 
        logger.debug("Server received KeyboardInterrupt")
2073
 
    logger.debug("Server exiting")
 
2005
            print >> sys.stderr
 
2006
        logger.debug(u"Server received KeyboardInterrupt")
 
2007
    logger.debug(u"Server exiting")
2074
2008
    # Must run before the D-Bus bus name gets deregistered
2075
2009
    cleanup()
2076
2010