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   DBusString address;
 121
 122   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 123
 124   if (!server_hash)
 125     {
 126       server_hash = _dbus_hash_table_new (DBUS_HASH_STRING, NULL, NULL);
 127
 128       if (!server_hash)
 129         {
 130           dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
 131           return NULL;
 132         }
 133     }
 134
 135   if (_dbus_hash_table_lookup_string (server_hash, server_name) != NULL)
 136     {
 137       dbus_set_error (error, DBUS_ERROR_ADDRESS_IN_USE,
 138                       NULL);
 139       return NULL;
 140     }
 141
 142   debug_server = dbus_new0 (DBusServerDebug, 1);
 143
 144   if (debug_server == NULL)
 145     return NULL;
 146
 147   if (!_dbus_string_init (&address))
 148     goto nomem_0;
 149
 150   if (!_dbus_string_append (&address, "debug:name=") ||
 151       !_dbus_string_append (&address, server_name))
 152     goto nomem_1;
 153
 154   debug_server->name = _dbus_strdup (server_name);
 155   if (debug_server->name == NULL)
 156     goto nomem_1;
 157
 158   if (!_dbus_server_init_base (&debug_server->base,
 159                                &debug_vtable,
 160                                &address))
 161     goto nomem_2;
 162
 163   if (!_dbus_hash_table_insert_string (server_hash,
 164                                        debug_server->name,
 165                                        debug_server))
 166     goto nomem_3;
 167
 168   _dbus_string_free (&address);
 169
 170   return (DBusServer *)debug_server;
 171
 172  nomem_3:
 173   _dbus_server_finalize_base (&debug_server->base);
 174  nomem_2:
 175   dbus_free (debug_server->name);
 176  nomem_1:
 177   _dbus_string_free (&address);
 178  nomem_0:
 179   dbus_free (debug_server);
 180
 181   dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
 182
 183   return NULL;
 184 }
 185
 186 typedef struct
 187 {
 188   DBusServer *server;
 189   DBusTransport *transport;
 190   DBusTimeout *timeout;
 191 } ServerAndTransport;
 192
 193 static dbus_bool_t
 194 handle_new_client (void *data)
 195 {
 196   ServerAndTransport *st = data;
 197   DBusTransport *transport;
 198   DBusConnection *connection;
 199
 200   _dbus_verbose ("  new debug client transport %p connecting to server\n",
 201                  st->transport);
 202
 203   transport = _dbus_transport_debug_server_new (st->transport);
 204   if (transport == NULL)
 205     return FALSE;
 206
 207   connection = _dbus_connection_new_for_transport (transport);
 208   _dbus_transport_unref (transport);
 209
 210   if (connection == NULL)
 211     return FALSE;
 212
 213   /* See if someone wants to handle this new connection,
 214    * self-referencing for paranoia
 215    */
 216   if (st->server->new_connection_function)
 217     {
 218       dbus_server_ref (st->server);
 219
 220       (* st->server->new_connection_function) (st->server, connection,
 221                                                st->server->new_connection_data);
 222       dbus_server_unref (st->server);
 223     }
 224
 225   _dbus_server_remove_timeout (st->server, st->timeout);
 226
 227   /* If no one grabbed a reference, the connection will die. */
 228   dbus_connection_unref (connection);
 229
 230   /* killing timeout frees both "st" and "timeout" */
 231   _dbus_timeout_unref (st->timeout);
 232
 233   return TRUE;
 234 }
 235
 236 /**
 237  * Tells the server to accept a transport so the transport
 238  * can send messages to it.
 239  *
 240  * @param server the server
 241  * @param transport the transport
 242  * @returns #TRUE on success.
 243  */
 244 dbus_bool_t
 245 _dbus_server_debug_accept_transport (DBusServer     *server,
 246                                      DBusTransport  *transport)
 247 {
 248   ServerAndTransport *st = NULL;
 249
 250   st = dbus_new (ServerAndTransport, 1);
 251   if (st == NULL)
 252     return FALSE;
 253
 254   st->transport = transport;
 255   st->server = server;
 256
 257   st->timeout = _dbus_timeout_new (DEFAULT_INTERVAL, handle_new_client, st,
 258                                    dbus_free);
 259
 260   if (st->timeout == NULL)
 261     goto failed;
 262
 263   if (!_dbus_server_add_timeout (server, st->timeout))
 264     goto failed;
 265
 266   return TRUE;
 267
 268  failed:
 269   if (st->timeout)
 270     _dbus_timeout_unref (st->timeout);
 271   dbus_free (st);
 272   return FALSE;
 273 }
 274
 275 /** @} */
 276
 277 #endif /* DBUS_BUILD_TESTS */
 278