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 */
50 typedef struct DBusServerDebugPipe DBusServerDebugPipe;
51
52 /**
53 * Implementation details of DBusServerDebugPipe. All members
54 * are private.
55 */
56 struct 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 ) */
66 static DBusHashTable *server_pipe_hash;
67 static int server_pipe_hash_refcount = 0;
68
69 static dbus_bool_t
pipe_hash_ref(void)70 pipe_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
87 static void
pipe_hash_unref(void)88 pipe_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
101 static void
debug_finalize(DBusServer * server)102 debug_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
114 static void
debug_disconnect(DBusServer * server)115 debug_disconnect (DBusServer *server)
116 {
117 ((DBusServerDebugPipe*)server)->disconnected = TRUE;
118 }
119
120 static 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 */
132 DBusServer*
_dbus_server_debug_pipe_new(const char * server_name,DBusError * error)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 */
207 DBusTransport*
_dbus_transport_debug_pipe_new(const char * server_name,DBusError * error)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 */
336 DBusServerListenResult
_dbus_server_listen_debug_pipe(DBusAddressEntry * entry,DBusServer ** server_p,DBusError * error)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 */
386 DBusTransportOpenResult
_dbus_transport_open_debug_pipe(DBusAddressEntry * entry,DBusTransport ** transport_p,DBusError * error)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