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