Add IgnoreOnIsolate=yes to dbus.service
[platform/upstream/dbus.git] / tools / dbus-send.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-send.c  Utility program to send messages from the command line
3  *
4  * Copyright (C) 2003 Philip Blundell <philb@gnu.org>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include <dbus/dbus.h>
28 #include "dbus/dbus-internals.h"
29
30 #ifndef HAVE_STRTOLL
31 #undef strtoll
32 #define strtoll mystrtoll
33 #include "strtoll.c"
34 #endif
35
36 #ifndef HAVE_STRTOULL
37 #undef strtoull
38 #define strtoull mystrtoull
39 #include "strtoull.c"
40 #endif
41
42 #ifdef DBUS_WINCE
43 #ifndef strdup
44 #define strdup _strdup
45 #endif
46 #endif
47
48 #include "dbus-print-message.h"
49
50 static const char *appname;
51
52 static void usage (int ecode) _DBUS_GNUC_NORETURN;
53
54 static void
55 usage (int ecode)
56 {
57   fprintf (stderr, "Usage: %s [--help] [--system | --session | --bus=ADDRESS | --peer=ADDRESS] [--dest=NAME] [--type=TYPE] [--print-reply[=literal]] [--reply-timeout=MSEC] <destination object path> <message name> [contents ...]\n", appname);
58   exit (ecode);
59 }
60
61 /* Abort on any allocation failure; there is nothing else we can do. */
62 static void
63 handle_oom (dbus_bool_t success)
64 {
65   if (!success)
66     {
67       fprintf (stderr, "%s: Ran out of memory\n", appname);
68       exit (1);
69     }
70 }
71
72 static void
73 append_arg (DBusMessageIter *iter, int type, const char *value)
74 {
75   dbus_uint16_t uint16;
76   dbus_int16_t int16;
77   dbus_uint32_t uint32;
78   dbus_int32_t int32;
79   dbus_uint64_t uint64;
80   dbus_int64_t int64;
81   double d;
82   unsigned char byte;
83   dbus_bool_t v_BOOLEAN;
84   dbus_bool_t ret;
85
86   switch (type)
87     {
88     case DBUS_TYPE_BYTE:
89       byte = strtoul (value, NULL, 0);
90       ret = dbus_message_iter_append_basic (iter, DBUS_TYPE_BYTE, &byte);
91       break;
92
93     case DBUS_TYPE_DOUBLE:
94       d = strtod (value, NULL);
95       ret = dbus_message_iter_append_basic (iter, DBUS_TYPE_DOUBLE, &d);
96       break;
97
98     case DBUS_TYPE_INT16:
99       int16 = strtol (value, NULL, 0);
100       ret = dbus_message_iter_append_basic (iter, DBUS_TYPE_INT16, &int16);
101       break;
102
103     case DBUS_TYPE_UINT16:
104       uint16 = strtoul (value, NULL, 0);
105       ret = dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT16, &uint16);
106       break;
107
108     case DBUS_TYPE_INT32:
109       int32 = strtol (value, NULL, 0);
110       ret = dbus_message_iter_append_basic (iter, DBUS_TYPE_INT32, &int32);
111       break;
112
113     case DBUS_TYPE_UINT32:
114       uint32 = strtoul (value, NULL, 0);
115       ret = dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT32, &uint32);
116       break;
117
118     case DBUS_TYPE_INT64:
119       int64 = strtoll (value, NULL, 0);
120       ret = dbus_message_iter_append_basic (iter, DBUS_TYPE_INT64, &int64);
121       break;
122
123     case DBUS_TYPE_UINT64:
124       uint64 = strtoull (value, NULL, 0);
125       ret = dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT64, &uint64);
126       break;
127
128     case DBUS_TYPE_STRING:
129       ret = dbus_message_iter_append_basic (iter, DBUS_TYPE_STRING, &value);
130       break;
131
132     case DBUS_TYPE_OBJECT_PATH:
133       ret = dbus_message_iter_append_basic (iter, DBUS_TYPE_OBJECT_PATH, &value);
134       break;
135
136     case DBUS_TYPE_BOOLEAN:
137       if (strcmp (value, "true") == 0)
138         {
139           v_BOOLEAN = TRUE;
140           ret = dbus_message_iter_append_basic (iter, DBUS_TYPE_BOOLEAN, &v_BOOLEAN);
141         }
142       else if (strcmp (value, "false") == 0)
143         {
144           v_BOOLEAN = FALSE;
145           ret = dbus_message_iter_append_basic (iter, DBUS_TYPE_BOOLEAN, &v_BOOLEAN);
146         }
147       else
148         {
149           fprintf (stderr, "%s: Expected \"true\" or \"false\" instead of \"%s\"\n", appname, value);
150           exit (1);
151         }
152       break;
153
154     default:
155       fprintf (stderr, "%s: Unsupported data type %c\n", appname, (char) type);
156       exit (1);
157     }
158
159   handle_oom (ret);
160 }
161
162 static void
163 append_array (DBusMessageIter *iter, int type, const char *value)
164 {
165   const char *val;
166   char *dupval = strdup (value);
167
168   handle_oom (dupval != NULL);
169
170   val = strtok (dupval, ",");
171   while (val != NULL)
172     {
173       append_arg (iter, type, val);
174       val = strtok (NULL, ",");
175     }
176   free (dupval);
177 }
178
179 static void
180 append_dict (DBusMessageIter *iter, int keytype, int valtype, const char *value)
181 {
182   const char *val;
183   char *dupval = strdup (value);
184
185   handle_oom (dupval != NULL);
186
187   val = strtok (dupval, ",");
188   while (val != NULL)
189     {
190       DBusMessageIter subiter;
191       
192       handle_oom (dbus_message_iter_open_container (iter,
193                                                     DBUS_TYPE_DICT_ENTRY,
194                                                     NULL,
195                                                     &subiter));
196
197       append_arg (&subiter, keytype, val);
198       val = strtok (NULL, ",");
199       if (val == NULL)
200         {
201           fprintf (stderr, "%s: Malformed dictionary\n", appname);
202           exit (1);
203         }
204       append_arg (&subiter, valtype, val);
205
206       handle_oom (dbus_message_iter_close_container (iter, &subiter));
207       val = strtok (NULL, ",");
208     } 
209   free (dupval);
210 }
211
212 static int
213 type_from_name (const char *arg)
214 {
215   int type;
216   if (!strcmp (arg, "string"))
217     type = DBUS_TYPE_STRING;
218   else if (!strcmp (arg, "int16"))
219     type = DBUS_TYPE_INT16;
220   else if (!strcmp (arg, "uint16"))
221     type = DBUS_TYPE_UINT16;
222   else if (!strcmp (arg, "int32"))
223     type = DBUS_TYPE_INT32;
224   else if (!strcmp (arg, "uint32"))
225     type = DBUS_TYPE_UINT32;
226   else if (!strcmp (arg, "int64"))
227     type = DBUS_TYPE_INT64;
228   else if (!strcmp (arg, "uint64"))
229     type = DBUS_TYPE_UINT64;
230   else if (!strcmp (arg, "double"))
231     type = DBUS_TYPE_DOUBLE;
232   else if (!strcmp (arg, "byte"))
233     type = DBUS_TYPE_BYTE;
234   else if (!strcmp (arg, "boolean"))
235     type = DBUS_TYPE_BOOLEAN;
236   else if (!strcmp (arg, "objpath"))
237     type = DBUS_TYPE_OBJECT_PATH;
238   else
239     {
240       fprintf (stderr, "%s: Unknown type \"%s\"\n", appname, arg);
241       exit (1);
242     }
243   return type;
244 }
245
246 int
247 main (int argc, char *argv[])
248 {
249   DBusConnection *connection;
250   DBusError error;
251   DBusMessage *message;
252   dbus_bool_t print_reply;
253   dbus_bool_t print_reply_literal;
254   int reply_timeout;
255   DBusMessageIter iter;
256   int i;
257   DBusBusType type = DBUS_BUS_SESSION;
258   const char *dest = NULL;
259   const char *name = NULL;
260   const char *path = NULL;
261   int message_type = DBUS_MESSAGE_TYPE_SIGNAL;
262   const char *type_str = NULL;
263   const char *address = NULL;
264   int is_bus = FALSE;
265   int session_or_system = FALSE;
266
267   appname = argv[0];
268   
269   if (argc < 3)
270     usage (1);
271
272   print_reply = FALSE;
273   print_reply_literal = FALSE;
274   reply_timeout = -1;
275   
276   for (i = 1; i < argc && name == NULL; i++)
277     {
278       char *arg = argv[i];
279
280       if (strcmp (arg, "--system") == 0)
281         {
282           type = DBUS_BUS_SYSTEM;
283           session_or_system = TRUE;
284         }
285       else if (strcmp (arg, "--session") == 0)
286         {
287           type = DBUS_BUS_SESSION;
288           session_or_system = TRUE;
289         }
290       else if ((strstr (arg, "--bus=") == arg) || (strstr (arg, "--peer=") == arg) || (strstr (arg, "--address=") == arg))
291         {
292           /* Check for peer first, to avoid the GCC -Wduplicated-branches
293            * warning.
294            */
295           if (arg[2] == 'p') /* peer */
296             {
297               is_bus = FALSE;
298             }
299           else if (arg[2] == 'b') /* bus */
300             {
301               is_bus = TRUE;
302             }
303           else /* address; keeping backwards compatibility */
304             {
305               is_bus = FALSE;
306             }
307
308           address = strchr (arg, '=') + 1;
309
310           if (address[0] == '\0')
311             {
312               fprintf (stderr, "\"--peer=\" and \"--bus=\" require an ADDRESS\n");
313               usage (1);
314             }
315         }
316       else if (strncmp (arg, "--print-reply", 13) == 0)
317         {
318           print_reply = TRUE;
319           message_type = DBUS_MESSAGE_TYPE_METHOD_CALL;
320           if (strcmp (arg + 13, "=literal") == 0)
321             print_reply_literal = TRUE;
322           else if (*(arg + 13) != '\0')
323             {
324               fprintf (stderr, "invalid value (%s) of \"--print-reply\"\n", arg + 13);
325               usage (1);
326             }
327         }
328       else if (strstr (arg, "--reply-timeout=") == arg)
329         {
330           if (*(strchr (arg, '=') + 1) == '\0')
331             {
332               fprintf (stderr, "\"--reply-timeout=\" requires an MSEC\n");
333               usage (1);
334             }
335           reply_timeout = strtol (strchr (arg, '=') + 1,
336                                   NULL, 10);
337           if (reply_timeout <= 0)
338             {
339               fprintf (stderr, "invalid value (%s) of \"--reply-timeout\"\n",
340                        strchr (arg, '=') + 1);
341               usage (1);
342             }
343         }
344       else if (strstr (arg, "--dest=") == arg)
345         {
346           if (*(strchr (arg, '=') + 1) == '\0')
347             {
348               fprintf (stderr, "\"--dest=\" requires an NAME\n");
349               usage (1);
350             }
351           dest = strchr (arg, '=') + 1;
352         }
353       else if (strstr (arg, "--type=") == arg)
354         type_str = strchr (arg, '=') + 1;
355       else if (!strcmp(arg, "--help"))
356         usage (0);
357       else if (arg[0] == '-')
358         usage (1);
359       else if (path == NULL)
360         path = arg;
361       else /* name == NULL guaranteed by the 'while' loop */
362         name = arg;
363     }
364
365   if (name == NULL)
366     usage (1);
367
368   if (session_or_system &&
369       (address != NULL))
370     {
371       fprintf (stderr, "\"--peer\" and \"--bus\" may not be used with \"--system\" or \"--session\"\n");
372       usage (1);
373     }
374
375   if (type_str != NULL)
376     {
377       message_type = dbus_message_type_from_string (type_str);
378       if (!(message_type == DBUS_MESSAGE_TYPE_METHOD_CALL ||
379             message_type == DBUS_MESSAGE_TYPE_SIGNAL))
380         {
381           fprintf (stderr, "Message type \"%s\" is not supported\n",
382                    type_str);
383           exit (1);
384         }
385     }
386   
387   dbus_error_init (&error);
388
389   if (dest && !dbus_validate_bus_name (dest, &error))
390     {
391       fprintf (stderr, "invalid value (%s) of \"--dest\"\n", dest);
392       usage (1);
393     }
394
395   if (address != NULL)
396     {
397       connection = dbus_connection_open (address, &error);
398     }
399   else
400     {
401       connection = dbus_bus_get (type, &error);
402     }
403
404   if (connection == NULL)
405     {
406       fprintf (stderr, "Failed to open connection to \"%s\" message bus: %s\n",
407                (address != NULL) ? address :
408                  ((type == DBUS_BUS_SYSTEM) ? "system" : "session"),
409                error.message);
410       dbus_error_free (&error);
411       exit (1);
412     }
413   else if ((address != NULL) && is_bus)
414     {
415       if (!dbus_bus_register (connection, &error))
416         {
417           fprintf (stderr, "Failed to register on connection to \"%s\" message bus: %s\n",
418                    address, error.message);
419           dbus_error_free (&error);
420           exit (1);
421         }
422     }
423
424   if (message_type == DBUS_MESSAGE_TYPE_METHOD_CALL)
425     {
426       char *last_dot;
427
428       last_dot = strrchr (name, '.');
429       if (last_dot == NULL)
430         {
431           fprintf (stderr, "Must use org.mydomain.Interface.Method notation, no dot in \"%s\"\n",
432                    name);
433           exit (1);
434         }
435       *last_dot = '\0';
436       
437       message = dbus_message_new_method_call (NULL,
438                                               path,
439                                               name,
440                                               last_dot + 1);
441       handle_oom (message != NULL);
442       dbus_message_set_auto_start (message, TRUE);
443     }
444   else if (message_type == DBUS_MESSAGE_TYPE_SIGNAL)
445     {
446       char *last_dot;
447
448       last_dot = strrchr (name, '.');
449       if (last_dot == NULL)
450         {
451           fprintf (stderr, "Must use org.mydomain.Interface.Signal notation, no dot in \"%s\"\n",
452                    name);
453           exit (1);
454         }
455       *last_dot = '\0';
456       
457       message = dbus_message_new_signal (path, name, last_dot + 1);
458       handle_oom (message != NULL);
459     }
460   else
461     {
462       fprintf (stderr, "Internal error, unknown message type\n");
463       exit (1);
464     }
465
466   if (message == NULL)
467     {
468       fprintf (stderr, "Couldn't allocate D-Bus message\n");
469       exit (1);
470     }
471
472   if (dest && !dbus_message_set_destination (message, dest))
473     {
474       fprintf (stderr, "Not enough memory\n");
475       exit (1);
476     }
477   
478   dbus_message_iter_init_append (message, &iter);
479
480   while (i < argc)
481     {
482       char *arg;
483       char *c;
484       int type2;
485       int secondary_type;
486       int container_type;
487       DBusMessageIter *target_iter;
488       DBusMessageIter container_iter;
489
490       type2 = DBUS_TYPE_INVALID;
491       secondary_type = DBUS_TYPE_INVALID;
492       arg = argv[i++];
493       c = strchr (arg, ':');
494
495       if (c == NULL)
496         {
497           fprintf (stderr, "%s: Data item \"%s\" is badly formed\n", argv[0], arg);
498           exit (1);
499         }
500
501       *(c++) = 0;
502
503       container_type = DBUS_TYPE_INVALID;
504
505       if (strcmp (arg, "variant") == 0)
506         container_type = DBUS_TYPE_VARIANT;
507       else if (strcmp (arg, "array") == 0)
508         container_type = DBUS_TYPE_ARRAY;
509       else if (strcmp (arg, "dict") == 0)
510         container_type = DBUS_TYPE_DICT_ENTRY;
511
512       if (container_type != DBUS_TYPE_INVALID)
513         {
514           arg = c;
515           c = strchr (arg, ':');
516           if (c == NULL)
517             {
518               fprintf (stderr, "%s: Data item \"%s\" is badly formed\n", argv[0], arg);
519               exit (1);
520             }
521           *(c++) = 0;
522         }
523
524       if (arg[0] == 0)
525         type2 = DBUS_TYPE_STRING;
526       else
527         type2 = type_from_name (arg);
528
529       if (container_type == DBUS_TYPE_DICT_ENTRY)
530         {
531           char sig[5];
532           arg = c;
533           c = strchr (c, ':');
534           if (c == NULL)
535             {
536               fprintf (stderr, "%s: Data item \"%s\" is badly formed\n", argv[0], arg);
537               exit (1);
538             }
539           *(c++) = 0;
540           secondary_type = type_from_name (arg);
541           sig[0] = DBUS_DICT_ENTRY_BEGIN_CHAR;
542           sig[1] = type2;
543           sig[2] = secondary_type;
544           sig[3] = DBUS_DICT_ENTRY_END_CHAR;
545           sig[4] = '\0';
546           handle_oom (dbus_message_iter_open_container (&iter,
547                                                         DBUS_TYPE_ARRAY,
548                                                         sig,
549                                                         &container_iter));
550           target_iter = &container_iter;
551         }
552       else if (container_type != DBUS_TYPE_INVALID)
553         {
554           char sig[2];
555           sig[0] = type2;
556           sig[1] = '\0';
557           handle_oom (dbus_message_iter_open_container (&iter,
558                                                         container_type,
559                                                         sig,
560                                                         &container_iter));
561           target_iter = &container_iter;
562         }
563       else
564         target_iter = &iter;
565
566       if (container_type == DBUS_TYPE_ARRAY)
567         {
568           append_array (target_iter, type2, c);
569         }
570       else if (container_type == DBUS_TYPE_DICT_ENTRY)
571         {
572           _dbus_assert (secondary_type != DBUS_TYPE_INVALID);
573           append_dict (target_iter, type2, secondary_type, c);
574         }
575       else
576         append_arg (target_iter, type2, c);
577
578       if (container_type != DBUS_TYPE_INVALID)
579         {
580           handle_oom (dbus_message_iter_close_container (&iter,
581                                                          &container_iter));
582         }
583     }
584
585   if (print_reply)
586     {
587       DBusMessage *reply;
588
589       dbus_error_init (&error);
590       reply = dbus_connection_send_with_reply_and_block (connection,
591                                                          message, reply_timeout,
592                                                          &error);
593       if (dbus_error_is_set (&error))
594         {
595           fprintf (stderr, "Error %s: %s\n",
596                    error.name,
597                    error.message);
598           exit (1);
599         }
600
601       if (reply)
602         {
603           long sec, usec;
604
605           _dbus_get_real_time (&sec, &usec);
606           print_message (reply, print_reply_literal, sec, usec);
607           dbus_message_unref (reply);
608         }
609     }
610   else
611     {
612       dbus_connection_send (connection, message, NULL);
613       dbus_connection_flush (connection);
614     }
615
616   dbus_message_unref (message);
617
618   dbus_connection_unref (connection);
619
620   exit (0);
621 }