/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-26 18:32:58 UTC
  • Revision ID: teddy@fukt.bsnet.se-20100926183258-n31ux2r8d06m1hi1
Update copyright year to "2010" wherever appropriate.

* DBUS-API: Added copyright and license statement.
* README: Mention new "plymouth" plugin.
* debian/control: Depend on python-2.6 or python-multiprocessing.
* debian/mandos-client.README.Debian: Update info about DEVICE setting
                                      of initramfs.conf.
* mandos-ctl: Added copyright and license statement.
* mandos-monitor: - '' -
* plugins.d/plymouth.c: - '' -

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
11
11
# "AvahiService" class, and some lines in "main".
12
12
# 
13
13
# Everything else is
14
 
# Copyright © 2008,2009 Teddy Hogeborn
15
 
# Copyright © 2008,2009 Björn Påhlsson
 
14
# Copyright © 2008-2010 Teddy Hogeborn
 
15
# Copyright © 2008-2010 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
240
240
    """A representation of a client host served by this server.
241
241
    
242
242
    Attributes:
243
 
    name:       string; from the config file, used in log messages and
244
 
                        D-Bus identifiers
 
243
    _approved:   bool(); 'None' if not yet approved/disapproved
 
244
    approval_delay: datetime.timedelta(); Time to wait for approval
 
245
    approval_duration: datetime.timedelta(); Duration of one approval
 
246
    checker:    subprocess.Popen(); a running checker process used
 
247
                                    to see if the client lives.
 
248
                                    'None' if no process is running.
 
249
    checker_callback_tag: a gobject event source tag, or None
 
250
    checker_command: string; External command which is run to check
 
251
                     if client lives.  %() expansions are done at
 
252
                     runtime with vars(self) as dict, so that for
 
253
                     instance %(name)s can be used in the command.
 
254
    checker_initiator_tag: a gobject event source tag, or None
 
255
    created:    datetime.datetime(); (UTC) object creation
 
256
    current_checker_command: string; current running checker_command
 
257
    disable_hook:  If set, called by disable() as disable_hook(self)
 
258
    disable_initiator_tag: a gobject event source tag, or None
 
259
    enabled:    bool()
245
260
    fingerprint: string (40 or 32 hexadecimal digits); used to
246
261
                 uniquely identify the client
247
 
    secret:     bytestring; sent verbatim (over TLS) to client
248
262
    host:       string; available for use by the checker command
249
 
    created:    datetime.datetime(); (UTC) object creation
 
263
    interval:   datetime.timedelta(); How often to start a new checker
 
264
    last_approval_request: datetime.datetime(); (UTC) or None
 
265
    last_checked_ok: datetime.datetime(); (UTC) or None
250
266
    last_enabled: datetime.datetime(); (UTC)
251
 
    enabled:    bool()
252
 
    last_checked_ok: datetime.datetime(); (UTC) or None
 
267
    name:       string; from the config file, used in log messages and
 
268
                        D-Bus identifiers
 
269
    secret:     bytestring; sent verbatim (over TLS) to client
253
270
    timeout:    datetime.timedelta(); How long from last_checked_ok
254
271
                                      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)
257
 
    checker:    subprocess.Popen(); a running checker process used
258
 
                                    to see if the client lives.
259
 
                                    'None' if no process is running.
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
265
 
                     runtime with vars(self) as dict, so that for
266
 
                     instance %(name)s can be used in the command.
267
 
    current_checker_command: string; current running checker_command
268
 
    approved_delay: datetime.timedelta(); Time to wait for approval
269
 
    _approved:   bool(); 'None' if not yet approved/disapproved
270
 
    approved_duration: datetime.timedelta(); Duration of one approval
 
272
    runtime_expansions: Allowed attributes for runtime expansion.
271
273
    """
272
274
    
 
275
    runtime_expansions = (u"approval_delay", u"approval_duration",
 
276
                          u"created", u"enabled", u"fingerprint",
 
277
                          u"host", u"interval", u"last_checked_ok",
 
278
                          u"last_enabled", u"name", u"timeout")
 
279
    
273
280
    @staticmethod
274
281
    def _timedelta_to_milliseconds(td):
275
282
        "Convert a datetime.timedelta() to milliseconds"
285
292
        "Return the 'interval' attribute in milliseconds"
286
293
        return self._timedelta_to_milliseconds(self.interval)
287
294
 
288
 
    def approved_delay_milliseconds(self):
289
 
        return self._timedelta_to_milliseconds(self.approved_delay)
 
295
    def approval_delay_milliseconds(self):
 
296
        return self._timedelta_to_milliseconds(self.approval_delay)
290
297
    
291
298
    def __init__(self, name = None, disable_hook=None, config=None):
292
299
        """Note: the 'checker' key in 'config' sets the
315
322
        self.host = config.get(u"host", u"")
316
323
        self.created = datetime.datetime.utcnow()
317
324
        self.enabled = False
 
325
        self.last_approval_request = None
318
326
        self.last_enabled = None
319
327
        self.last_checked_ok = None
320
328
        self.timeout = string_to_delta(config[u"timeout"])
331
339
        self.approved_by_default = config.get(u"approved_by_default",
332
340
                                              True)
333
341
        self.approvals_pending = 0
334
 
        self.approved_delay = string_to_delta(
335
 
            config[u"approved_delay"])
336
 
        self.approved_duration = string_to_delta(
337
 
            config[u"approved_duration"])
 
342
        self.approval_delay = string_to_delta(
 
343
            config[u"approval_delay"])
 
344
        self.approval_duration = string_to_delta(
 
345
            config[u"approval_duration"])
338
346
        self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
339
347
    
340
348
    def send_changedstate(self):
416
424
                                      (self.timeout_milliseconds(),
417
425
                                       self.disable))
418
426
    
 
427
    def need_approval(self):
 
428
        self.last_approval_request = datetime.datetime.utcnow()
 
429
    
419
430
    def start_checker(self):
420
431
        """Start a new checker subprocess if one is not running.
421
432
        
450
461
                command = self.checker_command % self.host
451
462
            except TypeError:
452
463
                # Escape attributes for the shell
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())
 
464
                escaped_attrs = dict(
 
465
                    (attr,
 
466
                     re.escape(unicode(str(getattr(self, attr, u"")),
 
467
                                       errors=
 
468
                                       u'replace')))
 
469
                    for attr in
 
470
                    self.runtime_expansions)
 
471
 
459
472
                try:
460
473
                    command = self.checker_command % escaped_attrs
461
474
                except TypeError, error:
703
716
    dbus_object_path: dbus.ObjectPath
704
717
    bus: dbus.SystemBus()
705
718
    """
 
719
    
 
720
    runtime_expansions = (Client.runtime_expansions
 
721
                          + (u"dbus_object_path",))
 
722
    
706
723
    # dbus.service.Object doesn't use super(), so we can't either.
707
724
    
708
725
    def __init__(self, bus = None, *args, **kwargs):
711
728
        Client.__init__(self, *args, **kwargs)
712
729
        # Only now, when this client is initialized, can it show up on
713
730
        # the D-Bus
 
731
        client_object_name = unicode(self.name).translate(
 
732
            {ord(u"."): ord(u"_"),
 
733
             ord(u"-"): ord(u"_")})
714
734
        self.dbus_object_path = (dbus.ObjectPath
715
 
                                 (u"/clients/"
716
 
                                  + self.name.replace(u".", u"_")))
 
735
                                 (u"/clients/" + client_object_name))
717
736
        DBusObjectWithProperties.__init__(self, self.bus,
718
737
                                          self.dbus_object_path)
719
 
 
 
738
        
720
739
    def _get_approvals_pending(self):
721
740
        return self._approvals_pending
722
741
    def _set_approvals_pending(self, value):
726
745
        if (hasattr(self, "dbus_object_path")
727
746
            and bval is not bool(old_value)):
728
747
            dbus_bool = dbus.Boolean(bval, variant_level=1)
729
 
            self.PropertyChanged(dbus.String(u"approved_pending"),
 
748
            self.PropertyChanged(dbus.String(u"ApprovalPending"),
730
749
                                 dbus_bool)
731
750
 
732
751
    approvals_pending = property(_get_approvals_pending,
744
763
        r = Client.enable(self)
745
764
        if oldstate != self.enabled:
746
765
            # Emit D-Bus signals
747
 
            self.PropertyChanged(dbus.String(u"enabled"),
 
766
            self.PropertyChanged(dbus.String(u"Enabled"),
748
767
                                 dbus.Boolean(True, variant_level=1))
749
768
            self.PropertyChanged(
750
 
                dbus.String(u"last_enabled"),
 
769
                dbus.String(u"LastEnabled"),
751
770
                self._datetime_to_dbus(self.last_enabled,
752
771
                                       variant_level=1))
753
772
        return r
757
776
        r = Client.disable(self, quiet=quiet)
758
777
        if not quiet and oldstate != self.enabled:
759
778
            # Emit D-Bus signal
760
 
            self.PropertyChanged(dbus.String(u"enabled"),
 
779
            self.PropertyChanged(dbus.String(u"Enabled"),
761
780
                                 dbus.Boolean(False, variant_level=1))
762
781
        return r
763
782
    
775
794
        self.checker_callback_tag = None
776
795
        self.checker = None
777
796
        # Emit D-Bus signal
778
 
        self.PropertyChanged(dbus.String(u"checker_running"),
 
797
        self.PropertyChanged(dbus.String(u"CheckerRunning"),
779
798
                             dbus.Boolean(False, variant_level=1))
780
799
        if os.WIFEXITED(condition):
781
800
            exitstatus = os.WEXITSTATUS(condition)
796
815
        r = Client.checked_ok(self, *args, **kwargs)
797
816
        # Emit D-Bus signal
798
817
        self.PropertyChanged(
799
 
            dbus.String(u"last_checked_ok"),
 
818
            dbus.String(u"LastCheckedOK"),
800
819
            (self._datetime_to_dbus(self.last_checked_ok,
801
820
                                    variant_level=1)))
802
821
        return r
803
822
    
 
823
    def need_approval(self, *args, **kwargs):
 
824
        r = Client.need_approval(self, *args, **kwargs)
 
825
        # Emit D-Bus signal
 
826
        self.PropertyChanged(
 
827
            dbus.String(u"LastApprovalRequest"),
 
828
            (self._datetime_to_dbus(self.last_approval_request,
 
829
                                    variant_level=1)))
 
830
        return r
 
831
    
804
832
    def start_checker(self, *args, **kwargs):
805
833
        old_checker = self.checker
806
834
        if self.checker is not None:
814
842
            # Emit D-Bus signal
815
843
            self.CheckerStarted(self.current_checker_command)
816
844
            self.PropertyChanged(
817
 
                dbus.String(u"checker_running"),
 
845
                dbus.String(u"CheckerRunning"),
818
846
                dbus.Boolean(True, variant_level=1))
819
847
        return r
820
848
    
823
851
        r = Client.stop_checker(self, *args, **kwargs)
824
852
        if (old_checker is not None
825
853
            and getattr(self, u"checker", None) is None):
826
 
            self.PropertyChanged(dbus.String(u"checker_running"),
 
854
            self.PropertyChanged(dbus.String(u"CheckerRunning"),
827
855
                                 dbus.Boolean(False, variant_level=1))
828
856
        return r
829
857
 
834
862
    def approve(self, value=True):
835
863
        self.send_changedstate()
836
864
        self._approved = value
837
 
        gobject.timeout_add(self._timedelta_to_milliseconds(self.approved_duration),
 
865
        gobject.timeout_add(self._timedelta_to_milliseconds
 
866
                            (self.approval_duration),
838
867
                            self._reset_approved)
839
868
    
840
869
    
877
906
        pass
878
907
    
879
908
    # NeedApproval - signal
880
 
    @dbus.service.signal(_interface, signature=u"db")
 
909
    @dbus.service.signal(_interface, signature=u"tb")
881
910
    def NeedApproval(self, timeout, default):
882
911
        "D-Bus signal"
883
 
        pass
 
912
        return self.need_approval()
884
913
    
885
914
    ## Methods
886
 
 
 
915
    
887
916
    # Approve - method
888
917
    @dbus.service.method(_interface, in_signature=u"b")
889
918
    def Approve(self, value):
890
919
        self.approve(value)
891
 
 
 
920
    
892
921
    # CheckedOK - method
893
922
    @dbus.service.method(_interface)
894
923
    def CheckedOK(self):
919
948
    
920
949
    ## Properties
921
950
    
922
 
    # approved_pending - property
 
951
    # ApprovalPending - property
923
952
    @dbus_service_property(_interface, signature=u"b", access=u"read")
924
 
    def approved_pending_dbus_property(self):
 
953
    def ApprovalPending_dbus_property(self):
925
954
        return dbus.Boolean(bool(self.approvals_pending))
926
955
    
927
 
    # approved_by_default - property
 
956
    # ApprovedByDefault - property
928
957
    @dbus_service_property(_interface, signature=u"b",
929
958
                           access=u"readwrite")
930
 
    def approved_by_default_dbus_property(self):
931
 
        return dbus.Boolean(self.approved_by_default)
932
 
    
933
 
    # approved_delay - property
934
 
    @dbus_service_property(_interface, signature=u"t",
935
 
                           access=u"readwrite")
936
 
    def approved_delay_dbus_property(self):
937
 
        return dbus.UInt64(self.approved_delay_milliseconds())
938
 
    
939
 
    # approved_duration - property
940
 
    @dbus_service_property(_interface, signature=u"t",
941
 
                           access=u"readwrite")
942
 
    def approved_duration_dbus_property(self):
943
 
        return dbus.UInt64(self._timedelta_to_milliseconds(
944
 
                self.approved_duration))
945
 
    
946
 
    # name - property
 
959
    def ApprovedByDefault_dbus_property(self, value=None):
 
960
        if value is None:       # get
 
961
            return dbus.Boolean(self.approved_by_default)
 
962
        self.approved_by_default = bool(value)
 
963
        # Emit D-Bus signal
 
964
        self.PropertyChanged(dbus.String(u"ApprovedByDefault"),
 
965
                             dbus.Boolean(value, variant_level=1))
 
966
    
 
967
    # ApprovalDelay - property
 
968
    @dbus_service_property(_interface, signature=u"t",
 
969
                           access=u"readwrite")
 
970
    def ApprovalDelay_dbus_property(self, value=None):
 
971
        if value is None:       # get
 
972
            return dbus.UInt64(self.approval_delay_milliseconds())
 
973
        self.approval_delay = datetime.timedelta(0, 0, 0, value)
 
974
        # Emit D-Bus signal
 
975
        self.PropertyChanged(dbus.String(u"ApprovalDelay"),
 
976
                             dbus.UInt64(value, variant_level=1))
 
977
    
 
978
    # ApprovalDuration - property
 
979
    @dbus_service_property(_interface, signature=u"t",
 
980
                           access=u"readwrite")
 
981
    def ApprovalDuration_dbus_property(self, value=None):
 
982
        if value is None:       # get
 
983
            return dbus.UInt64(self._timedelta_to_milliseconds(
 
984
                    self.approval_duration))
 
985
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
 
986
        # Emit D-Bus signal
 
987
        self.PropertyChanged(dbus.String(u"ApprovalDuration"),
 
988
                             dbus.UInt64(value, variant_level=1))
 
989
    
 
990
    # Name - property
947
991
    @dbus_service_property(_interface, signature=u"s", access=u"read")
948
 
    def name_dbus_property(self):
 
992
    def Name_dbus_property(self):
949
993
        return dbus.String(self.name)
950
994
    
951
 
    # fingerprint - property
 
995
    # Fingerprint - property
952
996
    @dbus_service_property(_interface, signature=u"s", access=u"read")
953
 
    def fingerprint_dbus_property(self):
 
997
    def Fingerprint_dbus_property(self):
954
998
        return dbus.String(self.fingerprint)
955
999
    
956
 
    # host - property
 
1000
    # Host - property
957
1001
    @dbus_service_property(_interface, signature=u"s",
958
1002
                           access=u"readwrite")
959
 
    def host_dbus_property(self, value=None):
 
1003
    def Host_dbus_property(self, value=None):
960
1004
        if value is None:       # get
961
1005
            return dbus.String(self.host)
962
1006
        self.host = value
963
1007
        # Emit D-Bus signal
964
 
        self.PropertyChanged(dbus.String(u"host"),
 
1008
        self.PropertyChanged(dbus.String(u"Host"),
965
1009
                             dbus.String(value, variant_level=1))
966
1010
    
967
 
    # created - property
 
1011
    # Created - property
968
1012
    @dbus_service_property(_interface, signature=u"s", access=u"read")
969
 
    def created_dbus_property(self):
 
1013
    def Created_dbus_property(self):
970
1014
        return dbus.String(self._datetime_to_dbus(self.created))
971
1015
    
972
 
    # last_enabled - property
 
1016
    # LastEnabled - property
973
1017
    @dbus_service_property(_interface, signature=u"s", access=u"read")
974
 
    def last_enabled_dbus_property(self):
 
1018
    def LastEnabled_dbus_property(self):
975
1019
        if self.last_enabled is None:
976
1020
            return dbus.String(u"")
977
1021
        return dbus.String(self._datetime_to_dbus(self.last_enabled))
978
1022
    
979
 
    # enabled - property
 
1023
    # Enabled - property
980
1024
    @dbus_service_property(_interface, signature=u"b",
981
1025
                           access=u"readwrite")
982
 
    def enabled_dbus_property(self, value=None):
 
1026
    def Enabled_dbus_property(self, value=None):
983
1027
        if value is None:       # get
984
1028
            return dbus.Boolean(self.enabled)
985
1029
        if value:
987
1031
        else:
988
1032
            self.disable()
989
1033
    
990
 
    # last_checked_ok - property
 
1034
    # LastCheckedOK - property
991
1035
    @dbus_service_property(_interface, signature=u"s",
992
1036
                           access=u"readwrite")
993
 
    def last_checked_ok_dbus_property(self, value=None):
 
1037
    def LastCheckedOK_dbus_property(self, value=None):
994
1038
        if value is not None:
995
1039
            self.checked_ok()
996
1040
            return
999
1043
        return dbus.String(self._datetime_to_dbus(self
1000
1044
                                                  .last_checked_ok))
1001
1045
    
1002
 
    # timeout - property
 
1046
    # LastApprovalRequest - property
 
1047
    @dbus_service_property(_interface, signature=u"s", access=u"read")
 
1048
    def LastApprovalRequest_dbus_property(self):
 
1049
        if self.last_approval_request is None:
 
1050
            return dbus.String(u"")
 
1051
        return dbus.String(self.
 
1052
                           _datetime_to_dbus(self
 
1053
                                             .last_approval_request))
 
1054
    
 
1055
    # Timeout - property
1003
1056
    @dbus_service_property(_interface, signature=u"t",
1004
1057
                           access=u"readwrite")
1005
 
    def timeout_dbus_property(self, value=None):
 
1058
    def Timeout_dbus_property(self, value=None):
1006
1059
        if value is None:       # get
1007
1060
            return dbus.UInt64(self.timeout_milliseconds())
1008
1061
        self.timeout = datetime.timedelta(0, 0, 0, value)
1009
1062
        # Emit D-Bus signal
1010
 
        self.PropertyChanged(dbus.String(u"timeout"),
 
1063
        self.PropertyChanged(dbus.String(u"Timeout"),
1011
1064
                             dbus.UInt64(value, variant_level=1))
1012
1065
        if getattr(self, u"disable_initiator_tag", None) is None:
1013
1066
            return
1027
1080
            self.disable_initiator_tag = (gobject.timeout_add
1028
1081
                                          (time_to_die, self.disable))
1029
1082
    
1030
 
    # interval - property
 
1083
    # Interval - property
1031
1084
    @dbus_service_property(_interface, signature=u"t",
1032
1085
                           access=u"readwrite")
1033
 
    def interval_dbus_property(self, value=None):
 
1086
    def Interval_dbus_property(self, value=None):
1034
1087
        if value is None:       # get
1035
1088
            return dbus.UInt64(self.interval_milliseconds())
1036
1089
        self.interval = datetime.timedelta(0, 0, 0, value)
1037
1090
        # Emit D-Bus signal
1038
 
        self.PropertyChanged(dbus.String(u"interval"),
 
1091
        self.PropertyChanged(dbus.String(u"Interval"),
1039
1092
                             dbus.UInt64(value, variant_level=1))
1040
1093
        if getattr(self, u"checker_initiator_tag", None) is None:
1041
1094
            return
1045
1098
                                      (value, self.start_checker))
1046
1099
        self.start_checker()    # Start one now, too
1047
1100
 
1048
 
    # checker - property
 
1101
    # Checker - property
1049
1102
    @dbus_service_property(_interface, signature=u"s",
1050
1103
                           access=u"readwrite")
1051
 
    def checker_dbus_property(self, value=None):
 
1104
    def Checker_dbus_property(self, value=None):
1052
1105
        if value is None:       # get
1053
1106
            return dbus.String(self.checker_command)
1054
1107
        self.checker_command = value
1055
1108
        # Emit D-Bus signal
1056
 
        self.PropertyChanged(dbus.String(u"checker"),
 
1109
        self.PropertyChanged(dbus.String(u"Checker"),
1057
1110
                             dbus.String(self.checker_command,
1058
1111
                                         variant_level=1))
1059
1112
    
1060
 
    # checker_running - property
 
1113
    # CheckerRunning - property
1061
1114
    @dbus_service_property(_interface, signature=u"b",
1062
1115
                           access=u"readwrite")
1063
 
    def checker_running_dbus_property(self, value=None):
 
1116
    def CheckerRunning_dbus_property(self, value=None):
1064
1117
        if value is None:       # get
1065
1118
            return dbus.Boolean(self.checker is not None)
1066
1119
        if value:
1068
1121
        else:
1069
1122
            self.stop_checker()
1070
1123
    
1071
 
    # object_path - property
 
1124
    # ObjectPath - property
1072
1125
    @dbus_service_property(_interface, signature=u"o", access=u"read")
1073
 
    def object_path_dbus_property(self):
 
1126
    def ObjectPath_dbus_property(self):
1074
1127
        return self.dbus_object_path # is already a dbus.ObjectPath
1075
1128
    
1076
 
    # secret = property
 
1129
    # Secret = property
1077
1130
    @dbus_service_property(_interface, signature=u"ay",
1078
1131
                           access=u"write", byte_arrays=True)
1079
 
    def secret_dbus_property(self, value):
 
1132
    def Secret_dbus_property(self, value):
1080
1133
        self.secret = str(value)
1081
1134
    
1082
1135
    del _interface
1180
1233
                except KeyError:
1181
1234
                    return
1182
1235
                
1183
 
                if client.approved_delay:
1184
 
                    delay = client.approved_delay
 
1236
                if client.approval_delay:
 
1237
                    delay = client.approval_delay
1185
1238
                    client.approvals_pending += 1
1186
1239
                    approval_required = True
1187
1240
                
1194
1247
                            client.Rejected("Disabled")                    
1195
1248
                        return
1196
1249
                    
1197
 
                    if client._approved or not client.approved_delay:
 
1250
                    if client._approved or not client.approval_delay:
1198
1251
                        #We are approved or approval is disabled
1199
1252
                        break
1200
1253
                    elif client._approved is None:
1201
 
                        logger.info(u"Client %s need approval",
 
1254
                        logger.info(u"Client %s needs approval",
1202
1255
                                    client.name)
1203
1256
                        if self.server.use_dbus:
1204
1257
                            # Emit D-Bus signal
1205
1258
                            client.NeedApproval(
1206
 
                                client.approved_delay_milliseconds(),
 
1259
                                client.approval_delay_milliseconds(),
1207
1260
                                client.approved_by_default)
1208
1261
                    else:
1209
1262
                        logger.warning(u"Client %s was not approved",
1210
1263
                                       client.name)
1211
1264
                        if self.server.use_dbus:
1212
1265
                            # Emit D-Bus signal
1213
 
                            client.Rejected("Disapproved")
 
1266
                            client.Rejected("Denied")
1214
1267
                        return
1215
1268
                    
1216
1269
                    #wait until timeout or approved
1227
1280
                                           client.name)
1228
1281
                            if self.server.use_dbus:
1229
1282
                                # Emit D-Bus signal
1230
 
                                client.Rejected("Time out")
 
1283
                                client.Rejected("Approval timed out")
1231
1284
                            return
1232
1285
                        else:
1233
1286
                            break
1259
1312
                try:
1260
1313
                    session.bye()
1261
1314
                except (gnutls.errors.GNUTLSError), error:
1262
 
                    logger.warning("gnutls bye failed")
 
1315
                    logger.warning("GnuTLS bye failed")
1263
1316
    
1264
1317
    @staticmethod
1265
1318
    def peer_certificate(session):
1471
1524
                                       for cond, name in
1472
1525
                                       condition_names.iteritems()
1473
1526
                                       if cond & condition)
1474
 
        logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1475
 
                     conditions_string)
1476
 
 
1477
1527
        # error or the other end of multiprocessing.Pipe has closed
1478
1528
        if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1479
1529
            return False
1480
1530
        
1481
1531
        # Read a request from the child
1482
1532
        request = parent_pipe.recv()
1483
 
        logger.debug(u"IPC request: %s", repr(request))
1484
1533
        command = request[0]
1485
1534
        
1486
1535
        if command == 'init':
1496
1545
                               u"dress: %s", fpr, address)
1497
1546
                if self.use_dbus:
1498
1547
                    # Emit D-Bus signal
1499
 
                    mandos_dbus_service.ClientNotFound(fpr, address)
 
1548
                    mandos_dbus_service.ClientNotFound(fpr, address[0])
1500
1549
                parent_pipe.send(False)
1501
1550
                return False
1502
1551
            
1720
1769
                        u"interval": u"5m",
1721
1770
                        u"checker": u"fping -q -- %%(host)s",
1722
1771
                        u"host": u"",
1723
 
                        u"approved_delay": u"0s",
1724
 
                        u"approved_duration": u"1s",
 
1772
                        u"approval_delay": u"0s",
 
1773
                        u"approval_duration": u"1s",
1725
1774
                        }
1726
1775
    client_config = configparser.SafeConfigParser(client_defaults)
1727
1776
    client_config.read(os.path.join(server_settings[u"configdir"],
1733
1782
    tcp_server = MandosServer((server_settings[u"address"],
1734
1783
                               server_settings[u"port"]),
1735
1784
                              ClientHandler,
1736
 
                              interface=server_settings[u"interface"],
 
1785
                              interface=(server_settings[u"interface"]
 
1786
                                         or None),
1737
1787
                              use_ipv6=use_ipv6,
1738
1788
                              gnutls_priority=
1739
1789
                              server_settings[u"priority"],
1740
1790
                              use_dbus=use_dbus)
1741
 
    pidfilename = u"/var/run/mandos.pid"
1742
 
    try:
1743
 
        pidfile = open(pidfilename, u"w")
1744
 
    except IOError:
1745
 
        logger.error(u"Could not open file %r", pidfilename)
 
1791
    if not debug:
 
1792
        pidfilename = u"/var/run/mandos.pid"
 
1793
        try:
 
1794
            pidfile = open(pidfilename, u"w")
 
1795
        except IOError:
 
1796
            logger.error(u"Could not open file %r", pidfilename)
1746
1797
    
1747
1798
    try:
1748
1799
        uid = pwd.getpwnam(u"_mandos").pw_uid
1765
1816
        if error[0] != errno.EPERM:
1766
1817
            raise error
1767
1818
    
1768
 
    # Enable all possible GnuTLS debugging
1769
 
 
1770
 
 
1771
1819
    if not debug and not debuglevel:
1772
1820
        syslogger.setLevel(logging.WARNING)
1773
1821
        console.setLevel(logging.WARNING)
1777
1825
        console.setLevel(level)
1778
1826
 
1779
1827
    if debug:
 
1828
        # Enable all possible GnuTLS debugging
 
1829
        
1780
1830
        # "Use a log level over 10 to enable all debugging options."
1781
1831
        # - GnuTLS manual
1782
1832
        gnutls.library.functions.gnutls_global_set_log_level(11)
1787
1837
        
1788
1838
        (gnutls.library.functions
1789
1839
         .gnutls_global_set_log_function(debug_gnutls))
1790
 
 
 
1840
        
1791
1841
        # Redirect stdin so all checkers get /dev/null
1792
1842
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1793
1843
        os.dup2(null, sys.stdin.fileno())
1796
1846
    else:
1797
1847
        # No console logging
1798
1848
        logger.removeHandler(console)
1799
 
 
 
1849
    
1800
1850
    
1801
1851
    global main_loop
1802
1852
    # From the Avahi example code
1851
1901
    if not tcp_server.clients:
1852
1902
        logger.warning(u"No clients defined")
1853
1903
        
1854
 
    try:
1855
 
        with pidfile:
1856
 
            pid = os.getpid()
1857
 
            pidfile.write(str(pid) + "\n")
1858
 
        del pidfile
1859
 
    except IOError:
1860
 
        logger.error(u"Could not write to file %r with PID %d",
1861
 
                     pidfilename, pid)
1862
 
    except NameError:
1863
 
        # "pidfile" was never created
1864
 
        pass
1865
 
    del pidfilename
1866
 
    
1867
1904
    if not debug:
 
1905
        try:
 
1906
            with pidfile:
 
1907
                pid = os.getpid()
 
1908
                pidfile.write(str(pid) + "\n")
 
1909
            del pidfile
 
1910
        except IOError:
 
1911
            logger.error(u"Could not write to file %r with PID %d",
 
1912
                         pidfilename, pid)
 
1913
        except NameError:
 
1914
            # "pidfile" was never created
 
1915
            pass
 
1916
        del pidfilename
 
1917
        
1868
1918
        signal.signal(signal.SIGINT, signal.SIG_IGN)
 
1919
 
1869
1920
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1870
1921
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1871
1922