/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

* debian/control (Standards-Version): Upgraded to "3.9.2".
  (DM-Upload-Allowed): New; set to "yes".

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