src/include/gnunet_tun_lib.h

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2010-2013 Christian Grothoff
   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 /**
  22  * @author Philipp Toelke
  23  * @author Christian Grothoff
  24  *
  25  * @file
  26  * Standard TCP/IP network structs and IP checksum calculations for TUN
  27  * interaction
  28  *
  29  * @defgroup tun  TUN library
  30  * Standard TCP/IP network structs and IP checksum calculations for TUN
  31  * interaction
  32  * @{
  33  */
  34 #ifndef GNUNET_TUN_LIB_H
  35 #define GNUNET_TUN_LIB_H
  36
  37 #include "gnunet_common.h"
  38 #include "gnunet_crypto_lib.h"
  39
  40
  41 /* see http://www.iana.org/assignments/ethernet-numbers */
  42 #ifndef ETH_P_IPV4
  43 /**
  44  * Number for IPv4
  45  */
  46 #define ETH_P_IPV4 0x0800
  47 #endif
  48
  49 #ifndef ETH_P_IPV6
  50 /**
  51  * Number for IPv6
  52  */
  53 #define ETH_P_IPV6 0x86DD
  54 #endif
  55
  56
  57 /**
  58  * Maximum regex string length for use with #GNUNET_TUN_ipv4toregexsearch.
  59  *
  60  * 8 bytes for IPv4, 4 bytes for port, 1 byte for "4", 2 bytes for "-",
  61  * one byte for 0-termination.
  62  */
  63
  64 #define GNUNET_TUN_IPV4_REGEXLEN 16
  65
  66
  67 /**
  68  * Maximum regex string length for use with #GNUNET_TUN_ipv6toregexsearch
  69  *
  70  * 32 bytes for IPv4, 4 bytes for port, 1 byte for "4", 2 bytes for "-",
  71  * one byte for 0-termination.
  72  */
  73 #define GNUNET_TUN_IPV6_REGEXLEN 40
  74
  75
  76 GNUNET_NETWORK_STRUCT_BEGIN
  77
  78 /**
  79  * Header from Linux TUN interface.
  80  */
  81 struct GNUNET_TUN_Layer2PacketHeader
  82 {
  83   /**
  84    * Some flags (unused).
  85    */
  86   uint16_t flags GNUNET_PACKED;
  87
  88   /**
  89    * Here we get an ETH_P_-number.
  90    */
  91   uint16_t proto GNUNET_PACKED;
  92 };
  93
  94
  95 /**
  96  * Standard IPv4 header.
  97  */
  98 struct GNUNET_TUN_IPv4Header
  99 {
 100 #if __BYTE_ORDER == __LITTLE_ENDIAN
 101   unsigned int header_length : 4 GNUNET_PACKED;
 102   unsigned int version : 4 GNUNET_PACKED;
 103 #elif __BYTE_ORDER == __BIG_ENDIAN
 104   unsigned int version : 4 GNUNET_PACKED;
 105   unsigned int header_length : 4 GNUNET_PACKED;
 106 #else
 107 #error byteorder undefined
 108 #endif
 109   uint8_t diff_serv;
 110
 111   /**
 112    * Length of the packet, including this header.
 113    */
 114   uint16_t total_length GNUNET_PACKED;
 115
 116   /**
 117    * Unique random ID for matching up fragments.
 118    */
 119   uint16_t identification GNUNET_PACKED;
 120
 121   unsigned int flags : 3 GNUNET_PACKED;
 122
 123   unsigned int fragmentation_offset : 13 GNUNET_PACKED;
 124
 125   /**
 126    * How many more hops can this packet be forwarded?
 127    */
 128   uint8_t ttl;
 129
 130   /**
 131    * L4-protocol, for example, IPPROTO_UDP or IPPROTO_TCP.
 132    */
 133   uint8_t protocol;
 134
 135   /**
 136    * Checksum.
 137    */
 138   uint16_t checksum GNUNET_PACKED;
 139
 140   /**
 141    * Origin of the packet.
 142    */
 143   struct in_addr source_address;
 144
 145   /**
 146    * Destination of the packet.
 147    */
 148   struct in_addr destination_address;
 149 } GNUNET_GCC_STRUCT_LAYOUT;
 150
 151
 152 /**
 153  * Standard IPv6 header.
 154  */
 155 struct GNUNET_TUN_IPv6Header
 156 {
 157 #if __BYTE_ORDER == __LITTLE_ENDIAN
 158   unsigned int traffic_class_h : 4 GNUNET_PACKED;
 159   unsigned int version : 4 GNUNET_PACKED;
 160   unsigned int traffic_class_l : 4 GNUNET_PACKED;
 161   unsigned int flow_label : 20 GNUNET_PACKED;
 162 #elif __BYTE_ORDER == __BIG_ENDIAN
 163   unsigned int version : 4 GNUNET_PACKED;
 164   unsigned int traffic_class : 8 GNUNET_PACKED;
 165   unsigned int flow_label : 20 GNUNET_PACKED;
 166 #else
 167 #error byteorder undefined
 168 #endif
 169   /**
 170    * Length of the payload, excluding this header.
 171    */
 172   uint16_t payload_length GNUNET_PACKED;
 173
 174   /**
 175    * For example, IPPROTO_UDP or IPPROTO_TCP.
 176    */
 177   uint8_t next_header;
 178
 179   /**
 180    * How many more hops can this packet be forwarded?
 181    */
 182   uint8_t hop_limit;
 183
 184   /**
 185    * Origin of the packet.
 186    */
 187   struct in6_addr source_address GNUNET_PACKED;
 188
 189   /**
 190    * Destination of the packet.
 191    */
 192   struct in6_addr destination_address GNUNET_PACKED;
 193 } GNUNET_GCC_STRUCT_LAYOUT;
 194
 195
 196 /**
 197  * TCP flags.
 198  */
 199 #define GNUNET_TUN_TCP_FLAGS_FIN 1
 200 #define GNUNET_TUN_TCP_FLAGS_SYN 2
 201 #define GNUNET_TUN_TCP_FLAGS_RST 4
 202 #define GNUNET_TUN_TCP_FLAGS_PSH 8
 203 #define GNUNET_TUN_TCP_FLAGS_ACK 16
 204 #define GNUNET_TUN_TCP_FLAGS_URG 32
 205 #define GNUNET_TUN_TCP_FLAGS_ECE 64
 206 #define GNUNET_TUN_TCP_FLAGS_CWR 128
 207
 208 /**
 209  * TCP packet header.
 210  */
 211 struct GNUNET_TUN_TcpHeader
 212 {
 213   /**
 214    * Source port (in NBO).
 215    */
 216   uint16_t source_port GNUNET_PACKED;
 217
 218   /**
 219    * Destination port (in NBO).
 220    */
 221   uint16_t destination_port GNUNET_PACKED;
 222
 223   /**
 224    * Sequence number.
 225    */
 226   uint32_t seq GNUNET_PACKED;
 227
 228   /**
 229    * Acknowledgement number.
 230    */
 231   uint32_t ack GNUNET_PACKED;
 232 #if __BYTE_ORDER == __LITTLE_ENDIAN
 233   /**
 234    * Reserved.  Must be zero.
 235    */
 236   unsigned int reserved : 4 GNUNET_PACKED;
 237   /**
 238    * Number of 32-bit words in TCP header.
 239    */
 240   unsigned int off : 4 GNUNET_PACKED;
 241 #elif __BYTE_ORDER == __BIG_ENDIAN
 242   /**
 243    * Number of 32-bit words in TCP header.
 244    */
 245   unsigned int off : 4 GNUNET_PACKED;
 246   /**
 247    * Reserved.  Must be zero.
 248    */
 249   unsigned int reserved : 4 GNUNET_PACKED;
 250 #else
 251 #error byteorder undefined
 252 #endif
 253
 254   /**
 255    * Flags (SYN, FIN, ACK, etc.)
 256    */
 257   uint8_t flags;
 258
 259   /**
 260    * Window size.
 261    */
 262   uint16_t window_size GNUNET_PACKED;
 263
 264   /**
 265    * Checksum.
 266    */
 267   uint16_t crc GNUNET_PACKED;
 268
 269   /**
 270    * Urgent pointer.
 271    */
 272   uint16_t urgent_pointer GNUNET_PACKED;
 273 } GNUNET_GCC_STRUCT_LAYOUT;
 274
 275
 276 /**
 277  * UDP packet header.
 278  */
 279 struct GNUNET_TUN_UdpHeader
 280 {
 281   /**
 282    * Source port (in NBO).
 283    */
 284   uint16_t source_port GNUNET_PACKED;
 285
 286   /**
 287    * Destination port (in NBO).
 288    */
 289   uint16_t destination_port GNUNET_PACKED;
 290
 291   /**
 292    * Number of bytes of payload.
 293    */
 294   uint16_t len GNUNET_PACKED;
 295
 296   /**
 297    * Checksum.
 298    */
 299   uint16_t crc GNUNET_PACKED;
 300 };
 301
 302
 303 /**
 304  * A few common DNS classes (ok, only one is common, but I list a
 305  * couple more to make it clear what we're talking about here).
 306  */
 307 #define GNUNET_TUN_DNS_CLASS_INTERNET 1
 308 #define GNUNET_TUN_DNS_CLASS_CHAOS 3
 309 #define GNUNET_TUN_DNS_CLASS_HESIOD 4
 310
 311 #define GNUNET_TUN_DNS_OPCODE_QUERY 0
 312 #define GNUNET_TUN_DNS_OPCODE_INVERSE_QUERY 1
 313 #define GNUNET_TUN_DNS_OPCODE_STATUS 2
 314
 315
 316 /**
 317  * RFC 1035 codes.
 318  */
 319 #define GNUNET_TUN_DNS_RETURN_CODE_NO_ERROR 0
 320 #define GNUNET_TUN_DNS_RETURN_CODE_FORMAT_ERROR 1
 321 #define GNUNET_TUN_DNS_RETURN_CODE_SERVER_FAILURE 2
 322 #define GNUNET_TUN_DNS_RETURN_CODE_NAME_ERROR 3
 323 #define GNUNET_TUN_DNS_RETURN_CODE_NOT_IMPLEMENTED 4
 324 #define GNUNET_TUN_DNS_RETURN_CODE_REFUSED 5
 325
 326 /**
 327  * RFC 2136 codes
 328  */
 329 #define GNUNET_TUN_DNS_RETURN_CODE_YXDOMAIN 6
 330 #define GNUNET_TUN_DNS_RETURN_CODE_YXRRSET 7
 331 #define GNUNET_TUN_DNS_RETURN_CODE_NXRRSET 8
 332 #define GNUNET_TUN_DNS_RETURN_CODE_NOT_AUTH 9
 333 #define GNUNET_TUN_DNS_RETURN_CODE_NOT_ZONE 10
 334
 335
 336 /**
 337  * DNS flags (largely RFC 1035 / RFC 2136).
 338  */
 339 struct GNUNET_TUN_DnsFlags
 340 {
 341 #if __BYTE_ORDER == __LITTLE_ENDIAN
 342   /**
 343    * Set to 1 if recursion is desired (client -> server)
 344    */
 345   unsigned int recursion_desired : 1 GNUNET_PACKED;
 346
 347   /**
 348    * Set to 1 if message is truncated
 349    */
 350   unsigned int message_truncated : 1 GNUNET_PACKED;
 351
 352   /**
 353    * Set to 1 if this is an authoritative answer
 354    */
 355   unsigned int authoritative_answer : 1 GNUNET_PACKED;
 356
 357   /**
 358    * See GNUNET_TUN_DNS_OPCODE_ defines.
 359    */
 360   unsigned int opcode : 4 GNUNET_PACKED;
 361
 362   /**
 363    * query:0, response:1
 364    */
 365   unsigned int query_or_response : 1 GNUNET_PACKED;
 366
 367   /**
 368    * See GNUNET_TUN_DNS_RETURN_CODE_ defines.
 369    */
 370   unsigned int return_code : 4 GNUNET_PACKED;
 371
 372   /**
 373    * See RFC 4035.
 374    */
 375   unsigned int checking_disabled : 1 GNUNET_PACKED;
 376
 377   /**
 378    * Response has been cryptographically verified, RFC 4035.
 379    */
 380   unsigned int authenticated_data : 1 GNUNET_PACKED;
 381
 382   /**
 383    * Always zero.
 384    */
 385   unsigned int zero : 1 GNUNET_PACKED;
 386
 387   /**
 388    * Set to 1 if recursion is available (server -> client)
 389    */
 390   unsigned int recursion_available : 1 GNUNET_PACKED;
 391 #elif __BYTE_ORDER == __BIG_ENDIAN
 392   /**
 393    * query:0, response:1
 394    */
 395   unsigned int query_or_response : 1 GNUNET_PACKED;
 396
 397   /**
 398    * See GNUNET_TUN_DNS_OPCODE_ defines.
 399    */
 400   unsigned int opcode : 4 GNUNET_PACKED;
 401
 402   /**
 403    * Set to 1 if this is an authoritative answer
 404    */
 405   unsigned int authoritative_answer : 1 GNUNET_PACKED;
 406
 407   /**
 408    * Set to 1 if message is truncated
 409    */
 410   unsigned int message_truncated : 1 GNUNET_PACKED;
 411
 412   /**
 413    * Set to 1 if recursion is desired (client -> server)
 414    */
 415   unsigned int recursion_desired : 1 GNUNET_PACKED;
 416
 417
 418   /**
 419    * Set to 1 if recursion is available (server -> client)
 420    */
 421   unsigned int recursion_available : 1 GNUNET_PACKED;
 422
 423   /**
 424    * Always zero.
 425    */
 426   unsigned int zero : 1 GNUNET_PACKED;
 427
 428   /**
 429    * Response has been cryptographically verified, RFC 4035.
 430    */
 431   unsigned int authenticated_data : 1 GNUNET_PACKED;
 432
 433   /**
 434    * See RFC 4035.
 435    */
 436   unsigned int checking_disabled : 1 GNUNET_PACKED;
 437
 438   /**
 439    * See GNUNET_TUN_DNS_RETURN_CODE_ defines.
 440    */
 441   unsigned int return_code : 4 GNUNET_PACKED;
 442 #else
 443 #error byteorder undefined
 444 #endif
 445 } GNUNET_GCC_STRUCT_LAYOUT;
 446
 447
 448 /**
 449  * DNS header.
 450  */
 451 struct GNUNET_TUN_DnsHeader
 452 {
 453   /**
 454    * Unique identifier for the request/response.
 455    */
 456   uint16_t id GNUNET_PACKED;
 457
 458   /**
 459    * Flags.
 460    */
 461   struct GNUNET_TUN_DnsFlags flags;
 462
 463   /**
 464    * Number of queries.
 465    */
 466   uint16_t query_count GNUNET_PACKED;
 467
 468   /**
 469    * Number of answers.
 470    */
 471   uint16_t answer_rcount GNUNET_PACKED;
 472
 473   /**
 474    * Number of authoritative answers.
 475    */
 476   uint16_t authority_rcount GNUNET_PACKED;
 477
 478   /**
 479    * Number of additional records.
 480    */
 481   uint16_t additional_rcount GNUNET_PACKED;
 482 };
 483
 484
 485 /**
 486  * Payload of DNS SOA record (header).
 487  */
 488 struct GNUNET_TUN_DnsSoaRecord
 489 {
 490   /**
 491    * The version number of the original copy of the zone.   (NBO)
 492    */
 493   uint32_t serial GNUNET_PACKED;
 494
 495   /**
 496    * Time interval before the zone should be refreshed. (NBO)
 497    */
 498   uint32_t refresh GNUNET_PACKED;
 499
 500   /**
 501    * Time interval that should elapse before a failed refresh should
 502    * be retried. (NBO)
 503    */
 504   uint32_t retry GNUNET_PACKED;
 505
 506   /**
 507    * Time value that specifies the upper limit on the time interval
 508    * that can elapse before the zone is no longer authoritative. (NBO)
 509    */
 510   uint32_t expire GNUNET_PACKED;
 511
 512   /**
 513    * The bit minimum TTL field that should be exported with any RR
 514    * from this zone. (NBO)
 515    */
 516   uint32_t minimum GNUNET_PACKED;
 517 };
 518
 519
 520 /**
 521  * Payload of DNS SRV record (header).
 522  */
 523 struct GNUNET_TUN_DnsSrvRecord
 524 {
 525   /**
 526    * Preference for this entry (lower value is higher preference).  Clients
 527    * will contact hosts from the lowest-priority group first and fall back
 528    * to higher priorities if the low-priority entries are unavailable. (NBO)
 529    */
 530   uint16_t prio GNUNET_PACKED;
 531
 532   /**
 533    * Relative weight for records with the same priority.  Clients will use
 534    * the hosts of the same (lowest) priority with a probability proportional
 535    * to the weight given. (NBO)
 536    */
 537   uint16_t weight GNUNET_PACKED;
 538
 539   /**
 540    * TCP or UDP port of the service. (NBO)
 541    */
 542   uint16_t port GNUNET_PACKED;
 543
 544   /* followed by 'target' name */
 545 };
 546
 547
 548 /**
 549  * Payload of DNS CERT record.
 550  */
 551 struct GNUNET_TUN_DnsCertRecord
 552 {
 553   /**
 554    * Certificate type
 555    */
 556   uint16_t cert_type;
 557
 558   /**
 559    * Certificate KeyTag
 560    */
 561   uint16_t cert_tag;
 562
 563   /**
 564    * Algorithm
 565    */
 566   uint8_t algorithm;
 567
 568   /* Followed by the certificate */
 569 };
 570
 571
 572 /**
 573  * Payload of DNSSEC TLSA record.
 574  * http://datatracker.ietf.org/doc/draft-ietf-dane-protocol/
 575  */
 576 struct GNUNET_TUN_DnsTlsaRecord
 577 {
 578   /**
 579    * Certificate usage
 580    * 0: CA cert
 581    * 1: Entity cert
 582    * 2: Trust anchor
 583    * 3: domain-issued cert
 584    */
 585   uint8_t usage;
 586
 587   /**
 588    * Selector
 589    * What part will be matched against the cert
 590    * presented by server
 591    * 0: Full cert (in binary)
 592    * 1: Full cert (in DER)
 593    */
 594   uint8_t selector;
 595
 596   /**
 597    * Matching type (of selected content)
 598    * 0: exact match
 599    * 1: SHA-256 hash
 600    * 2: SHA-512 hash
 601    */
 602   uint8_t matching_type;
 603
 604   /**
 605    * followed by certificate association data
 606    * The "certificate association data" to be matched.
 607    * These bytes are either raw data (that is, the full certificate or
 608    * its SubjectPublicKeyInfo, depending on the selector) for matching
 609    * type 0, or the hash of the raw data for matching types 1 and 2.
 610    * The data refers to the certificate in the association, not to the
 611    * TLS ASN.1 Certificate object.
 612    *
 613    * The data is represented as a string of hex chars
 614    */
 615 };
 616
 617
 618 /**
 619  * Payload of GNS VPN record
 620  */
 621 struct GNUNET_TUN_GnsVpnRecord
 622 {
 623   /**
 624    * The peer to contact
 625    */
 626   struct GNUNET_PeerIdentity peer;
 627
 628   /**
 629    * The protocol to use
 630    */
 631   uint16_t proto;
 632
 633   /* followed by the servicename */
 634 };
 635
 636
 637 /**
 638  * DNS query prefix.
 639  */
 640 struct GNUNET_TUN_DnsQueryLine
 641 {
 642   /**
 643    * Desired type (GNUNET_DNSPARSER_TYPE_XXX). (NBO)
 644    */
 645   uint16_t type GNUNET_PACKED;
 646
 647   /**
 648    * Desired class (usually GNUNET_TUN_DNS_CLASS_INTERNET). (NBO)
 649    */
 650   uint16_t dns_traffic_class GNUNET_PACKED;
 651 };
 652
 653
 654 /**
 655  * General DNS record prefix.
 656  */
 657 struct GNUNET_TUN_DnsRecordLine
 658 {
 659   /**
 660    * Record type (GNUNET_DNSPARSER_TYPE_XXX). (NBO)
 661    */
 662   uint16_t type GNUNET_PACKED;
 663
 664   /**
 665    * Record class (usually GNUNET_TUN_DNS_CLASS_INTERNET). (NBO)
 666    */
 667   uint16_t dns_traffic_class GNUNET_PACKED;
 668
 669   /**
 670    * Expiration for the record (in seconds). (NBO)
 671    */
 672   uint32_t ttl GNUNET_PACKED;
 673
 674   /**
 675    * Number of bytes of data that follow. (NBO)
 676    */
 677   uint16_t data_len GNUNET_PACKED;
 678 };
 679
 680
 681 #define GNUNET_TUN_ICMPTYPE_ECHO_REPLY 0
 682 #define GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE 3
 683 #define GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH 4
 684 #define GNUNET_TUN_ICMPTYPE_REDIRECT_MESSAGE 5
 685 #define GNUNET_TUN_ICMPTYPE_ECHO_REQUEST 8
 686 #define GNUNET_TUN_ICMPTYPE_ROUTER_ADVERTISEMENT 9
 687 #define GNUNET_TUN_ICMPTYPE_ROUTER_SOLICITATION 10
 688 #define GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED 11
 689
 690 #define GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE 1
 691 #define GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG 2
 692 #define GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED 3
 693 #define GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM 4
 694 #define GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST 128
 695 #define GNUNET_TUN_ICMPTYPE6_ECHO_REPLY 129
 696
 697
 698 /**
 699  * ICMP header.
 700  */
 701 struct GNUNET_TUN_IcmpHeader
 702 {
 703   uint8_t type;
 704   uint8_t code;
 705   uint16_t crc GNUNET_PACKED;
 706
 707   union
 708   {
 709     /**
 710      * ICMP Echo (request/reply)
 711      */
 712     struct
 713     {
 714       uint16_t identifier GNUNET_PACKED;
 715       uint16_t sequence_number GNUNET_PACKED;
 716     } echo;
 717
 718     /**
 719      * ICMP Destination Unreachable (RFC 1191)
 720      */
 721     struct ih_pmtu
 722     {
 723       uint16_t empty GNUNET_PACKED;
 724       uint16_t next_hop_mtu GNUNET_PACKED;
 725       /* followed by original IP header + first 8 bytes of original IP datagram
 726        */
 727     } destination_unreachable;
 728
 729     /**
 730      * ICMP Redirect
 731      */
 732     struct in_addr redirect_gateway_address;
 733
 734     /**
 735      * MTU for packets that are too big (IPv6).
 736      */
 737     uint32_t packet_too_big_mtu GNUNET_PACKED;
 738   } quench;
 739 };
 740
 741
 742 GNUNET_NETWORK_STRUCT_END
 743
 744
 745 /**
 746  * Initialize an IPv4 header.
 747  *
 748  * @param ip header to initialize
 749  * @param protocol protocol to use (i.e. IPPROTO_UDP)
 750  * @param payload_length number of bytes of payload that follow (excluding IPv4
 751  * header)
 752  * @param src source IP address to use
 753  * @param dst destination IP address to use
 754  */
 755 void
 756 GNUNET_TUN_initialize_ipv4_header (struct GNUNET_TUN_IPv4Header *ip,
 757                                    uint8_t protocol,
 758                                    uint16_t payload_length,
 759                                    const struct in_addr *src,
 760                                    const struct in_addr *dst);
 761
 762
 763 /**
 764  * Initialize an IPv6 header.
 765  *
 766  * @param ip header to initialize
 767  * @param protocol protocol to use (i.e. IPPROTO_UDP)
 768  * @param payload_length number of bytes of payload that follow (excluding IPv4
 769  * header)
 770  * @param src source IP address to use
 771  * @param dst destination IP address to use
 772  */
 773 void
 774 GNUNET_TUN_initialize_ipv6_header (struct GNUNET_TUN_IPv6Header *ip,
 775                                    uint8_t protocol,
 776                                    uint16_t payload_length,
 777                                    const struct in6_addr *src,
 778                                    const struct in6_addr *dst);
 779
 780 /**
 781  * Calculate IPv4 TCP checksum.
 782  *
 783  * @param ip ipv4 header fully initialized
 784  * @param tcp TCP header (initialized except for CRC)
 785  * @param payload the TCP payload
 786  * @param payload_length number of bytes of TCP @a payload
 787  */
 788 void
 789 GNUNET_TUN_calculate_tcp4_checksum (const struct GNUNET_TUN_IPv4Header *ip,
 790                                     struct GNUNET_TUN_TcpHeader *tcp,
 791                                     const void *payload,
 792                                     uint16_t payload_length);
 793
 794 /**
 795  * Calculate IPv6 TCP checksum.
 796  *
 797  * @param ip ipv6 header fully initialized
 798  * @param tcp TCP header (initialized except for CRC)
 799  * @param payload the TCP payload
 800  * @param payload_length number of bytes of TCP payload
 801  */
 802 void
 803 GNUNET_TUN_calculate_tcp6_checksum (const struct GNUNET_TUN_IPv6Header *ip,
 804                                     struct GNUNET_TUN_TcpHeader *tcp,
 805                                     const void *payload,
 806                                     uint16_t payload_length);
 807
 808 /**
 809  * Calculate IPv4 UDP checksum.
 810  *
 811  * @param ip ipv4 header fully initialized
 812  * @param udp UDP header (initialized except for CRC)
 813  * @param payload the UDP payload
 814  * @param payload_length number of bytes of UDP @a payload
 815  */
 816 void
 817 GNUNET_TUN_calculate_udp4_checksum (const struct GNUNET_TUN_IPv4Header *ip,
 818                                     struct GNUNET_TUN_UdpHeader *udp,
 819                                     const void *payload,
 820                                     uint16_t payload_length);
 821
 822
 823 /**
 824  * Calculate IPv6 UDP checksum.
 825  *
 826  * @param ip ipv6 header fully initialized
 827  * @param udp UDP header (initialized except for CRC)
 828  * @param payload the UDP payload
 829  * @param payload_length number of bytes of @a payload
 830  */
 831 void
 832 GNUNET_TUN_calculate_udp6_checksum (const struct GNUNET_TUN_IPv6Header *ip,
 833                                     struct GNUNET_TUN_UdpHeader *udp,
 834                                     const void *payload,
 835                                     uint16_t payload_length);
 836
 837
 838 /**
 839  * Calculate ICMP checksum.
 840  *
 841  * @param icmp IMCP header (initialized except for CRC)
 842  * @param payload the ICMP payload
 843  * @param payload_length number of bytes of @a payload
 844  */
 845 void
 846 GNUNET_TUN_calculate_icmp_checksum (struct GNUNET_TUN_IcmpHeader *icmp,
 847                                     const void *payload,
 848                                     uint16_t payload_length);
 849
 850
 851 /**
 852  * Create a regex in @a rxstr from the given @a ip and @a port.
 853  *
 854  * @param ip IPv4 representation.
 855  * @param port destination port
 856  * @param rxstr generated regex, must be at least #GNUNET_TUN_IPV4_REGEXLEN
 857  *              bytes long.
 858  */
 859 void
 860 GNUNET_TUN_ipv4toregexsearch (const struct in_addr *ip,
 861                               uint16_t port,
 862                               char *rxstr);
 863
 864
 865 /**
 866  * Create a regex in @a rxstr from the given @a ipv6 and @a port.
 867  *
 868  * @param ipv6 IPv6 representation.
 869  * @param port destination port
 870  * @param rxstr generated regex, must be at least #GNUNET_TUN_IPV6_REGEXLEN
 871  *              bytes long.
 872  */
 873 void
 874 GNUNET_TUN_ipv6toregexsearch (const struct in6_addr *ipv6,
 875                               uint16_t port,
 876                               char *rxstr);
 877
 878
 879 /**
 880  * Convert an exit policy to a regular expression.  The exit policy
 881  * specifies a set of subnets this peer is willing to serve as an
 882  * exit for; the resulting regular expression will match the
 883  * IPv6 address strings as returned by #GNUNET_TUN_ipv6toregexsearch.
 884  *
 885  * @param policy exit policy specification
 886  * @return regular expression, NULL on error
 887  */
 888 char *
 889 GNUNET_TUN_ipv6policy2regex (const char *policy);
 890
 891
 892 /**
 893  * Convert an exit policy to a regular expression.  The exit policy
 894  * specifies a set of subnets this peer is willing to serve as an
 895  * exit for; the resulting regular expression will match the
 896  * IPv4 address strings as returned by #GNUNET_TUN_ipv4toregexsearch.
 897  *
 898  * @param policy exit policy specification
 899  * @return regular expression, NULL on error
 900  */
 901 char *
 902 GNUNET_TUN_ipv4policy2regex (const char *policy);
 903
 904
 905 /**
 906  * Hash the service name of a hosted service to the
 907  * hash code that is used to identify the service on
 908  * the network.
 909  *
 910  * @param service_name a string
 911  * @param[out] hc corresponding hash
 912  */
 913 void
 914 GNUNET_TUN_service_name_to_hash (const char *service_name,
 915                                  struct GNUNET_HashCode *hc);
 916
 917
 918 /**
 919  * Check if two sockaddrs are equal.
 920  *
 921  * @param sa one address
 922  * @param sb another address
 923  * @param include_port also check ports
 924  * @return #GNUNET_YES if they are equal
 925  */
 926 int
 927 GNUNET_TUN_sockaddr_cmp (const struct sockaddr *sa,
 928                          const struct sockaddr *sb,
 929                          int include_port);
 930
 931
 932 /**
 933  * Compute the CADET port given a service descriptor
 934  * (returned from #GNUNET_TUN_service_name_to_hash) and
 935  * a TCP/UDP port @a ip_port.
 936  *
 937  * @param desc service shared secret
 938  * @param ip_port TCP/UDP port, use 0 for ICMP
 939  * @param[out] cadet_port CADET port to use
 940  */
 941 void
 942 GNUNET_TUN_compute_service_cadet_port (const struct GNUNET_HashCode *desc,
 943                                        uint16_t ip_port,
 944                                        struct GNUNET_HashCode *cadet_port);
 945
 946 #endif
 947
 948 /** @} */ /* end of group */