1/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2/* dbus-server-debug-pipe.c In-proc debug server implementation
3 *
4 * Copyright (C) 2003  CodeFactory AB
5 * Copyright (C) 2003, 2004  Red Hat, Inc.
6 *
7 * Licensed under the Academic Free License version 2.1
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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
22 *
23 */
24
25#include <config.h>
26#include "dbus-internals.h"
27#include "dbus-server-debug-pipe.h"
28#include "dbus-transport-socket.h"
29#include "dbus-connection-internal.h"
30#include "dbus-hash.h"
31#include "dbus-string.h"
32#include "dbus-protocol.h"
33
34#ifdef DBUS_BUILD_TESTS
35
36/**
37 * @defgroup DBusServerDebugPipe DBusServerDebugPipe
38 * @ingroup  DBusInternals
39 * @brief In-process pipe debug server used in unit tests.
40 *
41 * Types and functions related to DBusServerDebugPipe.
42 * This is used for unit testing.
43 *
44 * @{
45 */
46
47/**
48 * Opaque object representing a debug server implementation.
49 */
50typedef struct DBusServerDebugPipe DBusServerDebugPipe;
51
52/**
53 * Implementation details of DBusServerDebugPipe. All members
54 * are private.
55 */
56struct DBusServerDebugPipe
57{
58  DBusServer base;  /**< Parent class members. */
59
60  char *name; /**< Server name. */
61
62  dbus_bool_t disconnected; /**< TRUE if disconnect has been called */
63};
64
65/* FIXME not threadsafe (right now the test suite doesn't use threads anyhow ) */
66static DBusHashTable *server_pipe_hash;
67static int server_pipe_hash_refcount = 0;
68
69static dbus_bool_t
70pipe_hash_ref (void)
71{
72  if (!server_pipe_hash)
73    {
74      _dbus_assert (server_pipe_hash_refcount == 0);
75
76      server_pipe_hash = _dbus_hash_table_new (DBUS_HASH_STRING, NULL, NULL);
77
78      if (!server_pipe_hash)
79        return FALSE;
80    }
81
82  server_pipe_hash_refcount = 1;
83
84  return TRUE;
85}
86
87static void
88pipe_hash_unref (void)
89{
90  _dbus_assert (server_pipe_hash != NULL);
91  _dbus_assert (server_pipe_hash_refcount > 0);
92
93  server_pipe_hash_refcount -= 1;
94  if (server_pipe_hash_refcount == 0)
95    {
96      _dbus_hash_table_unref (server_pipe_hash);
97      server_pipe_hash = NULL;
98    }
99}
100
101static void
102debug_finalize (DBusServer *server)
103{
104  DBusServerDebugPipe *debug_server = (DBusServerDebugPipe*) server;
105
106  pipe_hash_unref ();
107
108  _dbus_server_finalize_base (server);
109
110  dbus_free (debug_server->name);
111  dbus_free (server);
112}
113
114static void
115debug_disconnect (DBusServer *server)
116{
117  ((DBusServerDebugPipe*)server)->disconnected = TRUE;
118}
119
120static DBusServerVTable debug_vtable = {
121  debug_finalize,
122  debug_disconnect
123};
124
125/**
126 * Creates a new debug server using an in-process pipe
127 *
128 * @param server_name the name of the server.
129 * @param error address where an error can be returned.
130 * @returns a new server, or #NULL on failure.
131 */
132DBusServer*
133_dbus_server_debug_pipe_new (const char     *server_name,
134                             DBusError      *error)
135{
136  DBusServerDebugPipe *debug_server;
137  DBusString address;
138  DBusString name_str;
139
140  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
141
142  if (!pipe_hash_ref ())
143    return NULL;
144
145  if (_dbus_hash_table_lookup_string (server_pipe_hash, server_name) != NULL)
146    {
147      dbus_set_error (error, DBUS_ERROR_ADDRESS_IN_USE, NULL);
148      pipe_hash_unref ();
149      return NULL;
150    }
151
152  debug_server = dbus_new0 (DBusServerDebugPipe, 1);
153  if (debug_server == NULL)
154    goto nomem_0;
155
156  if (!_dbus_string_init (&address))
157    goto nomem_1;
158
159  _dbus_string_init_const (&name_str, server_name);
160  if (!_dbus_string_append (&address, "debug-pipe:name=") ||
161      !_dbus_address_append_escaped (&address, &name_str))
162    goto nomem_2;
163
164  debug_server->name = _dbus_strdup (server_name);
165  if (debug_server->name == NULL)
166    goto nomem_2;
167
168  if (!_dbus_server_init_base (&debug_server->base,
169			       &debug_vtable, &address))
170    goto nomem_3;
171
172  if (!_dbus_hash_table_insert_string (server_pipe_hash,
173				       debug_server->name,
174				       debug_server))
175    goto nomem_4;
176
177  _dbus_string_free (&address);
178
179  /* server keeps the pipe hash ref */
180
181  _dbus_server_trace_ref (&debug_server->base, 0, 1, "debug_pipe_new");
182  return (DBusServer *)debug_server;
183
184 nomem_4:
185  _dbus_server_finalize_base (&debug_server->base);
186 nomem_3:
187  dbus_free (debug_server->name);
188 nomem_2:
189  _dbus_string_free (&address);
190 nomem_1:
191  dbus_free (debug_server);
192 nomem_0:
193  pipe_hash_unref ();
194  dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
195  return NULL;
196}
197
198/**
199 * Creates the client-side transport for
200 * a debug-pipe connection connected to the
201 * given debug-pipe server name.
202 *
203 * @param server_name name of server to connect to
204 * @param error address where an error can be returned.
205 * @returns #NULL on no memory or transport
206 */
207DBusTransport*
208_dbus_transport_debug_pipe_new (const char     *server_name,
209                                DBusError      *error)
210{
211  DBusTransport *client_transport;
212  DBusTransport *server_transport;
213  DBusConnection *connection;
214  int client_fd, server_fd;
215  DBusServer *server;
216  DBusString address;
217
218  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
219
220  if (server_pipe_hash == NULL)
221    {
222      dbus_set_error (error, DBUS_ERROR_NO_SERVER, NULL);
223      return NULL;
224    }
225
226  server = _dbus_hash_table_lookup_string (server_pipe_hash,
227                                           server_name);
228  if (server == NULL ||
229      ((DBusServerDebugPipe*)server)->disconnected)
230    {
231      dbus_set_error (error, DBUS_ERROR_NO_SERVER, NULL);
232      return NULL;
233    }
234
235  if (!_dbus_string_init (&address))
236    {
237      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
238      return NULL;
239    }
240
241  if (!_dbus_string_append (&address, "debug-pipe:name=") ||
242      !_dbus_string_append (&address, server_name))
243    {
244      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
245      _dbus_string_free (&address);
246      return NULL;
247    }
248
249  if (!_dbus_full_duplex_pipe (&client_fd, &server_fd, FALSE,
250                               NULL))
251    {
252      _dbus_verbose ("failed to create full duplex pipe\n");
253      dbus_set_error (error, DBUS_ERROR_FAILED, "Could not create full-duplex pipe");
254      _dbus_string_free (&address);
255      return NULL;
256    }
257
258  client_transport = _dbus_transport_new_for_socket (client_fd,
259                                                     NULL, &address);
260  if (client_transport == NULL)
261    {
262      _dbus_close_socket (client_fd, NULL);
263      _dbus_close_socket (server_fd, NULL);
264      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
265      _dbus_string_free (&address);
266      return NULL;
267    }
268
269  _dbus_string_free (&address);
270
271  client_fd = -1;
272
273  server_transport = _dbus_transport_new_for_socket (server_fd,
274                                                     &server->guid_hex, NULL);
275  if (server_transport == NULL)
276    {
277      _dbus_transport_unref (client_transport);
278      _dbus_close_socket (server_fd, NULL);
279      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
280      return NULL;
281    }
282
283  server_fd = -1;
284
285  if (!_dbus_transport_set_auth_mechanisms (server_transport,
286                                            (const char**) server->auth_mechanisms))
287    {
288      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
289      _dbus_transport_unref (server_transport);
290      _dbus_transport_unref (client_transport);
291      return NULL;
292    }
293
294  connection = _dbus_connection_new_for_transport (server_transport);
295  _dbus_transport_unref (server_transport);
296  server_transport = NULL;
297
298  if (connection == NULL)
299    {
300      _dbus_transport_unref (client_transport);
301      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
302      return NULL;
303    }
304
305  /* See if someone wants to handle this new connection,
306   * self-referencing for paranoia
307   */
308  if (server->new_connection_function)
309    {
310      dbus_server_ref (server);
311      (* server->new_connection_function) (server, connection,
312                                           server->new_connection_data);
313      dbus_server_unref (server);
314    }
315
316  /* If no one grabbed a reference, the connection will die,
317   * and the client transport will get an immediate disconnect
318   */
319  _dbus_connection_close_if_only_one_ref (connection);
320  dbus_connection_unref (connection);
321
322  return client_transport;
323}
324
325/**
326 * Tries to interpret the address entry as a debug pipe entry.
327 *
328 * Sets error if the result is not OK.
329 *
330 * @param entry an address entry
331 * @param server_p location to store a new DBusServer, or #NULL on failure.
332 * @param error location to store rationale for failure on bad address
333 * @returns the outcome
334 *
335 */
336DBusServerListenResult
337_dbus_server_listen_debug_pipe (DBusAddressEntry *entry,
338                                DBusServer      **server_p,
339                                DBusError        *error)
340{
341  const char *method;
342
343  *server_p = NULL;
344
345  method = dbus_address_entry_get_method (entry);
346
347  if (strcmp (method, "debug-pipe") == 0)
348    {
349      const char *name = dbus_address_entry_get_value (entry, "name");
350
351      if (name == NULL)
352        {
353          _dbus_set_bad_address(error, "debug-pipe", "name",
354                                NULL);
355          return DBUS_SERVER_LISTEN_BAD_ADDRESS;
356        }
357
358      *server_p = _dbus_server_debug_pipe_new (name, error);
359
360      if (*server_p)
361        {
362          _DBUS_ASSERT_ERROR_IS_CLEAR(error);
363          return DBUS_SERVER_LISTEN_OK;
364        }
365      else
366        {
367          _DBUS_ASSERT_ERROR_IS_SET(error);
368          return DBUS_SERVER_LISTEN_DID_NOT_CONNECT;
369        }
370    }
371  else
372    {
373      _DBUS_ASSERT_ERROR_IS_CLEAR(error);
374      return DBUS_SERVER_LISTEN_NOT_HANDLED;
375    }
376}
377
378/**
379 * Opens a debug pipe transport, used in the test suite.
380 *
381 * @param entry the address entry to try opening as debug-pipe
382 * @param transport_p return location for the opened transport
383 * @param error error to be set
384 * @returns result of the attempt
385 */
386DBusTransportOpenResult
387_dbus_transport_open_debug_pipe (DBusAddressEntry  *entry,
388                                 DBusTransport    **transport_p,
389                                 DBusError         *error)
390{
391  const char *method;
392
393  method = dbus_address_entry_get_method (entry);
394  _dbus_assert (method != NULL);
395
396  if (strcmp (method, "debug-pipe") == 0)
397    {
398      const char *name = dbus_address_entry_get_value (entry, "name");
399
400      if (name == NULL)
401        {
402          _dbus_set_bad_address (error, "debug-pipe", "name",
403                                 NULL);
404          return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
405        }
406
407      *transport_p = _dbus_transport_debug_pipe_new (name, error);
408
409      if (*transport_p == NULL)
410        {
411          _DBUS_ASSERT_ERROR_IS_SET (error);
412          return DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT;
413        }
414      else
415        {
416          _DBUS_ASSERT_ERROR_IS_CLEAR (error);
417          return DBUS_TRANSPORT_OPEN_OK;
418        }
419    }
420  else
421    {
422      _DBUS_ASSERT_ERROR_IS_CLEAR (error);
423      return DBUS_TRANSPORT_OPEN_NOT_HANDLED;
424    }
425}
426
427
428/** @} */
429
430#endif /* DBUS_BUILD_TESTS */
431
432