dbus-address.c 10.6 KB
Newer Older
1 2 3 4 5
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-address.c  Server address parser.
 *
 * Copyright (C) 2003  CodeFactory AB
 *
6
 * Licensed under the Academic Free License version 2.0
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
 * 
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include <config.h>
#include "dbus-address.h"
#include "dbus-internals.h"
#include "dbus-list.h"
28
#include "dbus-string.h"
29 30

/**
31 32 33
 * @defgroup DBusAddressInternals Address parsing
 * @ingroup  DBusInternals
 * @brief Implementation of parsing addresses of D-BUS servers.
34 35 36
 *
 * @{
 */
37 38 39 40

/**
 * Internals of DBusAddressEntry 
 */
41 42
struct DBusAddressEntry
{
43
  DBusString method; /**< The address type (unix, tcp, etc.) */
44

45 46
  DBusList *keys;    /**< List of keys */
  DBusList *values;  /**< List of values */
47 48
};

49 50
/** @} */ /* End of internals */

51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
static void
dbus_address_entry_free (DBusAddressEntry *entry)
{
  DBusList *link;
  
  _dbus_string_free (&entry->method);

  link = _dbus_list_get_first_link (&entry->keys);
  while (link != NULL)
    {
      _dbus_string_free (link->data);
      dbus_free (link->data);
      
      link = _dbus_list_get_next_link (&entry->keys, link);
    }
66 67
  _dbus_list_clear (&entry->keys);
  
68 69 70 71 72 73 74 75
  link = _dbus_list_get_first_link (&entry->values);
  while (link != NULL)
    {
      _dbus_string_free (link->data);
      dbus_free (link->data);
      
      link = _dbus_list_get_next_link (&entry->values, link);
    }
76
  _dbus_list_clear (&entry->values);
77 78 79 80
  
  dbus_free (entry);
}

81 82 83 84 85 86 87
/**
 * @defgroup DBusAddress Address parsing
 * @ingroup  DBus
 * @brief Parsing addresses of D-BUS servers.
 *
 * @{
 */
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113

/**
 * Frees a #NULL-terminated array of address entries.
 *
 * @param entries the array.
 */
void
dbus_address_entries_free (DBusAddressEntry **entries)
{
  int i;
  
  for (i = 0; entries[i] != NULL; i++)
    dbus_address_entry_free (entries[i]);
  dbus_free (entries);
}

static DBusAddressEntry *
create_entry (void)
{
  DBusAddressEntry *entry;

  entry = dbus_new0 (DBusAddressEntry, 1);

  if (entry == NULL)
    return NULL;

114
  if (!_dbus_string_init (&entry->method))
115 116 117 118
    {
      dbus_free (entry);
      return NULL;
    }
119 120 121 122 123 124 125 126 127 128 129 130 131 132

  return entry;
}

/**
 * Returns the method string of an address entry.
 *
 * @param entry the entry.
 * @returns a string describing the method. This string
 * must not be freed.
 */
const char *
dbus_address_entry_get_method (DBusAddressEntry *entry)
{
133
  return _dbus_string_get_const_data (&entry->method);
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
}

/**
 * Returns a value from a key of an entry.
 *
 * @param entry the entry.
 * @param key the key.
 * @returns the key value. This string must not be fred.
 */
const char *
dbus_address_entry_get_value (DBusAddressEntry *entry,
			      const char       *key)
{
  DBusList *values, *keys;

  keys = _dbus_list_get_first_link (&entry->keys);
  values = _dbus_list_get_first_link (&entry->values);

  while (keys != NULL)
    {
      _dbus_assert (values != NULL);

      if (_dbus_string_equal_c_str (keys->data, key))
157
        return _dbus_string_get_const_data (values->data);
158 159 160 161 162 163 164 165 166 167 168 169 170

      keys = _dbus_list_get_next_link (&entry->keys, keys);
      values = _dbus_list_get_next_link (&entry->values, values);
    }
  
  return NULL;
}

/**
 * Parses an address string of the form:
 *
 * method:key=value,key=value;method:key=value
 *
171 172 173 174 175
 * @todo document address format in the specification
 *
 * @todo need to be able to escape ';' and ',' in the
 * key values, and the parsing needs to handle that.
 * 
176 177 178
 * @param address the address.
 * @param entry return location to an array of entries.
 * @param array_len return location for array length.
179
 * @param error address where an error can be returned.
180 181 182 183 184 185
 * @returns #TRUE on success, #FALSE otherwise.
 */
dbus_bool_t
dbus_parse_address (const char         *address,
		    DBusAddressEntry ***entry,
		    int                *array_len,
186
                    DBusError          *error)
187 188 189 190 191 192
{
  DBusString str;
  int pos, end_pos, len, i;
  DBusList *entries, *link;
  DBusAddressEntry **entry_array;

193 194
  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
  _dbus_string_init_const (&str, address);

  entries = NULL;
  pos = 0;
  len = _dbus_string_get_length (&str);
  
  while (pos < len)
    {
      DBusAddressEntry *entry;

      int found_pos;

      entry = create_entry ();
      if (!entry)
	{
210
	  dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
211 212 213 214 215 216 217

	  goto error;
	}
      
      /* Append the entry */
      if (!_dbus_list_append (&entries, entry))
	{
218
	  dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
219 220 221 222 223 224 225 226 227 228 229
	  dbus_address_entry_free (entry);
	  goto error;
	}
      
      /* Look for a semi-colon */
      if (!_dbus_string_find (&str, pos, ";", &end_pos))
	end_pos = len;
      
      /* Look for the colon : */
      if (!_dbus_string_find_to (&str, pos, end_pos, ":", &found_pos))
	{
230
	  dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS, "Address does not contain a colon");
231 232 233 234 235
	  goto error;
	}

      if (!_dbus_string_copy_len (&str, pos, found_pos - pos, &entry->method, 0))
	{
236
	  dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
237 238 239 240 241 242 243 244 245 246 247 248
	  goto error;
	}
	  
      pos = found_pos + 1;

      while (pos < end_pos)
	{
	  int comma_pos, equals_pos;

	  if (!_dbus_string_find_to (&str, pos, end_pos, ",", &comma_pos))
	    comma_pos = end_pos;
	  
249 250
	  if (!_dbus_string_find_to (&str, pos, comma_pos, "=", &equals_pos) ||
	      equals_pos == pos || equals_pos + 1 == comma_pos)
251
	    {
252 253 254
	      dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
                              "'=' character not found or has no value following it");
              goto error;
255 256 257 258 259 260 261 262 263 264
	    }
	  else
	    {
	      DBusString *key;
	      DBusString *value;

	      key = dbus_new0 (DBusString, 1);

	      if (!key)
		{
265
		  dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);		  
266 267 268 269 270 271
		  goto error;
		}

	      value = dbus_new0 (DBusString, 1);
	      if (!value)
		{
272
		  dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
273 274 275 276
		  dbus_free (key);
		  goto error;
		}
	      
277
	      if (!_dbus_string_init (key))
278
		{
279
		  dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
280 281 282 283 284 285
		  dbus_free (key);
		  dbus_free (value);
		  
		  goto error;
		}
	      
286
	      if (!_dbus_string_init (value))
287
		{
288
		  dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
289 290 291 292 293 294 295 296 297
		  _dbus_string_free (key);

		  dbus_free (key);
		  dbus_free (value);		  
		  goto error;
		}

	      if (!_dbus_string_copy_len (&str, pos, equals_pos - pos, key, 0))
		{
298
		  dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
299 300 301 302 303 304 305 306 307 308
		  _dbus_string_free (key);
		  _dbus_string_free (value);

		  dbus_free (key);
		  dbus_free (value);		  
		  goto error;
		}

	      if (!_dbus_string_copy_len (&str, equals_pos + 1, comma_pos - equals_pos - 1, value, 0))
		{
309
		  dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);		  
310 311 312 313 314 315 316 317 318 319
		  _dbus_string_free (key);
		  _dbus_string_free (value);

		  dbus_free (key);
		  dbus_free (value);		  
		  goto error;
		}

	      if (!_dbus_list_append (&entry->keys, key))
		{
320
		  dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);		  
321 322 323 324 325 326 327 328 329 330
		  _dbus_string_free (key);
		  _dbus_string_free (value);

		  dbus_free (key);
		  dbus_free (value);		  
		  goto error;
		}

	      if (!_dbus_list_append (&entry->values, value))
		{
331
		  dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);		  
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
		  _dbus_string_free (value);

		  dbus_free (value);
		  goto error;		  
		}
	    }

	  pos = comma_pos + 1;
	}

      pos = end_pos + 1;
    }

  *array_len = _dbus_list_get_length (&entries);
  
  entry_array = dbus_new (DBusAddressEntry *, *array_len + 1);

  if (!entry_array)
    {
351
      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
      
      goto error;
    }
  
  entry_array [*array_len] = NULL;

  link = _dbus_list_get_first_link (&entries);
  i = 0;
  while (link != NULL)
    {
      entry_array[i] = link->data;
      i++;
      link = _dbus_list_get_next_link (&entries, link);
    }

  _dbus_list_clear (&entries);
  *entry = entry_array;

  return TRUE;

 error:
  
  link = _dbus_list_get_first_link (&entries);
  while (link != NULL)
    {
      dbus_address_entry_free (link->data);
      link = _dbus_list_get_next_link (&entries, link);
    }

381 382
  _dbus_list_clear (&entries);
  
383 384 385 386 387
  return FALSE;
  
}


388
/** @} */ /* End of public API */
389 390 391 392 393 394 395 396 397

#ifdef DBUS_BUILD_TESTS
#include "dbus-test.h"

dbus_bool_t
_dbus_address_test (void)
{
  DBusAddressEntry **entries;
  int len;  
398
  DBusError error;
399

400 401
  dbus_error_init (&error);
  
402
  if (!dbus_parse_address ("unix:path=/tmp/foo;debug:name=test,sliff=sloff;",
403
			   &entries, &len, &error))
404 405 406 407 408 409 410 411 412
    _dbus_assert_not_reached ("could not parse address");
  _dbus_assert (len == 2);
  _dbus_assert (strcmp (dbus_address_entry_get_value (entries[0], "path"), "/tmp/foo") == 0);
  _dbus_assert (strcmp (dbus_address_entry_get_value (entries[1], "name"), "test") == 0);
  _dbus_assert (strcmp (dbus_address_entry_get_value (entries[1], "sliff"), "sloff") == 0);
  
  dbus_address_entries_free (entries);

  /* Different possible errors */
413
  if (dbus_parse_address ("foo", &entries, &len, &error))
414
    _dbus_assert_not_reached ("Parsed incorrect address.");
415 416 417 418
  else
    dbus_error_free (&error);
  
  if (dbus_parse_address ("foo:bar", &entries, &len, &error))
419
    _dbus_assert_not_reached ("Parsed incorrect address.");
420 421 422 423
  else
    dbus_error_free (&error);
  
  if (dbus_parse_address ("foo:bar,baz", &entries, &len, &error))
424
    _dbus_assert_not_reached ("Parsed incorrect address.");
425 426 427 428
  else
    dbus_error_free (&error);
  
  if (dbus_parse_address ("foo:bar=foo,baz", &entries, &len, &error))
429
    _dbus_assert_not_reached ("Parsed incorrect address.");
430 431 432 433
  else
    dbus_error_free (&error);
  
  if (dbus_parse_address ("foo:bar=foo;baz", &entries, &len, &error))
434
    _dbus_assert_not_reached ("Parsed incorrect address.");
435 436 437 438
  else
    dbus_error_free (&error);
  
  if (dbus_parse_address ("foo:=foo", &entries, &len, &error))
439
    _dbus_assert_not_reached ("Parsed incorrect address.");
440 441 442 443
  else
    dbus_error_free (&error);
  
  if (dbus_parse_address ("foo:foo=", &entries, &len, &error))
444
    _dbus_assert_not_reached ("Parsed incorrect address.");
445 446
  else
    dbus_error_free (&error);
447 448 449 450 451 452

  if (dbus_parse_address ("foo:foo,bar=baz", &entries, &len, &error))
    _dbus_assert_not_reached ("Parsed incorrect address.");
  else
    dbus_error_free (&error);

453 454 455 456
  return TRUE;
}

#endif