method.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:  method.c
 
  Description:  
 
  Version:  1.0
  Created:  06/07/07 23:23:26 CEST
  Revision: 
    - 0 created (Ge@@ru)
    - 1 add doxygen documentation and added support
        for opaque structs (Ge@@ru) - 11/02/07 19:12:00 CEST
 
  Author:   Daniele Rondina aka Ge@@ru (geaaru@gmail.com) 
  License:  GPL 2.0
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// easydbus includes
#include "easydbus-core.h"
#include "elem_internal.h"
#include "message_internal.h"
#include "debug.h"
#include "monitor_internal.h"

inline void
easydbus_method_free_skeleton (EasyDbus_method * method) 
{
   struct EasyDbus_elem *el = NULL;

   if (method == NULL)
      return;

   if (method->name != NULL)
      free (method->name);
   if (method->path != NULL)
      free (method->path);
   if (method->destination != NULL)
      free (method->destination);
   if (method->interface != NULL)
      free (method->interface);

   method->name = method->path = method->interface = NULL;

   while (method->args) {
      if (method->first != NULL) {
         el = method->first;
         method->first = method->first->next;
         easydbus_elem_free (el);
      }
      method->args--;
   }

   if (method->reply != NULL)
      easydbus_reply_free_skeleton (method->reply);

   free (method);
}

inline int
easydbus_method_set_reply (EasyDbus_method * method,
                           EasyDbus_reply * reply)
{
   if (reply == NULL || method == NULL)
      return -1;

   method->reply = reply;

   return 0;
}

inline const EasyDbus_reply *
easydbus_method_get_reply (EasyDbus_method * method)
{
   if (method == NULL)
      return NULL;

   return method->reply;
}

EasyDbus_method *
easydbus_method_create_skeleton (char *destination,
                                 char *path, char *interface,
                                 char *method)
{
   int len = 0;
   struct EasyDbus_method *m = NULL;

   m = (struct EasyDbus_method *)
      malloc (sizeof (struct EasyDbus_method));

   if (m == NULL || path == NULL)
      return NULL;

   memset (m, 0, sizeof (struct EasyDbus_method));

   m->name = m->path = m->destination = m->interface = NULL;
   m->first = NULL;
   m->reply = NULL;
   m->retry = 0;

   len = strlen (method) + 1;
   m->name = (char *) malloc (len);
   if (!m->name)
      goto out_of_memory_error;
   EASYDBUS_MEMCOPY (m->name, method, len)

   if (interface) {
      len = strlen (interface) + 1;
      m->interface = (char *) malloc (len);
      if (!m->interface)
         goto out_of_memory_error;
      EASYDBUS_MEMCOPY (m->interface, interface, len);
   }

   len = strlen (path) + 1;
   m->path = (char *) malloc (len);
   if (!m->path)
      goto out_of_memory_error;
   EASYDBUS_MEMCOPY (m->path, path, len);

   if (destination) {
      len = strlen (destination) + 1;
      m->destination = (char *) malloc (len);
      if (!m->destination)
         goto out_of_memory_error;
      EASYDBUS_MEMCOPY (m->destination, destination, len);
   }

   return m;

 out_of_memory_error:
   if (m->path)
      free (m->path);
   if (m->interface)
      free (m->interface);
   if (m->name)
      free (m->name);
   if (m)
      free (m);
   return NULL;
}

EasyDbus_method *
easydbus_method_build_skeleton (DBusMessage * msg)
{
   struct EasyDbus_method *method = NULL;

   EasyDbusDebug ("Build Method Struct");

   method =
     easydbus_method_create_skeleton (
                                      // destination
                                      (char *) dbus_message_get_destination (msg),
                                      // path
                                      (char *) dbus_message_get_path (msg),
                                      // interface
                                      (char *) dbus_message_get_interface (msg),
                                      // method
                                      (char *) dbus_message_get_member (msg));

   if (method == NULL)
      return NULL;

   if (easydbus_build_skeleton_data (msg, EASYDBUS_ET_METHOD, method))
      goto out_of_memory_error;

   EasyDbusDebug ("Created method object");

   return method;

 out_of_memory_error:
   if (method != NULL)
      easydbus_method_free_skeleton (method);
   return NULL;
}

const char *
easydbus_method_get_interface (EasyDbus_method * method)
{
   return (method ? (const char *) method->interface : NULL);
}

const char *
easydbus_method_get_name (EasyDbus_method * method)
{
   return (method ? (const char *) method->name : NULL);
}

const char *
easydbus_method_get_path (EasyDbus_method * method)
{
   return (method ? (const char *) method->path : NULL);
}

const char *
easydbus_method_get_destination (EasyDbus_method * method)
{
   return (method ? (const char *) method->destination : NULL);
}

int
easydbus_method_get_args (EasyDbus_method * method)
{
   return (method ? method->args : -1);
}

const EasyDbus_elem *
easydbus_method_get_element (EasyDbus_method * method, unsigned int n)
{
   return ((!method || n > method->args) ? NULL :
           easydbus_elem_get_element (method->first, n));
}

inline DBusMessage *
create_method_msg (struct EasyDbus_core * core,
                   struct EasyDbus_method * method)
{

   /* create msg */
   DBusMessage *msg =
      dbus_message_new_method_call (method->destination,
                                    method->path,
                                    method->interface,
                                    method->name);

   if (msg == NULL)
      return msg;

   /* add method data if there are */
   if (method->args)
      add_elems_to_msg (msg, method->first);

   return msg;
}

int
easydbus_method_send_async_with_notify (EasyDbus_conn *conn,
                                        EasyDbus_method *method,
                                        easydbus_method_async_reply_cb_f r_cb,
                                        void *closure,
                                        int timeout)
{
   DBusMessage *msg = NULL;
   struct EasyDbus_core *core = 
      (struct EasyDbus_core *) conn;
   struct EasyDbus_Pending *p = NULL;

   if (!conn || !method || !r_cb)
      return -1;

   p = easydbus_pending_create_skeleton (core, method, r_cb,
                                         closure, timeout);
   if (!p) goto error;

   msg = create_method_msg (core, method);
   if (!msg) goto error;

   if (easydbus_message_send_async(core, p, msg))
      goto error;

   // add EasyDbus_Pending object to list
   if (core->pending_msgs)
      p->next = core->pending_msgs;
   core->pending_msgs = p;

   dbus_message_unref (msg);
   return 0;

error:
   if (p) {
      p->message = NULL;
      easydbus_pending_destroy (p);
   }
   if (msg)
      dbus_message_unref(msg);
   return -1;
}

int
easydbus_method_send_async (EasyDbus_conn * conn, 
                            EasyDbus_method * method,
                            void *closure)
{
   struct EasyDbus_core *core =
      (struct EasyDbus_core *) conn;
   struct EasyDbus_Pending *p = NULL;
   DBusMessage *msg = NULL;

   if (!conn || !method)
      return -1;

   p = easydbus_pending_create_skeleton (core, method, NULL,
                                         closure, 0);
   if (!p) goto error;

   msg = create_method_msg (core, method);

   if (!msg) {
      EasyDbusDebug ("Error on create method message");
      goto error;
   }

   if (easydbus_message_send(core, msg, 0, &p->message_serial)) {
      EasyDbusDebug ("Error on send message");
      goto error;
   }

   // add EasyDbus_Pending object to list
   if (core->pending_msgs)
      p->next = core->pending_msgs;
   core->pending_msgs = p;

   dbus_message_unref (msg);

   return 0;
error:
   if (p) {
      p->message = NULL;
      easydbus_pending_destroy (p);
   }
   if (msg)
      dbus_message_unref(msg);

   return -1;
}

enum easydbus_ret_values
easydbus_method_send_blocking (EasyDbus_conn * conn, 
                               EasyDbus_method * method,
                               int timeout) 
{
   struct EasyDbus_core *core =
      (struct EasyDbus_core *) conn;
   int ret_val = EASYDBUS_METHOD_NOT_SENT;

   if (!conn || !method)
      return EASYDBUS_ERROR;

   DBusMessage *msg = create_method_msg (core, method);

   if (!msg) {
      EasyDbusDebug ("Error on create method message");
      return EASYDBUS_ERROR;
   }

   if (!easydbus_send_method_withReply_Blocking
       (core, msg, method, timeout))
      ret_val = EASYDBUS_METHOD_SENT;

   dbus_message_unref (msg);

   return ret_val;
}

int
easydbus_method_set_retry_flags (EasyDbus_method *method) 
{
   if (!method)
      return -1;

   method->retry = 1;
   return 0;
}

// vim: ts=3 shiftwidth=3 expandtab

---