src/hello/hello.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file hello/hello.c
  23  * @brief helper library for handling HELLOs
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_hello_lib.h"
  28 #include "gnunet_protocols.h"
  29 #include "gnunet_util_lib.h"
  30 #include "gnunet_transport_plugin.h"
  31
  32 GNUNET_NETWORK_STRUCT_BEGIN
  33
  34 /**
  35  * A HELLO message is used to exchange information about
  36  * transports with other peers.  This struct is always
  37  * followed by the actual network addresses which have
  38  * the format:
  39  *
  40  * 1) transport-name (0-terminated)
  41  * 2) address-length (uint16_t, network byte order; possibly
  42  *    unaligned!)
  43  * 3) address expiration (`struct GNUNET_TIME_AbsoluteNBO`); possibly
  44  *    unaligned!)
  45  * 4) address (address-length bytes; possibly unaligned!)
  46  */
  47 struct GNUNET_HELLO_Message
  48 {
  49   /**
  50    * Type will be #GNUNET_MESSAGE_TYPE_HELLO.
  51    */
  52   struct GNUNET_MessageHeader header;
  53
  54   /**
  55    * Use in F2F mode: Do not gossip this HELLO message
  56    */
  57   uint32_t friend_only GNUNET_PACKED;
  58
  59   /**
  60    * The public key of the peer.
  61    */
  62   struct GNUNET_CRYPTO_EccPublicSignKey publicKey;
  63
  64 };
  65 GNUNET_NETWORK_STRUCT_END
  66
  67
  68 /**
  69  * Context used for building our own URI.
  70  */
  71 struct GNUNET_HELLO_ComposeUriContext
  72 {
  73   /**
  74    * Final URI.
  75    */
  76   char *uri;
  77
  78   /**
  79    * Function for finding transport plugins by name.
  80    */
  81   GNUNET_HELLO_TransportPluginsFind plugins_find;
  82 };
  83
  84
  85 /**
  86  * Context for 'add_address_to_hello'.
  87  */
  88 struct GNUNET_HELLO_ParseUriContext
  89 {
  90   /**
  91    * Position in the URI with the next address to parse.
  92    */
  93   const char *pos;
  94
  95   /**
  96    * Set to #GNUNET_SYSERR to indicate parse errors.
  97    */
  98   int ret;
  99
 100   /**
 101    * Function for finding transport plugins by name.
 102    */
 103   GNUNET_HELLO_TransportPluginsFind plugins_find;
 104 };
 105
 106
 107 /** Return HELLO type
 108  *
 109  * @param h HELLO Message to test
 110  * @return #GNUNET_YES or #GNUNET_NO
 111  */
 112 int
 113 GNUNET_HELLO_is_friend_only (const struct GNUNET_HELLO_Message *h)
 114 {
 115   if (GNUNET_YES == ntohl(h->friend_only))
 116         return GNUNET_YES;
 117   return GNUNET_NO;
 118 }
 119
 120
 121
 122 /**
 123  * Copy the given address information into
 124  * the given buffer using the format of HELLOs.
 125  *
 126  * @param address the address
 127  * @param expiration expiration for the @a address
 128  * @param target where to copy the @a address
 129  * @param max maximum number of bytes to copy to target
 130  * @return number of bytes copied, 0 if
 131  *         the target buffer was not big enough.
 132  */
 133 size_t
 134 GNUNET_HELLO_add_address (const struct GNUNET_HELLO_Address *address,
 135                           struct GNUNET_TIME_Absolute expiration, char *target,
 136                           size_t max)
 137 {
 138   uint16_t alen;
 139   size_t slen;
 140   struct GNUNET_TIME_AbsoluteNBO exp;
 141
 142   slen = strlen (address->transport_name) + 1;
 143   if (slen + sizeof (uint16_t) + sizeof (struct GNUNET_TIME_AbsoluteNBO) +
 144       address->address_length > max)
 145     return 0;
 146   exp = GNUNET_TIME_absolute_hton (expiration);
 147   alen = htons ((uint16_t) address->address_length);
 148   memcpy (target, address->transport_name, slen);
 149   memcpy (&target[slen], &alen, sizeof (uint16_t));
 150   slen += sizeof (uint16_t);
 151   memcpy (&target[slen], &exp, sizeof (struct GNUNET_TIME_AbsoluteNBO));
 152   slen += sizeof (struct GNUNET_TIME_AbsoluteNBO);
 153   memcpy (&target[slen], address->address, address->address_length);
 154   slen += address->address_length;
 155   return slen;
 156 }
 157
 158
 159 /**
 160  * Get the size of an address entry in a HELLO message.
 161  *
 162  * @param buf pointer to the start of the address entry
 163  * @param max maximum size of the entry (end of buf)
 164  * @param ralen set to the address length
 165  * @return size of the entry, or 0 if max is not large enough
 166  */
 167 static size_t
 168 get_hello_address_size (const char *buf,
 169                         size_t max,
 170                         uint16_t *ralen)
 171 {
 172   const char *pos;
 173   uint16_t alen;
 174   size_t left;
 175   size_t slen;
 176
 177   left = max;
 178   pos = buf;
 179   slen = 1;
 180   while ((left > 0) && ('\0' != *pos))
 181   {
 182     left--;
 183     pos++;
 184     slen++;
 185   }
 186   if (left == 0)
 187   {
 188     /* 0-termination not found */
 189     GNUNET_break_op (0);
 190     return 0;
 191   }
 192   pos++;
 193   if (left < sizeof (uint16_t) + sizeof (struct GNUNET_TIME_AbsoluteNBO))
 194   {
 195     /* not enough space for addrlen */
 196     GNUNET_break_op (0);
 197     return 0;
 198   }
 199   memcpy (&alen, pos, sizeof (uint16_t));
 200   alen = ntohs (alen);
 201   *ralen = alen;
 202   slen += alen + sizeof (uint16_t) + sizeof (struct GNUNET_TIME_AbsoluteNBO);
 203   if (max < slen)
 204   {
 205     /* not enough space for addr */
 206     GNUNET_break_op (0);
 207     return 0;
 208   }
 209   return slen;
 210 }
 211
 212
 213 /**
 214  * Construct a HELLO message given the public key,
 215  * expiration time and an iterator that spews the
 216  * transport addresses.
 217  *
 218  * @return the hello message
 219  */
 220 struct GNUNET_HELLO_Message *
 221 GNUNET_HELLO_create (const struct GNUNET_CRYPTO_EccPublicSignKey *publicKey,
 222                      GNUNET_HELLO_GenerateAddressListCallback addrgen,
 223                      void *addrgen_cls,
 224                      int friend_only)
 225 {
 226   char buffer[GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - 256 -
 227               sizeof (struct GNUNET_HELLO_Message)];
 228   size_t max;
 229   size_t used;
 230   size_t ret;
 231   struct GNUNET_HELLO_Message *hello;
 232
 233   GNUNET_assert (NULL != publicKey);
 234   GNUNET_assert ((GNUNET_YES == friend_only) || (GNUNET_NO == friend_only));
 235
 236   max = sizeof (buffer);
 237   used = 0;
 238   if (addrgen != NULL)
 239   {
 240     while (0 != (ret = addrgen (addrgen_cls, max, &buffer[used])))
 241     {
 242       max -= ret;
 243       used += ret;
 244     }
 245   }
 246   hello = GNUNET_malloc (sizeof (struct GNUNET_HELLO_Message) + used);
 247   hello->header.type = htons (GNUNET_MESSAGE_TYPE_HELLO);
 248   hello->header.size = htons (sizeof (struct GNUNET_HELLO_Message) + used);
 249   hello->friend_only = htonl (friend_only);
 250
 251   memcpy (&hello->publicKey, publicKey,
 252           sizeof (struct GNUNET_CRYPTO_EccPublicSignKey));
 253   memcpy (&hello[1], buffer, used);
 254   return hello;
 255 }
 256
 257
 258 /**
 259  * Iterate over all of the addresses in the HELLO.
 260  *
 261  * @param msg HELLO to iterate over
 262  * @param return_modified if a modified copy should be returned,
 263  *         otherwise NULL will be returned
 264  * @param it iterator to call on each address
 265  * @param it_cls closure for @a it
 266  * @return modified HELLO message
 267  */
 268 struct GNUNET_HELLO_Message *
 269 GNUNET_HELLO_iterate_addresses (const struct GNUNET_HELLO_Message *msg,
 270                                 int return_modified,
 271                                 GNUNET_HELLO_AddressIterator it, void *it_cls)
 272 {
 273   struct GNUNET_HELLO_Address address;
 274   uint16_t msize;
 275   struct GNUNET_HELLO_Message *ret;
 276   const char *inptr;
 277   size_t insize;
 278   size_t esize;
 279   size_t wpos;
 280   char *woff;
 281   uint16_t alen;
 282   struct GNUNET_TIME_AbsoluteNBO expire;
 283   int iret;
 284
 285   msize = GNUNET_HELLO_size (msg);
 286   if ((msize < sizeof (struct GNUNET_HELLO_Message)) ||
 287       (ntohs (msg->header.type) != GNUNET_MESSAGE_TYPE_HELLO))
 288     return NULL;
 289   ret = NULL;
 290   if (return_modified)
 291   {
 292     ret = GNUNET_malloc (msize);
 293     memcpy (ret, msg, msize);
 294   }
 295   inptr = (const char *) &msg[1];
 296   insize = msize - sizeof (struct GNUNET_HELLO_Message);
 297   wpos = 0;
 298   woff = (ret != NULL) ? (char *) &ret[1] : NULL;
 299   address.peer.public_key = msg->publicKey;
 300   while (insize > 0)
 301   {
 302     esize = get_hello_address_size (inptr, insize, &alen);
 303     if (esize == 0)
 304     {
 305       GNUNET_break (0);
 306       GNUNET_free_non_null (ret);
 307       return NULL;
 308     }
 309     memcpy (&expire,
 310             &inptr[esize - alen - sizeof (struct GNUNET_TIME_AbsoluteNBO)],
 311             sizeof (struct GNUNET_TIME_AbsoluteNBO));
 312     address.address = &inptr[esize - alen];
 313     address.address_length = alen;
 314     address.transport_name = inptr;
 315     iret = it (it_cls, &address, GNUNET_TIME_absolute_ntoh (expire));
 316     if (iret == GNUNET_SYSERR)
 317     {
 318       if (ret != NULL)
 319         ret->header.size = ntohs (sizeof (struct GNUNET_HELLO_Message) + wpos);
 320       return ret;
 321     }
 322     if ((iret == GNUNET_OK) && (ret != NULL))
 323     {
 324       memcpy (woff, inptr, esize);
 325       woff += esize;
 326       wpos += esize;
 327     }
 328     insize -= esize;
 329     inptr += esize;
 330   }
 331   if (ret != NULL)
 332     ret->header.size = ntohs (sizeof (struct GNUNET_HELLO_Message) + wpos);
 333   return ret;
 334 }
 335
 336
 337 struct ExpireContext
 338 {
 339   const struct GNUNET_HELLO_Address *address;
 340   int found;
 341   struct GNUNET_TIME_Absolute expiration;
 342 };
 343
 344
 345 static int
 346 get_match_exp (void *cls, const struct GNUNET_HELLO_Address *address,
 347                struct GNUNET_TIME_Absolute expiration)
 348 {
 349   struct ExpireContext *ec = cls;
 350
 351   if (0 == GNUNET_HELLO_address_cmp (address, ec->address))
 352   {
 353     ec->found = GNUNET_YES;
 354     ec->expiration = expiration;
 355     return GNUNET_SYSERR;       /* done here */
 356   }
 357   return GNUNET_OK;
 358 }
 359
 360
 361 struct MergeContext
 362 {
 363   const struct GNUNET_HELLO_Message *h1;
 364   const struct GNUNET_HELLO_Message *h2;
 365   const struct GNUNET_HELLO_Message *other;
 366   char *buf;
 367   size_t max;
 368   size_t ret;
 369   int take_equal;
 370
 371 };
 372
 373
 374 static int
 375 copy_latest (void *cls, const struct GNUNET_HELLO_Address *address,
 376              struct GNUNET_TIME_Absolute expiration)
 377 {
 378   struct MergeContext *mc = cls;
 379   struct ExpireContext ec;
 380
 381   ec.address = address;
 382   ec.found = GNUNET_NO;
 383   GNUNET_HELLO_iterate_addresses (mc->other, GNUNET_NO, &get_match_exp, &ec);
 384   if ((ec.found == GNUNET_NO) ||
 385       (ec.expiration.abs_value_us < expiration.abs_value_us) ||
 386       ((ec.expiration.abs_value_us == expiration.abs_value_us) &&
 387        (mc->take_equal == GNUNET_YES)))
 388   {
 389     mc->ret +=
 390         GNUNET_HELLO_add_address (address, expiration, &mc->buf[mc->ret],
 391                                   mc->max - mc->ret);
 392   }
 393   return GNUNET_OK;
 394 }
 395
 396
 397 static size_t
 398 merge_addr (void *cls, size_t max, void *buf)
 399 {
 400   struct MergeContext *mc = cls;
 401
 402   if (mc->h1 == NULL)
 403     return 0;
 404   mc->ret = 0;
 405   mc->max = max;
 406   mc->buf = buf;
 407   mc->take_equal = GNUNET_NO;
 408   mc->other = mc->h2;
 409   GNUNET_HELLO_iterate_addresses (mc->h1, GNUNET_NO, &copy_latest, mc);
 410   mc->take_equal = GNUNET_YES;
 411   mc->other = mc->h1;
 412   GNUNET_HELLO_iterate_addresses (mc->h2, GNUNET_NO, &copy_latest, mc);
 413   mc->h1 = NULL;
 414   return mc->ret;
 415 }
 416
 417
 418 /**
 419  * Construct a HELLO message by merging the
 420  * addresses in two existing HELLOs (which
 421  * must be for the same peer).
 422  *
 423  * @param h1 first HELLO message
 424  * @param h2 the second HELLO message
 425  * @return the combined hello message
 426  */
 427 struct GNUNET_HELLO_Message *
 428 GNUNET_HELLO_merge (const struct GNUNET_HELLO_Message *h1,
 429                     const struct GNUNET_HELLO_Message *h2)
 430 {
 431   struct MergeContext mc = { h1, h2, NULL, NULL, 0, 0, 0 };
 432   int friend_only;
 433
 434   if (h1->friend_only != h2->friend_only)
 435         friend_only = GNUNET_YES; /* One of the HELLOs is friend only */
 436   else
 437         friend_only = ntohl (h1->friend_only); /* Both HELLO's have the same type */
 438
 439         return GNUNET_HELLO_create (&h1->publicKey, &merge_addr, &mc, friend_only);
 440 }
 441
 442
 443 struct DeltaContext
 444 {
 445   struct GNUNET_TIME_Absolute expiration_limit;
 446
 447   GNUNET_HELLO_AddressIterator it;
 448
 449   void *it_cls;
 450
 451   const struct GNUNET_HELLO_Message *old_hello;
 452 };
 453
 454
 455 static int
 456 delta_match (void *cls, const struct GNUNET_HELLO_Address *address,
 457              struct GNUNET_TIME_Absolute expiration)
 458 {
 459   struct DeltaContext *dc = cls;
 460   int ret;
 461   struct ExpireContext ec;
 462
 463   ec.address = address;
 464   ec.found = GNUNET_NO;
 465   GNUNET_HELLO_iterate_addresses (dc->old_hello, GNUNET_NO, &get_match_exp,
 466                                   &ec);
 467   if ((ec.found == GNUNET_YES) &&
 468       ((ec.expiration.abs_value_us > expiration.abs_value_us) ||
 469        (ec.expiration.abs_value_us >= dc->expiration_limit.abs_value_us)))
 470     return GNUNET_YES;          /* skip */
 471   ret = dc->it (dc->it_cls, address, expiration);
 472   return ret;
 473 }
 474
 475
 476 /**
 477  * Iterate over addresses in "new_hello" that
 478  * are NOT already present in "old_hello".
 479  *
 480  * @param new_hello a HELLO message
 481  * @param old_hello a HELLO message
 482  * @param expiration_limit ignore addresses in old_hello
 483  *        that expired before the given time stamp
 484  * @param it iterator to call on each address
 485  * @param it_cls closure for it
 486  */
 487 void
 488 GNUNET_HELLO_iterate_new_addresses (const struct GNUNET_HELLO_Message
 489                                     *new_hello,
 490                                     const struct GNUNET_HELLO_Message
 491                                     *old_hello,
 492                                     struct GNUNET_TIME_Absolute
 493                                     expiration_limit,
 494                                     GNUNET_HELLO_AddressIterator it,
 495                                     void *it_cls)
 496 {
 497   struct DeltaContext dc;
 498
 499   dc.expiration_limit = expiration_limit;
 500   dc.it = it;
 501   dc.it_cls = it_cls;
 502   dc.old_hello = old_hello;
 503   GNUNET_HELLO_iterate_addresses (new_hello, GNUNET_NO, &delta_match, &dc);
 504 }
 505
 506
 507 /**
 508  * Return the size of the given HELLO message.
 509  * @param hello to inspect
 510  * @return the size, 0 if HELLO is invalid
 511  */
 512 uint16_t
 513 GNUNET_HELLO_size (const struct GNUNET_HELLO_Message *hello)
 514 {
 515   uint16_t ret = ntohs (hello->header.size);
 516
 517   if ((ret < sizeof (struct GNUNET_HELLO_Message)) ||
 518       (ntohs (hello->header.type) != GNUNET_MESSAGE_TYPE_HELLO))
 519     return 0;
 520   return ret;
 521 }
 522
 523
 524 /**
 525  * Get the public key from a HELLO message.
 526  *
 527  * @param hello the hello message
 528  * @param publicKey where to copy the public key information, can be NULL
 529  * @return GNUNET_SYSERR if the HELLO was malformed
 530  */
 531 int
 532 GNUNET_HELLO_get_key (const struct GNUNET_HELLO_Message *hello,
 533                       struct GNUNET_CRYPTO_EccPublicSignKey *publicKey)
 534 {
 535   uint16_t ret = ntohs (hello->header.size);
 536
 537   if ((ret < sizeof (struct GNUNET_HELLO_Message)) ||
 538       (ntohs (hello->header.type) != GNUNET_MESSAGE_TYPE_HELLO))
 539     return GNUNET_SYSERR;
 540   *publicKey = hello->publicKey;
 541   return GNUNET_OK;
 542 }
 543
 544
 545 /**
 546  * Get the peer identity from a HELLO message.
 547  *
 548  * @param hello the hello message
 549  * @param peer where to store the peer's identity
 550  * @return #GNUNET_SYSERR if the HELLO was malformed
 551  */
 552 int
 553 GNUNET_HELLO_get_id (const struct GNUNET_HELLO_Message *hello,
 554                      struct GNUNET_PeerIdentity *peer)
 555 {
 556   uint16_t ret = ntohs (hello->header.size);
 557
 558   if ((ret < sizeof (struct GNUNET_HELLO_Message)) ||
 559       (ntohs (hello->header.type) != GNUNET_MESSAGE_TYPE_HELLO))
 560     return GNUNET_SYSERR;
 561   peer->public_key = hello->publicKey;
 562   return GNUNET_OK;
 563 }
 564
 565
 566 /**
 567  * Get the header from a HELLO message, used so other code
 568  * can correctly send HELLO messages.
 569  *
 570  * @param hello the hello message
 571  *
 572  * @return header or NULL if the HELLO was malformed
 573  */
 574 struct GNUNET_MessageHeader *
 575 GNUNET_HELLO_get_header (struct GNUNET_HELLO_Message *hello)
 576 {
 577   uint16_t ret = ntohs (hello->header.size);
 578
 579   if ((ret < sizeof (struct GNUNET_HELLO_Message)) ||
 580       (ntohs (hello->header.type) != GNUNET_MESSAGE_TYPE_HELLO))
 581     return NULL;
 582
 583   return &hello->header;
 584 }
 585
 586
 587 struct EqualsContext
 588 {
 589   struct GNUNET_TIME_Absolute expiration_limit;
 590
 591   struct GNUNET_TIME_Absolute result;
 592
 593   const struct GNUNET_HELLO_Message *h2;
 594
 595   const struct GNUNET_HELLO_Address *address;
 596
 597   struct GNUNET_TIME_Absolute expiration;
 598
 599   int found;
 600
 601 };
 602
 603
 604 static int
 605 find_other_matching (void *cls, const struct GNUNET_HELLO_Address *address,
 606                      struct GNUNET_TIME_Absolute expiration)
 607 {
 608   struct EqualsContext *ec = cls;
 609
 610   if (expiration.abs_value_us < ec->expiration_limit.abs_value_us)
 611     return GNUNET_YES;
 612   if (0 == GNUNET_HELLO_address_cmp (address, ec->address))
 613   {
 614     ec->found = GNUNET_YES;
 615     if (expiration.abs_value_us < ec->expiration.abs_value_us)
 616       ec->result = GNUNET_TIME_absolute_min (expiration, ec->result);
 617     return GNUNET_SYSERR;
 618   }
 619   return GNUNET_YES;
 620 }
 621
 622
 623 static int
 624 find_matching (void *cls, const struct GNUNET_HELLO_Address *address,
 625                struct GNUNET_TIME_Absolute expiration)
 626 {
 627   struct EqualsContext *ec = cls;
 628
 629   if (expiration.abs_value_us < ec->expiration_limit.abs_value_us)
 630     return GNUNET_YES;
 631   ec->address = address;
 632   ec->expiration = expiration;
 633   ec->found = GNUNET_NO;
 634   GNUNET_HELLO_iterate_addresses (ec->h2, GNUNET_NO, &find_other_matching, ec);
 635   if (ec->found == GNUNET_NO)
 636   {
 637     ec->result = GNUNET_TIME_UNIT_ZERO_ABS;
 638     return GNUNET_SYSERR;
 639   }
 640   return GNUNET_OK;
 641 }
 642
 643
 644 /**
 645  * Test if two HELLO messages contain the same addresses.
 646  * If they only differ in expiration time, the lowest
 647  * expiration time larger than 'now' where they differ
 648  * is returned.
 649  *
 650  * @param h1 first HELLO message
 651  * @param h2 the second HELLO message
 652  * @param now time to use for deciding which addresses have
 653  *            expired and should not be considered at all
 654  * @return absolute time forever if the two HELLOs are
 655  *         totally identical; smallest timestamp >= now if
 656  *         they only differ in timestamps;
 657  *         zero if the some addresses with expirations >= now
 658  *         do not match at all
 659  */
 660 struct GNUNET_TIME_Absolute
 661 GNUNET_HELLO_equals (const struct GNUNET_HELLO_Message *h1,
 662                      const struct GNUNET_HELLO_Message *h2,
 663                      struct GNUNET_TIME_Absolute now)
 664 {
 665   struct EqualsContext ec;
 666
 667   if (h1->header.type != h2->header.type)
 668         return GNUNET_TIME_UNIT_ZERO_ABS;
 669
 670   if (0 !=
 671       memcmp (&h1->publicKey, &h2->publicKey,
 672               sizeof (struct GNUNET_CRYPTO_EccPublicSignKey)))
 673     return GNUNET_TIME_UNIT_ZERO_ABS;
 674   ec.expiration_limit = now;
 675   ec.result = GNUNET_TIME_UNIT_FOREVER_ABS;
 676   ec.h2 = h2;
 677   GNUNET_HELLO_iterate_addresses (h1, GNUNET_NO, &find_matching, &ec);
 678   if (ec.result.abs_value_us == GNUNET_TIME_UNIT_ZERO.rel_value_us)
 679     return ec.result;
 680   ec.h2 = h1;
 681   GNUNET_HELLO_iterate_addresses (h2, GNUNET_NO, &find_matching, &ec);
 682   return ec.result;
 683 }
 684
 685
 686 static int
 687 find_min_expire (void *cls, const struct GNUNET_HELLO_Address *address,
 688                  struct GNUNET_TIME_Absolute expiration)
 689 {
 690   struct GNUNET_TIME_Absolute *min = cls;
 691
 692   *min = GNUNET_TIME_absolute_min (*min, expiration);
 693   return GNUNET_OK;
 694 }
 695
 696
 697 /**
 698  * When does the last address in the given HELLO expire?
 699  *
 700  * @param msg HELLO to inspect
 701  * @return time the last address expires, 0 if there are no addresses in the HELLO
 702  */
 703 struct GNUNET_TIME_Absolute
 704 GNUNET_HELLO_get_last_expiration (const struct GNUNET_HELLO_Message *msg)
 705 {
 706   struct GNUNET_TIME_Absolute ret;
 707
 708   ret.abs_value_us = 0;
 709   GNUNET_HELLO_iterate_addresses (msg, GNUNET_NO, &find_min_expire, &ret);
 710   return ret;
 711 }
 712
 713 /**
 714  * GNUnet URIs are of the general form "gnunet://MODULE/IDENTIFIER".
 715  * The specific structure of "IDENTIFIER" depends on the module and
 716  * maybe differenciated into additional subcategories if applicable.
 717  * This module only deals with hello identifiers (MODULE = "hello").
 718  * <p>
 719  *
 720  * The concrete URI format is:
 721  *
 722  * "gnunet://hello/PEER[!YYYYMMDDHHMMSS!<TYPE>!<ADDRESS>]...".
 723  * These URIs can be used to add a peer record to peerinfo service.
 724  * PEER is the string representation of peer's public key.
 725  * YYYYMMDDHHMMSS is the expiration date.
 726  * TYPE is a transport type.
 727  * ADDRESS is the address, its format depends upon the transport type.
 728  * The concrete transport types and corresponding address formats are:
 729  *
 730  * <ul><li>
 731  *
 732  * <TCP|UDP>!IPADDRESS
 733  * IPVDDRESS is either IPV4 .-delimited address in form of XXX.XXX.XXX.XXX:PPPPP
 734  * or IPV6 :-delimited address, but with '(' and ')' instead of '[' and ']' (RFC2396 advises against using square brackets in URIs):
 735  * (XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX):PPPPP
 736  * PPPPP is the port number. May be 0.
 737  *
 738  * </li><li>
 739  *
 740  * [add SMTP, HTTP and other addresses here]
 741  *
 742  * </li></ul>
 743  *
 744  * The encoding for hexadecimal values is defined in the crypto_hash.c
 745  * module in the gnunetutil library and discussed there.
 746  *
 747  * Examples:
 748  *
 749  * gnunet://hello/0430205UC7D56PTQK8NV05776671CNN44FK4TL6D0GQ35OMF8MEN4RNMKA5UF6AL3DQO8B1SC5AQF50SQ2MABIRU4HC8H2HAJKJ59JL1JVRJAK308F9GASRFLMGUBB5TQ5AKR94AS5T3MDG8B9O1EMPRKB0HVCG7T6QPP4CDJ913LAEHVJ2DI1TOBB15Q1JIT5ARBOD12U4SIGRFDV3Q7T66G4TBVSJJ90UQF1BG29TGJJKLGEIMSPHHKO544D6EALQ4F2K0416311JC22GVAD48R616I7VK03K7MP7N0RS2MBV1TE9JV8CK1LSQMR7KCDRTLDA6917UGA67DHTGHERIACCGQ54TGSR48RMSGS9BA5HLMOKASFC1I6V4TT09TUGCU8GNDHQF0JF3H7LPV59UL5I38QID040G000!20120302010059!TCP!192.168.0.1:2086!TCP!64.23.8.174:0
 750  * gnunet://hello/0430205UC7D56PTQK8NV05776671CNN44FK4TL6D0GQ35OMF8MEN4RNMKA5UF6AL3DQO8B1SC5AQF50SQ2MABIRU4HC8H2HAJKJ59JL1JVRJAK308F9GASRFLMGUBB5TQ5AKR94AS5T3MDG8B9O1EMPRKB0HVCG7T6QPP4CDJ913LAEHVJ2DI1TOBB15Q1JIT5ARBOD12U4SIGRFDV3Q7T66G4TBVSJJ90UQF1BG29TGJJKLGEIMSPHHKO544D6EALQ4F2K0416311JC22GVAD48R616I7VK03K7MP7N0RS2MBV1TE9JV8CK1LSQMR7KCDRTLDA6917UGA67DHTGHERIACCGQ54TGSR48RMSGS9BA5HLMOKASFC1I6V4TT09TUGCU8GNDHQF0JF3H7LPV59UL5I38QID040G000!20120302010059!TCP!(2001:db8:85a3:8d3:1319:8a2e:370:7348):2086
 751  *
 752  * <p>
 753  */
 754
 755
 756 /* ************************* Compose HELLO URI ************************** */
 757
 758
 759 /**
 760  * Replace all characters in the input 'in' according
 761  * to the mapping.  The mapping says to map each character
 762  * in 'oldchars' to the corresponding character (by offset)
 763  * in 'newchars'.
 764  *
 765  * @param in input string to remap
 766  * @param oldchars characters to replace
 767  * @param newchars replacement characters, must have same length as 'oldchars'
 768  * @return copy of string with replacement applied.
 769  */
 770 static char *
 771 map_characters (const char *in,
 772                 const char *oldchars,
 773                 const char *newchars)
 774 {
 775   char *ret;
 776   const char *off;
 777   size_t i;
 778
 779   GNUNET_assert (strlen (oldchars) == strlen (newchars));
 780   ret = GNUNET_strdup (in);
 781   i = 0;
 782   while (ret[i] != '\0')
 783   {
 784     off = strchr (oldchars, ret[i]);
 785     if (NULL != off)
 786       ret[i] = newchars[off - oldchars];
 787     i++;
 788   }
 789   return ret;
 790 }
 791
 792
 793 /**
 794  * Function that is called on each address of this peer.
 795  * Expands the corresponding URI string.
 796  *
 797  * @param cls the 'GNUNET_HELLO_GetUriContext'
 798  * @param address address to add
 799  * @param expiration expiration time for the address
 800  * @return GNUNET_OK (continue iteration).
 801  */
 802 static int
 803 add_address_to_uri (void *cls, const struct GNUNET_HELLO_Address *address,
 804                     struct GNUNET_TIME_Absolute expiration)
 805 {
 806   struct GNUNET_HELLO_ComposeUriContext *ctx = cls;
 807   struct GNUNET_TRANSPORT_PluginFunctions *papi;
 808   const char *addr;
 809   char *uri_addr;
 810   char *ret;
 811   char *addr_dup;
 812   char *pos;
 813   char tbuf[16] = "";
 814   char *client_str = "_client";
 815   struct tm *t;
 816   time_t seconds;
 817
 818   papi = ctx->plugins_find (address->transport_name);
 819   if (papi == NULL)
 820   {
 821     /* Not an error - we might just not have the right plugin. */
 822     return GNUNET_OK;
 823   }
 824   if (NULL == papi->address_to_string)
 825   {
 826     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 827                 "URI conversion not implemented for plugin `%s'\n",
 828                 address->transport_name);
 829     return GNUNET_OK;
 830   }
 831   addr = papi->address_to_string (papi->cls, address->address, address->address_length);
 832
 833   if ( (addr == NULL) || (strlen(addr) == 0) )
 834     return GNUNET_OK;
 835
 836   addr_dup = GNUNET_strdup (addr);
 837   if (NULL != (pos = strstr (addr_dup, "_server")))
 838         memcpy (pos, client_str, strlen(client_str)); /* Replace all server addresses with client addresses */
 839
 840    /* For URIs we use '(' and ')' instead of '[' and ']' as brackets are reserved
 841       characters in URIs */
 842   uri_addr = map_characters (addr_dup, "[]", "()");
 843   GNUNET_free (addr_dup);
 844   seconds = expiration.abs_value_us / 1000LL / 1000LL;
 845   t = gmtime (&seconds);
 846
 847   GNUNET_asprintf (&ret,
 848                    "%s!%s!%s!%s",
 849                    ctx->uri,
 850                    strftime (tbuf, sizeof (tbuf), "%Y%m%d%H%M%S", t) ? tbuf : "0",
 851                    address->transport_name,
 852                    uri_addr);
 853   GNUNET_free (uri_addr);
 854   GNUNET_free (ctx->uri);
 855   ctx->uri = ret;
 856   return GNUNET_OK;
 857 }
 858
 859
 860 /**
 861  * Compose a hello URI string from a hello message.
 862  *
 863  * @param hello Hello message
 864  * @param plugins_find Function to find transport plugins by name
 865  * @return Hello URI string
 866  */
 867 char *
 868 GNUNET_HELLO_compose_uri (const struct GNUNET_HELLO_Message *hello,
 869                           GNUNET_HELLO_TransportPluginsFind plugins_find)
 870 {
 871   struct GNUNET_HELLO_ComposeUriContext ctx;
 872   ctx.plugins_find = plugins_find;
 873
 874   char *pkey = GNUNET_CRYPTO_ecc_public_sign_key_to_string (&(hello->publicKey));
 875
 876   GNUNET_asprintf (&(ctx.uri),
 877                    "%s%s",
 878                    (GNUNET_YES == GNUNET_HELLO_is_friend_only (hello)) ? GNUNET_FRIEND_HELLO_URI_PREFIX : GNUNET_HELLO_URI_PREFIX,
 879                    pkey);
 880   GNUNET_free (pkey);
 881
 882   GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &add_address_to_uri, &ctx);
 883   return ctx.uri;
 884 }
 885
 886
 887 /* ************************* Parse HELLO URI ********************* */
 888
 889
 890 /**
 891  * We're building a HELLO.  Parse the next address from the
 892  * parsing context and append it.
 893  *
 894  * @param cls the 'struct GNUNET_HELLO_AddressParsingContext'
 895  * @param max number of bytes available for HELLO construction
 896  * @param buffer where to copy the next address (in binary format)
 897  * @return number of bytes added to buffer
 898  */
 899 static size_t
 900 add_address_to_hello (void *cls, size_t max, void *buffer)
 901 {
 902   struct GNUNET_HELLO_ParseUriContext *ctx = cls;
 903   const char *tname;
 904   const char *address;
 905   char *uri_address;
 906   char *plugin_address;
 907   const char *end;
 908   char *plugin_name;
 909   struct tm expiration_time;
 910   time_t expiration_seconds;
 911   struct GNUNET_TIME_Absolute expire;
 912   struct GNUNET_TRANSPORT_PluginFunctions *papi;
 913   void *addr;
 914   size_t addr_len;
 915   struct GNUNET_HELLO_Address haddr;
 916   size_t ret;
 917
 918   if (NULL == ctx->pos)
 919     return 0;
 920   if ('!' != ctx->pos[0])
 921   {
 922     ctx->ret = GNUNET_SYSERR;
 923     GNUNET_break (0);
 924     return 0;
 925   }
 926   ctx->pos++;
 927
 928   if ('0' == ctx->pos[0] && '!' == ctx->pos[1])
 929   {
 930     expire = GNUNET_TIME_UNIT_FOREVER_ABS;
 931     tname = ctx->pos + 1;
 932   }
 933   else
 934   {
 935     memset (&expiration_time, 0, sizeof (expiration_time));
 936     tname = strptime (ctx->pos,
 937                       "%Y%m%d%H%M%S",
 938                       &expiration_time);
 939     if (NULL == tname)
 940     {
 941       ctx->ret = GNUNET_SYSERR;
 942       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 943                   _("Failed to parse HELLO message: missing expiration time\n"));
 944       GNUNET_break (0);
 945       return 0;
 946     }
 947
 948     expiration_seconds = mktime (&expiration_time);
 949     if (expiration_seconds == (time_t) -1)
 950     {
 951       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 952                   _("Failed to parse HELLO message: invalid expiration time\n"));
 953       ctx->ret = GNUNET_SYSERR;
 954       GNUNET_break (0);
 955       return 0;
 956     }
 957     expire.abs_value_us = expiration_seconds * 1000LL * 1000LL;
 958   }
 959   if ('!' != tname[0])
 960   {
 961     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 962                 _("Failed to parse HELLO message: malformed\n"));
 963     ctx->ret = GNUNET_SYSERR;
 964     GNUNET_break (0);
 965     return 0;
 966   }
 967   tname++;
 968   address = strchr (tname, (int) '!');
 969   if (NULL == address)
 970   {
 971     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 972                 _("Failed to parse HELLO message: missing transport plugin\n"));
 973     ctx->ret = GNUNET_SYSERR;
 974     GNUNET_break (0);
 975     return 0;
 976   }
 977   address++;
 978   end = strchr (address, (int) '!');
 979   ctx->pos = end;
 980   plugin_name = GNUNET_strndup (tname, address - (tname+1));
 981   papi = ctx->plugins_find (plugin_name);
 982   if (NULL == papi)
 983   {
 984     /* Not an error - we might just not have the right plugin.
 985      * Skip this part, advance to the next one and recurse.
 986      * But only if this is not the end of string.
 987      */
 988     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 989                 _("Plugin `%s' not found\n"),
 990                 plugin_name);
 991     GNUNET_free (plugin_name);
 992     GNUNET_break (0);
 993     return 0;
 994   }
 995   if (NULL == papi->string_to_address)
 996   {
 997     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 998                 _("Plugin `%s' does not support URIs yet\n"),
 999                 plugin_name);
1000     GNUNET_free (plugin_name);
1001     GNUNET_break (0);
1002     return 0;
1003   }
1004   uri_address = GNUNET_strndup (address, end - address);
1005   /* For URIs we use '(' and ')' instead of '[' and ']' as brackets are reserved
1006      characters in URIs; need to convert back to '[]' for the plugin */
1007    plugin_address = map_characters (uri_address, "()", "[]");
1008   GNUNET_free (uri_address);
1009   if (GNUNET_OK !=
1010       papi->string_to_address (papi->cls,
1011                                plugin_address,
1012                                strlen (plugin_address) + 1,
1013                                &addr,
1014                                &addr_len))
1015   {
1016     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1017                 _("Failed to parse `%s' as an address for plugin `%s'\n"),
1018                 plugin_address,
1019                 plugin_name);
1020     GNUNET_free (plugin_name);
1021     GNUNET_free (plugin_address);
1022     return 0;
1023   }
1024   GNUNET_free (plugin_address);
1025   /* address.peer is unset - not used by add_address() */
1026   haddr.address_length = addr_len;
1027   haddr.address = addr;
1028   haddr.transport_name = plugin_name;
1029   ret = GNUNET_HELLO_add_address (&haddr, expire, buffer, max);
1030   GNUNET_free (addr);
1031   GNUNET_free (plugin_name);
1032   return ret;
1033 }
1034
1035
1036 /**
1037  * Parse a hello URI string to a hello message.
1038  *
1039  * @param uri URI string to parse
1040  * @param pubkey Pointer to struct where public key is parsed
1041  * @param hello Pointer to struct where hello message is parsed
1042  * @param plugins_find Function to find transport plugins by name
1043  * @return GNUNET_OK on success, GNUNET_SYSERR if the URI was invalid, GNUNET_NO on other errors
1044  */
1045 int
1046 GNUNET_HELLO_parse_uri (const char *uri,
1047                         struct GNUNET_CRYPTO_EccPublicSignKey *pubkey,
1048                         struct GNUNET_HELLO_Message **hello,
1049                         GNUNET_HELLO_TransportPluginsFind plugins_find)
1050 {
1051   const char *pks;
1052   const char *exc;
1053   int friend_only;
1054   struct GNUNET_HELLO_ParseUriContext ctx;
1055
1056   if (0 == strncmp (uri,
1057                     GNUNET_HELLO_URI_PREFIX,
1058                     strlen (GNUNET_HELLO_URI_PREFIX)))
1059   {
1060                 pks = &uri[strlen (GNUNET_HELLO_URI_PREFIX)];
1061                 friend_only = GNUNET_NO;
1062   }
1063   else if (0 == strncmp (uri,
1064             GNUNET_FRIEND_HELLO_URI_PREFIX,
1065             strlen (GNUNET_FRIEND_HELLO_URI_PREFIX)))
1066   {
1067         pks = &uri[strlen (GNUNET_FRIEND_HELLO_URI_PREFIX)];
1068         friend_only = GNUNET_YES;
1069   }
1070   else
1071         return GNUNET_SYSERR;
1072   exc = strstr (pks, "!");
1073
1074   if (GNUNET_OK !=
1075       GNUNET_STRINGS_string_to_data (pks,
1076                                      (NULL == exc) ? strlen (pks) : (exc - pks),
1077                                      (unsigned char *) pubkey,
1078                                      sizeof (*pubkey)))
1079     return GNUNET_SYSERR;
1080
1081   ctx.pos = exc;
1082   ctx.ret = GNUNET_OK;
1083   ctx.plugins_find = plugins_find;
1084   *hello = GNUNET_HELLO_create (pubkey, &add_address_to_hello, &ctx, friend_only);
1085
1086   return ctx.ret;
1087 }
1088
1089
1090 /* end of hello.c */