src/util/regex.c

   1 /*
   2      This file is part of GNUnet
   3      Copyright (C) 2012, 2013, 2015 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your 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      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19 */
  20 /**
  21  * @file src/tun/regex.c
  22  * @brief functions to convert IP networks to regexes
  23  * @author Maximilian Szengel
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "gnunet_tun_lib.h"
  29
  30 /**
  31  * 'wildcard', matches all possible values (for HEX encoding).
  32  */
  33 #define DOT "(0|1|2|3|4|5|6|7|8|9|A|B|C|D|E|F)"
  34
  35
  36 /**
  37  * Create a regex in @a rxstr from the given @a ip and @a netmask.
  38  *
  39  * @param ip IPv4 representation.
  40  * @param port destination port
  41  * @param rxstr generated regex, must be at least #GNUNET_TUN_IPV4_REGEXLEN
  42  *              bytes long.
  43  */
  44 void
  45 GNUNET_TUN_ipv4toregexsearch (const struct in_addr *ip,
  46                               uint16_t port,
  47                               char *rxstr)
  48 {
  49   GNUNET_snprintf (rxstr,
  50                    GNUNET_TUN_IPV4_REGEXLEN,
  51                    "4-%04X-%08X",
  52                    (unsigned int) port,
  53                    ntohl (ip->s_addr));
  54 }
  55
  56
  57 /**
  58  * Create a regex in @a rxstr from the given @a ipv6 and @a prefixlen.
  59  *
  60  * @param ipv6 IPv6 representation.
  61  * @param port destination port
  62  * @param rxstr generated regex, must be at least #GNUNET_TUN_IPV6_REGEXLEN
  63  *              bytes long.
  64  */
  65 void
  66 GNUNET_TUN_ipv6toregexsearch (const struct in6_addr *ipv6,
  67                               uint16_t port,
  68                               char *rxstr)
  69 {
  70   const uint32_t *addr;
  71
  72   addr = (const uint32_t *) ipv6;
  73   GNUNET_snprintf (rxstr,
  74                    GNUNET_TUN_IPV6_REGEXLEN,
  75                    "6-%04X-%08X%08X%08X%08X",
  76                    (unsigned int) port,
  77                    ntohl (addr[0]),
  78                    ntohl (addr[1]),
  79                    ntohl (addr[2]),
  80                    ntohl (addr[3]));
  81 }
  82
  83
  84 /**
  85  * Convert the given 4-bit (!) number to a regex.
  86  *
  87  * @param value the value, only the lowest 4 bits will be looked at
  88  * @param mask which bits in value are wildcards (any value)?
  89  */
  90 static char *
  91 nibble_to_regex (uint8_t value,
  92                  uint8_t mask)
  93 {
  94   char *ret;
  95
  96   value &= mask;
  97   switch (mask)
  98   {
  99   case 0:
 100     return GNUNET_strdup (DOT);
 101   case 8:
 102     GNUNET_asprintf (&ret,
 103                      "(%X|%X|%X|%X|%X|%X|%X|%X)",
 104                      value,
 105                      value + 1,
 106                      value + 2,
 107                      value + 3,
 108                      value + 4,
 109                      value + 5,
 110                      value + 6,
 111                      value + 7);
 112     return ret;
 113   case 12:
 114     GNUNET_asprintf (&ret,
 115                      "(%X|%X|%X|%X)",
 116                      value,
 117                      value + 1,
 118                      value + 2,
 119                      value + 3);
 120     return ret;
 121   case 14:
 122     GNUNET_asprintf (&ret,
 123                      "(%X|%X)",
 124                      value,
 125                      value + 1);
 126     return ret;
 127   case 15:
 128     GNUNET_asprintf (&ret,
 129                      "%X",
 130                      value);
 131     return ret;
 132   default:
 133     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 134                 _("Bad mask: %d\n"),
 135                 mask);
 136     GNUNET_break (0);
 137     return NULL;
 138   }
 139 }
 140
 141
 142 /**
 143  * Convert the given 16-bit number to a regex.
 144  *
 145  * @param value the value
 146  * @param mask which bits in value are wildcards (any value)?
 147  */
 148 static char *
 149 num_to_regex (uint16_t value,
 150               uint16_t mask)
 151 {
 152   const uint8_t *v = (const uint8_t *) &value;
 153   const uint8_t *m = (const uint8_t *) &mask;
 154   char *a;
 155   char *b;
 156   char *c;
 157   char *d;
 158   char *ret;
 159
 160   a = nibble_to_regex (v[0] >> 4, m[0] >> 4);
 161   b = nibble_to_regex (v[0] & 15, m[0] & 15);
 162   c = nibble_to_regex (v[1] >> 4, m[1] >> 4);
 163   d = nibble_to_regex (v[1] & 15, m[1] & 15);
 164   ret = NULL;
 165   if ( (NULL != a) &&
 166        (NULL != b) &&
 167        (NULL != c) &&
 168        (NULL != d) )
 169     GNUNET_asprintf (&ret,
 170                      "%s%s%s%s",
 171                      a, b, c, d);
 172   GNUNET_free_non_null (a);
 173   GNUNET_free_non_null (b);
 174   GNUNET_free_non_null (c);
 175   GNUNET_free_non_null (d);
 176   return ret;
 177 }
 178
 179
 180 /**
 181  * Do we need to put parents around the given argument?
 182  *
 183  * @param arg part of a regular expression
 184  * @return #GNUNET_YES if we should parens,
 185  *         #GNUNET_NO if not
 186  */
 187 static int
 188 needs_parens (const char *arg)
 189 {
 190   size_t off;
 191   size_t len;
 192   unsigned int op;
 193
 194   op = 0;
 195   len = strlen (arg);
 196   for (off=0;off<len;off++)
 197   {
 198     switch (arg[off])
 199     {
 200     case '(':
 201       op++;
 202       break;
 203     case ')':
 204       GNUNET_assert (op > 0);
 205       op--;
 206       break;
 207     case '|':
 208       if (0 == op)
 209         return GNUNET_YES;
 210       break;
 211     default:
 212       break;
 213     }
 214   }
 215   return GNUNET_NO;
 216 }
 217
 218
 219 /**
 220  * Compute port policy for the given range of
 221  * port numbers.
 222  *
 223  * @param start starting offset
 224  * @param end end offset
 225  * @param step increment level (power of 16)
 226  * @param pp port policy to convert
 227  * @return corresponding regex
 228  */
 229 static char *
 230 compute_policy (unsigned int start,
 231                 unsigned int end,
 232                 unsigned int step,
 233                 const struct GNUNET_STRINGS_PortPolicy *pp)
 234 {
 235   unsigned int i;
 236   char before[36]; /* 16 * 2 + 3 dots + 0-terminator */
 237   char middlel[33]; /* 16 * 2 + 0-terminator */
 238   char middleh[33]; /* 16 * 2 + 0-terminator */
 239   char after[36]; /* 16 * 2 + 3 dots + 0-terminator */
 240   char beforep[36+2]; /* 16 * 2 + 3 dots + 0-terminator + ()*/
 241   char middlehp[33+2]; /* 16 * 2 + 0-terminator + () */
 242   char middlelp[33+2]; /* 16 * 2 + 0-terminator + () */
 243   char afterp[36+2]; /* 16 * 2 + 3 dots + 0-terminator + () */
 244   char dots[5 * strlen (DOT)];
 245   char buf[3];
 246   char *middle;
 247   char *ret;
 248   unsigned int xstep;
 249   char *recl;
 250   char *rech;
 251   char *reclp;
 252   char *rechp;
 253   unsigned int start_port;
 254   unsigned int end_port;
 255
 256   GNUNET_assert (GNUNET_YES == pp->negate_portrange);
 257   start_port = pp->start_port;
 258   if (1 == start_port)
 259     start_port = 0;
 260   end_port = pp->end_port;
 261   GNUNET_assert ((end - start) / step <= 0xF);
 262   before[0] = '\0';
 263   middlel[0] = '\0';
 264   middleh[0] = '\0';
 265   after[0] = '\0';
 266   for (i=start;i<=end;i+=step)
 267   {
 268     GNUNET_snprintf (buf,
 269                      sizeof (buf),
 270                      "%X|",
 271                      (i - start) / step);
 272     if (i / step < start_port / step)
 273       strcat (before, buf);
 274     else if (i / step > end_port / step)
 275       strcat (after, buf);
 276     else if (i / step == start_port / step)
 277       strcat (middlel, buf);
 278     else if (i / step == end_port / step)
 279       strcat (middleh, buf);
 280   }
 281   if (strlen (before) > 0)
 282     before[strlen (before)-1] = '\0';
 283   if (strlen (middlel) > 0)
 284     middlel[strlen (middlel)-1] = '\0';
 285   if (strlen (middleh) > 0)
 286     middleh[strlen (middleh)-1] = '\0';
 287   if (strlen (after) > 0)
 288     after[strlen (after)-1] = '\0';
 289   if (needs_parens (before))
 290     GNUNET_snprintf (beforep,
 291                      sizeof (beforep),
 292                      "(%s)",
 293                      before);
 294   else
 295     strcpy (beforep, before);
 296   if (needs_parens (middlel))
 297     GNUNET_snprintf (middlelp,
 298                      sizeof (middlelp),
 299                      "(%s)",
 300                      middlel);
 301   else
 302     strcpy (middlelp, middlel);
 303   if (needs_parens (middleh))
 304     GNUNET_snprintf (middlehp,
 305                      sizeof (middlehp),
 306                      "(%s)",
 307                      middleh);
 308   else
 309     strcpy (middlehp, middleh);
 310   if (needs_parens (after))
 311     GNUNET_snprintf (afterp,
 312                      sizeof (afterp),
 313                      "(%s)",
 314                      after);
 315   else
 316     strcpy (afterp, after);
 317   dots[0] = '\0';
 318   for (xstep=step/16;xstep>0;xstep/=16)
 319     strcat (dots, DOT);
 320   if (step >= 16)
 321   {
 322     if (strlen (middlel) > 0)
 323       recl = compute_policy ((start_port / step) * step,
 324                              (start_port / step) * step + step - 1,
 325                              step / 16,
 326                              pp);
 327     else
 328       recl = GNUNET_strdup ("");
 329     if (strlen (middleh) > 0)
 330       rech = compute_policy ((end_port / step) * step,
 331                              (end_port / step) * step + step - 1,
 332                              step / 16,
 333                              pp);
 334     else
 335       rech = GNUNET_strdup ("");
 336   }
 337   else
 338   {
 339     recl = GNUNET_strdup ("");
 340     rech = GNUNET_strdup ("");
 341     middlel[0] = '\0';
 342     middlelp[0] = '\0';
 343     middleh[0] = '\0';
 344     middlehp[0] = '\0';
 345   }
 346   if (needs_parens (recl))
 347     GNUNET_asprintf (&reclp,
 348                      "(%s)",
 349                      recl);
 350   else
 351     reclp = GNUNET_strdup (recl);
 352   if (needs_parens (rech))
 353     GNUNET_asprintf (&rechp,
 354                      "(%s)",
 355                      rech);
 356   else
 357     rechp = GNUNET_strdup (rech);
 358
 359   if ( (strlen (middleh) > 0) &&
 360        (strlen (rech) > 0) &&
 361        (strlen (middlel) > 0) &&
 362        (strlen (recl) > 0) )
 363   {
 364     GNUNET_asprintf (&middle,
 365                      "%s%s|%s%s",
 366                      middlel,
 367                      reclp,
 368                      middleh,
 369                      rechp);
 370   }
 371   else if ( (strlen (middleh) > 0) &&
 372             (strlen (rech) > 0) )
 373   {
 374     GNUNET_asprintf (&middle,
 375                      "%s%s",
 376                      middleh,
 377                      rechp);
 378   }
 379   else if ( (strlen (middlel) > 0) &&
 380             (strlen (recl) > 0) )
 381   {
 382     GNUNET_asprintf (&middle,
 383                      "%s%s",
 384                      middlel,
 385                      reclp);
 386   }
 387   else
 388   {
 389     middle = GNUNET_strdup ("");
 390   }
 391   if ( (strlen(before) > 0) &&
 392        (strlen(after) > 0) )
 393   {
 394     if (strlen (dots) > 0)
 395     {
 396       if (strlen (middle) > 0)
 397         GNUNET_asprintf (&ret,
 398                          "(%s%s|%s|%s%s)",
 399                          beforep, dots,
 400                          middle,
 401                          afterp, dots);
 402       else
 403         GNUNET_asprintf (&ret,
 404                          "(%s|%s)%s",
 405                          beforep,
 406                          afterp,
 407                          dots);
 408     }
 409     else
 410     {
 411       if (strlen (middle) > 0)
 412         GNUNET_asprintf (&ret,
 413                          "(%s|%s|%s)",
 414                          before,
 415                          middle,
 416                          after);
 417       else if (1 == step)
 418         GNUNET_asprintf (&ret,
 419                          "%s|%s",
 420                          before,
 421                          after);
 422       else
 423         GNUNET_asprintf (&ret,
 424                          "(%s|%s)",
 425                          before,
 426                          after);
 427     }
 428   }
 429   else if (strlen (before) > 0)
 430   {
 431     if (strlen (dots) > 0)
 432     {
 433       if (strlen (middle) > 0)
 434         GNUNET_asprintf (&ret,
 435                          "(%s%s|%s)",
 436                          beforep, dots,
 437                          middle);
 438       else
 439         GNUNET_asprintf (&ret,
 440                          "%s%s",
 441                          beforep, dots);
 442     }
 443     else
 444     {
 445       if (strlen (middle) > 0)
 446         GNUNET_asprintf (&ret,
 447                          "(%s|%s)",
 448                          before,
 449                          middle);
 450       else
 451         GNUNET_asprintf (&ret,
 452                          "%s",
 453                          before);
 454     }
 455   }
 456   else if (strlen (after) > 0)
 457   {
 458     if (strlen (dots) > 0)
 459     {
 460       if (strlen (middle) > 0)
 461         GNUNET_asprintf (&ret,
 462                          "(%s|%s%s)",
 463                          middle,
 464                          afterp, dots);
 465       else
 466         GNUNET_asprintf (&ret,
 467                          "%s%s",
 468                          afterp, dots);
 469     }
 470     else
 471     {
 472       if (strlen (middle) > 0)
 473         GNUNET_asprintf (&ret,
 474                          "%s|%s",
 475                          middle,
 476                          after);
 477       else
 478         GNUNET_asprintf (&ret,
 479                          "%s",
 480                          after);
 481     }
 482   }
 483   else if (strlen (middle) > 0)
 484   {
 485     GNUNET_asprintf (&ret,
 486                      "%s",
 487                      middle);
 488   }
 489   else
 490   {
 491     ret = GNUNET_strdup ("");
 492   }
 493   GNUNET_free (middle);
 494   GNUNET_free (reclp);
 495   GNUNET_free (rechp);
 496   GNUNET_free (recl);
 497   GNUNET_free (rech);
 498   return ret;
 499 }
 500
 501
 502 /**
 503  * Convert a port policy to a regular expression.  Note: this is a
 504  * very simplistic implementation, we might want to consider doing
 505  * something more sophisiticated (resulting in smaller regular
 506  * expressions) at a later time.
 507  *
 508  * @param pp port policy to convert
 509  * @return NULL on error
 510  */
 511 static char *
 512 port_to_regex (const struct GNUNET_STRINGS_PortPolicy *pp)
 513 {
 514   char *reg;
 515   char *ret;
 516   char *pos;
 517   unsigned int i;
 518   unsigned int cnt;
 519
 520   if ( (0 == pp->start_port) ||
 521        ( (1 == pp->start_port) &&
 522          (0xFFFF == pp->end_port) &&
 523          (GNUNET_NO == pp->negate_portrange)) )
 524     return GNUNET_strdup (DOT DOT DOT DOT);
 525   if ( (pp->start_port == pp->end_port) &&
 526        (GNUNET_NO == pp->negate_portrange))
 527   {
 528     GNUNET_asprintf (&ret,
 529                      "%04X",
 530                      pp->start_port);
 531     return ret;
 532   }
 533   if (pp->end_port < pp->start_port)
 534     return NULL;
 535
 536   if (GNUNET_YES == pp->negate_portrange)
 537   {
 538     ret = compute_policy (0, 0xFFFF, 0x1000, pp);
 539   }
 540   else
 541   {
 542     cnt = pp->end_port - pp->start_port + 1;
 543     reg = GNUNET_malloc (cnt * 5 + 1);
 544     pos = reg;
 545     for (i=1;i<=0xFFFF;i++)
 546     {
 547       if ( (i >= pp->start_port) && (i <= pp->end_port) )
 548       {
 549         if (pos == reg)
 550         {
 551           GNUNET_snprintf (pos,
 552                            5,
 553                            "%04X",
 554                            i);
 555         }
 556         else
 557         {
 558           GNUNET_snprintf (pos,
 559                            6,
 560                            "|%04X",
 561                            i);
 562         }
 563         pos += strlen (pos);
 564       }
 565     }
 566     GNUNET_asprintf (&ret,
 567                      "(%s)",
 568                      reg);
 569     GNUNET_free (reg);
 570   }
 571   return ret;
 572 }
 573
 574
 575 /**
 576  * Convert an address (IPv4 or IPv6) to a regex.
 577  *
 578  * @param addr address
 579  * @param mask network mask
 580  * @param len number of bytes in @a addr and @a mask
 581  * @return NULL on error, otherwise regex for the address
 582  */
 583 static char *
 584 address_to_regex (const void *addr,
 585                   const void *mask,
 586                   size_t len)
 587 {
 588   const uint16_t *a = addr;
 589   const uint16_t *m = mask;
 590   char *ret;
 591   char *tmp;
 592   char *reg;
 593   unsigned int i;
 594
 595   ret = NULL;
 596   GNUNET_assert (1 != (len % 2));
 597   for (i=0;i<len / 2;i++)
 598   {
 599     reg = num_to_regex (a[i], m[i]);
 600     if (NULL == reg)
 601     {
 602       GNUNET_free_non_null (ret);
 603       return NULL;
 604     }
 605     if (NULL == ret)
 606     {
 607       ret = reg;
 608     }
 609     else
 610     {
 611       GNUNET_asprintf (&tmp,
 612                        "%s%s",
 613                        ret, reg);
 614       GNUNET_free (ret);
 615       GNUNET_free (reg);
 616       ret = tmp;
 617     }
 618   }
 619   return ret;
 620 }
 621
 622
 623 /**
 624  * Convert a single line of an IPv4 policy to a regular expression.
 625  *
 626  * @param v4 line to convert
 627  * @return NULL on error
 628  */
 629 static char *
 630 ipv4_to_regex (const struct GNUNET_STRINGS_IPv4NetworkPolicy *v4)
 631 {
 632   char *reg;
 633   char *pp;
 634   char *ret;
 635
 636   reg = address_to_regex (&v4->network,
 637                           &v4->netmask,
 638                           sizeof (struct in_addr));
 639   if (NULL == reg)
 640     return NULL;
 641   pp = port_to_regex (&v4->pp);
 642   if (NULL == pp)
 643   {
 644     GNUNET_free (reg);
 645     return NULL;
 646   }
 647   GNUNET_asprintf (&ret,
 648                    "4-%s-%s",
 649                    pp, reg);
 650   GNUNET_free (pp);
 651   GNUNET_free (reg);
 652   return ret;
 653 }
 654
 655
 656 /**
 657  * Convert a single line of an IPv4 policy to a regular expression.
 658  *
 659  * @param v6 line to convert
 660  * @return NULL on error
 661  */
 662 static char *
 663 ipv6_to_regex (const struct GNUNET_STRINGS_IPv6NetworkPolicy *v6)
 664 {
 665   char *reg;
 666   char *pp;
 667   char *ret;
 668
 669   reg = address_to_regex (&v6->network,
 670                           &v6->netmask,
 671                           sizeof (struct in6_addr));
 672   if (NULL == reg)
 673     return NULL;
 674   pp = port_to_regex (&v6->pp);
 675   if (NULL == pp)
 676   {
 677     GNUNET_free (reg);
 678     return NULL;
 679   }
 680   GNUNET_asprintf (&ret,
 681                    "6-%s-%s",
 682                    pp, reg);
 683   GNUNET_free (pp);
 684   GNUNET_free (reg);
 685   return ret;
 686 }
 687
 688
 689 /**
 690  * Convert an exit policy to a regular expression.  The exit policy
 691  * specifies a set of subnets this peer is willing to serve as an
 692  * exit for; the resulting regular expression will match the
 693  * IPv4 address strings as returned by #GNUNET_TUN_ipv4toregexsearch().
 694  *
 695  * @param policy exit policy specification
 696  * @return regular expression, NULL on error
 697  */
 698 char *
 699 GNUNET_TUN_ipv4policy2regex (const char *policy)
 700 {
 701   struct GNUNET_STRINGS_IPv4NetworkPolicy *np;
 702   char *reg;
 703   char *tmp;
 704   char *line;
 705   unsigned int i;
 706
 707   np = GNUNET_STRINGS_parse_ipv4_policy (policy);
 708   if (NULL == np)
 709     return NULL;
 710   reg = NULL;
 711   for (i=0; (0 == i) || (0 != np[i].network.s_addr); i++)
 712   {
 713     line = ipv4_to_regex (&np[i]);
 714     if (NULL == line)
 715     {
 716       GNUNET_free_non_null (reg);
 717       GNUNET_free (np);
 718       return NULL;
 719     }
 720     if (NULL == reg)
 721     {
 722       reg = line;
 723     }
 724     else
 725     {
 726       GNUNET_asprintf (&tmp,
 727                        "%s|(%s)",
 728                        reg, line);
 729       GNUNET_free (reg);
 730       GNUNET_free (line);
 731       reg = tmp;
 732     }
 733     if (0 == np[i].network.s_addr)
 734       break;
 735   }
 736   GNUNET_free (np);
 737   return reg;
 738 }
 739
 740
 741 /**
 742  * Convert an exit policy to a regular expression.  The exit policy
 743  * specifies a set of subnets this peer is willing to serve as an
 744  * exit for; the resulting regular expression will match the
 745  * IPv6 address strings as returned by #GNUNET_TUN_ipv6toregexsearch().
 746  *
 747  * @param policy exit policy specification
 748  * @return regular expression, NULL on error
 749  */
 750 char *
 751 GNUNET_TUN_ipv6policy2regex (const char *policy)
 752 {
 753   struct in6_addr zero;
 754   struct GNUNET_STRINGS_IPv6NetworkPolicy *np;
 755   char *reg;
 756   char *tmp;
 757   char *line;
 758   unsigned int i;
 759
 760   np = GNUNET_STRINGS_parse_ipv6_policy (policy);
 761   if (NULL == np)
 762     return NULL;
 763   reg = NULL;
 764   memset (&zero, 0, sizeof (struct in6_addr));
 765   for (i=0; (0 == i) || (0 != memcmp (&zero, &np[i].network, sizeof (struct in6_addr))); i++)
 766   {
 767     line = ipv6_to_regex (&np[i]);
 768     if (NULL == line)
 769     {
 770       GNUNET_free_non_null (reg);
 771       GNUNET_free (np);
 772       return NULL;
 773     }
 774     if (NULL == reg)
 775     {
 776       reg = line;
 777     }
 778     else
 779     {
 780       GNUNET_asprintf (&tmp,
 781                        "%s|(%s)",
 782                        reg, line);
 783       GNUNET_free (reg);
 784       GNUNET_free (line);
 785       reg = tmp;
 786     }
 787     if (0 == memcmp (&zero, &np[i].network, sizeof (struct in6_addr)))
 788       break;
 789   }
 790   GNUNET_free (np);
 791   return reg;
 792 }
 793
 794
 795 /**
 796  * Hash the service name of a hosted service to the
 797  * hash code that is used to identify the service on
 798  * the network.
 799  *
 800  * @param service_name a string
 801  * @param hc corresponding hash
 802  */
 803 void
 804 GNUNET_TUN_service_name_to_hash (const char *service_name,
 805                                  struct GNUNET_HashCode *hc)
 806 {
 807   GNUNET_CRYPTO_hash (service_name,
 808                       strlen (service_name),
 809                       hc);
 810 }
 811
 812
 813 /**
 814  * Compute the CADET port given a service descriptor
 815  * (returned from #GNUNET_TUN_service_name_to_hash) and
 816  * a TCP/UDP port @a ip_port.
 817  *
 818  * @param desc service shared secret
 819  * @param ip_port TCP/UDP port, use 0 for ICMP
 820  * @param[out] cadet_port CADET port to use
 821  */
 822 void
 823 GNUNET_TUN_compute_service_cadet_port (const struct GNUNET_HashCode *desc,
 824                                        uint16_t ip_port,
 825                                        struct GNUNET_HashCode *cadet_port)
 826 {
 827   uint16_t be_port = htons (ip_port);
 828
 829   *cadet_port = *desc;
 830   GNUNET_memcpy (cadet_port,
 831                  &be_port,
 832                  sizeof (uint16_t));
 833 }
 834
 835
 836 /* end of regex.c */