array_internal.c

Go to the documentation of this file.

/*
 EasyDbus: DBus Binding Library
 Copyright (C) 2007  Daniele Rondina aka ge@@ru, geaaru@gmail.com 
 
 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.

 Filename:  array_internal.c
 
 Description:  
 
 Version:  1.0
 Created:  09/08/07 18:34:32 CEST
 Revision:  none
 
 Author:   Daniele Rondina aka Ge@@ru (geaaru@gmail.com) 
 License:  GPL 2.0
*/

#include <string.h>
#include <stdlib.h>
//easydbus includes
#include "easydbus-core.h"
#include "debug.h"
#include "utils.h"
#include "dict_entry_internal.h"
#include "variant_internal.h"
#include "array_internal.h"
#include "struct_internal.h"



int
add_array_to_msg (DBusMessage * msg, struct EasyDbus_elem *el)
{
   struct EasyDbus_container *container = el->payload.p_container;
   int ret_val = -1;
   unsigned int i = 0;
   DBusMessageIter iter;
   DBusMessageIter iter2;
   short *p_i16 = NULL;
   int *p_i32 = NULL;
   long long *p_i64 = NULL;
   double *p_double = NULL;
   char *p_byte = NULL;
   char **p_string = NULL;
   struct EasyDbus_elem *internal_el = NULL;
   char *signature = NULL;

   dbus_message_iter_init_append (msg, &iter);

   /*
    * When an array is empty is always needed to
    * have a correct signature, else you can
    * receive an error because there isn't a different
    * between message sent and message handled from
    * server.
    */
   if (!container->nel) {
      if (!container->signature)
         EasyDbusDebug ("Error an empty array must have a"
                        " signature");
         return ret_val;
      if (dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
                                            container->signature,
                                            &iter2))
         ret_val = 0;
      else
         EasyDbusDebug ("Error on open container container\n");
      goto end;
   }
   /* container has at least one element */
   /* build signature */
   signature = prepare_signature (el, EASYDBUS_SIGNATURE_NORMAL);
   EasyDbusDebug ("Signature prepared for array = %s", signature);
   /* this is needed beacause first char of signature
    * relative to first container container must be ignored.
    * Try to speak of this with dbus protocols developers 
    * because i think that isn't correct. */
   signature++;
   if (dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, 
                                         signature, &iter2))
      ret_val = 0;
   else
      EasyDbusDebug ("Error on open container container\n");
   switch (container->elem_type) {
      case EASYDBUS_ELTYPE_INT16:
         p_i16 = (short *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2, 
                                            DBUS_TYPE_INT16, p_i16);
            p_i16++;
         }
         break;
      case EASYDBUS_ELTYPE_UINT16:
         p_i16 = (short *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_UINT16, p_i16);
            p_i16++;
         }
         break;
      case EASYDBUS_ELTYPE_INT32:
         p_i32 = (int *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_INT32, p_i32);
            p_i32++;
         }
         break;
      case EASYDBUS_ELTYPE_UINT32:
         p_i32 = (int *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_UINT32, p_i32);
            p_i32++;
         }
         break;
      case EASYDBUS_ELTYPE_INT64:
         p_i64 = (long long *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_UINT32, p_i64);
            p_i64++;
         }
         break;
      case EASYDBUS_ELTYPE_UINT64:
         p_i64 = (long long *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_UINT64, p_i64);
            p_i64++;
         }
         break;
      case EASYDBUS_ELTYPE_BYTE:
         p_byte = (char *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_BYTE, p_byte);
            p_byte++;
         }
         break;
      case EASYDBUS_ELTYPE_DOUBLE:
         p_double = (double *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_DOUBLE,
                                            p_double);
            p_double++;
         }
         break;
      case EASYDBUS_ELTYPE_BOOLEAN:
         p_byte = (char *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_BOOLEAN,
                                            p_byte);
            p_byte++;
         }
         break;
      case EASYDBUS_ELTYPE_SIGNATURE:
         p_string = (char **) container->p_data;
         for (i = 0; i < container->nel; i++) {
            // char *temp = p_string[i];
            // printf ("%s \n", temp);
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_SIGNATURE,
                                            &p_string[i]);
         }
         break;
      case EASYDBUS_ELTYPE_STRING:
         p_string = (char **) container->p_data;
         for (i = 0; i < container->nel; i++) {
            // char *temp = p_string[i];
            // printf ("%s \n", temp);
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_STRING,
                                            &p_string[i]);
         }
         break;
      case EASYDBUS_ELTYPE_OBJECT_PATH:
         p_string = (char **) container->p_data;
         for (i = 0; i < container->nel; i++)
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_OBJECT_PATH,
                                            &p_string[i]);
         break;
      case EASYDBUS_ELTYPE_ARRAY:
         internal_el = (struct EasyDbus_elem *)
            container->p_data;
         for (i = 0; i < container->nel; i++) {
            easydbus_add_array_on_container_tomsg
               (msg, &iter2, internal_el);
            internal_el = internal_el->next;
         }
         break;
      case EASYDBUS_ELTYPE_DICT_ENTRY:
         internal_el = (struct EasyDbus_elem *)
            container->p_data;
         for (i = 0; i < container->nel; i++) {
            easydbus_add_dict_entry_tomsg (msg, &iter2, internal_el);
            internal_el = internal_el->next;
         }
         break;
      case EASYDBUS_ELTYPE_VARIANT:
         internal_el = (struct EasyDbus_elem *)
            container->p_data;
         for (i = 0; i < container->nel; i++) {
            //TODO:
            //rename function for manage variant on
            //container.
            add_variant_to_container_on_msg (msg, internal_el,
                                             &iter2);
            internal_el = internal_el->next;
         }
         break;
      case EASYDBUS_ELTYPE_STRUCT:
         internal_el = (struct EasyDbus_elem *)
            container->p_data;
         while (internal_el != NULL) {
            easydbus_add_struct_on_container_msg
               (msg, &iter2, internal_el);
            internal_el = internal_el->next;
         }
         break;
      case EASYDBUS_ELTYPE_INVALID:
         EasyDbusDebug ("ERROR This type must not be used!\n");
         break;
   }                            // end of switch

   /* move signature pointer to original 
    * position with container char before call free */
   free (--signature);

 end:

   dbus_message_iter_close_container (&iter, &iter2);

   return ret_val;
}

struct EasyDbus_container *
easydbus_get_marshal_data_from_array (enum event_type type,
                                      void *container,
                                      enum el_type type_marshal_data,
                                      DBusMessageIter * iter)
{
   int i32 = 0;
   unsigned int ui32 = 0;
   short i16 = 0;
   char byte = 0;
   char *string = NULL;
   unsigned short ui16 = 0;
   long long i64 = 0;
   double d = 0;
   unsigned long long ui64 = 0;
   DBusMessageIter subiter;
   unsigned int len = 1;
   char *bytes = NULL;
   char **strings = NULL;
   int *int32_array = NULL;
   unsigned int *uint32_array = NULL;
   unsigned short *uint16_array = NULL;
   short *int16_array = NULL;
   long long *int64_array = NULL;
   unsigned long long *uint64_array = NULL;
   double *double_array = NULL;
   unsigned int i = 0;
   struct EasyDbus_container *array = NULL;
   struct EasyDbus_container *cont_marshal_data = NULL;

#ifdef EASYDBUS_DEBUG
   char *signature = NULL;
#endif

   dbus_message_iter_recurse (iter, &subiter);

   if (type_marshal_data == DBUS_TYPE_INVALID) {
      EasyDbusDebug ("No element on array or error");
      return NULL;
   }

   if (type_marshal_data != DBUS_TYPE_DICT_ENTRY) {
      // count elems
      while (dbus_message_iter_has_next (&subiter)) {
         len++;
         dbus_message_iter_next (&subiter);
      }
      // reinit iterator
      dbus_message_iter_recurse (iter, &subiter);
      EasyDbusDebug ("Number of element on array = %d", len);
   }

   array = easydbus_container_create_skeleton (EASYDBUS_ELTYPE_ARRAY);
   if (!array) {
      EasyDbusDebug ("Error on create container skeleton");
      return NULL;
   }

   // this is neeeded for manage correctly empty array
   switch (type_marshal_data) {
      case DBUS_TYPE_STRING:
      case DBUS_TYPE_OBJECT_PATH:
      case DBUS_TYPE_SIGNATURE:
         strings = (char **) malloc (sizeof (char *) * len);
         if (!strings)
            goto error;
         memset (strings, 0, len * sizeof (char *));
         break;
      case DBUS_TYPE_INT32:
         int32_array = (int *) malloc (sizeof (int) * len);
         if (!int32_array)
            goto error;
         memset (int32_array, 0, sizeof (int) * len);
         break;
      case DBUS_TYPE_UINT32:
         uint32_array = (unsigned int *) malloc (sizeof (int) * len);
         if (!uint32_array)
            goto error;
         memset (uint32_array, 0, sizeof (int) * len);
         break;
      case DBUS_TYPE_INT64:
         int64_array =
            (long long *) malloc (sizeof (long long) * len);
         if (!int64_array)
            goto error;
         memset (int64_array, 0, sizeof (long long) * len);
         break;
      case DBUS_TYPE_UINT64:
         uint64_array = (unsigned long long *) malloc
            (sizeof (unsigned long long) * len);
         if (!uint64_array)
            goto error;
         memset (uint64_array, 0, sizeof (unsigned long long) * len);
         break;
      case DBUS_TYPE_INT16:
         int16_array = (short *) malloc (sizeof (short) * len);
         if (!int16_array)
            goto error;
         memset (int16_array, 0, sizeof (short) * len);
         break;
      case DBUS_TYPE_UINT16:
         uint16_array = (unsigned short *) malloc
            (sizeof (unsigned short) * len);
         if (!uint16_array)
            goto error;
         memset (uint16_array, 0, sizeof (unsigned short) * len);
         break;
      case DBUS_TYPE_BYTE:
      case DBUS_TYPE_BOOLEAN:
         bytes = (char *) malloc (len);
         if (!bytes)
            goto error;
         memset (bytes, 0, len);
      case DBUS_TYPE_DOUBLE:
         double_array = (double *) malloc (sizeof (double) * len);
         if (!double_array)
            goto error;
         memset (double_array, 0, sizeof (double) * len);
         break;
      case DBUS_TYPE_VARIANT:
      case DBUS_TYPE_DICT_ENTRY:
      case DBUS_TYPE_ARRAY:
      case DBUS_TYPE_STRUCT:
         // do nothings, dict entry and variant elements are
         // insert dinamically when it is read a element.
         break;
      default:
         goto error;
         break;
   }

   while (1) {
#ifdef EASYDBUS_DEBUG
      signature = dbus_message_iter_get_signature (iter);
      EasyDbusDebug ("Current Signature = %s", signature);
      dbus_free (signature);
#endif
      switch (dbus_message_iter_get_arg_type (&subiter)) {
         case DBUS_TYPE_STRING:
            dbus_message_iter_get_basic (&subiter, &string);
            EasyDbusDebug ("founded string = %s\n", string);
            strings[i] = (char *) malloc (strlen (string) + 1);
            EASYDBUS_MEMCOPY (strings[i], string,
                              strlen (string) + 1);
            //memset (strings[i], 0, strlen (string) + 1);
            //memcpy (strings[i], string, strlen (string) + 1);
            //EasyDbusDebug ("founded string = %s\n", strings[i]);
            i++;
            break;
         case DBUS_TYPE_INT32:
            dbus_message_iter_get_basic (&subiter, &i32);
            EasyDbusDebug ("founded int32 = %d", i32);
            int32_array[i] = i32;
            i++;
            break;
         case DBUS_TYPE_UINT32:
            dbus_message_iter_get_basic (&subiter, &ui32);
            EasyDbusDebug ("founded uint32 = %d", ui32);
            uint32_array[i] = ui32;
            i++;
            break;
         case DBUS_TYPE_INT16:
            dbus_message_iter_get_basic (&subiter, &i16);
            EasyDbusDebug ("founded int16 = %d", i16);
            int16_array[i] = i16;
            i++;
            break;
         case DBUS_TYPE_UINT16:
            dbus_message_iter_get_basic (&subiter, &ui16);
            EasyDbusDebug ("founded uint16 = %d", ui16);
            uint16_array[i] = ui16;
            i++;
            break;
         case DBUS_TYPE_INT64:
            dbus_message_iter_get_basic (&subiter, &i64);
            EasyDbusDebug ("founded int64 = %lld", i64);
            int64_array[i] = i64;
            i++;
            break;
         case DBUS_TYPE_UINT64:
            dbus_message_iter_get_basic (&subiter, &ui64);
            EasyDbusDebug ("founded uint64 = %lld", ui64);
            uint64_array[i] = ui64;
            i++;
            break;
         case DBUS_TYPE_BYTE:
            dbus_message_iter_get_basic (&subiter, &byte);
            EasyDbusDebug ("founded byte = %d", byte);
            bytes[i] = byte;
            i++;
            break;
         case DBUS_TYPE_BOOLEAN:
            dbus_message_iter_get_basic (&subiter, &byte);
            EasyDbusDebug ("founded boolean = %d", byte);
            bytes[i] = byte;
            i++;
            break;
         case DBUS_TYPE_DOUBLE:
            dbus_message_iter_get_basic (&subiter, &d);
            EasyDbusDebug ("founded double = %f", d);
            double_array[i] = d;
            i++;
            break;
         case DBUS_TYPE_OBJECT_PATH:
            dbus_message_iter_get_basic (&subiter, &string);
            EasyDbusDebug ("founded obj_path = %s\n", string);
            strings[i] = (char *) malloc (strlen (string) + 1);
            EASYDBUS_MEMCOPY (strings[i], string, strlen (string) + 1);
            //memset (strings[i], 0, strlen (string) + 1);
            //memcpy (strings[i], string, strlen (string));
            i++;
            break;
         case DBUS_TYPE_SIGNATURE:
            dbus_message_iter_get_basic (&subiter, &string);
            EasyDbusDebug ("founded signature = %s\n", string);
            strings[i] = (char *) malloc (strlen (string) + 1);
            EASYDBUS_MEMCOPY (strings[i], string, strlen (string) + 1);
            //memset (strings[i], 0, strlen (string) + 1);
            //memcpy (strings[i], string, strlen (string));
            i++;
            break;
         case DBUS_TYPE_ARRAY:
            cont_marshal_data =
               easydbus_get_marshal_data_from_array (type,
                                                     container,
                                                     dbus_message_iter_get_element_type
                                                     (&subiter),
                                                     &subiter);
            if (cont_marshal_data != NULL) {
               easydbus_array_add_array (cont_marshal_data, array);
               EasyDbusDebug ("Added array to container");
            }
            else
               EasyDbusDebug ("Error on manage array");
            break;
         case DBUS_TYPE_STRUCT:
            cont_marshal_data = easydbus_struct_build_elem
               (type, (void *) container, &subiter);
            if (cont_marshal_data != NULL) {
               easydbus_array_add_struct (cont_marshal_data, array);
               EasyDbusDebug ("Added struct to container");
            }
            else
               EasyDbusDebug ("Error on add struct to container");
            break;
         case DBUS_TYPE_VARIANT:
            cont_marshal_data = easydbus_variant_build_elem
               (type, (void *) container, &subiter);
            if (cont_marshal_data != NULL) {
               easydbus_array_add_variant (cont_marshal_data, array);
               EasyDbusDebug ("Added variant to container");
            }
            else
               EasyDbusDebug ("Error on add variant to container");
            i++;
            break;
         case DBUS_TYPE_DICT_ENTRY:
            cont_marshal_data = easydbus_dict_entry_build_container
               (type, container, &subiter);
            if (cont_marshal_data != NULL) {
               easydbus_array_add_dict_entry
                  (cont_marshal_data, array);
               EasyDbusDebug ("Added dict entry to array");
            }
            else
               EasyDbusDebug ("Error on add dict entry to array");
            i++;
            break;
         case DBUS_TYPE_INVALID:
            EasyDbusDebug ("Empty array or field wrong");
            break;
         default:
            EasyDbusDebug ("Not managed or error");
            break;
      }
      if (!dbus_message_iter_has_next (&subiter))
         goto exit;
      else
         dbus_message_iter_next (&subiter);
   }

 exit:
   /* no element on array */
   if (i == 0) {
      EasyDbusDebug ("Add signature %d (easydbus %d) to empty array",
                     type_marshal_data,
                     get_easydbus_type_from_dbus_type
                     (type_marshal_data));
      easydbus_container_add_signature_to_empty_container (array,
                                                           get_easydbus_type_from_dbus_type
                                                           (type_marshal_data),
                                                           EASYDBUS_ELTYPE_INVALID);
   }
   switch (type_marshal_data) {
      case DBUS_TYPE_STRING:
         if (i)                 /* if array isn't empty */
            easydbus_array_add_string_array (array, len, strings);
         for (i = 0; i < len; i++)
            free (strings[i]);
         free (strings);
         break;
      case DBUS_TYPE_INT32:
         if (i)
            easydbus_array_add_i32_array (array, len, int32_array);
         free (int32_array);
         break;
      case DBUS_TYPE_UINT32:
         if (i)
            easydbus_array_add_ui32_array (array, len, uint32_array);
         free (uint32_array);
      case DBUS_TYPE_BYTE:
         if (i)
            easydbus_array_add_byte_array (array, len, bytes);
         free (bytes);
         break;
      case DBUS_TYPE_INT64:
         if (i)
            easydbus_array_add_i64_array (array, len, int64_array);
         free (int64_array);
         break;
      case DBUS_TYPE_UINT64:
         if (i)
            easydbus_array_add_ui64_array (array, len, uint64_array);
         free (uint64_array);
         break;
      case DBUS_TYPE_INT16:
         if (i)
            easydbus_array_add_i16_array (array, len, int16_array);
         free (int16_array);
         break;
      case DBUS_TYPE_UINT16:
         if (i)
            easydbus_array_add_ui16_array (array, len, uint16_array);
         free (uint16_array);
         break;
      case DBUS_TYPE_BOOLEAN:
         if (i)
            easydbus_array_add_boolean_array (array, len, bytes);
         free (bytes);
         break;
      case DBUS_TYPE_DOUBLE:
         if (i)
            easydbus_array_add_double_array (array, len,
                                             double_array);
         free (double_array);
         break;
      case DBUS_TYPE_OBJECT_PATH:
         if (i)
            easydbus_array_add_obj_path_array (array, len, strings);
         for (i = 0; i < len; i++)
            free (strings[i]);
         free (strings);
         break;
      case DBUS_TYPE_SIGNATURE:
         if (i)
            easydbus_array_add_signature_array (array, len, strings);
         for (i = 0; i < len; i++)
            free (strings[i]);
         free (strings);
         break;
      case DBUS_TYPE_DICT_ENTRY:
      case DBUS_TYPE_VARIANT:
      case DBUS_TYPE_ARRAY:
      case DBUS_TYPE_STRUCT:
         EasyDbusDebug ("Data already inserted on array");
         break;
      default:
         break;
   }

   EasyDbusDebug ("End of get recurse marshal data");
   return array;

 error:
   if (array != NULL)
      easydbus_container_free (array);
   return NULL;
}

int 
easydbus_add_array_on_container_tomsg (DBusMessage * msg, 
                                       DBusMessageIter * iter,
                                       struct EasyDbus_elem *el) 
{
   DBusMessageIter iter2;
   short *p_i16 = NULL;
   int *p_i32 = NULL;
   long long *p_i64 = NULL;
   double *p_double = NULL;
   char *p_byte = NULL;
   char **p_string = NULL;
   struct EasyDbus_elem *internal_el = NULL;
   struct EasyDbus_container *container = el->payload.p_container;
   int ret_val = -1;
   unsigned int i;
   char *signature = NULL;

   if (!container->nel) {
      if (!container->signature) {
         EasyDbusDebug ("Error an empty array must have a"
                        " signature");
         return ret_val;
      }
      /* see if there is a solution more efficient */
      if (dbus_message_iter_open_container (iter, DBUS_TYPE_ARRAY,
                                             container->signature,
                                             &iter2))
         ret_val = 0;
      else
         EasyDbusDebug ("Error on open array container");
      goto end;
   }

   /* container has at least one element */
   /* build signature */
   signature = prepare_signature (el, EASYDBUS_SIGNATURE_NORMAL);
   EasyDbusDebug ("Signature prepared for container on array "
                  "= %s\n", signature);
   /* this is needed beacaurse first char of signature
    * relative to first container container must be ignored.
    * Try to speak of this with dbus protocols developers 
    * because i think that isn't correct. */
   signature++;
   if (dbus_message_iter_open_container (iter, DBUS_TYPE_ARRAY,
                                          signature, &iter2))
      ret_val = 0;
   else
      EasyDbusDebug ("Error on open array container\n");
   switch (container->elem_type) {
      case EASYDBUS_ELTYPE_INT16:
         p_i16 = (short *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_INT16, p_i16);
            p_i16++;
         }
         break;
      case EASYDBUS_ELTYPE_UINT16:
         p_i16 = (short *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_UINT16, p_i16);
            p_i16++;
         }
         break;
      case EASYDBUS_ELTYPE_INT32:
         p_i32 = (int *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_INT32, p_i32);
            p_i32++;
         }
         break;
      case EASYDBUS_ELTYPE_UINT32:
         p_i32 = (int *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_UINT32, p_i32);
            p_i32++;
         }
         break;
      case EASYDBUS_ELTYPE_INT64:
         p_i64 = (long long *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_UINT32, p_i64);
            p_i64++;
         }
         break;
      case EASYDBUS_ELTYPE_UINT64:
         p_i64 = (long long *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_UINT64, p_i64);
            p_i64++;
         }
         break;
      case EASYDBUS_ELTYPE_BYTE:
         p_byte = (char *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_BYTE, p_byte);
            p_byte++;
         }
         break;
      case EASYDBUS_ELTYPE_DOUBLE:
         p_double = (double *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_DOUBLE,
                                            p_double);
            p_double++;
         }
         break;
      case EASYDBUS_ELTYPE_BOOLEAN:
         p_byte = (char *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_BOOLEAN,
                                            p_byte);
            p_byte++;
         }
         break;
      case EASYDBUS_ELTYPE_STRING:
         p_string = (char **) container->p_data;
         for (i = 0; i < container->nel; i++) {
            // char *temp = p_string[i];
            // printf ("%s \n", temp);
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_STRING,
                                            &p_string[i]);
         }
         break;
      case EASYDBUS_ELTYPE_OBJECT_PATH:
         p_string = (char **) container->p_data;
         for (i = 0; i < container->nel; i++)
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_OBJECT_PATH,
                                            &p_string[i]);
         break;
      case EASYDBUS_ELTYPE_SIGNATURE:
         p_string = (char **) container->p_data;
         for (i = 0; i < container->nel; i++)
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_SIGNATURE,
                                            &p_string[i]);
         break;
      case EASYDBUS_ELTYPE_ARRAY:
         internal_el = (struct EasyDbus_elem *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            easydbus_add_array_on_container_tomsg
               (msg, &iter2, internal_el);
            internal_el = internal_el->next;
         }
         break;
      case EASYDBUS_ELTYPE_VARIANT:
         internal_el = (struct EasyDbus_elem *)
            container->p_data;
         for (i = 0; i < container->nel; i++) {
            add_variant_to_container_on_msg (msg, internal_el,
                                             &iter2);
            internal_el = internal_el->next;
         }
         break;
      case EASYDBUS_ELTYPE_DICT_ENTRY:
         internal_el = (struct EasyDbus_elem *)
            container->p_data;
         for (i = 0; i < container->nel; i++) {
            easydbus_add_dict_entry_tomsg (msg, &iter2, internal_el);
            internal_el = internal_el->next;
         }
         break;
      case EASYDBUS_ELTYPE_STRUCT:
         internal_el = (struct EasyDbus_elem *)
            container->p_data;
         while (internal_el != NULL) {
            easydbus_add_struct_on_container_msg
               (msg, &iter2, internal_el);
            internal_el = internal_el->next;
         }
         break;
      case EASYDBUS_ELTYPE_INVALID:
         EasyDbusDebug ("ERROR This type must not be used!");
         break;
   } // end of switch

   /* move signature pointer to original 
    * position with array char before call free */
   free (--signature);

 end:
   dbus_message_iter_close_container (iter, &iter2);

   return ret_val;
}



//-------------------------------------------------//
// struct easydbus_signature_elem_stack functions  //
//-------------------------------------------------//

struct easydbus_signature_elem_stack *
easydbus_add_elem_to_stack (enum el_type el,
                            struct easydbus_signature_elem_stack
                            *stack)
{
   struct easydbus_signature_elem_stack *new_el = NULL;
   struct easydbus_signature_elem_stack *tmp_el = NULL;

   new_el = (struct easydbus_signature_elem_stack *)
      malloc (sizeof (struct easydbus_signature_elem_stack));

   if (!new_el)
      return NULL;

   memset (new_el, 0, sizeof (struct easydbus_signature_elem_stack));
   new_el->next = new_el->prev = NULL;
   new_el->type = el;

   if (!stack)
      return new_el;

   tmp_el = stack;
   while (tmp_el->next)
      tmp_el = tmp_el->next;

   tmp_el->next = new_el;
   new_el->prev = tmp_el;
   return stack;
}

void
easydbus_free_elem_from_stack 
  (struct easydbus_signature_elem_stack *el)
{
   if (!el)
      return;

   if (el->next)
      el->next->prev = el->prev;
   if (el->prev)
      el->prev->next = el->next;
   free (el);
}

inline void
easydbus_free_elem_from_stack_list 
  (struct easydbus_signature_elem_stack *list)
{
   struct easydbus_signature_elem_stack *tmp_elem = NULL;

   while (list) {
      tmp_elem = list;
      list = list->next;
      easydbus_free_elem_from_stack (tmp_elem);
   }
}

// vim: ts=3 shiftwidth=3 expandtab

---