register_obj_internal.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_internal.c

 Description:

 Version:  1.0
 Created:  09/17/07 19:16:42 CEST
 Revision:  none

 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 "debug.h"
#include "utils.h"
#include "reply_internal.h"
#include "introspect_internal.h"
#include "register_obj_internal.h"
#include "message_internal.h"

/* prototypes */
static DBusHandlerResult
easydbus_signal_handler (struct EasyDbus_core *,
                         DBusMessage *);

static DBusHandlerResult
easydbus_error_handler (struct EasyDbus_core *,
                        DBusMessage *);

static DBusHandlerResult
easydbus_reply_handler (struct EasyDbus_core *,
                        DBusMessage *);

DBusHandlerResult 
easydbus_obj_path_msg_function (DBusConnection * conn, 
                                DBusMessage * msg, 
                                void *user_data) 
{
   struct EasyDbus_core *core = (struct EasyDbus_core *) user_data;
   struct EasyDbus_object_box *obj = NULL;
   struct EasyDbus_obj_interface *interface = NULL;
   EasyDbus_reply *reply = NULL;
   const char *msg_member = NULL;
   const char *msg_interface = NULL;
   const char *msg_path = NULL;
   int ret_val = -1;

   // Check input param
   if (!msg || !conn || !user_data ||
       (dbus_message_get_type (msg) != 
        DBUS_MESSAGE_TYPE_METHOD_CALL)) {
      EasyDbusDebug ("Error");
      // see how manage this error. Maybe with an error msg.
      return DBUS_HANDLER_RESULT_HANDLED;
   }

   msg_path = dbus_message_get_path (msg);
   msg_member = dbus_message_get_member (msg);
   msg_interface = dbus_message_get_interface (msg);

   EasyDbusDebug ("Message %s for \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);

   // check object path string of message with object
   // path string of registered objects.
   obj = easydbus_get_obj (core->objects, msg_path);
   if (!obj)
      goto obj_not_found;

   /* control any interface connect to object:
    * - first match meet is used */
   for (interface = obj->core.handled_interfaces;
        interface; interface = interface->next) {
      reply = easydbus_verify_match_and_prepare_reply (interface, 
                                                       msg, msg_interface, 
                                                       msg_member, &ret_val);
      if (ret_val == EASYDBUS_METHOD_HANDLED ||
          ret_val == EASYDBUS_FAILURE_HANDLED) {
         easydbus_reply_send (core, msg, reply);
         easydbus_reply_free_skeleton (reply);
         return DBUS_HANDLER_RESULT_HANDLED;
         // this must be managed correctly still
      }
      else if (ret_val == EASYDBUS_SIGNAL_HANDLED ||
               ret_val == EASYDBUS_METHOD_RETURN_HANDLED) {
         easydbus_reply_send_error (core, msg,
                                    "Error",
                                    "Error: unpredictable error");
         return DBUS_HANDLER_RESULT_HANDLED;
      }
   }

obj_not_found:
   // send obj path doesn't exist error msg.
   // send_not_found_error ();
   easydbus_reply_send_error (core, msg, "NotFound",
                              "Error: method not found");
   return DBUS_HANDLER_RESULT_HANDLED;
}

void 
easydbus_obj_path_unregister_function (DBusConnection * conn, 
                                       void *user_data) 
{
}

EasyDbus_reply *
easydbus_verify_match_and_prepare_reply 
  (struct EasyDbus_obj_interface *interface,
   DBusMessage * msg, const char *msg_interface,
   const char *member_name, int *return_value) 
{
   int callback_retvalue;
   struct EasyDbus_obj_method *method = NULL;
   EasyDbus_method *method_skeleton = NULL;
   EasyDbus_reply *reply = NULL;

   // manage method request
   method = easydbus_obj_interface_get_method (member_name, 
                                               msg_interface, 
                                               interface);
   if (!method) {
      *return_value = EASYDBUS_METHOD_NOT_FOUND;
      goto not_found;
   }

   method_skeleton = easydbus_method_build_skeleton (msg);
   if (!method_skeleton) {
      *return_value = EASYDBUS_ERROR;
      goto not_found;
   }
   callback_retvalue = (int) 
      method->method_callback (method_skeleton);
   // see if manage failure in this mannaer
   if (callback_retvalue == EASYDBUS_METHOD_HANDLED) {
      reply = method_skeleton->reply;
      *return_value = callback_retvalue;
   }
   else if (callback_retvalue == EASYDBUS_FAILURE_HANDLED)
      if (method_skeleton->reply) {
         reply = method_skeleton->reply;
         *return_value = callback_retvalue;
      }
   method_skeleton->reply = NULL;
   easydbus_method_free_skeleton (method_skeleton);

   return reply;

not_found:

   return NULL;
}


static DBusHandlerResult
easydbus_signal_handler (struct EasyDbus_core *core,
                         DBusMessage *msg) 
{
   struct EasyDbus_ext_signal *el = NULL;
   struct EasyDbus_signal *handled_signal = NULL;
   const char *msg_member = NULL;
   const char *msg_interface = NULL;
   const char *msg_path = NULL;
   const char *msg_sender = NULL;
   const char *msg_destination = NULL;

   // 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);
   // get destination
   msg_destination = dbus_message_get_destination (msg);

   if (core->handled_signal)
      for (el = core->handled_ext_signals; el; el = el->next)
         if (!easydbus_verify_signal_match
             (msg_member, msg_interface, msg_path, msg_sender, 
              msg_destination, el)) {
            EasyDbusDebug ("Extern Signal Handled");
            handled_signal = easydbus_signal_build_skeleton (msg);
            if (handled_signal) {
               if (msg_sender)
                  easydbus_signal_set_sender (handled_signal, msg_sender);
               el->signal_callback ((struct EasyDbus_conn *) core,
                                    handled_signal);
               easydbus_signal_free_skeleton (handled_signal);
            }
            goto out;
         }

   EasyDbusDebug ("\n"
                  "- Drop signal -------------------\n"
                  "path = %s\n"
                  "interface = %s\n"
                  "member = %s\n"
                  "sender = %s\n"
                  "destination = %s\n"
                  "---------------------------------\n",
                  msg_path, msg_interface, msg_member, 
                  msg_sender, msg_destination);

out:
   return DBUS_HANDLER_RESULT_HANDLED;
}

static DBusHandlerResult
easydbus_error_handler (struct EasyDbus_core *core,
                         DBusMessage *msg) 
{
   EasyDbus_reply *error_message = NULL;
   struct EasyDbus_Pending *p = NULL, **pp = NULL;
   const char *msg_interface = NULL;
   const char *msg_path = NULL;
   const char *msg_sender = NULL;
   dbus_uint32_t serial = 0;

   // 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 ("\n"
                  "- Handle error message ----------\n"
                  "path = %s\n"
                  "interface = %s\n"
                  "member = %s\n"
                  "sender = %s\n"
                  "---------------------------------\n",
                  msg_path, msg_interface, 
                  dbus_message_get_member (msg), msg_sender);

   error_message = easydbus_reply_create_skeleton ();
   if (!error_message)
      goto need_memory;

   easydbus_reply_set_type (error_message, EASYDBUS_ET_FAILURE);

   if (msg_interface)
      if (easydbus_reply_set_interface (error_message, msg_interface))
         goto need_memory;
   if (msg_path)
      if (easydbus_reply_set_path (error_message, msg_path))
         goto need_memory;
   if (msg_sender)
      if (easydbus_reply_set_sender (error_message, msg_sender))
         goto need_memory;

   easydbus_build_skeleton_data (msg, EASYDBUS_ET_FAILURE, 
                                 error_message);

   serial = dbus_message_get_reply_serial (msg);
   EasyDbusDebug ("Message serial = %d", serial);

   for (p = core->pending_msgs; p; p = p->next) 
      // if p->pcall is equal to null then is a pending struct
      // not connected to async message with notify
      if (!p->pcall && p->message_serial == serial) {
         p->message->reply = error_message;
         // remove EasyDbus_pending object from list
         for (pp = &(p->core->pending_msgs); *pp; pp = &(*pp)->next)
            if (*pp == p) {
               *pp = (*pp)->next;
               break;
            }
         if (core->user_data.reply_message_cb) 
            core->user_data.reply_message_cb ((EasyDbus_conn *) core,
                                              (const EasyDbus_method *) p->message,
                                              p->closure);
         break;
      }

   if (p)
      // error_message is free on easydbus_pending_destroy if 
      // it is connected to a EasyDbus_pending object
      easydbus_pending_destroy (p);
   else {
      if (core->user_data.error_message_cb)
         core->user_data.error_message_cb ((EasyDbus_conn *) core,
                                           (const EasyDbus_reply *) error_message,
                                           core->user_data.error_message_closure);
      easydbus_reply_free_skeleton (error_message);
   }

   return DBUS_HANDLER_RESULT_HANDLED;

need_memory:
   if (error_message)
      easydbus_reply_free_skeleton (error_message);

   return DBUS_HANDLER_RESULT_NEED_MEMORY;
}

static DBusHandlerResult
easydbus_reply_handler (struct EasyDbus_core *core,
                         DBusMessage *msg) 
{
   EasyDbus_reply *reply = NULL;
   struct EasyDbus_Pending *p = NULL, **pp = NULL;
   const char *msg_member = NULL;
   const char *msg_interface = NULL;
   const char *msg_path = NULL;
   const char *msg_sender = NULL;
   dbus_uint32_t serial = 0;

   // 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 ("\n"
                  "- Message reply -----------------\n"
                  "path = %s\n"
                  "interface = %s\n"
                  "member = %s\n"
                  "sender = %s\n"
                  "---------------------------------\n",
                  msg_path, msg_interface, msg_member, msg_sender);

   reply = easydbus_reply_create_skeleton ();
   if (!reply)
      goto need_memory;

   easydbus_reply_set_type (reply, EASYDBUS_ET_REPLY);

   if (msg_interface)
      if (easydbus_reply_set_interface (reply, msg_interface))
         goto need_memory;
   if (msg_path)
      if (easydbus_reply_set_path (reply, msg_path))
         goto need_memory;
   if (msg_sender)
      if (easydbus_reply_set_sender (reply, msg_sender))
         goto need_memory;

   easydbus_build_skeleton_data (msg, EASYDBUS_ET_REPLY, 
                                 reply);

   serial = dbus_message_get_reply_serial (msg);
   EasyDbusDebug ("Message serial = %d", serial);

   for (p = core->pending_msgs; p; p = p->next)
      // if p->pcall is equal to null then is a pending struct
      // not connected to async message with notify
      if (!p->pcall && p->message_serial == serial) {
         p->message->reply = reply;
         // remove EasyDbus_pending object from list
         for (pp = &(p->core->pending_msgs); *pp; pp = &(*pp)->next)
            if (*pp == p) {
               *pp = (*pp)->next;
               break;
            }
         if (core->user_data.reply_message_cb)
            core->user_data.reply_message_cb ((EasyDbus_conn *) core,
                                              (const EasyDbus_method *) p->message,
                                              p->closure);
         break;
      }

   if (p)
      easydbus_pending_destroy (p);
   else
      easydbus_reply_free_skeleton (reply);

   return DBUS_HANDLER_RESULT_HANDLED;

need_memory:

   if (reply)
      easydbus_reply_free_skeleton (reply);

   return DBUS_HANDLER_RESULT_NEED_MEMORY;
}

DBusHandlerResult
easydbus_core_filter_func (DBusConnection * conn,
                           DBusMessage * msg, void *user_data)
{
   struct EasyDbus_core *core =
    (struct EasyDbus_core *) user_data;

   if (dbus_message_is_signal (msg,
                               DBUS_INTERFACE_LOCAL,
                               "Disconnected")) {
      EasyDbusDebug ("Error DBUS disconnected!!!");

      if (core->user_data.error_cb)
         core->user_data.error_cb ((EasyDbus_conn *) user_data, 
                                   core->user_data.error_closure);
      return DBUS_HANDLER_RESULT_HANDLED;
   }

   EasyDbusDebug ("Core filter analysis");
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}

DBusHandlerResult
easydbus_filter_func (DBusConnection * conn,
                      DBusMessage * msg, void *user_data)
{
   struct EasyDbus_core *core = (struct EasyDbus_core *) user_data;
   int msg_type;

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

   EasyDbusDebug ("Message under filter analysis");

   // get message type
   msg_type = dbus_message_get_type (msg);

   if (msg_type == DBUS_MESSAGE_TYPE_SIGNAL) 
      return easydbus_signal_handler (core, msg);
   else if (msg_type == DBUS_MESSAGE_TYPE_ERROR) 
      return easydbus_error_handler (core, msg);
   else if (msg_type == DBUS_MESSAGE_TYPE_METHOD_RETURN) 
      return easydbus_reply_handler (core, msg);

   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}

int
easydbus_verify_signal_match (const char *member,
                              const char *interface,
                              const char *path,
                              const char *sender,
                              const char *destination,
                              struct EasyDbus_ext_signal *el)
{
   if (!el || !member )
      return -1;

   if (strcmp (el->signal, member))
      return -1;

   if (interface && el->interface)
      if (strcmp (el->interface, interface))
         return -1;

   if (path && el->path)
      if (strcmp (el->path, path))
         return -1;

   if (sender && el->sender)
      if (strcmp (el->sender, sender))
         return -1;

   if (destination && el->destination)
      if (strcmp (el->destination, destination))
         return -1;

   return 0;
}

// vim: ts=3 shiftwidth=3 expandtab

---