/mandos/release

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

« back to all changes in this revision

Viewing changes to mandos

* initramfs-tools-hook: Set DEVICE for network hooks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
83
83
        SO_BINDTODEVICE = None
84
84
 
85
85
 
86
 
version = "1.3.1"
 
86
version = "1.4.1"
87
87
 
88
88
#logger = logging.getLogger('mandos')
89
89
logger = logging.Logger('mandos')
464
464
        if timeout is None:
465
465
            timeout = self.timeout
466
466
        self.last_checked_ok = datetime.datetime.utcnow()
467
 
        gobject.source_remove(self.disable_initiator_tag)
468
 
        self.expires = datetime.datetime.utcnow() + timeout
469
 
        self.disable_initiator_tag = (gobject.timeout_add
470
 
                                      (_timedelta_to_milliseconds
471
 
                                       (timeout), self.disable))
 
467
        if self.disable_initiator_tag is not None:
 
468
            gobject.source_remove(self.disable_initiator_tag)
 
469
        if getattr(self, "enabled", False):
 
470
            self.disable_initiator_tag = (gobject.timeout_add
 
471
                                          (_timedelta_to_milliseconds
 
472
                                           (timeout), self.disable))
 
473
            self.expires = datetime.datetime.utcnow() + timeout
472
474
    
473
475
    def need_approval(self):
474
476
        self.last_approval_request = datetime.datetime.utcnow()
891
893
        """ Modify a variable so that it's a property which announces
892
894
        its changes to DBus.
893
895
 
894
 
        transform_fun: Function that takes a value and transforms it
895
 
                       to a D-Bus type.
 
896
        transform_fun: Function that takes a value and a variant_level
 
897
                       and transforms it to a D-Bus type.
896
898
        dbus_name: D-Bus name of the variable
897
899
        type_func: Function that transform the value before sending it
898
900
                   to the D-Bus.  Default: no transform
899
901
        variant_level: D-Bus variant level.  Default: 1
900
902
        """
901
 
        real_value = [None,]
 
903
        attrname = "_{0}".format(dbus_name)
902
904
        def setter(self, value):
903
 
            old_value = real_value[0]
904
 
            real_value[0] = value
905
905
            if hasattr(self, "dbus_object_path"):
906
 
                if type_func(old_value) != type_func(real_value[0]):
907
 
                    dbus_value = transform_func(type_func
908
 
                                                (real_value[0]),
909
 
                                                variant_level)
 
906
                if (not hasattr(self, attrname) or
 
907
                    type_func(getattr(self, attrname, None))
 
908
                    != type_func(value)):
 
909
                    dbus_value = transform_func(type_func(value),
 
910
                                                variant_level
 
911
                                                =variant_level)
910
912
                    self.PropertyChanged(dbus.String(dbus_name),
911
913
                                         dbus_value)
 
914
            setattr(self, attrname, value)
912
915
        
913
 
        return property(lambda self: real_value[0], setter)
 
916
        return property(lambda self: getattr(self, attrname), setter)
914
917
    
915
918
    
916
919
    expires = notifychangeproperty(datetime_to_dbus, "Expires")
1187
1190
        gobject.source_remove(self.disable_initiator_tag)
1188
1191
        self.disable_initiator_tag = None
1189
1192
        self.expires = None
1190
 
        time_to_die = (self.
1191
 
                       _timedelta_to_milliseconds((self
1192
 
                                                   .last_checked_ok
1193
 
                                                   + self.timeout)
1194
 
                                                  - datetime.datetime
1195
 
                                                  .utcnow()))
 
1193
        time_to_die = _timedelta_to_milliseconds((self
 
1194
                                                  .last_checked_ok
 
1195
                                                  + self.timeout)
 
1196
                                                 - datetime.datetime
 
1197
                                                 .utcnow())
1196
1198
        if time_to_die <= 0:
1197
1199
            # The timeout has passed
1198
1200
            self.disable()
1394
1396
                        return
1395
1397
                    
1396
1398
                    #wait until timeout or approved
1397
 
                    #x = float(client
1398
 
                    #          ._timedelta_to_milliseconds(delay))
1399
1399
                    time = datetime.datetime.now()
1400
1400
                    client.changedstate.acquire()
1401
1401
                    (client.changedstate.wait
1430
1430
                    sent_size += sent
1431
1431
                
1432
1432
                logger.info("Sending secret to %s", client.name)
1433
 
                # bump the timeout as if seen
 
1433
                # bump the timeout using extended_timeout
1434
1434
                client.checked_ok(client.extended_timeout)
1435
1435
                if self.server.use_dbus:
1436
1436
                    # Emit D-Bus signal
1516
1516
        except:
1517
1517
            self.handle_error(request, address)
1518
1518
        self.close_request(request)
1519
 
            
 
1519
    
1520
1520
    def process_request(self, request, address):
1521
1521
        """Start a new process to process the request."""
1522
 
        multiprocessing.Process(target = self.sub_process_main,
1523
 
                                args = (request, address)).start()
 
1522
        proc = multiprocessing.Process(target = self.sub_process_main,
 
1523
                                       args = (request,
 
1524
                                               address))
 
1525
        proc.start()
 
1526
        return proc
1524
1527
 
1525
1528
 
1526
1529
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1532
1535
        """
1533
1536
        parent_pipe, self.child_pipe = multiprocessing.Pipe()
1534
1537
        
1535
 
        super(MultiprocessingMixInWithPipe,
1536
 
              self).process_request(request, client_address)
 
1538
        proc = MultiprocessingMixIn.process_request(self, request,
 
1539
                                                    client_address)
1537
1540
        self.child_pipe.close()
1538
 
        self.add_pipe(parent_pipe)
 
1541
        self.add_pipe(parent_pipe, proc)
1539
1542
    
1540
 
    def add_pipe(self, parent_pipe):
 
1543
    def add_pipe(self, parent_pipe, proc):
1541
1544
        """Dummy function; override as necessary"""
1542
1545
        raise NotImplementedError
1543
1546
 
1631
1634
    def server_activate(self):
1632
1635
        if self.enabled:
1633
1636
            return socketserver.TCPServer.server_activate(self)
 
1637
    
1634
1638
    def enable(self):
1635
1639
        self.enabled = True
1636
 
    def add_pipe(self, parent_pipe):
 
1640
    
 
1641
    def add_pipe(self, parent_pipe, proc):
1637
1642
        # Call "handle_ipc" for both data and EOF events
1638
1643
        gobject.io_add_watch(parent_pipe.fileno(),
1639
1644
                             gobject.IO_IN | gobject.IO_HUP,
1640
1645
                             functools.partial(self.handle_ipc,
1641
1646
                                               parent_pipe =
1642
 
                                               parent_pipe))
1643
 
        
 
1647
                                               parent_pipe,
 
1648
                                               proc = proc))
 
1649
    
1644
1650
    def handle_ipc(self, source, condition, parent_pipe=None,
1645
 
                   client_object=None):
 
1651
                   proc = None, client_object=None):
1646
1652
        condition_names = {
1647
1653
            gobject.IO_IN: "IN",   # There is data to read.
1648
1654
            gobject.IO_OUT: "OUT", # Data can be written (without
1657
1663
                                       for cond, name in
1658
1664
                                       condition_names.iteritems()
1659
1665
                                       if cond & condition)
1660
 
        # error or the other end of multiprocessing.Pipe has closed
 
1666
        # error, or the other end of multiprocessing.Pipe has closed
1661
1667
        if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
 
1668
            # Wait for other process to exit
 
1669
            proc.join()
1662
1670
            return False
1663
1671
        
1664
1672
        # Read a request from the child
1688
1696
                                 functools.partial(self.handle_ipc,
1689
1697
                                                   parent_pipe =
1690
1698
                                                   parent_pipe,
 
1699
                                                   proc = proc,
1691
1700
                                                   client_object =
1692
1701
                                                   client))
1693
1702
            parent_pipe.send(True)
2129
2138
        "Cleanup function; run on exit"
2130
2139
        service.cleanup()
2131
2140
        
 
2141
        multiprocessing.active_children()
2132
2142
        while tcp_server.clients:
2133
2143
            client = tcp_server.clients.pop()
2134
2144
            if use_dbus: