Commit a6c8a71b authored by Havoc Pennington's avatar Havoc Pennington
Browse files

2003-08-14 Havoc Pennington <hp@redhat.com>

	* dbus/dbus-pending-call.c: start on new object that will replace
	DBusMessageHandler and ReplyHandlerData for tracking outstanding
	replies

	* dbus/dbus-gproxy.c: start on proxy object used to communicate
	with remote interfaces

	* dbus/dbus-gidl.c: do the boring boilerplate in here
parent 9d1c3a0f
2003-08-14 Havoc Pennington <hp@redhat.com>
* dbus/dbus-pending-call.c: start on new object that will replace
DBusMessageHandler and ReplyHandlerData for tracking outstanding
replies
* dbus/dbus-gproxy.c: start on proxy object used to communicate
with remote interfaces
* dbus/dbus-gidl.c: do the boring boilerplate in here
2003-08-12 Havoc Pennington <hp@pobox.com> 2003-08-12 Havoc Pennington <hp@pobox.com>
* bus/dispatch.c (bus_dispatch): make this return proper * bus/dispatch.c (bus_dispatch): make this return proper
......
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-pending-call.c Object representing a call in progress.
*
* Copyright (C) 2002, 2003 Red Hat Inc.
*
* Licensed under the Academic Free License version 1.2
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "dbus-internals.h"
#include "dbus-message-pending.h"
#include "dbus-list.h"
#include "dbus-threads.h"
#include "dbus-test.h"
#include "dbus-connection-internal.h"
/**
* @defgroup DBusPendingCallInternals DBusPendingCall implementation details
* @ingroup DBusInternals
* @brief DBusPendingCall private implementation details.
*
* The guts of DBusPendingCall and its methods.
*
* @{
*/
/**
* @brief Internals of DBusPendingCall
*
* Object representing a reply message that we're waiting for.
*/
struct DBusPendingCall
{
DBusAtomic refcount; /**< reference count */
DBusPendingCallNotifyFunction function; /**< Notifier when reply arrives. */
void *user_data; /**< user data for function */
DBusFreeFunction free_user_data; /**< free the user data */
DBusConnection *connection; /**< Connections we're associated with */
DBusMessage *reply; /**< Reply (after we've received it) */
DBusTimeout *timeout; /**< Timeout */
DBusList *timeout_link; /**< Preallocated timeout response */
dbus_uint32_t reply_serial; /**< Expected serial of reply */
unsigned int completed : 1; /**< TRUE if completed */
unsigned int timeout_added : 1; /**< Have added the timeout */
};
/**
* Creates a new pending reply object.
*
* @param connection connection where reply will arrive
* @param reply_serial reply serial of the expected reply
* @returns a new #DBusPendingCall or #NULL if no memory.
*/
DBusPendingCall*
_dbus_pending_call_new (DBusConnection *connection,
dbus_uint32_t reply_serial)
{
DBusPendingCall *pending;
pending = dbus_new (DBusPendingCall, 1);
if (pending == NULL)
return NULL;
pending->refcount.value = 1;
pending->connection = connection;
pending->reply_serial = reply_serial;
return pending;
}
/** @} */
/**
* @defgroup DBusPendingCall DBusPendingCall
* @ingroup DBus
* @brief Pending reply to a method call message
*
* A DBusPendingCall is an object representing an
* expected reply. A #DBusPendingCall can be created
* when you send a message that should have a reply.
*
* @{
*/
/**
* @typedef DBusPendingCall
*
* Opaque data type representing a message pending.
*/
/**
* Increments the reference count on a pending call.
*
* @param pending the pending call object
*/
void
dbus_pending_call_ref (DBusPendingCall *pending)
{
_dbus_return_if_fail (pending != NULL);
_dbus_atomic_inc (&pending->refcount);
}
/**
* Decrements the reference count on a pending call,
* freeing it if the count reaches 0.
*
* @param pending the pending call object
*/
void
dbus_pending_call_unref (DBusPendingCall *pending)
{
dbus_bool_t last_unref;
_dbus_return_if_fail (pending != NULL);
last_unref = (_dbus_atomic_dec (&pending->refcount) == 1);
if (last_unref)
{
if (pending->free_user_data)
(* pending->free_user_data) (pending->user_data);
if (pending->connection != NULL)
{
_dbus_connection_pending_destroyed_locked (connection, pending);
pending->connection = NULL;
}
if (pending->reply)
{
dbus_message_unref (pending->reply);
pending->reply = NULL;
}
dbus_free (pending);
}
}
/**
* Sets a notification function to be called when the reply is
* received or the pending call times out.
*
* @param pending the pending call
* @param function notifier function
* @param user_data data to pass to notifier function
* @param free_user_data function to free the user data
*
*/
void
dbus_pending_call_set_notify (DBusPendingCall *pending,
DBusPendingCallNotifyFunction function,
void *user_data,
DBusFreeFunction free_user_data)
{
DBusFreeFunction old_free_func;
void *old_user_data;
_dbus_return_if_fail (pending != NULL);
_DBUS_LOCK (pending_call);
old_free_func = pending->free_user_data;
old_user_data = pending->user_data;
pending->user_data = user_data;
pending->free_user_data = free_user_data;
pending->function = function;
_DBUS_UNLOCK (pending_call);
if (old_free_func)
(* old_free_func) (old_user_data);
}
/** @} */
#ifdef DBUS_BUILD_TESTS
static DBusPendingResult
test_pending (DBusPendingCall *pending,
DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
return DBUS_PENDING_RESULT_NOT_YET_HANDLED;
}
static void
free_test_data (void *data)
{
/* does nothing */
}
/**
* @ingroup DBusPendingCallInternals
* Unit test for DBusPendingCall.
*
* @returns #TRUE on success.
*/
dbus_bool_t
_dbus_pending_call_test (const char *test_data_dir)
{
return TRUE;
}
#endif /* DBUS_BUILD_TESTS */
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-pending-call.h Object representing a call in progress.
*
* Copyright (C) 2002, 2003 Red Hat Inc.
*
* Licensed under the Academic Free License version 1.2
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION)
#error "Only <dbus/dbus.h> can be included directly, this file may disappear or change contents."
#endif
#ifndef DBUS_PENDING_CALL_H
#define DBUS_PENDING_CALL_H
#include <dbus/dbus-macros.h>
#include <dbus/dbus-types.h>
#include <dbus/dbus-connection.h>
DBUS_BEGIN_DECLS;
typedef void (* DBusPendingCallNotifyFunction) (DBusPendingCall *pending,
void *user_data);
DBusPendingCall* _dbus_pending_call_new (DBusConnection *connection,
dbus_uint32_t reply_serial);
void dbus_pending_call_ref (DBusPendingCall *pending);
void dbus_pending_call_unref (DBusPendingCall *pending);
void dbus_pending_call_set_notify (DBusPendingCall *pending,
DBusPendingCallNotifyFunction function,
void *user_data,
DBusFreeFunction free_user_data);
dbus_bool_t dbus_pending_call_get_completed (DBusPendingCall *pending);
DBusMessage* dbus_pending_call_get_reply (DBusPendingCall *pending);
DBUS_END_DECLS;
#endif /* DBUS_PENDING_CALL_H */
INCLUDES=-I$(top_srcdir) $(DBUS_CLIENT_CFLAGS) $(DBUS_GLIB_CFLAGS) INCLUDES=-I$(top_srcdir) $(DBUS_CLIENT_CFLAGS) $(DBUS_GLIB_CFLAGS) -DDBUS_COMPILATION=1
dbusincludedir=$(includedir)/dbus-1.0/dbus dbusincludedir=$(includedir)/dbus-1.0/dbus
lib_LTLIBRARIES=libdbus-glib-1.la lib_LTLIBRARIES=libdbus-glib-1.la
dbusinclude_HEADERS= \ dbusinclude_HEADERS= \
dbus-glib.h dbus-glib.h \
dbus-gproxy.h
libdbus_glib_1_la_SOURCES = \ libdbus_glib_1_la_SOURCES = \
dbus-gmain.c \ dbus-gmain.c \
dbus-gproxy.c \
dbus-gthread.c dbus-gthread.c
libdbus_glib_1_la_LIBADD= $(DBUS_GLIB_LIBS) $(top_builddir)/dbus/libdbus-1.la libdbus_glib_1_la_LIBADD= $(DBUS_GLIB_LIBS) $(top_builddir)/dbus/libdbus-1.la
bin_PROGRAMS=dbus-glib-compiler
dbus_glib_compiler_SOURCES = \
dbus-gidl.c \
dbus-gidl.h \
dbus-compiler-main.c
dbus_glib_compiler_LDADD= libdbus-glib-1.la $(DBUS_GLIB_LIBS) $(top_builddir)/dbus/libdbus-1.la
if DBUS_BUILD_TESTS if DBUS_BUILD_TESTS
if HAVE_GLIB_THREADS if HAVE_GLIB_THREADS
......
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-compiler-main.c main() for GLib stubs/skels generator
*
* Copyright (C) 2003 Red Hat, Inc.
*
* Licensed under the Academic Free License version 1.2
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "dbus-gidl.h"
int
main (int argc, char **argv)
{
return 0;
}
#ifdef DBUS_BUILD_TESTS
/**
* @ingroup DBusGCompiler
* Unit test for GLib stubs/skels compiler
* @returns #TRUE on success.
*/
dbus_bool_t
_dbus_gcompiler_test (void)
{
return TRUE;
}
#endif /* DBUS_BUILD_TESTS */
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-gidl.c data structure describing an interface, to be generated from IDL
* or something
*
* Copyright (C) 2003 Red Hat, Inc.
*
* Licensed under the Academic Free License version 1.2
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "dbus-gidl.h"
struct InterfaceInfo
{
int refcount;
char *name;
GSList *methods;
GSList *signals;
};
struct MethodInfo
{
int refcount;
GSList *args;
char *name;
MethodStyle style;
};
struct SignalInfo
{
int refcount;
GSList *args;
char *name;
};
struct ArgInfo
{
int refcount;
char *name;
int type;
ArgDirection direction;
};
static void
free_method_list (GSList **methods_p)
{
GSList *tmp;
tmp = *methods_p;
while (tmp != NULL)
{
method_info_unref (tmp->data);
tmp = tmp->next;
}
g_slist_free (*methods_p);
*methods_p = NULL;
}
static void
free_signal_list (GSList **signals_p)
{
GSList *tmp;
tmp = *signals_p;
while (tmp != NULL)
{
signal_info_unref (tmp->data);
tmp = tmp->next;
}
g_slist_free (*signals_p);
*signals_p = NULL;
}
InterfaceInfo*
interface_info_new (const char *name)
{
InterfaceInfo *info;
info = g_new0 (InterfaceInfo, 1);
info->refcount = 1;
info->name = g_strdup (name);
return info;
}
void
interface_info_ref (InterfaceInfo *info)
{
info->refcount += 1;
}
void
interface_info_unref (InterfaceInfo *info)
{
info->refcount -= 1;
if (info->refcount == 0)
{
free_method_list (&info->methods);
free_signal_list (&info->signals);
g_free (info->name);
g_free (info);
}
}
GSList*
interface_info_get_methods (InterfaceInfo *info)
{
return info->methods;
}
GSList*
interface_info_get_signals (InterfaceInfo *info)
{
return info->signals;
}
void
interface_info_add_method (InterfaceInfo *info,
MethodInfo *method)
{
method_info_ref (method);
info->methods = g_slist_append (info->methods, method);
}
void
interface_info_add_signal (InterfaceInfo *info,
SignalInfo *signal)
{
signal_info_ref (signal);
info->signals = g_slist_append (info->signals, signal);
}
static void
free_arg_list (GSList **args_p)
{
GSList *tmp;
tmp = *args_p;
while (tmp != NULL)
{
arg_info_unref (tmp->data);
tmp = tmp->next;
}
g_slist_free (*args_p);
*args_p = NULL;
}
MethodInfo*
method_info_new (const char *name,
MethodStyle style)
{
MethodInfo *info;
info = g_new0 (MethodInfo, 1);
info->refcount = 1;
info->name = g_strdup (name);
info->style = style;
return info;
}
void
method_info_ref (MethodInfo *info)
{
info->refcount += 1;
}
void
method_info_unref (MethodInfo *info)
{
info->refcount -= 1;
if (info->refcount == 0)
{
free_arg_list (&info->args);
g_free (info->name);
g_free (info);
}
}
const char*
method_info_get_name (MethodInfo *info)
{
return info->name;
}
GSList*
method_info_get_args (MethodInfo *info)
{
return info->args;
}
MethodStyle
method_info_get_style (MethodInfo *info)
{
return info->style;
}
void
method_info_add_arg (MethodInfo *info,
ArgInfo *arg)
{
arg_info_ref (arg);
info->args = g_slist_append (info->args, arg);
}
SignalInfo*
signal_info_new (const char *name)
{
SignalInfo *info;
info = g_new0 (SignalInfo, 1);
info->refcount = 1;
info->name = g_strdup (name);
return info;
}
void
signal_info_ref (SignalInfo *info)
{
info->refcount += 1;
}
void
signal_info_unref (SignalInfo *info)
{
info->refcount -= 1;
if (info->refcount == 0)
{
free_arg_list (&info->args);
g_free (info->name);
g_free (info);
}
}
const char*
signal_info_get_name (SignalInfo *info)
{
return info->name;
}
GSList*
signal_info_get_args (SignalInfo *info)
{