utils.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:  utils.c
 
  Description:  
 
  Version:  1.0
  Created:  06/16/07 14:56:05 CEST
  Revision:  
    0 - created (Ge@@ru)
    1 - created doxygen documentation and added support for
        opaque struct (Ge@@ru) - 11/07/07

  Author:   Daniele Rondina aka Ge@@ru , geaaru@gmail.com 
  License:  GPL 2.0
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// easydbus includes
#include "easydbus-core.h"
#include "debug.h"
#include "utils.h"

inline int
easydbus_save_serviceName (struct EasyDbus_core *core,
                           char *serviceName)
{
   int serviceNameL = 0;

   serviceNameL = strlen (serviceName) + 1;
   core->service_name = (char *) malloc (serviceNameL);

   if (core->service_name == NULL)
      return -1;

   EASYDBUS_MEMCOPY (core->service_name, serviceName, 
                     serviceNameL);

   return 0;
}

inline char *
prepare_match_string (enum event_type type,
                      char *sender, char *interface,
                      char *member, char *path, char *destination)
{

   unsigned char s, t, i, m, p, d;

   s = t = i = m = p = d = 0;
   int buffer_lenght;
   char *type_string = NULL;
   char *buffer = NULL;

   switch (type) {
      case EASYDBUS_ET_METHOD:
         type_string = (char *) dbus_message_type_to_string
            (DBUS_MESSAGE_TYPE_METHOD_CALL);
         t = 1;
         break;
      case EASYDBUS_ET_SIGNAL:
         type_string = (char *) dbus_message_type_to_string
            (DBUS_MESSAGE_TYPE_SIGNAL);
         t = 1;
         break;
      case EASYDBUS_ET_REPLY:
         type_string = (char *) dbus_message_type_to_string
            (DBUS_MESSAGE_TYPE_METHOD_RETURN);
         t = 1;
         break;
      case EASYDBUS_ET_FAILURE:
         type_string = (char *) dbus_message_type_to_string
            (DBUS_MESSAGE_TYPE_ERROR);
         t = 1;
         break;
      default:
         return NULL;
         break;
   }

   if (sender != NULL)
      s = 1;
   if (interface != NULL)
      i = 1;
   if (member != NULL)
      m = 1;
   if (path != NULL)
      p = 1;
   if (destination != NULL)
      d = 1;

   buffer_lenght =
      (t ? strlen (type_string) + 1 + 7 : 0) +
      (s ? strlen (sender) + 1 + 9 : 0) +
      (i ? strlen (interface) + 1 + 12 : 0) +
      (m ? strlen (member) + 1 + 8 : 0) +
      (p ? strlen (path) + 1 + 7 : 0) +
      (d ? strlen (destination) + 1 + 14 : 0) + 10;

   buffer = (char *) malloc (buffer_lenght);
   if (buffer == NULL)
      return NULL;
   memset (buffer, 0, buffer_lenght);

   snprintf (buffer, buffer_lenght,
             "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
             (t ? EASYDBUS_MATCHRULE_FOR_TYPE : ""),
             (t ? type_string : ""),
             (t ? EASYDBUS_MATCHRULE_FOR_SINGLE_QUOTE : ""),
             (t ? ((s || i || m || p || d) ?
                   EASYDBUS_MATCHRULE_FOR_COMMA : "") : ""),
             (s ? EASYDBUS_MATCHRULE_FOR_SENDER : ""),
             (s ? sender : ""),
             (s ? EASYDBUS_MATCHRULE_FOR_SINGLE_QUOTE : ""),
             (s ? ((i || m || p || d) ?
                   EASYDBUS_MATCHRULE_FOR_COMMA : "") : ""),
             (i ? EASYDBUS_MATCHRULE_FOR_INTERFACE : ""),
             (i ? interface : ""),
             (i ? EASYDBUS_MATCHRULE_FOR_SINGLE_QUOTE : ""),
             (i ? ((m || p || d) ?
                   EASYDBUS_MATCHRULE_FOR_COMMA : "") : ""),
             (m ? EASYDBUS_MATCHRULE_FOR_MEMBER : ""),
             (m ? member : ""),
             (m ? EASYDBUS_MATCHRULE_FOR_SINGLE_QUOTE : ""),
             (m ? ((p || d) ?
                   EASYDBUS_MATCHRULE_FOR_COMMA : "") : ""),
             (p ? EASYDBUS_MATCHRULE_FOR_PATH : ""),
             (p ? path : ""),
             (p ? EASYDBUS_MATCHRULE_FOR_SINGLE_QUOTE : ""),
             (p ? (d ? EASYDBUS_MATCHRULE_FOR_COMMA : "") : ""),
             (d ? EASYDBUS_MATCHRULE_FOR_DESTINATION : ""),
             (d ? destination : ""),
             (d ? EASYDBUS_MATCHRULE_FOR_SINGLE_QUOTE : ""));

   return buffer;
}


int
count_elems (struct EasyDbus_elem *el,
             int *error, enum signature_flags flags)
{
   struct EasyDbus_container *container;
   struct EasyDbus_elem *internal_el;
   int elems_founded = 0;
   unsigned int i;

   switch (el->type) {
      case EASYDBUS_ELTYPE_STRING:
      case EASYDBUS_ELTYPE_BYTE:
      case EASYDBUS_ELTYPE_BOOLEAN:
      case EASYDBUS_ELTYPE_DOUBLE:
      case EASYDBUS_ELTYPE_INT16:
      case EASYDBUS_ELTYPE_UINT16:
      case EASYDBUS_ELTYPE_INT32:
      case EASYDBUS_ELTYPE_UINT32:
      case EASYDBUS_ELTYPE_INT64:
      case EASYDBUS_ELTYPE_UINT64:
      case EASYDBUS_ELTYPE_OBJECT_PATH:
      case EASYDBUS_ELTYPE_SIGNATURE:
         //EasyDbusDebug ("founded elem\n");
         elems_founded++;
         break;
      case EASYDBUS_ELTYPE_VARIANT:
         /* variant is composed by v signature
          * and a normal type:
          * signature[..] := DBUS_TYPE_VARIANT
          * signature[..+1] := DBUS_TYPE_* 
          */
         if (flags & EASYDBUS_SIGNATURE_VARIANT)
            elems_founded += 1;
         elems_founded += 1;
         EasyDbusDebug ("founded elem %d\n", elems_founded);
         break;
      case EASYDBUS_ELTYPE_DICT_ENTRY:
         EasyDbusDebug ("founded elem\n");
         /* dict_entry is composed by:
          * DBUS_DICT_ENTRY_BEGIN_CHAR
          * + 2 elems
          * DBUS_DICT_ENTRY_END_CHAR */
         container = el->payload.p_container;
         elems_founded += 2;
         internal_el = (struct EasyDbus_elem *) container->p_data;
         for (i = 0; i < 2; i++) {
            elems_founded += count_elems (internal_el, error, flags);
            if (*error == 1)
               return 0;
            internal_el = internal_el->next;
         }
         break;
      case EASYDBUS_ELTYPE_STRUCT:
         // for STRUCT type it is needed
         // two field for 
         // DBUS_STRUCT_BEGIN_CHAR
         // DBUS_STRUCT_END_CHAR
         container = el->payload.p_container;
         elems_founded += 2;
         internal_el = (struct EasyDbus_elem *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            EasyDbusDebug ("manage elem %d of struct\n", i + 1);
            elems_founded += count_elems (internal_el, error, flags);
            if (*error == 1)
               return 0;
            internal_el = internal_el->next;
            EasyDbusDebug ("founded elem %d\n", elems_founded);
         }
         EasyDbusDebug ("founded elem %d\n", elems_founded);
         break;
      case EASYDBUS_ELTYPE_INVALID:
         *error = 1;
         break;
      case EASYDBUS_ELTYPE_ARRAY:
         EasyDbusDebug ("founded elem\n");
         container = el->payload.p_container;
         elems_founded = 1;
         switch (container->elem_type) {
            case EASYDBUS_ELTYPE_ARRAY:
               internal_el = (struct EasyDbus_elem *)
                  container->p_data;
               for (i = 0; i < container->nel; i++) {
                  elems_founded +=
                     count_elems (internal_el, error, flags);
                  if (*error == 1)
                     return 0;
                  internal_el++;
               }
               EasyDbusDebug ("founded elem\n");
               break;
            case EASYDBUS_ELTYPE_STRING:
            case EASYDBUS_ELTYPE_BYTE:
            case EASYDBUS_ELTYPE_BOOLEAN:
            case EASYDBUS_ELTYPE_DOUBLE:
            case EASYDBUS_ELTYPE_INT16:
            case EASYDBUS_ELTYPE_UINT16:
            case EASYDBUS_ELTYPE_INT32:
            case EASYDBUS_ELTYPE_UINT32:
            case EASYDBUS_ELTYPE_INT64:
            case EASYDBUS_ELTYPE_UINT64:
            case EASYDBUS_ELTYPE_OBJECT_PATH:
            case EASYDBUS_ELTYPE_SIGNATURE:
               EasyDbusDebug ("founded elem\n");
               elems_founded++;
               break;
            case EASYDBUS_ELTYPE_VARIANT:
               elems_founded += 2;
               EasyDbusDebug ("founded elem %d\n", elems_founded);
               break;
            case EASYDBUS_ELTYPE_DICT_ENTRY:
               container = el->payload.p_container;
               elems_founded += 2;
               internal_el =
                  (struct EasyDbus_elem *) container->p_data;
               internal_el = internal_el->payload.p_container->p_data;
               for (i = 0; i < 2; i++) {
                  EasyDbusDebug ("founded elem %d\n", elems_founded);
                  elems_founded +=
                     count_elems (internal_el, error, flags);
                  if (*error == 1)
                     return 0;
                  internal_el = internal_el->next;
               }
               EasyDbusDebug ("founded elem %d\n", elems_founded);
               break;
            case EASYDBUS_ELTYPE_STRUCT:
               container = el->payload.p_container;
               internal_el =
                  (struct EasyDbus_elem *) container->p_data;
               elems_founded +=
                  count_elems (internal_el, error, flags);
               if (*error == 1)
                  return 0;
               EasyDbusDebug ("founded elem %d\n", elems_founded);
               break;
            case EASYDBUS_ELTYPE_INVALID:
               *error = 1;
               break;
         }
         break;
   }
   return elems_founded;
}

int
count_total_elems (struct EasyDbus_elem *el, int *error)
{
   int elems_founded = 0;

   *error = 0;
   while (el != NULL) {
      elems_founded += count_elems (el, error,
                                    EASYDBUS_SIGNATURE_NORMAL);
      el = el->next;
   }
   return elems_founded;
}

char *
prepare_complete_signature (struct EasyDbus_elem *el) 
{
   int number_of_elems = 0;
   int num_of_elems_from_one_node = 0;
   char *signature = NULL;
   int error = 0;

   if (el != NULL)
      number_of_elems = count_total_elems (el, &error);
   if (error)
      return NULL;
   EasyDbusDebug ("COUNT = %d\n", number_of_elems);
   signature = (char *) malloc (sizeof (char[number_of_elems + 1]));
   if (signature == NULL)
      return NULL;
   memset (signature, 0, number_of_elems + 1);

   while (el != NULL) {
      if (set_signature (el, signature,
                         num_of_elems_from_one_node,
                         EASYDBUS_SIGNATURE_NORMAL)) {
         free (signature);
         return NULL;
      }
      num_of_elems_from_one_node += count_elems (el, &error, 0);
      EasyDbusDebug ("Signature prepared for %d elems: %s",
          num_of_elems_from_one_node, signature);
      el = el->next;
   }
   EasyDbusDebug ("Signature complete prepared for %d elems: %s",
                  number_of_elems, signature);
   return signature;
}

char *
prepare_signature (struct EasyDbus_elem *el, 
                   enum signature_flags flags)
{
   int number_of_elems = 0;
   char *signature = NULL;
   int error = 0;

   if (el != NULL)
      number_of_elems = count_elems (el, &error, flags);
   if (error)
      return NULL;
   EasyDbusDebug ("COUNT = %d\n", number_of_elems);
   signature = (char *) malloc (sizeof (char[number_of_elems + 1]));
   if (signature == NULL)
      return NULL;
   memset (signature, 0, number_of_elems + 1);

   if (set_signature (el, signature, 0, flags)) {
      free (signature);
      return NULL;
   }
   EasyDbusDebug ("Signature prepared for %d elems: %s",
                  number_of_elems, signature);
   return signature;
}

int
set_signature (struct EasyDbus_elem *el, char *signature,
               int offset, enum signature_flags flags)
{
   struct EasyDbus_container *container = NULL;
   struct EasyDbus_elem *dict_entry = NULL;
   struct EasyDbus_container *dict_container = NULL;
   struct EasyDbus_elem *internal_el = NULL;
   unsigned int i;
   int error = 0;

   switch (el->type) {
      case EASYDBUS_ELTYPE_STRING:
         signature[offset] = DBUS_TYPE_STRING;
         break;
      case EASYDBUS_ELTYPE_BYTE:
         signature[offset] = DBUS_TYPE_BYTE;
         break;
      case EASYDBUS_ELTYPE_BOOLEAN:
         signature[offset] = DBUS_TYPE_BOOLEAN;
         break;
      case EASYDBUS_ELTYPE_DOUBLE:
         signature[offset] = DBUS_TYPE_DOUBLE;
         break;
      case EASYDBUS_ELTYPE_INT16:
         signature[offset] = DBUS_TYPE_INT16;
         break;
      case EASYDBUS_ELTYPE_UINT16:
         signature[offset] = DBUS_TYPE_UINT16;
         break;
      case EASYDBUS_ELTYPE_INT32:
         signature[offset] = DBUS_TYPE_INT32;
         break;
      case EASYDBUS_ELTYPE_UINT32:
         signature[offset] = DBUS_TYPE_UINT32;
         break;
      case EASYDBUS_ELTYPE_INT64:
         signature[offset] = DBUS_TYPE_INT64;
         break;
      case EASYDBUS_ELTYPE_UINT64:
         signature[offset] = DBUS_TYPE_UINT64;
         break;
      case EASYDBUS_ELTYPE_OBJECT_PATH:
         signature[offset] = DBUS_TYPE_OBJECT_PATH;
         break;
      case EASYDBUS_ELTYPE_SIGNATURE:
         signature[offset] = DBUS_TYPE_SIGNATURE;
         break;
      case EASYDBUS_ELTYPE_VARIANT:
         signature[offset] = DBUS_TYPE_VARIANT;
         if (flags & EASYDBUS_SIGNATURE_VARIANT) {
            container = el->payload.p_container;
            switch (container->elem_type) {
               case EASYDBUS_ELTYPE_STRING:
                  signature[offset + 1] = DBUS_TYPE_STRING;
                  break;
               case EASYDBUS_ELTYPE_BYTE:
                  signature[offset + 1] = DBUS_TYPE_BYTE;
                  break;
               case EASYDBUS_ELTYPE_DOUBLE:
                  signature[offset + 1] = DBUS_TYPE_DOUBLE;
                  break;
               case EASYDBUS_ELTYPE_BOOLEAN:
                  signature[offset + 1] = DBUS_TYPE_BOOLEAN;
                  break;
               case EASYDBUS_ELTYPE_INT16:
                  signature[offset + 1] = DBUS_TYPE_INT16;
                  break;
               case EASYDBUS_ELTYPE_UINT16:
                  signature[offset + 1] = DBUS_TYPE_UINT16;
                  break;
               case EASYDBUS_ELTYPE_INT32:
                  signature[offset + 1] = DBUS_TYPE_INT32;
                  break;
               case EASYDBUS_ELTYPE_UINT32:
                  signature[offset + 1] = DBUS_TYPE_UINT32;
                  break;
               case EASYDBUS_ELTYPE_INT64:
                  signature[offset + 1] = DBUS_TYPE_INT64;
                  break;
               case EASYDBUS_ELTYPE_UINT64:
                  signature[offset + 1] = DBUS_TYPE_UINT64;
                  break;
               case EASYDBUS_ELTYPE_OBJECT_PATH:
                  signature[offset + 1] = DBUS_TYPE_OBJECT_PATH;
                  break;
               case EASYDBUS_ELTYPE_SIGNATURE:
                  signature[offset + 1] = DBUS_TYPE_SIGNATURE;
                  break;
               default:
                  /* manage error  */
                  break;
            }
         }                      // end of if (flags)
         break;
      case EASYDBUS_ELTYPE_STRUCT:
         signature[offset] = DBUS_STRUCT_BEGIN_CHAR;
         container = el->payload.p_container;
         internal_el = (struct EasyDbus_elem *)
            container->p_data;
         i = 1;
         while (internal_el != NULL) {
            if (set_signature (internal_el, signature,
                               offset + i, flags))
               return -1;
            // found offset for signature of next element.
            i += count_elems (internal_el, &error,
                              EASYDBUS_SIGNATURE_NORMAL);
            if (error == 1)
               EasyDbusDebug ("Error on calculate"
                              " offset for signature");
            internal_el = internal_el->next;
            EasyDbusDebug ("offset = %d, i = %d", offset, i);
         }
         signature[offset + i] = DBUS_STRUCT_END_CHAR;
         break;
      case EASYDBUS_ELTYPE_DICT_ENTRY:
         signature[offset] = DBUS_DICT_ENTRY_BEGIN_CHAR;
         container = el->payload.p_container;
         internal_el = (struct EasyDbus_elem *)
            container->p_data;
         if (set_signature
             (internal_el, signature, offset + 1, flags))
            return -1;
         if (set_signature (internal_el->next,
                            signature, offset + 2, flags))
            return -1;
         /* signature for dict_entry with variant must indicate
          * only variant char not element of variant char. So,
          * for example for a dict entry of string and variant
          * char, is needed:
          * - a signature {sv} for dict_entry;
          * - a signature {vs} for variant.
          */
         if (internal_el->next->type == EASYDBUS_ELTYPE_VARIANT
             && (flags & EASYDBUS_SIGNATURE_VARIANT))
            signature[offset + 4] = DBUS_DICT_ENTRY_END_CHAR;
         else
            signature[offset + 3] = DBUS_DICT_ENTRY_END_CHAR;
         break;
      case EASYDBUS_ELTYPE_INVALID:
         break;
      case EASYDBUS_ELTYPE_ARRAY:
         signature[offset] = DBUS_TYPE_ARRAY;
         container = el->payload.p_container;
         switch (container->elem_type) {
            case EASYDBUS_ELTYPE_ARRAY:
               internal_el =
                  (struct EasyDbus_elem *) container->p_data;
               for (i = 0; i < container->nel; i++) {
                  if (set_signature (internal_el,
                                     signature, offset + 1, flags))
                     return -1;
                  internal_el++;
               }
               break;
               /* isn't possible use also set_signature() in recursive
                * mode because data for string, byte, etc. on array
                * are saved without struct EasyDbus_elem container 
                * for limit used memory */
            case EASYDBUS_ELTYPE_STRING:
               signature[offset + 1] = DBUS_TYPE_STRING;
               break;
            case EASYDBUS_ELTYPE_BYTE:
               signature[offset + 1] = DBUS_TYPE_BYTE;
               break;
            case EASYDBUS_ELTYPE_BOOLEAN:
               signature[offset + 1] = DBUS_TYPE_BOOLEAN;
               break;
            case EASYDBUS_ELTYPE_DOUBLE:
               signature[offset + 1] = DBUS_TYPE_DOUBLE;
               break;
            case EASYDBUS_ELTYPE_INT16:
               signature[offset + 1] = DBUS_TYPE_INT16;
               break;
            case EASYDBUS_ELTYPE_UINT16:
               signature[offset + 1] = DBUS_TYPE_UINT16;
               break;
            case EASYDBUS_ELTYPE_INT32:
               signature[offset + 1] = DBUS_TYPE_INT32;
               break;
            case EASYDBUS_ELTYPE_UINT32:
               signature[offset + 1] = DBUS_TYPE_UINT32;
               break;
            case EASYDBUS_ELTYPE_INT64:
               signature[offset + 1] = DBUS_TYPE_INT64;
               break;
            case EASYDBUS_ELTYPE_UINT64:
               signature[offset + 1] = DBUS_TYPE_UINT64;
               break;
            case EASYDBUS_ELTYPE_OBJECT_PATH:
               signature[offset + 1] = DBUS_TYPE_OBJECT_PATH;
               break;
            case EASYDBUS_ELTYPE_SIGNATURE:
               signature[offset + 1] = DBUS_TYPE_SIGNATURE;
               break;
            case EASYDBUS_ELTYPE_VARIANT:
               signature[offset + 1] = DBUS_TYPE_VARIANT;
               if (flags & EASYDBUS_SIGNATURE_VARIANT) {
                  container = el->payload.p_container;
                  switch (container->elem_type) {
                     case EASYDBUS_ELTYPE_STRING:
                        signature[offset + 2] = DBUS_TYPE_STRING;
                        break;
                     case EASYDBUS_ELTYPE_DOUBLE:
                        signature[offset + 2] = DBUS_TYPE_DOUBLE;
                        break;
                     case EASYDBUS_ELTYPE_BYTE:
                        signature[offset + 2] = DBUS_TYPE_BYTE;
                        break;
                     case EASYDBUS_ELTYPE_BOOLEAN:
                        signature[offset + 2] = DBUS_TYPE_BOOLEAN;
                        break;
                     case EASYDBUS_ELTYPE_INT16:
                        signature[offset + 2] = DBUS_TYPE_INT16;
                        break;
                     case EASYDBUS_ELTYPE_UINT16:
                        signature[offset + 2] = DBUS_TYPE_UINT16;
                        break;
                     case EASYDBUS_ELTYPE_INT32:
                        signature[offset + 2] = DBUS_TYPE_INT32;
                        break;
                     case EASYDBUS_ELTYPE_UINT32:
                        signature[offset + 2] = DBUS_TYPE_UINT32;
                        break;
                     case EASYDBUS_ELTYPE_INT64:
                        signature[offset + 2] = DBUS_TYPE_INT64;
                        break;
                     case EASYDBUS_ELTYPE_UINT64:
                        signature[offset + 2] = DBUS_TYPE_UINT64;
                        break;
                     case EASYDBUS_ELTYPE_OBJECT_PATH:
                        signature[offset + 2] = DBUS_TYPE_OBJECT_PATH;
                        break;
                     case EASYDBUS_ELTYPE_SIGNATURE:
                        signature[offset + 2] = DBUS_TYPE_SIGNATURE;
                     default:
                        /* manage error  */
                        break;
                  }
               }                //end of if (flags)
               break;
            case EASYDBUS_ELTYPE_DICT_ENTRY:
               signature[offset + 1] = DBUS_DICT_ENTRY_BEGIN_CHAR;
               /* point to dict_entry element container */
               container = el->payload.p_container;
               dict_entry = container->p_data;
               /* recover dict_entry container */
               dict_container = dict_entry->payload.p_container;
               /* get first element of dict_entry container */
               internal_el = (struct EasyDbus_elem *)
                  dict_container->p_data;
               if (set_signature (internal_el,
                                  signature, offset + 2, flags))
                  return -1;
               if (set_signature (internal_el->next,
                                  signature, offset + 3, flags))
                  return -1;
               if ((internal_el->next->type ==
                    EASYDBUS_ELTYPE_VARIANT) &&
                   (flags & EASYDBUS_SIGNATURE_VARIANT))
                  signature[offset + 5] = DBUS_DICT_ENTRY_END_CHAR;
               else
                  signature[offset + 4] = DBUS_DICT_ENTRY_END_CHAR;
               break;
            case EASYDBUS_ELTYPE_STRUCT:
               container = el->payload.p_container;
               internal_el = (struct EasyDbus_elem *)
                  container->p_data;
               if (set_signature (internal_el, signature,
                                  offset + 1, flags))
                  return -1;
               break;
            case EASYDBUS_ELTYPE_INVALID:
               return -1;
               break;
         }                      // end of switch
         break;
   }
   return 0;
}

char *
add_el_signature (enum el_type type_el,
                  char *old_signature, int marshal_data_status)
{
   char *signature = NULL;
   int offset = 0;
   int signature_length = 0;

   if (old_signature == NULL) {
      signature = (char *) malloc (2);
      if (signature == NULL)
         return NULL;
      memset (signature, 0, 2);

   }
   else {
      signature_length = strlen (old_signature) + 1;
      signature = (char *) malloc (signature_length + 1);
      if (signature == NULL)
         return NULL;
      memset (signature, 0, signature_length + 1);
      memcpy (signature, old_signature, signature_length);
      offset = signature_length - 1;
      free (old_signature);
   }

   switch (type_el) {
      case EASYDBUS_ELTYPE_STRING:
         signature[offset] = DBUS_TYPE_STRING;
         break;
      case EASYDBUS_ELTYPE_BYTE:
         signature[offset] = DBUS_TYPE_BYTE;
         break;
      case EASYDBUS_ELTYPE_BOOLEAN:
         signature[offset] = DBUS_TYPE_BOOLEAN;
         break;
      case EASYDBUS_ELTYPE_DOUBLE:
         signature[offset] = DBUS_TYPE_DOUBLE;
         break;
      case EASYDBUS_ELTYPE_INT16:
         signature[offset] = DBUS_TYPE_INT16;
         break;
      case EASYDBUS_ELTYPE_UINT16:
         signature[offset] = DBUS_TYPE_UINT16;
         break;
      case EASYDBUS_ELTYPE_INT32:
         signature[offset] = DBUS_TYPE_INT32;
         break;
      case EASYDBUS_ELTYPE_UINT32:
         signature[offset] = DBUS_TYPE_UINT32;
         break;
      case EASYDBUS_ELTYPE_INT64:
         signature[offset] = DBUS_TYPE_INT64;
         break;
      case EASYDBUS_ELTYPE_UINT64:
         signature[offset] = DBUS_TYPE_UINT64;
         break;
      case EASYDBUS_ELTYPE_OBJECT_PATH:
         signature[offset] = DBUS_TYPE_OBJECT_PATH;
         break;
      case EASYDBUS_ELTYPE_VARIANT:
         signature[offset] = DBUS_TYPE_VARIANT;
         break;
      case EASYDBUS_ELTYPE_DICT_ENTRY:
         if (marshal_data_status)
            signature[offset] = DBUS_DICT_ENTRY_END_CHAR;
         else
            signature[offset] = DBUS_DICT_ENTRY_BEGIN_CHAR;
         break;
      case EASYDBUS_ELTYPE_ARRAY:
         signature[offset] = DBUS_TYPE_ARRAY;
         break;
      case EASYDBUS_ELTYPE_SIGNATURE:
         signature[offset] = DBUS_TYPE_SIGNATURE;
         break;
      case EASYDBUS_ELTYPE_STRUCT:
         if (marshal_data_status)
            signature[offset] = DBUS_STRUCT_END_CHAR;
         else
            signature[offset] = DBUS_STRUCT_BEGIN_CHAR;
         break;
      case EASYDBUS_ELTYPE_INVALID:
         goto error;
         break;
   }

   return signature;

 error:
   if (signature != NULL)
      free (signature);
   return NULL;
}

int
easydbus_manage_list_signature (struct easydbus_signature_elem_stack *el, 
                                char **signature, int flags)
{
   enum el_type type = EASYDBUS_ELTYPE_INVALID;
   struct easydbus_signature_elem_stack *tmp = NULL;

   if (el == NULL || signature == NULL)
      return -1;

   switch (el->type) {
      case EASYDBUS_ELTYPE_VARIANT:
         if (el->next == NULL)
            return -1;
         *signature = add_el_signature (el->type, *signature, 0);
         /* variant element type is ignored */
         //container->signature = add_el_signature 
         // (el->next->type, container->signature, 0);
         EasyDbusDebug ("Ignore variant element type");
         easydbus_free_elem_from_stack (el->next);
         break;
      case EASYDBUS_ELTYPE_DICT_ENTRY:
         /* dict entry signature are managed in this way:
          * - EASYDBUS_ELTYPE_DICT_ENTRY +
          *   EASYDBUS_ELTYPE_1+ EASYDBUS_ELTYPE_2
          *   if elem of dict entry is a variant element, then
          *   also another field is inserted.
          */
         // open dict_entry
         *signature = add_el_signature (el->type, *signature, 0);
         /* check first elem (the key) */
         if (el->next == NULL)
            return -1;
         type = el->next->type;

         if (type == EASYDBUS_ELTYPE_INVALID ||
             type == EASYDBUS_ELTYPE_ARRAY ||
             type == EASYDBUS_ELTYPE_STRUCT ||
             type == EASYDBUS_ELTYPE_DICT_ENTRY)
            return -1;

         if (easydbus_manage_list_signature
             (el->next, signature, flags))
            return -1;

         /* check second elem */
         if (el->next->next == NULL)
            return -1;
         type = el->next->next->type;

         if (type == EASYDBUS_ELTYPE_INVALID ||
             type == EASYDBUS_ELTYPE_ARRAY ||
             type == EASYDBUS_ELTYPE_STRUCT ||
             type == EASYDBUS_ELTYPE_DICT_ENTRY)
            return -1;

         if (easydbus_manage_list_signature
             (el->next->next, signature, flags))
            return -1;

         /* remove dict entry elements */
         easydbus_free_elem_from_stack (el->next);
         easydbus_free_elem_from_stack (el->next);

         // close dict_entry 
         *signature = add_el_signature (el->type, *signature, 1);
         break;
      case EASYDBUS_ELTYPE_STRUCT:
         *signature = add_el_signature (el->type, *signature, 0);
         while (el->next != NULL &&
                el->next->type != EASYDBUS_ELTYPE_STRUCT &&
                el->next->type != EASYDBUS_ELTYPE_INVALID) {
            if (easydbus_manage_list_signature
                (el->next, signature, flags))
               return -1;
            tmp = el->next;
            el->next = el->next->next;
            easydbus_free_elem_from_stack (tmp);
         }
         if (el->next == NULL)
            return -1;
         if (el->next->type == EASYDBUS_ELTYPE_STRUCT) {
            *signature = add_el_signature
               (el->next->type, *signature, 1);
         }
         else
            return -1;
         easydbus_free_elem_from_stack (el->next);
         break;
      case EASYDBUS_ELTYPE_ARRAY:
         *signature = add_el_signature (el->type, *signature, 0);
         if (el->next == NULL)
            return -1;
         if (easydbus_manage_list_signature (el->next,
                                             signature, flags))
            return -1;
         // remove array element 
         easydbus_free_elem_from_stack (el->next);
         break;
      case EASYDBUS_ELTYPE_INVALID:
         return -1;
         break;
      default:
         *signature = add_el_signature (el->type, *signature, 0);
         break;
   }

   return 0;
}

enum el_type
get_easydbus_type_from_dbus_type (int type)
{
   switch (type) {
      case DBUS_TYPE_ARRAY:
         return EASYDBUS_ELTYPE_ARRAY;
         break;
      case DBUS_TYPE_STRUCT:
         return EASYDBUS_ELTYPE_STRUCT;
         break;
      case DBUS_TYPE_VARIANT:
         return EASYDBUS_ELTYPE_VARIANT;
         break;
      case DBUS_TYPE_DICT_ENTRY:
         return EASYDBUS_ELTYPE_DICT_ENTRY;
         break;
      case DBUS_TYPE_SIGNATURE:
         return EASYDBUS_ELTYPE_SIGNATURE;
         break;
      case DBUS_TYPE_OBJECT_PATH:
         return EASYDBUS_ELTYPE_OBJECT_PATH;
         break;
      case DBUS_TYPE_DOUBLE:
         return EASYDBUS_ELTYPE_DOUBLE;
         break;
      case DBUS_TYPE_BOOLEAN:
         return EASYDBUS_ELTYPE_BOOLEAN;
         break;
      case DBUS_TYPE_BYTE:
         return EASYDBUS_ELTYPE_BYTE;
         break;
      case DBUS_TYPE_UINT64:
         return EASYDBUS_ELTYPE_UINT64;
         break;
      case DBUS_TYPE_INT64:
         return EASYDBUS_ELTYPE_INT64;
         break;
      case DBUS_TYPE_UINT16:
         return EASYDBUS_ELTYPE_UINT16;
         break;
      case DBUS_TYPE_INT16:
         return EASYDBUS_ELTYPE_INT16;
         break;
      case DBUS_TYPE_INT32:
         return EASYDBUS_ELTYPE_INT32;
         break;
      case DBUS_TYPE_UINT32:
         return EASYDBUS_ELTYPE_UINT32;
         break;
      case DBUS_TYPE_STRING:
         return EASYDBUS_ELTYPE_STRING;
         break;
      default:
         return EASYDBUS_ELTYPE_INVALID;
         break;
   }
}

inline struct EasyDbus_object_box *
easydbus_get_obj (struct EasyDbus_object_box *objects,
                  const char *object_path)
{

   while (objects != NULL) {
      if (!strcmp (object_path, objects->core.path))
         return objects;
      objects = objects->next;
   }
   return NULL;
}

// vim: ts=3 shiftwidth=3 expandtab

---