signal.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:  signal.c
 
  Description: Functions used for manage signal on dbus. 
 
  Version:  1.0
  Created:  04/07/07 23:06:58 CEST
  Revision:
    0 - created (Ge@@ru)
    1 - added doxygen documentation and manage of opaque structs.
        11/02/07 10:41:00 CEST (Ge@@ru)
 
  Author:   Daniele Rondina aka ge@@ru, (geaaru@gmail.com) 
  Company:  
  License:  GPL 2.0
*/

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

EasyDbus_signal *
easydbus_signal_create_skeleton (char *path,
                                 char *interface, 
                                 char *signal)
{
   struct EasyDbus_signal *signal_skeleton = NULL;
   int string_length = 0;

   if (path == NULL || interface == NULL || signal == NULL)
      return NULL;

   signal_skeleton = (struct EasyDbus_signal *) malloc
      (sizeof (struct EasyDbus_signal));

   if (signal_skeleton == NULL)
      return NULL;

   memset (signal_skeleton, 0, sizeof (struct EasyDbus_signal));

   signal_skeleton->name = signal_skeleton->path =
      signal_skeleton->interface = 
      signal_skeleton->destination = 
      signal_skeleton->sender = NULL;
   signal_skeleton->first = NULL;

   string_length = strlen (signal) + 1;
   signal_skeleton->name = (char *) malloc (string_length);
   if (!signal_skeleton->name)
      goto out_of_memory_error;
   EASYDBUS_MEMCOPY (signal_skeleton->name, signal,
                     string_length);

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

   string_length = strlen (interface) + 1;
   signal_skeleton->interface = (char *) malloc (string_length);
   if (!signal_skeleton->interface)
      goto out_of_memory_error;
   EASYDBUS_MEMCOPY (signal_skeleton->interface, interface,
                     string_length);

   return signal_skeleton;

 out_of_memory_error:
   if (signal_skeleton->name)
      free (signal_skeleton->name);
   if (signal_skeleton->path)
      free (signal_skeleton->path);
   if (signal_skeleton->interface)
      free (signal_skeleton->interface);
   free (signal_skeleton);

   return NULL;
}

inline void
easydbus_signal_free_skeleton (EasyDbus_signal * signal)
{
   struct EasyDbus_elem *el = NULL;

   if (signal) {
      if (signal->name)
         free (signal->name);
      if (signal->path)
         free (signal->path);
      if (signal->interface)
         free (signal->interface);
      if (signal->sender)
         free (signal->sender);
      if (signal->destination)
         free (signal->destination);
      signal->name = signal->path =
         signal->destination =
         signal->interface = signal->sender = NULL;

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

inline DBusMessage *
create_signal_msg (struct EasyDbus_core *core,
                   struct EasyDbus_signal *signal)
{

   /* create msg */
   DBusMessage *msg =
      dbus_message_new_signal (signal->path, signal->interface,
                               signal->name);

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

   return msg;
}


struct EasyDbus_signal *
easydbus_signal_build_skeleton (DBusMessage * msg)
{
   struct EasyDbus_signal *signal = NULL;

   EasyDbusDebug ("Build Signal Skeleton");

   signal =
     easydbus_signal_create_skeleton (
                                      // path
                                      (char *) dbus_message_get_path (msg),
                                      // interface
                                      (char *) dbus_message_get_interface (msg),
                                      // method
                                      (char *) dbus_message_get_member (msg));

   if (!signal)
      return NULL;

   if (dbus_message_get_sender (msg))
      easydbus_signal_set_sender (signal, dbus_message_get_sender (msg));

   if (dbus_message_get_destination (msg))
      easydbus_signal_set_destination (signal,
                                       dbus_message_get_destination (msg));

   if (easydbus_build_skeleton_data (msg, EASYDBUS_ET_SIGNAL, signal))
      goto out_of_memory_error;

   EasyDbusDebug ("Created signal object");

   return signal;

 out_of_memory_error:
   if (signal)
      easydbus_signal_free_skeleton (signal);
   return NULL;
}

const char *
easydbus_signal_get_name (EasyDbus_signal * signal)
{
   return (signal ? (const char *) signal->name : NULL);
}

const char *
easydbus_signal_get_path (EasyDbus_signal * signal)
{
   return (signal ? (const char *) signal->path : NULL);
}

const char *
easydbus_signal_get_interface (EasyDbus_signal * signal)
{
   return (signal ? (const char *) signal->interface : NULL);
}

const char *
easydbus_signal_get_destination (EasyDbus_signal * signal)
{
   return (signal ? (const char *) signal->destination : NULL);
}

const char *
easydbus_signal_get_sender (EasyDbus_signal * signal)
{
  return (signal ? (const char *) signal->sender : NULL);
}

int
easydbus_signal_set_sender (EasyDbus_signal * signal, 
                            const char *sender)
{
   unsigned int string_length = 0;

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

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

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

   return 0;
}

int
easydbus_signal_set_destination (EasyDbus_signal * signal, 
                                 const char *destination)
{
   unsigned int string_length = 0;

   if (!destination || !signal || signal->destination) 
      return -1;

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

   EASYDBUS_MEMCOPY (signal->destination, destination,
                     string_length);

   return 0;
}

int
easydbus_signal_get_args (EasyDbus_signal * signal)
{
   return (signal ? (int) signal->args : -1);
}

const EasyDbus_elem *
easydbus_signal_get_element (EasyDbus_signal * signal, 
                             unsigned int n)
{
   return ((signal && n <= signal->args) ? 
            easydbus_elem_get_element (signal->first, n) : NULL);
}

enum easydbus_ret_values
easydbus_signal_send (EasyDbus_conn * data, 
                      EasyDbus_signal * signal)
{
   struct EasyDbus_core *core = (struct EasyDbus_core *) data;
   int ret_val = EASYDBUS_SIGNAL_NOT_SENT;

   if (!data || !signal)
      return EASYDBUS_ERROR;

   DBusMessage *msg = create_signal_msg (core, signal);

   if (!msg)
      return EASYDBUS_ERROR;

   if (!easydbus_message_send (core, msg, 1, NULL))
      ret_val = EASYDBUS_SIGNAL_SENT;

   dbus_message_unref (msg);

   return ret_val;
}

// vim: ts=3 shiftwidth=3 expandtab

---