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

  Description:

  Version:  0.1
  Created:  06/12/07 22:20:04 CEST
  Revision:
      0 - created
      1 - 10/08/07 - use opaque structs.
      2 - added doxygen documentation, renamed EasyDbus_object_core to
          EasyDbus_object

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

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


EasyDbus_object *
easydbus_object_create_skeleton (char *path, void *user_data)
{
   struct EasyDbus_object_box *object;
   int path_length;

   if (!path)
      return NULL;

   object = (struct EasyDbus_object_box *)
      malloc (sizeof (struct EasyDbus_object_box));

   if (!object)
      return NULL;
   memset (object, 0, sizeof (struct EasyDbus_object_box));

   path_length = strlen (path) + 1;

   object->core.path = (char *) malloc (path_length);
   if (!object->core.path)
      goto out_of_memory;

   EASYDBUS_MEMCOPY (object->core.path, path, path_length);

   object->core.handled_interfaces = NULL;

   if (user_data)
      object->core.user_data = user_data;

   object->next = NULL;

   EasyDbusDebug ("Create object core with" " path %s", path);

   return (EasyDbus_object *) object;

 out_of_memory:
   if (object)
      free (object);
   return NULL;
}

int
easydbus_object_add_interface (EasyDbus_obj_interface * interface, 
                               EasyDbus_object * object) 
{
   struct EasyDbus_obj_interface *temp;

   if (!interface || !object)
      return -1;

   if (!object->handled_interfaces)
      object->handled_interfaces = interface;
   else {
      temp = object->handled_interfaces;
      while (temp->next)
         temp = temp->next;
      temp->next = interface;
   }

   object->n_interfaces++;

   EasyDbusDebug ("Added interface %s to object %s",
                  interface->name, object->path);

   return 0;
}

int
easydbus_object_unregister (EasyDbus_conn * data,
                            EasyDbus_object * object)
{
   struct EasyDbus_core *core = (struct EasyDbus_core *) data;
   struct EasyDbus_object_box *obj =
      (struct EasyDbus_object_box *) object;

   if (!object || !data)
      return -1;

   if (dbus_connection_unregister_object_path
       (core->conn, (const char *) obj->core.path))
      return -1;

   return 0;
}

int 
easydbus_conn_disable_filters (EasyDbus_conn * conn) 
{
   struct EasyDbus_core *core = (struct EasyDbus_core *) conn;

   if (!conn)
      return -1;

   dbus_connection_remove_filter (core->conn,
                                  easydbus_core_filter_func, core);

   dbus_connection_remove_filter (core->conn,
                                  easydbus_filter_func, core);

   if (core->handled_introspect)
      dbus_connection_remove_filter (core->conn,
                                     easydbus_introspect_filter_func,
                                     core);

   EasyDbusDebug ("Filters Removed");
   return 0;
}

int 
easydbus_conn_enable_filters (EasyDbus_conn * conn) 
{
   struct EasyDbus_core *core = (struct EasyDbus_core *) conn;

   if (!conn)
      return -1;

   // This solution works only for register object
   // not for simple client. See for an another solution.
   if (!dbus_connection_add_filter (core->conn,
                                    easydbus_core_filter_func, core,
                                    NULL)) {
      EasyDbusDebug ("Error on add core filter");
      return -1;
   }

   if (core->handled_introspect)
      if (!dbus_connection_add_filter (core->conn,
                                       easydbus_introspect_filter_func,
                                       core, NULL)) {
         EasyDbusDebug ("Error on add filter");
         return -1;
      }

   if (!dbus_connection_add_filter (core->conn,
                                    easydbus_filter_func, core,
                                    NULL)) {
      EasyDbusDebug ("Error on add filter");
      return -1;
   }

   EasyDbusDebug ("Filters activated");

   return 0;
}

int 
easydbus_object_register (EasyDbus_conn * data, 
                          EasyDbus_object * object) 
{
   struct EasyDbus_core *core = (struct EasyDbus_core *) data;
   struct EasyDbus_object_box *obj =
      (struct EasyDbus_object_box *) object;
   struct EasyDbus_object_box *temp = NULL;

   if (!object || !data)
      return -1;

   memset (&obj->vtable, 0, sizeof (DBusObjectPathVTable));

   obj->vtable.message_function = easydbus_obj_path_msg_function;
   obj->vtable.unregister_function =
      easydbus_obj_path_unregister_function;
   obj->vtable.dbus_internal_pad1 = NULL;
   obj->vtable.dbus_internal_pad2 = NULL;

   if (!dbus_connection_register_object_path (core->conn,
                                              (const char *) obj->
                                              core.path, &obj->vtable,
                                              core)) {
      EasyDbusDebug ("Error on register object %s", obj->core.path);
      return -1;
   }
   temp = core->objects;

   if (core->n_objs) {
      while (temp->next)
         temp = temp->next;
      temp->next = obj;
   }
   else
      core->objects = obj;
   core->n_objs++;

   EasyDbusDebug ("Register object %s", obj->core.path);

   return 0;
}

void 
easydbus_object_free_skeleton (EasyDbus_object * object) 
{
   struct EasyDbus_obj_interface *interface;
   struct EasyDbus_object_box *obj =
      (struct EasyDbus_object_box *) object;

   if (!object)
      return;

   EasyDbusDebug ("Free of object skeleton %s", object->path);

   if (object->path)
      free (object->path);

   while (object->handled_interfaces) {
      interface = object->handled_interfaces;
      object->handled_interfaces = interface->next;
      easydbus_obj_interface_free_skeleton (interface);
   }

   object->user_data = NULL;

   free (obj);
}

inline const char *
easydbus_object_get_path (EasyDbus_object * object)
{
   return (object ? (const char *) object->path : NULL);
}

inline int
easydbus_object_get_n_interfaces (EasyDbus_object * object)
{
   return (object ? object->n_interfaces : -1);
}

EasyDbus_obj_interface *
easydbus_object_get_interface (EasyDbus_object * object, 
                               unsigned int n) 
{
   unsigned int i;
   EasyDbus_obj_interface *ans = NULL;

   if (object && ((int) n <= object->n_interfaces))
      for (i = 0, ans = object->handled_interfaces;
           i < n; i++, ans = ans->next);

   return ans;
}

inline void *
easydbus_object_get_closure (EasyDbus_object * object)
{
   return (object ? object->user_data : NULL);
}

inline void
easydbus_object_set_closure (EasyDbus_object * object,
                             void *user_data)
{
   if (object) object->user_data = user_data;
}

// vim: ts=3 shiftwidth=3 expandtab

---