message_internal
[Internal functions of Easydbus Library]

Collaboration diagram for message_internal:

---

Detailed Description

Module for manage EasyDbus Message Internal

TO COMPLETE

Message Meta Information

Contact:

Daniele Rondina aka Ge@ru <geaaru@gmail.com>

Status:

EasyDbus Core Library

License:

GPL

Contributor(s):

• Daniele Rondina aka Ge@ru <geaaru@gmail.com>

Modules
	signal_internal
	method_internal
	reply_internal
Functions
int	easydbus_message_send (struct EasyDbus_core *core, DBusMessage *msg, unsigned int flush, dbus_uint32_t *mserial)
	Send DBusMessage or insert message on queue.
int	easydbus_message_send_async (struct EasyDbus_core *core, struct EasyDbus_Pending *p, DBusMessage *msg)
	Send DBusMessage on async mode.
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)
	Create EasyDbus_Pending object skeleton.
void	easydbus_pending_destroy (struct EasyDbus_Pending *p)
	Free EasyDbus_Pending object.
void	easydbus_pending_msg_handler (DBusPendingCall *pcall, void *data)
	Handler for manage pending messages.

---

Function Documentation

int easydbus_message_send	(	struct EasyDbus_core *	core,
		DBusMessage *	msg,
		unsigned int	flush,
		dbus_uint32_t *	mserial
	)			[inline]

Send DBusMessage or insert message on queue.

For internal use only.

Parameters:

	core	EasyDbus_core object pointer
	msg	DBusMessage to send.
	flush	field to enable flush of queue.
	mserial	pointer to a dbus_uint32_t variable where is saved serial number of message.

Returns:

-1 on error

0 ok

Definition at line 59 of file message.c.

References EasyDbus_core::conn, and EasyDbusDebug.

Referenced by easydbus_method_send_async(), easydbus_reply_send(), easydbus_reply_send_error(), and easydbus_signal_send().

{
   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
	)

Send DBusMessage on async mode.

Returns:

-1 on error

0 message on outgoing queue.

For internal use only.

Definition at line 87 of file message.c.

References EasyDbus_core::conn, easydbus_pending_msg_handler(), EasyDbusDebug, EasyDbus_Pending::pcall, and EasyDbus_Pending::timeout.

Referenced by easydbus_method_send_async_with_notify().

{
   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;
}

Here is the call graph for this function:

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
	)			[read]

Create EasyDbus_Pending object skeleton.

Parameters:

	core	pointer to EasyDbus_core object
	method	pointer to EasyDbus_method object with request message.
	p_cb	user callback to call on event.
	closure	user closure passed to callback
	timeout	timeout on wait reply message. -1 is default value.

For internal use only.

Definition at line 192 of file message.c.

References EasyDbus_Pending::closure, EasyDbus_Pending::core, EasyDbus_Pending::message, EasyDbus_Pending::message_serial, EasyDbus_Pending::next, EasyDbus_Pending::p_cb, EasyDbus_Pending::pcall, and EasyDbus_Pending::timeout.

Referenced by easydbus_method_send_async(), and easydbus_method_send_async_with_notify().

{
   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

)

Free EasyDbus_Pending object.

Precondition:

p != NULL

Parameters:

p

pointer to EasyDbus_Pending object.

For internal use only.

Definition at line 230 of file message.c.

References EasyDbus_Pending::closure, EasyDbus_Pending::core, easydbus_method_free_skeleton(), EasyDbusDebug, EasyDbus_Pending::message, EasyDbus_Pending::message_serial, EasyDbus_Pending::next, EasyDbus_Pending::p_cb, and EasyDbus_Pending::pcall.

Referenced by easydbus_conn_destroy(), easydbus_error_handler(), easydbus_method_send_async(), easydbus_method_send_async_with_notify(), easydbus_pending_msg_handler(), and easydbus_reply_handler().

{
   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);
   
}

Here is the call graph for this function:

void easydbus_pending_msg_handler	(	DBusPendingCall *	pcall,
		void *	data
	)

Handler for manage pending messages.

Parameters:

	pcall	DBusPendingCall object connect to async message.
	data	pointer to EasyDbus_Pending object.

For internal use only.

TODO

Definition at line 117 of file message.c.

References EasyDbus_Pending::closure, EasyDbus_Pending::core, easydbus_build_skeleton_data(), EASYDBUS_ET_REPLY, easydbus_pending_destroy(), easydbus_reply_create_skeleton(), easydbus_reply_free_skeleton(), EasyDbusDebug, EasyDbus_Pending::message, EasyDbus_Pending::next, EasyDbus_Pending::p_cb, EasyDbus_Pending::pcall, EasyDbus_core::pending_msgs, EasyDbus_method::reply, and EasyDbus_method::retry.

Referenced by easydbus_message_send_async().

{
   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);
}

Here is the call graph for this function:

---