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 dbus_bool_t
  77 debug_handle_watch (DBusServer  *server,
  78                     DBusWatch   *watch,
  79                     unsigned int flags)
  80 {
  81
  82   return TRUE;
  83 }
  84
  85 static void
  86 debug_disconnect (DBusServer *server)
  87 {
  88   ((DBusServerDebugPipe*)server)->disconnected = TRUE;
  89 }
  90
  91 static DBusServerVTable debug_vtable = {
  92   debug_finalize,
  93   debug_handle_watch,
  94   debug_disconnect
  95 };
  96
  97 /**
  98  * Creates a new debug server using an in-process pipe
  99  *
 100  * @param server_name the name of the server.
 101  * @param result address where a result code can be returned.
 102  * @returns a new server, or #NULL on failure.
 103  */
 104 DBusServer*
 105 _dbus_server_debug_pipe_new (const char     *server_name,
 106                              DBusResultCode *result)
 107 {
 108   DBusServerDebugPipe *debug_server;
 109
 110   if (!server_pipe_hash)
 111     {
 112       server_pipe_hash = _dbus_hash_table_new (DBUS_HASH_STRING, NULL, NULL);
 113
 114       if (!server_pipe_hash)
 115         {
 116           dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
 117           return NULL;
 118         }
 119     }
 120
 121   if (_dbus_hash_table_lookup_string (server_pipe_hash, server_name) != NULL)
 122     {
 123       dbus_set_result (result, DBUS_RESULT_ADDRESS_IN_USE);
 124       return NULL;
 125     }
 126
 127   debug_server = dbus_new0 (DBusServerDebugPipe, 1);
 128
 129   if (debug_server == NULL)
 130     return NULL;
 131
 132   debug_server->name = _dbus_strdup (server_name);
 133   if (debug_server->name == NULL)
 134     {
 135       dbus_free (debug_server->name);
 136       dbus_free (debug_server);
 137
 138       dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
 139     }
 140
 141   if (!_dbus_server_init_base (&debug_server->base,
 142                                &debug_vtable))
 143     {
 144       dbus_free (debug_server->name);
 145       dbus_free (debug_server);
 146
 147       dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
 148
 149       return NULL;
 150     }
 151
 152   if (!_dbus_hash_table_insert_string (server_pipe_hash,
 153                                        debug_server->name,
 154                                        debug_server))
 155     {
 156       _dbus_server_finalize_base (&debug_server->base);
 157       dbus_free (debug_server->name);
 158       dbus_free (debug_server);
 159
 160       dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
 161
 162       return NULL;
 163     }
 164
 165   dbus_set_result (result, DBUS_RESULT_SUCCESS);
 166
 167   return (DBusServer *)debug_server;
 168 }
 169
 170 /**
 171  * Creates the client-side transport for
 172  * a debug-pipe connection connected to the
 173  * given debug-pipe server name.
 174  *
 175  * @param server_name name of server to connect to
 176  * @param result return location for result
 177  * @returns #NULL on no memory or transport
 178  */
 179 DBusTransport*
 180 _dbus_transport_debug_pipe_new (const char     *server_name,
 181                                 DBusResultCode *result)
 182 {
 183   DBusTransport *client_transport;
 184   DBusTransport *server_transport;
 185   DBusConnection *connection;
 186   int client_fd, server_fd;
 187   DBusServer *server;
 188
 189   server = _dbus_hash_table_lookup_string (server_pipe_hash,
 190                                            server_name);
 191   if (server == NULL ||
 192       ((DBusServerDebugPipe*)server)->disconnected)
 193     {
 194       dbus_set_result (result, DBUS_RESULT_BAD_ADDRESS);
 195       return NULL;
 196     }
 197
 198   if (!_dbus_full_duplex_pipe (&client_fd, &server_fd,
 199                                NULL))
 200     {
 201       _dbus_verbose ("failed to create full duplex pipe\n");
 202       dbus_set_result (result, DBUS_RESULT_FAILED);
 203       return NULL;
 204     }
 205
 206   _dbus_fd_set_close_on_exec (client_fd);
 207   _dbus_fd_set_close_on_exec (server_fd);
 208
 209   client_transport = _dbus_transport_new_for_fd (client_fd,
 210                                                  FALSE);
 211   if (client_transport == NULL)
 212     {
 213       _dbus_close (client_fd, NULL);
 214       _dbus_close (server_fd, NULL);
 215       dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
 216       return NULL;
 217     }
 218
 219   client_fd = -1;
 220
 221   server_transport = _dbus_transport_new_for_fd (server_fd,
 222                                                  TRUE);
 223   if (server_transport == NULL)
 224     {
 225       _dbus_transport_unref (client_transport);
 226       _dbus_close (server_fd, NULL);
 227       dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
 228       return NULL;
 229     }
 230
 231   server_fd = -1;
 232
 233   connection = _dbus_connection_new_for_transport (server_transport);
 234   _dbus_transport_unref (server_transport);
 235   server_transport = NULL;
 236
 237   if (connection == NULL)
 238     {
 239       _dbus_transport_unref (client_transport);
 240       dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
 241       return NULL;
 242     }
 243
 244   /* See if someone wants to handle this new connection,
 245    * self-referencing for paranoia
 246    */
 247   if (server->new_connection_function)
 248     {
 249       dbus_server_ref (server);
 250       (* server->new_connection_function) (server, connection,
 251                                            server->new_connection_data);
 252       dbus_server_unref (server);
 253     }
 254
 255   /* If no one grabbed a reference, the connection will die,
 256    * and the client transport will get an immediate disconnect
 257    */
 258   dbus_connection_unref (connection);
 259
 260   return client_transport;
 261 }
 262
 263
 264 /** @} */
 265
 266 #endif /* DBUS_BUILD_TESTS */
 267