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   /**
 394    * query:0, response:1
 395    */
 396   unsigned int query_or_response : 1 GNUNET_PACKED;
 397
 398   /**
 399    * See GNUNET_TUN_DNS_OPCODE_ defines.
 400    */
 401   unsigned int opcode : 4 GNUNET_PACKED;
 402
 403   /**
 404    * Set to 1 if this is an authoritative answer
 405    */
 406   unsigned int authoritative_answer : 1 GNUNET_PACKED;
 407
 408   /**
 409    * Set to 1 if message is truncated
 410    */
 411   unsigned int message_truncated : 1 GNUNET_PACKED;
 412
 413   /**
 414    * Set to 1 if recursion is desired (client -> server)
 415    */
 416   unsigned int recursion_desired : 1 GNUNET_PACKED;
 417
 418
 419   /**
 420    * Set to 1 if recursion is available (server -> client)
 421    */
 422   unsigned int recursion_available : 1 GNUNET_PACKED;
 423
 424   /**
 425    * Always zero.
 426    */
 427   unsigned int zero : 1 GNUNET_PACKED;
 428
 429   /**
 430    * Response has been cryptographically verified, RFC 4035.
 431    */
 432   unsigned int authenticated_data : 1 GNUNET_PACKED;
 433
 434   /**
 435    * See RFC 4035.
 436    */
 437   unsigned int checking_disabled : 1 GNUNET_PACKED;
 438
 439   /**
 440    * See GNUNET_TUN_DNS_RETURN_CODE_ defines.
 441    */
 442   unsigned int return_code : 4 GNUNET_PACKED;
 443 #else
 444 #error byteorder undefined
 445 #endif
 446
 447 } GNUNET_GCC_STRUCT_LAYOUT;
 448
 449
 450 /**
 451  * DNS header.
 452  */
 453 struct GNUNET_TUN_DnsHeader
 454 {
 455   /**
 456    * Unique identifier for the request/response.
 457    */
 458   uint16_t id GNUNET_PACKED;
 459
 460   /**
 461    * Flags.
 462    */
 463   struct GNUNET_TUN_DnsFlags flags;
 464
 465   /**
 466    * Number of queries.
 467    */
 468   uint16_t query_count GNUNET_PACKED;
 469
 470   /**
 471    * Number of answers.
 472    */
 473   uint16_t answer_rcount GNUNET_PACKED;
 474
 475   /**
 476    * Number of authoritative answers.
 477    */
 478   uint16_t authority_rcount GNUNET_PACKED;
 479
 480   /**
 481    * Number of additional records.
 482    */
 483   uint16_t additional_rcount GNUNET_PACKED;
 484 };
 485
 486
 487 /**
 488  * Payload of DNS SOA record (header).
 489  */
 490 struct GNUNET_TUN_DnsSoaRecord
 491 {
 492   /**
 493    * The version number of the original copy of the zone.   (NBO)
 494    */
 495   uint32_t serial GNUNET_PACKED;
 496
 497   /**
 498    * Time interval before the zone should be refreshed. (NBO)
 499    */
 500   uint32_t refresh GNUNET_PACKED;
 501
 502   /**
 503    * Time interval that should elapse before a failed refresh should
 504    * be retried. (NBO)
 505    */
 506   uint32_t retry GNUNET_PACKED;
 507
 508   /**
 509    * Time value that specifies the upper limit on the time interval
 510    * that can elapse before the zone is no longer authoritative. (NBO)
 511    */
 512   uint32_t expire GNUNET_PACKED;
 513
 514   /**
 515    * The bit minimum TTL field that should be exported with any RR
 516    * from this zone. (NBO)
 517    */
 518   uint32_t minimum GNUNET_PACKED;
 519 };
 520
 521
 522 /**
 523  * Payload of DNS SRV record (header).
 524  */
 525 struct GNUNET_TUN_DnsSrvRecord
 526 {
 527
 528   /**
 529    * Preference for this entry (lower value is higher preference).  Clients
 530    * will contact hosts from the lowest-priority group first and fall back
 531    * to higher priorities if the low-priority entries are unavailable. (NBO)
 532    */
 533   uint16_t prio GNUNET_PACKED;
 534
 535   /**
 536    * Relative weight for records with the same priority.  Clients will use
 537    * the hosts of the same (lowest) priority with a probability proportional
 538    * to the weight given. (NBO)
 539    */
 540   uint16_t weight GNUNET_PACKED;
 541
 542   /**
 543    * TCP or UDP port of the service. (NBO)
 544    */
 545   uint16_t port GNUNET_PACKED;
 546
 547   /* followed by 'target' name */
 548 };
 549
 550
 551 /**
 552  * Payload of DNS CERT record.
 553  */
 554 struct GNUNET_TUN_DnsCertRecord
 555 {
 556
 557   /**
 558    * Certificate type
 559    */
 560   uint16_t cert_type;
 561
 562   /**
 563    * Certificate KeyTag
 564    */
 565   uint16_t cert_tag;
 566
 567   /**
 568    * Algorithm
 569    */
 570   uint8_t algorithm;
 571
 572   /* Followed by the certificate */
 573 };
 574
 575
 576 /**
 577  * Payload of DNSSEC TLSA record.
 578  * http://datatracker.ietf.org/doc/draft-ietf-dane-protocol/
 579  */
 580 struct GNUNET_TUN_DnsTlsaRecord
 581 {
 582
 583   /**
 584    * Certificate usage
 585    * 0: CA cert
 586    * 1: Entity cert
 587    * 2: Trust anchor
 588    * 3: domain-issued cert
 589    */
 590   uint8_t usage;
 591
 592   /**
 593    * Selector
 594    * What part will be matched against the cert
 595    * presented by server
 596    * 0: Full cert (in binary)
 597    * 1: Full cert (in DER)
 598    */
 599   uint8_t selector;
 600
 601   /**
 602    * Matching type (of selected content)
 603    * 0: exact match
 604    * 1: SHA-256 hash
 605    * 2: SHA-512 hash
 606    */
 607   uint8_t matching_type;
 608
 609   /**
 610    * followed by certificate association data
 611    * The "certificate association data" to be matched.
 612    * These bytes are either raw data (that is, the full certificate or
 613    * its SubjectPublicKeyInfo, depending on the selector) for matching
 614    * type 0, or the hash of the raw data for matching types 1 and 2.
 615    * The data refers to the certificate in the association, not to the
 616    * TLS ASN.1 Certificate object.
 617    *
 618    * The data is represented as a string of hex chars
 619    */
 620 };
 621
 622
 623 /**
 624  * Payload of GNS VPN record
 625  */
 626 struct GNUNET_TUN_GnsVpnRecord
 627 {
 628   /**
 629    * The peer to contact
 630    */
 631   struct GNUNET_PeerIdentity peer;
 632
 633   /**
 634    * The protocol to use
 635    */
 636   uint16_t proto;
 637
 638   /* followed by the servicename */
 639 };
 640
 641
 642 /**
 643  * DNS query prefix.
 644  */
 645 struct GNUNET_TUN_DnsQueryLine
 646 {
 647   /**
 648    * Desired type (GNUNET_DNSPARSER_TYPE_XXX). (NBO)
 649    */
 650   uint16_t type GNUNET_PACKED;
 651
 652   /**
 653    * Desired class (usually GNUNET_TUN_DNS_CLASS_INTERNET). (NBO)
 654    */
 655   uint16_t dns_traffic_class GNUNET_PACKED;
 656 };
 657
 658
 659 /**
 660  * General DNS record prefix.
 661  */
 662 struct GNUNET_TUN_DnsRecordLine
 663 {
 664   /**
 665    * Record type (GNUNET_DNSPARSER_TYPE_XXX). (NBO)
 666    */
 667   uint16_t type GNUNET_PACKED;
 668
 669   /**
 670    * Record class (usually GNUNET_TUN_DNS_CLASS_INTERNET). (NBO)
 671    */
 672   uint16_t dns_traffic_class GNUNET_PACKED;
 673
 674   /**
 675    * Expiration for the record (in seconds). (NBO)
 676    */
 677   uint32_t ttl GNUNET_PACKED;
 678
 679   /**
 680    * Number of bytes of data that follow. (NBO)
 681    */
 682   uint16_t data_len GNUNET_PACKED;
 683 };
 684
 685
 686 #define GNUNET_TUN_ICMPTYPE_ECHO_REPLY 0
 687 #define GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE 3
 688 #define GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH 4
 689 #define GNUNET_TUN_ICMPTYPE_REDIRECT_MESSAGE 5
 690 #define GNUNET_TUN_ICMPTYPE_ECHO_REQUEST 8
 691 #define GNUNET_TUN_ICMPTYPE_ROUTER_ADVERTISEMENT 9
 692 #define GNUNET_TUN_ICMPTYPE_ROUTER_SOLICITATION 10
 693 #define GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED 11
 694
 695 #define GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE 1
 696 #define GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG 2
 697 #define GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED 3
 698 #define GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM 4
 699 #define GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST 128
 700 #define GNUNET_TUN_ICMPTYPE6_ECHO_REPLY 129
 701
 702
 703 /**
 704  * ICMP header.
 705  */
 706 struct GNUNET_TUN_IcmpHeader
 707 {
 708   uint8_t type;
 709   uint8_t code;
 710   uint16_t crc GNUNET_PACKED;
 711
 712   union
 713   {
 714     /**
 715      * ICMP Echo (request/reply)
 716      */
 717     struct
 718     {
 719       uint16_t identifier GNUNET_PACKED;
 720       uint16_t sequence_number GNUNET_PACKED;
 721     } echo;
 722
 723     /**
 724      * ICMP Destination Unreachable (RFC 1191)
 725      */
 726     struct ih_pmtu
 727     {
 728       uint16_t empty GNUNET_PACKED;
 729       uint16_t next_hop_mtu GNUNET_PACKED;
 730       /* followed by original IP header + first 8 bytes of original IP datagram
 731        */
 732     } destination_unreachable;
 733
 734     /**
 735      * ICMP Redirect
 736      */
 737     struct in_addr redirect_gateway_address;
 738
 739     /**
 740      * MTU for packets that are too big (IPv6).
 741      */
 742     uint32_t packet_too_big_mtu GNUNET_PACKED;
 743
 744   } quench;
 745 };
 746
 747
 748 GNUNET_NETWORK_STRUCT_END
 749
 750
 751 /**
 752  * Initialize an IPv4 header.
 753  *
 754  * @param ip header to initialize
 755  * @param protocol protocol to use (i.e. IPPROTO_UDP)
 756  * @param payload_length number of bytes of payload that follow (excluding IPv4
 757  * header)
 758  * @param src source IP address to use
 759  * @param dst destination IP address to use
 760  */
 761 void
 762 GNUNET_TUN_initialize_ipv4_header (struct GNUNET_TUN_IPv4Header *ip,
 763                                    uint8_t protocol,
 764                                    uint16_t payload_length,
 765                                    const struct in_addr *src,
 766                                    const struct in_addr *dst);
 767
 768
 769 /**
 770  * Initialize an IPv6 header.
 771  *
 772  * @param ip header to initialize
 773  * @param protocol protocol to use (i.e. IPPROTO_UDP)
 774  * @param payload_length number of bytes of payload that follow (excluding IPv4
 775  * header)
 776  * @param src source IP address to use
 777  * @param dst destination IP address to use
 778  */
 779 void
 780 GNUNET_TUN_initialize_ipv6_header (struct GNUNET_TUN_IPv6Header *ip,
 781                                    uint8_t protocol,
 782                                    uint16_t payload_length,
 783                                    const struct in6_addr *src,
 784                                    const struct in6_addr *dst);
 785
 786 /**
 787  * Calculate IPv4 TCP checksum.
 788  *
 789  * @param ip ipv4 header fully initialized
 790  * @param tcp TCP header (initialized except for CRC)
 791  * @param payload the TCP payload
 792  * @param payload_length number of bytes of TCP @a payload
 793  */
 794 void
 795 GNUNET_TUN_calculate_tcp4_checksum (const struct GNUNET_TUN_IPv4Header *ip,
 796                                     struct GNUNET_TUN_TcpHeader *tcp,
 797                                     const void *payload,
 798                                     uint16_t payload_length);
 799
 800 /**
 801  * Calculate IPv6 TCP checksum.
 802  *
 803  * @param ip ipv6 header fully initialized
 804  * @param tcp TCP header (initialized except for CRC)
 805  * @param payload the TCP payload
 806  * @param payload_length number of bytes of TCP payload
 807  */
 808 void
 809 GNUNET_TUN_calculate_tcp6_checksum (const struct GNUNET_TUN_IPv6Header *ip,
 810                                     struct GNUNET_TUN_TcpHeader *tcp,
 811                                     const void *payload,
 812                                     uint16_t payload_length);
 813
 814 /**
 815  * Calculate IPv4 UDP checksum.
 816  *
 817  * @param ip ipv4 header fully initialized
 818  * @param udp UDP header (initialized except for CRC)
 819  * @param payload the UDP payload
 820  * @param payload_length number of bytes of UDP @a payload
 821  */
 822 void
 823 GNUNET_TUN_calculate_udp4_checksum (const struct GNUNET_TUN_IPv4Header *ip,
 824                                     struct GNUNET_TUN_UdpHeader *udp,
 825                                     const void *payload,
 826                                     uint16_t payload_length);
 827
 828
 829 /**
 830  * Calculate IPv6 UDP checksum.
 831  *
 832  * @param ip ipv6 header fully initialized
 833  * @param udp UDP header (initialized except for CRC)
 834  * @param payload the UDP payload
 835  * @param payload_length number of bytes of @a payload
 836  */
 837 void
 838 GNUNET_TUN_calculate_udp6_checksum (const struct GNUNET_TUN_IPv6Header *ip,
 839                                     struct GNUNET_TUN_UdpHeader *udp,
 840                                     const void *payload,
 841                                     uint16_t payload_length);
 842
 843
 844 /**
 845  * Calculate ICMP checksum.
 846  *
 847  * @param icmp IMCP header (initialized except for CRC)
 848  * @param payload the ICMP payload
 849  * @param payload_length number of bytes of @a payload
 850  */
 851 void
 852 GNUNET_TUN_calculate_icmp_checksum (struct GNUNET_TUN_IcmpHeader *icmp,
 853                                     const void *payload,
 854                                     uint16_t payload_length);
 855
 856
 857 /**
 858  * Create a regex in @a rxstr from the given @a ip and @a port.
 859  *
 860  * @param ip IPv4 representation.
 861  * @param port destination port
 862  * @param rxstr generated regex, must be at least #GNUNET_TUN_IPV4_REGEXLEN
 863  *              bytes long.
 864  */
 865 void
 866 GNUNET_TUN_ipv4toregexsearch (const struct in_addr *ip,
 867                               uint16_t port,
 868                               char *rxstr);
 869
 870
 871 /**
 872  * Create a regex in @a rxstr from the given @a ipv6 and @a port.
 873  *
 874  * @param ipv6 IPv6 representation.
 875  * @param port destination port
 876  * @param rxstr generated regex, must be at least #GNUNET_TUN_IPV6_REGEXLEN
 877  *              bytes long.
 878  */
 879 void
 880 GNUNET_TUN_ipv6toregexsearch (const struct in6_addr *ipv6,
 881                               uint16_t port,
 882                               char *rxstr);
 883
 884
 885 /**
 886  * Convert an exit policy to a regular expression.  The exit policy
 887  * specifies a set of subnets this peer is willing to serve as an
 888  * exit for; the resulting regular expression will match the
 889  * IPv6 address strings as returned by #GNUNET_TUN_ipv6toregexsearch.
 890  *
 891  * @param policy exit policy specification
 892  * @return regular expression, NULL on error
 893  */
 894 char *
 895 GNUNET_TUN_ipv6policy2regex (const char *policy);
 896
 897
 898 /**
 899  * Convert an exit policy to a regular expression.  The exit policy
 900  * specifies a set of subnets this peer is willing to serve as an
 901  * exit for; the resulting regular expression will match the
 902  * IPv4 address strings as returned by #GNUNET_TUN_ipv4toregexsearch.
 903  *
 904  * @param policy exit policy specification
 905  * @return regular expression, NULL on error
 906  */
 907 char *
 908 GNUNET_TUN_ipv4policy2regex (const char *policy);
 909
 910
 911 /**
 912  * Hash the service name of a hosted service to the
 913  * hash code that is used to identify the service on
 914  * the network.
 915  *
 916  * @param service_name a string
 917  * @param[out] hc corresponding hash
 918  */
 919 void
 920 GNUNET_TUN_service_name_to_hash (const char *service_name,
 921                                  struct GNUNET_HashCode *hc);
 922
 923
 924 /**
 925  * Check if two sockaddrs are equal.
 926  *
 927  * @param sa one address
 928  * @param sb another address
 929  * @param include_port also check ports
 930  * @return #GNUNET_YES if they are equal
 931  */
 932 int
 933 GNUNET_TUN_sockaddr_cmp (const struct sockaddr *sa,
 934                          const struct sockaddr *sb,
 935                          int include_port);
 936
 937
 938 /**
 939  * Compute the CADET port given a service descriptor
 940  * (returned from #GNUNET_TUN_service_name_to_hash) and
 941  * a TCP/UDP port @a ip_port.
 942  *
 943  * @param desc service shared secret
 944  * @param ip_port TCP/UDP port, use 0 for ICMP
 945  * @param[out] cadet_port CADET port to use
 946  */
 947 void
 948 GNUNET_TUN_compute_service_cadet_port (const struct GNUNET_HashCode *desc,
 949                                        uint16_t ip_port,
 950                                        struct GNUNET_HashCode *cadet_port);
 951
 952 #endif
 953
 954 /** @} */ /* end of group */