EasyDbus-0.2: struct_internal.c Source File

00001 /*
00002  EasyDbus: DBUS Binding Library.
00003  Copyright (C) 2007  Daniele Rondina aka ge@@ru, geaaru@gmail.com 
00004 
00005  This program is free software; you can redistribute it and/or
00006  modify it under the terms of the GNU General Public License
00007  as published by the Free Software Foundation; either version 2
00008  of the License, or (at your option) any later version.
00009 
00010  This program is distributed in the hope that it will be useful,
00011  but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013  GNU General Public License for more details.
00014 
00015  You should have received a copy of the GNU General Public License
00016  along with this program; if not, write to the Free Software
00017  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
00018 
00019  Filename:  struct_internal.c
00020  
00021  Description:  
00022  
00023  Version:  1.0
00024  Created:  09/08/07 14:24:04 CEST
00025  Revision:  
00026         0 - created (Ge@@ru)
00027  
00028  Author:   Daniele Rondina aka Ge@@ru , geaaru@gmail.com 
00029  License:  GPL 2.0
00030 */
00031 
00036 #include <string.h>
00037 #include <stdlib.h>
00038 // easydbus includes 
00039 #include "easydbus-core.h"
00040 #include "debug.h"
00041 #include "struct_internal.h"
00042 #include "variant_internal.h"
00043 #include "dict_entry_internal.h"
00044 #include "array_internal.h"
00045 #include "utils.h"
00046 
00055 int 
00056 easydbus_add_struct_to_msg (DBusMessage * msg, 
00057                             struct EasyDbus_elem *elem) 
00058 {
00059    DBusMessageIter iter;
00060    DBusMessageIter subiter;
00061    int ret_val = -1;
00062 //   char *signature = NULL;
00063    struct EasyDbus_container *container = NULL;
00064    struct EasyDbus_elem *struct_elem = NULL;
00065 
00066    dbus_message_iter_init_append (msg, &iter);
00067 
00068    container = elem->payload.p_container;
00069 
00070    if (!container->nel) {
00071       if (container->signature == NULL) {
00072          EasyDbusDebug ("Error an empty struct must have a"
00073                         "signature");
00074          return ret_val;
00075       }
00076       if (!dbus_message_iter_open_container (&iter,
00077                                              DBUS_TYPE_STRUCT,
00078                                              container->signature,
00079                                              &subiter)) {
00080          EasyDbusDebug ("Error on open struct container");
00081       }
00082       else {
00083          ret_val = 0;
00084       }
00085       goto end;
00086    }
00087 
00088    /* container has at least one element.
00089     * build signature */
00090    //signature = prepare_signature (elem, EASYDBUS_SIGNATURE_NORMAL);
00091    //EasyDbusDebug ("Signature prepared for struct = %s", signature);
00092 
00093    if (!dbus_message_iter_open_container
00094        (&iter, DBUS_TYPE_STRUCT, NULL, &subiter))
00095       EasyDbusDebug ("Error on open container subiterator");
00096    else
00097       ret_val = 0;
00098 
00099    struct_elem = (struct EasyDbus_elem *) container->p_data;
00100 
00101    while (struct_elem != NULL) {
00102       switch (struct_elem->type) {
00103          case EASYDBUS_ELTYPE_STRING:
00104             dbus_message_iter_append_basic (&subiter,
00105                                             DBUS_TYPE_STRING,
00106                                             &struct_elem->payload.
00107                                             string);
00108             break;
00109          case EASYDBUS_ELTYPE_BYTE:
00110             dbus_message_iter_append_basic (&subiter,
00111                                             DBUS_TYPE_BYTE,
00112                                             &struct_elem->payload.
00113                                             byte);
00114             break;
00115          case EASYDBUS_ELTYPE_BOOLEAN:
00116             dbus_message_iter_append_basic (&subiter,
00117                                             DBUS_TYPE_BOOLEAN,
00118                                             &struct_elem->payload.
00119                                             boolean);
00120             break;
00121          case EASYDBUS_ELTYPE_DOUBLE:
00122             dbus_message_iter_append_basic (&subiter,
00123                                             DBUS_TYPE_DOUBLE,
00124                                             &struct_elem->payload.
00125                                             Double);
00126             break;
00127          case EASYDBUS_ELTYPE_INT16:
00128             dbus_message_iter_append_basic (&subiter,
00129                                             DBUS_TYPE_INT16,
00130                                             &struct_elem->payload.
00131                                             i16);
00132             break;
00133          case EASYDBUS_ELTYPE_UINT16:
00134             dbus_message_iter_append_basic (&subiter,
00135                                             DBUS_TYPE_UINT16,
00136                                             &struct_elem->payload.
00137                                             ui16);
00138             break;
00139          case EASYDBUS_ELTYPE_INT32:
00140             dbus_message_iter_append_basic (&subiter,
00141                                             DBUS_TYPE_INT32,
00142                                             &struct_elem->payload.
00143                                             i32);
00144             break;
00145          case EASYDBUS_ELTYPE_UINT32:
00146             dbus_message_iter_append_basic (&subiter,
00147                                             DBUS_TYPE_UINT32,
00148                                             &struct_elem->payload.
00149                                             ui32);
00150             break;
00151          case EASYDBUS_ELTYPE_INT64:
00152             dbus_message_iter_append_basic (&subiter,
00153                                             DBUS_TYPE_INT64,
00154                                             &struct_elem->payload.
00155                                             i64);
00156             break;
00157          case EASYDBUS_ELTYPE_UINT64:
00158             dbus_message_iter_append_basic (&subiter,
00159                                             DBUS_TYPE_UINT64,
00160                                             &struct_elem->payload.
00161                                             ui64);
00162             break;
00163          case EASYDBUS_ELTYPE_OBJECT_PATH:
00164             dbus_message_iter_append_basic (&subiter,
00165                                             DBUS_TYPE_OBJECT_PATH,
00166                                             &struct_elem->payload.
00167                                             string);
00168             break;
00169          case EASYDBUS_ELTYPE_SIGNATURE:
00170             dbus_message_iter_append_basic (&subiter,
00171                                             DBUS_TYPE_SIGNATURE,
00172                                             &struct_elem->payload.
00173                                             string);
00174             break;
00175          case EASYDBUS_ELTYPE_VARIANT:
00176             if (add_variant_to_container_on_msg
00177                 (msg, struct_elem, &subiter)) {
00178                ret_val = -1;
00179                goto end;
00180             }
00181             break;
00182          case EASYDBUS_ELTYPE_ARRAY:
00183             if (easydbus_add_array_on_container_tomsg
00184                 (msg, &subiter, struct_elem)) {
00185                ret_val = -1;
00186                goto end;
00187             }
00188             break;
00189          case EASYDBUS_ELTYPE_STRUCT:
00190             if (easydbus_add_struct_on_container_msg
00191                 (msg, &subiter, struct_elem)) {
00192                ret_val = -1;
00193                goto end;
00194             }
00195             break;
00196          case EASYDBUS_ELTYPE_DICT_ENTRY:
00197             /*
00198              * Dict entry must be insert on array container
00199              * if (easydbus_add_dict_entry_tomsg 
00200              (msg, &subiter, struct_elem)) {
00201              ret_val = -1;
00202              goto end;
00203              }
00204              break;
00205              */
00206          case EASYDBUS_ELTYPE_INVALID:
00207             EasyDbusDebug ("Error");
00208             ret_val = -1;
00209             goto end;
00210             break;
00211       }                         // end of switch
00212       struct_elem = struct_elem->next;
00213    }                            // end of while
00214 
00215  end:
00216    
00217    //if (signature != NULL)
00218    //   free (signature);
00219 
00220    dbus_message_iter_close_container (&iter, &subiter);
00221 
00222    return ret_val;
00223 }
00224 
00225 
00226 
00241 int 
00242 easydbus_add_struct_on_container_msg (DBusMessage * msg, 
00243                                       DBusMessageIter * iter,
00244                                       struct EasyDbus_elem *elem) 
00245 {
00246    DBusMessageIter subiter;
00247    int ret_val = -1;
00248    //char *signature = NULL;
00249    struct EasyDbus_container *container = NULL;
00250    struct EasyDbus_elem *struct_elem = NULL;
00251 
00252    container = elem->payload.p_container;
00253 
00254    if (!container->nel) {
00255       if (container->signature == NULL) {
00256          EasyDbusDebug ("Error an empty struct must have a"
00257                         "signature");
00258          return ret_val;
00259       }
00260       if (!dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT,
00261                                              container->signature,
00262                                              &subiter)) {
00263          EasyDbusDebug ("Error on open struct container");
00264       }
00265       else {
00266          ret_val = 0;
00267       }
00268       goto end;
00269    }
00270 
00271    /* container has at least one element.
00272     * build signature */
00273 //   signature = prepare_signature (elem, EASYDBUS_SIGNATURE_NORMAL);
00274 //   EasyDbusDebug ("Signature prepared for struct = %s", signature);
00275 
00276    if (!dbus_message_iter_open_container
00277        (iter, DBUS_TYPE_STRUCT, NULL, &subiter))
00278        //(iter, DBUS_TYPE_STRUCT, signature, &subiter))
00279       EasyDbusDebug ("Error on open container subiterator");
00280    else
00281       ret_val = 0;
00282 
00283    struct_elem = (struct EasyDbus_elem *) container->p_data;
00284 
00285    while (struct_elem != NULL) {
00286       switch (struct_elem->type) {
00287          case EASYDBUS_ELTYPE_STRING:
00288             dbus_message_iter_append_basic (&subiter,
00289                                             DBUS_TYPE_STRING,
00290                                             &struct_elem->payload.
00291                                             string);
00292             break;
00293          case EASYDBUS_ELTYPE_BYTE:
00294             dbus_message_iter_append_basic (&subiter,
00295                                             DBUS_TYPE_BYTE,
00296                                             &struct_elem->payload.
00297                                             byte);
00298             break;
00299          case EASYDBUS_ELTYPE_BOOLEAN:
00300             dbus_message_iter_append_basic (&subiter,
00301                                             DBUS_TYPE_BOOLEAN,
00302                                             &struct_elem->payload.
00303                                             boolean);
00304             break;
00305          case EASYDBUS_ELTYPE_DOUBLE:
00306             dbus_message_iter_append_basic (&subiter,
00307                                             DBUS_TYPE_DOUBLE,
00308                                             &struct_elem->payload.
00309                                             Double);
00310             break;
00311          case EASYDBUS_ELTYPE_INT16:
00312             dbus_message_iter_append_basic (&subiter,
00313                                             DBUS_TYPE_INT16,
00314                                             &struct_elem->payload.
00315                                             i16);
00316             break;
00317          case EASYDBUS_ELTYPE_UINT16:
00318             dbus_message_iter_append_basic (&subiter,
00319                                             DBUS_TYPE_UINT16,
00320                                             &struct_elem->payload.
00321                                             ui16);
00322             break;
00323          case EASYDBUS_ELTYPE_INT32:
00324             dbus_message_iter_append_basic (&subiter,
00325                                             DBUS_TYPE_INT32,
00326                                             &struct_elem->payload.
00327                                             i32);
00328             break;
00329          case EASYDBUS_ELTYPE_UINT32:
00330             dbus_message_iter_append_basic (&subiter,
00331                                             DBUS_TYPE_UINT32,
00332                                             &struct_elem->payload.
00333                                             ui32);
00334             break;
00335          case EASYDBUS_ELTYPE_INT64:
00336             dbus_message_iter_append_basic (&subiter,
00337                                             DBUS_TYPE_INT64,
00338                                             &struct_elem->payload.
00339                                             i64);
00340             break;
00341          case EASYDBUS_ELTYPE_UINT64:
00342             dbus_message_iter_append_basic (&subiter,
00343                                             DBUS_TYPE_UINT64,
00344                                             &struct_elem->payload.
00345                                             ui64);
00346             break;
00347          case EASYDBUS_ELTYPE_OBJECT_PATH:
00348             dbus_message_iter_append_basic (&subiter,
00349                                             DBUS_TYPE_OBJECT_PATH,
00350                                             &struct_elem->payload.
00351                                             string);
00352             break;
00353          case EASYDBUS_ELTYPE_SIGNATURE:
00354             dbus_message_iter_append_basic (&subiter,
00355                                             DBUS_TYPE_SIGNATURE,
00356                                             &struct_elem->payload.
00357                                             string);
00358             break;
00359          case EASYDBUS_ELTYPE_VARIANT:
00360             if (add_variant_to_container_on_msg
00361                 (msg, struct_elem, &subiter)) {
00362                ret_val = -1;
00363                goto end;
00364             }
00365             break;
00366          case EASYDBUS_ELTYPE_ARRAY:
00367             if (easydbus_add_array_on_container_tomsg
00368                 (msg, &subiter, struct_elem)) {
00369                ret_val = -1;
00370                goto end;
00371             }
00372             break;
00373          case EASYDBUS_ELTYPE_STRUCT:
00374             if (easydbus_add_struct_on_container_msg
00375                 (msg, &subiter, struct_elem)) {
00376                ret_val = -1;
00377                goto end;
00378             }
00379             break;
00380          case EASYDBUS_ELTYPE_DICT_ENTRY:
00381             /*
00382              * Dict entry must be insert on array container
00383              * if (easydbus_add_dict_entry_tomsg 
00384              (msg, &subiter, struct_elem)) {
00385              ret_val = -1;
00386              goto end;
00387              }
00388              break;
00389              */
00390          case EASYDBUS_ELTYPE_INVALID:
00391             EasyDbusDebug ("Error");
00392             ret_val = -1;
00393             goto end;
00394             break;
00395       }                         // end of switch
00396       struct_elem = struct_elem->next;
00397    }                            // end of while
00398 
00399  end:
00400 //   if (signature != NULL)
00401 //      free (signature);
00402 
00403    dbus_message_iter_close_container (iter, &subiter);
00404 
00405    return ret_val;
00406 }
00407 
00408 
00419 struct EasyDbus_container *
00420 easydbus_struct_build_elem (enum event_type type,
00421                             void *container, DBusMessageIter * iter)
00422 {
00423    struct EasyDbus_container *struct_el = NULL;
00424    struct EasyDbus_container *cont_marshal_data = NULL;
00425    DBusMessageIter subiter;
00426    int i32 = 0;
00427    unsigned int ui32 = 0;
00428    short i16 = 0;
00429    char byte = 0;
00430    char *string = NULL;
00431    unsigned short ui16 = 0;
00432    long long i64 = 0;
00433    unsigned long long ui64 = 0;
00434    double d = 0;
00435 
00436 #ifdef EASYDBUS_DEBUG
00437    char *signature = NULL;
00438 #endif
00439 
00440    if (container == NULL || iter == NULL)
00441       return NULL;
00442 
00443    struct_el = easydbus_container_create_skeleton
00444       (EASYDBUS_ELTYPE_STRUCT);
00445 
00446    if (struct_el == NULL)
00447       return NULL;
00448 
00449    dbus_message_iter_recurse (iter, &subiter);
00450    while (1) {
00451 #ifdef EASYDBUS_DEBUG
00452       signature = dbus_message_iter_get_signature (&subiter);
00453       EasyDbusDebug ("Current Signature = %s", signature);
00454       dbus_free (signature);
00455 #endif
00456       switch (dbus_message_iter_get_arg_type (&subiter)) {
00457          case DBUS_TYPE_STRING:
00458             dbus_message_iter_get_basic (&subiter, &string);
00459             EasyDbusDebug ("founded string = %s\n", string);
00460             easydbus_struct_add_string (struct_el, string);
00461             break;
00462          case DBUS_TYPE_INT32:
00463             dbus_message_iter_get_basic (&subiter, &i32);
00464             EasyDbusDebug ("founded int32 = %d", i32);
00465             easydbus_struct_add_i32 (struct_el, i32);
00466             break;
00467          case DBUS_TYPE_UINT32:
00468             dbus_message_iter_get_basic (&subiter, &ui32);
00469             EasyDbusDebug ("founded uint32 = %d", ui32);
00470             easydbus_struct_add_ui32 (struct_el, ui32);
00471             break;
00472          case DBUS_TYPE_INT16:
00473             dbus_message_iter_get_basic (&subiter, &i16);
00474             EasyDbusDebug ("founded int16 = %d", i16);
00475             easydbus_struct_add_i16 (struct_el, i16);
00476             break;
00477          case DBUS_TYPE_UINT16:
00478             dbus_message_iter_get_basic (&subiter, &ui16);
00479             EasyDbusDebug ("founded uint16 = %d", ui16);
00480             easydbus_struct_add_ui16 (struct_el, ui16);
00481             break;
00482          case DBUS_TYPE_INT64:
00483             dbus_message_iter_get_basic (&subiter, &i64);
00484             EasyDbusDebug ("founded int64 = %lld", i64);
00485             easydbus_struct_add_i64 (struct_el, i64);
00486             break;
00487          case DBUS_TYPE_UINT64:
00488             dbus_message_iter_get_basic (&subiter, &ui64);
00489             EasyDbusDebug ("founded uint64 = %lld", ui64);
00490             easydbus_struct_add_ui64 (struct_el, ui64);
00491             break;
00492          case DBUS_TYPE_BYTE:
00493             dbus_message_iter_get_basic (&subiter, &byte);
00494             EasyDbusDebug ("founded byte = %d", byte);
00495             easydbus_struct_add_byte (struct_el, byte);
00496             break;
00497          case DBUS_TYPE_BOOLEAN:
00498             dbus_message_iter_get_basic (&subiter, &byte);
00499             EasyDbusDebug ("founded boolean = %d", byte);
00500             easydbus_struct_add_boolean (struct_el, byte);
00501             break;
00502          case DBUS_TYPE_DOUBLE:
00503             dbus_message_iter_get_basic (&subiter, &d);
00504             EasyDbusDebug ("founded double = %f", d);
00505             easydbus_struct_add_double (struct_el, d);
00506             break;
00507          case DBUS_TYPE_OBJECT_PATH:
00508             dbus_message_iter_get_basic (&subiter, &string);
00509             EasyDbusDebug ("founded obj_path = %s\n", string);
00510             easydbus_struct_add_obj_path (struct_el, string);
00511             break;
00512          case DBUS_TYPE_SIGNATURE:
00513             dbus_message_iter_get_basic (&subiter, &string);
00514             EasyDbusDebug ("founded signature = %s\n", string);
00515             easydbus_struct_add_signature (struct_el, string);
00516             break;
00517          case DBUS_TYPE_VARIANT:
00518             cont_marshal_data = easydbus_variant_build_elem
00519                (type, (void *) container, &subiter);
00520             if (cont_marshal_data != NULL) {
00521                easydbus_struct_add_variant (struct_el,
00522                                             cont_marshal_data);
00523                EasyDbusDebug ("Added variant to container");
00524             }
00525             else
00526                EasyDbusDebug ("Error on add variant to container");
00527             break;
00528          case DBUS_TYPE_ARRAY:
00529             cont_marshal_data =
00530                easydbus_get_marshal_data_from_array (type,
00531                                                      container,
00532                                                      dbus_message_iter_get_element_type
00533                                                      (&subiter),
00534                                                      &subiter);
00535             if (cont_marshal_data != NULL) {
00536                easydbus_add_array_param_to_skeleton (type,
00537                                                      container,
00538                                                      cont_marshal_data);
00539                EasyDbusDebug ("Added array to container");
00540             }
00541             else
00542                EasyDbusDebug ("Error on manage array");
00543             break;
00544          case DBUS_TYPE_STRUCT:
00545             cont_marshal_data = easydbus_struct_build_elem
00546                (type, (void *) container, &subiter);
00547             if (cont_marshal_data != NULL) {
00548                easydbus_struct_add_struct (struct_el,
00549                                            cont_marshal_data);
00550                EasyDbusDebug ("Added struct to container");
00551             }
00552             else
00553                EasyDbusDebug ("Error on add struct to container");
00554             break;
00555          case DBUS_TYPE_DICT_ENTRY:
00556             // this must be on an array
00557             goto error;
00558             break;
00559          default:
00560             goto error;
00561             break;
00562       }                         // end of switch
00563       if (!dbus_message_iter_has_next (&subiter))
00564          break;
00565       else
00566          dbus_message_iter_next (&subiter);
00567 
00568    }                            // end of while
00569 
00570    return struct_el;
00571 
00572  error:
00573    if (struct_el != NULL)
00574       easydbus_container_free (struct_el);
00575    return NULL;
00576 }
00577 
00579 // vim: ts=3 shiftwidth=3 expandtab