watcher.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:  watcher.c
 
 Description:  
 
 Version:  1.0
 Created:  09/20/07 19:02:41 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 "monitor_internal.h"


EasyDbus_watcher *
easydbus_watcher_create_skeleton (void)
{
   struct EasyDbus_watcher *watcher = NULL;

   watcher = (struct EasyDbus_watcher *)
      malloc (sizeof (struct EasyDbus_watcher));

   if (!watcher)
      return NULL;

   memset (watcher, 0, sizeof (struct EasyDbus_watcher));

   watcher->watch = NULL;
   watcher->next = NULL;

   return watcher;
}

int
easydbus_watcher_add (struct EasyDbus_core *core,
                      struct EasyDbus_watcher *watcher)
{
   struct EasyDbus_watcher *watch = NULL;

   if (!core || !watcher)
      return -1;

   if (!core->watcher) {
      // no watcher
      core->watcher = watcher;
   }
   else {
      watch = core->watcher;
      while (watch->next)
         watch = watch->next;
      watch->next = watcher;
   }
   watcher->core = core;
   if (dbus_watch_get_enabled (watcher->watch))
      core->user_data.watcher_add_cb (watcher, 
                                      core->user_data.watcher_closure);
   return 0;
}

int
easydbus_watcher_remove_dbus_watch (struct EasyDbus_core *core,
                                    DBusWatch * watch)
{
   struct EasyDbus_watcher *current, *prev;

   if (!watch || !core)
      return -1;

   prev = current = core->watcher;

   while (current) {
      if (watch == current->watch) {
         if (core->user_data.watcher_remove_cb &&
             dbus_watch_get_enabled (watch))
            core->user_data.watcher_remove_cb (current, 
                                               core->user_data.watcher_closure);
         if (prev == current)
            core->watcher = current->next;
         else
            prev->next = current->next;
         free (current);
         return 0;
      }
      prev = current;
      current = current->next;
   }

   return -1;
}

struct EasyDbus_watcher *
easydbus_watcher_get_from_fd (struct EasyDbus_watcher *list, 
                                int fd,
                                enum easydbus_watcher_flags flags)
{
   if (!list || fd < 0)
      return NULL;

   while (list) {
      if (list->watch) {
         if (dbus_watch_get_enabled (list->watch))
#if defined(__DBUS_VERSION__) && (__DBUS_VERSION__ <= 102)
            if (dbus_watch_get_fd (list->watch) == fd) {
#else
            if (dbus_watch_get_unix_fd (list->watch) == fd) {
#endif
               if (dbus_watch_get_flags (list->watch) & 
                   (flags & EASYDBUS_WATCHER_READABLE ? DBUS_WATCH_READABLE : 
                     DBUS_WATCH_WRITABLE))
               return list;
            }
      }
      list = list->next;
   }

   return NULL;
}

EasyDbus_watcher *
easydbus_watcher_get_from_watch (EasyDbus_watcher *list,
                                 DBusWatch *watch) 
{
   if (list && watch)
      while (list) {
         if (list->watch == watch)
            return list;
         list = list->next;
      }

   return NULL;
}

unsigned int
easydbus_watcher_get_flags (EasyDbus_watcher *watch)
{
   int flags = EASYDBUS_WATCHER_INVALID;
   int easydbus_flags = EASYDBUS_WATCHER_INVALID;

   if (!watch)
      return EASYDBUS_WATCHER_INVALID;

   flags = dbus_watch_get_flags (watch->watch);
   if (flags & DBUS_WATCH_READABLE) 
      easydbus_flags |= EASYDBUS_WATCHER_READABLE;
   if (flags & DBUS_WATCH_WRITABLE) 
      easydbus_flags |= EASYDBUS_WATCHER_WRITABLE;
   if (flags & DBUS_WATCH_HANGUP)
      easydbus_flags |= EASYDBUS_WATCHER_HANGUP;
   if (flags & DBUS_WATCH_ERROR)
      easydbus_flags |= EASYDBUS_WATCHER_ERROR;

   EasyDbusDebug ("EasyDbus_watcher (%p) flags are: %s%s%s%s",
                  watch,
                  flags & DBUS_WATCH_READABLE ? "readable " : "",
                  flags & DBUS_WATCH_WRITABLE ? "writable " : "",
                  flags & DBUS_WATCH_HANGUP ? "hangup " : "",
                  flags & DBUS_WATCH_ERROR ? "error" : "");

   return easydbus_flags;
}

inline EasyDbus_conn *
easydbus_watcher_get_conn (EasyDbus_watcher *watch)
{
   return (watch != NULL ? (EasyDbus_conn *) watch->core : NULL);
}

// vim: ts=3 shiftwidth=3 expandtab

---