message.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:  message.c
 
  Description: Functions used for manage messages.
 
  Version:  1.0
  Created:  11/03/07 19:25:58 CEST
  Revision:  
        0 - created (Ge@@ru)
 
  Author:   Daniele Rondina aka ge@@ru, (geaaru@gmail.com) 
  Company:  
  License:  GPL 2.0
*/

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

inline int
easydbus_message_send (struct EasyDbus_core *core, DBusMessage * msg, 
                       unsigned int flush, dbus_uint32_t *mserial)
{
   EasyDbusDebug ("Message serial %d", 
                   mserial ? *mserial : 0);
   
   if (!dbus_connection_send (core->conn, msg, mserial)) {
      fprintf (stderr, "Could not send message on D-BUS.");
      return -1;
   }

   EasyDbusDebug ("Message serial %d", 
                   mserial ? *mserial : 0);

   if (flush)
      dbus_connection_flush (core->conn);

   return 0;
}


int 
easydbus_message_send_async (struct EasyDbus_core *core, 
                             struct EasyDbus_Pending *p,
                             DBusMessage * msg)
{
   if (!core || !p || !msg)
      return -1;

   if (!dbus_connection_send_with_reply (core->conn, msg, 
                                         &(p->pcall), p->timeout))
      return -1;

   EasyDbusDebug ("Created Pending Object (%p)", p->pcall);

   if (!dbus_pending_call_set_notify (p->pcall, 
                                      easydbus_pending_msg_handler, 
                                      (void *) p, NULL))
      return -1;

   EasyDbusDebug ("Message insert on queue");
   return 0;
}

void 
easydbus_pending_msg_handler (DBusPendingCall *pcall, 
                              void *data)
{
   DBusMessage *reply_msg = NULL;
   EasyDbus_reply *reply = NULL;
   struct EasyDbus_Pending *p, **temp;
   
   p = (struct EasyDbus_Pending *) data;
   EasyDbusDebug ("Use Pending Object (%p)", pcall);

   if (!p || p->pcall != pcall) {
      EasyDbusDebug ("Error data mismatch");
      return;
   }

   // initialize retry field of method
   p->message->retry = 0;
   reply_msg = dbus_pending_call_steal_reply(pcall);
   if (reply_msg) {
      // there is a reply
      reply = easydbus_reply_create_skeleton ();
      if (!reply) 
         goto error;

      if (easydbus_build_skeleton_data (reply_msg, EASYDBUS_ET_REPLY,
                                        reply))
         goto error;
      p->message->reply = reply;
   } 
   // else a timeout is handled.

   p->p_cb ((EasyDbus_conn *) p->core, p->message,
            p->closure);

   if (p->message->retry) {
      // retry method call
      if (p->message->reply) {
         easydbus_reply_free_skeleton (p->message->reply);
         p->message->reply = NULL;
      }
      dbus_pending_call_unref (p->pcall);
   }
   else {
      // remove pending object from list
      for (temp = &(p->core->pending_msgs); *temp;
           temp = &(*temp)->next)
         if (*temp == p) {
            *temp = (*temp)->next;
            break;
         }
      if (reply_msg)
         dbus_message_unref (reply_msg);
      easydbus_pending_destroy (p);
   }

   return;
error:
   EasyDbusDebug ("Error not managed");
   if (reply) 
      easydbus_reply_free_skeleton (reply);
}

struct EasyDbus_Pending * 
easydbus_pending_create_skeleton (struct EasyDbus_core *core,
                                  EasyDbus_method *method,
                                  easydbus_method_async_reply_cb_f p_cb,
                                  void *closure, int timeout)
{
   struct EasyDbus_Pending *p;

   if (!core || !method)
      return NULL;

   p = (struct EasyDbus_Pending *) 
       malloc (sizeof (struct EasyDbus_Pending));
   
   if (!p) 
      return NULL;
   
   memset (p, 0, sizeof (struct EasyDbus_Pending));

   p->core = core;
   p->message = method;
   p->message_serial = 0;
   p->p_cb = p_cb;
   p->closure = closure;
   p->next = NULL;
   p->timeout = timeout;
   p->pcall = NULL;
  
   return p;
}

void
easydbus_pending_destroy (struct EasyDbus_Pending *p) 
{
   if (!p) return;

   if (p->message)
      easydbus_method_free_skeleton(p->message);

   if (p->pcall) {
      EasyDbusDebug ("Free EasyDbus_Pending object (%p)", p->pcall);
      dbus_pending_call_unref (p->pcall);
      p->pcall = NULL;
   }

   p->message = NULL;
   p->message_serial = 0;
   p->core = NULL;
   p->p_cb = NULL;
   p->next = NULL;
   p->closure = NULL;

   free(p);
   
}

// vim: ts=3 shiftwidth=3 expandtab

---