skeleton.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:  skeleton.c

  Description:  

  Version:  0.1
  Created:  06/09/07 09:55:14 CEST
  Revision: 
      0 - created (Ge@@ru)

  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 "elem_internal.h"
#include "debug.h"
#include "variant_internal.h"
#include "dict_entry_internal.h"
#include "struct_internal.h"
#include "array_internal.h"

int
easydbus_add_variant_param_to_skeleton (enum event_type type,
                                        void *skeleton, 
                                        struct EasyDbus_container *container) 
{
   struct EasyDbus_elem *el = NULL;

   if (!container || !skeleton ||
       container->container_type != EASYDBUS_ELTYPE_VARIANT)
      return -1;

   el = easydbus_elem_create (EASYDBUS_ELTYPE_VARIANT);
   if (!el)
      return -1;
   el->payload.p_container = container;

   easydbus_elem_add_to_skeleton (type, skeleton, el);

   return 0;

}

int 
easydbus_add_struct_param_to_skeleton (enum event_type type,
                                       void *skeleton, 
                                       struct EasyDbus_container *container) 
{
   struct EasyDbus_elem *el = NULL;

   if (container == NULL ||
       skeleton == NULL ||
       container->container_type != EASYDBUS_ELTYPE_STRUCT)
      return -1;

   el = easydbus_elem_create (EASYDBUS_ELTYPE_STRUCT);
   if (!el)
      return -1;
   el->payload.p_container = container;

   easydbus_elem_add_to_skeleton (type, skeleton, el);

   return 0;
}

int
easydbus_add_ui16_param_to_skeleton (enum event_type type, 
                                     void *skeleton, 
                                     unsigned short i) 
{
   struct EasyDbus_elem *el = NULL;

   el = easydbus_elem_create (EASYDBUS_ELTYPE_UINT16);
   if (!el)
      return -1;
   el->payload.ui16 = i;

   easydbus_elem_add_to_skeleton (type, skeleton, el);

   return 0;
}


int
easydbus_add_i16_param_to_skeleton (enum event_type type, 
                                    void *skeleton, short i) 
{
   struct EasyDbus_elem *el = NULL;

   el = easydbus_elem_create (EASYDBUS_ELTYPE_INT16);
   if (!el)
      return -1;
   el->payload.i16 = i;

   easydbus_elem_add_to_skeleton (type, skeleton, el);

   return 0;
}

int
easydbus_add_byte_param_to_skeleton (enum event_type type, 
                                     void *skeleton, char byte) 
{
   struct EasyDbus_elem *el = NULL;

   el = easydbus_elem_create (EASYDBUS_ELTYPE_BYTE);
   if (!el)
      return -1;
   el->payload.byte = byte;

   easydbus_elem_add_to_skeleton (type, skeleton, el);

   return 0;
}

int
easydbus_add_boolean_param_to_skeleton (enum event_type type, 
                                        void *skeleton, 
                                        unsigned char boolean) 
{
   struct EasyDbus_elem *el = NULL;

   if (boolean > 1)
      return -1;

   el = easydbus_elem_create (EASYDBUS_ELTYPE_BOOLEAN);
   if (!el)
      return -1;
   el->payload.boolean = boolean;

   easydbus_elem_add_to_skeleton (type, skeleton, el);

   return 0;
}

int
easydbus_add_array_param_to_skeleton (enum event_type type,
                                      void *skeleton, 
                                      struct EasyDbus_container *container)
{
   struct EasyDbus_elem *el = NULL;

   if (!container || !skeleton)
      return -1;

   el = easydbus_elem_create (EASYDBUS_ELTYPE_ARRAY);
   if (!el)
      return -1;

   el->payload.p_container = container;

   easydbus_elem_add_to_skeleton (type, skeleton, el);

   return 0;
}

int
easydbus_add_string_param_to_skeleton (enum event_type type, 
                                       void *skeleton, 
                                       char *string)
{
   struct EasyDbus_elem *el = NULL;
   int string_length = 0;

   if (!string || !skeleton)
      return -1;

   el = easydbus_elem_create (EASYDBUS_ELTYPE_STRING);
   if (!el)
      return -1;

   string_length = strlen (string) + 1;
   el->payload.string = (char *) malloc (string_length);

   if (!el->payload.string) {
      easydbus_elem_free (el);
      return -1;
   }

   EASYDBUS_MEMCOPY (el->payload.string, string, string_length);

   easydbus_elem_add_to_skeleton (type, skeleton, el);

   return 0;
}

int
easydbus_add_obj_path_param_to_skeleton (enum event_type type, 
                                         void *skeleton, 
                                         char *string) 
{
   struct EasyDbus_elem *el = NULL;
   int string_length = 0;

   if (!string || !skeleton)
      return -1;

   el = easydbus_elem_create (EASYDBUS_ELTYPE_OBJECT_PATH);
   if (!el)
      return -1;

   string_length = strlen (string) + 1;
   el->payload.string = (char *) malloc (string_length);

   if (!el->payload.string) {
      easydbus_elem_free (el);
      return -1;
   }

   EASYDBUS_MEMCOPY (el->payload.string, string, string_length);

   easydbus_elem_add_to_skeleton (type, skeleton, el);

   return 0;
}

int
easydbus_add_signature_param_to_skeleton (enum event_type type, 
                                          void *skeleton, 
                                          char *signature) 
{
   struct EasyDbus_elem *el = NULL;
   int string_length = 0;

   if (!signature || !skeleton)
      return -1;

   el = easydbus_elem_create (EASYDBUS_ELTYPE_SIGNATURE);
   if (!el)
      return -1;

   string_length = strlen (signature) + 1;
   el->payload.string = (char *) malloc (string_length);

   if (!el->payload.string) {
      easydbus_elem_free (el);
      return -1;
   }

   EASYDBUS_MEMCOPY (el->payload.string, signature, string_length);

   easydbus_elem_add_to_skeleton (type, skeleton, el);

   return 0;
}

int 
easydbus_add_ui32_param_to_skeleton (enum event_type type, 
                                     void *skeleton, 
                                     unsigned int i) 
{
   struct EasyDbus_elem *el = NULL;

   el = easydbus_elem_create (EASYDBUS_ELTYPE_UINT32);
   if (!el)
      return -1;
   el->payload.ui32 = i;

   easydbus_elem_add_to_skeleton (type, skeleton, el);

   return 0;
}

int
easydbus_add_double_param_to_skeleton (enum event_type type, 
                                       void *skeleton, 
                                       double d) 
{
   struct EasyDbus_elem *el = NULL;

   el = easydbus_elem_create (EASYDBUS_ELTYPE_DOUBLE);
   if (!el)
      return -1;
   el->payload.Double = d;

   easydbus_elem_add_to_skeleton (type, skeleton, el);

   return 0;
}

int
easydbus_add_i32_param_to_skeleton (enum event_type type, 
                                    void *skeleton, int i) 
{
   struct EasyDbus_elem *el = NULL;

   if (!skeleton)
      return -1;

   el = easydbus_elem_create (EASYDBUS_ELTYPE_INT32);
   if (!el)
      return -1;
   el->payload.i32 = i;

   easydbus_elem_add_to_skeleton (type, skeleton, el);

   return 0;
}

int
easydbus_add_ui64_param_to_skeleton (enum event_type type, 
                                     void *skeleton, 
                                     unsigned long long i) 
{
   struct EasyDbus_elem *el = NULL;

   el = easydbus_elem_create (EASYDBUS_ELTYPE_UINT64);
   if (!el)
      return -1;
   el->payload.ui64 = i;

   easydbus_elem_add_to_skeleton (type, skeleton, el);

   return 0;
}

int
easydbus_add_i64_param_to_skeleton (enum event_type type, 
                                    void *skeleton, 
                                    long long i) 
{
   struct EasyDbus_elem *el = NULL;

   el = easydbus_elem_create (EASYDBUS_ELTYPE_INT64);
   if (!el)
      return -1;
   el->payload.i64 = i;

   easydbus_elem_add_to_skeleton (type, skeleton, el);

   return 0;
}

void
easydbus_elem_add_to_skeleton (enum event_type type,
                               void *event, EasyDbus_elem * el)
{
   struct EasyDbus_signal *signal;
   struct EasyDbus_method *method;
   struct EasyDbus_reply *reply;
   struct EasyDbus_elem *temp;

   temp = NULL;
   reply = NULL;
   method = NULL;
   signal = NULL;

   switch (type) {
      case EASYDBUS_ET_METHOD:
         method = (struct EasyDbus_method *) event;
         if (!method->first)
            method->first = el;
         else {
            temp = method->first;
            while (temp->next)
               temp = temp->next;
            temp->next = el;
         }
         method->args++;
         break;
      case EASYDBUS_ET_SIGNAL:
         signal = (struct EasyDbus_signal *) event;
         if (!signal->first)
            signal->first = el;
         else {
            temp = signal->first;
            while (temp->next)
               temp = temp->next;
            temp->next = el;
         }
         signal->args++;
         break;
      case EASYDBUS_ET_REPLY:
      case EASYDBUS_ET_FAILURE:
         reply = (struct EasyDbus_reply *) event;
         if (!reply->first)
            reply->first = el;
         else {
            temp = reply->first;
            while (temp->next)
               temp = temp->next;
            temp->next = el;
         }
         reply->args++;
         break;
      default:
         return;
         break;
   }
}

int
easydbus_build_skeleton_data (DBusMessage * msg,
                              enum event_type type, void *container)
{
   char *string = NULL;
   int i32 = 0;
   unsigned int ui32 = 0;
   short i16 = 0;
   char byte = 0;
   unsigned short ui16 = 0;
   long long i64 = 0;
   double d = 0;
   unsigned long long ui64 = 0;
   DBusMessageIter iter;
   struct EasyDbus_container *cont_marshal_data = NULL;

#ifdef EASYDBUS_DEBUG
   char *signature = NULL;
#endif

   dbus_message_iter_init (msg, &iter);

   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 (&iter)) {
         case DBUS_TYPE_STRING:
            dbus_message_iter_get_basic (&iter, &string);
            EasyDbusDebug ("founded string = %s\n", string);
            easydbus_add_string_param_to_skeleton (type,
                                                   (void *) container,
                                                   string);
            break;
         case DBUS_TYPE_INT32:
            dbus_message_iter_get_basic (&iter, &i32);
            EasyDbusDebug ("founded int32 = %d", i32);
            easydbus_add_i32_param_to_skeleton (type,
                                                (void *) container,
                                                i32);
            break;
         case DBUS_TYPE_UINT32:
            dbus_message_iter_get_basic (&iter, &ui32);
            EasyDbusDebug ("founded uint32 = %d", ui32);
            easydbus_add_ui32_param_to_skeleton (type,
                                                 (void *) container,
                                                 ui32);
            break;
         case DBUS_TYPE_INT16:
            dbus_message_iter_get_basic (&iter, &i16);
            EasyDbusDebug ("founded int16 = %d", i16);
            easydbus_add_i16_param_to_skeleton (type,
                                                (void *) container,
                                                i16);
            break;
         case DBUS_TYPE_UINT16:
            dbus_message_iter_get_basic (&iter, &ui16);
            EasyDbusDebug ("founded uint16 = %d", ui16);
            easydbus_add_ui16_param_to_skeleton (type,
                                                 (void *) container,
                                                 ui16);
            break;
         case DBUS_TYPE_INT64:
            dbus_message_iter_get_basic (&iter, &i64);
            EasyDbusDebug ("founded int64 = %lld", i64);
            easydbus_add_i64_param_to_skeleton (type,
                                                (void *) container,
                                                i64);
            break;
         case DBUS_TYPE_UINT64:
            dbus_message_iter_get_basic (&iter, &ui64);
            EasyDbusDebug ("founded uint64 = %lld", ui64);
            easydbus_add_ui64_param_to_skeleton (type,
                                                 (void *) container,
                                                 ui64);
            break;
         case DBUS_TYPE_BYTE:
            dbus_message_iter_get_basic (&iter, &byte);
            EasyDbusDebug ("founded byte = %d", byte);
            easydbus_add_byte_param_to_skeleton (type,
                                                 (void *) container,
                                                 byte);
            break;
         case DBUS_TYPE_BOOLEAN:
            dbus_message_iter_get_basic (&iter, &byte);
            EasyDbusDebug ("founded boolean = %d", byte);
            easydbus_add_boolean_param_to_skeleton (type,
                                                    (void *) container,
                                                    byte);
            break;
         case DBUS_TYPE_DOUBLE:
            dbus_message_iter_get_basic (&iter, &d);
            EasyDbusDebug ("founded double = %f", d);
            easydbus_add_double_param_to_skeleton (type,
                                                   (void *) container, d);
            break;
         case DBUS_TYPE_OBJECT_PATH:
            dbus_message_iter_get_basic (&iter, &string);
            EasyDbusDebug ("founded obj_path = %s\n", string);
            easydbus_add_obj_path_param_to_skeleton (type,
                                                     (void *) container,
                                                     string);
            break;
         case DBUS_TYPE_SIGNATURE:
            dbus_message_iter_get_basic (&iter, &string);
            EasyDbusDebug ("founded signature = %s\n", string);
            easydbus_add_signature_param_to_skeleton (type,
                                                      (void *) container,
                                                      string);
            break;
         case DBUS_TYPE_ARRAY:
            cont_marshal_data =
               easydbus_get_marshal_data_from_array (type,
                                                     container,
                                                     dbus_message_iter_get_element_type
                                                     (&iter), &iter);
            if (cont_marshal_data) {
               easydbus_add_array_param_to_skeleton (type,
                                                     container,
                                                     cont_marshal_data);
               EasyDbusDebug ("Added array to container");
            }
            else
               EasyDbusDebug ("Error on manage array");
            break;
         case DBUS_TYPE_VARIANT:
            cont_marshal_data = easydbus_variant_build_elem
               (type, (void *) container, &iter);
            if (cont_marshal_data) {
               easydbus_add_variant_param_to_skeleton (type,
                                                       container,
                                                       cont_marshal_data);
               EasyDbusDebug ("Added variant to container");
            }
            else
               EasyDbusDebug ("Error on add variant to container");
            break;
         case DBUS_TYPE_DICT_ENTRY:
            // dict entry can be inserted only on an array
            goto error;
            break;
         case DBUS_TYPE_STRUCT:
            cont_marshal_data = easydbus_struct_build_elem
               (type, container, &iter);
            if (cont_marshal_data) {
               easydbus_add_struct_param_to_skeleton (type,
                                                      container,
                                                      cont_marshal_data);
               EasyDbusDebug ("Added struct to container");
            }
            else
               EasyDbusDebug ("Error on add struct to container");
            break;
      }
      if (dbus_message_iter_has_next (&iter))
         dbus_message_iter_next (&iter);
      else
         goto exit;
   }
 exit:
   return 0;
 error:
   return -1;
}
// vim: ts=3 shiftwidth=3 expandtab

---