dbus/dbus-server-debug.c

   1 /* -*- mode: C; c-file-style: "gnu" -*- */
   2 /* dbus-server-debug.h In-proc debug server implementation
   3  *
   4  * Copyright (C) 2003  CodeFactory AB
   5  *
   6  * Licensed under the Academic Free License version 1.2
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  */
  23
  24 #include "dbus-internals.h"
  25 #include "dbus-server-debug.h"
  26 #include "dbus-transport-debug.h"
  27 #include "dbus-connection-internal.h"
  28 #include "dbus-hash.h"
  29
  30 #ifdef DBUS_BUILD_TESTS
  31
  32 /**
  33  * @defgroup DBusServerDebug DBusServerDebug
  34  * @ingroup  DBusInternals
  35  * @brief In-process debug server used in unit tests.
  36  *
  37  * Types and functions related to DBusServerDebug.
  38  * This is used for unit testing.
  39  *
  40  * @{
  41  */
  42
  43 /**
  44  * Default timeout interval when reading or writing.
  45  */
  46 #define DEFAULT_INTERVAL 1
  47
  48 /**
  49  * Opaque object representing a debug server implementation.
  50  */
  51 typedef struct DBusServerDebug DBusServerDebug;
  52
  53 /**
  54  * Implementation details of DBusServerDebug. All members
  55  * are private.
  56  */
  57 struct DBusServerDebug
  58 {
  59   DBusServer base;  /**< Parent class members. */
  60
  61   char *name; /**< Server name. */
  62 };
  63
  64 /* Not thread safe, but OK since we don't use
  65  * threads in the bus
  66  */
  67 static DBusHashTable *server_hash;
  68
  69 static void
  70 debug_finalize (DBusServer *server)
  71 {
  72 }
  73
  74 static dbus_bool_t
  75 debug_handle_watch (DBusServer  *server,
  76                     DBusWatch   *watch,
  77                     unsigned int flags)
  78 {
  79   return TRUE;
  80 }
  81
  82 static void
  83 debug_disconnect (DBusServer *server)
  84 {
  85 }
  86
  87 static DBusServerVTable debug_vtable = {
  88   debug_finalize,
  89   debug_handle_watch,
  90   debug_disconnect
  91 };
  92
  93 /**
  94  * Looks up a server by its name.
  95  *
  96  * @param server_name the server name.
  97  * @returns the server, or #NULL if none exists.
  98  */
  99 DBusServer*
 100 _dbus_server_debug_lookup (const char *server_name)
 101 {
 102   if (!server_hash)
 103     return NULL;
 104
 105   return _dbus_hash_table_lookup_string (server_hash, server_name);
 106 }
 107
 108 /**
 109  * Creates a new debug server.
 110  *
 111  * @param server_name the name of the server.
 112  * @param error address where an error can be returned.
 113  * @returns a new server, or #NULL on failure.
 114  */
 115 DBusServer*
 116 _dbus_server_debug_new (const char     *server_name,
 117                         DBusError      *error)
 118 {
 119   DBusServerDebug *debug_server;
 120
 121   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 122
 123   if (!server_hash)
 124     {
 125       server_hash = _dbus_hash_table_new (DBUS_HASH_STRING, NULL, NULL);
 126
 127       if (!server_hash)
 128         {
 129           dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
 130           return NULL;
 131         }
 132     }
 133
 134   if (_dbus_hash_table_lookup_string (server_hash, server_name) != NULL)
 135     {
 136       dbus_set_error (error, DBUS_ERROR_ADDRESS_IN_USE,
 137                       NULL);
 138       return NULL;
 139     }
 140
 141   debug_server = dbus_new0 (DBusServerDebug, 1);
 142
 143   if (debug_server == NULL)
 144     return NULL;
 145
 146   debug_server->name = _dbus_strdup (server_name);
 147   if (debug_server->name == NULL)
 148     {
 149       dbus_free (debug_server->name);
 150       dbus_free (debug_server);
 151
 152       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
 153     }
 154
 155   if (!_dbus_server_init_base (&debug_server->base,
 156                                &debug_vtable))
 157     {
 158       dbus_free (debug_server->name);
 159       dbus_free (debug_server);
 160
 161       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
 162
 163       return NULL;
 164     }
 165
 166   if (!_dbus_hash_table_insert_string (server_hash,
 167                                        debug_server->name,
 168                                        debug_server))
 169     {
 170       _dbus_server_finalize_base (&debug_server->base);
 171       dbus_free (debug_server->name);
 172       dbus_free (debug_server);
 173
 174       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
 175
 176       return NULL;
 177     }
 178
 179   return (DBusServer *)debug_server;
 180 }
 181
 182 typedef struct
 183 {
 184   DBusServer *server;
 185   DBusTransport *transport;
 186   DBusTimeout *timeout;
 187 } ServerAndTransport;
 188
 189 static dbus_bool_t
 190 handle_new_client (void *data)
 191 {
 192   ServerAndTransport *st = data;
 193   DBusTransport *transport;
 194   DBusConnection *connection;
 195
 196   _dbus_verbose ("  new debug client transport %p connecting to server\n",
 197                  st->transport);
 198
 199   transport = _dbus_transport_debug_server_new (st->transport);
 200   if (transport == NULL)
 201     return FALSE;
 202
 203   connection = _dbus_connection_new_for_transport (transport);
 204   _dbus_transport_unref (transport);
 205
 206   if (connection == NULL)
 207     return FALSE;
 208
 209   /* See if someone wants to handle this new connection,
 210    * self-referencing for paranoia
 211    */
 212   if (st->server->new_connection_function)
 213     {
 214       dbus_server_ref (st->server);
 215
 216       (* st->server->new_connection_function) (st->server, connection,
 217                                                st->server->new_connection_data);
 218       dbus_server_unref (st->server);
 219     }
 220
 221   _dbus_server_remove_timeout (st->server, st->timeout);
 222
 223   /* If no one grabbed a reference, the connection will die. */
 224   dbus_connection_unref (connection);
 225
 226   /* killing timeout frees both "st" and "timeout" */
 227   _dbus_timeout_unref (st->timeout);
 228
 229   return TRUE;
 230 }
 231
 232 /**
 233  * Tells the server to accept a transport so the transport
 234  * can send messages to it.
 235  *
 236  * @param server the server
 237  * @param transport the transport
 238  * @returns #TRUE on success.
 239  */
 240 dbus_bool_t
 241 _dbus_server_debug_accept_transport (DBusServer     *server,
 242                                      DBusTransport  *transport)
 243 {
 244   ServerAndTransport *st = NULL;
 245
 246   st = dbus_new (ServerAndTransport, 1);
 247   if (st == NULL)
 248     return FALSE;
 249
 250   st->transport = transport;
 251   st->server = server;
 252
 253   st->timeout = _dbus_timeout_new (DEFAULT_INTERVAL, handle_new_client, st,
 254                                    dbus_free);
 255
 256   if (st->timeout == NULL)
 257     goto failed;
 258
 259   if (!_dbus_server_add_timeout (server, st->timeout))
 260     goto failed;
 261
 262   return TRUE;
 263
 264  failed:
 265   if (st->timeout)
 266     _dbus_timeout_unref (st->timeout);
 267   dbus_free (st);
 268   return FALSE;
 269 }
 270
 271 /** @} */
 272
 273 #endif /* DBUS_BUILD_TESTS */
 274