core: allow building and running without udev

Instead of relying on the udev daemon and GUDev to manage the devices reported
by the kernel, we can now run ModemManager relying solely on the kernel events
reported via the new ReportKernelEvent() API. Therefore, the '--no-auto-scan'
option is implicit for the ModemManager daemon when udev is disabled in the
build.

Additionally, a new custom implementation of the kernel device object is
provided, which uses sysfs to load the properties and attributes required in
each kernel device, instead of using a GUdevDevice.

The udev rule files are kept in place, and a simple custom parser is provided
which preloads all rules in memory once and then applies them to the different
kernel objects reported via ReportKernelEvent(), e.g. to set port type hints.
A simple unit test setup is prepared to validate the udev rules during the
`check' Makefile target.

1 files changed, 446 insertions, 0 deletions

diff --git a/src/kerneldevice/mm-kernel-device-generic-rules.c b/src/kerneldevice/mm-kernel-device-generic-rules.c
new file mode 100644
index 00000000..608ca9f1
--- /dev/null
+++ b/src/kerneldevice/mm-kernel-device-generic-rules.c
@@ -0,0 +1,446 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2016 Aleksander Morgado <aleksander@aleksander.es>
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <ModemManager.h>
+#define _LIBMM_INSIDE_MM
+#include <libmm-glib.h>
+
+#include "mm-log.h"
+#include "mm-kernel-device-generic-rules.h"
+
+static void
+udev_rule_match_clear (MMUdevRuleMatch *rule_match)
+{
+    g_free (rule_match->parameter);
+    g_free (rule_match->value);
+}
+
+static void
+udev_rule_clear (MMUdevRule *rule)
+{
+    switch (rule->result.type) {
+    case MM_UDEV_RULE_RESULT_TYPE_PROPERTY:
+        g_free (rule->result.content.property.name);
+        g_free (rule->result.content.property.value);
+        break;
+    case MM_UDEV_RULE_RESULT_TYPE_GOTO_TAG:
+    case MM_UDEV_RULE_RESULT_TYPE_LABEL:
+        g_free (rule->result.content.tag);
+        break;
+    case MM_UDEV_RULE_RESULT_TYPE_GOTO_INDEX:
+    case MM_UDEV_RULE_RESULT_TYPE_UNKNOWN:
+        break;
+    }
+
+    if (rule->conditions)
+        g_array_unref (rule->conditions);
+}
+
+static gboolean
+split_item (const gchar  *item,
+            gchar       **out_left,
+            gchar       **out_operator,
+            gchar       **out_right,
+            GError      **error)
+{
+    const gchar *aux;
+    gchar       *left = NULL;
+    gchar       *operator = NULL;
+    gchar       *right = NULL;
+    GError      *inner_error = NULL;
+
+    g_assert (item && out_left && out_operator && out_right);
+
+    /* Get left/operator/right */
+    if (((aux = strstr (item, "==")) != NULL) || ((aux = strstr (item, "!=")) != NULL)) {
+        operator = g_strndup (aux, 2);
+        right    = g_strdup (aux + 2);
+    } else if ((aux = strstr (item, "=")) != NULL) {
+        operator = g_strndup (aux, 1);
+        right    = g_strdup (aux + 1);
+    } else {
+        inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
+                                   "Invalid rule item, missing operator: '%s'", item);
+        goto out;
+    }
+
+    left = g_strndup (item, (aux - item));
+    g_strstrip (left);
+    if (!left[0]) {
+        inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
+                                   "Invalid rule item, missing left field: '%s'", item);
+        goto out;
+    }
+
+    g_strdelimit (right, "\"", ' ');
+    g_strstrip (right);
+    if (!right[0]) {
+        inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
+                                   "Invalid rule item, missing right field: '%s'", item);
+        goto out;
+    }
+
+out:
+    if (inner_error) {
+        g_free (left);
+        g_free (operator);
+        g_free (right);
+        g_propagate_error (error, inner_error);
+        return FALSE;
+    }
+
+    *out_left     = left;
+    *out_operator = operator;
+    *out_right    = right;
+    return TRUE;
+}
+
+static gboolean
+load_rule_result (MMUdevRuleResult  *rule_result,
+                  const gchar       *item,
+                  GError           **error)
+{
+    gchar  *left;
+    gchar  *operator;
+    gchar  *right;
+    GError *inner_error = NULL;
+    gsize   left_len;
+
+    if (!split_item (item, &left, &operator, &right, error))
+        return FALSE;
+
+    if (!g_str_equal (operator, "=")) {
+        inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
+                                   "Invalid rule result operator: '%s'", item);
+        goto out;
+    }
+
+    if (g_str_equal (left, "LABEL")) {
+        rule_result->type = MM_UDEV_RULE_RESULT_TYPE_LABEL;
+        rule_result->content.tag = right;
+        right = NULL;
+        goto out;
+    }
+
+    if (g_str_equal (left, "GOTO")) {
+        rule_result->type = MM_UDEV_RULE_RESULT_TYPE_GOTO_TAG;
+        rule_result->content.tag = right;
+        right = NULL;
+        goto out;
+    }
+
+    left_len = strlen (left);
+    if (g_str_has_prefix (left, "ENV{") && left[left_len - 1] == '}') {
+        rule_result->type = MM_UDEV_RULE_RESULT_TYPE_PROPERTY;
+        rule_result->content.property.name = g_strndup (left + 4, left_len - 5);
+        rule_result->content.property.value = right;
+        right = NULL;
+        goto out;
+    }
+
+    g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
+                 "Invalid rule result parameter: '%s'", item);
+
+out:
+    g_free (left);
+    g_free (operator);
+    g_free (right);
+
+    if (inner_error) {
+        g_propagate_error (error, inner_error);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static gboolean
+load_rule_match (MMUdevRuleMatch  *rule_match,
+                 const gchar      *item,
+                 GError          **error)
+{
+    gchar  *left;
+    gchar  *operator;
+    gchar  *right;
+
+    if (!split_item (item, &left, &operator, &right, error))
+        return FALSE;
+
+    if (g_str_equal (operator, "=="))
+        rule_match->type = MM_UDEV_RULE_MATCH_TYPE_EQUAL;
+    else if (g_str_equal (operator, "!="))
+        rule_match->type = MM_UDEV_RULE_MATCH_TYPE_NOT_EQUAL;
+    else {
+        g_free (left);
+        g_free (operator);
+        g_free (right);
+        g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
+                     "Invalid rule match, wrong match type: '%s'", item);
+
+        return FALSE;
+    }
+
+    g_free (operator);
+    rule_match->parameter = left;
+    rule_match->value     = right;
+    return TRUE;
+}
+
+static gboolean
+load_rule_from_line (MMUdevRule   *rule,
+                     const gchar  *line,
+                     GError      **error)
+{
+    gchar  **split;
+    guint    n_items;
+    GError  *inner_error = NULL;
+
+    split = g_strsplit (line, ",", -1);
+    n_items = g_strv_length (split);
+
+    /* Conditions */
+    if (n_items > 1) {
+        guint i;
+
+        rule->conditions = g_array_sized_new (FALSE, FALSE, sizeof (MMUdevRuleMatch), n_items - 1);
+        g_array_set_clear_func (rule->conditions, (GDestroyNotify) udev_rule_match_clear);
+
+        /* All items except for the last one are conditions */
+        for (i = 0; !inner_error && i < (n_items - 1); i++) {
+            MMUdevRuleMatch rule_match = { 0 };
+
+            /* If condition correctly preloaded, add it to the rule */
+            if (!load_rule_match (&rule_match, split[i], &inner_error))
+                goto out;
+            g_assert (rule_match.type != MM_UDEV_RULE_MATCH_TYPE_UNKNOWN);
+            g_assert (rule_match.parameter);
+            g_assert (rule_match.value);
+            g_array_append_val (rule->conditions, rule_match);
+        }
+    }
+
+    /* Last item, the result */
+    if (!load_rule_result (&rule->result, split[n_items - 1], &inner_error))
+        goto out;
+
+    g_assert ((rule->result.type == MM_UDEV_RULE_RESULT_TYPE_GOTO_TAG && rule->result.content.tag) ||
+              (rule->result.type == MM_UDEV_RULE_RESULT_TYPE_LABEL && rule->result.content.tag) ||
+              (rule->result.type == MM_UDEV_RULE_RESULT_TYPE_PROPERTY && rule->result.content.property.name && rule->result.content.property.value));
+
+out:
+    g_strfreev (split);
+
+    if (inner_error) {
+        g_propagate_error (error, inner_error);
+        return FALSE;
+    }
+    return TRUE;
+}
+
+static gboolean
+process_goto_tags (GArray  *rules,
+                   guint    first_rule_index,
+                   GError **error)
+{
+    guint i;
+
+    for (i = first_rule_index; i < rules->len; i++) {
+        MMUdevRule *rule;
+
+        rule = &g_array_index (rules, MMUdevRule, i);
+        if (rule->result.type == MM_UDEV_RULE_RESULT_TYPE_GOTO_TAG) {
+            guint j;
+            guint label_index = 0;
+
+            for (j = i + 1; j < rules->len; j++) {
+                MMUdevRule *walker;
+
+                walker = &g_array_index (rules, MMUdevRule, j);
+                if (walker->result.type == MM_UDEV_RULE_RESULT_TYPE_LABEL &&
+                    g_str_equal (rule->result.content.tag, walker->result.content.tag)) {
+
+                    if (label_index) {
+                        g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
+                                     "More than one label '%s' found", rule->result.content.tag);
+                        return FALSE;
+                    }
+
+                    label_index = j;
+                }
+            }
+
+            if (!label_index) {
+                g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
+                             "Couldn't find label '%s'", rule->result.content.tag);
+                return FALSE;
+            }
+
+            rule->result.type = MM_UDEV_RULE_RESULT_TYPE_GOTO_INDEX;
+            g_free (rule->result.content.tag);
+            rule->result.content.index = label_index;
+        }
+    }
+
+    return TRUE;
+}
+
+static gboolean
+load_rules_from_file (GArray       *rules,
+                      const gchar  *path,
+                      GError      **error)
+{
+    GFile            *file;
+    GFileInputStream *fistream;
+    GDataInputStream *distream = NULL;
+    GError           *inner_error = NULL;
+    gchar            *line;
+    guint             first_rule_index;
+
+    mm_dbg ("[rules] loading rules from: %s", path);
+    first_rule_index = rules->len;
+
+    file = g_file_new_for_path (path);
+    fistream = g_file_read (file, NULL, &inner_error);
+    if (!fistream)
+        goto out;
+
+    distream = g_data_input_stream_new (G_INPUT_STREAM (fistream));
+
+    while (((line = g_data_input_stream_read_line_utf8 (distream, NULL, NULL, &inner_error)) != NULL) && !inner_error) {
+        const gchar *aux;
+
+        aux = line;
+        while (*aux == ' ')
+            aux++;
+        if (*aux != '#' && *aux != '\0') {
+            MMUdevRule rule = { 0 };
+
+            if (load_rule_from_line (&rule, aux, &inner_error))
+                g_array_append_val (rules, rule);
+            else
+                udev_rule_clear (&rule);
+        }
+        g_free (line);
+    }
+
+out:
+
+    if (distream)
+        g_object_unref (distream);
+    if (fistream)
+        g_object_unref (fistream);
+    g_object_unref (file);
+
+    if (inner_error) {
+        g_propagate_error (error, inner_error);
+        return FALSE;
+    }
+
+    if (first_rule_index < rules->len && !process_goto_tags (rules, first_rule_index, error))
+        return FALSE;
+
+    return TRUE;
+}
+
+static GList *
+list_rule_files (const gchar *rules_dir_path)
+{
+    static const gchar *expected_rules_prefix[] = { "77-mm-", "78-mm-", "79-mm-", "80-mm-" };
+    GFile              *udevrulesdir;
+    GFileEnumerator    *enumerator;
+    GList              *children = NULL;
+
+    udevrulesdir = g_file_new_for_path (rules_dir_path);
+    enumerator   = g_file_enumerate_children (udevrulesdir,
+                                              G_FILE_ATTRIBUTE_STANDARD_NAME,
+                                              G_FILE_QUERY_INFO_NONE,
+                                              NULL,
+                                              NULL);
+    if (enumerator) {
+        GFileInfo *info;
+
+        /* If we get any kind of error, assume we need to stop enumerating */
+        while ((info = g_file_enumerator_next_file (enumerator, NULL, NULL)) != NULL) {
+            guint i;
+
+            for (i = 0; i < G_N_ELEMENTS (expected_rules_prefix); i++) {
+                if (g_str_has_prefix (g_file_info_get_name (info), expected_rules_prefix[i])) {
+                    children = g_list_prepend (children, g_build_path (G_DIR_SEPARATOR_S, rules_dir_path, g_file_info_get_name (info), NULL));
+                    break;
+                }
+            }
+            g_object_unref (info);
+        }
+        g_object_unref (enumerator);
+    }
+    g_object_unref (udevrulesdir);
+
+    return g_list_sort (children, (GCompareFunc) g_strcmp0);
+}
+
+GArray *
+mm_kernel_device_generic_rules_load (const gchar  *rules_dir,
+                                     GError      **error)
+{
+    GList  *rule_files, *l;
+    GArray *rules;
+    GError *inner_error = NULL;
+
+    mm_dbg ("[rules] rules directory set to '%s'...", rules_dir);
+
+    rules = g_array_new (FALSE, FALSE, sizeof (MMUdevRule));
+    g_array_set_clear_func (rules, (GDestroyNotify) udev_rule_clear);
+
+    /* List rule files in rules dir */
+    rule_files = list_rule_files (rules_dir);
+    if (!rule_files) {
+        inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
+                                   "No rule files found in '%s'", rules_dir);
+        goto out;
+    }
+
+    /* Iterate over rule files */
+    for (l = rule_files; l; l = g_list_next (l)) {
+        if (!load_rules_from_file (rules, (const gchar *)(l->data), &inner_error))
+            goto out;
+    }
+
+    /* Fail if no rules were loaded */
+    if (rules->len == 0) {
+        inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "No rules loaded");
+        goto out;
+    }
+
+    mm_dbg ("[rules] %u loaded", rules->len);
+
+out:
+    if (rule_files)
+        g_list_free_full (rule_files, (GDestroyNotify) g_free);
+
+    if (inner_error) {
+        g_propagate_error (error, inner_error);
+        g_array_unref (rules);
+        return NULL;
+    }
+
+    return rules;
+}