/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: 2014-08-09 13:12:55 UTC
  • Revision ID: teddy@recompile.se-20140809131255-lp31j98u2pl0xpe6
mandos: Stop using str() and remove unnecessary unicode() calls.

* mandos (if_nametoindex): Use "bytes" literal instead of str().
  (initlogger): Use a unicode string for log device.
  (AvahiError.__unicode__): Removed.
  (DBusPropertyException.__unicode__): - '' -
  (ClientDBus.Secret_dbus_property): Use bytes() instead of str().
  (IPv6_TCPServer.server_bind): Use .encode() instead of str().
  (string_to_delta): Removed unnecessary unicode() call.
  (main): Use "isinstance(x, bytes)" instead of "type(x) is str", use
          .decode() instead of unicode(), and use .encode() instead of
          str().

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
88
88
    except ImportError:
89
89
        SO_BINDTODEVICE = None
90
90
 
91
 
if sys.version_info.major == 2:
92
 
    str = unicode
93
 
 
94
 
version = "1.6.9"
 
91
version = "1.6.8"
95
92
stored_state_file = "clients.pickle"
96
93
 
97
94
logger = logging.getLogger()
275
272
        self.bus = bus
276
273
        self.entry_group_state_changed_match = None
277
274
    
278
 
    def rename(self, remove=True):
 
275
    def rename(self):
279
276
        """Derived from the Avahi example code"""
280
277
        if self.rename_count >= self.max_renames:
281
278
            logger.critical("No suitable Zeroconf service name found"
282
279
                            " after %i retries, exiting.",
283
280
                            self.rename_count)
284
281
            raise AvahiServiceError("Too many renames")
285
 
        self.name = str(self.server
286
 
                        .GetAlternativeServiceName(self.name))
287
 
        self.rename_count += 1
 
282
        self.name = unicode(self.server
 
283
                            .GetAlternativeServiceName(self.name))
288
284
        logger.info("Changing Zeroconf service name to %r ...",
289
285
                    self.name)
290
 
        if remove:
291
 
            self.remove()
 
286
        self.remove()
292
287
        try:
293
288
            self.add()
294
289
        except dbus.exceptions.DBusException as error:
295
 
            if (error.get_dbus_name()
296
 
                == "org.freedesktop.Avahi.CollisionError"):
297
 
                logger.info("Local Zeroconf service name collision.")
298
 
                return self.rename(remove=False)
299
 
            else:
300
 
                logger.critical("D-Bus Exception", exc_info=error)
301
 
                self.cleanup()
302
 
                os._exit(1)
 
290
            logger.critical("D-Bus Exception", exc_info=error)
 
291
            self.cleanup()
 
292
            os._exit(1)
 
293
        self.rename_count += 1
303
294
    
304
295
    def remove(self):
305
296
        """Derived from the Avahi example code"""
343
334
            self.rename()
344
335
        elif state == avahi.ENTRY_GROUP_FAILURE:
345
336
            logger.critical("Avahi: Error in group state changed %s",
346
 
                            str(error))
 
337
                            unicode(error))
347
338
            raise AvahiGroupError("State changed: {!s}"
348
339
                                  .format(error))
349
340
    
397
388
 
398
389
 
399
390
class AvahiServiceToSyslog(AvahiService):
400
 
    def rename(self, *args, **kwargs):
 
391
    def rename(self):
401
392
        """Add the new name to the syslog messages"""
402
 
        ret = AvahiService.rename(self, *args, **kwargs)
 
393
        ret = AvahiService.rename(self)
403
394
        syslogger.setFormatter(logging.Formatter
404
395
                               ('Mandos ({}) [%(process)d]:'
405
396
                                ' %(levelname)s: %(message)s'
694
685
        if self.checker is None:
695
686
            # Escape attributes for the shell
696
687
            escaped_attrs = { attr:
697
 
                                  re.escape(str(getattr(self, attr)))
 
688
                                  re.escape(unicode(getattr(self,
 
689
                                                            attr)))
698
690
                              for attr in self.runtime_expansions }
699
691
            try:
700
692
                command = self.checker_command % escaped_attrs
819
811
    """Decorator to annotate D-Bus methods, signals or properties
820
812
    Usage:
821
813
    
822
 
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
823
 
                       "org.freedesktop.DBus.Property."
824
 
                       "EmitsChangedSignal": "false"})
825
814
    @dbus_service_property("org.example.Interface", signature="b",
826
815
                           access="r")
 
816
    @dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
 
817
                        "org.freedesktop.DBus.Property."
 
818
                        "EmitsChangedSignal": "false"})
827
819
    def Property_dbus_property(self):
828
820
        return dbus.Boolean(False)
829
821
    """
952
944
                                           value.variant_level+1)
953
945
        return dbus.Dictionary(properties, signature="sv")
954
946
    
955
 
    @dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
956
 
    def PropertiesChanged(self, interface_name, changed_properties,
957
 
                          invalidated_properties):
958
 
        """Standard D-Bus PropertiesChanged() signal, see D-Bus
959
 
        standard.
960
 
        """
961
 
        pass
962
 
    
963
947
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
964
948
                         out_signature="s",
965
949
                         path_keyword='object_path',
1232
1216
    runtime_expansions = (Client.runtime_expansions
1233
1217
                          + ("dbus_object_path",))
1234
1218
    
1235
 
    _interface = "se.recompile.Mandos.Client"
1236
 
    
1237
1219
    # dbus.service.Object doesn't use super(), so we can't either.
1238
1220
    
1239
1221
    def __init__(self, bus = None, *args, **kwargs):
1241
1223
        Client.__init__(self, *args, **kwargs)
1242
1224
        # Only now, when this client is initialized, can it show up on
1243
1225
        # the D-Bus
1244
 
        client_object_name = str(self.name).translate(
 
1226
        client_object_name = unicode(self.name).translate(
1245
1227
            {ord("."): ord("_"),
1246
1228
             ord("-"): ord("_")})
1247
1229
        self.dbus_object_path = (dbus.ObjectPath
1251
1233
    
1252
1234
    def notifychangeproperty(transform_func,
1253
1235
                             dbus_name, type_func=lambda x: x,
1254
 
                             variant_level=1, invalidate_only=False,
1255
 
                             _interface=_interface):
 
1236
                             variant_level=1):
1256
1237
        """ Modify a variable so that it's a property which announces
1257
1238
        its changes to DBus.
1258
1239
        
1269
1250
                if (not hasattr(self, attrname) or
1270
1251
                    type_func(getattr(self, attrname, None))
1271
1252
                    != type_func(value)):
1272
 
                    if invalidate_only:
1273
 
                        self.PropertiesChanged(_interface,
1274
 
                                               dbus.Dictionary(),
1275
 
                                               dbus.Array
1276
 
                                               ((dbus_name,)))
1277
 
                    else:
1278
 
                        dbus_value = transform_func(type_func(value),
1279
 
                                                    variant_level
1280
 
                                                    =variant_level)
1281
 
                        self.PropertyChanged(dbus.String(dbus_name),
1282
 
                                             dbus_value)
1283
 
                        self.PropertiesChanged(_interface,
1284
 
                                               dbus.Dictionary({
1285
 
                                    dbus.String(dbus_name):
1286
 
                                        dbus_value }), dbus.Array())
 
1253
                    dbus_value = transform_func(type_func(value),
 
1254
                                                variant_level
 
1255
                                                =variant_level)
 
1256
                    self.PropertyChanged(dbus.String(dbus_name),
 
1257
                                         dbus_value)
1287
1258
            setattr(self, attrname, value)
1288
1259
        
1289
1260
        return property(lambda self: getattr(self, attrname), setter)
1327
1298
                                    lambda td: td.total_seconds()
1328
1299
                                    * 1000)
1329
1300
    checker_command = notifychangeproperty(dbus.String, "Checker")
1330
 
    secret = notifychangeproperty(dbus.ByteArray, "Secret",
1331
 
                                  invalidate_only=True)
1332
1301
    
1333
1302
    del notifychangeproperty
1334
1303
    
1381
1350
        self.send_changedstate()
1382
1351
    
1383
1352
    ## D-Bus methods, signals & properties
 
1353
    _interface = "se.recompile.Mandos.Client"
1384
1354
    
1385
1355
    ## Interfaces
1386
1356
    
 
1357
    @dbus_interface_annotations(_interface)
 
1358
    def _foo(self):
 
1359
        return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
 
1360
                     "false"}
 
1361
    
1387
1362
    ## Signals
1388
1363
    
1389
1364
    # CheckerCompleted - signal
1399
1374
        pass
1400
1375
    
1401
1376
    # PropertyChanged - signal
1402
 
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1403
1377
    @dbus.service.signal(_interface, signature="sv")
1404
1378
    def PropertyChanged(self, property, value):
1405
1379
        "D-Bus signal"
1510
1484
    def Host_dbus_property(self, value=None):
1511
1485
        if value is None:       # get
1512
1486
            return dbus.String(self.host)
1513
 
        self.host = str(value)
 
1487
        self.host = unicode(value)
1514
1488
    
1515
1489
    # Created - property
1516
1490
    @dbus_service_property(_interface, signature="s", access="read")
1614
1588
    def Checker_dbus_property(self, value=None):
1615
1589
        if value is None:       # get
1616
1590
            return dbus.String(self.checker_command)
1617
 
        self.checker_command = str(value)
 
1591
        self.checker_command = unicode(value)
1618
1592
    
1619
1593
    # CheckerRunning - property
1620
1594
    @dbus_service_property(_interface, signature="b",
1676
1650
    def handle(self):
1677
1651
        with contextlib.closing(self.server.child_pipe) as child_pipe:
1678
1652
            logger.info("TCP connection from: %s",
1679
 
                        str(self.client_address))
 
1653
                        unicode(self.client_address))
1680
1654
            logger.debug("Pipe FD: %d",
1681
1655
                         self.server.child_pipe.fileno())
1682
1656
            
2733
2707
            def GetAllClientsWithProperties(self):
2734
2708
                "D-Bus method"
2735
2709
                return dbus.Dictionary(
2736
 
                    { c.dbus_object_path: c.GetAll("")
2737
 
                      for c in tcp_server.clients.itervalues() },
 
2710
                    ((c.dbus_object_path, c.GetAll(""))
 
2711
                     for c in tcp_server.clients.itervalues()),
2738
2712
                    signature="oa{sv}")
2739
2713
            
2740
2714
            @dbus.service.method(_interface, in_signature="o")