watch_events.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:  watch_events.c
 
 Description:  
 
 Version:  1.0
 Created:  09/18/07 10:57:24 CEST
 Revision:  none
 
 Author:   Daniele Rondina aka Ge@@ru (geaaru@gmail.com) 
 License:  GPL 2.0
*/

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


int
easydbus_watcher_get_fd (EasyDbus_watcher * watcher)
{
   if (watcher)
#if defined(__DBUS_VERSION__) && (__DBUS_VERSION__ <= 102)
      return dbus_watch_get_fd (watcher->watch);
#else
      return dbus_watch_get_unix_fd (watcher->watch);
#endif
   return -1;
}

int 
easydbus_object_handle_message (EasyDbus_conn * data, 
                                int event_fd) 
{
   struct EasyDbus_core *core = (struct EasyDbus_core *) data;
   struct EasyDbus_watcher *watch = NULL;
   int ret_val;

   if (data == NULL || event_fd < 0)
      return -1;

   watch = easydbus_watcher_get_from_fd (core->watcher, event_fd, 
                                         EASYDBUS_WATCHER_READABLE);
   if (watch == NULL)
      return -1;

   do {
      if (!dbus_watch_get_enabled (watch->watch)) {
         EasyDbusDebug ("Watch not enabled");
         return -1;
      }
      else
         dbus_watch_handle (watch->watch, DBUS_WATCH_READABLE);
      ret_val = dbus_connection_dispatch (core->conn);
      // this permit to call dbus_connection_dispatch
      // in the next step. See if it is needed a sleep.
      if (ret_val == DBUS_DISPATCH_NEED_MEMORY)
         return 0;
   } while (ret_val == DBUS_DISPATCH_DATA_REMAINS);

   return 0;
}

int 
easydbus_object_main_loop (EasyDbus_conn * data) 
{
   struct EasyDbus_core *core = (struct EasyDbus_core *) data;
   void *user_data;

   if (core == NULL || core->objects == NULL)
      return -1;

   if (!dbus_connection_get_object_path_data (core->conn,
                                              core->objects->core.
                                              path, &user_data)) {
      EasyDbusDebug ("Error on recover user data");
      return -1;
   }

   if (user_data != (void *) core) {
      EasyDbusDebug ("User data pointer wrong!");
   }
   EasyDbusDebug ("User data pointer is correct!");

   while (1) 
      dbus_connection_read_write_dispatch (core->conn, -1);

   return 0;
}

enum easydbus_ret_values
easydbus_watch_method_blocking (EasyDbus_conn * conn,
                                EasyDbus_method *method_container, 
                                int timeout)
{
   DBusMessage *msg;
   struct EasyDbus_core *core = (struct EasyDbus_core *) conn;
   int ret_val = EASYDBUS_METHOD_NOT_HANDLED;

   // blocking read of the next available message
   dbus_connection_read_write_dispatch (core->conn, timeout);
   msg = dbus_connection_pop_message (core->conn);

   // loop again if we haven't read a message
   if (!msg) {
      EasyDbusDebug ("Null Message");
      return EASYDBUS_METHOD_MSG_NULL;
   }

   EasyDbusDebug ("%s Message: member = %s\n"
                  "interface = %s\n"
                  "path = %s\n",
                  dbus_message_type_to_string (dbus_message_get_type
                                               (msg)),
                  dbus_message_get_member (msg),
                  dbus_message_get_interface (msg),
                  dbus_message_get_path (msg));

   // check if the message is a signal from the correct 
   // interface and with the correct name
   if (dbus_message_is_method_call (msg,
                                    method_container->interface,
                                    method_container->name)) {
      conn->received_msg++;
      // data->received_methods++;
      struct EasyDbus_method *temp =
         easydbus_method_build_skeleton (msg);
      easydbus_method_free_skeleton (temp);
      ret_val = EASYDBUS_METHOD_HANDLED;
   }

   if (msg)
      dbus_message_unref (msg);

   return ret_val;
}

enum easydbus_ret_values
easydbus_watch_signal_blocking (EasyDbus_conn * data,
                                EasyDbus_signal *signal_container, 
                                int timeout)
{
   DBusMessage *msg;
   struct EasyDbus_core *core = (struct EasyDbus_core *) data;
   int ret_val = EASYDBUS_SIGNAL_NOT_HANDLED;

   do {
      // blocking read of the next available message
      dbus_connection_read_write_dispatch (core->conn, timeout);
      msg = dbus_connection_pop_message (core->conn);

      // loop again if we haven't read a message
      // (a timeout is handled);
      if (!msg) {
         EasyDbusDebug ("Null Message");
         return EASYDBUS_SIGNAL_MSG_NULL;
      }

      EasyDbusDebug ("%s Message: member = %s\n"
                     "interface = %s\n"
                     "path = %s\n",
                     dbus_message_type_to_string
                     (dbus_message_get_type (msg)),
                     dbus_message_get_member (msg),
                     dbus_message_get_interface (msg),
                     dbus_message_get_path (msg));

      // check if the message is a signal from the correct 
      // interface and with the correct name
      if (dbus_message_is_signal (msg,
                                  signal_container->interface,
                                  signal_container->name)) {
         //data->received_msg++;
         data->received_signal++;
         // add arg of signal to signal container passed in input 
         easydbus_build_skeleton_data (msg, EASYDBUS_ET_SIGNAL,
                                       signal_container);
         ret_val = EASYDBUS_SIGNAL_HANDLED;
      }

      if (msg)
         dbus_message_unref (msg);

   } while (ret_val == EASYDBUS_SIGNAL_NOT_HANDLED);

   return ret_val;
}

int
easydbus_watcher_enable (EasyDbus_conn * conn,
                         easydbus_watcher_add_cb_f watcher_add_cb,
                         easydbus_watcher_remove_cb_f watcher_remove_cb, 
                         void *closure)
{
   struct EasyDbus_core *core = (struct EasyDbus_core *) conn;
   int ret_val;

   if (!conn || !watcher_add_cb || !watcher_remove_cb)
      return -1;

   conn->watcher_add_cb = watcher_add_cb;
   conn->watcher_remove_cb = watcher_remove_cb;
   conn->watcher_closure = closure;
//#ifdef EASYDBUS_TESTING
//   dbus_connection_set_dispatch_status_function
//    (core->conn, easydbus_dispatch_status_callback,
//     (void *) core, NULL);
//#endif
   dbus_connection_set_watch_functions (core->conn,
                                        easydbus_add_watch_callback,
                                        easydbus_remove_watch_callback,
                                        easydbus_toggle_watch_callback,
                                        core, NULL);
// dbus_connection_set_timeout_functions (core->conn,
//    easydbus_add_timeout, 
//    easydbus_remove_timeout, 
//    easydbus_toggle_timeout, core,
//    NULL);

   do {
      ret_val = dbus_connection_dispatch (core->conn);
   } while (ret_val == DBUS_DISPATCH_DATA_REMAINS);

// dbus_connection_set_wakeup_main_function 
// (core->conn,
//    easydbus_wakeup_main_callback,
// core, NULL);

   return 0;
}

int *
easydbus_watcher_get_fd_list (EasyDbus_conn * data, 
                              int *num_fd)
{
   int *list_fd = NULL, *fd = NULL;
   int i = 0;
   struct EasyDbus_watcher *watch = NULL;
   struct EasyDbus_core *core = (struct EasyDbus_core *) data;

   if (data == NULL || num_fd == NULL)
      return NULL;

   if (core->watcher == NULL)
      return NULL;

   // count watcher 
   watch = core->watcher;
   while (watch != NULL) {
      i++;
      watch = watch->next;
   }

   EasyDbusDebug ("Founded %d watcher", i);

   list_fd = (int *) malloc (sizeof (int) * i);
   if (list_fd == NULL)
      return NULL;

   memset (list_fd, 0, sizeof (int) * i);

   // save fd
   watch = core->watcher;
   fd = list_fd;
   while (watch != NULL) {
#if defined(__DBUS_VERSION__) && (__DBUS_VERSION__ <= 102)
      *fd = dbus_watch_get_fd (watch->watch);
#else
      *fd = dbus_watch_get_unix_fd(watch->watch);
#endif
      fd++;
      watch = watch->next;
   }
   *num_fd = i;
   return list_fd;
}
// vim: ts=3 shiftwidth=3 expandtab

---