| /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ |
| /* dbus-spam.c - a plain libdbus message-sender, loosely based on dbus-send |
| * |
| * Copyright © 2003 Philip Blundell <philb@gnu.org> |
| * Copyright © 2011 Nokia Corporation |
| * Copyright © 2014 Collabora Ltd. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| * |
| */ |
| |
| #include <config.h> |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <time.h> |
| |
| #include <dbus/dbus.h> |
| |
| #include "test-tool.h" |
| #include "tool-common.h" |
| |
| static dbus_bool_t ignore_errors = FALSE; |
| |
| static void |
| usage (int ecode) |
| { |
| fprintf (stderr, |
| "Usage: dbus-test-tool spam [OPTIONS]\n" |
| "\n" |
| "Repeatedly call com.example.Spam() on the given D-Bus service.\n" |
| "\n" |
| "Options:\n" |
| "\n" |
| " --session use the session bus (default)\n" |
| " --system use the system bus\n" |
| "\n" |
| " --ignore-errors ignore errors\n" |
| " --dest=NAME call methods on NAME (default " DBUS_SERVICE_DBUS ")\n" |
| "\n" |
| " --count=N send N messages (default 1)\n" |
| " --queue=N queue up N messages at a time (default 1)\n" |
| " --flood send all messages immediately\n" |
| " --no-reply set the NO_REPLY flag (implies --flood)\n" |
| " --messages-per-conn=N after sending messages-per-conn, wait\n" |
| " for the pending replies if any, then reconnect\n" |
| " (default: don't reconnect)\n" |
| "\n" |
| " --string send payload as a string (default)\n" |
| " --bytes send payload as a byte-array\n" |
| " --empty send an empty payload\n" |
| "\n" |
| " --payload=S use S as payload (default \"hello, world!\")\n" |
| " --stdin read payload from stdin, until EOF\n" |
| " --message-stdin read a complete D-Bus message from stdin\n" |
| " --random-size read whitespace-separated ASCII decimal\n" |
| " payload sizes from stdin and pick one randomly\n" |
| " for each message\n" |
| "\n" |
| " --seed=SEED seed for srand (default is time())\n" |
| "\n" |
| ); |
| exit (ecode); |
| } |
| |
| static void |
| pc_notify (DBusPendingCall *pc, |
| void *data) |
| { |
| DBusMessage *message; |
| int *received_p = data; |
| DBusError error; |
| |
| dbus_error_init (&error); |
| |
| message = dbus_pending_call_steal_reply (pc); |
| |
| if (!ignore_errors && dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) |
| { |
| dbus_set_error_from_message (&error, message); |
| fprintf (stderr, "Failed to receive reply #%d: %s: %s\n", *received_p, |
| error.name, error.message); |
| } |
| else |
| { |
| VERBOSE (stderr, "received message #%d\n", *received_p); |
| } |
| |
| (*received_p)++; |
| } |
| |
| static void |
| consume_stdin (char **payload_p, |
| size_t *len_p) |
| { |
| const size_t BLOCK_SIZE = 4096; |
| size_t len = BLOCK_SIZE; |
| size_t pos = 0; |
| size_t n; |
| char *buf; |
| |
| buf = dbus_malloc (len); |
| |
| if (buf == NULL) |
| tool_oom ("reading payload from stdin"); |
| |
| while (1) |
| { |
| if (len - pos < BLOCK_SIZE) |
| { |
| char *tmp = dbus_realloc (buf, len + BLOCK_SIZE); |
| |
| if (tmp == NULL) |
| tool_oom ("reading payload from stdin"); |
| |
| buf = tmp; |
| len += BLOCK_SIZE; |
| } |
| |
| n = fread (buf + pos, 1, len - pos, stdin); |
| |
| if (n <= 0) |
| { |
| /* EOF or error - treat as EOF */ |
| break; |
| } |
| |
| pos += n; |
| } |
| |
| *len_p = pos; |
| *payload_p = buf; |
| } |
| |
| int |
| dbus_test_tool_spam (int argc, char **argv) |
| { |
| DBusConnection *connection = NULL; |
| DBusError error = DBUS_ERROR_INIT; |
| DBusBusType type = DBUS_BUS_SESSION; |
| const char *destination = DBUS_SERVICE_DBUS; |
| int i; |
| int count = 1; |
| int sent = 0; |
| unsigned int sent_in_this_conn = 0; |
| int received = 0; |
| unsigned int received_before_this_conn = 0; |
| int queue_len = 1; |
| const char *payload = NULL; |
| char *payload_buf = NULL; |
| size_t payload_len; |
| int payload_type = DBUS_TYPE_STRING; |
| DBusMessage *template = NULL; |
| dbus_bool_t flood = FALSE; |
| dbus_bool_t no_reply = FALSE; |
| unsigned int messages_per_conn = 0; |
| unsigned int seed = time (NULL); |
| int n_random_sizes = 0; |
| unsigned int *random_sizes = NULL; |
| |
| /* argv[1] is the tool name, so start from 2 */ |
| |
| for (i = 2; i < argc; i++) |
| { |
| const char *arg = argv[i]; |
| |
| if (strcmp (arg, "--system") == 0) |
| { |
| type = DBUS_BUS_SYSTEM; |
| } |
| else if (strcmp (arg, "--session") == 0) |
| { |
| type = DBUS_BUS_SESSION; |
| } |
| else if (strstr (arg, "--count=") == arg) |
| { |
| count = atoi (arg + strlen ("--count=")); |
| |
| if (count < 1) |
| usage (2); |
| } |
| else if (strcmp (arg, "--ignore-errors") == 0) |
| { |
| ignore_errors = TRUE; |
| } |
| else if (strstr (arg, "--dest=") == arg) |
| { |
| destination = arg + strlen ("--dest="); |
| } |
| else if (strstr (arg, "--payload=") == arg) |
| { |
| payload = arg + strlen ("--payload="); |
| } |
| else if (strcmp (arg, "--stdin") == 0) |
| { |
| consume_stdin (&payload_buf, &payload_len); |
| payload = payload_buf; |
| } |
| else if (strcmp (arg, "--message-stdin") == 0) |
| { |
| consume_stdin (&payload_buf, &payload_len); |
| payload = payload_buf; |
| template = dbus_message_demarshal (payload, payload_len, &error); |
| |
| if (template == NULL) |
| { |
| fprintf (stderr, "Unable to demarshal template message: %s: %s", |
| error.name, error.message); |
| exit (1); |
| } |
| |
| if (dbus_message_get_type (template) != DBUS_MESSAGE_TYPE_METHOD_CALL) |
| { |
| fprintf (stderr, "Template message must be a method call\n"); |
| exit (1); |
| } |
| } |
| else if (strcmp (arg, "--random-size") == 0) |
| { |
| unsigned int len, max = 0; |
| int j, consumed = 0; |
| const char *p; |
| |
| consume_stdin (&payload_buf, &payload_len); |
| |
| for (p = payload_buf; p < payload_buf + payload_len; p += consumed) |
| { |
| /* the space character matches any (or no) whitespace */ |
| if (sscanf (p, " %u %n", &len, &consumed) == 0) |
| break; |
| |
| n_random_sizes++; |
| } |
| |
| random_sizes = dbus_new0 (int, n_random_sizes); |
| |
| if (random_sizes == NULL) |
| tool_oom ("allocating array of message lengths"); |
| |
| for (p = payload_buf, j = 0; |
| p < payload_buf + payload_len && j < n_random_sizes; |
| p += consumed, j++) |
| { |
| sscanf (p, " %u %n", &len, &consumed); |
| random_sizes[j] = len; |
| |
| if (len > max) |
| max = len; |
| } |
| |
| dbus_free (payload_buf); |
| payload_len = max + 1; |
| payload_buf = dbus_new (char, payload_len); |
| payload = payload_buf; |
| |
| if (payload_buf == NULL) |
| tool_oom ("allocating maximum-sized payload"); |
| |
| memset (payload_buf, 'X', payload_len); |
| payload_buf[payload_len - 1] = '\0'; |
| } |
| else if (strcmp (arg, "--empty") == 0) |
| { |
| payload_type = DBUS_TYPE_INVALID; |
| } |
| else if (strcmp (arg, "--string") == 0) |
| { |
| payload_type = DBUS_TYPE_STRING; |
| } |
| else if (strcmp (arg, "--bytes") == 0) |
| { |
| payload_type = DBUS_TYPE_ARRAY; |
| } |
| else if (strcmp (arg, "--flood") == 0) |
| { |
| if (queue_len > 1) |
| usage (2); |
| |
| if (messages_per_conn > 0) |
| usage (2); |
| |
| flood = TRUE; |
| queue_len = -1; |
| } |
| else if (strcmp (arg, "--no-reply") == 0) |
| { |
| if (queue_len > 1) |
| usage (2); |
| |
| queue_len = -1; |
| no_reply = TRUE; |
| } |
| else if (strstr (arg, "--queue=") == arg) |
| { |
| if (flood || no_reply) |
| usage (2); |
| |
| queue_len = atoi (arg + strlen ("--queue=")); |
| |
| if (queue_len < 1) |
| usage (2); |
| } |
| else if (strstr (arg, "--seed=") == arg) |
| { |
| seed = strtoul (arg + strlen ("--seed="), NULL, 10); |
| } |
| else if (strstr (arg, "--messages-per-conn=") == arg) |
| { |
| messages_per_conn = atoi (arg + strlen ("--messages-per-conn=")); |
| |
| if (messages_per_conn > 0 && flood) |
| usage (2); |
| } |
| else |
| { |
| usage (2); |
| } |
| } |
| |
| srand (seed); |
| |
| if (payload == NULL) |
| { |
| payload = "hello, world!"; |
| payload_len = strlen (payload); |
| } |
| |
| VERBOSE (stderr, "Will send up to %d messages, with up to %d queued, max %d per connection\n", |
| count, queue_len, messages_per_conn); |
| |
| while (no_reply ? sent < count : received < count) |
| { |
| /* Connect? |
| * - In the first iteration |
| * or |
| * - When messages_per_conn messages have been sent and no replies are being waited for |
| */ |
| if (connection == NULL || |
| (messages_per_conn > 0 && sent_in_this_conn == messages_per_conn && |
| (no_reply || received - received_before_this_conn == messages_per_conn))) |
| { |
| if (connection != NULL) |
| { |
| dbus_connection_flush (connection); |
| dbus_connection_close (connection); |
| dbus_connection_unref (connection); |
| } |
| |
| VERBOSE (stderr, "New connection.\n"); |
| connection = dbus_bus_get_private (type, &error); |
| |
| if (connection == NULL) |
| { |
| fprintf (stderr, "Failed to connect to bus: %s: %s\n", |
| error.name, error.message); |
| dbus_error_free (&error); |
| dbus_free (random_sizes); |
| dbus_free (payload_buf); |
| return 1; |
| } |
| |
| sent_in_this_conn = 0; |
| received_before_this_conn = received; |
| } |
| |
| /* Send another message? Only if we don't exceed the 3 limits: |
| * - total amount of messages |
| * - messages sent on this connection |
| * - queue |
| */ |
| while (sent < count && |
| (messages_per_conn == 0 || sent_in_this_conn < messages_per_conn) && |
| (queue_len == -1 || sent_in_this_conn < queue_len + received - received_before_this_conn)) |
| { |
| DBusMessage *message; |
| |
| if (template != NULL) |
| { |
| message = dbus_message_copy (template); |
| |
| if (message == NULL) |
| tool_oom ("copying message"); |
| |
| dbus_message_set_no_reply (message, no_reply); |
| } |
| else |
| { |
| dbus_bool_t mem; |
| unsigned int len = 0; |
| |
| message = dbus_message_new_method_call (destination, |
| "/", |
| "com.example", |
| "Spam"); |
| |
| if (message == NULL) |
| tool_oom ("allocating message"); |
| |
| dbus_message_set_no_reply (message, no_reply); |
| |
| switch (payload_type) |
| { |
| case DBUS_TYPE_STRING: |
| if (random_sizes != NULL) |
| { |
| /* this isn't fair, strictly speaking - the first few |
| * are a bit more likely to be chosen, unless |
| * RAND_MAX is divisible by n_random_sizes - but it's |
| * good enough for traffic-generation */ |
| len = random_sizes[rand () % n_random_sizes]; |
| payload_buf[len] = '\0'; |
| } |
| |
| mem = dbus_message_append_args (message, |
| DBUS_TYPE_STRING, &payload, |
| DBUS_TYPE_INVALID); |
| |
| if (random_sizes != NULL) |
| { |
| /* undo the truncation above */ |
| payload_buf[len] = 'X'; |
| } |
| |
| break; |
| |
| case DBUS_TYPE_ARRAY: |
| len = payload_len; |
| |
| /* as above, not strictly fair, but close enough */ |
| if (random_sizes != NULL) |
| len = random_sizes[rand () % n_random_sizes]; |
| |
| mem = dbus_message_append_args (message, |
| DBUS_TYPE_ARRAY, |
| DBUS_TYPE_BYTE, |
| &payload, |
| (dbus_uint32_t) len, |
| DBUS_TYPE_INVALID); |
| break; |
| |
| default: |
| mem = TRUE; |
| } |
| |
| if (!mem) |
| tool_oom ("building message"); |
| } |
| |
| if (no_reply) |
| { |
| if (!dbus_connection_send (connection, message, NULL)) |
| tool_oom ("sending message"); |
| |
| VERBOSE (stderr, "sent message #%d\n", sent); |
| sent++; |
| sent_in_this_conn++; |
| } |
| else |
| { |
| DBusPendingCall *pc; |
| |
| if (!dbus_connection_send_with_reply (connection, |
| message, |
| &pc, |
| DBUS_TIMEOUT_INFINITE)) |
| tool_oom ("sending message"); |
| |
| VERBOSE (stderr, "sent message #%d\n", sent); |
| sent++; |
| sent_in_this_conn++; |
| |
| if (pc == NULL) |
| tool_oom ("sending message"); |
| |
| if (dbus_pending_call_get_completed (pc)) |
| pc_notify (pc, &received); |
| else if (!dbus_pending_call_set_notify (pc, pc_notify, &received, |
| NULL)) |
| tool_oom ("setting pending call notifier"); |
| |
| dbus_pending_call_unref (pc); |
| } |
| |
| dbus_message_unref (message); |
| } |
| |
| if (!dbus_connection_read_write_dispatch (connection, -1)) |
| { |
| fprintf (stderr, "Disconnected from bus\n"); |
| exit (1); |
| } |
| } |
| |
| if (connection != NULL) |
| { |
| dbus_connection_flush (connection); |
| dbus_connection_close (connection); |
| dbus_connection_unref (connection); |
| } |
| |
| VERBOSE (stderr, "Done\n"); |
| |
| dbus_free (payload_buf); |
| dbus_free (random_sizes); |
| |
| if (template != NULL) |
| dbus_message_unref (template); |
| |
| dbus_shutdown (); |
| return 0; |
| } |
