reply.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:  reply.c
 
  Description:  
 
  Version:  0.1
  Created:  06/19/07 23:15:41 CEST
  Revision: 
    - 0 created (Ge@@ru)
    - 1 add doxygen documentation and added support
        for opaque structs (Ge@@ru) - 11/02/07 21:25:00 CEST
    
 
  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 "reply_internal.h"
#include "elem_internal.h"
#include "debug.h"
#include "message_internal.h"

int
easydbus_reply_send_error (struct EasyDbus_core *core,
                           DBusMessage * msg, char *error_name,
                           char *error_string)
{
   DBusMessage *error = NULL;

   if (!core || !msg || !error_name || !error_string) {
      EasyDbusDebug ("Error from input params");
      return -1;
   }

   error = dbus_message_new_error (msg,
                                   DBUS_ERROR_FAILED,
                                   (const char *) error_string);

   if (!error)
      return -1;

   if (easydbus_message_send (core, error, 1, NULL)) {
      dbus_message_unref (error);
      return -1;
   }
   dbus_message_unref (error);
   return 0;
}

inline int 
easydbus_reply_set_type (EasyDbus_reply * reply, 
                         enum event_type type) 
{
   if (!reply || (type != EASYDBUS_ET_REPLY && 
       type != EASYDBUS_ET_FAILURE))
      return -1;

   reply->type = type;
   return 0;
}

inline const EasyDbus_elem *
easydbus_reply_get_element (const EasyDbus_reply * reply, 
                            unsigned int n) 
{
   return (reply && n <= reply->args ? 
           easydbus_elem_get_element (reply->first, n) : NULL);
}

inline int 
easydbus_reply_get_args (const EasyDbus_reply * reply) 
{
   return (reply ? (int) reply->args : -1);
}

int
easydbus_reply_send (struct EasyDbus_core *core,
                     DBusMessage * method_msg,
                     struct EasyDbus_reply *reply)
{
   DBusMessage *msg = NULL;
   int ret = -1;

   if (!reply || !method_msg || !core) {
      EasyDbusDebug ("Error from input params");
      return -1;
   }

   msg = easydbus_reply_create_msg (core, reply, method_msg);

   if (msg &&
       !easydbus_message_send (core, msg, 1, NULL))
      ret = 0;

   if (msg)
      dbus_message_unref (msg);

   return ret;
}

inline DBusMessage *
easydbus_reply_create_msg (struct EasyDbus_core * core,
                           struct EasyDbus_reply * reply,
                           DBusMessage * method_msg)
{
   DBusMessage *msg = NULL;

   if (reply->type == EASYDBUS_ET_REPLY) {
      /* create msg */
      msg = dbus_message_new_method_return (method_msg);
   }
   else if (reply->type == EASYDBUS_ET_FAILURE) {
      if (reply->args == 1 &&
          reply->first->type == EASYDBUS_ELTYPE_STRING) {
         msg = dbus_message_new_error (method_msg,
                                       DBUS_ERROR_FAILED,
                                       (const char *) reply->first->
                                       payload.string);
      }
   }

   if (msg && 
       /* add method data if there are */
       (reply->args && reply->type == EASYDBUS_ET_REPLY))
      add_elems_to_msg (msg, reply->first);

   return msg;
}

inline void
easydbus_reply_free_skeleton (EasyDbus_reply * reply) 
{
   struct EasyDbus_elem *el = NULL;

   if (reply) {
      if (reply->src_path)
         free (reply->src_path);
      if (reply->interface)
         free (reply->interface);
      if (reply->sender)
         free (reply->sender);
      reply->src_path = reply->interface =
                        reply->sender = NULL;

      while (reply->args) {
         if (reply->first) {
            el = reply->first;
            reply->first = reply->first->next;
         }
         easydbus_elem_free (el);
         reply->args--;
      }
      free (reply);
   }
}


EasyDbus_reply *
easydbus_reply_create_skeleton (void)
{
   struct EasyDbus_reply *reply_skeleton = NULL;

   reply_skeleton = (struct EasyDbus_reply *) malloc
      (sizeof (struct EasyDbus_reply));

   if (reply_skeleton == NULL)
      return NULL;

   memset (reply_skeleton, 0, sizeof (struct EasyDbus_reply));

   reply_skeleton->src_path = reply_skeleton->interface = NULL;
   reply_skeleton->first = NULL;
   reply_skeleton->sender = NULL;
   reply_skeleton->type = EASYDBUS_ET_INVALID;

   return reply_skeleton;
}

int
easydbus_reply_build_error (struct EasyDbus_method *method,
                            const char *error_msg)
{
   struct EasyDbus_reply *reply_foruser = NULL;

   reply_foruser = easydbus_reply_create_skeleton ();
   if (!reply_foruser)
      return -1;

   if (easydbus_add_string_param_to_skeleton
       (EASYDBUS_ET_REPLY, reply_foruser, (char *) error_msg))
      goto out_of_memory;

   reply_foruser->type = EASYDBUS_ET_FAILURE;
   method->reply = reply_foruser;

   return 0;
 out_of_memory:
   if (reply_foruser)
      easydbus_reply_free_skeleton (reply_foruser);
   return -1;
}

int
easydbus_reply_build_struct (struct EasyDbus_method *method,
                             DBusMessage * reply)
{
   struct EasyDbus_reply *reply_foruser = NULL;
   const char *temp = NULL;
   int type_msg = 0;

   reply_foruser = easydbus_reply_create_skeleton ();

   if (!reply_foruser)
      return -1;

   temp = dbus_message_get_path (reply);
   /* see of manage case where path == NULL */
   //if (temp == NULL) goto out_of_memory_error;

   if (temp)
      if (easydbus_reply_set_path (reply_foruser, temp))
         goto out_of_memory_error;

   temp = dbus_message_get_interface (reply);
   /* see of manage case where path == NULL */
   //if (temp == NULL) goto out_of_memory_error;

   if (temp)
      if (easydbus_reply_set_interface (reply_foruser,
                                        temp))
         goto out_of_memory_error;

   type_msg = dbus_message_get_type (reply);
   if (type_msg == DBUS_MESSAGE_TYPE_METHOD_RETURN)
      reply_foruser->type = EASYDBUS_ET_REPLY;
   else
      reply_foruser->type = EASYDBUS_ET_INVALID;

   easydbus_build_skeleton_data (reply, EASYDBUS_ET_REPLY,
                                 reply_foruser);

   method->reply = reply_foruser;
   EasyDbusDebug ("Created reply object");
   return 0;

out_of_memory_error:

   if (reply_foruser)
      easydbus_reply_free_skeleton (reply_foruser);

   return -1;
}

enum event_type
easydbus_reply_get_type (EasyDbus_reply * reply)
{
   return (reply ? reply->type : EASYDBUS_ET_INVALID);
}

const char *
easydbus_reply_get_src_path (EasyDbus_reply * reply)
{
   return (reply ? (const char *) reply->src_path : NULL);
}

const char *
easydbus_reply_get_interface (EasyDbus_reply * reply)
{
   return (reply ? (const char *) reply->interface : NULL);
}

const char *
easydbus_reply_get_sender (EasyDbus_reply * reply)
{
  return (reply ? (const char *) reply->sender : NULL);
}

inline int
easydbus_reply_set_sender (EasyDbus_reply * reply, 
                           const char *sender)
{
   unsigned int string_length = 0;

   if (!sender || !reply || reply->sender) 
      return -1;

   string_length = strlen (sender) + 1;
   reply->sender = (char *) malloc (string_length);
   if (!reply->sender)
      return -1;

   EASYDBUS_MEMCOPY (reply->sender, sender, string_length);

   return 0;
}

inline int
easydbus_reply_set_interface (EasyDbus_reply * reply, 
                              const char *interface)
{
   unsigned int string_length = 0;

   if (!interface || !reply || reply->interface) 
      return -1;

   string_length = strlen (interface) + 1;
   reply->interface = (char *) malloc (string_length);
   if (!reply->interface)
      return -1;

   EASYDBUS_MEMCOPY (reply->interface, interface,
                     string_length);

   return 0;
}

inline int
easydbus_reply_set_path (EasyDbus_reply * reply, 
                         const char *path)
{
   unsigned int string_length = 0;

   if (!path || !reply || reply->src_path) 
      return -1;

   string_length = strlen (path) + 1;
   reply->src_path = (char *) malloc (string_length);
   if (!reply->src_path)
      return -1;

   EASYDBUS_MEMCOPY (reply->src_path, path,
                     string_length);

   return 0;
}

// vim: ts=3 shiftwidth=3 expandtab

---