introspect_internal.c

Go to the documentation of this file.

/*
 EasyDbus Library: 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:  introspect.c
 
 Description: Functions for insert informations about 
        methods/signals managed on a register object. 
 
 Version:  1.0
 Created:  09/12/07 12:36:15 CEST
 Revision:  
        0 - created
        1 - created functions for creation of instropect XML
                 string.
   2 - created doxygen documentation and added support for
       opaque struct (Ge@@ru) - 11/03/07 
 
 Author:   Daniele Rondina aka ge@@ru (geaaru@gmail.com) 
 License:  GPL 2.0
*/

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

// ---  Introspect Object Tree functions ---

introspect_objs_tree *
easydbus_introspect_obj_tree_create (char *leaf_name, 
                                     struct EasyDbus_object_box *obj)
{
   introspect_objs_tree *o = NULL;
   int n;

   if (!leaf_name) return NULL;

   o = (introspect_objs_tree *) 
       malloc (sizeof (introspect_objs_tree));
   if (!o) goto error;

   memset (o, 0, sizeof (introspect_objs_tree));
   n = strlen (leaf_name) + 1;
   o->leaf_name = (char *) malloc (n);
   EASYDBUS_MEMCOPY (o->leaf_name, leaf_name, n);
   o->n_leafs = 0;
   o->obj = obj;
   o->leafs = NULL;

   return o;

error:
   if (o) {
      if (o->leaf_name)
         free (o->leaf_name);
      free (o);
   }
   return NULL;
}

void 
easydbus_introspect_obj_tree_free (introspect_objs_tree *o)
{
   if (!o) return;

   if (o->leaf_name)
      free (o->leaf_name);

   if (o->leafs)
      free (o->leafs);

   o->leaf_name = NULL;
   o->obj = NULL;
   o->leafs = NULL;

   free (o);
}

introspect_objs_tree *
easydbus_introspect_objs_tree_build (struct EasyDbus_object_box *object)
{
   introspect_objs_tree *tree = NULL;
   struct EasyDbus_object_box *obj = NULL;
   int i, length, n_token = 0;
   char *tmp , *token, *saveptr;
   char **l_tokens;

   if (!object) 
      return NULL;
   
   tmp = token = saveptr = NULL;
   l_tokens = NULL;

   for (obj = object; obj; obj = obj->next) {
      length = strlen (obj->core.path);
      n_token = 
         easydbus_introspect_get_ntoken (obj->core.path, 
                                         length);
      EasyDbusDebug ("Service %s has %d token", obj->core.path,
                     n_token);
      if (n_token <= 0) goto error;

      l_tokens = (char **) malloc (sizeof (char *[n_token]));
      if (!l_tokens) goto error;

      tmp = (char *) malloc (++length);
      if (!tmp) goto error;

      EASYDBUS_MEMCOPY (tmp, obj->core.path, length);
      // post: i with number of token;
      for (i = 0, token = strtok_r (tmp, "/", &saveptr); token;
          token = strtok_r (saveptr, "/", &saveptr), i++)
         l_tokens[i] = token;
      if (easydbus_introspect_objs_tree_add_leafs (&tree, l_tokens, 
                                                   n_token, obj))
         goto error;
      free (l_tokens);
      free (tmp);
      l_tokens = NULL;
      tmp = NULL;
   }

   return tree;
error:
   if (tmp) free (tmp);
   if (l_tokens) free (l_tokens);
   if (tree) 
      easydbus_introspect_objs_tree_destroy (tree);
   EasyDbusDebug ("Error on create introspect tree");
   return NULL;
}

int
easydbus_introspect_objs_tree_add_leafs (introspect_objs_tree **tt,
                                         char **l_tokens, unsigned int n,
                                         struct EasyDbus_object_box *obj)
{
   unsigned int i, j, hastoken = 0;
   introspect_objs_tree *t, *leaf, *next;
   introspect_objs_tree **temp_tt, **temp2_tt;

   if (!l_tokens) return -1;

   leaf = next = t = NULL;
   temp_tt = temp2_tt = NULL;

   // if tt is null create main node.
   if (!*tt) {
      *tt = easydbus_introspect_obj_tree_create ("/", NULL);
      if (!*tt) return -1;
   }
   t = *tt;
   for (i = 0; i < n; i++, t = next) {
      // if there are child leafs check if token is already on tree
      if (t->n_leafs) {
         leaf = easydbus_introspect_obj_tree_hastoken (t, l_tokens[i]);
         if (leaf) hastoken = 1;
      }
      if (!leaf) {
         // if token isn't already on tree
         if (i < (n-1))
            leaf = easydbus_introspect_obj_tree_create (l_tokens[i], NULL);
         else
            leaf = easydbus_introspect_obj_tree_create (l_tokens[i], obj);
         if (!leaf) return -1;
      }
      if (t->n_leafs && !hastoken) {
         temp_tt = (introspect_objs_tree **) 
                   malloc (sizeof (introspect_objs_tree [t->n_leafs+1]));
         if (!temp_tt) goto error;
         for (j = 0; j < t->n_leafs; j++)
            temp_tt[j] = t->leafs[j];
         temp_tt[t->n_leafs++] = leaf;
         temp2_tt = t->leafs;
         t->leafs = temp_tt;
         free (temp2_tt);
      } else if (!hastoken) {
         t->n_leafs = 1;
         t->leafs = (introspect_objs_tree **) 
                    malloc (sizeof (introspect_objs_tree [t->n_leafs]));
         if (!t->leafs) goto error;
         t->leafs[0] = leaf;
      }
      next = leaf;
      leaf = NULL;
      hastoken = 0;
   }
   return 0;
error:
   if (leaf) 
      easydbus_introspect_obj_tree_free (leaf);
   return -1;
}

int 
easydbus_introspect_objs_tree_destroy (introspect_objs_tree *tree) 
{
   unsigned int i;

   if (!tree) return -1;

   for (i = 0; i < tree->n_leafs; i++) 
      easydbus_introspect_objs_tree_destroy (tree->leafs[i]);

   easydbus_introspect_obj_tree_free (tree);
   return 0;
}

inline introspect_objs_tree *         
easydbus_introspect_obj_tree_hastoken (introspect_objs_tree *tree,
                                       char *token)
{
   unsigned int i;

   if (tree && token)
      for (i = 0; i < tree->n_leafs; i++)
         if (!strcmp (tree->leafs[i]->leaf_name, token))
            return tree->leafs[i];

   return NULL;
}

// --- Functions for manage struct easydbus_introspect_arg_info ---

void inline
easydbus_free_introspect_info_arg (struct easydbus_introspect_arg_info *arg)
{
   if (!arg)
      return;

   if (arg->name)
      free (arg->name);

   if (arg->signature)
      free (arg->signature);

   free (arg);
}

int
easydbus_add_new_field_to_list (struct easydbus_introspect_arg_info *el, 
                                struct easydbus_introspect_arg_info **list)
{
   struct easydbus_introspect_arg_info *prev, *current;

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

   if (*list == NULL) {
      // no element on list
      *list = el;
      return 0;
   }

   prev = NULL;
   current = *list;
   while (current != NULL) {
      if (el->offset < current->offset) {
         el->next = current;
         if (prev != NULL)
            prev->next = el;
         else
            *list = el;
         return 0;
      }
      prev = current;
      current = current->next;
   }

   prev->next = el;
   return 0;
}

inline int
easydbus_introspect_get_ntoken (char *name, int l) 
{
   int i, n;
 
   for (i = 0, n = 0; name[i] != '\0'; i++) 
      if ((i != (l-1)) && name[i] == '/') 
         n++;
   return n;
}

int
easydbus_introspect_set_object_buffer (struct EasyDbus_object_box * obj,
                                       char *istring, int *offset) 
{
   EasyDbus_obj_interface *interface = NULL;
   int i_string_l = 0;

   // add interfaces info
   for (interface = obj->core.handled_interfaces;
        interface; interface = interface->next) 
      if (easydbus_introspect_set_interface_buffer (interface, 
                                                    istring, offset))
         return -1;
   i_string_l = *offset;
   
   // add introspectable interface info
   EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                EASYDBUS_INTROSPECT_XML_INTERFACE_DATA,
                                strlen (EASYDBUS_INTROSPECT_XML_INTERFACE_DATA));

   *offset = i_string_l;

   return 0;
}

int 
easydbus_introspect_set_reply_buffer (char *istring,
                                      char *req_path,
                                      introspect_objs_tree *t,
                                      struct EasyDbus_object_box * obj,
                                      unsigned int obj_path)
{
   int offset = 0, ntoken = 0;
   unsigned int i;
   char *token = NULL, *saveptr, *tmp_path;
   introspect_objs_tree *i_t;

   EasyDbusDebug ("Insert data on buffer (%p) for request %s (%d)",
                   istring, req_path, obj_path);
   /* create informations about object */
   // insert dtd info
   EASYDBUS_INTROSPECT_MEMCOPY (istring, offset,
                                EASYDBUS_INTROSPECT_MSG, 
                                strlen (EASYDBUS_INTROSPECT_MSG));
   
   // add easydbus comment 
   EASYDBUS_INTROSPECT_MEMCOPY (istring, offset,
                                EASYDBUS_INTROSPECT_MSG_COMMENT, 
                                strlen (EASYDBUS_INTROSPECT_MSG_COMMENT));

   // Manage request with path equal to "/"
   if (!strcmp ("/", req_path)) {
      // insert node tag
      EASYDBUS_INTROSPECT_MEMCOPY (istring, offset,
                                   EASYDBUS_INTROSPECT_NODE_TAG_O, 
                                   EASYDBUS_INTROSPECT_NODE_TAG_O_L);

      // add leaf node info
      for (i = 0; i < t->n_leafs; i++) {
         EASYDBUS_INTROSPECT_MEMCOPY (istring, offset, 
                                      EASYDBUS_INTROSPECT_NODE_TAG_INIT, 
                                      EASYDBUS_INTROSPECT_NODE_TAG_INIT_L);
         EASYDBUS_INTROSPECT_MEMCOPY (istring, offset,
                                      t->leafs[i]->leaf_name, 
                                      strlen(t->leafs[i]->leaf_name));
         // close node tag
         EASYDBUS_INTROSPECT_MEMCOPY (istring, offset,
                                      EASYDBUS_INTROSPECT_TAG_END, 
                                      EASYDBUS_INTROSPECT_TAG_END_L);
      }

   } else {
      if (obj_path) {
         // insert node tag
         EASYDBUS_INTROSPECT_MEMCOPY (istring, offset,  
                                      EASYDBUS_INTROSPECT_NODE_TAG_INIT2, 
                                      EASYDBUS_INTROSPECT_NODE_TAG_INIT2_L);
         // insert object path string
         EASYDBUS_INTROSPECT_MEMCOPY (istring, offset,  
                                      req_path, strlen (req_path));
         // close node tag
         EASYDBUS_INTROSPECT_MEMCOPY (istring, offset,  
                                      EASYDBUS_INTROSPECT_NODE_TAG_INIT_C,
                                      EASYDBUS_INTROSPECT_NODE_TAG_INIT_C_L);
      } else {
         // insert node tag
         EASYDBUS_INTROSPECT_MEMCOPY (istring, offset,  
                                      EASYDBUS_INTROSPECT_NODE_TAG_O, 
                                      EASYDBUS_INTROSPECT_NODE_TAG_O_L);
      }

      ntoken = easydbus_introspect_get_ntoken (req_path, 
                                               strlen (req_path));
      tmp_path = (char *) malloc (strlen (req_path) + 1);
      if (!tmp_path) return -1;
      EASYDBUS_MEMCOPY (tmp_path, req_path, strlen (req_path) + 1);

      // move to last leaf of tree
      for (i = 0, token = strtok_r (tmp_path, "/", &saveptr),
           i_t = t; (int) i < ntoken; i++, 
           token = strtok_r (saveptr, "/", &saveptr)) {
         EasyDbusDebug ("token[%d] = %s, leafs = %d", 
                        i, token, i_t->n_leafs);
         i_t = easydbus_introspect_obj_tree_hastoken (i_t, token);
      }
      free (tmp_path);

      // add object introspect info
      if (obj_path) 
         if (easydbus_introspect_set_object_buffer (i_t->obj, istring,
                                                    &offset))
            return -1; 

      // add subnodes
      for (i = 0; i < i_t->n_leafs; i++) {
         EasyDbusDebug ("insert leaf[%d] %s",i, 
                        i_t->leafs[i]->leaf_name);
         EASYDBUS_INTROSPECT_MEMCOPY (istring, offset,
                                      EASYDBUS_INTROSPECT_NODE_TAG_INIT,
                                      EASYDBUS_INTROSPECT_NODE_TAG_INIT_L);
         EASYDBUS_INTROSPECT_MEMCOPY (istring, offset,
                                      i_t->leafs[i]->leaf_name,
                                      strlen (i_t->leafs[i]->leaf_name));
         EASYDBUS_INTROSPECT_MEMCOPY (istring, offset,
                                      EASYDBUS_INTROSPECT_TAG_END,
                                      EASYDBUS_INTROSPECT_TAG_END_L);
      }

   }
   // close node tag
   EASYDBUS_INTROSPECT_MEMCOPY (istring, offset, 
                                EASYDBUS_INTROSPECT_NODE_TAG_C, 
                                EASYDBUS_INTROSPECT_NODE_TAG_C_L);
   
   // insert close buffer
   memset (&istring[offset++], 0, 1);
   EasyDbusDebug ("Created introspect string (offset %d) %s\n", 
                  offset, istring);
   return 0;
}

int
easydbus_introspect_set_interface_buffer (EasyDbus_obj_interface *interface,
                                          char *istring, int *offset)
{
   EasyDbus_obj_method *method = NULL;
   EasyDbus_obj_signal *signal = NULL;
   struct easydbus_introspect_arg_info *el = NULL;
   int i_string_l = *offset;
   
   if (!istring || !offset || !interface)
      return -1;

   // add <interface name="...">
   EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                EASYDBUS_INTROSPECT_INTERFACE_TAG_O,
                                EASYDBUS_INTROSPECT_INTERFACE_TAG_O_L);
   EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                interface->name, strlen (interface->name));
   EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                EASYDBUS_INTROSPECT_NODE_TAG_INIT_C,
                                EASYDBUS_INTROSPECT_NODE_TAG_INIT_C_L);

   for (method = interface->handled_methods; method;
        method = method->next) 
      // only method with info about arguments are inserted
      if (method->input_info || method->output_info) {
         // add method tag <method name="...">
         EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                      EASYDBUS_INTROSPECT_METHOD_TAG_O,
                                      EASYDBUS_INTROSPECT_METHOD_TAG_O_L);
         EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                      method->name, strlen (method->name));
         EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                      EASYDBUS_INTROSPECT_NODE_TAG_INIT_C,
                                      EASYDBUS_INTROSPECT_NODE_TAG_INIT_C_L);

         // add input arg <arg name="..." type="signature" destination="in"/>
         for (el = method->input_info; el; el = el->next) {
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_ARG_NAME_TAG_O,
                                         EASYDBUS_INTROSPECT_ARG_NAME_TAG_O_L);
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         el->name, strlen (el->name));
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_ARG_SPACE,
                                         EASYDBUS_INTROSPECT_ARG_SPACE_L);
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_ARG_TYPE_TAG_O,
                                         EASYDBUS_INTROSPECT_ARG_TYPE_TAG_O_L);
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         el->signature, strlen (el->signature));
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_ARG_SPACE,
                                         EASYDBUS_INTROSPECT_ARG_SPACE_L);
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_ARG_DIRECTION_O,
                                         EASYDBUS_INTROSPECT_ARG_DIRECTION_O_L);
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_DIRECTION_IN,
                                         EASYDBUS_INTROSPECT_DIRECTION_IN_L);
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_TAG_END,
                                         EASYDBUS_INTROSPECT_TAG_END_L);
         }

         // add output arg <arg name="..." type="signature" destination="out"/>
         for (el = method->output_info; el; el = el->next) {
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_ARG_NAME_TAG_O,
                                         EASYDBUS_INTROSPECT_ARG_NAME_TAG_O_L);
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         el->name, strlen (el->name));
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_ARG_SPACE,
                                         EASYDBUS_INTROSPECT_ARG_SPACE_L);
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_ARG_TYPE_TAG_O,
                                         EASYDBUS_INTROSPECT_ARG_TYPE_TAG_O_L);
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         el->signature, strlen (el->signature));
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_ARG_SPACE,
                                         EASYDBUS_INTROSPECT_ARG_SPACE_L);
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_ARG_DIRECTION_O,
                                         EASYDBUS_INTROSPECT_ARG_DIRECTION_O_L);
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_DIRECTION_OUT,
                                         EASYDBUS_INTROSPECT_DIRECTION_OUT_L);
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_TAG_END,
                                         EASYDBUS_INTROSPECT_TAG_END_L);
         }
         // close method </method>
         EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                      EASYDBUS_INTROSPECT_METHOD_TAG_C,
                                      EASYDBUS_INTROSPECT_METHOD_TAG_C_L);
      }

   for (signal = interface->handled_signals; signal;
        signal = signal->next) 
      // only signal with info about arguments are inserted
      if (signal->output_info) {
         // add signal tag <signal name="...">
         EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                      EASYDBUS_INTROSPECT_SIGNAL_TAG_O,
                                      EASYDBUS_INTROSPECT_SIGNAL_TAG_O_L);
         EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                      signal->name, strlen (signal->name));
         EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                      EASYDBUS_INTROSPECT_NODE_TAG_INIT_C,
                                      EASYDBUS_INTROSPECT_NODE_TAG_INIT_C_L);

         // add output arg <arg name="..." type="signature" />
         for (el = signal->output_info; el; el = el->next) {
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_ARG_NAME_TAG_O,
                                         EASYDBUS_INTROSPECT_ARG_NAME_TAG_O_L);
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         el->name, strlen (el->name));
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_ARG_SPACE,
                                         EASYDBUS_INTROSPECT_ARG_SPACE_L);
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_ARG_TYPE_TAG_O,
                                         EASYDBUS_INTROSPECT_ARG_TYPE_TAG_O_L);
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         el->signature, strlen (el->signature));
            EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                         EASYDBUS_INTROSPECT_TAG_END,
                                         EASYDBUS_INTROSPECT_TAG_END_L);
         }

         // close signal </signal>
         EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                      EASYDBUS_INTROSPECT_SIGNAL_TAG_C,
                                      EASYDBUS_INTROSPECT_SIGNAL_TAG_C_L);
      }

   // </interface>
   EASYDBUS_INTROSPECT_MEMCOPY (istring, i_string_l,
                                EASYDBUS_INTROSPECT_INTERFACE_TAG_C,
                                EASYDBUS_INTROSPECT_INTERFACE_TAG_C_L);

   *offset = i_string_l;
   return 0;
}

char *
easydbus_introspect_create_reply_string (char *req_path,
                                         introspect_objs_tree *t,
                                         struct EasyDbus_object_box *obj)
{
   int istring_length = 0;
   unsigned int obj_dest_path = 0;
   char *buffer = NULL;

   if (!req_path || !t || !obj)
      return NULL;

   istring_length = easydbus_introspect_get_reply_length (req_path,
                                                          t, obj, 
                                                          &obj_dest_path);
   if (istring_length <= 0) 
      return NULL;
   EasyDbusDebug ("Introspect reply string length = %d\n", istring_length);

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

   if (easydbus_introspect_set_reply_buffer (buffer, req_path, t, 
                                             obj, obj_dest_path))
      goto error;

   return buffer;
error:
   if (buffer)
      free (buffer);
   return NULL;
}

inline char *
easydbus_create_arg_signature 
  (struct easydbus_signature_elem_stack *list)
{
   char *signature = NULL;
   struct easydbus_signature_elem_stack *tmp_elem = NULL;

   while (list != NULL) {
      if (easydbus_manage_list_signature (list,
                                          &signature,
                                          EASYDBUS_SIGNATURE_NORMAL))
         goto error;
      tmp_elem = list->next;
      easydbus_free_elem_from_stack (list);
      list = tmp_elem;
   }

   EasyDbusDebug ("signature created for arg = %s", signature);
   return signature;
 error:
   if (signature != NULL)
      free (signature);
   return NULL;
}

DBusHandlerResult
easydbus_introspect_filter_func (DBusConnection * conn, 
                                 DBusMessage * msg, 
                                 void *user_data) 
{
   struct EasyDbus_core *core = (struct EasyDbus_core *) user_data;
   struct EasyDbus_object_box *objects = NULL;
   const char *msg_member = NULL;
   const char *msg_interface = NULL;
   const char *msg_path = NULL;
   const char *msg_sender = NULL;
   introspect_objs_tree *tree = NULL;
   char *introspect_string = NULL;
   struct EasyDbus_reply *reply = NULL;

   if (conn == NULL || msg == NULL || user_data == NULL) {
      EasyDbusDebug ("Error");
      return DBUS_HANDLER_RESULT_HANDLED;
   }

   objects = core->objects;
   EasyDbusDebug ("Message under filter analysis");

   // check if message is for Introspect method and Introspectable
   // interface.
   if (!dbus_message_is_method_call (msg,
                                     EASYDBUS_INTROSPECT_INTERFACE,
                                     EASYDBUS_INTROSPECT_METHOD)) 
      return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

   // introspect message handled.
   // get member
   msg_member = dbus_message_get_member (msg);
   // get interface
   msg_interface = dbus_message_get_interface (msg);
   // get path
   msg_path = dbus_message_get_path (msg);
   // get sender
   msg_sender = dbus_message_get_sender (msg);

   EasyDbusDebug ("Introspect Request:\n"
                  "Message %s with \n"
                  "path = %s\n"
                  "interface = %s\n"
                  "member = %s\n",
                  dbus_message_type_to_string (dbus_message_get_type (msg)),
                  msg_path, msg_interface, msg_member);

   // create introspect_objs_tree and check on tree
   tree = easydbus_introspect_objs_tree_build (objects);
   if (!tree) 
      goto error;

   reply = easydbus_reply_create_skeleton ();
   if (reply == NULL)
      goto error;
   
   introspect_string = 
      easydbus_introspect_create_reply_string ((char *) msg_path,
                                               tree, objects);
   // \todo manage error reply
   if (!introspect_string) {
      EasyDbusDebug ("instrospect string null");
      goto error;
   }

   reply->type = EASYDBUS_ET_REPLY;
   easydbus_add_string_param_to_skeleton (EASYDBUS_ET_REPLY,
                                          reply, introspect_string);

   easydbus_reply_send (core, msg, reply);
   easydbus_reply_free_skeleton (reply);
   free (introspect_string);
   easydbus_introspect_objs_tree_destroy (tree);
   return DBUS_HANDLER_RESULT_HANDLED;

 error:
   if (tree) easydbus_introspect_objs_tree_destroy (tree);
   if (introspect_string) free (introspect_string);

   if (reply) easydbus_reply_free_skeleton (reply);
   // if reply is null then there are problem on allocate memory
   else
      return DBUS_HANDLER_RESULT_NEED_MEMORY;

   if (easydbus_reply_send_error (core, msg, 
                                  "Object Not Found", 
                                  "Object request not founded"))
      return DBUS_HANDLER_RESULT_NEED_MEMORY;

   return DBUS_HANDLER_RESULT_HANDLED;
}

int
easydbus_introspect_get_reply_length (char *path,
                                      introspect_objs_tree *t,
                                      struct EasyDbus_object_box *obj,
                                      unsigned int *obj_dest_path)
{
   int istring_l = 0, ntoken = 0;
   char *tmp_path = NULL;
   char *token = NULL, *saveptr;
   unsigned int i, j;
   introspect_objs_tree *i_t;

   if (!path || !t || !obj)
      return -1;

   // +1 for \0 field
   istring_l = strlen (EASYDBUS_INTROSPECT_MSG) +
               strlen (EASYDBUS_INTROSPECT_MSG_COMMENT) + 1;

   if (!strcmp ("/", path)) {
      istring_l += EASYDBUS_INTROSPECT_NODE_TAG_O_L;
      for (i = 0; i < t->n_leafs; i++)
         // add sub nodes
         istring_l += EASYDBUS_INTROSPECT_NODE_TAG_INIT_L +
                      strlen(t->leafs[i]->leaf_name) + 
                      EASYDBUS_INTROSPECT_TAG_END_L;
   } else {
      // get number of token on path
      ntoken = easydbus_introspect_get_ntoken (path, 
                                               strlen (path));
      // create temporary string for strtok_r function
      tmp_path = (char *) malloc (strlen (path)+1);
      if (!tmp_path) 
         return -1;
      EASYDBUS_MEMCOPY (tmp_path, path, strlen (path) + 1);
      // POST: i_t point to last leaf.
      for (i = 0, token = strtok_r(tmp_path, "/", &saveptr),
           i_t = t; (int) i < ntoken; 
           token = strtok_r (saveptr, "/", &saveptr), i++) {
         i_t = easydbus_introspect_obj_tree_hastoken (i_t, token);
         if (!i_t)
            goto error;
      }
      if (i_t->obj) {
         *obj_dest_path = 1;
         // manage obj dest path and so interface, etc.
         istring_l += easydbus_introspect_get_obj_string_length (i_t->obj) +
                      EASYDBUS_INTROSPECT_NODE_TAG_INIT2_L +
                      strlen (path) + 
                      EASYDBUS_INTROSPECT_NODE_TAG_INIT_C_L;
      } else 
         istring_l += EASYDBUS_INTROSPECT_NODE_TAG_O_L;
      // add sub objects
      for (j = 0; j < i_t->n_leafs; j++)
         istring_l += strlen (i_t->leafs[j]->leaf_name) +
                      EASYDBUS_INTROSPECT_NODE_TAG_INIT_L +
                      EASYDBUS_INTROSPECT_TAG_END_L;
      free (tmp_path);
   }

   istring_l += EASYDBUS_INTROSPECT_NODE_TAG_C_L;
   return istring_l;

error:
   if (tmp_path)
      free (tmp_path);
   return -1;
}

int
easydbus_introspect_get_obj_string_length (struct EasyDbus_object_box *obj) 
{
   int i_string_l = 0, i;
   EasyDbus_obj_interface *interface = NULL;

   // get introspect string length for any interface
   for (i = 0, interface = obj->core.handled_interfaces; 
        i < obj->core.n_interfaces && interface;
        i++, interface = interface->next) 
      i_string_l += 
         easydbus_introspect_get_interface_string_length (interface);

   // add introspectable interface.
   i_string_l += strlen(EASYDBUS_INTROSPECT_XML_INTERFACE_DATA); 

   return i_string_l;
}

int
easydbus_introspect_get_interface_string_length (EasyDbus_obj_interface *interface)
{
   EasyDbus_obj_method *method = NULL;
   EasyDbus_obj_signal *signal = NULL;
   struct easydbus_introspect_arg_info *el = NULL;
   int i_string_l = 0;

   if (!interface) 
      return -1;

   // add <introspect name="..."> + </introspect>
   i_string_l = EASYDBUS_INTROSPECT_INTERFACE_TAG_O_L +
                strlen (interface->name) +
                EASYDBUS_INTROSPECT_NODE_TAG_INIT_C_L +
                EASYDBUS_INTROSPECT_INTERFACE_TAG_C_L;

   for (method = interface->handled_methods; method;
        method = method->next) 
      if (method->input_info || method->output_info) {
         // add <method name="..."> + </method>
         i_string_l += EASYDBUS_INTROSPECT_METHOD_TAG_O_L +
                       strlen (method->name) +
                       EASYDBUS_INTROSPECT_NODE_TAG_INIT_C_L +
                       EASYDBUS_INTROSPECT_METHOD_TAG_C_L;
         for (el = method->input_info; el; el = el->next)
            // add <arg name="..." type="..." direction="in"/>
            i_string_l += EASYDBUS_INTROSPECT_ARG_NAME_TAG_O_L +
                          strlen (el->name) +
                          EASYDBUS_INTROSPECT_ARG_SPACE_L +
                          EASYDBUS_INTROSPECT_ARG_TYPE_TAG_O_L +
                          strlen (el->signature) +
                          EASYDBUS_INTROSPECT_ARG_SPACE_L +
                          EASYDBUS_INTROSPECT_ARG_DIRECTION_O_L +
                          EASYDBUS_INTROSPECT_DIRECTION_IN_L +
                          EASYDBUS_INTROSPECT_TAG_END_L;
         for (el = method->output_info; el; el = el->next)
            // add <arg name="..." type="..." direction="out"/>
            i_string_l += EASYDBUS_INTROSPECT_ARG_NAME_TAG_O_L +
                          strlen (el->name) +
                          EASYDBUS_INTROSPECT_ARG_SPACE_L +
                          EASYDBUS_INTROSPECT_ARG_TYPE_TAG_O_L +
                          strlen (el->signature) +
                          EASYDBUS_INTROSPECT_ARG_SPACE_L +
                          EASYDBUS_INTROSPECT_ARG_DIRECTION_O_L +
                          EASYDBUS_INTROSPECT_DIRECTION_OUT_L +
                          EASYDBUS_INTROSPECT_TAG_END_L;
      }

   for (signal = interface->handled_signals; signal;
        signal = signal->next)
      if (signal->output_info) {
         // add <signal name="..."> + </signal>
         i_string_l += EASYDBUS_INTROSPECT_SIGNAL_TAG_O_L +
                       strlen (signal->name) + 
                       EASYDBUS_INTROSPECT_NODE_TAG_INIT_C_L +
                       EASYDBUS_INTROSPECT_SIGNAL_TAG_C_L;
         for (el = signal->output_info; el; el = el->next)
            // add <arg name="..." type="..."/>
            i_string_l += EASYDBUS_INTROSPECT_ARG_NAME_TAG_O_L +
                          strlen (el->name) + 
                          EASYDBUS_INTROSPECT_ARG_SPACE_L +
                          EASYDBUS_INTROSPECT_ARG_TYPE_TAG_O_L +
                          strlen (el->signature) +
                          EASYDBUS_INTROSPECT_TAG_END_L;
      }

   return i_string_l;
}

// vim: ts=3 shiftwidth=3 expandtab

---