Do not print invalid UTF-8 in error messages

[elogind.git] / src / shared / net-util.c

diff --git a/src/shared/net-util.c b/src/shared/net-util.c
index 8f8cfc9fdb6d7fe6ece6b9ede732c13a85ec4d95..50cfa2c3f3a5a791f903859167523ebda43da131 100644 (file)
--- a/src/shared/net-util.c
+++ b/src/shared/net-util.c
@@ -22,42 +22,112 @@
 #include <netinet/ether.h>
 #include <linux/if.h>
 #include <arpa/inet.h>
+#include <fnmatch.h>
 
 #include "net-util.h"
 #include "log.h"
 #include "utf8.h"
 #include "util.h"
 #include "conf-parser.h"
+#include "condition.h"
 
 bool net_match_config(const struct ether_addr *match_mac,
                       const char *match_path,
                       const char *match_driver,
                       const char *match_type,
                       const char *match_name,
+                      Condition *match_host,
+                      Condition *match_virt,
+                      Condition *match_kernel,
+                      Condition *match_arch,
                       const char *dev_mac,
                       const char *dev_path,
+                      const char *dev_parent_driver,
                       const char *dev_driver,
                       const char *dev_type,
                       const char *dev_name) {
 
-        if (match_mac && (!dev_mac || memcmp(match_mac, ether_aton(dev_mac), ETH_ALEN)))
+        if (match_host && !condition_test_host(match_host))
+                return 0;
+
+        if (match_virt && !condition_test_virtualization(match_virt))
+                return 0;
+
+        if (match_kernel && !condition_test_kernel_command_line(match_kernel))
+                return 0;
+
+        if (match_arch && !condition_test_architecture(match_arch))
                 return 0;
 
-        if (match_path && !streq_ptr(match_path, dev_path))
+        if (match_mac && (!dev_mac || memcmp(match_mac, ether_aton(dev_mac), ETH_ALEN)))
                 return 0;
 
-        if (match_driver && !streq_ptr(match_driver, dev_driver))
+        if (match_path && (!dev_path || fnmatch(match_path, dev_path, 0)))
                 return 0;
 
+        if (match_driver) {
+                if (dev_parent_driver && !streq(match_driver, dev_parent_driver))
+                        return 0;
+                else if (!streq_ptr(match_driver, dev_driver))
+                        return 0;
+        }
+
         if (match_type && !streq_ptr(match_type, dev_type))
                 return 0;
 
-        if (match_name && !streq_ptr(match_name, dev_name))
+        if (match_name && (!dev_name || fnmatch(match_name, dev_name, 0)))
                 return 0;
 
         return 1;
 }
 
+unsigned net_netmask_to_prefixlen(const struct in_addr *addr) {
+        assert(addr);
+
+        return 32 - u32ctz(be32toh(addr->s_addr));
+}
+
+int config_parse_net_condition(const char *unit,
+                               const char *filename,
+                               unsigned line,
+                               const char *section,
+                               unsigned section_line,
+                               const char *lvalue,
+                               int ltype,
+                               const char *rvalue,
+                               void *data,
+                               void *userdata) {
+
+        ConditionType cond = ltype;
+        Condition **ret = data;
+        bool negate;
+        Condition *c;
+        _cleanup_free_ char *s = NULL;
+
+        assert(filename);
+        assert(lvalue);
+        assert(rvalue);
+        assert(data);
+
+        negate = rvalue[0] == '!';
+        if (negate)
+                rvalue++;
+
+        s = strdup(rvalue);
+        if (!s)
+                return log_oom();
+
+        c = condition_new(cond, s, false, negate);
+        if (!c)
+                return log_oom();
+
+        if (*ret)
+                condition_free(*ret);
+
+        *ret = c;
+        return 0;
+}
+
 int config_parse_ifname(const char *unit,
                         const char *filename,
                         unsigned line,
@@ -192,16 +262,24 @@ int net_parse_inaddr(const char *address, unsigned char *family, void *dst) {
 
         /* IPv4 */
         r = inet_pton(AF_INET, address, dst);
-        if (r > 0)
-                *family = AF_INET; /* successfully parsed IPv4 address */
-        else  if (r < 0)
+        if (r > 0) {
+                /* succsefully parsed IPv4 address */
+                if (*family == AF_UNSPEC)
+                        *family = AF_INET;
+                else if (*family != AF_INET)
+                        return -EINVAL;
+        } else  if (r < 0)
                 return -errno;
         else {
                 /* not an IPv4 address, so let's try IPv6 */
                 r = inet_pton(AF_INET6, address, dst);
-                if (r > 0)
-                        *family = AF_INET6; /* successfully parsed IPv6 address */
-                else if (r < 0)
+                if (r > 0) {
+                        /* successfully parsed IPv6 address */
+                        if (*family == AF_UNSPEC)
+                                *family = AF_INET6;
+                        else if (*family != AF_INET6)
+                                return -EINVAL;
+                } else if (r < 0)
                         return -errno;
                 else
                         return -EINVAL;