Remove forward declaration for do_decrement_ttl.
[oweals/tinc.git] / src / route.c
index a568d1e..907197b 100644 (file)
@@ -53,8 +53,6 @@ static const size_t icmp6_size = sizeof(struct icmp6_hdr);
 static const size_t ns_size = sizeof(struct nd_neighbor_solicit);
 static const size_t opt_size = sizeof(struct nd_opt_hdr);
 
-static bool do_decrement_ttl(node_t *source, vpn_packet_t *packet);
-
 #ifndef MAX
 #define MAX(a, b) ((a) > (b) ? (a) : (b))
 #endif
@@ -103,6 +101,260 @@ static bool checklength(node_t *source, vpn_packet_t *packet, length_t length) {
                return true;
 }
 
+static void swap_mac_addresses(vpn_packet_t *packet) {
+       mac_t tmp;
+       memcpy(&tmp, &packet->data[0], sizeof tmp);
+       memcpy(&packet->data[0], &packet->data[6], sizeof tmp);
+       memcpy(&packet->data[6], &tmp, sizeof tmp);
+}
+
+/* RFC 792 */
+
+static void route_ipv4_unreachable(node_t *source, vpn_packet_t *packet, length_t ether_size, uint8_t type, uint8_t code) {
+       struct ip ip = {0};
+       struct icmp icmp = {0};
+       
+       struct in_addr ip_src;
+       struct in_addr ip_dst;
+       uint32_t oldlen;
+
+       if(ratelimit(3))
+               return;
+       
+       /* Swap Ethernet source and destination addresses */
+
+       swap_mac_addresses(packet);
+
+       /* Copy headers from packet into properly aligned structs on the stack */
+
+       memcpy(&ip, packet->data + ether_size, ip_size);
+
+       /* Remember original source and destination */
+       
+       ip_src = ip.ip_src;
+       ip_dst = ip.ip_dst;
+
+       /* Try to reply with an IP address assigned to the local machine */
+
+       if (type == ICMP_TIME_EXCEEDED && code == ICMP_EXC_TTL) {
+               int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+               if (sockfd != -1) {
+                       struct sockaddr_in addr;
+                       memset(&addr, 0, sizeof(addr));
+                       addr.sin_family = AF_INET;
+                       addr.sin_addr = ip.ip_src;
+                       if (!connect(sockfd, (const struct sockaddr*) &addr, sizeof(addr))) {
+                               memset(&addr, 0, sizeof(addr));
+                               addr.sin_family = AF_INET;
+                               socklen_t addrlen = sizeof(addr);
+                               if (!getsockname(sockfd, (struct sockaddr*) &addr, &addrlen) && addrlen <= sizeof(addr)) {
+                                       ip_dst = addr.sin_addr;
+                               }
+                       }
+                       close(sockfd);
+               }
+       }
+
+       oldlen = packet->len - ether_size;
+
+       if(type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED)
+               icmp.icmp_nextmtu = htons(packet->len - ether_size);
+
+       if(oldlen >= IP_MSS - ip_size - icmp_size)
+               oldlen = IP_MSS - ip_size - icmp_size;
+       
+       /* Copy first part of original contents to ICMP message */
+       
+       memmove(packet->data + ether_size + ip_size + icmp_size, packet->data + ether_size, oldlen);
+
+       /* Fill in IPv4 header */
+       
+       ip.ip_v = 4;
+       ip.ip_hl = ip_size / 4;
+       ip.ip_tos = 0;
+       ip.ip_len = htons(ip_size + icmp_size + oldlen);
+       ip.ip_id = 0;
+       ip.ip_off = 0;
+       ip.ip_ttl = 255;
+       ip.ip_p = IPPROTO_ICMP;
+       ip.ip_sum = 0;
+       ip.ip_src = ip_dst;
+       ip.ip_dst = ip_src;
+
+       ip.ip_sum = inet_checksum(&ip, ip_size, ~0);
+       
+       /* Fill in ICMP header */
+       
+       icmp.icmp_type = type;
+       icmp.icmp_code = code;
+       icmp.icmp_cksum = 0;
+       
+       icmp.icmp_cksum = inet_checksum(&icmp, icmp_size, ~0);
+       icmp.icmp_cksum = inet_checksum(packet->data + ether_size + ip_size + icmp_size, oldlen, icmp.icmp_cksum);
+
+       /* Copy structs on stack back to packet */
+
+       memcpy(packet->data + ether_size, &ip, ip_size);
+       memcpy(packet->data + ether_size + ip_size, &icmp, icmp_size);
+       
+       packet->len = ether_size + ip_size + icmp_size + oldlen;
+
+       send_packet(source, packet);
+}
+
+/* RFC 2463 */
+
+static void route_ipv6_unreachable(node_t *source, vpn_packet_t *packet, length_t ether_size, uint8_t type, uint8_t code) {
+       struct ip6_hdr ip6;
+       struct icmp6_hdr icmp6 = {0};
+       uint16_t checksum;      
+
+       struct {
+               struct in6_addr ip6_src;        /* source address */
+               struct in6_addr ip6_dst;        /* destination address */
+               uint32_t length;
+               uint32_t next;
+       } pseudo;
+
+       if(ratelimit(3))
+               return;
+       
+       /* Swap Ethernet source and destination addresses */
+
+       swap_mac_addresses(packet);
+
+       /* Copy headers from packet to structs on the stack */
+
+       memcpy(&ip6, packet->data + ether_size, ip6_size);
+
+       /* Remember original source and destination */
+       
+       pseudo.ip6_src = ip6.ip6_dst;
+       pseudo.ip6_dst = ip6.ip6_src;
+
+       /* Try to reply with an IP address assigned to the local machine */
+
+       if (type == ICMP6_TIME_EXCEEDED && code == ICMP6_TIME_EXCEED_TRANSIT) {
+               int sockfd = socket(AF_INET6, SOCK_DGRAM, 0);
+               if (sockfd != -1) {
+                       struct sockaddr_in6 addr;
+                       memset(&addr, 0, sizeof(addr));
+                       addr.sin6_family = AF_INET6;
+                       addr.sin6_addr = ip6.ip6_src;
+                       if (!connect(sockfd, (const struct sockaddr*) &addr, sizeof(addr))) {
+                               memset(&addr, 0, sizeof(addr));
+                               addr.sin6_family = AF_INET6;
+                               socklen_t addrlen = sizeof(addr);
+                               if (!getsockname(sockfd, (struct sockaddr*) &addr, &addrlen) && addrlen <= sizeof(addr)) {
+                                       pseudo.ip6_src = addr.sin6_addr;
+                               }
+                       }
+                       close(sockfd);
+               }
+       }
+
+       pseudo.length = packet->len - ether_size;
+
+       if(type == ICMP6_PACKET_TOO_BIG)
+               icmp6.icmp6_mtu = htonl(pseudo.length);
+       
+       if(pseudo.length >= IP_MSS - ip6_size - icmp6_size)
+               pseudo.length = IP_MSS - ip6_size - icmp6_size;
+       
+       /* Copy first part of original contents to ICMP message */
+       
+       memmove(packet->data + ether_size + ip6_size + icmp6_size, packet->data + ether_size, pseudo.length);
+
+       /* Fill in IPv6 header */
+       
+       ip6.ip6_flow = htonl(0x60000000UL);
+       ip6.ip6_plen = htons(icmp6_size + pseudo.length);
+       ip6.ip6_nxt = IPPROTO_ICMPV6;
+       ip6.ip6_hlim = 255;
+       ip6.ip6_src = pseudo.ip6_src;
+       ip6.ip6_dst = pseudo.ip6_dst;
+
+       /* Fill in ICMP header */
+       
+       icmp6.icmp6_type = type;
+       icmp6.icmp6_code = code;
+       icmp6.icmp6_cksum = 0;
+
+       /* Create pseudo header */
+               
+       pseudo.length = htonl(icmp6_size + pseudo.length);
+       pseudo.next = htonl(IPPROTO_ICMPV6);
+
+       /* Generate checksum */
+       
+       checksum = inet_checksum(&pseudo, sizeof(pseudo), ~0);
+       checksum = inet_checksum(&icmp6, icmp6_size, checksum);
+       checksum = inet_checksum(packet->data + ether_size + ip6_size + icmp6_size, ntohl(pseudo.length) - icmp6_size, checksum);
+
+       icmp6.icmp6_cksum = checksum;
+
+       /* Copy structs on stack back to packet */
+
+       memcpy(packet->data + ether_size, &ip6, ip6_size);
+       memcpy(packet->data + ether_size + ip6_size, &icmp6, icmp6_size);
+       
+       packet->len = ether_size + ip6_size + ntohl(pseudo.length);
+       
+       send_packet(source, packet);
+}
+
+static bool do_decrement_ttl(node_t *source, vpn_packet_t *packet) {
+       uint16_t type = packet->data[12] << 8 | packet->data[13];
+       length_t ethlen = ether_size;
+
+       if(type == ETH_P_8021Q) {
+               type = packet->data[16] << 8 | packet->data[17];
+               ethlen += 4;
+       }
+
+       switch (type) {
+               case ETH_P_IP:
+                       if(!checklength(source, packet, ethlen + ip_size))
+                               return false;
+
+                       if(packet->data[ethlen + 8] <= 1) {
+                               if(packet->data[ethlen + 11] != IPPROTO_ICMP || packet->data[ethlen + 32] != ICMP_TIME_EXCEEDED)
+                                       route_ipv4_unreachable(source, packet, ethlen, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL);
+                               return false;
+                       }
+
+                       uint16_t old = packet->data[ethlen + 8] << 8 | packet->data[ethlen + 9];
+                       packet->data[ethlen + 8]--;
+                       uint16_t new = packet->data[ethlen + 8] << 8 | packet->data[ethlen + 9];
+
+                       uint32_t checksum = packet->data[ethlen + 10] << 8 | packet->data[ethlen + 11];
+                       checksum += old + (~new & 0xFFFF);
+                       while(checksum >> 16)
+                               checksum = (checksum & 0xFFFF) + (checksum >> 16);
+                       packet->data[ethlen + 10] = checksum >> 8;
+                       packet->data[ethlen + 11] = checksum & 0xff;
+
+                       return true;
+
+               case ETH_P_IPV6:
+                       if(!checklength(source, packet, ethlen + ip6_size))
+                               return false;
+
+                       if(packet->data[ethlen + 7] <= 1) {
+                               if(packet->data[ethlen + 6] != IPPROTO_ICMPV6 || packet->data[ethlen + 40] != ICMP6_TIME_EXCEEDED)
+                                       route_ipv6_unreachable(source, packet, ethlen, ICMP6_TIME_EXCEEDED, ICMP6_TIME_EXCEED_TRANSIT);
+                               return false;
+                       }
+
+                       packet->data[ethlen + 7]--;
+
+                       return true;
+
+               default:
+                       return true;
+       }
+}
+
 static void clamp_mss(const node_t *source, const node_t *via, vpn_packet_t *packet) {
        if(!source || !via || !(via->options & OPTION_CLAMP_MSS))
                return;
@@ -183,13 +435,6 @@ static void clamp_mss(const node_t *source, const node_t *via, vpn_packet_t *pac
                break;
        }
 }
-
-static void swap_mac_addresses(vpn_packet_t *packet) {
-       mac_t tmp;
-       memcpy(&tmp, &packet->data[0], sizeof tmp);
-       memcpy(&packet->data[0], &packet->data[6], sizeof tmp);
-       memcpy(&packet->data[6], &tmp, sizeof tmp);
-}
        
 static void learn_mac(mac_t *address) {
        subnet_t *subnet;
@@ -261,100 +506,6 @@ static void route_broadcast(node_t *source, vpn_packet_t *packet) {
        broadcast_packet(source, packet);
 }
 
-/* RFC 792 */
-
-static void route_ipv4_unreachable(node_t *source, vpn_packet_t *packet, length_t ether_size, uint8_t type, uint8_t code) {
-       struct ip ip = {0};
-       struct icmp icmp = {0};
-       
-       struct in_addr ip_src;
-       struct in_addr ip_dst;
-       uint32_t oldlen;
-
-       if(ratelimit(3))
-               return;
-       
-       /* Swap Ethernet source and destination addresses */
-
-       swap_mac_addresses(packet);
-
-       /* Copy headers from packet into properly aligned structs on the stack */
-
-       memcpy(&ip, packet->data + ether_size, ip_size);
-
-       /* Remember original source and destination */
-       
-       ip_src = ip.ip_src;
-       ip_dst = ip.ip_dst;
-
-       /* Try to reply with an IP address assigned to the local machine */
-
-       if (type == ICMP_TIME_EXCEEDED && code == ICMP_EXC_TTL) {
-               int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
-               if (sockfd != -1) {
-                       struct sockaddr_in addr;
-                       memset(&addr, 0, sizeof(addr));
-                       addr.sin_family = AF_INET;
-                       addr.sin_addr = ip.ip_src;
-                       if (!connect(sockfd, (const struct sockaddr*) &addr, sizeof(addr))) {
-                               memset(&addr, 0, sizeof(addr));
-                               addr.sin_family = AF_INET;
-                               socklen_t addrlen = sizeof(addr);
-                               if (!getsockname(sockfd, (struct sockaddr*) &addr, &addrlen) && addrlen <= sizeof(addr)) {
-                                       ip_dst = addr.sin_addr;
-                               }
-                       }
-                       close(sockfd);
-               }
-       }
-
-       oldlen = packet->len - ether_size;
-
-       if(type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED)
-               icmp.icmp_nextmtu = htons(packet->len - ether_size);
-
-       if(oldlen >= IP_MSS - ip_size - icmp_size)
-               oldlen = IP_MSS - ip_size - icmp_size;
-       
-       /* Copy first part of original contents to ICMP message */
-       
-       memmove(packet->data + ether_size + ip_size + icmp_size, packet->data + ether_size, oldlen);
-
-       /* Fill in IPv4 header */
-       
-       ip.ip_v = 4;
-       ip.ip_hl = ip_size / 4;
-       ip.ip_tos = 0;
-       ip.ip_len = htons(ip_size + icmp_size + oldlen);
-       ip.ip_id = 0;
-       ip.ip_off = 0;
-       ip.ip_ttl = 255;
-       ip.ip_p = IPPROTO_ICMP;
-       ip.ip_sum = 0;
-       ip.ip_src = ip_dst;
-       ip.ip_dst = ip_src;
-
-       ip.ip_sum = inet_checksum(&ip, ip_size, ~0);
-       
-       /* Fill in ICMP header */
-       
-       icmp.icmp_type = type;
-       icmp.icmp_code = code;
-       icmp.icmp_cksum = 0;
-       
-       icmp.icmp_cksum = inet_checksum(&icmp, icmp_size, ~0);
-       icmp.icmp_cksum = inet_checksum(packet->data + ether_size + ip_size + icmp_size, oldlen, icmp.icmp_cksum);
-
-       /* Copy structs on stack back to packet */
-
-       memcpy(packet->data + ether_size, &ip, ip_size);
-       memcpy(packet->data + ether_size + ip_size, &icmp, icmp_size);
-       
-       packet->len = ether_size + ip_size + icmp_size + oldlen;
-
-       send_packet(source, packet);
-}
-
 /* RFC 791 */
 
 static void fragment_ipv4_packet(node_t *dest, vpn_packet_t *packet, length_t ether_size) {
@@ -484,107 +635,6 @@ static void route_ipv4(node_t *source, vpn_packet_t *packet) {
                route_ipv4_unicast(source, packet);
 }
 
-/* RFC 2463 */
-
-static void route_ipv6_unreachable(node_t *source, vpn_packet_t *packet, length_t ether_size, uint8_t type, uint8_t code) {
-       struct ip6_hdr ip6;
-       struct icmp6_hdr icmp6 = {0};
-       uint16_t checksum;      
-
-       struct {
-               struct in6_addr ip6_src;        /* source address */
-               struct in6_addr ip6_dst;        /* destination address */
-               uint32_t length;
-               uint32_t next;
-       } pseudo;
-
-       if(ratelimit(3))
-               return;
-       
-       /* Swap Ethernet source and destination addresses */
-
-       swap_mac_addresses(packet);
-
-       /* Copy headers from packet to structs on the stack */
-
-       memcpy(&ip6, packet->data + ether_size, ip6_size);
-
-       /* Remember original source and destination */
-       
-       pseudo.ip6_src = ip6.ip6_dst;
-       pseudo.ip6_dst = ip6.ip6_src;
-
-       /* Try to reply with an IP address assigned to the local machine */
-
-       if (type == ICMP6_TIME_EXCEEDED && code == ICMP6_TIME_EXCEED_TRANSIT) {
-               int sockfd = socket(AF_INET6, SOCK_DGRAM, 0);
-               if (sockfd != -1) {
-                       struct sockaddr_in6 addr;
-                       memset(&addr, 0, sizeof(addr));
-                       addr.sin6_family = AF_INET6;
-                       addr.sin6_addr = ip6.ip6_src;
-                       if (!connect(sockfd, (const struct sockaddr*) &addr, sizeof(addr))) {
-                               memset(&addr, 0, sizeof(addr));
-                               addr.sin6_family = AF_INET6;
-                               socklen_t addrlen = sizeof(addr);
-                               if (!getsockname(sockfd, (struct sockaddr*) &addr, &addrlen) && addrlen <= sizeof(addr)) {
-                                       pseudo.ip6_src = addr.sin6_addr;
-                               }
-                       }
-                       close(sockfd);
-               }
-       }
-
-       pseudo.length = packet->len - ether_size;
-
-       if(type == ICMP6_PACKET_TOO_BIG)
-               icmp6.icmp6_mtu = htonl(pseudo.length);
-       
-       if(pseudo.length >= IP_MSS - ip6_size - icmp6_size)
-               pseudo.length = IP_MSS - ip6_size - icmp6_size;
-       
-       /* Copy first part of original contents to ICMP message */
-       
-       memmove(packet->data + ether_size + ip6_size + icmp6_size, packet->data + ether_size, pseudo.length);
-
-       /* Fill in IPv6 header */
-       
-       ip6.ip6_flow = htonl(0x60000000UL);
-       ip6.ip6_plen = htons(icmp6_size + pseudo.length);
-       ip6.ip6_nxt = IPPROTO_ICMPV6;
-       ip6.ip6_hlim = 255;
-       ip6.ip6_src = pseudo.ip6_src;
-       ip6.ip6_dst = pseudo.ip6_dst;
-
-       /* Fill in ICMP header */
-       
-       icmp6.icmp6_type = type;
-       icmp6.icmp6_code = code;
-       icmp6.icmp6_cksum = 0;
-
-       /* Create pseudo header */
-               
-       pseudo.length = htonl(icmp6_size + pseudo.length);
-       pseudo.next = htonl(IPPROTO_ICMPV6);
-
-       /* Generate checksum */
-       
-       checksum = inet_checksum(&pseudo, sizeof(pseudo), ~0);
-       checksum = inet_checksum(&icmp6, icmp6_size, checksum);
-       checksum = inet_checksum(packet->data + ether_size + ip6_size + icmp6_size, ntohl(pseudo.length) - icmp6_size, checksum);
-
-       icmp6.icmp6_cksum = checksum;
-
-       /* Copy structs on stack back to packet */
-
-       memcpy(packet->data + ether_size, &ip6, ip6_size);
-       memcpy(packet->data + ether_size + ip6_size, &icmp6, icmp6_size);
-       
-       packet->len = ether_size + ip6_size + ntohl(pseudo.length);
-       
-       send_packet(source, packet);
-}
-
 static void route_ipv6_unicast(node_t *source, vpn_packet_t *packet) {
        subnet_t *subnet;
        node_t *via;
@@ -951,58 +1001,6 @@ static void route_mac(node_t *source, vpn_packet_t *packet) {
        send_packet(subnet->owner, packet);
 }
 
-static bool do_decrement_ttl(node_t *source, vpn_packet_t *packet) {
-       uint16_t type = packet->data[12] << 8 | packet->data[13];
-       length_t ethlen = ether_size;
-
-       if(type == ETH_P_8021Q) {
-               type = packet->data[16] << 8 | packet->data[17];
-               ethlen += 4;
-       }
-
-       switch (type) {
-               case ETH_P_IP:
-                       if(!checklength(source, packet, ethlen + ip_size))
-                               return false;
-
-                       if(packet->data[ethlen + 8] <= 1) {
-                               if(packet->data[ethlen + 11] != IPPROTO_ICMP || packet->data[ethlen + 32] != ICMP_TIME_EXCEEDED)
-                                       route_ipv4_unreachable(source, packet, ethlen, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL);
-                               return false;
-                       }
-
-                       uint16_t old = packet->data[ethlen + 8] << 8 | packet->data[ethlen + 9];
-                       packet->data[ethlen + 8]--;
-                       uint16_t new = packet->data[ethlen + 8] << 8 | packet->data[ethlen + 9];
-
-                       uint32_t checksum = packet->data[ethlen + 10] << 8 | packet->data[ethlen + 11];
-                       checksum += old + (~new & 0xFFFF);
-                       while(checksum >> 16)
-                               checksum = (checksum & 0xFFFF) + (checksum >> 16);
-                       packet->data[ethlen + 10] = checksum >> 8;
-                       packet->data[ethlen + 11] = checksum & 0xff;
-
-                       return true;
-
-               case ETH_P_IPV6:
-                       if(!checklength(source, packet, ethlen + ip6_size))
-                               return false;
-
-                       if(packet->data[ethlen + 7] <= 1) {
-                               if(packet->data[ethlen + 6] != IPPROTO_ICMPV6 || packet->data[ethlen + 40] != ICMP6_TIME_EXCEEDED)
-                                       route_ipv6_unreachable(source, packet, ethlen, ICMP6_TIME_EXCEEDED, ICMP6_TIME_EXCEED_TRANSIT);
-                               return false;
-                       }
-
-                       packet->data[ethlen + 7]--;
-
-                       return true;
-
-               default:
-                       return true;
-       }
-}
-
 void route(node_t *source, vpn_packet_t *packet) {
        if(forwarding_mode == FMODE_KERNEL && source != myself) {
                send_packet(myself, packet);