Commit 041b0767 authored by Havoc Pennington's avatar Havoc Pennington
Browse files

2002-11-24 Havoc Pennington <hp@pobox.com>

        * test/echo-client.c, test/echo-server.c: cheesy test
	clients.

	* configure.in (AC_CHECK_FUNCS): check for writev

	* dbus/dbus-message.c (_dbus_message_get_network_data): new
	function

	* dbus/dbus-list.c (_dbus_list_foreach): new function

	* dbus/dbus-internals.c (_dbus_verbose): new function

	* dbus/dbus-server.c, dbus/dbus-server.h: public object
	representing a server that listens for connections.

	* dbus/.cvsignore: create

	* dbus/dbus-errors.h, dbus/dbus-errors.c:
	public API for reporting errors

	* dbus/dbus-connection.h, dbus/dbus-connection.c:
	public object representing a connection that
	sends/receives messages. (Same object used for
	both client and server.)

	* dbus/dbus-transport.h, dbus/dbus-transport.c:
	Basic abstraction for different kinds of stream
	that we might read/write messages from.
parent 576cdb6e
config.log
config.status
config.sub
configure
*.pc
libtool
ltmain.sh
stamp-h1
Doxyfile
Makefile
Makefile.in
aclocal.m4
autom4te.cache
config.guess
config.h
config.h.in
2002-11-24 Havoc Pennington <hp@pobox.com>
* test/echo-client.c, test/echo-server.c: cheesy test
clients.
* configure.in (AC_CHECK_FUNCS): check for writev
* dbus/dbus-message.c (_dbus_message_get_network_data): new
function
* dbus/dbus-list.c (_dbus_list_foreach): new function
* dbus/dbus-internals.c (_dbus_verbose): new function
* dbus/dbus-server.c, dbus/dbus-server.h: public object
representing a server that listens for connections.
* dbus/.cvsignore: create
* dbus/dbus-errors.h, dbus/dbus-errors.c:
public API for reporting errors
* dbus/dbus-connection.h, dbus/dbus-connection.c:
public object representing a connection that
sends/receives messages. (Same object used for
both client and server.)
* dbus/dbus-transport.h, dbus/dbus-transport.c:
Basic abstraction for different kinds of stream
that we might read/write messages from.
2002-11-23 Havoc Pennington <hp@pobox.com>
* dbus/dbus-internals.h (_DBUS_INT_MAX): add _DBUS_INT_MIN
......
.deps
.libs
Makefile
Makefile.in
*.lo
*.la
dbus-daemon-1
......@@ -102,6 +102,10 @@ AC_C_BIGENDIAN
AC_CHECK_FUNCS(vsnprintf vasprintf)
dnl check for writev header and writev function so we're
dnl good to go if HAVE_WRITEV gets defined.
AC_CHECK_HEADERS(sys/uio.h, [AC_CHECK_FUNCS(writev)])
DBUS_CLIENT_CFLAGS=
DBUS_CLIENT_LIBS=
AC_SUBST(DBUS_CLIENT_CFLAGS)
......@@ -112,6 +116,11 @@ DBUS_BUS_LIBS=
AC_SUBST(DBUS_BUS_CFLAGS)
AC_SUBST(DBUS_BUS_LIBS)
DBUS_TEST_CFLAGS=
DBUS_TEST_LIBS=
AC_SUBST(DBUS_TEST_CFLAGS)
AC_SUBST(DBUS_TEST_LIBS)
AC_OUTPUT([
Makefile
Doxyfile
......
.deps
.libs
Makefile
Makefile.in
*.lo
*.la
dbus-test
......@@ -7,18 +7,38 @@ lib_LTLIBRARIES=libdbus-1.la
dbusinclude_HEADERS= \
dbus.h \
dbus-errors.h \
dbus-macros.h \
dbus-memory.h \
dbus-message.h \
dbus-server.h \
dbus-types.h
libdbus_1_la_SOURCES= \
dbus-connection.c \
dbus-connection-internal.h \
dbus-errors.c \
dbus-memory.c \
dbus-message.c
dbus-message.c \
dbus-message-internal.h \
dbus-server.c \
dbus-server-protected.h \
dbus-server-unix.c \
dbus-server-unix.h \
dbus-transport.c \
dbus-transport.h \
dbus-transport-protected.h \
dbus-transport-unix.c \
dbus-transport-unix.h \
dbus-watch.c \
dbus-watch.h
## this library is linked into both libdbus and the bus
## itself, but does not export any symbols from libdbus.
## It contains utility functions not in the public API.
## i.e. the point is to contain symbols that we don't
## want the shared lib to export, but we do want the
## message bus to be able to use.
noinst_LTLIBRARIES=libdbus-convenience.la
......
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-connection-internal.h DBusConnection internal interfaces
*
* Copyright (C) 2002 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
*
*/
#ifndef DBUS_CONNECTION_INTERNAL_H
#define DBUS_CONNECTION_INTERNAL_H
#include <dbus/dbus-internals.h>
#include <dbus/dbus-connection.h>
#include <dbus/dbus-message.h>
#include <dbus/dbus-transport.h>
DBUS_BEGIN_DECLS;
typedef enum
{
DBUS_ITERATION_DO_WRITING = 1 << 0, /**< Write messages out. */
DBUS_ITERATION_DO_READING = 1 << 1, /**< Read messages in. */
DBUS_ITERATION_BLOCK = 1 << 2 /**< Block if nothing to do. */
} DBusIterationFlags;
dbus_bool_t _dbus_connection_queue_received_message (DBusConnection *connection,
DBusMessage *message);
dbus_bool_t _dbus_connection_have_messages_to_send (DBusConnection *connection);
DBusMessage* _dbus_connection_get_message_to_send (DBusConnection *connection);
void _dbus_connection_message_sent (DBusConnection *connection,
DBusMessage *message);
dbus_bool_t _dbus_connection_add_watch (DBusConnection *connection,
DBusWatch *watch);
void _dbus_connection_remove_watch (DBusConnection *connection,
DBusWatch *watch);
DBusConnection* _dbus_connection_new_for_transport (DBusTransport *transport);
void _dbus_connection_do_iteration (DBusConnection *connection,
unsigned int flags,
int timeout_milliseconds);
void _dbus_connection_transport_error (DBusConnection *connection,
DBusResultCode result_code);
DBUS_END_DECLS;
#endif /* DBUS_CONNECTION_INTERNAL_H */
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-connection.c DBusConnection object
*
* Copyright (C) 2002 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-connection.h"
#include "dbus-list.h"
#include "dbus-transport.h"
#include "dbus-watch.h"
#include "dbus-connection-internal.h"
#include "dbus-list.h"
/**
* @defgroup DBusConnection DBusConnection
* @ingroup DBus
* @brief Connection to another application
*
* A DBusConnection represents a connection to another
* application. Messages can be sent and received via this connection.
*
* The connection maintains a queue of incoming messages and a queue
* of outgoing messages. dbus_connection_pop_message() and friends
* can be used to read incoming messages from the queue.
* Outgoing messages are automatically discarded as they are
* written to the network.
*
* In brief a DBusConnection is a message queue associated with some
* message transport mechanism such as a socket.
*
*/
/**
* @defgroup DBusConnectionInternals DBusConnection implementation details
* @ingroup DBusInternals
* @brief Implementation details of DBusConnection
*
* @{
*/
/**
* Implementation details of DBusConnection. All fields are private.
*/
struct DBusConnection
{
int refcount; /**< Reference count. */
DBusList *outgoing_messages; /**< Queue of messages we need to send, send the end of the list first. */
DBusList *incoming_messages; /**< Queue of messages we have received, end of the list received most recently. */
int n_outgoing; /**< Length of outgoing queue. */
int n_incoming; /**< Length of incoming queue. */
DBusTransport *transport; /**< Object that sends/receives messages over network. */
DBusWatchList *watches; /**< Stores active watches. */
DBusConnectionErrorFunction error_function; /**< Callback for errors. */
void *error_data; /**< Data for error callback. */
DBusFreeFunction error_free_data_function; /**< Free function for error callback data. */
};
/**
* Adds a message to the incoming message queue, returning #FALSE
* if there's insufficient memory to queue the message.
*
* @param connection the connection.
* @param message the message to queue.
* @returns #TRUE on success.
*/
dbus_bool_t
_dbus_connection_queue_received_message (DBusConnection *connection,
DBusMessage *message)
{
if (!_dbus_list_append (&connection->incoming_messages,
message))
return FALSE;
dbus_message_ref (message);
connection->n_incoming += 1;
return TRUE;
}
/**
* Checks whether there are messages in the outgoing message queue.
*
* @param connection the connection.
* @returns #TRUE if the outgoing queue is non-empty.
*/
dbus_bool_t
_dbus_connection_have_messages_to_send (DBusConnection *connection)
{
return connection->outgoing_messages != NULL;
}
/**
* Gets the next outgoing message. The message remanins in the
* queue, and the caller does not own a reference to it.
*
* @param connection the connection.
* @returns the message to be sent.
*/
DBusMessage*
_dbus_connection_get_message_to_send (DBusConnection *connection)
{
return _dbus_list_get_last (&connection->outgoing_messages);
}
/**
* Notifies the connection that a message has been sent, so the
* message can be removed from the outgoing queue.
*
* @param connection the connection.
* @param message the message that was sent.
*/
void
_dbus_connection_message_sent (DBusConnection *connection,
DBusMessage *message)
{
_dbus_assert (message == _dbus_list_get_last (&connection->outgoing_messages));
_dbus_list_pop_last (&connection->outgoing_messages);
dbus_message_unref (message);
connection->n_outgoing -= 1;
if (connection->n_outgoing == 0)
_dbus_transport_messages_pending (connection->transport,
connection->n_outgoing);
}
/**
* Adds a watch using the connection's DBusAddWatchFunction if
* available. Otherwise records the watch to be added when said
* function is available. Also re-adds the watch if the
* DBusAddWatchFunction changes. May fail due to lack of memory.
*
* @param connection the connection.
* @param watch the watch to add.
* @returns #TRUE on success.
*/
dbus_bool_t
_dbus_connection_add_watch (DBusConnection *connection,
DBusWatch *watch)
{
return _dbus_watch_list_add_watch (connection->watches,
watch);
return TRUE;
}
/**
* Removes a watch using the connection's DBusRemoveWatchFunction
* if available. It's an error to call this function on a watch
* that was not previously added.
*
* @param connection the connection.
* @param watch the watch to remove.
*/
void
_dbus_connection_remove_watch (DBusConnection *connection,
DBusWatch *watch)
{
_dbus_watch_list_remove_watch (connection->watches,
watch);
}
static void
handle_error (DBusConnection *connection,
DBusResultCode result)
{
if (result != DBUS_RESULT_SUCCESS &&
connection->error_function != NULL)
{
dbus_connection_ref (connection);
(* connection->error_function) (connection, result,
connection->error_data);
dbus_connection_unref (connection);
}
}
static void
set_result_handled (DBusConnection *connection,
DBusResultCode *result_address,
DBusResultCode result)
{
dbus_set_result (result_address, result);
handle_error (connection, result);
}
/**
* Reports a transport error to the connection. Typically
* results in an application error callback being invoked.
*
* @param connection the connection.
* @param result_code the error code.
*/
void
_dbus_connection_transport_error (DBusConnection *connection,
DBusResultCode result_code)
{
handle_error (connection, result_code);
}
/**
* Queues incoming messages and sends outgoing messages for this
* connection, optionally blocking in the process. Each call to
* _dbus_connection_do_iteration() will call select() or poll() one
* time and then read or write data if possible.
*
* The purpose of this function is to be able to flush outgoing
* messages or queue up incoming messages without returning
* control to the application and causing reentrancy weirdness.
*
* The flags parameter allows you to specify whether to
* read incoming messages, write outgoing messages, or both,
* and whether to block if no immediate action is possible.
*
* The timeout_milliseconds parameter does nothing unless the
* iteration is blocking.
*
* If there are no outgoing messages and DBUS_ITERATION_DO_READING
* wasn't specified, then it's impossible to block, even if
* you specify DBUS_ITERATION_BLOCK; in that case the function
* returns immediately.
*
* @param connection the connection.
* @param flags iteration flags.
* @param timeout_milliseconds maximum blocking time, or -1 for no limit.
*/
void
_dbus_connection_do_iteration (DBusConnection *connection,
unsigned int flags,
int timeout_milliseconds)
{
if (connection->n_outgoing == 0)
flags &= ~DBUS_ITERATION_DO_WRITING;
_dbus_transport_do_iteration (connection->transport,
flags, timeout_milliseconds);
}
/**
* Creates a new connection for the given transport. A transport
* represents a message stream that uses some concrete mechanism, such
* as UNIX domain sockets. May return #NULL if insufficient
* memory exists to create the connection.
*
* @param transport the transport.
* @returns the new connection, or #NULL on failure.
*/
DBusConnection*
_dbus_connection_new_for_transport (DBusTransport *transport)
{
DBusConnection *connection;
DBusWatchList *watch_list;
watch_list = NULL;
connection = NULL;
watch_list = _dbus_watch_list_new ();
if (watch_list == NULL)
goto error;
connection = dbus_new0 (DBusConnection, 1);
if (connection == NULL)
goto error;
connection->refcount = 1;
connection->transport = transport;
connection->watches = watch_list;
_dbus_transport_ref (transport);
_dbus_transport_set_connection (transport, connection);
return connection;
error:
_dbus_assert (connection == NULL);
if (watch_list)
_dbus_watch_list_free (watch_list);
return NULL;
}
/** @} */
/**
* @addtogroup DBusConnection
*
* @{
*/
/**
* Opens a new connection to a remote address.
*
* @todo specify what the address parameter is. Right now
* it's just the name of a UNIX domain socket. It should be
* something more complex that encodes which transport to use.
*
* If the open fails, the function returns #NULL, and provides
* a reason for the failure in the result parameter. Pass
* #NULL for the result parameter if you aren't interested
* in the reason for failure.
*
* @param address the address.
* @param result address where a result code can be returned.
* @returns new connection, or #NULL on failure.
*/
DBusConnection*
dbus_connection_open (const char *address,
DBusResultCode *result)
{
DBusConnection *connection;
DBusTransport *transport;
transport = _dbus_transport_open (address, result);
if (transport == NULL)
return NULL;
connection = _dbus_connection_new_for_transport (transport);
_dbus_transport_unref (transport);
if (connection == NULL)
{
dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
return NULL;
}
return connection;
}
/**
* Increments the reference count of a DBusConnection.
*
* @param connection the connection.
*/
void
dbus_connection_ref (DBusConnection *connection)
{
connection->refcount += 1;
}
/**
* Decrements the reference count of a DBusConnection, and finalizes
* it if the count reaches zero. If a connection is still connected
* when it's finalized, it will be disconnected (that is, associated
* file handles will be closed).
*
* @param connection the connection.
*/
void
dbus_connection_unref (DBusConnection *connection)
{
_dbus_assert (connection != NULL);
_dbus_assert (connection->refcount > 0);
connection->refcount -= 1;
if (connection->refcount == 0)
{
/* free error data as a side effect */
dbus_connection_set_error_function (connection,
NULL, NULL, NULL);
_dbus_watch_list_free (connection->watches);
_dbus_list_foreach (&connection->outgoing_messages,
(DBusForeachFunction) dbus_message_unref,
NULL);
_dbus_list_clear (&connection->outgoing_messages);
_dbus_list_foreach (&connection->incoming_messages,
(DBusForeachFunction) dbus_message_unref,
NULL);
_dbus_list_clear (&connection->incoming_messages);
_dbus_transport_unref (connection->transport);
dbus_free (connection);
}
}
/**
* Closes the connection, so no further data can be sent or received.
* Any further attempts to send data will result in errors. This
* function does not affect the connection's reference count. It's
* safe to disconnect a connection more than once; all calls after the
* first do nothing. It's impossible to "reconnect" a connection, a
* new connection must be created.
*
* @param connection the connection.
*/
void
dbus_connection_disconnect (DBusConnection *connection)
{
_dbus_transport_disconnect (connection->transport);
}
/**
* Gets whether the connection is currently connected. All
* connections are connected when they are opened. A connection may
* become disconnected when the remote application closes its end, or
* exits; a connection may also be disconnected with
* dbus_connection_disconnect().
*
* @param connection the connection.
* @returns #TRUE if the connection is still alive.
*/
dbus_bool_t
dbus_connection_get_is_connected (DBusConnection *connection)
{