acquire.c

Go to the documentation of this file.

/*
 EasyDbus: DBUS Binding Library.
 Copyright (C) 2007  Daniele Rondina aka Ge@@eu, 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:  acquire.c
 
  Description:  
 
  Version:  1.0
  Created:  06/07/07 23:49:35 CEST
  Revision:  
    0 - created (Ge@@ru)
    1 - Added doxygen comments
 
  Author:   Daniele Rondina aka Ge@@ru , geaaru@gmail.com 
  License:  GPL 2.0
*/

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


int
easydbus_conn_get_address (EasyDbus_conn * conn,
                           char *serviceName,
                           enum easydbus_bus bus, int flags)
{
   if (serviceName == NULL || conn == NULL)
      return -1;

   conn->flags = flags;
   conn->bus = bus;
   switch (bus) {
      case EASYDBUS_SESSION:
         return 
            easydbus_get_address_onsession (conn, serviceName);
         break;
      case EASYDBUS_SYSTEM:
         return 
            easydbus_get_address_onsystem (conn, serviceName);
         break;
      case EASYDBUS_SESSION_SERVER:
         return 
            easydbus_get_address_serverSession (conn, serviceName);
         break;
      default:
         break;
   }

   return -1;
}

int
easydbus_conn_reconnect (EasyDbus_conn *conn, int sleep_time) 
{
   DBusError err;
   int result = -1;
   struct EasyDbus_object_box *object;
   struct EasyDbus_core *core = 
      (struct EasyDbus_core *)conn;
   char *new_service_name = NULL;

   if (!conn || !core->service_name)
      return -1;

   if (core->conn)
      dbus_connection_unref(core->conn);
   core->conn = NULL;
   conn->registered_ondbus = 0;

   dbus_error_init (&err);

   sleep (sleep_time);

   // Acquire bus address
   switch (conn->bus) {
      case EASYDBUS_SESSION:
      case EASYDBUS_SESSION_SERVER:
         if (easydbus_connect_to_bus (core, &err, DBUS_BUS_SESSION))
            goto error;
         break;
      case EASYDBUS_SYSTEM:
      case EASYDBUS_SYSTEM_SERVER:
         if (easydbus_connect_to_bus (core, &err, DBUS_BUS_SYSTEM))
            goto error;
         break;
      default:
         goto error;
         break;
   }

   result = easydbus_acquire_name (core, core->service_name, 
                                   conn->flags, &err);

   if (result == EASYDBUS_CONN_NAME_SERVICE_EXISTS &&
       // probably this isn't needed because without this flags
       // return value is EASYDBUS_CONN_NAME_SERVICE_IN_QUEUE
       (conn->flags & EASYDBUS_CONN_DO_NOT_QUEUE)) {
      if (conn->flags & EASYDBUS_CONN_NAME_SERVICE_RENAMED) {
         new_service_name = easydbus_found_new_name
            (core, core->service_name, conn->flags, &err);
         if (new_service_name == NULL)
            goto error;
         result = EASYDBUS_CONN_NAME_SERVICE_RENAMED;
      }
      else
         goto error;
   }

   conn->registered_ondbus = 1;
   if (new_service_name) {
      if (core->service_name)
         free (core->service_name);
      core->service_name = new_service_name;
   }

   if (core->objects) {
      for (object = core->objects; object; 
           object = object->next) {
         if (!dbus_connection_register_object_path (core->conn,
                                     (const char *) object->core.path, 
                                                    &object->vtable,
                                                    core)) {
            EasyDbusDebug ("Error on register object %s", object->core.path);
            goto error;
         }
      }
      easydbus_conn_enable_filters (conn);
   }

   // check if there is watcher
   if (conn->watcher_add_cb && conn->watcher_remove_cb) {
      if (easydbus_watcher_enable (conn, conn->watcher_add_cb,
                                   conn->watcher_remove_cb,
                                   conn->watcher_closure))
         goto error;
   }

   dbus_error_free (&err);

   return result;
error:
   if (conn->registered_ondbus)
      dbus_bus_release_name (core->conn, core->service_name, &err);

   if (core->conn != NULL)
      dbus_connection_unref (core->conn);

   dbus_error_free (&err);
   return -1;
}

int 
easydbus_conn_set_error_cb (EasyDbus_conn *conn,
                            easydbus_error_cb_f cb,
                            void *user_closure) 
{
  if (!conn || !cb) 
     return -1; 

  conn->error_cb = cb;
  conn->error_closure = user_closure;

  return 0;
}

inline int
easydbus_conn_get_n_object (EasyDbus_conn *conn)
{
   return (conn ? 
           ((struct EasyDbus_core *) conn)->n_objs : -1);
}

EasyDbus_object *
easydbus_conn_get_object (EasyDbus_conn *conn,
                          unsigned int n)
{
   int i;
   struct EasyDbus_core *core = 
      (struct EasyDbus_core *) conn;
   struct EasyDbus_object_box *ans = NULL;

   if (conn && (((int) n) <= core->n_objs))
      for (i = 0, ans = core->objects;
           i < core->n_objs;
           i++, ans = ans->next);

   return (EasyDbus_object *) ans;
}

int
easydbus_conn_set_reply_async_cb (EasyDbus_conn *conn,
                                  easydbus_reply_async_cb_f r_cb,
                                  void *user_closure)
{
   if (!conn || !r_cb)
      return -1;
   conn->reply_async_cb = r_cb;
   conn->reply_async_closure = user_closure;

   return 0;
}

int
easydbus_conn_set_error_message_cb (EasyDbus_conn *conn,
                                    easydbus_error_message_cb_f e_cb,
                                    void *user_closure)
{
   if (!conn || !e_cb)
      return -1;
   conn->error_message_cb = e_cb;
   conn->error_message_closure = user_closure;

   return 0;
}

int
easydbus_conn_set_reply_message_cb (EasyDbus_conn *conn,
                                    easydbus_reply_message_cb_f r_cb)
{
   if (!conn || !r_cb)
      return -1;
   conn->reply_message_cb = r_cb;

   return 0;
}

EasyDbus_conn *
easydbus_conn_create (void)
{
   struct EasyDbus_core *conn =
      (struct EasyDbus_core *)
      malloc (sizeof (struct EasyDbus_core));

   if (!conn)
      return NULL;

   memset (conn, 0, sizeof (struct EasyDbus_core));

   conn->objects = NULL;
   conn->conn = NULL;
   conn->service_name = NULL;
   conn->watcher = NULL;
   conn->handled_ext_signals = NULL;
   conn->user_data.error_cb = NULL;
   conn->user_data.error_closure = NULL;
   conn->user_data.flags = 0;
   conn->user_data.bus = EASYDBUS_INVALID;
   conn->pending_msgs = NULL;
   conn->user_data.reply_async_cb = NULL;
   conn->user_data.error_message_cb = NULL;
   conn->user_data.error_message_closure = NULL;
   conn->user_data.reply_message_cb = NULL;

   return (EasyDbus_conn *) conn;
}

void 
easydbus_conn_set_closure (EasyDbus_conn *c,
                           void *closure)
{
   c->closure = closure;
}

void *
easydbus_conn_get_closure (EasyDbus_conn *c)
{
   return (c ? c->closure : NULL);
}

int
easydbus_conn_destroy (EasyDbus_conn * conn)
{
   struct EasyDbus_core *core =
      (struct EasyDbus_core *) conn;
   struct EasyDbus_object_box *object = NULL;
   struct EasyDbus_watcher *watch = NULL;
   struct EasyDbus_Pending *p = NULL;
   struct EasyDbus_ext_signal *signal = NULL;
   DBusError err;
   int ret_val = 0;
   int i;

   EasyDbusDebug ("Destroy service %s...",
                  core->service_name ? core->
                  service_name : ".");

   dbus_error_init (&err);


   if (core->n_objs) {
      for (i = 0; i < core->n_objs; i++) {
         object = core->objects;
         core->objects = object->next;
         easydbus_object_unregister (conn, &object->core);
         easydbus_object_free_skeleton (&object->core);
      }
   }

   /* remove external signals */
   while (core->handled_ext_signals) {
      signal = core->handled_ext_signals;
      core->handled_ext_signals = signal->next;
      easydbus_ext_signal_free_skeleton (signal);
   }

   if (core->conn != NULL) {
      if (core->service_name != NULL) {
         if (conn->registered_ondbus)
            // dbus_bus_release_name (core->conn,
            //    core->service_name, &err);
            free (core->service_name);
         conn->registered_ondbus = 0;
      }
     
      for (p = core->pending_msgs; core->pending_msgs; 
           p = core->pending_msgs) {
         core->pending_msgs = p->next;
         easydbus_pending_destroy(p);
      }

      while (core->watcher != NULL) {
         watch = core->watcher;
         if (conn->watcher_remove_cb && 
             dbus_watch_get_enabled (core->watcher->watch))
           conn->watcher_remove_cb(core->watcher, 
                                   conn->watcher_closure);
         core->watcher = core->watcher->next;
         free (watch);
      }
      // use watcher_remove_cb field for detect
      // if was watcher.
      if (conn->watcher_remove_cb) {
         conn->watcher_remove_cb = NULL;
         conn->watcher_add_cb = NULL;
         // remove watch callbacks. Workaround for resolve problem
         // on call of callback when data are invalid.
         // (An another solution could be check connection data)
         dbus_connection_set_watch_functions (core->conn,
                                              NULL, NULL, NULL,
                                              NULL, NULL);
      } 

      // dbus_connection_remove_filter (core->conn,
      //    easydbus_core_filter_func, core);
      dbus_connection_unref (core->conn);
   }

   free (core);
   dbus_error_free (&err);

   return ret_val;
}

inline int 
easydbus_conn_get_system_service_address (EasyDbus_conn * data, 
                                          char *serviceName) 
{
   struct EasyDbus_core *core = (struct EasyDbus_core *) data;
   char *dbus_starter_address = NULL;
   DBusError err;

   dbus_error_init (&err);

   /* recover DBUS_STARTER_ADDRESS environment variable */
   dbus_starter_address = getenv ("DBUS_STARTER_ADDRESS");

   if (dbus_starter_address == NULL) {
      EasyDbusDebug ("Error on recover dbus_starter_address");
      return -1;
   }

   core->conn = dbus_connection_open (dbus_starter_address, &err);

   if (!core->conn) {
      EasyDbusDebug ("Error %s from "
                     "dbus_connection_open: %s",
                     err.name, err.message);
      return -1;
   }

   /* do not allw libdbus to exit on connection failure ( This
    * may around random exit () on SIGPIPE errors) */
   dbus_connection_set_exit_on_disconnect (core->conn, FALSE);

   dbus_bus_register (core->conn, &err);

   if (dbus_error_is_set (&err)) {
      EasyDbusDebug ("Error %s from "
                     "dbus_bus_register: %s", err.name, err.message);
      goto error_acquire;
   }

   /* TODO: manage return values correctly */
   /* request for set service name */
   dbus_bus_request_name (core->conn, serviceName, 0, &err);


   if (dbus_error_is_set (&err)) {
      EasyDbusDebug ("Error %s from "
                     "dbus_bus_request_name: %s",
                     err.name, err.message);
      goto error_acquire;
   }

   /* see if this is correct and what it do. */
   //if (set_unique_nameID (core, serviceName)) {
   // EasyDbusDebug ("Error on set unique nameID");
   // goto error_acquire;
   //}

   data->registered_ondbus = 1;

   if (easydbus_save_serviceName (core, serviceName)) {
      EasyDbusDebug ("Error on set unique nameID");
      goto error_acquire;
   }

   dbus_error_free (&err);

   return 0;

 error_acquire:
   if (data->registered_ondbus)
      dbus_bus_release_name (core->conn, serviceName, &err);

   if (core->conn != NULL)
      dbus_connection_unref (core->conn);

   dbus_error_free (&err);

   return -1;
}

const char *
easydbus_conn_get_service_name (const EasyDbus_conn * conn)
{
   return conn ? (const char *)
      ((struct EasyDbus_core *)conn)->service_name : NULL;
}

int
easydbus_conn_get_fd (EasyDbus_conn * data)
{
   struct EasyDbus_core *core = (struct EasyDbus_core *) data;
   int fd;

   if (data)
      //if (dbus_connection_get_fd (core->conn, &fd))
      if (dbus_connection_get_unix_fd (core->conn, &fd))
         return fd;

   return -1;
}

// vim: ts=3 shiftwidth=3 expandtab

---