sbus: use hard coded getters instead of generated

Properties are single value of a small number of predefined D-Bus
types. There is no need to generate them with codegen. Actually,
the source generator for property getters is already quite mess
with branching for array, strings and object paths. Adding any
more complex type in the future (such as dictionary) would require
even more branching or creating a separate path for it.

Hard coding the getters will simplify creating new ones for more
complex types. This patch also reduces lots of code duplication
and creates a simple function for GetAll.

Reviewed-by: Jakub Hrozek <jhrozek@redhat.com>

1 files changed, 465 insertions, 0 deletions

diff --git a/src/sbus/sssd_dbus_invokers.c b/src/sbus/sssd_dbus_invokers.c
new file mode 100644
index 000000000..df9104f63
--- /dev/null
+++ b/src/sbus/sssd_dbus_invokers.c
@@ -0,0 +1,465 @@
+/*
+    Authors:
+        Pavel Březina <pbrezina@redhat.com>
+
+    Copyright (C) 2014 Red Hat
+
+    SBUS: Interface introspection
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "config.h"
+
+#include <dbus/dbus.h>
+#include <errno.h>
+
+#include "util/util.h"
+#include "sbus/sssd_dbus.h"
+#include "sbus/sssd_dbus_meta.h"
+#include "sbus/sssd_dbus_private.h"
+#include "sbus/sssd_dbus_invokers.h"
+
+static int
+sbus_invoke_get_basic(struct sbus_request *sbus_req,
+                      void *function_ptr,
+                      void *value_ptr,
+                      int dbus_type,
+                      DBusMessageIter *iter)
+{
+    void (*handler_fn)(struct sbus_request *, void *, void *);
+    dbus_bool_t value_bool;
+    dbus_bool_t dbret;
+
+    handler_fn = function_ptr;
+    handler_fn(sbus_req, sbus_req->intf->handler_data, value_ptr);
+
+    if (dbus_type == DBUS_TYPE_BOOLEAN) {
+        /* Special case to convert bool into dbus_bool_t. */
+        value_bool = *((bool *) value_ptr);
+        value_ptr = &value_bool;
+    }
+
+    dbret = dbus_message_iter_append_basic(iter, dbus_type, value_ptr);
+    return dbret ? EOK : EIO;
+}
+
+static int
+sbus_invoke_get_string(struct sbus_request *sbus_req,
+                       void *function_ptr,
+                       const char *default_value,
+                       int dbus_type,
+                       DBusMessageIter *iter)
+{
+    void (*handler_fn)(struct sbus_request *, void *, const char **);
+    const char *value = NULL;
+    dbus_bool_t dbret;
+
+    handler_fn = function_ptr;
+    handler_fn(sbus_req, sbus_req->intf->handler_data, &value);
+
+    value = value == NULL ? default_value : value;
+
+    dbret = dbus_message_iter_append_basic(iter, dbus_type, &value);
+    return dbret ? EOK : EIO;
+}
+
+static int
+sbus_invoke_get_array(struct sbus_request *sbus_req,
+                      void *function_ptr,
+                      unsigned int item_size,
+                      int dbus_type,
+                      DBusMessageIter *iter)
+{
+    void (*handler_fn)(struct sbus_request *, void *, void *, int *);
+    const char array_type[2] = {dbus_type, '\0'};
+    DBusMessageIter array;
+    dbus_bool_t dbret;
+    uint8_t *values;
+    void *addr;
+    int num_values;
+    int i;
+
+    handler_fn = function_ptr;
+    handler_fn(sbus_req, sbus_req->intf->handler_data, &values, &num_values);
+
+    dbret = dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+                                             array_type, &array);
+    if (!dbret) {
+        return EIO;
+    }
+
+    for (i = 0; i < num_values; i++) {
+        addr = values + i * item_size;
+
+        dbret = dbus_message_iter_append_basic(&array, dbus_type, addr);
+        if (!dbret) {
+            return ENOMEM;
+        }
+    }
+
+    dbret = dbus_message_iter_close_container(iter, &array);
+    if (!dbret) {
+        return EIO;
+    }
+
+    return EOK;
+}
+
+int sbus_invoke_get_y(DBusMessageIter *iter,
+                      struct sbus_request *sbus_req,
+                      void *function_ptr)
+{
+    uint8_t value;
+
+    return sbus_invoke_get_basic(sbus_req, function_ptr, &value,
+                                 DBUS_TYPE_BYTE, iter);
+}
+
+int sbus_invoke_get_b(DBusMessageIter *iter,
+                      struct sbus_request *sbus_req,
+                      void *function_ptr)
+{
+    bool value;
+
+    return sbus_invoke_get_basic(sbus_req, function_ptr, &value,
+                                 DBUS_TYPE_BOOLEAN, iter);
+}
+
+int sbus_invoke_get_n(DBusMessageIter *iter,
+                      struct sbus_request *sbus_req,
+                      void *function_ptr)
+{
+    int16_t value;
+
+    return sbus_invoke_get_basic(sbus_req, function_ptr, &value,
+                                 DBUS_TYPE_INT16, iter);
+}
+
+int sbus_invoke_get_q(DBusMessageIter *iter,
+                      struct sbus_request *sbus_req,
+                      void *function_ptr)
+{
+    uint16_t value;
+
+    return sbus_invoke_get_basic(sbus_req, function_ptr, &value,
+                                 DBUS_TYPE_UINT16, iter);
+}
+
+int sbus_invoke_get_i(DBusMessageIter *iter,
+                      struct sbus_request *sbus_req,
+                      void *function_ptr)
+{
+    int32_t value;
+
+    return sbus_invoke_get_basic(sbus_req, function_ptr, &value,
+                                 DBUS_TYPE_INT32, iter);
+}
+
+int sbus_invoke_get_u(DBusMessageIter *iter,
+                      struct sbus_request *sbus_req,
+                      void *function_ptr)
+{
+    uint32_t value;
+
+    return sbus_invoke_get_basic(sbus_req, function_ptr, &value,
+                                 DBUS_TYPE_UINT32, iter);
+}
+
+int sbus_invoke_get_x(DBusMessageIter *iter,
+                      struct sbus_request *sbus_req,
+                      void *function_ptr)
+{
+    int64_t value;
+
+    return sbus_invoke_get_basic(sbus_req, function_ptr, &value,
+                                 DBUS_TYPE_INT64, iter);
+}
+
+int sbus_invoke_get_t(DBusMessageIter *iter,
+                      struct sbus_request *sbus_req,
+                      void *function_ptr)
+{
+    uint64_t value;
+
+    return sbus_invoke_get_basic(sbus_req, function_ptr, &value,
+                                 DBUS_TYPE_UINT64, iter);
+}
+
+int sbus_invoke_get_d(DBusMessageIter *iter,
+                      struct sbus_request *sbus_req,
+                      void *function_ptr)
+{
+    double value;
+
+    return sbus_invoke_get_basic(sbus_req, function_ptr, &value,
+                                 DBUS_TYPE_DOUBLE, iter);
+}
+
+int sbus_invoke_get_s(DBusMessageIter *iter,
+                      struct sbus_request *sbus_req,
+                      void *function_ptr)
+{
+    return sbus_invoke_get_string(sbus_req, function_ptr, "",
+                                  DBUS_TYPE_STRING, iter);
+}
+
+int sbus_invoke_get_o(DBusMessageIter *iter,
+                      struct sbus_request *sbus_req,
+                      void *function_ptr)
+{
+    return sbus_invoke_get_string(sbus_req, function_ptr, "/",
+                                  DBUS_TYPE_OBJECT_PATH, iter);
+}
+
+int sbus_invoke_get_ay(DBusMessageIter *iter,
+                       struct sbus_request *sbus_req,
+                       void *function_ptr)
+{
+    return sbus_invoke_get_array(sbus_req, function_ptr, sizeof(uint8_t),
+                                 DBUS_TYPE_BYTE, iter);
+}
+
+int sbus_invoke_get_an(DBusMessageIter *iter,
+                       struct sbus_request *sbus_req,
+                       void *function_ptr)
+{
+    return sbus_invoke_get_array(sbus_req, function_ptr, sizeof(int16_t),
+                                 DBUS_TYPE_INT16, iter);
+}
+
+int sbus_invoke_get_aq(DBusMessageIter *iter,
+                       struct sbus_request *sbus_req,
+                       void *function_ptr)
+{
+    return sbus_invoke_get_array(sbus_req, function_ptr, sizeof(uint16_t),
+                                 DBUS_TYPE_UINT16, iter);
+}
+
+int sbus_invoke_get_ai(DBusMessageIter *iter,
+                       struct sbus_request *sbus_req,
+                       void *function_ptr)
+{
+    return sbus_invoke_get_array(sbus_req, function_ptr, sizeof(int32_t),
+                                 DBUS_TYPE_INT32, iter);
+}
+
+int sbus_invoke_get_au(DBusMessageIter *iter,
+                       struct sbus_request *sbus_req,
+                       void *function_ptr)
+{
+    return sbus_invoke_get_array(sbus_req, function_ptr, sizeof(uint32_t),
+                                 DBUS_TYPE_UINT32, iter);
+}
+
+int sbus_invoke_get_ax(DBusMessageIter *iter,
+                       struct sbus_request *sbus_req,
+                       void *function_ptr)
+{
+    return sbus_invoke_get_array(sbus_req, function_ptr, sizeof(int64_t),
+                                 DBUS_TYPE_INT64, iter);
+}
+
+int sbus_invoke_get_at(DBusMessageIter *iter,
+                       struct sbus_request *sbus_req,
+                       void *function_ptr)
+{
+    return sbus_invoke_get_array(sbus_req, function_ptr, sizeof(uint64_t),
+                                 DBUS_TYPE_UINT64, iter);
+}
+
+int sbus_invoke_get_ad(DBusMessageIter *iter,
+                       struct sbus_request *sbus_req,
+                       void *function_ptr)
+{
+    return sbus_invoke_get_array(sbus_req, function_ptr, sizeof(double),
+                                 DBUS_TYPE_DOUBLE, iter);
+}
+
+int sbus_invoke_get_as(DBusMessageIter *iter,
+                       struct sbus_request *sbus_req,
+                       void *function_ptr)
+{
+    return sbus_invoke_get_array(sbus_req, function_ptr, sizeof(const char *),
+                                 DBUS_TYPE_STRING, iter);
+}
+
+int sbus_invoke_get_ao(DBusMessageIter *iter,
+                       struct sbus_request *sbus_req,
+                       void *function_ptr)
+{
+    return sbus_invoke_get_array(sbus_req, function_ptr, sizeof(const char *),
+                                 DBUS_TYPE_OBJECT_PATH, iter);
+}
+
+void sbus_invoke_get(struct sbus_request *sbus_req,
+                     const char *type,
+                     sbus_get_invoker_fn invoker_fn,
+                     sbus_msg_handler_fn handler_fn)
+{
+    DBusMessage *reply = NULL;
+    DBusMessageIter iter;
+    DBusMessageIter variant;
+    dbus_bool_t dbret;
+    errno_t ret;
+
+    reply = dbus_message_new_method_return(sbus_req->message);
+    if (reply == NULL) {
+        ret = ENOMEM;
+        goto fail;
+    }
+
+    dbus_message_iter_init_append(reply, &iter);
+
+    dbret = dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
+                                             type, &variant);
+    if (!dbret) {
+        ret = ENOMEM;
+        goto fail;
+    }
+
+    ret = invoker_fn(&variant, sbus_req, handler_fn);
+    if (ret != EOK) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Invoker error [%d]: %s\n", ret, sss_strerror(ret));
+        goto fail;
+    }
+
+    dbret = dbus_message_iter_close_container(&iter, &variant);
+    if (!dbret) {
+        ret = EIO;
+        goto fail;
+    }
+
+    sbus_request_finish(sbus_req, reply);
+    return;
+
+fail:
+    DEBUG(SSSDBG_CRIT_FAILURE,
+          "Unable to reply [%d]: %s\n", ret, sss_strerror(ret));
+
+    if (reply != NULL) {
+        dbus_message_unref(reply);
+    }
+    sbus_request_finish(sbus_req, NULL);
+
+    return;
+}
+
+void sbus_invoke_get_all(struct sbus_request *sbus_req)
+{
+    const struct sbus_property_meta *props;
+    sbus_msg_handler_fn *handler_fn;
+    DBusMessage *reply = NULL;
+    DBusMessageIter iter;
+    DBusMessageIter array;
+    DBusMessageIter dict;
+    DBusMessageIter variant;
+    dbus_bool_t dbret;
+    errno_t ret;
+    int i;
+
+    reply = dbus_message_new_method_return(sbus_req->message);
+    if (reply == NULL) {
+        ret = ENOMEM;
+        goto fail;
+    }
+
+    dbus_message_iter_init_append(reply, &iter);
+
+    dbret = dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+                                     DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+                                     DBUS_TYPE_STRING_AS_STRING
+                                     DBUS_TYPE_VARIANT_AS_STRING
+                                     DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
+                                     &array);
+    if (!dbret) {
+        ret = ENOMEM;
+        goto fail;
+    }
+
+    props = sbus_req->intf->vtable->meta->properties;
+
+    if (props != NULL) {
+        for (i = 0; props[i].name != NULL; i++) {
+            dbret = dbus_message_iter_open_container(&array,
+                                                     DBUS_TYPE_DICT_ENTRY, NULL,
+                                                     &dict);
+            if (!dbret) {
+                ret = ENOMEM;
+                goto fail;
+            }
+
+            /* key */
+            dbret = dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING,
+                                                   &props[i].name);
+            if (!dbret) {
+                ret = ENOMEM;
+                goto fail;
+            }
+
+            /* value */
+            dbret = dbus_message_iter_open_container(&dict, DBUS_TYPE_VARIANT,
+                                                     props[i].type, &variant);
+            if (!dbret) {
+                ret = ENOMEM;
+                goto fail;
+            }
+
+            handler_fn = VTABLE_FUNC(sbus_req->intf->vtable,
+                                     props[i].vtable_offset_get);
+            if (handler_fn == NULL) {
+                ret = ERR_INTERNAL;
+                goto fail;
+            }
+
+            ret = props[i].invoker_get(&variant, sbus_req, handler_fn);
+            if (ret != EOK) {
+                DEBUG(SSSDBG_CRIT_FAILURE,
+                      "Invoker error [%d]: %s\n", ret, sss_strerror(ret));
+                goto fail;
+            }
+
+            dbret = dbus_message_iter_close_container(&dict, &variant);
+            if (!dbret) {
+                ret = EIO;
+                goto fail;
+            }
+
+            dbret = dbus_message_iter_close_container(&array, &dict);
+            if (!dbret) {
+                ret = EIO;
+                goto fail;
+            }
+        }
+    }
+
+    dbret = dbus_message_iter_close_container(&iter, &array);
+    if (!dbret) {
+        ret = EIO;
+        goto fail;
+    }
+
+    sbus_request_finish(sbus_req, reply);
+    return;
+
+fail:
+    DEBUG(SSSDBG_CRIT_FAILURE,
+          "Unable to reply [%d]: %s\n", ret, sss_strerror(ret));
+
+    dbus_message_unref(reply);
+    sbus_request_finish(sbus_req, NULL);
+
+    return;
+}