Adding upstream version 2.9.4.upstream/2.9.4

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 365 insertions, 0 deletions

diff --git a/src/sbus/interface/sbus_iterator_writers.c b/src/sbus/interface/sbus_iterator_writers.c
new file mode 100644
index 0000000..3becc8f
--- /dev/null
+++ b/src/sbus/interface/sbus_iterator_writers.c
@@ -0,0 +1,365 @@
+/*
+    Authors:
+        Pavel Březina <pbrezina@redhat.com>
+
+    Copyright (C) 2017 Red Hat
+
+    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 <errno.h>
+#include <string.h>
+#include <stdint.h>
+#include <talloc.h>
+#include <dbus/dbus.h>
+
+#include "util/util.h"
+#include "util/sss_utf8.h"
+#include "sbus/interface/sbus_iterator_writers.h"
+
+static errno_t
+sbus_iterator_write_basic(DBusMessageIter *iterator,
+                          int dbus_type,
+                          void *value_ptr)
+{
+    dbus_bool_t ret;
+
+    ret = dbus_message_iter_append_basic(iterator, dbus_type, value_ptr);
+
+    return ret ? EOK : EIO;
+}
+
+static errno_t
+sbus_iterator_write_string(DBusMessageIter *iterator,
+                           int dbus_type,
+                           const char *value,
+                           const char *default_value)
+{
+    dbus_bool_t ret;
+    bool is_valid;
+
+    /* If the value is not set, we will provide a correct default value. */
+    value = value == NULL ? default_value : value;
+
+    /* D-Bus is not capable of sending NULL string. If even the default value
+     * was not set, we return an error. */
+    if (value == NULL) {
+        return ERR_SBUS_EMPTY_STRING;
+    }
+
+    /* D-Bus can send only correct UTF-8 strings. */
+    is_valid = sss_utf8_check((const uint8_t *)value, strlen(value));
+    if (!is_valid) {
+          DEBUG(SSSDBG_CRIT_FAILURE, "String with non-utf8 characters was "
+                "given [%s]\n", value);
+        return ERR_SBUS_INVALID_STRING;
+    }
+
+    ret = dbus_message_iter_append_basic(iterator, dbus_type, &value);
+
+    return ret ? EOK : EIO;
+}
+
+static errno_t
+sbus_iterator_write_string_elements(DBusMessageIter *iterator,
+                                    int dbus_type,
+                                    const char **values)
+{
+    errno_t ret;
+    int i;
+
+    if (values == NULL) {
+        return EOK;
+    }
+
+    /* String arrays are NULL-terminated. */
+    for (i = 0; values[i] != NULL; i++) {
+        ret = sbus_iterator_write_string(iterator, dbus_type, values[i], NULL);
+        if (ret != EOK) {
+            return ret;
+        }
+    }
+
+    return EOK;
+}
+
+static errno_t
+sbus_iterator_write_fixed_elements(DBusMessageIter *iterator,
+                                   int dbus_type,
+                                   int element_size,
+                                   int array_length,
+                                   void *value_ptr)
+{
+    errno_t ret;
+    uint8_t *element_ptr;
+    int count;
+    int i;
+
+    element_ptr = value_ptr;
+    if (array_length < 0) {
+        count = talloc_get_size(value_ptr) / element_size;
+    } else {
+        count = array_length;
+    }
+
+
+    for (i = 0; i < count; i++) {
+        ret = sbus_iterator_write_basic(iterator, dbus_type, element_ptr);
+        if (ret != EOK) {
+            return ret;
+        }
+
+        element_ptr += element_size;
+    }
+
+    return EOK;
+}
+
+errno_t
+_sbus_iterator_write_basic_array(DBusMessageIter *iterator,
+                                 int dbus_type,
+                                 int element_size,
+                                 int array_length,
+                                 void *value_ptr)
+{
+    const char array_type[2] = {dbus_type, '\0'};
+    DBusMessageIter arrayiter;
+    dbus_bool_t dbret;
+    errno_t ret;
+
+    dbret = dbus_message_iter_open_container(iterator, DBUS_TYPE_ARRAY,
+                                             array_type, &arrayiter);
+    if (!dbret) {
+        return EIO;
+    }
+
+    switch (dbus_type) {
+    case DBUS_TYPE_STRING:
+    case DBUS_TYPE_OBJECT_PATH:
+        ret = sbus_iterator_write_string_elements(&arrayiter, dbus_type,
+                                                  (const char **)value_ptr);
+        if (ret != EOK) {
+            goto done;
+        }
+        break;
+    default:
+        ret = sbus_iterator_write_fixed_elements(&arrayiter, dbus_type,
+                                                 element_size, array_length,
+                                                 value_ptr);
+        if (ret != EOK) {
+            goto done;
+        }
+        break;
+    }
+
+    dbret = dbus_message_iter_close_container(iterator, &arrayiter);
+    if (!dbret) {
+        ret = EIO;
+        goto done;
+    }
+
+    ret = EOK;
+
+done:
+    if (ret != EOK) {
+        dbus_message_iter_abandon_container(iterator, &arrayiter);
+    }
+
+    return ret;
+}
+
+errno_t sbus_iterator_write_y(DBusMessageIter *iterator,
+                              uint8_t value)
+{
+    return sbus_iterator_write_basic(iterator, DBUS_TYPE_BYTE, &value);
+}
+
+errno_t sbus_iterator_write_b(DBusMessageIter *iterator,
+                              bool value)
+{
+    dbus_bool_t dbus_value = value;
+
+    return sbus_iterator_write_basic(iterator, DBUS_TYPE_BOOLEAN, &dbus_value);
+}
+
+errno_t sbus_iterator_write_n(DBusMessageIter *iterator,
+                              int16_t value)
+{
+    dbus_int16_t dbus_value = value;
+
+    return sbus_iterator_write_basic(iterator, DBUS_TYPE_INT16, &dbus_value);
+}
+
+errno_t sbus_iterator_write_q(DBusMessageIter *iterator,
+                              uint16_t value)
+{
+    dbus_uint16_t dbus_value = value;
+
+    return sbus_iterator_write_basic(iterator, DBUS_TYPE_UINT16, &dbus_value);
+}
+
+errno_t sbus_iterator_write_i(DBusMessageIter *iterator,
+                              int32_t value)
+{
+    dbus_int32_t dbus_value = value;
+
+    return sbus_iterator_write_basic(iterator, DBUS_TYPE_INT32, &dbus_value);
+}
+
+errno_t sbus_iterator_write_u(DBusMessageIter *iterator,
+                              uint32_t value)
+{
+    dbus_uint32_t dbus_value = value;
+
+    return sbus_iterator_write_basic(iterator, DBUS_TYPE_UINT32, &dbus_value);
+}
+
+errno_t sbus_iterator_write_x(DBusMessageIter *iterator,
+                              int64_t value)
+{
+    dbus_int64_t dbus_value = value;
+
+    return sbus_iterator_write_basic(iterator, DBUS_TYPE_INT64, &dbus_value);
+}
+
+errno_t sbus_iterator_write_t(DBusMessageIter *iterator,
+                              uint64_t value)
+{
+    dbus_uint64_t dbus_value = value;
+
+    return sbus_iterator_write_basic(iterator, DBUS_TYPE_UINT64, &dbus_value);
+}
+
+errno_t sbus_iterator_write_d(DBusMessageIter *iterator,
+                              double value)
+{
+    return sbus_iterator_write_basic(iterator, DBUS_TYPE_DOUBLE, &value);
+}
+
+errno_t sbus_iterator_write_s(DBusMessageIter *iterator,
+                              const char *value)
+{
+    return sbus_iterator_write_string(iterator, DBUS_TYPE_STRING, value, "");
+}
+
+errno_t sbus_iterator_write_S(DBusMessageIter *iterator,
+                              char *value)
+{
+    return sbus_iterator_write_string(iterator, DBUS_TYPE_STRING, value, "");
+}
+
+errno_t sbus_iterator_write_o(DBusMessageIter *iterator,
+                              const char *value)
+{
+    return sbus_iterator_write_string(iterator, DBUS_TYPE_OBJECT_PATH,
+                                      value, "/");
+}
+
+errno_t sbus_iterator_write_O(DBusMessageIter *iterator,
+                              char *value)
+{
+    return sbus_iterator_write_string(iterator, DBUS_TYPE_OBJECT_PATH,
+                                      value, "/");
+}
+
+errno_t sbus_iterator_write_ay(DBusMessageIter *iterator,
+                               uint8_t *value)
+{
+    return sbus_iterator_write_basic_array(iterator, DBUS_TYPE_BYTE,
+                                           uint8_t, value);
+}
+
+errno_t sbus_iterator_write_ab(DBusMessageIter *iterator,
+                               bool *value)
+{
+    return sbus_iterator_write_basic_array(iterator, DBUS_TYPE_BOOLEAN,
+                                           bool, value);
+}
+
+errno_t sbus_iterator_write_an(DBusMessageIter *iterator,
+                               int16_t *value)
+{
+    return sbus_iterator_write_basic_array(iterator, DBUS_TYPE_INT16,
+                                           int16_t, value);
+}
+
+errno_t sbus_iterator_write_aq(DBusMessageIter *iterator,
+                               uint16_t *value)
+{
+    return sbus_iterator_write_basic_array(iterator, DBUS_TYPE_UINT16,
+                                           uint16_t, value);
+}
+
+errno_t sbus_iterator_write_ai(DBusMessageIter *iterator,
+                               int32_t *value)
+{
+    return sbus_iterator_write_basic_array(iterator, DBUS_TYPE_INT32,
+                                           int32_t, value);
+}
+
+errno_t sbus_iterator_write_au(DBusMessageIter *iterator,
+                               uint32_t *value)
+{
+    return sbus_iterator_write_basic_array(iterator, DBUS_TYPE_UINT32,
+                                           uint32_t, value);
+}
+
+errno_t sbus_iterator_write_ax(DBusMessageIter *iterator,
+                               int64_t *value)
+{
+    return sbus_iterator_write_basic_array(iterator, DBUS_TYPE_INT64,
+                                           int64_t, value);
+}
+
+errno_t sbus_iterator_write_at(DBusMessageIter *iterator,
+                               uint64_t *value)
+{
+    return sbus_iterator_write_basic_array(iterator, DBUS_TYPE_UINT64,
+                                           uint64_t, value);
+}
+
+errno_t sbus_iterator_write_ad(DBusMessageIter *iterator,
+                               double *value)
+{
+    return sbus_iterator_write_basic_array(iterator, DBUS_TYPE_DOUBLE,
+                                           double, value);
+}
+
+errno_t sbus_iterator_write_as(DBusMessageIter *iterator,
+                               const char **value)
+{
+    return sbus_iterator_write_basic_array(iterator, DBUS_TYPE_STRING,
+                                           const char *, value);
+}
+
+errno_t sbus_iterator_write_aS(DBusMessageIter *iterator,
+                               char **value)
+{
+    return sbus_iterator_write_basic_array(iterator, DBUS_TYPE_STRING,
+                                           char *, value);
+}
+
+errno_t sbus_iterator_write_ao(DBusMessageIter *iterator,
+                               const char **value)
+{
+    return sbus_iterator_write_basic_array(iterator, DBUS_TYPE_OBJECT_PATH,
+                                           const char *, value);
+}
+
+errno_t sbus_iterator_write_aO(DBusMessageIter *iterator,
+                               char **value)
+{
+    return sbus_iterator_write_basic_array(iterator, DBUS_TYPE_OBJECT_PATH,
+                                           char *, value);
+}