Fix some annoying DBusString API and fix all affected code.
* dbus/dbus-string.c (_dbus_string_init): get rid of annoying
max_length argument
(_dbus_string_get_data): change to return string instead of using
an out param
(_dbus_string_get_const_data): ditto
(_dbus_string_get_data_len): ditto
(_dbus_string_get_const_data_len): ditto
2003-03-31 Havoc Pennington <hp@redhat.com>
+ Fix some annoying DBusString API and fix all affected code.
+
+ * dbus/dbus-string.c (_dbus_string_init): get rid of annoying
+ max_length argument
+ (_dbus_string_get_data): change to return string instead of using
+ an out param
+ (_dbus_string_get_const_data): ditto
+ (_dbus_string_get_data_len): ditto
+ (_dbus_string_get_const_data_len): ditto
+
+2003-03-31 Havoc Pennington <hp@redhat.com>
+
* bus/main.c (main): fix up the command line arguments to be nicer
2003-03-31 Havoc Pennington <hp@redhat.com>
iter = NULL;
desktop_file = NULL;
- if (!_dbus_string_init (&filename, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&filename))
{
BUS_SET_OOM (error);
return FALSE;
}
- if (!_dbus_string_init (&full_path, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&full_path))
{
BUS_SET_OOM (error);
_dbus_string_free (&filename);
if (!_dbus_string_ends_with_c_str (&filename, ".service"))
{
- const char *filename_c;
- _dbus_string_get_const_data (&filename, &filename_c);
_dbus_verbose ("Skipping non-.service file %s\n",
- filename_c);
+ _dbus_string_get_const_data (&filename));
continue;
}
if (desktop_file == NULL)
{
- const char *full_path_c;
-
- _dbus_string_get_const_data (&full_path, &full_path_c);
-
- _dbus_verbose ("Could not load %s: %s\n", full_path_c,
+ _dbus_verbose ("Could not load %s: %s\n",
+ _dbus_string_get_const_data (&full_path),
tmp_error.message);
if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY))
if (!add_desktop_file_entry (activation, desktop_file, &tmp_error))
{
- const char *full_path_c;
-
bus_desktop_file_free (desktop_file);
desktop_file = NULL;
-
- _dbus_string_get_const_data (&full_path, &full_path_c);
_dbus_verbose ("Could not add %s to activation entry list: %s\n",
- full_path_c, tmp_error.message);
+ _dbus_string_get_const_data (&full_path), tmp_error.message);
if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY))
{
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- if (!_dbus_string_init (&full_address, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&full_address))
return NULL;
parser = NULL;
context.error = error;
context.failed = FALSE;
- _dbus_string_get_const_data (file, &filename);
+ filename = _dbus_string_get_const_data (file);
- if (!_dbus_string_init (&context.content, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&context.content))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
DBusString data;
const char *data_str;
- if (!_dbus_string_init (&data, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&data))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto failed;
goto failed;
}
- _dbus_string_get_const_data (&data, &data_str);
+ data_str = _dbus_string_get_const_data (&data);
if (!XML_Parse (expat, data_str, _dbus_string_get_length (&data), TRUE))
{
retval = FALSE;
dir = NULL;
- if (!_dbus_string_init (&test_directory, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&test_directory))
_dbus_assert_not_reached ("didn't allocate test_directory\n");
_dbus_string_init_const (&filename, subdir);
_dbus_assert_not_reached ("couldn't allocate full path");
_dbus_string_free (&filename);
- if (!_dbus_string_init (&filename, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&filename))
_dbus_assert_not_reached ("didn't allocate filename string\n");
dbus_error_init (&error);
dir = _dbus_directory_open (&test_directory, &error);
if (dir == NULL)
{
- const char *s;
- _dbus_string_get_const_data (&test_directory, &s);
- _dbus_warn ("Could not open %s: %s\n", s,
+ _dbus_warn ("Could not open %s: %s\n",
+ _dbus_string_get_const_data (&test_directory),
error.message);
dbus_error_free (&error);
goto failed;
DBusString full_path;
LoaderOomData d;
- if (!_dbus_string_init (&full_path, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&full_path))
_dbus_assert_not_reached ("couldn't init string");
if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
if (!_dbus_string_ends_with_c_str (&full_path, ".conf"))
{
- const char *filename_c;
- _dbus_string_get_const_data (&filename, &filename_c);
_dbus_verbose ("Skipping non-.conf file %s\n",
- filename_c);
+ _dbus_string_get_const_data (&filename));
_dbus_string_free (&full_path);
goto next;
}
- {
- const char *s;
- _dbus_string_get_const_data (&filename, &s);
- printf (" %s\n", s);
- }
+ printf (" %s\n", _dbus_string_get_const_data (&filename));
_dbus_verbose (" expecting %s\n",
validity == VALID ? "valid" :
if (dbus_error_is_set (&error))
{
- const char *s;
- _dbus_string_get_const_data (&test_directory, &s);
_dbus_warn ("Could not get next file in %s: %s\n",
- s, error.message);
+ _dbus_string_get_const_data (&test_directory),
+ error.message);
dbus_error_free (&error);
goto failed;
}
bus_connection_set_name (DBusConnection *connection,
const DBusString *name)
{
- const char *c_name;
BusConnectionData *d;
d = BUS_CONNECTION_DATA (connection);
_dbus_assert (d != NULL);
_dbus_assert (d->name == NULL);
- _dbus_string_get_const_data (name, &c_name);
-
- d->name = _dbus_strdup (c_name);
-
- if (d->name == NULL)
+ if (!_dbus_string_copy_data (name, &d->name))
return FALSE;
+ _dbus_assert (d->name != NULL);
+
_dbus_verbose ("Name %s assigned to %p\n", d->name, connection);
return TRUE;
return FALSE;
}
- if (!_dbus_string_init (&key, key_end - key_start))
+ if (!_dbus_string_init (&key))
{
parser_free (parser);
return FALSE;
return NULL;
}
- if (!_dbus_string_init (&str, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&str))
return NULL;
if (!_dbus_file_get_contents (&str, filename, error))
* bounce back an error message.
*/
- if (!_dbus_string_init (&error_message, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&error_message))
{
BUS_SET_OOM (error);
return FALSE;
return FALSE;
}
- _dbus_string_get_const_data (&error_message, &error_str);
+ error_str = _dbus_string_get_const_data (&error_message);
error_reply = dbus_message_new_error_reply (in_reply_to,
DBUS_ERROR_SERVICE_DOES_NOT_EXIST,
error_str);
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- if (!_dbus_string_init (&unique_name, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&unique_name))
{
BUS_SET_OOM (error);
return FALSE;
{
if (_dbus_string_get_length (config_file) > 0)
{
- const char *s;
- _dbus_string_get_const_data (config_file, &s);
fprintf (stderr, "--%s specified but configuration file %s already requested\n",
- extra_arg, s);
+ extra_arg, _dbus_string_get_const_data (config_file));
exit (1);
}
}
const char *prev_arg;
int i;
- if (!_dbus_string_init (&config_file, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&config_file))
return 1;
prev_arg = NULL;
bus_registry_lookup (BusRegistry *registry,
const DBusString *service_name)
{
- const char *c_name;
BusService *service;
-
- _dbus_string_get_const_data (service_name, &c_name);
service = _dbus_hash_table_lookup_string (registry->service_hash,
- c_name);
+ _dbus_string_get_const_data (service_name));
return service;
}
BusTransaction *transaction,
DBusError *error)
{
- const char *c_name;
BusService *service;
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
_dbus_assert (owner_if_created != NULL);
_dbus_assert (transaction != NULL);
-
- _dbus_string_get_const_data (service_name, &c_name);
service = _dbus_hash_table_lookup_string (registry->service_hash,
- c_name);
+ _dbus_string_get_const_data (service_name));
if (service != NULL)
return service;
service->registry = registry;
- service->name = _dbus_strdup (c_name);
- if (service->name == NULL)
+ if (!_dbus_string_copy_data (service_name, &service->name))
{
_dbus_mem_pool_dealloc (registry->service_pool, service);
BUS_SET_OOM (error);
DBusString relative;
BusContext *context;
- if (!_dbus_string_init (&config_file, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&config_file))
{
_dbus_warn ("No memory\n");
return NULL;
if (entry == NULL)
return NULL;
- if (!_dbus_string_init (&entry->method, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&entry->method))
{
dbus_free (entry);
return NULL;
const char *
dbus_address_entry_get_method (DBusAddressEntry *entry)
{
- const char *method;
-
- _dbus_string_get_const_data (&entry->method, &method);
-
- return method;
+ return _dbus_string_get_const_data (&entry->method);
}
/**
_dbus_assert (values != NULL);
if (_dbus_string_equal_c_str (keys->data, key))
- {
- const char *str;
+ return _dbus_string_get_const_data (values->data);
- _dbus_string_get_const_data (values->data, &str);
- return str;
- }
keys = _dbus_list_get_next_link (&entry->keys, keys);
values = _dbus_list_get_next_link (&entry->values, values);
}
goto error;
}
- if (!_dbus_string_init (key, _DBUS_INT_MAX))
+ if (!_dbus_string_init (key))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
dbus_free (key);
goto error;
}
- if (!_dbus_string_init (value, _DBUS_INT_MAX))
+ if (!_dbus_string_init (value))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
_dbus_string_free (key);
_dbus_string_init_const (&context, "org_freedesktop_test");
- if (!_dbus_string_init (&file, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&file))
return FALSE;
- if (!_dbus_string_init (&line, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&line))
{
_dbus_string_free (&file);
return FALSE;
}
- if (!_dbus_string_init (&from_auth, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&from_auth))
{
_dbus_string_free (&file);
_dbus_string_free (&line);
dbus_error_init (&error);
if (!_dbus_file_get_contents (&file, filename, &error)) {
- const char *s;
- _dbus_string_get_const_data (filename, &s);
_dbus_warn ("Getting contents of %s failed: %s\n",
- s, error.message);
+ _dbus_string_get_const_data (filename), error.message);
dbus_error_free (&error);
goto out;
}
_dbus_string_delete_first_word (&line);
- if (!_dbus_string_init (&to_send, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&to_send))
{
_dbus_warn ("no memory to allocate string\n");
goto out;
goto out;
}
- {
- const char *s4;
- _dbus_string_get_const_data (&to_send, &s4);
- _dbus_verbose ("Sending '%s'\n", s4);
- }
+ _dbus_verbose ("Sending '%s'\n", _dbus_string_get_const_data (&to_send));
if (!_dbus_string_append (&to_send, "\r\n"))
{
{
DBusString username;
- if (!_dbus_string_init (&username, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&username))
{
_dbus_warn ("no memory for userid\n");
_dbus_string_free (&to_send);
DBusString username;
const DBusString *u;
- if (!_dbus_string_init (&username, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&username))
{
_dbus_warn ("no memory for username\n");
_dbus_string_free (&to_send);
_dbus_string_delete_first_word (&line);
- if (!_dbus_string_init (&received, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&received))
{
_dbus_warn ("no mem to allocate string received\n");
goto out;
if (!_dbus_string_pop_line (&from_auth, &received))
{
- const char *command;
- _dbus_string_get_const_data (&line, &command);
_dbus_warn ("no line popped from the DBusAuth being tested, expected command %s on line %d\n",
- command, line_no);
+ _dbus_string_get_const_data (&line), line_no);
_dbus_string_free (&received);
goto out;
}
if (!same_first_word (&received, &line))
{
- const char *s1, *s2;
- _dbus_string_get_const_data (&line, &s1);
- _dbus_string_get_const_data (&received, &s2);
_dbus_warn ("line %d expected command '%s' and got '%s'\n",
- line_no, s1, s2);
+ line_no,
+ _dbus_string_get_const_data (&line),
+ _dbus_string_get_const_data (&received));
_dbus_string_free (&received);
goto out;
}
_dbus_string_delete_first_word (&line);
- if (!_dbus_string_init (&expected, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&expected))
{
_dbus_warn ("no mem to allocate string expected\n");
goto out;
}
else
{
- const char *e1, *h1;
- _dbus_string_get_const_data (&expected, &e1);
- _dbus_string_get_const_data (unused, &h1);
_dbus_warn ("Expected unused bytes '%s' and have '%s'\n",
- e1, h1);
+ _dbus_string_get_const_data (&expected),
+ _dbus_string_get_const_data (unused));
_dbus_string_free (&expected);
goto out;
}
_dbus_string_delete_first_word (&line);
- if (!_dbus_string_init (&expected, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&expected))
{
_dbus_warn ("no mem to allocate string expected\n");
goto out;
}
else
{
- const char *e1, *h1;
- _dbus_string_get_const_data (&expected, &e1);
- _dbus_string_get_const_data (&from_auth, &h1);
_dbus_warn ("Expected exact string '%s' and have '%s'\n",
- e1, h1);
+ _dbus_string_get_const_data (&expected),
+ _dbus_string_get_const_data (&from_auth));
_dbus_string_free (&expected);
goto out;
}
parse_failed:
{
- const char *s;
- _dbus_string_get_const_data (&line, &s);
_dbus_warn ("couldn't process line %d \"%s\"\n",
- line_no, s);
+ line_no, _dbus_string_get_const_data (&line));
goto out;
}
}
if (_dbus_string_get_length (&from_auth) > 0)
{
- const char *s;
_dbus_warn ("script did not have EXPECT_ statements for all the data received from the DBusAuth\n");
- _dbus_string_get_const_data (&from_auth, &s);
- _dbus_warn ("Leftover data: %s\n", s);
+ _dbus_warn ("Leftover data: %s\n", _dbus_string_get_const_data (&from_auth));
goto out;
}
* overlong buffers in _dbus_auth_do_work().
*/
- if (!_dbus_string_init (&auth->incoming, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&auth->incoming))
goto enomem_0;
- if (!_dbus_string_init (&auth->outgoing, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&auth->outgoing))
goto enomem_1;
- if (!_dbus_string_init (&auth->identity, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&auth->identity))
goto enomem_2;
- if (!_dbus_string_init (&auth->context, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&auth->context))
goto enomem_3;
- if (!_dbus_string_init (&auth->challenge, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&auth->challenge))
goto enomem_4;
/* default context if none is specified */
retval = FALSE;
- if (!_dbus_string_init (&cookie, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&cookie))
return FALSE;
if (!_dbus_keyring_get_hex_key (auth->keyring, cookie_id,
goto out_0;
}
- if (!_dbus_string_init (&to_hash, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&to_hash))
goto out_0;
if (!_dbus_string_copy (server_challenge, 0,
return send_rejected (auth);
}
- if (!_dbus_string_init (&tmp, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&tmp))
return FALSE;
- if (!_dbus_string_init (&tmp2, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&tmp2))
{
_dbus_string_free (&tmp);
return FALSE;
return send_rejected (auth);
}
- if (!_dbus_string_init (&client_challenge, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&client_challenge))
goto out_0;
- if (!_dbus_string_init (&client_hash, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&client_hash))
goto out_1;
if (!_dbus_string_copy_len (data, 0, i, &client_challenge,
goto out_2;
}
- if (!_dbus_string_init (&correct_hash, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&correct_hash))
goto out_2;
if (!sha1_compute_hash (auth, auth->cookie_id,
goto out_0;
}
- if (!_dbus_string_init (&context, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&context))
goto out_0;
if (!_dbus_string_copy_len (data, 0, i,
goto out_1;
}
- if (!_dbus_string_init (&cookie_id_str, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&cookie_id_str))
goto out_1;
if (!_dbus_string_copy_len (data, i, j - i,
&cookie_id_str, 0))
goto out_2;
- if (!_dbus_string_init (&server_challenge, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&server_challenge))
goto out_2;
i = j;
_dbus_assert (auth->keyring != NULL);
- if (!_dbus_string_init (&tmp, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&tmp))
goto out_3;
if (!_dbus_generate_random_bytes (&tmp, N_CHALLENGE_BYTES))
goto out_4;
- if (!_dbus_string_init (&client_challenge, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&client_challenge))
goto out_4;
if (!_dbus_string_hex_encode (&tmp, 0, &client_challenge, 0))
goto out_5;
- if (!_dbus_string_init (&correct_hash, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&correct_hash))
goto out_6;
if (!sha1_compute_hash (auth, val,
*/
DBusString plaintext;
- if (!_dbus_string_init (&plaintext, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&plaintext))
return FALSE;
if (!_dbus_string_append_our_uid (&plaintext))
DBusAuthServer *server_auth;
int i;
- if (!_dbus_string_init (&command, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&command))
return FALSE;
if (!_dbus_string_append (&command,
_dbus_string_find_blank (args, 0, &i);
- if (!_dbus_string_init (&mech, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&mech))
return FALSE;
- if (!_dbus_string_init (&base64_response, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&base64_response))
{
_dbus_string_free (&mech);
return FALSE;
}
- if (!_dbus_string_init (&decoded_response, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&decoded_response))
{
_dbus_string_free (&mech);
_dbus_string_free (&base64_response);
{
DBusString decoded;
- if (!_dbus_string_init (&decoded, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&decoded))
return FALSE;
if (!_dbus_string_base64_decode (args, 0, &decoded, 0))
#ifdef DBUS_ENABLE_VERBOSE_MODE
if (_dbus_string_validate_ascii (&decoded, 0,
_dbus_string_get_length (&decoded)))
- {
- const char *s;
- _dbus_string_get_const_data (&decoded, &s);
- _dbus_verbose ("data: '%s'\n", s);
- }
+ _dbus_verbose ("data: '%s'\n", _dbus_string_get_const_data (&decoded));
#endif
if (!(* auth->mech->server_data_func) (auth, &decoded))
DBusString m;
const DBusAuthMechanismHandler *mech;
- if (!_dbus_string_init (&m, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&m))
goto nomem;
if (!get_word (args, &next, &m))
}
else
{
- const char *s;
-
- _dbus_string_get_const_data (&m, &s);
_dbus_verbose ("Server offered mechanism \"%s\" that we don't know how to use\n",
- s);
+ _dbus_string_get_const_data (&m));
}
_dbus_string_free (&m);
mech = DBUS_AUTH_CLIENT (auth)->mechs_to_try->data;
- if (!_dbus_string_init (&auth_command, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&auth_command))
return FALSE;
if (!_dbus_string_append (&auth_command,
{
DBusString decoded;
- if (!_dbus_string_init (&decoded, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&decoded))
return FALSE;
if (!_dbus_string_base64_decode (args, 0, &decoded, 0))
if (_dbus_string_validate_ascii (&decoded, 0,
_dbus_string_get_length (&decoded)))
{
- const char *s;
- _dbus_string_get_const_data (&decoded, &s);
- _dbus_verbose ("data: '%s'\n", s);
+ _dbus_verbose ("data: '%s'\n",
+ _dbus_string_get_const_data (&decoded));
}
#endif
if (!_dbus_string_find (&auth->incoming, 0, "\r\n", &eol))
return FALSE;
- if (!_dbus_string_init (&command, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&command))
{
auth->needed_memory = TRUE;
return FALSE;
}
- if (!_dbus_string_init (&args, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&args))
{
_dbus_string_free (&command);
auth->needed_memory = TRUE;
goto next_command;
}
- {
- const char *q;
- _dbus_string_get_const_data (&command, &q);
- _dbus_verbose ("got command \"%s\"\n", q);
- }
+ _dbus_verbose ("got command \"%s\"\n", _dbus_string_get_const_data (&command));
_dbus_string_find_blank (&command, 0, &i);
_dbus_string_skip_blank (&command, i, &j);
_dbus_auth_bytes_sent (DBusAuth *auth,
int bytes_sent)
{
- {
- const char *s;
- _dbus_string_get_const_data (&auth->outgoing, &s);
- _dbus_verbose ("Sent %d bytes of: %s\n", bytes_sent, s);
- }
+ _dbus_verbose ("Sent %d bytes of: %s\n", bytes_sent,
+ _dbus_string_get_const_data (&auth->outgoing));
_dbus_string_delete (&auth->outgoing,
0, bytes_sent);
retval = FALSE;
dir = NULL;
- if (!_dbus_string_init (&test_directory, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&test_directory))
_dbus_assert_not_reached ("didn't allocate test_directory\n");
_dbus_string_init_const (&filename, subdir);
_dbus_assert_not_reached ("couldn't allocate full path");
_dbus_string_free (&filename);
- if (!_dbus_string_init (&filename, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&filename))
_dbus_assert_not_reached ("didn't allocate filename string\n");
dbus_error_init (&error);
dir = _dbus_directory_open (&test_directory, &error);
if (dir == NULL)
{
- const char *s;
- _dbus_string_get_const_data (&test_directory, &s);
- _dbus_warn ("Could not open %s: %s\n", s,
+ _dbus_warn ("Could not open %s: %s\n",
+ _dbus_string_get_const_data (&test_directory),
error.message);
dbus_error_free (&error);
goto failed;
{
DBusString full_path;
- if (!_dbus_string_init (&full_path, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&full_path))
_dbus_assert_not_reached ("couldn't init string");
if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
if (!_dbus_string_ends_with_c_str (&filename, ".auth-script"))
{
- const char *filename_c;
- _dbus_string_get_const_data (&filename, &filename_c);
_dbus_verbose ("Skipping non-.auth-script file %s\n",
- filename_c);
+ _dbus_string_get_const_data (&filename));
_dbus_string_free (&full_path);
goto next;
}
- {
- const char *s;
- _dbus_string_get_const_data (&filename, &s);
- printf (" %s\n", s);
- }
+ printf (" %s\n", _dbus_string_get_const_data (&filename));
if (!_dbus_auth_script_run (&full_path))
{
if (dbus_error_is_set (&error))
{
- const char *s;
- _dbus_string_get_const_data (&test_directory, &s);
_dbus_warn ("Could not get next file in %s: %s\n",
- s, error.message);
+ _dbus_string_get_const_data (&test_directory), error.message);
dbus_error_free (&error);
goto failed;
}
if (keyring == NULL)
goto out_0;
- if (!_dbus_string_init (&keyring->directory, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&keyring->directory))
goto out_1;
- if (!_dbus_string_init (&keyring->filename, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&keyring->filename))
goto out_2;
- if (!_dbus_string_init (&keyring->filename_lock, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&keyring->filename_lock))
goto out_3;
- if (!_dbus_string_init (&keyring->username, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&keyring->username))
goto out_4;
keyring->refcount = 1;
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- if (!_dbus_string_init (&bytes, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&bytes))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return FALSE;
goto out;
}
- _dbus_string_get_const_data (&bytes, (const char**) &s);
+ s = (const unsigned char*) _dbus_string_get_const_data (&bytes);
id = s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24);
if (id < 0)
keys = new;
n_keys += 1;
- if (!_dbus_string_init (&keys[n_keys-1].secret,
- _DBUS_INT_MAX))
+ if (!_dbus_string_init (&keys[n_keys-1].secret))
{
n_keys -= 1; /* we don't want to free the one we didn't init */
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- if (!_dbus_string_init (&contents, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&contents))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return FALSE;
}
- if (!_dbus_string_init (&line, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&line))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
_dbus_string_free (&contents);
keys = new;
n_keys += 1;
- if (!_dbus_string_init (&keys[n_keys-1].secret,
- _DBUS_INT_MAX))
+ if (!_dbus_string_init (&keys[n_keys-1].secret))
{
n_keys -= 1; /* we don't want to free the one we didn't init */
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
keyring = NULL;
error_set = FALSE;
- if (!_dbus_string_init (&homedir, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&homedir))
return FALSE;
_dbus_string_init_const (&dotdir, ".dbus-keyrings");
_dbus_string_init_const (&context, "foo bar");
_dbus_assert (!_dbus_keyring_validate_context (&context));
- if (!_dbus_string_init (&context, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&context))
_dbus_assert_not_reached ("no memory");
if (!_dbus_string_append_byte (&context, '\0'))
_dbus_assert_not_reached ("no memory");
_dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
byte_order == DBUS_BIG_ENDIAN);
- _dbus_string_get_data_len (str, &data, offset, 4);
+ data = _dbus_string_get_data_len (str, offset, 4);
_dbus_pack_int32 (value, byte_order, data);
}
_dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
byte_order == DBUS_BIG_ENDIAN);
- _dbus_string_get_data_len (str, &data, offset, 4);
+ data = _dbus_string_get_data_len (str, offset, 4);
_dbus_pack_uint32 (value, byte_order, data);
}
pos = _DBUS_ALIGN_VALUE (pos, sizeof (double));
- _dbus_string_get_const_data_len (str, &buffer, pos, sizeof (double));
+ buffer = _dbus_string_get_const_data_len (str, pos, sizeof (double));
retval = *(double *)buffer;
if (!retval)
return NULL;
- _dbus_string_get_const_data_len (str, &data, pos, len);
+ data = _dbus_string_get_const_data_len (str, pos, len);
if (!data)
return NULL;
if (!retval)
return FALSE;
- _dbus_string_get_const_data_len (str, &data, pos, len);
+ data = _dbus_string_get_const_data_len (str, pos, len);
if (!data)
{
if (pos >= _dbus_string_get_length (str))
return FALSE;
- _dbus_string_get_const_data_len (str, &data, pos, 1);
+ data = _dbus_string_get_const_data_len (str, pos, 1);
switch (*data)
{
if (pos >= _dbus_string_get_length (str))
return FALSE;
- _dbus_string_get_const_data_len (str, &data, pos, 1);
+ data = _dbus_string_get_const_data_len (str, pos, 1);
switch (*data)
{
len = real_len - start;
}
-
- _dbus_string_get_const_data_len (str, &d, start, len);
+ d = _dbus_string_get_const_data_len (str, start, len);
_dbus_verbose_bytes (d, len);
}
const char **our_string_array;
DBusDict *dict;
- if (!_dbus_string_init (&str, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&str))
_dbus_assert_not_reached ("failed to init string");
/* Marshal doubles */
_dbus_md5_update (&context, data);
- if (!_dbus_string_init (&digest, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&digest))
return FALSE;
if (!_dbus_md5_final (&context, &digest))
_dbus_string_init_const_len (&input_str, input, input_len);
_dbus_string_init_const (&expected_str, expected);
- if (!_dbus_string_init (&results, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&results))
_dbus_assert_not_reached ("no memory for md5 results");
if (!_dbus_md5_compute (&input_str, &results))
{
SavedLength *sl;
const char *s;
-
- _dbus_string_get_const_data (name, &s);
+
+ s = _dbus_string_get_const_data (name);
sl = _dbus_hash_table_lookup_string (hash, s);
if (sl != NULL)
sl = dbus_new0 (SavedLength, 1);
- if (!_dbus_string_init (&sl->name, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&sl->name))
{
dbus_free (sl);
return NULL;
if (!_dbus_string_copy (name, 0, &sl->name, 0))
goto failed;
- _dbus_string_get_const_data (&sl->name, &s);
+ s = _dbus_string_get_const_data (&sl->name);
if (!_dbus_hash_table_insert_string (hash, (char*)s, sl))
goto failed;
retval = FALSE;
length_hash = NULL;
- if (!_dbus_string_init (&file, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&file))
return FALSE;
- if (!_dbus_string_init (&line, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&line))
{
_dbus_string_free (&file);
return FALSE;
}
- {
- const char *s;
- _dbus_string_get_const_data (filename, &s);
- _dbus_verbose ("Loading %s\n", s);
- }
+ _dbus_verbose ("Loading %s\n", _dbus_string_get_const_data (filename));
dbus_error_init (&error);
if (!_dbus_file_get_contents (&file, filename, &error))
{
- const char *s;
- _dbus_string_get_const_data (filename, &s);
_dbus_warn ("Getting contents of %s failed: %s\n",
- s, error.message);
+ _dbus_string_get_const_data (filename), error.message);
dbus_error_free (&error);
goto out;
}
if (_dbus_string_get_length (&line) != 4)
{
- const char *s;
- _dbus_string_get_const_data (&line, &s);
_dbus_warn ("Field name must be four characters not \"%s\"\n",
- s);
+ _dbus_string_get_const_data (&line));
goto parse_failed;
}
code = DBUS_TYPE_DICT;
else
{
- const char *s;
- _dbus_string_get_const_data (&line, &s);
- _dbus_warn ("%s is not a valid type name\n", s);
+ _dbus_warn ("%s is not a valid type name\n", _dbus_string_get_const_data (&line));
goto parse_failed;
}
if (b != '{')
goto parse_failed;
- _dbus_string_init (&val_str, _DBUS_INT_MAX);
+ _dbus_string_init (&val_str);
while (i < _dbus_string_get_length (&line))
{
_dbus_string_skip_blank (&line, i, &i);
parse_failed:
{
- const char *s;
- _dbus_string_get_const_data (&line, &s);
_dbus_warn ("couldn't process line %d \"%s\"\n",
- line_no, s);
+ line_no, _dbus_string_get_const_data (&line));
goto out;
}
}
SavedLength *sl = _dbus_hash_iter_get_value (&iter);
const char *s;
- _dbus_string_get_const_data (&sl->name, &s);
+ s = _dbus_string_get_const_data (&sl->name);
if (sl->length < 0)
{
offset,
NULL);
- _dbus_string_get_const_data (&message->header,
- &data);
+ data = _dbus_string_get_const_data (&message->header);
return data + (offset + 4);
}
++i;
}
- if (!_dbus_string_init (&message->header, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&message->header))
{
dbus_free (message);
return NULL;
}
- if (!_dbus_string_init (&message->body, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&message->body))
{
_dbus_string_free (&message->header);
dbus_free (message);
retval->header_padding = message->header_padding;
retval->locked = FALSE;
- if (!_dbus_string_init (&retval->header, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&retval->header))
{
dbus_free (retval);
return NULL;
}
- if (!_dbus_string_init (&retval->body, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&retval->body))
{
_dbus_string_free (&retval->header);
dbus_free (retval);
if (iter->pos >= _dbus_string_get_length (&iter->message->body))
return DBUS_TYPE_INVALID;
- _dbus_string_get_const_data_len (&iter->message->body, &data, iter->pos, 1);
+ data = _dbus_string_get_const_data_len (&iter->message->body, iter->pos, 1);
if (*data > DBUS_TYPE_INVALID && *data <= DBUS_TYPE_DICT)
return *data;
_dbus_assert (!message->locked);
- _dbus_string_get_data_len (&message->header, &header, 1, 1);
+ header = _dbus_string_get_data_len (&message->header, 1, 1);
if (is_error_reply)
*header |= DBUS_HEADER_FLAG_ERROR;
{
const char *header;
- _dbus_string_get_const_data_len (&message->header, &header, 1, 1);
+ header = _dbus_string_get_const_data_len (&message->header, 1, 1);
return (*header & DBUS_HEADER_FLAG_ERROR) != 0;
}
*/
loader->max_message_size = _DBUS_ONE_MEGABYTE * 32;
- if (!_dbus_string_init (&loader->data, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&loader->data))
{
dbus_free (loader);
return NULL;
if ((pos + 4) > header_len)
return FALSE;
- _dbus_string_get_const_data_len (data, &field, pos, 4);
+ field =_dbus_string_get_const_data_len (data, pos, 4);
pos += 4;
_dbus_assert (_DBUS_ALIGN_ADDRESS (field, 4) == field);
int byte_order, header_len, body_len, header_padding;
dbus_uint32_t header_len_unsigned, body_len_unsigned;
- _dbus_string_get_const_data_len (&loader->data, &header_data, 0, 16);
+ header_data = _dbus_string_get_const_data_len (&loader->data, 0, 16);
_dbus_assert (_DBUS_ALIGN_ADDRESS (header_data, 4) == header_data);
dbus_error_init (&error);
if (!_dbus_file_get_contents (data, filename, &error))
{
- const char *s;
- _dbus_string_get_const_data (filename, &s);
- _dbus_warn ("Could not load message file %s: %s\n", s, error.message);
+ _dbus_warn ("Could not load message file %s: %s\n",
+ _dbus_string_get_const_data (filename),
+ error.message);
dbus_error_free (&error);
goto failed;
}
{
if (!_dbus_message_data_load (data, filename))
{
- const char *s;
- _dbus_string_get_const_data (filename, &s);
- _dbus_warn ("Could not load message file %s\n", s);
+ _dbus_warn ("Could not load message file %s\n",
+ _dbus_string_get_const_data (filename));
goto failed;
}
}
retval = FALSE;
- if (!_dbus_string_init (&data, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&data))
_dbus_assert_not_reached ("could not allocate string\n");
if (!dbus_internal_do_not_use_load_message_file (filename, is_raw,
if (!retval)
{
- const char *s;
-
if (_dbus_string_get_length (&data) > 0)
_dbus_verbose_bytes_of_string (&data, 0,
_dbus_string_get_length (&data));
- _dbus_string_get_const_data (filename, &s);
_dbus_warn ("Failed message loader test on %s\n",
- s);
+ _dbus_string_get_const_data (filename));
}
_dbus_string_free (&data);
retval = FALSE;
dir = NULL;
- if (!_dbus_string_init (&test_directory, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&test_directory))
_dbus_assert_not_reached ("didn't allocate test_directory\n");
_dbus_string_init_const (&filename, subdir);
_dbus_assert_not_reached ("couldn't allocate full path");
_dbus_string_free (&filename);
- if (!_dbus_string_init (&filename, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&filename))
_dbus_assert_not_reached ("didn't allocate filename string\n");
dbus_error_init (&error);
dir = _dbus_directory_open (&test_directory, &error);
if (dir == NULL)
{
- const char *s;
- _dbus_string_get_const_data (&test_directory, &s);
- _dbus_warn ("Could not open %s: %s\n", s,
+ _dbus_warn ("Could not open %s: %s\n",
+ _dbus_string_get_const_data (&test_directory),
error.message);
dbus_error_free (&error);
goto failed;
DBusString full_path;
dbus_bool_t is_raw;
- if (!_dbus_string_init (&full_path, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&full_path))
_dbus_assert_not_reached ("couldn't init string");
if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
is_raw = TRUE;
else
{
- const char *filename_c;
- _dbus_string_get_const_data (&filename, &filename_c);
_dbus_verbose ("Skipping non-.message file %s\n",
- filename_c);
+ _dbus_string_get_const_data (&filename));
_dbus_string_free (&full_path);
goto next;
}
- {
- const char *s;
- _dbus_string_get_const_data (&filename, &s);
- printf (" %s\n", s);
- }
+ printf (" %s\n",
+ _dbus_string_get_const_data (&filename));
_dbus_verbose (" expecting %s\n",
validity == _DBUS_MESSAGE_VALID ? "valid" :
if (dbus_error_is_set (&error))
{
- const char *s;
- _dbus_string_get_const_data (&test_directory, &s);
_dbus_warn ("Could not get next file in %s: %s\n",
- s, error.message);
+ _dbus_string_get_const_data (&test_directory),
+ error.message);
dbus_error_free (&error);
goto failed;
}
loader = _dbus_message_loader_new ();
/* Write the header data one byte at a time */
- _dbus_string_get_const_data (&message->header, &data);
+ data = _dbus_string_get_const_data (&message->header);
for (i = 0; i < _dbus_string_get_length (&message->header); i++)
{
DBusString *buffer;
}
/* Write the body data one byte at a time */
- _dbus_string_get_const_data (&message->body, &data);
+ data = _dbus_string_get_const_data (&message->body);
for (i = 0; i < _dbus_string_get_length (&message->body); i++)
{
DBusString *buffer;
if (debug_server == NULL)
goto nomem_0;
- if (!_dbus_string_init (&address, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&address))
goto nomem_1;
if (!_dbus_string_append (&address, "debug-pipe:name=") ||
return NULL;
}
- if (!_dbus_string_init (&address, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&address))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
if (debug_server == NULL)
return NULL;
- if (!_dbus_string_init (&address, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&address))
goto nomem_0;
if (!_dbus_string_append (&address, "debug:name=") ||
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- if (!_dbus_string_init (&address, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&address))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- if (!_dbus_string_init (&address, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&address))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
const DBusString *data)
{
unsigned int inputLen;
- unsigned char *input;
+ const unsigned char *input;
- _dbus_string_get_const_data (data, (const char**) &input);
+ input = (const unsigned char*) _dbus_string_get_const_data (data);
inputLen = _dbus_string_get_length (data);
sha_append (context, input, inputLen);
_dbus_sha_update (&context, data);
- if (!_dbus_string_init (&digest, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&digest))
return FALSE;
if (!_dbus_sha_final (&context, &digest))
_dbus_string_init_const_len (&input_str, input, input_len);
_dbus_string_init_const (&expected_str, expected);
- if (!_dbus_string_init (&results, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&results))
_dbus_assert_not_reached ("no memory for SHA-1 results");
if (!_dbus_sha_compute (&input_str, &results))
if (!_dbus_string_equal (&expected_str, &results))
{
- const char *s;
- _dbus_string_get_const_data (&results, &s);
_dbus_warn ("Expected hash %s got %s for SHA-1 sum\n",
- expected, s);
+ expected,
+ _dbus_string_get_const_data (&results));
_dbus_string_free (&results);
return FALSE;
}
if (!_dbus_string_parse_int (line, offset, &val, &next))
{
- const char *s;
- _dbus_string_get_const_data (line, &s);
fprintf (stderr, "could not parse length at start of compact string: %s\n",
- s);
+ _dbus_string_get_const_data (line));
return FALSE;
}
offset = next;
if (!_dbus_string_parse_int (line, offset, &val, &next))
{
- const char *s;
- _dbus_string_get_const_data (line, &s);
fprintf (stderr, "could not parse start bit 'b' in compact string: %s\n",
- s);
+ _dbus_string_get_const_data (line));
return FALSE;
}
retval = FALSE;
- if (!_dbus_string_init (&line, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&line))
_dbus_assert_not_reached ("no memory");
next_iteration:
goto next_iteration;
else if (_dbus_string_starts_with_c_str (&line, "H>"))
{
- const char *s;
- _dbus_string_get_const_data (&line, &s);
/* don't print */
}
else if (_dbus_string_starts_with_c_str (&line, "D>") ||
retval = FALSE;
- if (!_dbus_string_init (&tests_file, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&tests_file))
_dbus_assert_not_reached ("no memory");
- if (!_dbus_string_init (&results_file, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&results_file))
_dbus_assert_not_reached ("no memory");
- if (!_dbus_string_init (&tests, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&tests))
_dbus_assert_not_reached ("no memory");
- if (!_dbus_string_init (&results, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&results))
_dbus_assert_not_reached ("no memory");
- if (!_dbus_string_init (&line, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&line))
_dbus_assert_not_reached ("no memory");
if (!_dbus_string_append (&tests_file, test_data_dir))
dbus_error_init (&error);
if (!_dbus_file_get_contents (&tests, &tests_file, &error))
{
- const char *s;
- _dbus_string_get_const_data (&tests_file, &s);
fprintf (stderr, "could not load test data file %s: %s\n",
- s, error.message);
+ _dbus_string_get_const_data (&tests_file),
+ error.message);
dbus_error_free (&error);
goto out;
}
if (!_dbus_file_get_contents (&results, &results_file, &error))
{
- const char *s;
- _dbus_string_get_const_data (&results_file, &s);
fprintf (stderr, "could not load results data file %s: %s\n",
- s, error.message);
+ _dbus_string_get_const_data (&results_file), error.message);
dbus_error_free (&error);
goto out;
}
goto next_iteration;
else if (_dbus_string_starts_with_c_str (&line, "H>"))
{
- const char *s;
- _dbus_string_get_const_data (&line, &s);
- printf ("SHA-1: %s\n", s);
+ printf ("SHA-1: %s\n", _dbus_string_get_const_data (&line));
if (_dbus_string_find (&line, 0, "Type 3", NULL))
{
success = FALSE;
- if (!_dbus_string_init (&next_line, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&next_line))
_dbus_assert_not_reached ("no memory");
- if (!_dbus_string_init (&expected, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&expected))
_dbus_assert_not_reached ("no memory");
- if (!_dbus_string_init (&test, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&test))
_dbus_assert_not_reached ("no memory");
- if (!_dbus_string_init (&result, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&result))
_dbus_assert_not_reached ("no memory");
/* the "compact strings" are "^"-terminated not
}
if (!_dbus_string_equal (&result, &expected))
- {
- const char *s1;
- const char *s2;
-
- _dbus_string_get_const_data (&result, &s1);
- _dbus_string_get_const_data (&expected, &s2);
-
+ {
fprintf (stderr, " for line %d got hash %s expected %s\n",
- line_no, s1, s2);
+ line_no,
+ _dbus_string_get_const_data (&result),
+ _dbus_string_get_const_data (&expected));
goto failure;
}
else
{
- const char *s;
- _dbus_string_get_const_data (&result, &s);
- /* printf (" Got expected: %s\n", s); */
success_count += 1;
}
}
/**
- * Initializes a string. The maximum length may be _DBUS_INT_MAX for
- * no maximum. The string starts life with zero length.
- * The string must eventually be freed with _dbus_string_free().
- *
- * @todo the max length feature is useless, because it looks to the
- * app like out of memory, and the app might try to "recover" - but
- * recovery in this case is impossible, as we can't ever "get more
- * memory" - so should delete the max length feature I think. Well, at
- * least there's a strong caveat that it can only be used when
- * out-of-memory is a permanent fatal error.
- *
- * @todo we could make this init routine not alloc any memory and
- * return void, would simplify a lot of code, however it might
- * complexify things elsewhere because _dbus_string_get_data()
- * etc. could suddenly fail as they'd need to alloc new memory.
+ * Initializes a string. The string starts life with zero length. The
+ * string must eventually be freed with _dbus_string_free().
*
* @param str memory to hold the string
- * @param max_length the maximum size of the string
- * @returns #TRUE on success */
+ * @returns #TRUE on success, #FALSE if no memory
+ */
dbus_bool_t
-_dbus_string_init (DBusString *str,
- int max_length)
+_dbus_string_init (DBusString *str)
{
DBusRealString *real;
_dbus_assert (str != NULL);
- _dbus_assert (max_length >= 0);
_dbus_assert (sizeof (DBusString) == sizeof (DBusRealString));
real->len = 0;
real->str[real->len] = '\0';
- real->max_length = max_length;
- if (real->max_length > MAX_MAX_LENGTH)
- real->max_length = MAX_MAX_LENGTH;
+ real->max_length = MAX_MAX_LENGTH;
real->constant = FALSE;
real->locked = FALSE;
real->invalid = FALSE;
return TRUE;
}
+/* The max length thing is sort of a historical artifact
+ * from a feature that turned out to be dumb; perhaps
+ * we should purge it entirely. The problem with
+ * the feature is that it looks like memory allocation
+ * failure, but is not a transient or resolvable failure.
+ */
+static void
+set_max_length (DBusString *str,
+ int max_length)
+{
+ DBusRealString *real;
+
+ real = (DBusRealString*) str;
+
+ real->max_length = max_length;
+}
+
/**
* Initializes a constant string. The value parameter is not copied
* (should be static), and the string may never be modified.
* function on a const string.
*
* @param str the string
- * @param data_return place to store the returned data
+ * @returns the data
*/
-void
-_dbus_string_get_data (DBusString *str,
- char **data_return)
+char*
+_dbus_string_get_data (DBusString *str)
{
DBUS_STRING_PREAMBLE (str);
- _dbus_assert (data_return != NULL);
- *data_return = real->str;
+ return real->str;
}
/**
* Gets the raw character buffer from a const string.
*
- * @todo should return the const char* instead of using an out param;
- * the temporary variable encourages a bug where you use const data
- * after modifying the string and possibly causing a realloc.
- *
* @param str the string
- * @param data_return location to store returned data
+ * @returns the string data
*/
-void
-_dbus_string_get_const_data (const DBusString *str,
- const char **data_return)
+const char*
+_dbus_string_get_const_data (const DBusString *str)
{
DBUS_CONST_STRING_PREAMBLE (str);
- _dbus_assert (data_return != NULL);
- *data_return = real->str;
+ return real->str;
}
/**
* string, not at start + len.
*
* @param str the string
- * @param data_return location to return the buffer
* @param start byte offset to return
* @param len length of segment to return
+ * @returns the string data
*/
-void
+char*
_dbus_string_get_data_len (DBusString *str,
- char **data_return,
int start,
int len)
{
DBUS_STRING_PREAMBLE (str);
- _dbus_assert (data_return != NULL);
_dbus_assert (start >= 0);
_dbus_assert (len >= 0);
_dbus_assert (start <= real->len);
_dbus_assert (len <= real->len - start);
- *data_return = real->str + start;
+ return real->str + start;
}
/**
* after modifying the string and possibly causing a realloc.
*
* @param str the string
- * @param data_return location to return the buffer
* @param start byte offset to return
* @param len length of segment to return
+ * @returns the string data
*/
-void
+const char*
_dbus_string_get_const_data_len (const DBusString *str,
- const char **data_return,
int start,
int len)
{
DBUS_CONST_STRING_PREAMBLE (str);
- _dbus_assert (data_return != NULL);
_dbus_assert (start >= 0);
_dbus_assert (len >= 0);
_dbus_assert (start <= real->len);
_dbus_assert (len <= real->len - start);
- *data_return = real->str + start;
+ return real->str + start;
}
/**
_dbus_string_steal_data (DBusString *str,
char **data_return)
{
+ int old_max_length;
DBUS_STRING_PREAMBLE (str);
_dbus_assert (data_return != NULL);
*data_return = real->str;
+ old_max_length = real->max_length;
+
/* reset the string */
- if (!_dbus_string_init (str, real->max_length))
+ if (!_dbus_string_init (str))
{
/* hrm, put it back then */
real->str = *data_return;
return FALSE;
}
+ real->max_length = old_max_length;
+
return TRUE;
}
int len)
{
DBusString dest;
-
DBUS_STRING_PREAMBLE (str);
_dbus_assert (data_return != NULL);
_dbus_assert (start >= 0);
_dbus_assert (start <= real->len);
_dbus_assert (len <= real->len - start);
- if (!_dbus_string_init (&dest, real->max_length))
+ if (!_dbus_string_init (&dest))
return FALSE;
+ set_max_length (&dest, real->max_length);
+
if (!_dbus_string_move_len (str, start, len, &dest, 0))
{
_dbus_string_free (&dest);
_dbus_assert (start <= real->len);
_dbus_assert (len <= real->len - start);
- if (!_dbus_string_init (&dest, real->max_length))
+ if (!_dbus_string_init (&dest))
return FALSE;
+ set_max_length (&dest, real->max_length);
+
if (!_dbus_string_copy_len (str, start, len, &dest, 0))
{
_dbus_string_free (&dest);
if (source_len == 0)
return TRUE;
- if (!_dbus_string_init (&result, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&result))
return FALSE;
pad_count = 0;
_dbus_assert (start <= _dbus_string_get_length (source));
- if (!_dbus_string_init (&result, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&result))
return FALSE;
retval = FALSE;
- _dbus_string_get_const_data (source, (const char**) &p);
+ p = (const unsigned char*) _dbus_string_get_const_data (source);
end = p + _dbus_string_get_length (source);
p += start;
_dbus_assert (start <= _dbus_string_get_length (source));
- if (!_dbus_string_init (&result, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&result))
return FALSE;
retval = FALSE;
high_bits = TRUE;
- _dbus_string_get_const_data (source, (const char**) &p);
+ p = (const unsigned char*) _dbus_string_get_const_data (source);
end = p + _dbus_string_get_length (source);
p += start;
if (len < 0)
len = strlen (data);
- if (!_dbus_string_init (&orig, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&orig))
_dbus_assert_not_reached ("could not init string");
- if (!_dbus_string_init (&encoded, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&encoded))
_dbus_assert_not_reached ("could not init string");
- if (!_dbus_string_init (&decoded, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&decoded))
_dbus_assert_not_reached ("could not init string");
if (!_dbus_string_append_len (&orig, data, len))
_dbus_string_get_length (&encoded),
_dbus_string_get_length (&decoded));
printf ("Original: %s\n", data);
- _dbus_string_get_const_data (&decoded, &s);
+ s = _dbus_string_get_const_data (&decoded);
printf ("Decoded: %s\n", s);
_dbus_assert_not_reached ("original string not the same as string decoded from base64");
}
if (len < 0)
len = strlen (data);
- if (!_dbus_string_init (&orig, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&orig))
_dbus_assert_not_reached ("could not init string");
- if (!_dbus_string_init (&encoded, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&encoded))
_dbus_assert_not_reached ("could not init string");
- if (!_dbus_string_init (&decoded, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&decoded))
_dbus_assert_not_reached ("could not init string");
if (!_dbus_string_append_len (&orig, data, len))
_dbus_string_get_length (&encoded),
_dbus_string_get_length (&decoded));
printf ("Original: %s\n", data);
- _dbus_string_get_const_data (&decoded, &s);
+ s = _dbus_string_get_const_data (&decoded);
printf ("Decoded: %s\n", s);
_dbus_assert_not_reached ("original string not the same as string decoded from base64");
}
i = 0;
while (i < _DBUS_N_ELEMENTS (lens))
{
- if (!_dbus_string_init (&str, lens[i]))
+ if (!_dbus_string_init (&str))
_dbus_assert_not_reached ("failed to init string");
+
+ set_max_length (&str, lens[i]);
test_max_len (&str, lens[i]);
_dbus_string_free (&str);
{
int j;
- if (!_dbus_string_init (&str, lens[i]))
+ if (!_dbus_string_init (&str))
_dbus_assert_not_reached ("failed to init string");
+
+ set_max_length (&str, lens[i]);
if (!_dbus_string_set_length (&str, lens[i]))
_dbus_assert_not_reached ("failed to set string length");
}
/* Test appending data */
- if (!_dbus_string_init (&str, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&str))
_dbus_assert_not_reached ("failed to init string");
i = 0;
/* Check steal_data */
- if (!_dbus_string_init (&str, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&str))
_dbus_assert_not_reached ("failed to init string");
if (!_dbus_string_append (&str, "Hello World"))
i = _dbus_string_get_length (&str);
- if (!_dbus_string_init (&other, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&other))
_dbus_assert_not_reached ("could not init string");
if (!_dbus_string_move (&str, 0, &other, 0))
i = _dbus_string_get_length (&str);
- if (!_dbus_string_init (&other, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&other))
_dbus_assert_not_reached ("could not init string");
if (!_dbus_string_copy (&str, 0, &other, 0))
/* Check replace */
- if (!_dbus_string_init (&str, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&str))
_dbus_assert_not_reached ("failed to init string");
if (!_dbus_string_append (&str, "Hello World"))
i = _dbus_string_get_length (&str);
- if (!_dbus_string_init (&other, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&other))
_dbus_assert_not_reached ("could not init string");
if (!_dbus_string_replace_len (&str, 0, _dbus_string_get_length (&str),
/* Check append/get unichar */
- if (!_dbus_string_init (&str, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&str))
_dbus_assert_not_reached ("failed to init string");
ch = 0;
/* Check insert/set/get byte */
- if (!_dbus_string_init (&str, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&str))
_dbus_assert_not_reached ("failed to init string");
if (!_dbus_string_append (&str, "Hello"))
/* Check append/parse int/double */
- if (!_dbus_string_init (&str, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&str))
_dbus_assert_not_reached ("failed to init string");
if (!_dbus_string_append_int (&str, 27))
_dbus_string_free (&str);
- if (!_dbus_string_init (&str, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&str))
_dbus_assert_not_reached ("failed to init string");
if (!_dbus_string_append_double (&str, 50.3))
_dbus_string_free (&str);
/* Test find */
- if (!_dbus_string_init (&str, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&str))
_dbus_assert_not_reached ("failed to init string");
if (!_dbus_string_append (&str, "Hello"))
unsigned int dummy8 : 3; /**< placeholder */
};
-dbus_bool_t _dbus_string_init (DBusString *str,
- int max_length);
+dbus_bool_t _dbus_string_init (DBusString *str);
void _dbus_string_init_const (DBusString *str,
const char *value);
void _dbus_string_init_const_len (DBusString *str,
void _dbus_string_free (DBusString *str);
void _dbus_string_lock (DBusString *str);
-void _dbus_string_get_data (DBusString *str,
- char **data_return);
-void _dbus_string_get_const_data (const DBusString *str,
- const char **data_return);
-void _dbus_string_get_data_len (DBusString *str,
- char **data_return,
+char* _dbus_string_get_data (DBusString *str);
+const char* _dbus_string_get_const_data (const DBusString *str);
+char* _dbus_string_get_data_len (DBusString *str,
int start,
int len);
-void _dbus_string_get_const_data_len (const DBusString *str,
- const char **data_return,
+const char* _dbus_string_get_const_data_len (const DBusString *str,
int start,
int len);
void _dbus_string_set_byte (DBusString *str,
DBusString str;
char *putenv_value;
- if (!_dbus_string_init (&str, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&str))
return FALSE;
if (!_dbus_string_append (&str, varname) ||
return -1;
}
- _dbus_string_get_data_len (buffer, &data, start, count);
+ data = _dbus_string_get_data_len (buffer, start, count);
again:
const char *data;
int bytes_written;
- _dbus_string_get_const_data_len (buffer, &data, start, len);
+ data = _dbus_string_get_const_data_len (buffer, start, len);
again:
const char *data2;
int bytes_written;
- _dbus_string_get_const_data_len (buffer1, &data1, start1, len1);
+ data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
if (buffer2 != NULL)
- _dbus_string_get_const_data_len (buffer2, &data2, start2, len2);
+ data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
else
{
data2 = NULL;
if (!_dbus_string_lengthen (str, MAX_LONG_LEN))
return FALSE;
- _dbus_string_get_data_len (str, &buf, orig_len, MAX_LONG_LEN);
+ buf = _dbus_string_get_data_len (str, orig_len, MAX_LONG_LEN);
snprintf (buf, MAX_LONG_LEN, "%ld", value);
if (!_dbus_string_lengthen (str, MAX_ULONG_LEN))
return FALSE;
- _dbus_string_get_data_len (str, &buf, orig_len, MAX_ULONG_LEN);
+ buf = _dbus_string_get_data_len (str, orig_len, MAX_ULONG_LEN);
snprintf (buf, MAX_ULONG_LEN, "%lu", value);
if (!_dbus_string_lengthen (str, MAX_DOUBLE_LEN))
return FALSE;
- _dbus_string_get_data_len (str, &buf, orig_len, MAX_DOUBLE_LEN);
+ buf = _dbus_string_get_data_len (str, orig_len, MAX_DOUBLE_LEN);
snprintf (buf, MAX_LONG_LEN, "%g", value);
const char *p;
char *end;
- _dbus_string_get_const_data_len (str, &p, start,
- _dbus_string_get_length (str) - start);
+ p = _dbus_string_get_const_data_len (str, start,
+ _dbus_string_get_length (str) - start);
end = NULL;
errno = 0;
const char *p;
char *end;
- _dbus_string_get_const_data_len (str, &p, start,
- _dbus_string_get_length (str) - start);
+ p = _dbus_string_get_const_data_len (str, start,
+ _dbus_string_get_length (str) - start);
end = NULL;
errno = 0;
_dbus_warn ("_dbus_string_parse_double() needs to be made locale-independent\n");
- _dbus_string_get_const_data_len (str, &p, start,
- _dbus_string_get_length (str) - start);
+ p = _dbus_string_get_const_data_len (str, start,
+ _dbus_string_get_length (str) - start);
end = NULL;
errno = 0;
}
if (username != NULL)
- _dbus_string_get_const_data (username, &username_c_str);
+ username_c_str = _dbus_string_get_const_data (username);
else
username_c_str = NULL;
if (initialized_generation != _dbus_current_generation)
{
- if (!_dbus_string_init (&u.name, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&u.name))
{
_DBUS_UNLOCK (user_info);
return FALSE;
}
- if (!_dbus_string_init (&u.dir, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&u.dir))
{
_dbus_string_free (&u.name);
_DBUS_UNLOCK (user_info);
unsigned long *gid)
{
const char *group_c_str;
-
- _dbus_string_get_const_data (group_name, &group_c_str);
+
+ group_c_str = _dbus_string_get_const_data (group_name);
/* For now assuming that the getgrnam() and getgrgid() flavors
* always correspond to the pwnam flavors, if not we have
retval = FALSE;
- if (!_dbus_string_init (&username, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&username))
return FALSE;
if (!get_user_info (NULL, uid, &creds,
creds.gid < 0)
goto out;
- _dbus_string_get_const_data (&username, &username_c);
+ username_c = _dbus_string_get_const_data (&username);
#ifdef HAVE_GETGROUPLIST
{
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- _dbus_string_get_const_data (filename, &filename_c);
+ filename_c = _dbus_string_get_const_data (filename);
/* O_BINARY useful on Cygwin */
fd = open (filename_c, O_RDONLY | O_BINARY);
retval = FALSE;
need_unlink = FALSE;
- if (!_dbus_string_init (&tmp_filename, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&tmp_filename))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return FALSE;
return FALSE;
}
- _dbus_string_get_const_data (filename, &filename_c);
- _dbus_string_get_const_data (&tmp_filename, &tmp_filename_c);
+ filename_c = _dbus_string_get_const_data (filename);
+ tmp_filename_c = _dbus_string_get_const_data (&tmp_filename);
fd = open (tmp_filename_c, O_WRONLY | O_BINARY | O_EXCL | O_CREAT,
0600);
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- _dbus_string_get_const_data (filename, &filename_c);
+ filename_c = _dbus_string_get_const_data (filename);
fd = open (filename_c, O_WRONLY | O_BINARY | O_EXCL | O_CREAT,
0600);
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- _dbus_string_get_const_data (filename, &filename_c);
+ filename_c = _dbus_string_get_const_data (filename);
if (unlink (filename_c) < 0)
{
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- _dbus_string_get_const_data (filename, &filename_c);
+ filename_c = _dbus_string_get_const_data (filename);
if (mkdir (filename_c, 0700) < 0)
{
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- _dbus_string_get_const_data (filename, &filename_c);
+ filename_c = _dbus_string_get_const_data (filename);
d = opendir (filename_c);
if (d == NULL)
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- _dbus_string_get_const_data (filename, &filename_c);
+ filename_c = _dbus_string_get_const_data (filename);
if (stat (filename_c, &sb) < 0)
{
return NULL;
}
- if (!_dbus_string_init (&address, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&address))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
if (unix_transport == NULL)
return NULL;
- if (!_dbus_string_init (&unix_transport->encoded_outgoing,
- _DBUS_INT_MAX))
+ if (!_dbus_string_init (&unix_transport->encoded_outgoing))
goto failed_0;
- if (!_dbus_string_init (&unix_transport->encoded_incoming,
- _DBUS_INT_MAX))
+ if (!_dbus_string_init (&unix_transport->encoded_incoming))
goto failed_1;
unix_transport->write_watch = _dbus_watch_new (fd,
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- if (!_dbus_string_init (&address, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&address))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- if (!_dbus_string_init (&address, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&address))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
DBusString *buffer;
int orig_len;
- if (!_dbus_string_init (&plaintext, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&plaintext))
goto nomem;
_dbus_auth_get_unused_bytes (transport->auth,
failed = FALSE;
- if (!_dbus_string_init (&filename, _DBUS_INT_MAX) ||
+ if (!_dbus_string_init (&filename) ||
!_dbus_string_copy (&failure_dir, 0,
&filename, 0) ||
!_dbus_string_append_byte (&filename, '/'))
if (failed)
{
- const char *filename_c;
DBusError error;
_dbus_string_append (&filename, ".message-raw");
- _dbus_string_get_const_data (&filename, &filename_c);
- printf ("Child failed, writing %s\n",
- filename_c);
+ printf ("Child failed, writing %s\n", _dbus_string_get_const_data (&filename));
dbus_error_init (&error);
if (!_dbus_string_save_to_file (data, &filename, &error))
if (_dbus_string_get_length (mutated) < 12)
return;
- _dbus_string_get_const_data (mutated, &d);
+ d = _dbus_string_get_const_data (mutated);
if (!(*d == DBUS_LITTLE_ENDIAN ||
*d == DBUS_BIG_ENDIAN))
if (_dbus_string_get_length (mutated) < 12)
return;
- _dbus_string_get_const_data (mutated, &d);
+ d = _dbus_string_get_const_data (mutated);
if (!(*d == DBUS_LITTLE_ENDIAN ||
*d == DBUS_BIG_ENDIAN))
dbus_bool_t retval;
int i;
- _dbus_string_get_const_data (filename, &filename_c);
+ filename_c = _dbus_string_get_const_data (filename);
retval = FALSE;
- if (!_dbus_string_init (&orig_data, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&orig_data))
_dbus_assert_not_reached ("could not allocate string\n");
- if (!_dbus_string_init (&mutated, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&mutated))
_dbus_assert_not_reached ("could not allocate string\n");
if (!dbus_internal_do_not_use_load_message_file (filename, is_raw,
seed = 0;
- if (!_dbus_string_init (&bytes, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&bytes))
exit (1);
fd = open ("/dev/urandom", O_RDONLY);
close (fd);
- _dbus_string_get_const_data (&bytes, &s);
+ s = _dbus_string_get_const_data (&bytes);
seed = * (unsigned int*) s;
goto out;
total_failures_found = 0;
total_attempts = 0;
- if (!_dbus_string_init (&failure_dir, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&failure_dir))
return 1;
/* so you can leave it overnight safely */
if (!_dbus_string_append_uint (&failure_dir, seed))
return 1;
- _dbus_string_get_const_data (&failure_dir, &failure_dir_c);
+ failure_dir_c = _dbus_string_get_const_data (&failure_dir);
if (mkdir (failure_dir_c, 0700) < 0)
{
_dbus_string_init_const (&filename, argv[1]);
- if (!_dbus_string_init (&contents, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&contents))
return 1;
- if (!_dbus_string_init (&decoded, _DBUS_INT_MAX))
+ if (!_dbus_string_init (&decoded))
return 1;
dbus_error_init (&error);
&decoded, 0))
return 1;
- _dbus_string_get_const_data (&decoded, &s);
+ s = _dbus_string_get_const_data (&decoded);
fputs (s, stdout);
projects / platform / upstream / dbus.git / commitdiff