dbus/dbus-server-debug-pipe.c

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