Pavel S / UIPEthernet

mbed OS5

Fork of UIPEthernet by Zoltan Hudak

utility/uip.c@3:5b17e4656dd0, 2014-12-20 (annotated)

Committer:
hudakz
Date:
Sat Dec 20 11:10:40 2014 +0000
Revision:
3:5b17e4656dd0
Child:
4:d774541a34da
02 Name clash with "Ethernet" fixed for LPC1768

Who changed what in which revision?

UserRevisionLine numberNew contents of line
hudakz 3:5b17e4656dd0 1 #define DEBUG_PRINTF(...) /*printf(__VA_ARGS__)*/
hudakz 3:5b17e4656dd0 2
hudakz 3:5b17e4656dd0 3 /**
hudakz 3:5b17e4656dd0 4 * \defgroup uip The uIP TCP/IP stack
hudakz 3:5b17e4656dd0 5 * @{
hudakz 3:5b17e4656dd0 6 *
hudakz 3:5b17e4656dd0 7 * uIP is an implementation of the TCP/IP protocol stack intended for
hudakz 3:5b17e4656dd0 8 * small 8-bit and 16-bit microcontrollers.
hudakz 3:5b17e4656dd0 9 *
hudakz 3:5b17e4656dd0 10 * uIP provides the necessary protocols for Internet communication,
hudakz 3:5b17e4656dd0 11 * with a very small code footprint and RAM requirements - the uIP
hudakz 3:5b17e4656dd0 12 * code size is on the order of a few kilobytes and RAM usage is on
hudakz 3:5b17e4656dd0 13 * the order of a few hundred bytes.
hudakz 3:5b17e4656dd0 14 */
hudakz 3:5b17e4656dd0 15
hudakz 3:5b17e4656dd0 16 /**
hudakz 3:5b17e4656dd0 17 * \file
hudakz 3:5b17e4656dd0 18 * The uIP TCP/IP stack code.
hudakz 3:5b17e4656dd0 19 * \author Adam Dunkels <adam@dunkels.com>
hudakz 3:5b17e4656dd0 20 */
hudakz 3:5b17e4656dd0 21 /*
hudakz 3:5b17e4656dd0 22 * Copyright (c) 2001-2003, Adam Dunkels.
hudakz 3:5b17e4656dd0 23 * All rights reserved.
hudakz 3:5b17e4656dd0 24 *
hudakz 3:5b17e4656dd0 25 * Redistribution and use in source and binary forms, with or without
hudakz 3:5b17e4656dd0 26 * modification, are permitted provided that the following conditions
hudakz 3:5b17e4656dd0 27 * are met:
hudakz 3:5b17e4656dd0 28 * 1. Redistributions of source code must retain the above copyright
hudakz 3:5b17e4656dd0 29 * notice, this list of conditions and the following disclaimer.
hudakz 3:5b17e4656dd0 30 * 2. Redistributions in binary form must reproduce the above copyright
hudakz 3:5b17e4656dd0 31 * notice, this list of conditions and the following disclaimer in the
hudakz 3:5b17e4656dd0 32 * documentation and/or other materials provided with the distribution.
hudakz 3:5b17e4656dd0 33 * 3. The name of the author may not be used to endorse or promote
hudakz 3:5b17e4656dd0 34 * products derived from this software without specific prior
hudakz 3:5b17e4656dd0 35 * written permission.
hudakz 3:5b17e4656dd0 36 *
hudakz 3:5b17e4656dd0 37 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
hudakz 3:5b17e4656dd0 38 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
hudakz 3:5b17e4656dd0 39 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
hudakz 3:5b17e4656dd0 40 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
hudakz 3:5b17e4656dd0 41 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
hudakz 3:5b17e4656dd0 42 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
hudakz 3:5b17e4656dd0 43 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
hudakz 3:5b17e4656dd0 44 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
hudakz 3:5b17e4656dd0 45 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
hudakz 3:5b17e4656dd0 46 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
hudakz 3:5b17e4656dd0 47 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
hudakz 3:5b17e4656dd0 48 *
hudakz 3:5b17e4656dd0 49 * This file is part of the uIP TCP/IP stack.
hudakz 3:5b17e4656dd0 50 *
hudakz 3:5b17e4656dd0 51 * $Id: uip.c,v 1.65 2006/06/11 21:46:39 adam Exp $
hudakz 3:5b17e4656dd0 52 *
hudakz 3:5b17e4656dd0 53 */
hudakz 3:5b17e4656dd0 54 /*
hudakz 3:5b17e4656dd0 55 * uIP is a small implementation of the IP, UDP and TCP protocols (as
hudakz 3:5b17e4656dd0 56 * well as some basic ICMP stuff). The implementation couples the IP,
hudakz 3:5b17e4656dd0 57 * UDP, TCP and the application layers very tightly. To keep the size
hudakz 3:5b17e4656dd0 58 * of the compiled code down, this code frequently uses the goto
hudakz 3:5b17e4656dd0 59 * statement. While it would be possible to break the uip_process()
hudakz 3:5b17e4656dd0 60 * function into many smaller functions, this would increase the code
hudakz 3:5b17e4656dd0 61 * size because of the overhead of parameter passing and the fact that
hudakz 3:5b17e4656dd0 62 * the optimier would not be as efficient.
hudakz 3:5b17e4656dd0 63 *
hudakz 3:5b17e4656dd0 64 * The principle is that we have a small buffer, called the uip_buf,
hudakz 3:5b17e4656dd0 65 * in which the device driver puts an incoming packet. The TCP/IP
hudakz 3:5b17e4656dd0 66 * stack parses the headers in the packet, and calls the
hudakz 3:5b17e4656dd0 67 * application. If the remote host has sent data to the application,
hudakz 3:5b17e4656dd0 68 * this data is present in the uip_buf and the application read the
hudakz 3:5b17e4656dd0 69 * data from there. It is up to the application to put this data into
hudakz 3:5b17e4656dd0 70 * a byte stream if needed. The application will not be fed with data
hudakz 3:5b17e4656dd0 71 * that is out of sequence.
hudakz 3:5b17e4656dd0 72 *
hudakz 3:5b17e4656dd0 73 * If the application whishes to send data to the peer, it should put
hudakz 3:5b17e4656dd0 74 * its data into the uip_buf. The uip_appdata pointer points to the
hudakz 3:5b17e4656dd0 75 * first available byte. The TCP/IP stack will calculate the
hudakz 3:5b17e4656dd0 76 * checksums, and fill in the necessary header fields and finally send
hudakz 3:5b17e4656dd0 77 * the packet back to the peer.
hudakz 3:5b17e4656dd0 78 */
hudakz 3:5b17e4656dd0 79 #include "uip.h"
hudakz 3:5b17e4656dd0 80 #include "uipopt.h"
hudakz 3:5b17e4656dd0 81 #include "uip_arch.h"
hudakz 3:5b17e4656dd0 82
hudakz 3:5b17e4656dd0 83 #if UIP_CONF_IPV6
hudakz 3:5b17e4656dd0 84 #include "uip-neighbor.h"
hudakz 3:5b17e4656dd0 85 #endif /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 86
hudakz 3:5b17e4656dd0 87 #include <string.h>
hudakz 3:5b17e4656dd0 88
hudakz 3:5b17e4656dd0 89 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 90
hudakz 3:5b17e4656dd0 91 /* Variable definitions. */
hudakz 3:5b17e4656dd0 92 /* The IP address of this host. If it is defined to be fixed (by
hudakz 3:5b17e4656dd0 93 setting UIP_FIXEDADDR to 1 in uipopt.h), the address is set
hudakz 3:5b17e4656dd0 94 here. Otherwise, the address */
hudakz 3:5b17e4656dd0 95 #if UIP_FIXEDADDR > 0
hudakz 3:5b17e4656dd0 96 const uip_ipaddr_t uip_hostaddr = { HTONS((UIP_IPADDR0 << 8) | UIP_IPADDR1), HTONS
hudakz 3:5b17e4656dd0 97 ((UIP_IPADDR2 << 8) | UIP_IPADDR3) };
hudakz 3:5b17e4656dd0 98 const uip_ipaddr_t uip_draddr =
hudakz 3:5b17e4656dd0 99 {
hudakz 3:5b17e4656dd0 100 HTONS((UIP_DRIPADDR0 << 8) | UIP_DRIPADDR1),
hudakz 3:5b17e4656dd0 101 HTONS((UIP_DRIPADDR2 << 8) | UIP_DRIPADDR3)
hudakz 3:5b17e4656dd0 102 };
hudakz 3:5b17e4656dd0 103 const uip_ipaddr_t uip_netmask =
hudakz 3:5b17e4656dd0 104 {
hudakz 3:5b17e4656dd0 105 HTONS((UIP_NETMASK0 << 8) | UIP_NETMASK1),
hudakz 3:5b17e4656dd0 106 HTONS((UIP_NETMASK2 << 8) | UIP_NETMASK3)
hudakz 3:5b17e4656dd0 107 };
hudakz 3:5b17e4656dd0 108 #else
hudakz 3:5b17e4656dd0 109 uip_ipaddr_t uip_hostaddr, uip_draddr, uip_netmask;
hudakz 3:5b17e4656dd0 110 #endif /* UIP_FIXEDADDR */
hudakz 3:5b17e4656dd0 111
hudakz 3:5b17e4656dd0 112 static const uip_ipaddr_t all_ones_addr =
hudakz 3:5b17e4656dd0 113 #if UIP_CONF_IPV6
hudakz 3:5b17e4656dd0 114 { 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff };
hudakz 3:5b17e4656dd0 115 #else /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 116 {
hudakz 3:5b17e4656dd0 117 0xffff, 0xffff
hudakz 3:5b17e4656dd0 118 };
hudakz 3:5b17e4656dd0 119 #endif /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 120 static const uip_ipaddr_t all_zeroes_addr =
hudakz 3:5b17e4656dd0 121 #if UIP_CONF_IPV6
hudakz 3:5b17e4656dd0 122 { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 };
hudakz 3:5b17e4656dd0 123 #else /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 124 {
hudakz 3:5b17e4656dd0 125 0x0000, 0x0000
hudakz 3:5b17e4656dd0 126 };
hudakz 3:5b17e4656dd0 127 #endif /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 128
hudakz 3:5b17e4656dd0 129 #if UIP_FIXEDETHADDR
hudakz 3:5b17e4656dd0 130 const struct uip_eth_addr uip_ethaddr =
hudakz 3:5b17e4656dd0 131 {
hudakz 3:5b17e4656dd0 132 { UIP_ETHADDR0, UIP_ETHADDR1, UIP_ETHADDR2, UIP_ETHADDR3, UIP_ETHADDR4, UIP_ETHADDR5 }
hudakz 3:5b17e4656dd0 133 };
hudakz 3:5b17e4656dd0 134 #else
hudakz 3:5b17e4656dd0 135 struct uip_eth_addr uip_ethaddr = { { 0, 0, 0, 0, 0, 0 } };
hudakz 3:5b17e4656dd0 136 #endif
hudakz 3:5b17e4656dd0 137 #ifndef UIP_CONF_EXTERNAL_BUFFER
hudakz 3:5b17e4656dd0 138 u8_t uip_buf[UIP_BUFSIZE + 2]; /* The packet buffer that contains
hudakz 3:5b17e4656dd0 139 incoming packets. */
hudakz 3:5b17e4656dd0 140 #endif /* UIP_CONF_EXTERNAL_BUFFER */
hudakz 3:5b17e4656dd0 141
hudakz 3:5b17e4656dd0 142 void* uip_appdata; /* The uip_appdata pointer points to
hudakz 3:5b17e4656dd0 143 application data. */
hudakz 3:5b17e4656dd0 144 void* uip_sappdata; /* The uip_appdata pointer points to
hudakz 3:5b17e4656dd0 145 the application data which is to
hudakz 3:5b17e4656dd0 146 be sent. */
hudakz 3:5b17e4656dd0 147 #if UIP_URGDATA > 0
hudakz 3:5b17e4656dd0 148 void* uip_urgdata; /* The uip_urgdata pointer points to
hudakz 3:5b17e4656dd0 149 urgent data (out-of-band data), if
hudakz 3:5b17e4656dd0 150 present. */
hudakz 3:5b17e4656dd0 151 u16_t uip_urglen, uip_surglen;
hudakz 3:5b17e4656dd0 152 #endif /* UIP_URGDATA > 0 */
hudakz 3:5b17e4656dd0 153
hudakz 3:5b17e4656dd0 154 u16_t uip_len, uip_slen;
hudakz 3:5b17e4656dd0 155
hudakz 3:5b17e4656dd0 156 /* The uip_len is either 8 or 16 bits,
hudakz 3:5b17e4656dd0 157 depending on the maximum packet
hudakz 3:5b17e4656dd0 158 size. */
hudakz 3:5b17e4656dd0 159 u8_t uip_flags; /* The uip_flags variable is used for
hudakz 3:5b17e4656dd0 160 communication between the TCP/IP stack
hudakz 3:5b17e4656dd0 161 and the application program. */
hudakz 3:5b17e4656dd0 162 struct uip_conn* uip_conn; /* uip_conn always points to the current
hudakz 3:5b17e4656dd0 163 connection. */
hudakz 3:5b17e4656dd0 164
hudakz 3:5b17e4656dd0 165 struct uip_conn uip_conns[UIP_CONNS];
hudakz 3:5b17e4656dd0 166
hudakz 3:5b17e4656dd0 167 /* The uip_conns array holds all TCP
hudakz 3:5b17e4656dd0 168 connections. */
hudakz 3:5b17e4656dd0 169 u16_t uip_listenports[UIP_LISTENPORTS];
hudakz 3:5b17e4656dd0 170
hudakz 3:5b17e4656dd0 171 /* The uip_listenports list all currently
hudakz 3:5b17e4656dd0 172 listning ports. */
hudakz 3:5b17e4656dd0 173 #if UIP_UDP
hudakz 3:5b17e4656dd0 174 struct uip_udp_conn* uip_udp_conn;
hudakz 3:5b17e4656dd0 175 struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
hudakz 3:5b17e4656dd0 176 #endif /* UIP_UDP */
hudakz 3:5b17e4656dd0 177
hudakz 3:5b17e4656dd0 178 static u16_t ipid; /* Ths ipid variable is an increasing
hudakz 3:5b17e4656dd0 179 number that is used for the IP ID
hudakz 3:5b17e4656dd0 180 field. */
hudakz 3:5b17e4656dd0 181
hudakz 3:5b17e4656dd0 182 /**
hudakz 3:5b17e4656dd0 183 * @brief
hudakz 3:5b17e4656dd0 184 * @note
hudakz 3:5b17e4656dd0 185 * @param
hudakz 3:5b17e4656dd0 186 * @retval
hudakz 3:5b17e4656dd0 187 */
hudakz 3:5b17e4656dd0 188 void uip_setipid(u16_t id) {
hudakz 3:5b17e4656dd0 189 ipid = id;
hudakz 3:5b17e4656dd0 190 }
hudakz 3:5b17e4656dd0 191
hudakz 3:5b17e4656dd0 192 static u8_t iss[4]; /* The iss variable is used for the TCP
hudakz 3:5b17e4656dd0 193 initial sequence number. */
hudakz 3:5b17e4656dd0 194
hudakz 3:5b17e4656dd0 195 #if UIP_ACTIVE_OPEN
hudakz 3:5b17e4656dd0 196 static u16_t lastport; /* Keeps track of the last port used for
hudakz 3:5b17e4656dd0 197 a new connection. */
hudakz 3:5b17e4656dd0 198 #endif /* UIP_ACTIVE_OPEN */
hudakz 3:5b17e4656dd0 199
hudakz 3:5b17e4656dd0 200 /* Temporary variables. */
hudakz 3:5b17e4656dd0 201
hudakz 3:5b17e4656dd0 202 u8_t uip_acc32[4];
hudakz 3:5b17e4656dd0 203 static u8_t c, opt;
hudakz 3:5b17e4656dd0 204 static u16_t tmp16;
hudakz 3:5b17e4656dd0 205
hudakz 3:5b17e4656dd0 206 /* Structures and definitions. */
hudakz 3:5b17e4656dd0 207
hudakz 3:5b17e4656dd0 208 #define TCP_FIN 0x01
hudakz 3:5b17e4656dd0 209 #define TCP_SYN 0x02
hudakz 3:5b17e4656dd0 210 #define TCP_RST 0x04
hudakz 3:5b17e4656dd0 211 #define TCP_PSH 0x08
hudakz 3:5b17e4656dd0 212 #define TCP_ACK 0x10
hudakz 3:5b17e4656dd0 213 #define TCP_URG 0x20
hudakz 3:5b17e4656dd0 214 #define TCP_CTL 0x3f
hudakz 3:5b17e4656dd0 215
hudakz 3:5b17e4656dd0 216 #define TCP_OPT_END 0 /* End of TCP options list */
hudakz 3:5b17e4656dd0 217
hudakz 3:5b17e4656dd0 218 #define TCP_OPT_NOOP 1 /* "No-operation" TCP option */
hudakz 3:5b17e4656dd0 219
hudakz 3:5b17e4656dd0 220 #define TCP_OPT_MSS 2 /* Maximum segment size TCP option */
hudakz 3:5b17e4656dd0 221
hudakz 3:5b17e4656dd0 222 #define TCP_OPT_MSS_LEN 4 /* Length of TCP MSS option. */
hudakz 3:5b17e4656dd0 223
hudakz 3:5b17e4656dd0 224 #define ICMP_ECHO_REPLY 0
hudakz 3:5b17e4656dd0 225 #define ICMP_ECHO 8
hudakz 3:5b17e4656dd0 226
hudakz 3:5b17e4656dd0 227 #define ICMP6_ECHO_REPLY 129
hudakz 3:5b17e4656dd0 228 #define ICMP6_ECHO 128
hudakz 3:5b17e4656dd0 229 #define ICMP6_NEIGHBOR_SOLICITATION 135
hudakz 3:5b17e4656dd0 230 #define ICMP6_NEIGHBOR_ADVERTISEMENT 136
hudakz 3:5b17e4656dd0 231
hudakz 3:5b17e4656dd0 232 #define ICMP6_FLAG_S (1 << 6)
hudakz 3:5b17e4656dd0 233 #define ICMP6_OPTION_SOURCE_LINK_ADDRESS 1
hudakz 3:5b17e4656dd0 234 #define ICMP6_OPTION_TARGET_LINK_ADDRESS 2
hudakz 3:5b17e4656dd0 235
hudakz 3:5b17e4656dd0 236 /* Macros. */
hudakz 3:5b17e4656dd0 237
hudakz 3:5b17e4656dd0 238 #define BUF ((struct uip_tcpip_hdr*) &uip_buf[UIP_LLH_LEN])
hudakz 3:5b17e4656dd0 239 #define FBUF ((struct uip_tcpip_hdr*) &uip_reassbuf[0])
hudakz 3:5b17e4656dd0 240 #define ICMPBUF ((struct uip_icmpip_hdr*) &uip_buf[UIP_LLH_LEN])
hudakz 3:5b17e4656dd0 241 #define UDPBUF ((struct uip_udpip_hdr*) &uip_buf[UIP_LLH_LEN])
hudakz 3:5b17e4656dd0 242 #if UIP_STATISTICS == 1
hudakz 3:5b17e4656dd0 243 struct uip_stats uip_stat;
hudakz 3:5b17e4656dd0 244 #define UIP_STAT(s) s
hudakz 3:5b17e4656dd0 245 #else
hudakz 3:5b17e4656dd0 246 #define UIP_STAT(s)
hudakz 3:5b17e4656dd0 247 #endif /* UIP_STATISTICS == 1 */
hudakz 3:5b17e4656dd0 248
hudakz 3:5b17e4656dd0 249 #if UIP_LOGGING == 1
hudakz 3:5b17e4656dd0 250 #include <stdio.h>
hudakz 3:5b17e4656dd0 251 void uip_log(char* msg);
hudakz 3:5b17e4656dd0 252 #define UIP_LOG(m) uip_log(m)
hudakz 3:5b17e4656dd0 253 #else
hudakz 3:5b17e4656dd0 254 #define UIP_LOG(m)
hudakz 3:5b17e4656dd0 255 #endif /* UIP_LOGGING == 1 */
hudakz 3:5b17e4656dd0 256
hudakz 3:5b17e4656dd0 257 #if !UIP_ARCH_ADD32
hudakz 3:5b17e4656dd0 258
hudakz 3:5b17e4656dd0 259 /**
hudakz 3:5b17e4656dd0 260 * @brief
hudakz 3:5b17e4656dd0 261 * @note
hudakz 3:5b17e4656dd0 262 * @param
hudakz 3:5b17e4656dd0 263 * @retval
hudakz 3:5b17e4656dd0 264 */
hudakz 3:5b17e4656dd0 265 void uip_add32(u8_t* op32, u16_t op16) {
hudakz 3:5b17e4656dd0 266 uip_acc32[3] = op32[3] + (op16 & 0xff);
hudakz 3:5b17e4656dd0 267 uip_acc32[2] = op32[2] + (op16 >> 8);
hudakz 3:5b17e4656dd0 268 uip_acc32[1] = op32[1];
hudakz 3:5b17e4656dd0 269 uip_acc32[0] = op32[0];
hudakz 3:5b17e4656dd0 270
hudakz 3:5b17e4656dd0 271 if(uip_acc32[2] < (op16 >> 8)) {
hudakz 3:5b17e4656dd0 272 ++uip_acc32[1];
hudakz 3:5b17e4656dd0 273 if(uip_acc32[1] == 0) {
hudakz 3:5b17e4656dd0 274 ++uip_acc32[0];
hudakz 3:5b17e4656dd0 275 }
hudakz 3:5b17e4656dd0 276 }
hudakz 3:5b17e4656dd0 277
hudakz 3:5b17e4656dd0 278 if(uip_acc32[3] < (op16 & 0xff)) {
hudakz 3:5b17e4656dd0 279 ++uip_acc32[2];
hudakz 3:5b17e4656dd0 280 if(uip_acc32[2] == 0) {
hudakz 3:5b17e4656dd0 281 ++uip_acc32[1];
hudakz 3:5b17e4656dd0 282 if(uip_acc32[1] == 0) {
hudakz 3:5b17e4656dd0 283 ++uip_acc32[0];
hudakz 3:5b17e4656dd0 284 }
hudakz 3:5b17e4656dd0 285 }
hudakz 3:5b17e4656dd0 286 }
hudakz 3:5b17e4656dd0 287 }
hudakz 3:5b17e4656dd0 288 #endif /* UIP_ARCH_ADD32 */
hudakz 3:5b17e4656dd0 289
hudakz 3:5b17e4656dd0 290 #if !UIP_ARCH_CHKSUM
hudakz 3:5b17e4656dd0 291
hudakz 3:5b17e4656dd0 292 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 293 static u16_t chksum(u16_t sum, const u8_t* data, u16_t len) {
hudakz 3:5b17e4656dd0 294 u16_t t;
hudakz 3:5b17e4656dd0 295 const u8_t* dataptr;
hudakz 3:5b17e4656dd0 296 const u8_t* last_byte;
hudakz 3:5b17e4656dd0 297
hudakz 3:5b17e4656dd0 298 dataptr = data;
hudakz 3:5b17e4656dd0 299 last_byte = data + len - 1;
hudakz 3:5b17e4656dd0 300
hudakz 3:5b17e4656dd0 301 while(dataptr < last_byte) {
hudakz 3:5b17e4656dd0 302
hudakz 3:5b17e4656dd0 303 /* At least two more bytes */
hudakz 3:5b17e4656dd0 304 t = (dataptr[0] << 8) + dataptr[1];
hudakz 3:5b17e4656dd0 305 sum += t;
hudakz 3:5b17e4656dd0 306 if(sum < t) {
hudakz 3:5b17e4656dd0 307 sum++; /* carry */
hudakz 3:5b17e4656dd0 308 }
hudakz 3:5b17e4656dd0 309
hudakz 3:5b17e4656dd0 310 dataptr += 2;
hudakz 3:5b17e4656dd0 311 }
hudakz 3:5b17e4656dd0 312
hudakz 3:5b17e4656dd0 313 if(dataptr == last_byte) {
hudakz 3:5b17e4656dd0 314 t = (dataptr[0] << 8) + 0;
hudakz 3:5b17e4656dd0 315 sum += t;
hudakz 3:5b17e4656dd0 316 if(sum < t) {
hudakz 3:5b17e4656dd0 317 sum++; /* carry */
hudakz 3:5b17e4656dd0 318 }
hudakz 3:5b17e4656dd0 319 }
hudakz 3:5b17e4656dd0 320
hudakz 3:5b17e4656dd0 321 /* Return sum in host byte order. */
hudakz 3:5b17e4656dd0 322 return sum;
hudakz 3:5b17e4656dd0 323 }
hudakz 3:5b17e4656dd0 324
hudakz 3:5b17e4656dd0 325 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 326 u16_t uip_chksum(u16_t* data, u16_t len) {
hudakz 3:5b17e4656dd0 327 return htons(chksum(0, (u8_t*)data, len));
hudakz 3:5b17e4656dd0 328 }
hudakz 3:5b17e4656dd0 329
hudakz 3:5b17e4656dd0 330 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 331 #ifndef UIP_ARCH_IPCHKSUM
hudakz 3:5b17e4656dd0 332
hudakz 3:5b17e4656dd0 333 /**
hudakz 3:5b17e4656dd0 334 * @brief
hudakz 3:5b17e4656dd0 335 * @note
hudakz 3:5b17e4656dd0 336 * @param
hudakz 3:5b17e4656dd0 337 * @retval
hudakz 3:5b17e4656dd0 338 */
hudakz 3:5b17e4656dd0 339 u16_t uip_ipchksum(void) {
hudakz 3:5b17e4656dd0 340 u16_t sum;
hudakz 3:5b17e4656dd0 341
hudakz 3:5b17e4656dd0 342 sum = chksum(0, &uip_buf[UIP_LLH_LEN], UIP_IPH_LEN);
hudakz 3:5b17e4656dd0 343 DEBUG_PRINTF("uip_ipchksum: sum 0x%04x\n", sum);
hudakz 3:5b17e4656dd0 344 return(sum == 0) ? 0xffff : htons(sum);
hudakz 3:5b17e4656dd0 345 }
hudakz 3:5b17e4656dd0 346 #endif
hudakz 3:5b17e4656dd0 347
hudakz 3:5b17e4656dd0 348 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 349 static u16_t upper_layer_chksum(u8_t proto) {
hudakz 3:5b17e4656dd0 350 u16_t upper_layer_len;
hudakz 3:5b17e4656dd0 351 u16_t sum;
hudakz 3:5b17e4656dd0 352
hudakz 3:5b17e4656dd0 353 #if UIP_CONF_IPV6
hudakz 3:5b17e4656dd0 354 upper_layer_len = (((u16_t) (BUF->len[0]) << 8) + BUF->len[1]);
hudakz 3:5b17e4656dd0 355 #else /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 356 upper_layer_len = (((u16_t) (BUF->len[0]) << 8) + BUF->len[1]) - UIP_IPH_LEN;
hudakz 3:5b17e4656dd0 357 #endif /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 358
hudakz 3:5b17e4656dd0 359 /* First sum pseudoheader. */
hudakz 3:5b17e4656dd0 360
hudakz 3:5b17e4656dd0 361 /* IP protocol and length fields. This addition cannot carry. */
hudakz 3:5b17e4656dd0 362 sum = upper_layer_len + proto;
hudakz 3:5b17e4656dd0 363
hudakz 3:5b17e4656dd0 364 /* Sum IP source and destination addresses. */
hudakz 3:5b17e4656dd0 365 sum = chksum(sum, (u8_t*) &BUF->srcipaddr[0], 2 * sizeof(uip_ipaddr_t));
hudakz 3:5b17e4656dd0 366
hudakz 3:5b17e4656dd0 367 /* Sum TCP header and data. */
hudakz 3:5b17e4656dd0 368 sum = chksum(sum, &uip_buf[UIP_IPH_LEN + UIP_LLH_LEN], upper_layer_len);
hudakz 3:5b17e4656dd0 369
hudakz 3:5b17e4656dd0 370 return(sum == 0) ? 0xffff : htons(sum);
hudakz 3:5b17e4656dd0 371 }
hudakz 3:5b17e4656dd0 372
hudakz 3:5b17e4656dd0 373 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 374 #if UIP_CONF_IPV6
hudakz 3:5b17e4656dd0 375
hudakz 3:5b17e4656dd0 376 /**
hudakz 3:5b17e4656dd0 377 * @brief
hudakz 3:5b17e4656dd0 378 * @note
hudakz 3:5b17e4656dd0 379 * @param
hudakz 3:5b17e4656dd0 380 * @retval
hudakz 3:5b17e4656dd0 381 */
hudakz 3:5b17e4656dd0 382 u16_t uip_icmp6chksum(void) {
hudakz 3:5b17e4656dd0 383 return upper_layer_chksum(UIP_PROTO_ICMP6);
hudakz 3:5b17e4656dd0 384 }
hudakz 3:5b17e4656dd0 385 #endif /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 386
hudakz 3:5b17e4656dd0 387 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 388 u16_t uip_tcpchksum(void) {
hudakz 3:5b17e4656dd0 389 return upper_layer_chksum(UIP_PROTO_TCP);
hudakz 3:5b17e4656dd0 390 }
hudakz 3:5b17e4656dd0 391
hudakz 3:5b17e4656dd0 392 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 393 #if UIP_UDP_CHECKSUMS
hudakz 3:5b17e4656dd0 394
hudakz 3:5b17e4656dd0 395 /**
hudakz 3:5b17e4656dd0 396 * @brief
hudakz 3:5b17e4656dd0 397 * @note
hudakz 3:5b17e4656dd0 398 * @param
hudakz 3:5b17e4656dd0 399 * @retval
hudakz 3:5b17e4656dd0 400 */
hudakz 3:5b17e4656dd0 401 u16_t uip_udpchksum(void) {
hudakz 3:5b17e4656dd0 402 return upper_layer_chksum(UIP_PROTO_UDP);
hudakz 3:5b17e4656dd0 403 }
hudakz 3:5b17e4656dd0 404 #endif /* UIP_UDP_CHECKSUMS */
hudakz 3:5b17e4656dd0 405 #endif /* UIP_ARCH_CHKSUM */
hudakz 3:5b17e4656dd0 406
hudakz 3:5b17e4656dd0 407 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 408 void uip_init(void) {
hudakz 3:5b17e4656dd0 409 for(c = 0; c < UIP_LISTENPORTS; ++c) {
hudakz 3:5b17e4656dd0 410 uip_listenports[c] = 0;
hudakz 3:5b17e4656dd0 411 }
hudakz 3:5b17e4656dd0 412
hudakz 3:5b17e4656dd0 413 for(c = 0; c < UIP_CONNS; ++c) {
hudakz 3:5b17e4656dd0 414 uip_conns[c].tcpstateflags = UIP_CLOSED;
hudakz 3:5b17e4656dd0 415 }
hudakz 3:5b17e4656dd0 416
hudakz 3:5b17e4656dd0 417 #if UIP_ACTIVE_OPEN
hudakz 3:5b17e4656dd0 418 lastport = 1024;
hudakz 3:5b17e4656dd0 419 #endif /* UIP_ACTIVE_OPEN */
hudakz 3:5b17e4656dd0 420
hudakz 3:5b17e4656dd0 421 #if UIP_UDP
hudakz 3:5b17e4656dd0 422 for(c = 0; c < UIP_UDP_CONNS; ++c) {
hudakz 3:5b17e4656dd0 423 uip_udp_conns[c].lport = 0;
hudakz 3:5b17e4656dd0 424 }
hudakz 3:5b17e4656dd0 425 #endif /* UIP_UDP */
hudakz 3:5b17e4656dd0 426
hudakz 3:5b17e4656dd0 427 /* IPv4 initialization. */
hudakz 3:5b17e4656dd0 428
hudakz 3:5b17e4656dd0 429 #if UIP_FIXEDADDR == 0
hudakz 3:5b17e4656dd0 430 /* uip_hostaddr[0] = uip_hostaddr[1] = 0;*/
hudakz 3:5b17e4656dd0 431 #endif /* UIP_FIXEDADDR */
hudakz 3:5b17e4656dd0 432 }
hudakz 3:5b17e4656dd0 433
hudakz 3:5b17e4656dd0 434 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 435 #if UIP_ACTIVE_OPEN
hudakz 3:5b17e4656dd0 436
hudakz 3:5b17e4656dd0 437 /**
hudakz 3:5b17e4656dd0 438 * @brief
hudakz 3:5b17e4656dd0 439 * @note
hudakz 3:5b17e4656dd0 440 * @param
hudakz 3:5b17e4656dd0 441 * @retval
hudakz 3:5b17e4656dd0 442 */
hudakz 3:5b17e4656dd0 443 struct uip_conn* uip_connect(uip_ipaddr_t* ripaddr, u16_t rport) {
hudakz 3:5b17e4656dd0 444 register struct uip_conn* conn, *cconn;
hudakz 3:5b17e4656dd0 445
hudakz 3:5b17e4656dd0 446 /* Find an unused local port. */
hudakz 3:5b17e4656dd0 447
hudakz 3:5b17e4656dd0 448 again:
hudakz 3:5b17e4656dd0 449 ++lastport;
hudakz 3:5b17e4656dd0 450
hudakz 3:5b17e4656dd0 451 if(lastport >= 32000) {
hudakz 3:5b17e4656dd0 452 lastport = 4096;
hudakz 3:5b17e4656dd0 453 }
hudakz 3:5b17e4656dd0 454
hudakz 3:5b17e4656dd0 455 /* Check if this port is already in use, and if so try to find
hudakz 3:5b17e4656dd0 456 another one. */
hudakz 3:5b17e4656dd0 457 for(c = 0; c < UIP_CONNS; ++c) {
hudakz 3:5b17e4656dd0 458 conn = &uip_conns[c];
hudakz 3:5b17e4656dd0 459 if(conn->tcpstateflags != UIP_CLOSED && conn->lport == htons(lastport)) {
hudakz 3:5b17e4656dd0 460 goto again;
hudakz 3:5b17e4656dd0 461 }
hudakz 3:5b17e4656dd0 462 }
hudakz 3:5b17e4656dd0 463
hudakz 3:5b17e4656dd0 464 conn = 0;
hudakz 3:5b17e4656dd0 465 for(c = 0; c < UIP_CONNS; ++c) {
hudakz 3:5b17e4656dd0 466 cconn = &uip_conns[c];
hudakz 3:5b17e4656dd0 467 if(cconn->tcpstateflags == UIP_CLOSED) {
hudakz 3:5b17e4656dd0 468 conn = cconn;
hudakz 3:5b17e4656dd0 469 break;
hudakz 3:5b17e4656dd0 470 }
hudakz 3:5b17e4656dd0 471
hudakz 3:5b17e4656dd0 472 if(cconn->tcpstateflags == UIP_TIME_WAIT) {
hudakz 3:5b17e4656dd0 473 if(conn == 0 || cconn->timer > conn->timer) {
hudakz 3:5b17e4656dd0 474 conn = cconn;
hudakz 3:5b17e4656dd0 475 }
hudakz 3:5b17e4656dd0 476 }
hudakz 3:5b17e4656dd0 477 }
hudakz 3:5b17e4656dd0 478
hudakz 3:5b17e4656dd0 479 if(conn == 0) {
hudakz 3:5b17e4656dd0 480 return 0;
hudakz 3:5b17e4656dd0 481 }
hudakz 3:5b17e4656dd0 482
hudakz 3:5b17e4656dd0 483 conn->tcpstateflags = UIP_SYN_SENT;
hudakz 3:5b17e4656dd0 484
hudakz 3:5b17e4656dd0 485 conn->snd_nxt[0] = iss[0];
hudakz 3:5b17e4656dd0 486 conn->snd_nxt[1] = iss[1];
hudakz 3:5b17e4656dd0 487 conn->snd_nxt[2] = iss[2];
hudakz 3:5b17e4656dd0 488 conn->snd_nxt[3] = iss[3];
hudakz 3:5b17e4656dd0 489
hudakz 3:5b17e4656dd0 490 conn->initialmss = conn->mss = UIP_TCP_MSS;
hudakz 3:5b17e4656dd0 491
hudakz 3:5b17e4656dd0 492 conn->len = 1; /* TCP length of the SYN is one. */
hudakz 3:5b17e4656dd0 493 conn->nrtx = 0;
hudakz 3:5b17e4656dd0 494 conn->timer = 1; /* Send the SYN next time around. */
hudakz 3:5b17e4656dd0 495 conn->rto = UIP_RTO;
hudakz 3:5b17e4656dd0 496 conn->sa = 0;
hudakz 3:5b17e4656dd0 497 conn->sv = 16; /* Initial value of the RTT variance. */
hudakz 3:5b17e4656dd0 498 conn->lport = htons(lastport);
hudakz 3:5b17e4656dd0 499 conn->rport = rport;
hudakz 3:5b17e4656dd0 500 uip_ipaddr_copy(&conn->ripaddr, ripaddr);
hudakz 3:5b17e4656dd0 501
hudakz 3:5b17e4656dd0 502 return conn;
hudakz 3:5b17e4656dd0 503 }
hudakz 3:5b17e4656dd0 504 #endif /* UIP_ACTIVE_OPEN */
hudakz 3:5b17e4656dd0 505
hudakz 3:5b17e4656dd0 506 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 507
hudakz 3:5b17e4656dd0 508 #if UIP_UDP
hudakz 3:5b17e4656dd0 509
hudakz 3:5b17e4656dd0 510 /**
hudakz 3:5b17e4656dd0 511 * @brief
hudakz 3:5b17e4656dd0 512 * @note
hudakz 3:5b17e4656dd0 513 * @param
hudakz 3:5b17e4656dd0 514 * @retval
hudakz 3:5b17e4656dd0 515 */
hudakz 3:5b17e4656dd0 516 struct uip_udp_conn* uip_udp_new(uip_ipaddr_t* ripaddr, u16_t rport) {
hudakz 3:5b17e4656dd0 517 register struct uip_udp_conn* conn;
hudakz 3:5b17e4656dd0 518
hudakz 3:5b17e4656dd0 519 /* Find an unused local port. */
hudakz 3:5b17e4656dd0 520
hudakz 3:5b17e4656dd0 521 again:
hudakz 3:5b17e4656dd0 522 ++lastport;
hudakz 3:5b17e4656dd0 523
hudakz 3:5b17e4656dd0 524 if(lastport >= 32000) {
hudakz 3:5b17e4656dd0 525 lastport = 4096;
hudakz 3:5b17e4656dd0 526 }
hudakz 3:5b17e4656dd0 527
hudakz 3:5b17e4656dd0 528 for(c = 0; c < UIP_UDP_CONNS; ++c) {
hudakz 3:5b17e4656dd0 529 if(uip_udp_conns[c].lport == htons(lastport)) {
hudakz 3:5b17e4656dd0 530 goto again;
hudakz 3:5b17e4656dd0 531 }
hudakz 3:5b17e4656dd0 532 }
hudakz 3:5b17e4656dd0 533
hudakz 3:5b17e4656dd0 534 conn = 0;
hudakz 3:5b17e4656dd0 535 for(c = 0; c < UIP_UDP_CONNS; ++c) {
hudakz 3:5b17e4656dd0 536 if(uip_udp_conns[c].lport == 0) {
hudakz 3:5b17e4656dd0 537 conn = &uip_udp_conns[c];
hudakz 3:5b17e4656dd0 538 break;
hudakz 3:5b17e4656dd0 539 }
hudakz 3:5b17e4656dd0 540 }
hudakz 3:5b17e4656dd0 541
hudakz 3:5b17e4656dd0 542 if(conn == 0) {
hudakz 3:5b17e4656dd0 543 return 0;
hudakz 3:5b17e4656dd0 544 }
hudakz 3:5b17e4656dd0 545
hudakz 3:5b17e4656dd0 546 conn->lport = HTONS(lastport);
hudakz 3:5b17e4656dd0 547 conn->rport = rport;
hudakz 3:5b17e4656dd0 548 if(ripaddr == NULL) {
hudakz 3:5b17e4656dd0 549 memset(conn->ripaddr, 0, sizeof(uip_ipaddr_t));
hudakz 3:5b17e4656dd0 550 }
hudakz 3:5b17e4656dd0 551 else {
hudakz 3:5b17e4656dd0 552 uip_ipaddr_copy(&conn->ripaddr, ripaddr);
hudakz 3:5b17e4656dd0 553 }
hudakz 3:5b17e4656dd0 554
hudakz 3:5b17e4656dd0 555 conn->ttl = UIP_TTL;
hudakz 3:5b17e4656dd0 556
hudakz 3:5b17e4656dd0 557 return conn;
hudakz 3:5b17e4656dd0 558 }
hudakz 3:5b17e4656dd0 559 #endif /* UIP_UDP */
hudakz 3:5b17e4656dd0 560
hudakz 3:5b17e4656dd0 561 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 562 void uip_unlisten(u16_t port) {
hudakz 3:5b17e4656dd0 563 for(c = 0; c < UIP_LISTENPORTS; ++c) {
hudakz 3:5b17e4656dd0 564 if(uip_listenports[c] == port) {
hudakz 3:5b17e4656dd0 565 uip_listenports[c] = 0;
hudakz 3:5b17e4656dd0 566 return;
hudakz 3:5b17e4656dd0 567 }
hudakz 3:5b17e4656dd0 568 }
hudakz 3:5b17e4656dd0 569 }
hudakz 3:5b17e4656dd0 570
hudakz 3:5b17e4656dd0 571 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 572 void uip_listen(u16_t port) {
hudakz 3:5b17e4656dd0 573 for(c = 0; c < UIP_LISTENPORTS; ++c) {
hudakz 3:5b17e4656dd0 574 if(uip_listenports[c] == 0) {
hudakz 3:5b17e4656dd0 575 uip_listenports[c] = port;
hudakz 3:5b17e4656dd0 576 return;
hudakz 3:5b17e4656dd0 577 }
hudakz 3:5b17e4656dd0 578 }
hudakz 3:5b17e4656dd0 579 }
hudakz 3:5b17e4656dd0 580
hudakz 3:5b17e4656dd0 581 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 582 /* XXX: IP fragment reassembly: not well-tested. */
hudakz 3:5b17e4656dd0 583 #if UIP_REASSEMBLY && !UIP_CONF_IPV6
hudakz 3:5b17e4656dd0 584 #define UIP_REASS_BUFSIZE (UIP_BUFSIZE - UIP_LLH_LEN)
hudakz 3:5b17e4656dd0 585 static u8_t uip_reassbuf[UIP_REASS_BUFSIZE];
hudakz 3:5b17e4656dd0 586 static u8_t uip_reassbitmap[UIP_REASS_BUFSIZE / (8 * 8)];
hudakz 3:5b17e4656dd0 587 static const u8_t bitmap_bits[8] = { 0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01 };
hudakz 3:5b17e4656dd0 588 static u16_t uip_reasslen;
hudakz 3:5b17e4656dd0 589 static u8_t uip_reassflags;
hudakz 3:5b17e4656dd0 590 #define UIP_REASS_FLAG_LASTFRAG 0x01
hudakz 3:5b17e4656dd0 591 static u8_t uip_reasstmr;
hudakz 3:5b17e4656dd0 592
hudakz 3:5b17e4656dd0 593 #define IP_MF 0x20
hudakz 3:5b17e4656dd0 594
hudakz 3:5b17e4656dd0 595 /**
hudakz 3:5b17e4656dd0 596 * @brief
hudakz 3:5b17e4656dd0 597 * @note
hudakz 3:5b17e4656dd0 598 * @param
hudakz 3:5b17e4656dd0 599 * @retval
hudakz 3:5b17e4656dd0 600 */
hudakz 3:5b17e4656dd0 601 static u8_t uip_reass(void) {
hudakz 3:5b17e4656dd0 602 u16_t offset, len;
hudakz 3:5b17e4656dd0 603 u16_t i;
hudakz 3:5b17e4656dd0 604
hudakz 3:5b17e4656dd0 605 /* If ip_reasstmr is zero, no packet is present in the buffer, so we
hudakz 3:5b17e4656dd0 606 write the IP header of the fragment into the reassembly
hudakz 3:5b17e4656dd0 607 buffer. The timer is updated with the maximum age. */
hudakz 3:5b17e4656dd0 608
hudakz 3:5b17e4656dd0 609 if(uip_reasstmr == 0) {
hudakz 3:5b17e4656dd0 610 memcpy(uip_reassbuf, &BUF->vhl, UIP_IPH_LEN);
hudakz 3:5b17e4656dd0 611 uip_reasstmr = UIP_REASS_MAXAGE;
hudakz 3:5b17e4656dd0 612 uip_reassflags = 0;
hudakz 3:5b17e4656dd0 613
hudakz 3:5b17e4656dd0 614 /* Clear the bitmap. */
hudakz 3:5b17e4656dd0 615 memset(uip_reassbitmap, 0, sizeof(uip_reassbitmap));
hudakz 3:5b17e4656dd0 616 }
hudakz 3:5b17e4656dd0 617
hudakz 3:5b17e4656dd0 618 /* Check if the incoming fragment matches the one currently present
hudakz 3:5b17e4656dd0 619 in the reasembly buffer. If so, we proceed with copying the
hudakz 3:5b17e4656dd0 620 fragment into the buffer. */
hudakz 3:5b17e4656dd0 621 if
hudakz 3:5b17e4656dd0 622 (
hudakz 3:5b17e4656dd0 623 BUF->srcipaddr[0] == FBUF->srcipaddr[0]
hudakz 3:5b17e4656dd0 624 && BUF->srcipaddr[1] == FBUF->srcipaddr[1]
hudakz 3:5b17e4656dd0 625 && BUF->destipaddr[0] == FBUF->destipaddr[0]
hudakz 3:5b17e4656dd0 626 && BUF->destipaddr[1] == FBUF->destipaddr[1]
hudakz 3:5b17e4656dd0 627 && BUF->ipid[0] == FBUF->ipid[0]
hudakz 3:5b17e4656dd0 628 && BUF->ipid[1] == FBUF->ipid[1]
hudakz 3:5b17e4656dd0 629 ) {
hudakz 3:5b17e4656dd0 630 len = (BUF->len[0] << 8) + BUF->len[1] - (BUF->vhl & 0x0f) * 4;
hudakz 3:5b17e4656dd0 631 offset = (((BUF->ipoffset[0] & 0x3f) << 8) + BUF->ipoffset[1]) * 8;
hudakz 3:5b17e4656dd0 632
hudakz 3:5b17e4656dd0 633 /* If the offset or the offset + fragment length overflows the
hudakz 3:5b17e4656dd0 634 reassembly buffer, we discard the entire packet. */
hudakz 3:5b17e4656dd0 635 if(offset > UIP_REASS_BUFSIZE || offset + len > UIP_REASS_BUFSIZE) {
hudakz 3:5b17e4656dd0 636 uip_reasstmr = 0;
hudakz 3:5b17e4656dd0 637 goto nullreturn;
hudakz 3:5b17e4656dd0 638 }
hudakz 3:5b17e4656dd0 639
hudakz 3:5b17e4656dd0 640 /* Copy the fragment into the reassembly buffer, at the right
hudakz 3:5b17e4656dd0 641 offset. */
hudakz 3:5b17e4656dd0 642 memcpy(&uip_reassbuf[UIP_IPH_LEN + offset], (char*)BUF + (int)((BUF->vhl & 0x0f) * 4), len);
hudakz 3:5b17e4656dd0 643
hudakz 3:5b17e4656dd0 644 /* Update the bitmap. */
hudakz 3:5b17e4656dd0 645 if(offset / (8 * 8) == (offset + len) / (8 * 8)) {
hudakz 3:5b17e4656dd0 646
hudakz 3:5b17e4656dd0 647 /* If the two endpoints are in the same byte, we only update
hudakz 3:5b17e4656dd0 648 that byte. */
hudakz 3:5b17e4656dd0 649 uip_reassbitmap[offset / (8 * 8)] |= bitmap_bits[(offset / 8) & 7] &~bitmap_bits[((offset + len) / 8) & 7];
hudakz 3:5b17e4656dd0 650 }
hudakz 3:5b17e4656dd0 651 else {
hudakz 3:5b17e4656dd0 652
hudakz 3:5b17e4656dd0 653 /* If the two endpoints are in different bytes, we update the
hudakz 3:5b17e4656dd0 654 bytes in the endpoints and fill the stuff inbetween with
hudakz 3:5b17e4656dd0 655 0xff. */
hudakz 3:5b17e4656dd0 656 uip_reassbitmap[offset / (8 * 8)] |= bitmap_bits[(offset / 8) & 7];
hudakz 3:5b17e4656dd0 657 for(i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i) {
hudakz 3:5b17e4656dd0 658 uip_reassbitmap[i] = 0xff;
hudakz 3:5b17e4656dd0 659 }
hudakz 3:5b17e4656dd0 660
hudakz 3:5b17e4656dd0 661 uip_reassbitmap[(offset + len) / (8 * 8)] |= ~bitmap_bits[((offset + len) / 8) & 7];
hudakz 3:5b17e4656dd0 662 }
hudakz 3:5b17e4656dd0 663
hudakz 3:5b17e4656dd0 664 /* If this fragment has the More Fragments flag set to zero, we
hudakz 3:5b17e4656dd0 665 know that this is the last fragment, so we can calculate the
hudakz 3:5b17e4656dd0 666 size of the entire packet. We also set the
hudakz 3:5b17e4656dd0 667 IP_REASS_FLAG_LASTFRAG flag to indicate that we have received
hudakz 3:5b17e4656dd0 668 the final fragment. */
hudakz 3:5b17e4656dd0 669 if((BUF->ipoffset[0] & IP_MF) == 0) {
hudakz 3:5b17e4656dd0 670 uip_reassflags |= UIP_REASS_FLAG_LASTFRAG;
hudakz 3:5b17e4656dd0 671 uip_reasslen = offset + len;
hudakz 3:5b17e4656dd0 672 }
hudakz 3:5b17e4656dd0 673
hudakz 3:5b17e4656dd0 674 /* Finally, we check if we have a full packet in the buffer. We do
hudakz 3:5b17e4656dd0 675 this by checking if we have the last fragment and if all bits
hudakz 3:5b17e4656dd0 676 in the bitmap are set. */
hudakz 3:5b17e4656dd0 677 if(uip_reassflags & UIP_REASS_FLAG_LASTFRAG) {
hudakz 3:5b17e4656dd0 678
hudakz 3:5b17e4656dd0 679 /* Check all bytes up to and including all but the last byte in
hudakz 3:5b17e4656dd0 680 the bitmap. */
hudakz 3:5b17e4656dd0 681 for(i = 0; i < uip_reasslen / (8 * 8) - 1; ++i) {
hudakz 3:5b17e4656dd0 682 if(uip_reassbitmap[i] != 0xff) {
hudakz 3:5b17e4656dd0 683 goto nullreturn;
hudakz 3:5b17e4656dd0 684 }
hudakz 3:5b17e4656dd0 685 }
hudakz 3:5b17e4656dd0 686
hudakz 3:5b17e4656dd0 687 /* Check the last byte in the bitmap. It should contain just the
hudakz 3:5b17e4656dd0 688 right amount of bits. */
hudakz 3:5b17e4656dd0 689 if(uip_reassbitmap[uip_reasslen / (8 * 8)] != (u8_t)~bitmap_bits[uip_reasslen / 8 & 7]) {
hudakz 3:5b17e4656dd0 690 goto nullreturn;
hudakz 3:5b17e4656dd0 691 }
hudakz 3:5b17e4656dd0 692
hudakz 3:5b17e4656dd0 693 /* If we have come this far, we have a full packet in the
hudakz 3:5b17e4656dd0 694 buffer, so we allocate a pbuf and copy the packet into it. We
hudakz 3:5b17e4656dd0 695 also reset the timer. */
hudakz 3:5b17e4656dd0 696 uip_reasstmr = 0;
hudakz 3:5b17e4656dd0 697 memcpy(BUF, FBUF, uip_reasslen);
hudakz 3:5b17e4656dd0 698
hudakz 3:5b17e4656dd0 699 /* Pretend to be a "normal" (i.e., not fragmented) IP packet
hudakz 3:5b17e4656dd0 700 from now on. */
hudakz 3:5b17e4656dd0 701 BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
hudakz 3:5b17e4656dd0 702 BUF->len[0] = uip_reasslen >> 8;
hudakz 3:5b17e4656dd0 703 BUF->len[1] = uip_reasslen & 0xff;
hudakz 3:5b17e4656dd0 704 BUF->ipchksum = 0;
hudakz 3:5b17e4656dd0 705 BUF->ipchksum = ~(uip_ipchksum());
hudakz 3:5b17e4656dd0 706
hudakz 3:5b17e4656dd0 707 return uip_reasslen;
hudakz 3:5b17e4656dd0 708 }
hudakz 3:5b17e4656dd0 709 }
hudakz 3:5b17e4656dd0 710
hudakz 3:5b17e4656dd0 711 nullreturn:
hudakz 3:5b17e4656dd0 712 return 0;
hudakz 3:5b17e4656dd0 713 }
hudakz 3:5b17e4656dd0 714 #endif /* UIP_REASSEMBLY */
hudakz 3:5b17e4656dd0 715
hudakz 3:5b17e4656dd0 716 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 717 static void uip_add_rcv_nxt(u16_t n) {
hudakz 3:5b17e4656dd0 718 uip_add32(uip_conn->rcv_nxt, n);
hudakz 3:5b17e4656dd0 719 uip_conn->rcv_nxt[0] = uip_acc32[0];
hudakz 3:5b17e4656dd0 720 uip_conn->rcv_nxt[1] = uip_acc32[1];
hudakz 3:5b17e4656dd0 721 uip_conn->rcv_nxt[2] = uip_acc32[2];
hudakz 3:5b17e4656dd0 722 uip_conn->rcv_nxt[3] = uip_acc32[3];
hudakz 3:5b17e4656dd0 723 }
hudakz 3:5b17e4656dd0 724
hudakz 3:5b17e4656dd0 725 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 726 void uip_process(u8_t flag) {
hudakz 3:5b17e4656dd0 727 register struct uip_conn* uip_connr = uip_conn;
hudakz 3:5b17e4656dd0 728
hudakz 3:5b17e4656dd0 729 #if UIP_UDP
hudakz 3:5b17e4656dd0 730 if(flag == UIP_UDP_SEND_CONN) {
hudakz 3:5b17e4656dd0 731 goto udp_send;
hudakz 3:5b17e4656dd0 732 }
hudakz 3:5b17e4656dd0 733 #endif /* UIP_UDP */
hudakz 3:5b17e4656dd0 734
hudakz 3:5b17e4656dd0 735 uip_sappdata = uip_appdata = &uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
hudakz 3:5b17e4656dd0 736
hudakz 3:5b17e4656dd0 737 /* Check if we were invoked because of a poll request for a
hudakz 3:5b17e4656dd0 738 particular connection. */
hudakz 3:5b17e4656dd0 739 if(flag == UIP_POLL_REQUEST) {
hudakz 3:5b17e4656dd0 740 if((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED && !uip_outstanding(uip_connr)) {
hudakz 3:5b17e4656dd0 741 uip_flags = UIP_POLL;
hudakz 3:5b17e4656dd0 742 UIP_APPCALL();
hudakz 3:5b17e4656dd0 743 goto appsend;
hudakz 3:5b17e4656dd0 744 }
hudakz 3:5b17e4656dd0 745
hudakz 3:5b17e4656dd0 746 goto drop;
hudakz 3:5b17e4656dd0 747
hudakz 3:5b17e4656dd0 748 /* Check if we were invoked because of the perodic timer fireing. */
hudakz 3:5b17e4656dd0 749 }
hudakz 3:5b17e4656dd0 750 else
hudakz 3:5b17e4656dd0 751 if(flag == UIP_TIMER)
hudakz 3:5b17e4656dd0 752 {
hudakz 3:5b17e4656dd0 753 #if UIP_REASSEMBLY
hudakz 3:5b17e4656dd0 754 if(uip_reasstmr != 0) {
hudakz 3:5b17e4656dd0 755 --uip_reasstmr;
hudakz 3:5b17e4656dd0 756 }
hudakz 3:5b17e4656dd0 757 #endif /* UIP_REASSEMBLY */
hudakz 3:5b17e4656dd0 758
hudakz 3:5b17e4656dd0 759 /* Increase the initial sequence number. */
hudakz 3:5b17e4656dd0 760
hudakz 3:5b17e4656dd0 761 if(++iss[3] == 0) {
hudakz 3:5b17e4656dd0 762 if(++iss[2] == 0) {
hudakz 3:5b17e4656dd0 763 if(++iss[1] == 0) {
hudakz 3:5b17e4656dd0 764 ++iss[0];
hudakz 3:5b17e4656dd0 765 }
hudakz 3:5b17e4656dd0 766 }
hudakz 3:5b17e4656dd0 767 }
hudakz 3:5b17e4656dd0 768
hudakz 3:5b17e4656dd0 769 /* Reset the length variables. */
hudakz 3:5b17e4656dd0 770 uip_len = 0;
hudakz 3:5b17e4656dd0 771 uip_slen = 0;
hudakz 3:5b17e4656dd0 772
hudakz 3:5b17e4656dd0 773 /* Check if the connection is in a state in which we simply wait
hudakz 3:5b17e4656dd0 774 for the connection to time out. If so, we increase the
hudakz 3:5b17e4656dd0 775 connection's timer and remove the connection if it times
hudakz 3:5b17e4656dd0 776 out. */
hudakz 3:5b17e4656dd0 777 if(uip_connr->tcpstateflags == UIP_TIME_WAIT || uip_connr->tcpstateflags == UIP_FIN_WAIT_2) {
hudakz 3:5b17e4656dd0 778 ++(uip_connr->timer);
hudakz 3:5b17e4656dd0 779 if(uip_connr->timer == UIP_TIME_WAIT_TIMEOUT) {
hudakz 3:5b17e4656dd0 780 uip_connr->tcpstateflags = UIP_CLOSED;
hudakz 3:5b17e4656dd0 781 }
hudakz 3:5b17e4656dd0 782 }
hudakz 3:5b17e4656dd0 783 else
hudakz 3:5b17e4656dd0 784 if(uip_connr->tcpstateflags != UIP_CLOSED) {
hudakz 3:5b17e4656dd0 785
hudakz 3:5b17e4656dd0 786 /* If the connection has outstanding data, we increase the
hudakz 3:5b17e4656dd0 787 connection's timer and see if it has reached the RTO value
hudakz 3:5b17e4656dd0 788 in which case we retransmit. */
hudakz 3:5b17e4656dd0 789 if(uip_outstanding(uip_connr)) {
hudakz 3:5b17e4656dd0 790 if(uip_connr->timer-- == 0) {
hudakz 3:5b17e4656dd0 791 if
hudakz 3:5b17e4656dd0 792 (
hudakz 3:5b17e4656dd0 793 uip_connr->nrtx == UIP_MAXRTX
hudakz 3:5b17e4656dd0 794 || (
hudakz 3:5b17e4656dd0 795 (uip_connr->tcpstateflags == UIP_SYN_SENT || uip_connr->tcpstateflags == UIP_SYN_RCVD)
hudakz 3:5b17e4656dd0 796 && uip_connr->nrtx == UIP_MAXSYNRTX
hudakz 3:5b17e4656dd0 797 )
hudakz 3:5b17e4656dd0 798 ) {
hudakz 3:5b17e4656dd0 799 uip_connr->tcpstateflags = UIP_CLOSED;
hudakz 3:5b17e4656dd0 800
hudakz 3:5b17e4656dd0 801 /* We call UIP_APPCALL() with uip_flags set to
hudakz 3:5b17e4656dd0 802 UIP_TIMEDOUT to inform the application that the
hudakz 3:5b17e4656dd0 803 connection has timed out. */
hudakz 3:5b17e4656dd0 804 uip_flags = UIP_TIMEDOUT;
hudakz 3:5b17e4656dd0 805 UIP_APPCALL();
hudakz 3:5b17e4656dd0 806
hudakz 3:5b17e4656dd0 807 /* We also send a reset packet to the remote host. */
hudakz 3:5b17e4656dd0 808 BUF->flags = TCP_RST | TCP_ACK;
hudakz 3:5b17e4656dd0 809 goto tcp_send_nodata;
hudakz 3:5b17e4656dd0 810 }
hudakz 3:5b17e4656dd0 811
hudakz 3:5b17e4656dd0 812 /* Exponential backoff. */
hudakz 3:5b17e4656dd0 813 uip_connr->timer = UIP_RTO << (uip_connr->nrtx > 4 ? 4 : uip_connr->nrtx);
hudakz 3:5b17e4656dd0 814 ++(uip_connr->nrtx);
hudakz 3:5b17e4656dd0 815
hudakz 3:5b17e4656dd0 816 /* Ok, so we need to retransmit. We do this differently
hudakz 3:5b17e4656dd0 817 depending on which state we are in. In ESTABLISHED, we
hudakz 3:5b17e4656dd0 818 call upon the application so that it may prepare the
hudakz 3:5b17e4656dd0 819 data for the retransmit. In SYN_RCVD, we resend the
hudakz 3:5b17e4656dd0 820 SYNACK that we sent earlier and in LAST_ACK we have to
hudakz 3:5b17e4656dd0 821 retransmit our FINACK. */
hudakz 3:5b17e4656dd0 822 UIP_STAT(++uip_stat.tcp.rexmit);
hudakz 3:5b17e4656dd0 823 switch(uip_connr->tcpstateflags & UIP_TS_MASK) {
hudakz 3:5b17e4656dd0 824 case UIP_SYN_RCVD:
hudakz 3:5b17e4656dd0 825 /* In the SYN_RCVD state, we should retransmit our
hudakz 3:5b17e4656dd0 826 SYNACK. */
hudakz 3:5b17e4656dd0 827 goto tcp_send_synack;
hudakz 3:5b17e4656dd0 828
hudakz 3:5b17e4656dd0 829 #if UIP_ACTIVE_OPEN
hudakz 3:5b17e4656dd0 830
hudakz 3:5b17e4656dd0 831 case UIP_SYN_SENT:
hudakz 3:5b17e4656dd0 832 /* In the SYN_SENT state, we retransmit out SYN. */
hudakz 3:5b17e4656dd0 833 BUF->flags = 0;
hudakz 3:5b17e4656dd0 834 goto tcp_send_syn;
hudakz 3:5b17e4656dd0 835 #endif /* UIP_ACTIVE_OPEN */
hudakz 3:5b17e4656dd0 836
hudakz 3:5b17e4656dd0 837 case UIP_ESTABLISHED:
hudakz 3:5b17e4656dd0 838 /* In the ESTABLISHED state, we call upon the application
hudakz 3:5b17e4656dd0 839 to do the actual retransmit after which we jump into
hudakz 3:5b17e4656dd0 840 the code for sending out the packet (the apprexmit
hudakz 3:5b17e4656dd0 841 label). */
hudakz 3:5b17e4656dd0 842 uip_flags = UIP_REXMIT;
hudakz 3:5b17e4656dd0 843 UIP_APPCALL();
hudakz 3:5b17e4656dd0 844 goto apprexmit;
hudakz 3:5b17e4656dd0 845
hudakz 3:5b17e4656dd0 846 case UIP_FIN_WAIT_1:
hudakz 3:5b17e4656dd0 847 case UIP_CLOSING:
hudakz 3:5b17e4656dd0 848 case UIP_LAST_ACK:
hudakz 3:5b17e4656dd0 849 /* In all these states we should retransmit a FINACK. */
hudakz 3:5b17e4656dd0 850 goto tcp_send_finack;
hudakz 3:5b17e4656dd0 851 }
hudakz 3:5b17e4656dd0 852 }
hudakz 3:5b17e4656dd0 853 }
hudakz 3:5b17e4656dd0 854 else
hudakz 3:5b17e4656dd0 855 if((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED) {
hudakz 3:5b17e4656dd0 856
hudakz 3:5b17e4656dd0 857 /* If there was no need for a retransmission, we poll the
hudakz 3:5b17e4656dd0 858 application for new data. */
hudakz 3:5b17e4656dd0 859 uip_flags = UIP_POLL;
hudakz 3:5b17e4656dd0 860 UIP_APPCALL();
hudakz 3:5b17e4656dd0 861 goto appsend;
hudakz 3:5b17e4656dd0 862 }
hudakz 3:5b17e4656dd0 863 }
hudakz 3:5b17e4656dd0 864
hudakz 3:5b17e4656dd0 865 goto drop;
hudakz 3:5b17e4656dd0 866 }
hudakz 3:5b17e4656dd0 867
hudakz 3:5b17e4656dd0 868 #if UIP_UDP
hudakz 3:5b17e4656dd0 869 if(flag == UIP_UDP_TIMER) {
hudakz 3:5b17e4656dd0 870 if(uip_udp_conn->lport != 0) {
hudakz 3:5b17e4656dd0 871 uip_conn = NULL;
hudakz 3:5b17e4656dd0 872 uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
hudakz 3:5b17e4656dd0 873 uip_len = uip_slen = 0;
hudakz 3:5b17e4656dd0 874 uip_flags = UIP_POLL;
hudakz 3:5b17e4656dd0 875 UIP_UDP_APPCALL();
hudakz 3:5b17e4656dd0 876 goto udp_send;
hudakz 3:5b17e4656dd0 877 }
hudakz 3:5b17e4656dd0 878 else {
hudakz 3:5b17e4656dd0 879 goto drop;
hudakz 3:5b17e4656dd0 880 }
hudakz 3:5b17e4656dd0 881 }
hudakz 3:5b17e4656dd0 882 #endif
hudakz 3:5b17e4656dd0 883 /* This is where the input processing starts. */
hudakz 3:5b17e4656dd0 884
hudakz 3:5b17e4656dd0 885 UIP_STAT(++uip_stat.ip.recv);
hudakz 3:5b17e4656dd0 886
hudakz 3:5b17e4656dd0 887 /* Start of IP input header processing code. */
hudakz 3:5b17e4656dd0 888 #if UIP_CONF_IPV6
hudakz 3:5b17e4656dd0 889 /* Check validity of the IP header. */
hudakz 3:5b17e4656dd0 890
hudakz 3:5b17e4656dd0 891 if((BUF->vtc & 0xf0) != 0x60) {
hudakz 3:5b17e4656dd0 892
hudakz 3:5b17e4656dd0 893 /* IP version and header length. */
hudakz 3:5b17e4656dd0 894 UIP_STAT(++uip_stat.ip.drop);
hudakz 3:5b17e4656dd0 895 UIP_STAT(++uip_stat.ip.vhlerr);
hudakz 3:5b17e4656dd0 896 UIP_LOG("ipv6: invalid version.");
hudakz 3:5b17e4656dd0 897 goto drop;
hudakz 3:5b17e4656dd0 898 }
hudakz 3:5b17e4656dd0 899
hudakz 3:5b17e4656dd0 900 #else /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 901 /* Check validity of the IP header. */
hudakz 3:5b17e4656dd0 902
hudakz 3:5b17e4656dd0 903 if(BUF->vhl != 0x45) {
hudakz 3:5b17e4656dd0 904
hudakz 3:5b17e4656dd0 905 /* IP version and header length. */
hudakz 3:5b17e4656dd0 906 UIP_STAT(++uip_stat.ip.drop);
hudakz 3:5b17e4656dd0 907 UIP_STAT(++uip_stat.ip.vhlerr);
hudakz 3:5b17e4656dd0 908 UIP_LOG("ip: invalid version or header length.");
hudakz 3:5b17e4656dd0 909 goto drop;
hudakz 3:5b17e4656dd0 910 }
hudakz 3:5b17e4656dd0 911 #endif /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 912
hudakz 3:5b17e4656dd0 913 /* Check the size of the packet. If the size reported to us in
hudakz 3:5b17e4656dd0 914 uip_len is smaller the size reported in the IP header, we assume
hudakz 3:5b17e4656dd0 915 that the packet has been corrupted in transit. If the size of
hudakz 3:5b17e4656dd0 916 uip_len is larger than the size reported in the IP packet header,
hudakz 3:5b17e4656dd0 917 the packet has been padded and we set uip_len to the correct
hudakz 3:5b17e4656dd0 918 value.. */
hudakz 3:5b17e4656dd0 919
hudakz 3:5b17e4656dd0 920 if((BUF->len[0] << 8) + BUF->len[1] <= uip_len) {
hudakz 3:5b17e4656dd0 921 uip_len = (BUF->len[0] << 8) + BUF->len[1];
hudakz 3:5b17e4656dd0 922 #if UIP_CONF_IPV6
hudakz 3:5b17e4656dd0 923 uip_len += 40; /* The length reported in the IPv6 header is the
hudakz 3:5b17e4656dd0 924 length of the payload that follows the
hudakz 3:5b17e4656dd0 925 header. However, uIP uses the uip_len variable
hudakz 3:5b17e4656dd0 926 for holding the size of the entire packet,
hudakz 3:5b17e4656dd0 927 including the IP header. For IPv4 this is not a
hudakz 3:5b17e4656dd0 928 problem as the length field in the IPv4 header
hudakz 3:5b17e4656dd0 929 contains the length of the entire packet. But
hudakz 3:5b17e4656dd0 930 for IPv6 we need to add the size of the IPv6
hudakz 3:5b17e4656dd0 931 header (40 bytes). */
hudakz 3:5b17e4656dd0 932 #endif /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 933 }
hudakz 3:5b17e4656dd0 934 else {
hudakz 3:5b17e4656dd0 935 UIP_LOG("ip: packet shorter than reported in IP header.");
hudakz 3:5b17e4656dd0 936 goto drop;
hudakz 3:5b17e4656dd0 937 }
hudakz 3:5b17e4656dd0 938
hudakz 3:5b17e4656dd0 939 #if !UIP_CONF_IPV6
hudakz 3:5b17e4656dd0 940 /* Check the fragment flag. */
hudakz 3:5b17e4656dd0 941
hudakz 3:5b17e4656dd0 942 if((BUF->ipoffset[0] & 0x3f) != 0 || BUF->ipoffset[1] != 0)
hudakz 3:5b17e4656dd0 943 {
hudakz 3:5b17e4656dd0 944 #if UIP_REASSEMBLY
hudakz 3:5b17e4656dd0 945 uip_len = uip_reass();
hudakz 3:5b17e4656dd0 946 if(uip_len == 0) {
hudakz 3:5b17e4656dd0 947 goto drop;
hudakz 3:5b17e4656dd0 948 }
hudakz 3:5b17e4656dd0 949
hudakz 3:5b17e4656dd0 950 #else /* UIP_REASSEMBLY */
hudakz 3:5b17e4656dd0 951 UIP_STAT(++uip_stat.ip.drop);
hudakz 3:5b17e4656dd0 952 UIP_STAT(++uip_stat.ip.fragerr);
hudakz 3:5b17e4656dd0 953 UIP_LOG("ip: fragment dropped.");
hudakz 3:5b17e4656dd0 954 goto drop;
hudakz 3:5b17e4656dd0 955 #endif /* UIP_REASSEMBLY */
hudakz 3:5b17e4656dd0 956 }
hudakz 3:5b17e4656dd0 957 #endif /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 958
hudakz 3:5b17e4656dd0 959 if(uip_ipaddr_cmp(uip_hostaddr, all_zeroes_addr))
hudakz 3:5b17e4656dd0 960 {
hudakz 3:5b17e4656dd0 961 /* If we are configured to use ping IP address configuration and
hudakz 3:5b17e4656dd0 962 hasn't been assigned an IP address yet, we accept all ICMP
hudakz 3:5b17e4656dd0 963 packets. */
hudakz 3:5b17e4656dd0 964 #if UIP_PINGADDRCONF && !UIP_CONF_IPV6
hudakz 3:5b17e4656dd0 965 if(BUF->proto == UIP_PROTO_ICMP) {
hudakz 3:5b17e4656dd0 966 UIP_LOG("ip: possible ping config packet received.");
hudakz 3:5b17e4656dd0 967 goto icmp_input;
hudakz 3:5b17e4656dd0 968 }
hudakz 3:5b17e4656dd0 969 else {
hudakz 3:5b17e4656dd0 970 UIP_LOG("ip: packet dropped since no address assigned.");
hudakz 3:5b17e4656dd0 971 goto drop;
hudakz 3:5b17e4656dd0 972 }
hudakz 3:5b17e4656dd0 973 #endif /* UIP_PINGADDRCONF */
hudakz 3:5b17e4656dd0 974 }
hudakz 3:5b17e4656dd0 975 else
hudakz 3:5b17e4656dd0 976 {
hudakz 3:5b17e4656dd0 977 /* If IP broadcast support is configured, we check for a broadcast
hudakz 3:5b17e4656dd0 978 UDP packet, which may be destined to us. */
hudakz 3:5b17e4656dd0 979 #if UIP_BROADCAST
hudakz 3:5b17e4656dd0 980 DEBUG_PRINTF("UDP IP checksum 0x%04x\n", uip_ipchksum());
hudakz 3:5b17e4656dd0 981 if
hudakz 3:5b17e4656dd0 982 (
hudakz 3:5b17e4656dd0 983 BUF->proto == UIP_PROTO_UDP
hudakz 3:5b17e4656dd0 984 && uip_ipaddr_cmp(BUF->destipaddr, all_ones_addr) /*&&
hudakz 3:5b17e4656dd0 985 uip_ipchksum() == 0xffff*/
hudakz 3:5b17e4656dd0 986 ) {
hudakz 3:5b17e4656dd0 987 goto udp_input;
hudakz 3:5b17e4656dd0 988 }
hudakz 3:5b17e4656dd0 989 #endif /* UIP_BROADCAST */
hudakz 3:5b17e4656dd0 990
hudakz 3:5b17e4656dd0 991 /* Check if the packet is destined for our IP address. */
hudakz 3:5b17e4656dd0 992
hudakz 3:5b17e4656dd0 993 #if !UIP_CONF_IPV6
hudakz 3:5b17e4656dd0 994 if(!uip_ipaddr_cmp(BUF->destipaddr, uip_hostaddr)) {
hudakz 3:5b17e4656dd0 995 UIP_STAT(++uip_stat.ip.drop);
hudakz 3:5b17e4656dd0 996 goto drop;
hudakz 3:5b17e4656dd0 997 }
hudakz 3:5b17e4656dd0 998
hudakz 3:5b17e4656dd0 999 #else /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 1000 /* For IPv6, packet reception is a little trickier as we need to
hudakz 3:5b17e4656dd0 1001 make sure that we listen to certain multicast addresses (all
hudakz 3:5b17e4656dd0 1002 hosts multicast address, and the solicited-node multicast
hudakz 3:5b17e4656dd0 1003 address) as well. However, we will cheat here and accept all
hudakz 3:5b17e4656dd0 1004 multicast packets that are sent to the ff02::/16 addresses. */
hudakz 3:5b17e4656dd0 1005
hudakz 3:5b17e4656dd0 1006 if(!uip_ipaddr_cmp(BUF->destipaddr, uip_hostaddr) && BUF->destipaddr[0] != HTONS(0xff02)) {
hudakz 3:5b17e4656dd0 1007 UIP_STAT(++uip_stat.ip.drop);
hudakz 3:5b17e4656dd0 1008 goto drop;
hudakz 3:5b17e4656dd0 1009 }
hudakz 3:5b17e4656dd0 1010 #endif /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 1011 }
hudakz 3:5b17e4656dd0 1012
hudakz 3:5b17e4656dd0 1013 #if !UIP_CONF_IPV6
hudakz 3:5b17e4656dd0 1014 if(uip_ipchksum() != 0xffff) {
hudakz 3:5b17e4656dd0 1015
hudakz 3:5b17e4656dd0 1016 /* Compute and check the IP header
hudakz 3:5b17e4656dd0 1017 checksum. */
hudakz 3:5b17e4656dd0 1018 UIP_STAT(++uip_stat.ip.drop);
hudakz 3:5b17e4656dd0 1019 UIP_STAT(++uip_stat.ip.chkerr);
hudakz 3:5b17e4656dd0 1020 UIP_LOG("ip: bad checksum.");
hudakz 3:5b17e4656dd0 1021 goto drop;
hudakz 3:5b17e4656dd0 1022 }
hudakz 3:5b17e4656dd0 1023 #endif /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 1024
hudakz 3:5b17e4656dd0 1025 if(BUF->proto == UIP_PROTO_TCP) {
hudakz 3:5b17e4656dd0 1026
hudakz 3:5b17e4656dd0 1027 /* Check for TCP packet. If so,
hudakz 3:5b17e4656dd0 1028 proceed with TCP input
hudakz 3:5b17e4656dd0 1029 processing. */
hudakz 3:5b17e4656dd0 1030 goto tcp_input;
hudakz 3:5b17e4656dd0 1031 }
hudakz 3:5b17e4656dd0 1032
hudakz 3:5b17e4656dd0 1033 #if UIP_UDP
hudakz 3:5b17e4656dd0 1034 if(BUF->proto == UIP_PROTO_UDP) {
hudakz 3:5b17e4656dd0 1035 goto udp_input;
hudakz 3:5b17e4656dd0 1036 }
hudakz 3:5b17e4656dd0 1037 #endif /* UIP_UDP */
hudakz 3:5b17e4656dd0 1038
hudakz 3:5b17e4656dd0 1039 #if !UIP_CONF_IPV6
hudakz 3:5b17e4656dd0 1040 /* ICMPv4 processing code follows. */
hudakz 3:5b17e4656dd0 1041
hudakz 3:5b17e4656dd0 1042 if(BUF->proto != UIP_PROTO_ICMP) {
hudakz 3:5b17e4656dd0 1043
hudakz 3:5b17e4656dd0 1044 /* We only allow ICMP packets from
hudakz 3:5b17e4656dd0 1045 here. */
hudakz 3:5b17e4656dd0 1046 UIP_STAT(++uip_stat.ip.drop);
hudakz 3:5b17e4656dd0 1047 UIP_STAT(++uip_stat.ip.protoerr);
hudakz 3:5b17e4656dd0 1048 UIP_LOG("ip: neither tcp nor icmp.");
hudakz 3:5b17e4656dd0 1049 goto drop;
hudakz 3:5b17e4656dd0 1050 }
hudakz 3:5b17e4656dd0 1051
hudakz 3:5b17e4656dd0 1052 #if UIP_PINGADDRCONF
hudakz 3:5b17e4656dd0 1053 icmp_input :
hudakz 3:5b17e4656dd0 1054 #endif /* UIP_PINGADDRCONF */
hudakz 3:5b17e4656dd0 1055
hudakz 3:5b17e4656dd0 1056 UIP_STAT(++uip_stat.icmp.recv);
hudakz 3:5b17e4656dd0 1057
hudakz 3:5b17e4656dd0 1058 /* ICMP echo (i.e., ping) processing. This is simple, we only change
hudakz 3:5b17e4656dd0 1059 the ICMP type from ECHO to ECHO_REPLY and adjust the ICMP
hudakz 3:5b17e4656dd0 1060 checksum before we return the packet. */
hudakz 3:5b17e4656dd0 1061 if(ICMPBUF->type != ICMP_ECHO) {
hudakz 3:5b17e4656dd0 1062 UIP_STAT(++uip_stat.icmp.drop);
hudakz 3:5b17e4656dd0 1063 UIP_STAT(++uip_stat.icmp.typeerr);
hudakz 3:5b17e4656dd0 1064 UIP_LOG("icmp: not icmp echo.");
hudakz 3:5b17e4656dd0 1065 goto drop;
hudakz 3:5b17e4656dd0 1066 }
hudakz 3:5b17e4656dd0 1067
hudakz 3:5b17e4656dd0 1068 /* If we are configured to use ping IP address assignment, we use
hudakz 3:5b17e4656dd0 1069 the destination IP address of this ping packet and assign it to
hudakz 3:5b17e4656dd0 1070 ourself. */
hudakz 3:5b17e4656dd0 1071 #if UIP_PINGADDRCONF
hudakz 3:5b17e4656dd0 1072 if((uip_hostaddr[0] | uip_hostaddr[1]) == 0) {
hudakz 3:5b17e4656dd0 1073 uip_hostaddr[0] = BUF->destipaddr[0];
hudakz 3:5b17e4656dd0 1074 uip_hostaddr[1] = BUF->destipaddr[1];
hudakz 3:5b17e4656dd0 1075 }
hudakz 3:5b17e4656dd0 1076 #endif /* UIP_PINGADDRCONF */
hudakz 3:5b17e4656dd0 1077
hudakz 3:5b17e4656dd0 1078 ICMPBUF->type = ICMP_ECHO_REPLY;
hudakz 3:5b17e4656dd0 1079
hudakz 3:5b17e4656dd0 1080 if(ICMPBUF->icmpchksum >= HTONS(0xffff - (ICMP_ECHO << 8))) {
hudakz 3:5b17e4656dd0 1081 ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8) + 1;
hudakz 3:5b17e4656dd0 1082 }
hudakz 3:5b17e4656dd0 1083 else {
hudakz 3:5b17e4656dd0 1084 ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8);
hudakz 3:5b17e4656dd0 1085 }
hudakz 3:5b17e4656dd0 1086
hudakz 3:5b17e4656dd0 1087 /* Swap IP addresses. */
hudakz 3:5b17e4656dd0 1088 uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr);
hudakz 3:5b17e4656dd0 1089 uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
hudakz 3:5b17e4656dd0 1090
hudakz 3:5b17e4656dd0 1091 UIP_STAT(++uip_stat.icmp.sent);
hudakz 3:5b17e4656dd0 1092 goto send;
hudakz 3:5b17e4656dd0 1093
hudakz 3:5b17e4656dd0 1094 /* End of IPv4 input header processing code. */
hudakz 3:5b17e4656dd0 1095 #else /* !UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 1096 /* This is IPv6 ICMPv6 processing code. */
hudakz 3:5b17e4656dd0 1097
hudakz 3:5b17e4656dd0 1098 DEBUG_PRINTF("icmp6_input: length %d\n", uip_len);
hudakz 3:5b17e4656dd0 1099
hudakz 3:5b17e4656dd0 1100 if(BUF->proto != UIP_PROTO_ICMP6) {
hudakz 3:5b17e4656dd0 1101
hudakz 3:5b17e4656dd0 1102 /* We only allow ICMPv6 packets from
hudakz 3:5b17e4656dd0 1103 here. */
hudakz 3:5b17e4656dd0 1104 UIP_STAT(++uip_stat.ip.drop);
hudakz 3:5b17e4656dd0 1105 UIP_STAT(++uip_stat.ip.protoerr);
hudakz 3:5b17e4656dd0 1106 UIP_LOG("ip: neither tcp nor icmp6.");
hudakz 3:5b17e4656dd0 1107 goto drop;
hudakz 3:5b17e4656dd0 1108 }
hudakz 3:5b17e4656dd0 1109
hudakz 3:5b17e4656dd0 1110 UIP_STAT(++uip_stat.icmp.recv);
hudakz 3:5b17e4656dd0 1111
hudakz 3:5b17e4656dd0 1112 /* If we get a neighbor solicitation for our address we should send
hudakz 3:5b17e4656dd0 1113 a neighbor advertisement message back. */
hudakz 3:5b17e4656dd0 1114 if(ICMPBUF->type == ICMP6_NEIGHBOR_SOLICITATION) {
hudakz 3:5b17e4656dd0 1115 if(uip_ipaddr_cmp(ICMPBUF->icmp6data, uip_hostaddr)) {
hudakz 3:5b17e4656dd0 1116 if(ICMPBUF->options[0] == ICMP6_OPTION_SOURCE_LINK_ADDRESS) {
hudakz 3:5b17e4656dd0 1117
hudakz 3:5b17e4656dd0 1118 /* Save the sender's address in our neighbor list. */
hudakz 3:5b17e4656dd0 1119 uip_neighbor_add(ICMPBUF->srcipaddr, &(ICMPBUF->options[2]));
hudakz 3:5b17e4656dd0 1120 }
hudakz 3:5b17e4656dd0 1121
hudakz 3:5b17e4656dd0 1122 /* We should now send a neighbor advertisement back to where the
hudakz 3:5b17e4656dd0 1123 neighbor solicication came from. */
hudakz 3:5b17e4656dd0 1124 ICMPBUF->type = ICMP6_NEIGHBOR_ADVERTISEMENT;
hudakz 3:5b17e4656dd0 1125 ICMPBUF->flags = ICMP6_FLAG_S; /* Solicited flag. */
hudakz 3:5b17e4656dd0 1126
hudakz 3:5b17e4656dd0 1127 ICMPBUF->reserved1 = ICMPBUF->reserved2 = ICMPBUF->reserved3 = 0;
hudakz 3:5b17e4656dd0 1128
hudakz 3:5b17e4656dd0 1129 uip_ipaddr_copy(ICMPBUF->destipaddr, ICMPBUF->srcipaddr);
hudakz 3:5b17e4656dd0 1130 uip_ipaddr_copy(ICMPBUF->srcipaddr, uip_hostaddr);
hudakz 3:5b17e4656dd0 1131 ICMPBUF->options[0] = ICMP6_OPTION_TARGET_LINK_ADDRESS;
hudakz 3:5b17e4656dd0 1132 ICMPBUF->options[1] = 1; /* Options length, 1 = 8 bytes. */
hudakz 3:5b17e4656dd0 1133 memcpy(&(ICMPBUF->options[2]), &uip_ethaddr, sizeof(uip_ethaddr));
hudakz 3:5b17e4656dd0 1134 ICMPBUF->icmpchksum = 0;
hudakz 3:5b17e4656dd0 1135 ICMPBUF->icmpchksum = ~uip_icmp6chksum();
hudakz 3:5b17e4656dd0 1136 goto send;
hudakz 3:5b17e4656dd0 1137 }
hudakz 3:5b17e4656dd0 1138
hudakz 3:5b17e4656dd0 1139 goto drop;
hudakz 3:5b17e4656dd0 1140 }
hudakz 3:5b17e4656dd0 1141 else
hudakz 3:5b17e4656dd0 1142 if(ICMPBUF->type == ICMP6_ECHO) {
hudakz 3:5b17e4656dd0 1143
hudakz 3:5b17e4656dd0 1144 /* ICMP echo (i.e., ping) processing. This is simple, we only
hudakz 3:5b17e4656dd0 1145 change the ICMP type from ECHO to ECHO_REPLY and update the
hudakz 3:5b17e4656dd0 1146 ICMP checksum before we return the packet. */
hudakz 3:5b17e4656dd0 1147 ICMPBUF->type = ICMP6_ECHO_REPLY;
hudakz 3:5b17e4656dd0 1148
hudakz 3:5b17e4656dd0 1149 uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr);
hudakz 3:5b17e4656dd0 1150 uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
hudakz 3:5b17e4656dd0 1151 ICMPBUF->icmpchksum = 0;
hudakz 3:5b17e4656dd0 1152 ICMPBUF->icmpchksum = ~uip_icmp6chksum();
hudakz 3:5b17e4656dd0 1153
hudakz 3:5b17e4656dd0 1154 UIP_STAT(++uip_stat.icmp.sent);
hudakz 3:5b17e4656dd0 1155 goto send;
hudakz 3:5b17e4656dd0 1156 }
hudakz 3:5b17e4656dd0 1157 else {
hudakz 3:5b17e4656dd0 1158 DEBUG_PRINTF("Unknown icmp6 message type %d\n", ICMPBUF->type);
hudakz 3:5b17e4656dd0 1159 UIP_STAT(++uip_stat.icmp.drop);
hudakz 3:5b17e4656dd0 1160 UIP_STAT(++uip_stat.icmp.typeerr);
hudakz 3:5b17e4656dd0 1161 UIP_LOG("icmp: unknown ICMP message.");
hudakz 3:5b17e4656dd0 1162 goto drop;
hudakz 3:5b17e4656dd0 1163 }
hudakz 3:5b17e4656dd0 1164
hudakz 3:5b17e4656dd0 1165 /* End of IPv6 ICMP processing. */
hudakz 3:5b17e4656dd0 1166 #endif /* !UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 1167
hudakz 3:5b17e4656dd0 1168 #if UIP_UDP
hudakz 3:5b17e4656dd0 1169 /* UDP input processing. */
hudakz 3:5b17e4656dd0 1170
hudakz 3:5b17e4656dd0 1171 udp_input :
hudakz 3:5b17e4656dd0 1172 /* UDP processing is really just a hack. We don't do anything to the
hudakz 3:5b17e4656dd0 1173 UDP/IP headers, but let the UDP application do all the hard
hudakz 3:5b17e4656dd0 1174 work. If the application sets uip_slen, it has a packet to
hudakz 3:5b17e4656dd0 1175 send. */
hudakz 3:5b17e4656dd0 1176 #if UIP_UDP_CHECKSUMS
hudakz 3:5b17e4656dd0 1177 uip_len = uip_len - UIP_IPUDPH_LEN;
hudakz 3:5b17e4656dd0 1178 uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
hudakz 3:5b17e4656dd0 1179 if(UDPBUF->udpchksum != 0 && uip_udpchksum() != 0xffff) {
hudakz 3:5b17e4656dd0 1180 UIP_STAT(++uip_stat.udp.drop);
hudakz 3:5b17e4656dd0 1181 UIP_STAT(++uip_stat.udp.chkerr);
hudakz 3:5b17e4656dd0 1182 UIP_LOG("udp: bad checksum.");
hudakz 3:5b17e4656dd0 1183 goto drop;
hudakz 3:5b17e4656dd0 1184 }
hudakz 3:5b17e4656dd0 1185
hudakz 3:5b17e4656dd0 1186 #else /* UIP_UDP_CHECKSUMS */
hudakz 3:5b17e4656dd0 1187 uip_len = uip_len - UIP_IPUDPH_LEN;
hudakz 3:5b17e4656dd0 1188 #endif /* UIP_UDP_CHECKSUMS */
hudakz 3:5b17e4656dd0 1189
hudakz 3:5b17e4656dd0 1190 /* Demultiplex this UDP packet between the UDP "connections". */
hudakz 3:5b17e4656dd0 1191
hudakz 3:5b17e4656dd0 1192 for(uip_udp_conn = &uip_udp_conns[0]; uip_udp_conn < &uip_udp_conns[UIP_UDP_CONNS]; ++uip_udp_conn) {
hudakz 3:5b17e4656dd0 1193
hudakz 3:5b17e4656dd0 1194 /* If the local UDP port is non-zero, the connection is considered
hudakz 3:5b17e4656dd0 1195 to be used. If so, the local port number is checked against the
hudakz 3:5b17e4656dd0 1196 destination port number in the received packet. If the two port
hudakz 3:5b17e4656dd0 1197 numbers match, the remote port number is checked if the
hudakz 3:5b17e4656dd0 1198 connection is bound to a remote port. Finally, if the
hudakz 3:5b17e4656dd0 1199 connection is bound to a remote IP address, the source IP
hudakz 3:5b17e4656dd0 1200 address of the packet is checked. */
hudakz 3:5b17e4656dd0 1201 if
hudakz 3:5b17e4656dd0 1202 (
hudakz 3:5b17e4656dd0 1203 uip_udp_conn->lport != 0
hudakz 3:5b17e4656dd0 1204 && UDPBUF->destport == uip_udp_conn->lport
hudakz 3:5b17e4656dd0 1205 && (uip_udp_conn->rport == 0 || UDPBUF->srcport == uip_udp_conn->rport)
hudakz 3:5b17e4656dd0 1206 && (
hudakz 3:5b17e4656dd0 1207 uip_ipaddr_cmp(uip_udp_conn->ripaddr, all_zeroes_addr)
hudakz 3:5b17e4656dd0 1208 || uip_ipaddr_cmp(uip_udp_conn->ripaddr, all_ones_addr)
hudakz 3:5b17e4656dd0 1209 || uip_ipaddr_cmp(BUF->srcipaddr, uip_udp_conn->ripaddr)
hudakz 3:5b17e4656dd0 1210 )
hudakz 3:5b17e4656dd0 1211 ) {
hudakz 3:5b17e4656dd0 1212 goto udp_found;
hudakz 3:5b17e4656dd0 1213 }
hudakz 3:5b17e4656dd0 1214 }
hudakz 3:5b17e4656dd0 1215
hudakz 3:5b17e4656dd0 1216 UIP_LOG("udp: no matching connection found");
hudakz 3:5b17e4656dd0 1217 goto drop;
hudakz 3:5b17e4656dd0 1218
hudakz 3:5b17e4656dd0 1219 udp_found:
hudakz 3:5b17e4656dd0 1220 uip_conn = NULL;
hudakz 3:5b17e4656dd0 1221 uip_flags = UIP_NEWDATA;
hudakz 3:5b17e4656dd0 1222 uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
hudakz 3:5b17e4656dd0 1223 uip_slen = 0;
hudakz 3:5b17e4656dd0 1224 UIP_UDP_APPCALL();
hudakz 3:5b17e4656dd0 1225 udp_send:
hudakz 3:5b17e4656dd0 1226 if(uip_slen == 0) {
hudakz 3:5b17e4656dd0 1227 goto drop;
hudakz 3:5b17e4656dd0 1228 }
hudakz 3:5b17e4656dd0 1229
hudakz 3:5b17e4656dd0 1230 uip_len = uip_slen + UIP_IPUDPH_LEN;
hudakz 3:5b17e4656dd0 1231
hudakz 3:5b17e4656dd0 1232 #if UIP_CONF_IPV6
hudakz 3:5b17e4656dd0 1233 /* For IPv6, the IP length field does not include the IPv6 IP header
hudakz 3:5b17e4656dd0 1234 length. */
hudakz 3:5b17e4656dd0 1235
hudakz 3:5b17e4656dd0 1236 BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);
hudakz 3:5b17e4656dd0 1237 BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);
hudakz 3:5b17e4656dd0 1238 #else /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 1239 BUF->len[0] = (uip_len >> 8);
hudakz 3:5b17e4656dd0 1240 BUF->len[1] = (uip_len & 0xff);
hudakz 3:5b17e4656dd0 1241 #endif /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 1242
hudakz 3:5b17e4656dd0 1243 BUF->ttl = uip_udp_conn->ttl;
hudakz 3:5b17e4656dd0 1244 BUF->proto = UIP_PROTO_UDP;
hudakz 3:5b17e4656dd0 1245
hudakz 3:5b17e4656dd0 1246 UDPBUF->udplen = HTONS(uip_slen + UIP_UDPH_LEN);
hudakz 3:5b17e4656dd0 1247 UDPBUF->udpchksum = 0;
hudakz 3:5b17e4656dd0 1248
hudakz 3:5b17e4656dd0 1249 BUF->srcport = uip_udp_conn->lport;
hudakz 3:5b17e4656dd0 1250 BUF->destport = uip_udp_conn->rport;
hudakz 3:5b17e4656dd0 1251
hudakz 3:5b17e4656dd0 1252 uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
hudakz 3:5b17e4656dd0 1253 uip_ipaddr_copy(BUF->destipaddr, uip_udp_conn->ripaddr);
hudakz 3:5b17e4656dd0 1254
hudakz 3:5b17e4656dd0 1255 uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPTCPH_LEN];
hudakz 3:5b17e4656dd0 1256
hudakz 3:5b17e4656dd0 1257 #if UIP_UDP_CHECKSUMS
hudakz 3:5b17e4656dd0 1258 /* Calculate UDP checksum. */
hudakz 3:5b17e4656dd0 1259
hudakz 3:5b17e4656dd0 1260 UDPBUF->udpchksum = ~(uip_udpchksum());
hudakz 3:5b17e4656dd0 1261 if(UDPBUF->udpchksum == 0) {
hudakz 3:5b17e4656dd0 1262 UDPBUF->udpchksum = 0xffff;
hudakz 3:5b17e4656dd0 1263 }
hudakz 3:5b17e4656dd0 1264 #endif /* UIP_UDP_CHECKSUMS */
hudakz 3:5b17e4656dd0 1265
hudakz 3:5b17e4656dd0 1266 goto ip_send_nolen;
hudakz 3:5b17e4656dd0 1267 #endif /* UIP_UDP */
hudakz 3:5b17e4656dd0 1268
hudakz 3:5b17e4656dd0 1269 /* TCP input processing. */
hudakz 3:5b17e4656dd0 1270
hudakz 3:5b17e4656dd0 1271 tcp_input : UIP_STAT(++uip_stat.tcp.recv);
hudakz 3:5b17e4656dd0 1272
hudakz 3:5b17e4656dd0 1273 /* Start of TCP input header processing code. */
hudakz 3:5b17e4656dd0 1274 if(uip_tcpchksum() != 0xffff) {
hudakz 3:5b17e4656dd0 1275
hudakz 3:5b17e4656dd0 1276 /* Compute and check the TCP
hudakz 3:5b17e4656dd0 1277 checksum. */
hudakz 3:5b17e4656dd0 1278 UIP_STAT(++uip_stat.tcp.drop);
hudakz 3:5b17e4656dd0 1279 UIP_STAT(++uip_stat.tcp.chkerr);
hudakz 3:5b17e4656dd0 1280 UIP_LOG("tcp: bad checksum.");
hudakz 3:5b17e4656dd0 1281 goto drop;
hudakz 3:5b17e4656dd0 1282 }
hudakz 3:5b17e4656dd0 1283
hudakz 3:5b17e4656dd0 1284 /* Demultiplex this segment. */
hudakz 3:5b17e4656dd0 1285 /* First check any active connections. */
hudakz 3:5b17e4656dd0 1286 for(uip_connr = &uip_conns[0]; uip_connr <= &uip_conns[UIP_CONNS - 1]; ++uip_connr) {
hudakz 3:5b17e4656dd0 1287 if
hudakz 3:5b17e4656dd0 1288 (
hudakz 3:5b17e4656dd0 1289 uip_connr->tcpstateflags != UIP_CLOSED
hudakz 3:5b17e4656dd0 1290 && BUF->destport == uip_connr->lport
hudakz 3:5b17e4656dd0 1291 && BUF->srcport == uip_connr->rport
hudakz 3:5b17e4656dd0 1292 && uip_ipaddr_cmp(BUF->srcipaddr, uip_connr->ripaddr)
hudakz 3:5b17e4656dd0 1293 ) {
hudakz 3:5b17e4656dd0 1294 goto found;
hudakz 3:5b17e4656dd0 1295 }
hudakz 3:5b17e4656dd0 1296 }
hudakz 3:5b17e4656dd0 1297
hudakz 3:5b17e4656dd0 1298 /* If we didn't find and active connection that expected the packet,
hudakz 3:5b17e4656dd0 1299 either this packet is an old duplicate, or this is a SYN packet
hudakz 3:5b17e4656dd0 1300 destined for a connection in LISTEN. If the SYN flag isn't set,
hudakz 3:5b17e4656dd0 1301 it is an old packet and we send a RST. */
hudakz 3:5b17e4656dd0 1302 if((BUF->flags & TCP_CTL) != TCP_SYN) {
hudakz 3:5b17e4656dd0 1303 goto reset;
hudakz 3:5b17e4656dd0 1304 }
hudakz 3:5b17e4656dd0 1305
hudakz 3:5b17e4656dd0 1306 tmp16 = BUF->destport;
hudakz 3:5b17e4656dd0 1307
hudakz 3:5b17e4656dd0 1308 /* Next, check listening connections. */
hudakz 3:5b17e4656dd0 1309 for(c = 0; c < UIP_LISTENPORTS; ++c) {
hudakz 3:5b17e4656dd0 1310 if(tmp16 == uip_listenports[c])
hudakz 3:5b17e4656dd0 1311 goto found_listen;
hudakz 3:5b17e4656dd0 1312 }
hudakz 3:5b17e4656dd0 1313
hudakz 3:5b17e4656dd0 1314 /* No matching connection found, so we send a RST packet. */
hudakz 3:5b17e4656dd0 1315 UIP_STAT(++uip_stat.tcp.synrst);
hudakz 3:5b17e4656dd0 1316 reset:
hudakz 3:5b17e4656dd0 1317 /* We do not send resets in response to resets. */
hudakz 3:5b17e4656dd0 1318 if(BUF->flags & TCP_RST) {
hudakz 3:5b17e4656dd0 1319 goto drop;
hudakz 3:5b17e4656dd0 1320 }
hudakz 3:5b17e4656dd0 1321
hudakz 3:5b17e4656dd0 1322 UIP_STAT(++uip_stat.tcp.rst);
hudakz 3:5b17e4656dd0 1323
hudakz 3:5b17e4656dd0 1324 BUF->flags = TCP_RST | TCP_ACK;
hudakz 3:5b17e4656dd0 1325 uip_len = UIP_IPTCPH_LEN;
hudakz 3:5b17e4656dd0 1326 BUF->tcpoffset = 5 << 4;
hudakz 3:5b17e4656dd0 1327
hudakz 3:5b17e4656dd0 1328 /* Flip the seqno and ackno fields in the TCP header. */
hudakz 3:5b17e4656dd0 1329 c = BUF->seqno[3];
hudakz 3:5b17e4656dd0 1330 BUF->seqno[3] = BUF->ackno[3];
hudakz 3:5b17e4656dd0 1331 BUF->ackno[3] = c;
hudakz 3:5b17e4656dd0 1332
hudakz 3:5b17e4656dd0 1333 c = BUF->seqno[2];
hudakz 3:5b17e4656dd0 1334 BUF->seqno[2] = BUF->ackno[2];
hudakz 3:5b17e4656dd0 1335 BUF->ackno[2] = c;
hudakz 3:5b17e4656dd0 1336
hudakz 3:5b17e4656dd0 1337 c = BUF->seqno[1];
hudakz 3:5b17e4656dd0 1338 BUF->seqno[1] = BUF->ackno[1];
hudakz 3:5b17e4656dd0 1339 BUF->ackno[1] = c;
hudakz 3:5b17e4656dd0 1340
hudakz 3:5b17e4656dd0 1341 c = BUF->seqno[0];
hudakz 3:5b17e4656dd0 1342 BUF->seqno[0] = BUF->ackno[0];
hudakz 3:5b17e4656dd0 1343 BUF->ackno[0] = c;
hudakz 3:5b17e4656dd0 1344
hudakz 3:5b17e4656dd0 1345 /* We also have to increase the sequence number we are
hudakz 3:5b17e4656dd0 1346 acknowledging. If the least significant byte overflowed, we need
hudakz 3:5b17e4656dd0 1347 to propagate the carry to the other bytes as well. */
hudakz 3:5b17e4656dd0 1348 if(++BUF->ackno[3] == 0) {
hudakz 3:5b17e4656dd0 1349 if(++BUF->ackno[2] == 0) {
hudakz 3:5b17e4656dd0 1350 if(++BUF->ackno[1] == 0) {
hudakz 3:5b17e4656dd0 1351 ++BUF->ackno[0];
hudakz 3:5b17e4656dd0 1352 }
hudakz 3:5b17e4656dd0 1353 }
hudakz 3:5b17e4656dd0 1354 }
hudakz 3:5b17e4656dd0 1355
hudakz 3:5b17e4656dd0 1356 /* Swap port numbers. */
hudakz 3:5b17e4656dd0 1357 tmp16 = BUF->srcport;
hudakz 3:5b17e4656dd0 1358 BUF->srcport = BUF->destport;
hudakz 3:5b17e4656dd0 1359 BUF->destport = tmp16;
hudakz 3:5b17e4656dd0 1360
hudakz 3:5b17e4656dd0 1361 /* Swap IP addresses. */
hudakz 3:5b17e4656dd0 1362 uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr);
hudakz 3:5b17e4656dd0 1363 uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
hudakz 3:5b17e4656dd0 1364
hudakz 3:5b17e4656dd0 1365 /* And send out the RST packet! */
hudakz 3:5b17e4656dd0 1366 goto tcp_send_noconn;
hudakz 3:5b17e4656dd0 1367
hudakz 3:5b17e4656dd0 1368 /* This label will be jumped to if we matched the incoming packet
hudakz 3:5b17e4656dd0 1369 with a connection in LISTEN. In that case, we should create a new
hudakz 3:5b17e4656dd0 1370 connection and send a SYNACK in return. */
hudakz 3:5b17e4656dd0 1371 found_listen:
hudakz 3:5b17e4656dd0 1372 /* First we check if there are any connections avaliable. Unused
hudakz 3:5b17e4656dd0 1373 connections are kept in the same table as used connections, but
hudakz 3:5b17e4656dd0 1374 unused ones have the tcpstate set to CLOSED. Also, connections in
hudakz 3:5b17e4656dd0 1375 TIME_WAIT are kept track of and we'll use the oldest one if no
hudakz 3:5b17e4656dd0 1376 CLOSED connections are found. Thanks to Eddie C. Dost for a very
hudakz 3:5b17e4656dd0 1377 nice algorithm for the TIME_WAIT search. */
hudakz 3:5b17e4656dd0 1378 uip_connr = 0;
hudakz 3:5b17e4656dd0 1379 for(c = 0; c < UIP_CONNS; ++c) {
hudakz 3:5b17e4656dd0 1380 if(uip_conns[c].tcpstateflags == UIP_CLOSED) {
hudakz 3:5b17e4656dd0 1381 uip_connr = &uip_conns[c];
hudakz 3:5b17e4656dd0 1382 break;
hudakz 3:5b17e4656dd0 1383 }
hudakz 3:5b17e4656dd0 1384
hudakz 3:5b17e4656dd0 1385 if(uip_conns[c].tcpstateflags == UIP_TIME_WAIT) {
hudakz 3:5b17e4656dd0 1386 if(uip_connr == 0 || uip_conns[c].timer > uip_connr->timer) {
hudakz 3:5b17e4656dd0 1387 uip_connr = &uip_conns[c];
hudakz 3:5b17e4656dd0 1388 }
hudakz 3:5b17e4656dd0 1389 }
hudakz 3:5b17e4656dd0 1390 }
hudakz 3:5b17e4656dd0 1391
hudakz 3:5b17e4656dd0 1392 if(uip_connr == 0) {
hudakz 3:5b17e4656dd0 1393
hudakz 3:5b17e4656dd0 1394 /* All connections are used already, we drop packet and hope that
hudakz 3:5b17e4656dd0 1395 the remote end will retransmit the packet at a time when we
hudakz 3:5b17e4656dd0 1396 have more spare connections. */
hudakz 3:5b17e4656dd0 1397 UIP_STAT(++uip_stat.tcp.syndrop);
hudakz 3:5b17e4656dd0 1398 UIP_LOG("tcp: found no unused connections.");
hudakz 3:5b17e4656dd0 1399 goto drop;
hudakz 3:5b17e4656dd0 1400 }
hudakz 3:5b17e4656dd0 1401
hudakz 3:5b17e4656dd0 1402 uip_conn = uip_connr;
hudakz 3:5b17e4656dd0 1403
hudakz 3:5b17e4656dd0 1404 /* Fill in the necessary fields for the new connection. */
hudakz 3:5b17e4656dd0 1405 uip_connr->rto = uip_connr->timer = UIP_RTO;
hudakz 3:5b17e4656dd0 1406 uip_connr->sa = 0;
hudakz 3:5b17e4656dd0 1407 uip_connr->sv = 4;
hudakz 3:5b17e4656dd0 1408 uip_connr->nrtx = 0;
hudakz 3:5b17e4656dd0 1409 uip_connr->lport = BUF->destport;
hudakz 3:5b17e4656dd0 1410 uip_connr->rport = BUF->srcport;
hudakz 3:5b17e4656dd0 1411 uip_ipaddr_copy(uip_connr->ripaddr, BUF->srcipaddr);
hudakz 3:5b17e4656dd0 1412 uip_connr->tcpstateflags = UIP_SYN_RCVD;
hudakz 3:5b17e4656dd0 1413
hudakz 3:5b17e4656dd0 1414 uip_connr->snd_nxt[0] = iss[0];
hudakz 3:5b17e4656dd0 1415 uip_connr->snd_nxt[1] = iss[1];
hudakz 3:5b17e4656dd0 1416 uip_connr->snd_nxt[2] = iss[2];
hudakz 3:5b17e4656dd0 1417 uip_connr->snd_nxt[3] = iss[3];
hudakz 3:5b17e4656dd0 1418 uip_connr->len = 1;
hudakz 3:5b17e4656dd0 1419
hudakz 3:5b17e4656dd0 1420 /* rcv_nxt should be the seqno from the incoming packet + 1. */
hudakz 3:5b17e4656dd0 1421 uip_connr->rcv_nxt[3] = BUF->seqno[3];
hudakz 3:5b17e4656dd0 1422 uip_connr->rcv_nxt[2] = BUF->seqno[2];
hudakz 3:5b17e4656dd0 1423 uip_connr->rcv_nxt[1] = BUF->seqno[1];
hudakz 3:5b17e4656dd0 1424 uip_connr->rcv_nxt[0] = BUF->seqno[0];
hudakz 3:5b17e4656dd0 1425 uip_add_rcv_nxt(1);
hudakz 3:5b17e4656dd0 1426
hudakz 3:5b17e4656dd0 1427 /* Parse the TCP MSS option, if present. */
hudakz 3:5b17e4656dd0 1428 if((BUF->tcpoffset & 0xf0) > 0x50) {
hudakz 3:5b17e4656dd0 1429 for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2;) {
hudakz 3:5b17e4656dd0 1430 opt = uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + c];
hudakz 3:5b17e4656dd0 1431 if(opt == TCP_OPT_END) {
hudakz 3:5b17e4656dd0 1432
hudakz 3:5b17e4656dd0 1433 /* End of options. */
hudakz 3:5b17e4656dd0 1434 break;
hudakz 3:5b17e4656dd0 1435 }
hudakz 3:5b17e4656dd0 1436 else
hudakz 3:5b17e4656dd0 1437 if(opt == TCP_OPT_NOOP) {
hudakz 3:5b17e4656dd0 1438 ++c;
hudakz 3:5b17e4656dd0 1439
hudakz 3:5b17e4656dd0 1440 /* NOP option. */
hudakz 3:5b17e4656dd0 1441 }
hudakz 3:5b17e4656dd0 1442 else
hudakz 3:5b17e4656dd0 1443 if(opt == TCP_OPT_MSS && uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == TCP_OPT_MSS_LEN) {
hudakz 3:5b17e4656dd0 1444
hudakz 3:5b17e4656dd0 1445 /* An MSS option with the right option length. */
hudakz 3:5b17e4656dd0 1446 tmp16 = ((u16_t) uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) | (u16_t) uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + 3 + c];
hudakz 3:5b17e4656dd0 1447 uip_connr->initialmss = uip_connr->mss = tmp16 > UIP_TCP_MSS ? UIP_TCP_MSS : tmp16;
hudakz 3:5b17e4656dd0 1448
hudakz 3:5b17e4656dd0 1449 /* And we are done processing options. */
hudakz 3:5b17e4656dd0 1450 break;
hudakz 3:5b17e4656dd0 1451 }
hudakz 3:5b17e4656dd0 1452 else {
hudakz 3:5b17e4656dd0 1453
hudakz 3:5b17e4656dd0 1454 /* All other options have a length field, so that we easily
hudakz 3:5b17e4656dd0 1455 can skip past them. */
hudakz 3:5b17e4656dd0 1456 if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {
hudakz 3:5b17e4656dd0 1457
hudakz 3:5b17e4656dd0 1458 /* If the length field is zero, the options are malformed
hudakz 3:5b17e4656dd0 1459 and we don't process them further. */
hudakz 3:5b17e4656dd0 1460 break;
hudakz 3:5b17e4656dd0 1461 }
hudakz 3:5b17e4656dd0 1462
hudakz 3:5b17e4656dd0 1463 c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
hudakz 3:5b17e4656dd0 1464 }
hudakz 3:5b17e4656dd0 1465 }
hudakz 3:5b17e4656dd0 1466 }
hudakz 3:5b17e4656dd0 1467
hudakz 3:5b17e4656dd0 1468 /* Our response will be a SYNACK. */
hudakz 3:5b17e4656dd0 1469 #if UIP_ACTIVE_OPEN
hudakz 3:5b17e4656dd0 1470 tcp_send_synack : BUF->flags = TCP_ACK;
hudakz 3:5b17e4656dd0 1471
hudakz 3:5b17e4656dd0 1472 tcp_send_syn:
hudakz 3:5b17e4656dd0 1473 BUF->flags |= TCP_SYN;
hudakz 3:5b17e4656dd0 1474 #else /* UIP_ACTIVE_OPEN */
hudakz 3:5b17e4656dd0 1475 tcp_send_synack : BUF->flags = TCP_SYN | TCP_ACK;
hudakz 3:5b17e4656dd0 1476 #endif /* UIP_ACTIVE_OPEN */
hudakz 3:5b17e4656dd0 1477
hudakz 3:5b17e4656dd0 1478 /* We send out the TCP Maximum Segment Size option with our
hudakz 3:5b17e4656dd0 1479 SYNACK. */
hudakz 3:5b17e4656dd0 1480
hudakz 3:5b17e4656dd0 1481 BUF->optdata[0] = TCP_OPT_MSS;
hudakz 3:5b17e4656dd0 1482 BUF->optdata[1] = TCP_OPT_MSS_LEN;
hudakz 3:5b17e4656dd0 1483 BUF->optdata[2] = (UIP_TCP_MSS) / 256;
hudakz 3:5b17e4656dd0 1484 BUF->optdata[3] = (UIP_TCP_MSS) & 255;
hudakz 3:5b17e4656dd0 1485 uip_len = UIP_IPTCPH_LEN + TCP_OPT_MSS_LEN;
hudakz 3:5b17e4656dd0 1486 BUF->tcpoffset = ((UIP_TCPH_LEN + TCP_OPT_MSS_LEN) / 4) << 4;
hudakz 3:5b17e4656dd0 1487 goto tcp_send;
hudakz 3:5b17e4656dd0 1488
hudakz 3:5b17e4656dd0 1489 /* This label will be jumped to if we found an active connection. */
hudakz 3:5b17e4656dd0 1490 found:
hudakz 3:5b17e4656dd0 1491 uip_conn = uip_connr;
hudakz 3:5b17e4656dd0 1492 uip_flags = 0;
hudakz 3:5b17e4656dd0 1493
hudakz 3:5b17e4656dd0 1494 /* We do a very naive form of TCP reset processing; we just accept
hudakz 3:5b17e4656dd0 1495 any RST and kill our connection. We should in fact check if the
hudakz 3:5b17e4656dd0 1496 sequence number of this reset is wihtin our advertised window
hudakz 3:5b17e4656dd0 1497 before we accept the reset. */
hudakz 3:5b17e4656dd0 1498 if(BUF->flags & TCP_RST) {
hudakz 3:5b17e4656dd0 1499 uip_connr->tcpstateflags = UIP_CLOSED;
hudakz 3:5b17e4656dd0 1500 UIP_LOG("tcp: got reset, aborting connection.");
hudakz 3:5b17e4656dd0 1501 uip_flags = UIP_ABORT;
hudakz 3:5b17e4656dd0 1502 UIP_APPCALL();
hudakz 3:5b17e4656dd0 1503 goto drop;
hudakz 3:5b17e4656dd0 1504 }
hudakz 3:5b17e4656dd0 1505
hudakz 3:5b17e4656dd0 1506 /* Calculated the length of the data, if the application has sent
hudakz 3:5b17e4656dd0 1507 any data to us. */
hudakz 3:5b17e4656dd0 1508 c = (BUF->tcpoffset >> 4) << 2;
hudakz 3:5b17e4656dd0 1509
hudakz 3:5b17e4656dd0 1510 /* uip_len will contain the length of the actual TCP data. This is
hudakz 3:5b17e4656dd0 1511 calculated by subtracing the length of the TCP header (in
hudakz 3:5b17e4656dd0 1512 c) and the length of the IP header (20 bytes). */
hudakz 3:5b17e4656dd0 1513 uip_len = uip_len - c - UIP_IPH_LEN;
hudakz 3:5b17e4656dd0 1514
hudakz 3:5b17e4656dd0 1515 /* First, check if the sequence number of the incoming packet is
hudakz 3:5b17e4656dd0 1516 what we're expecting next. If not, we send out an ACK with the
hudakz 3:5b17e4656dd0 1517 correct numbers in. */
hudakz 3:5b17e4656dd0 1518 if(!(((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_SYN_SENT) && ((BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)))) {
hudakz 3:5b17e4656dd0 1519 if
hudakz 3:5b17e4656dd0 1520 (
hudakz 3:5b17e4656dd0 1521 (uip_len > 0 || ((BUF->flags & (TCP_SYN | TCP_FIN)) != 0))
hudakz 3:5b17e4656dd0 1522 && (
hudakz 3:5b17e4656dd0 1523 BUF->seqno[0] != uip_connr->rcv_nxt[0]
hudakz 3:5b17e4656dd0 1524 || BUF->seqno[1] != uip_connr->rcv_nxt[1]
hudakz 3:5b17e4656dd0 1525 || BUF->seqno[2] != uip_connr->rcv_nxt[2]
hudakz 3:5b17e4656dd0 1526 || BUF->seqno[3] != uip_connr->rcv_nxt[3]
hudakz 3:5b17e4656dd0 1527 )
hudakz 3:5b17e4656dd0 1528 ) {
hudakz 3:5b17e4656dd0 1529 goto tcp_send_ack;
hudakz 3:5b17e4656dd0 1530 }
hudakz 3:5b17e4656dd0 1531 }
hudakz 3:5b17e4656dd0 1532
hudakz 3:5b17e4656dd0 1533 /* Next, check if the incoming segment acknowledges any outstanding
hudakz 3:5b17e4656dd0 1534 data. If so, we update the sequence number, reset the length of
hudakz 3:5b17e4656dd0 1535 the outstanding data, calculate RTT estimations, and reset the
hudakz 3:5b17e4656dd0 1536 retransmission timer. */
hudakz 3:5b17e4656dd0 1537 if((BUF->flags & TCP_ACK) && uip_outstanding(uip_connr)) {
hudakz 3:5b17e4656dd0 1538 uip_add32(uip_connr->snd_nxt, uip_connr->len);
hudakz 3:5b17e4656dd0 1539
hudakz 3:5b17e4656dd0 1540 if
hudakz 3:5b17e4656dd0 1541 (
hudakz 3:5b17e4656dd0 1542 BUF->ackno[0] == uip_acc32[0]
hudakz 3:5b17e4656dd0 1543 && BUF->ackno[1] == uip_acc32[1]
hudakz 3:5b17e4656dd0 1544 && BUF->ackno[2] == uip_acc32[2]
hudakz 3:5b17e4656dd0 1545 && BUF->ackno[3] == uip_acc32[3]
hudakz 3:5b17e4656dd0 1546 ) {
hudakz 3:5b17e4656dd0 1547
hudakz 3:5b17e4656dd0 1548 /* Update sequence number. */
hudakz 3:5b17e4656dd0 1549 uip_connr->snd_nxt[0] = uip_acc32[0];
hudakz 3:5b17e4656dd0 1550 uip_connr->snd_nxt[1] = uip_acc32[1];
hudakz 3:5b17e4656dd0 1551 uip_connr->snd_nxt[2] = uip_acc32[2];
hudakz 3:5b17e4656dd0 1552 uip_connr->snd_nxt[3] = uip_acc32[3];
hudakz 3:5b17e4656dd0 1553
hudakz 3:5b17e4656dd0 1554 /* Do RTT estimation, unless we have done retransmissions. */
hudakz 3:5b17e4656dd0 1555 if(uip_connr->nrtx == 0) {
hudakz 3:5b17e4656dd0 1556 signed char m;
hudakz 3:5b17e4656dd0 1557 m = uip_connr->rto - uip_connr->timer;
hudakz 3:5b17e4656dd0 1558
hudakz 3:5b17e4656dd0 1559 /* This is taken directly from VJs original code in his paper */
hudakz 3:5b17e4656dd0 1560 m = m - (uip_connr->sa >> 3);
hudakz 3:5b17e4656dd0 1561 uip_connr->sa += m;
hudakz 3:5b17e4656dd0 1562 if(m < 0) {
hudakz 3:5b17e4656dd0 1563 m = -m;
hudakz 3:5b17e4656dd0 1564 }
hudakz 3:5b17e4656dd0 1565
hudakz 3:5b17e4656dd0 1566 m = m - (uip_connr->sv >> 2);
hudakz 3:5b17e4656dd0 1567 uip_connr->sv += m;
hudakz 3:5b17e4656dd0 1568 uip_connr->rto = (uip_connr->sa >> 3) + uip_connr->sv;
hudakz 3:5b17e4656dd0 1569 }
hudakz 3:5b17e4656dd0 1570
hudakz 3:5b17e4656dd0 1571 /* Set the acknowledged flag. */
hudakz 3:5b17e4656dd0 1572 uip_flags = UIP_ACKDATA;
hudakz 3:5b17e4656dd0 1573
hudakz 3:5b17e4656dd0 1574 /* Reset the retransmission timer. */
hudakz 3:5b17e4656dd0 1575 uip_connr->timer = uip_connr->rto;
hudakz 3:5b17e4656dd0 1576
hudakz 3:5b17e4656dd0 1577 /* Reset length of outstanding data. */
hudakz 3:5b17e4656dd0 1578 uip_connr->len = 0;
hudakz 3:5b17e4656dd0 1579 }
hudakz 3:5b17e4656dd0 1580 }
hudakz 3:5b17e4656dd0 1581
hudakz 3:5b17e4656dd0 1582 /* Do different things depending on in what state the connection is. */
hudakz 3:5b17e4656dd0 1583 switch(uip_connr->tcpstateflags & UIP_TS_MASK) {
hudakz 3:5b17e4656dd0 1584 /* CLOSED and LISTEN are not handled here. CLOSE_WAIT is not
hudakz 3:5b17e4656dd0 1585 implemented, since we force the application to close when the
hudakz 3:5b17e4656dd0 1586 peer sends a FIN (hence the application goes directly from
hudakz 3:5b17e4656dd0 1587 ESTABLISHED to LAST_ACK). */
hudakz 3:5b17e4656dd0 1588 case UIP_SYN_RCVD:
hudakz 3:5b17e4656dd0 1589 /* In SYN_RCVD we have sent out a SYNACK in response to a SYN, and
hudakz 3:5b17e4656dd0 1590 we are waiting for an ACK that acknowledges the data we sent
hudakz 3:5b17e4656dd0 1591 out the last time. Therefore, we want to have the UIP_ACKDATA
hudakz 3:5b17e4656dd0 1592 flag set. If so, we enter the ESTABLISHED state. */
hudakz 3:5b17e4656dd0 1593 if(uip_flags & UIP_ACKDATA) {
hudakz 3:5b17e4656dd0 1594 uip_connr->tcpstateflags = UIP_ESTABLISHED;
hudakz 3:5b17e4656dd0 1595 uip_flags = UIP_CONNECTED;
hudakz 3:5b17e4656dd0 1596 uip_connr->len = 0;
hudakz 3:5b17e4656dd0 1597 if(uip_len > 0) {
hudakz 3:5b17e4656dd0 1598 uip_flags |= UIP_NEWDATA;
hudakz 3:5b17e4656dd0 1599 uip_add_rcv_nxt(uip_len);
hudakz 3:5b17e4656dd0 1600 }
hudakz 3:5b17e4656dd0 1601
hudakz 3:5b17e4656dd0 1602 uip_slen = 0;
hudakz 3:5b17e4656dd0 1603 UIP_APPCALL();
hudakz 3:5b17e4656dd0 1604 goto appsend;
hudakz 3:5b17e4656dd0 1605 }
hudakz 3:5b17e4656dd0 1606
hudakz 3:5b17e4656dd0 1607 goto drop;
hudakz 3:5b17e4656dd0 1608 #if UIP_ACTIVE_OPEN
hudakz 3:5b17e4656dd0 1609
hudakz 3:5b17e4656dd0 1610 case UIP_SYN_SENT:
hudakz 3:5b17e4656dd0 1611 /* In SYN_SENT, we wait for a SYNACK that is sent in response to
hudakz 3:5b17e4656dd0 1612 our SYN. The rcv_nxt is set to sequence number in the SYNACK
hudakz 3:5b17e4656dd0 1613 plus one, and we send an ACK. We move into the ESTABLISHED
hudakz 3:5b17e4656dd0 1614 state. */
hudakz 3:5b17e4656dd0 1615 if((uip_flags & UIP_ACKDATA) && (BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)) {
hudakz 3:5b17e4656dd0 1616
hudakz 3:5b17e4656dd0 1617 /* Parse the TCP MSS option, if present. */
hudakz 3:5b17e4656dd0 1618 if((BUF->tcpoffset & 0xf0) > 0x50) {
hudakz 3:5b17e4656dd0 1619 for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2;) {
hudakz 3:5b17e4656dd0 1620 opt = uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + c];
hudakz 3:5b17e4656dd0 1621 if(opt == TCP_OPT_END) {
hudakz 3:5b17e4656dd0 1622
hudakz 3:5b17e4656dd0 1623 /* End of options. */
hudakz 3:5b17e4656dd0 1624 break;
hudakz 3:5b17e4656dd0 1625 }
hudakz 3:5b17e4656dd0 1626 else
hudakz 3:5b17e4656dd0 1627 if(opt == TCP_OPT_NOOP) {
hudakz 3:5b17e4656dd0 1628 ++c;
hudakz 3:5b17e4656dd0 1629
hudakz 3:5b17e4656dd0 1630 /* NOP option. */
hudakz 3:5b17e4656dd0 1631 }
hudakz 3:5b17e4656dd0 1632 else
hudakz 3:5b17e4656dd0 1633 if(opt == TCP_OPT_MSS && uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == TCP_OPT_MSS_LEN) {
hudakz 3:5b17e4656dd0 1634
hudakz 3:5b17e4656dd0 1635 /* An MSS option with the right option length. */
hudakz 3:5b17e4656dd0 1636 tmp16 = (uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) | uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 3 + c];
hudakz 3:5b17e4656dd0 1637 uip_connr->initialmss = uip_connr->mss = tmp16 > UIP_TCP_MSS ? UIP_TCP_MSS : tmp16;
hudakz 3:5b17e4656dd0 1638
hudakz 3:5b17e4656dd0 1639 /* And we are done processing options. */
hudakz 3:5b17e4656dd0 1640 break;
hudakz 3:5b17e4656dd0 1641 }
hudakz 3:5b17e4656dd0 1642 else {
hudakz 3:5b17e4656dd0 1643
hudakz 3:5b17e4656dd0 1644 /* All other options have a length field, so that we easily
hudakz 3:5b17e4656dd0 1645 can skip past them. */
hudakz 3:5b17e4656dd0 1646 if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {
hudakz 3:5b17e4656dd0 1647
hudakz 3:5b17e4656dd0 1648 /* If the length field is zero, the options are malformed
hudakz 3:5b17e4656dd0 1649 and we don't process them further. */
hudakz 3:5b17e4656dd0 1650 break;
hudakz 3:5b17e4656dd0 1651 }
hudakz 3:5b17e4656dd0 1652
hudakz 3:5b17e4656dd0 1653 c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
hudakz 3:5b17e4656dd0 1654 }
hudakz 3:5b17e4656dd0 1655 }
hudakz 3:5b17e4656dd0 1656 }
hudakz 3:5b17e4656dd0 1657
hudakz 3:5b17e4656dd0 1658 uip_connr->tcpstateflags = UIP_ESTABLISHED;
hudakz 3:5b17e4656dd0 1659 uip_connr->rcv_nxt[0] = BUF->seqno[0];
hudakz 3:5b17e4656dd0 1660 uip_connr->rcv_nxt[1] = BUF->seqno[1];
hudakz 3:5b17e4656dd0 1661 uip_connr->rcv_nxt[2] = BUF->seqno[2];
hudakz 3:5b17e4656dd0 1662 uip_connr->rcv_nxt[3] = BUF->seqno[3];
hudakz 3:5b17e4656dd0 1663 uip_add_rcv_nxt(1);
hudakz 3:5b17e4656dd0 1664 uip_flags = UIP_CONNECTED | UIP_NEWDATA;
hudakz 3:5b17e4656dd0 1665 uip_connr->len = 0;
hudakz 3:5b17e4656dd0 1666 uip_len = 0;
hudakz 3:5b17e4656dd0 1667 uip_slen = 0;
hudakz 3:5b17e4656dd0 1668 UIP_APPCALL();
hudakz 3:5b17e4656dd0 1669 goto appsend;
hudakz 3:5b17e4656dd0 1670 }
hudakz 3:5b17e4656dd0 1671
hudakz 3:5b17e4656dd0 1672 /* Inform the application that the connection failed */
hudakz 3:5b17e4656dd0 1673 uip_flags = UIP_ABORT;
hudakz 3:5b17e4656dd0 1674 UIP_APPCALL();
hudakz 3:5b17e4656dd0 1675
hudakz 3:5b17e4656dd0 1676 /* The connection is closed after we send the RST */
hudakz 3:5b17e4656dd0 1677 uip_conn->tcpstateflags = UIP_CLOSED;
hudakz 3:5b17e4656dd0 1678 goto reset;
hudakz 3:5b17e4656dd0 1679 #endif /* UIP_ACTIVE_OPEN */
hudakz 3:5b17e4656dd0 1680
hudakz 3:5b17e4656dd0 1681 case UIP_ESTABLISHED:
hudakz 3:5b17e4656dd0 1682 /* In the ESTABLISHED state, we call upon the application to feed
hudakz 3:5b17e4656dd0 1683 data into the uip_buf. If the UIP_ACKDATA flag is set, the
hudakz 3:5b17e4656dd0 1684 application should put new data into the buffer, otherwise we are
hudakz 3:5b17e4656dd0 1685 retransmitting an old segment, and the application should put that
hudakz 3:5b17e4656dd0 1686 data into the buffer.
hudakz 3:5b17e4656dd0 1687
hudakz 3:5b17e4656dd0 1688 If the incoming packet is a FIN, we should close the connection on
hudakz 3:5b17e4656dd0 1689 this side as well, and we send out a FIN and enter the LAST_ACK
hudakz 3:5b17e4656dd0 1690 state. We require that there is no outstanding data; otherwise the
hudakz 3:5b17e4656dd0 1691 sequence numbers will be screwed up. */
hudakz 3:5b17e4656dd0 1692 if(BUF->flags & TCP_FIN && !(uip_connr->tcpstateflags & UIP_STOPPED)) {
hudakz 3:5b17e4656dd0 1693 if(uip_outstanding(uip_connr)) {
hudakz 3:5b17e4656dd0 1694 goto drop;
hudakz 3:5b17e4656dd0 1695 }
hudakz 3:5b17e4656dd0 1696
hudakz 3:5b17e4656dd0 1697 uip_add_rcv_nxt(1 + uip_len);
hudakz 3:5b17e4656dd0 1698 uip_flags |= UIP_CLOSE;
hudakz 3:5b17e4656dd0 1699 if(uip_len > 0) {
hudakz 3:5b17e4656dd0 1700 uip_flags |= UIP_NEWDATA;
hudakz 3:5b17e4656dd0 1701 }
hudakz 3:5b17e4656dd0 1702
hudakz 3:5b17e4656dd0 1703 UIP_APPCALL();
hudakz 3:5b17e4656dd0 1704 uip_connr->len = 1;
hudakz 3:5b17e4656dd0 1705 uip_connr->tcpstateflags = UIP_LAST_ACK;
hudakz 3:5b17e4656dd0 1706 uip_connr->nrtx = 0;
hudakz 3:5b17e4656dd0 1707 tcp_send_finack:
hudakz 3:5b17e4656dd0 1708 BUF->flags = TCP_FIN | TCP_ACK;
hudakz 3:5b17e4656dd0 1709 goto tcp_send_nodata;
hudakz 3:5b17e4656dd0 1710 }
hudakz 3:5b17e4656dd0 1711
hudakz 3:5b17e4656dd0 1712 /* Check the URG flag. If this is set, the segment carries urgent
hudakz 3:5b17e4656dd0 1713 data that we must pass to the application. */
hudakz 3:5b17e4656dd0 1714 if((BUF->flags & TCP_URG) != 0)
hudakz 3:5b17e4656dd0 1715 {
hudakz 3:5b17e4656dd0 1716 #if UIP_URGDATA > 0
hudakz 3:5b17e4656dd0 1717 uip_urglen = (BUF->urgp[0] << 8) | BUF->urgp[1];
hudakz 3:5b17e4656dd0 1718 if(uip_urglen > uip_len) {
hudakz 3:5b17e4656dd0 1719
hudakz 3:5b17e4656dd0 1720 /* There is more urgent data in the next segment to come. */
hudakz 3:5b17e4656dd0 1721 uip_urglen = uip_len;
hudakz 3:5b17e4656dd0 1722 }
hudakz 3:5b17e4656dd0 1723
hudakz 3:5b17e4656dd0 1724 uip_add_rcv_nxt(uip_urglen);
hudakz 3:5b17e4656dd0 1725 uip_len -= uip_urglen;
hudakz 3:5b17e4656dd0 1726 uip_urgdata = uip_appdata;
hudakz 3:5b17e4656dd0 1727 uip_appdata += uip_urglen;
hudakz 3:5b17e4656dd0 1728 }
hudakz 3:5b17e4656dd0 1729 else {
hudakz 3:5b17e4656dd0 1730 uip_urglen = 0;
hudakz 3:5b17e4656dd0 1731 #else /* UIP_URGDATA > 0 */
hudakz 3:5b17e4656dd0 1732 uip_appdata = ((char*)uip_appdata) + ((BUF->urgp[0] << 8) | BUF->urgp[1]);
hudakz 3:5b17e4656dd0 1733 uip_len -= (BUF->urgp[0] << 8) | BUF->urgp[1];
hudakz 3:5b17e4656dd0 1734 #endif /* UIP_URGDATA > 0 */
hudakz 3:5b17e4656dd0 1735 }
hudakz 3:5b17e4656dd0 1736
hudakz 3:5b17e4656dd0 1737 /* If uip_len > 0 we have TCP data in the packet, and we flag this
hudakz 3:5b17e4656dd0 1738 by setting the UIP_NEWDATA flag and update the sequence number
hudakz 3:5b17e4656dd0 1739 we acknowledge. If the application has stopped the dataflow
hudakz 3:5b17e4656dd0 1740 using uip_stop(), we must not accept any data packets from the
hudakz 3:5b17e4656dd0 1741 remote host. */
hudakz 3:5b17e4656dd0 1742 if(uip_len > 0 && !(uip_connr->tcpstateflags & UIP_STOPPED)) {
hudakz 3:5b17e4656dd0 1743 uip_flags |= UIP_NEWDATA;
hudakz 3:5b17e4656dd0 1744 uip_add_rcv_nxt(uip_len);
hudakz 3:5b17e4656dd0 1745 }
hudakz 3:5b17e4656dd0 1746
hudakz 3:5b17e4656dd0 1747 /* Check if the available buffer space advertised by the other end
hudakz 3:5b17e4656dd0 1748 is smaller than the initial MSS for this connection. If so, we
hudakz 3:5b17e4656dd0 1749 set the current MSS to the window size to ensure that the
hudakz 3:5b17e4656dd0 1750 application does not send more data than the other end can
hudakz 3:5b17e4656dd0 1751 handle.
hudakz 3:5b17e4656dd0 1752
hudakz 3:5b17e4656dd0 1753 If the remote host advertises a zero window, we set the MSS to
hudakz 3:5b17e4656dd0 1754 the initial MSS so that the application will send an entire MSS
hudakz 3:5b17e4656dd0 1755 of data. This data will not be acknowledged by the receiver,
hudakz 3:5b17e4656dd0 1756 and the application will retransmit it. This is called the
hudakz 3:5b17e4656dd0 1757 "persistent timer" and uses the retransmission mechanim.
hudakz 3:5b17e4656dd0 1758 */
hudakz 3:5b17e4656dd0 1759 tmp16 = ((u16_t) BUF->wnd[0] << 8) + (u16_t) BUF->wnd[1];
hudakz 3:5b17e4656dd0 1760 if(tmp16 > uip_connr->initialmss || tmp16 == 0) {
hudakz 3:5b17e4656dd0 1761 tmp16 = uip_connr->initialmss;
hudakz 3:5b17e4656dd0 1762 }
hudakz 3:5b17e4656dd0 1763
hudakz 3:5b17e4656dd0 1764 uip_connr->mss = tmp16;
hudakz 3:5b17e4656dd0 1765
hudakz 3:5b17e4656dd0 1766 /* If this packet constitutes an ACK for outstanding data (flagged
hudakz 3:5b17e4656dd0 1767 by the UIP_ACKDATA flag, we should call the application since it
hudakz 3:5b17e4656dd0 1768 might want to send more data. If the incoming packet had data
hudakz 3:5b17e4656dd0 1769 from the peer (as flagged by the UIP_NEWDATA flag), the
hudakz 3:5b17e4656dd0 1770 application must also be notified.
hudakz 3:5b17e4656dd0 1771
hudakz 3:5b17e4656dd0 1772 When the application is called, the global variable uip_len
hudakz 3:5b17e4656dd0 1773 contains the length of the incoming data. The application can
hudakz 3:5b17e4656dd0 1774 access the incoming data through the global pointer
hudakz 3:5b17e4656dd0 1775 uip_appdata, which usually points UIP_IPTCPH_LEN + UIP_LLH_LEN
hudakz 3:5b17e4656dd0 1776 bytes into the uip_buf array.
hudakz 3:5b17e4656dd0 1777
hudakz 3:5b17e4656dd0 1778 If the application wishes to send any data, this data should be
hudakz 3:5b17e4656dd0 1779 put into the uip_appdata and the length of the data should be
hudakz 3:5b17e4656dd0 1780 put into uip_len. If the application don't have any data to
hudakz 3:5b17e4656dd0 1781 send, uip_len must be set to 0. */
hudakz 3:5b17e4656dd0 1782 if(uip_flags & (UIP_NEWDATA | UIP_ACKDATA)) {
hudakz 3:5b17e4656dd0 1783 uip_slen = 0;
hudakz 3:5b17e4656dd0 1784 UIP_APPCALL();
hudakz 3:5b17e4656dd0 1785
hudakz 3:5b17e4656dd0 1786 appsend:
hudakz 3:5b17e4656dd0 1787 if(uip_flags & UIP_ABORT) {
hudakz 3:5b17e4656dd0 1788 uip_slen = 0;
hudakz 3:5b17e4656dd0 1789 uip_connr->tcpstateflags = UIP_CLOSED;
hudakz 3:5b17e4656dd0 1790 BUF->flags = TCP_RST | TCP_ACK;
hudakz 3:5b17e4656dd0 1791 goto tcp_send_nodata;
hudakz 3:5b17e4656dd0 1792 }
hudakz 3:5b17e4656dd0 1793
hudakz 3:5b17e4656dd0 1794 if(uip_flags & UIP_CLOSE) {
hudakz 3:5b17e4656dd0 1795 uip_slen = 0;
hudakz 3:5b17e4656dd0 1796 uip_connr->len = 1;
hudakz 3:5b17e4656dd0 1797 uip_connr->tcpstateflags = UIP_FIN_WAIT_1;
hudakz 3:5b17e4656dd0 1798 uip_connr->nrtx = 0;
hudakz 3:5b17e4656dd0 1799 BUF->flags = TCP_FIN | TCP_ACK;
hudakz 3:5b17e4656dd0 1800 goto tcp_send_nodata;
hudakz 3:5b17e4656dd0 1801 }
hudakz 3:5b17e4656dd0 1802
hudakz 3:5b17e4656dd0 1803 /* If uip_slen > 0, the application has data to be sent. */
hudakz 3:5b17e4656dd0 1804 if(uip_slen > 0) {
hudakz 3:5b17e4656dd0 1805
hudakz 3:5b17e4656dd0 1806 /* If the connection has acknowledged data, the contents of
hudakz 3:5b17e4656dd0 1807 the ->len variable should be discarded. */
hudakz 3:5b17e4656dd0 1808 if((uip_flags & UIP_ACKDATA) != 0) {
hudakz 3:5b17e4656dd0 1809 uip_connr->len = 0;
hudakz 3:5b17e4656dd0 1810 }
hudakz 3:5b17e4656dd0 1811
hudakz 3:5b17e4656dd0 1812 /* If the ->len variable is non-zero the connection has
hudakz 3:5b17e4656dd0 1813 already data in transit and cannot send anymore right
hudakz 3:5b17e4656dd0 1814 now. */
hudakz 3:5b17e4656dd0 1815 if(uip_connr->len == 0) {
hudakz 3:5b17e4656dd0 1816
hudakz 3:5b17e4656dd0 1817 /* The application cannot send more than what is allowed by
hudakz 3:5b17e4656dd0 1818 the mss (the minumum of the MSS and the available
hudakz 3:5b17e4656dd0 1819 window). */
hudakz 3:5b17e4656dd0 1820 if(uip_slen > uip_connr->mss) {
hudakz 3:5b17e4656dd0 1821 uip_slen = uip_connr->mss;
hudakz 3:5b17e4656dd0 1822 }
hudakz 3:5b17e4656dd0 1823
hudakz 3:5b17e4656dd0 1824 /* Remember how much data we send out now so that we know
hudakz 3:5b17e4656dd0 1825 when everything has been acknowledged. */
hudakz 3:5b17e4656dd0 1826 uip_connr->len = uip_slen;
hudakz 3:5b17e4656dd0 1827 }
hudakz 3:5b17e4656dd0 1828 else {
hudakz 3:5b17e4656dd0 1829
hudakz 3:5b17e4656dd0 1830 /* If the application already had unacknowledged data, we
hudakz 3:5b17e4656dd0 1831 make sure that the application does not send (i.e.,
hudakz 3:5b17e4656dd0 1832 retransmit) out more than it previously sent out. */
hudakz 3:5b17e4656dd0 1833 uip_slen = uip_connr->len;
hudakz 3:5b17e4656dd0 1834 }
hudakz 3:5b17e4656dd0 1835 }
hudakz 3:5b17e4656dd0 1836
hudakz 3:5b17e4656dd0 1837 uip_connr->nrtx = 0;
hudakz 3:5b17e4656dd0 1838 apprexmit:
hudakz 3:5b17e4656dd0 1839 uip_appdata = uip_sappdata;
hudakz 3:5b17e4656dd0 1840
hudakz 3:5b17e4656dd0 1841 /* If the application has data to be sent, or if the incoming
hudakz 3:5b17e4656dd0 1842 packet had new data in it, we must send out a packet. */
hudakz 3:5b17e4656dd0 1843 if(uip_slen > 0 && uip_connr->len > 0) {
hudakz 3:5b17e4656dd0 1844
hudakz 3:5b17e4656dd0 1845 /* Add the length of the IP and TCP headers. */
hudakz 3:5b17e4656dd0 1846 uip_len = uip_connr->len + UIP_TCPIP_HLEN;
hudakz 3:5b17e4656dd0 1847
hudakz 3:5b17e4656dd0 1848 /* We always set the ACK flag in response packets. */
hudakz 3:5b17e4656dd0 1849 BUF->flags = TCP_ACK | TCP_PSH;
hudakz 3:5b17e4656dd0 1850
hudakz 3:5b17e4656dd0 1851 /* Send the packet. */
hudakz 3:5b17e4656dd0 1852 goto tcp_send_noopts;
hudakz 3:5b17e4656dd0 1853 }
hudakz 3:5b17e4656dd0 1854
hudakz 3:5b17e4656dd0 1855 /* If there is no data to send, just send out a pure ACK if
hudakz 3:5b17e4656dd0 1856 there is newdata. */
hudakz 3:5b17e4656dd0 1857 if(uip_flags & UIP_NEWDATA) {
hudakz 3:5b17e4656dd0 1858 uip_len = UIP_TCPIP_HLEN;
hudakz 3:5b17e4656dd0 1859 BUF->flags = TCP_ACK;
hudakz 3:5b17e4656dd0 1860 goto tcp_send_noopts;
hudakz 3:5b17e4656dd0 1861 }
hudakz 3:5b17e4656dd0 1862 }
hudakz 3:5b17e4656dd0 1863
hudakz 3:5b17e4656dd0 1864 goto drop;
hudakz 3:5b17e4656dd0 1865
hudakz 3:5b17e4656dd0 1866 case UIP_LAST_ACK:
hudakz 3:5b17e4656dd0 1867 /* We can close this connection if the peer has acknowledged our
hudakz 3:5b17e4656dd0 1868 FIN. This is indicated by the UIP_ACKDATA flag. */
hudakz 3:5b17e4656dd0 1869 if(uip_flags & UIP_ACKDATA) {
hudakz 3:5b17e4656dd0 1870 uip_connr->tcpstateflags = UIP_CLOSED;
hudakz 3:5b17e4656dd0 1871 uip_flags = UIP_CLOSE;
hudakz 3:5b17e4656dd0 1872 UIP_APPCALL();
hudakz 3:5b17e4656dd0 1873 }
hudakz 3:5b17e4656dd0 1874 break;
hudakz 3:5b17e4656dd0 1875
hudakz 3:5b17e4656dd0 1876 case UIP_FIN_WAIT_1:
hudakz 3:5b17e4656dd0 1877 /* The application has closed the connection, but the remote host
hudakz 3:5b17e4656dd0 1878 hasn't closed its end yet. Thus we do nothing but wait for a
hudakz 3:5b17e4656dd0 1879 FIN from the other side. */
hudakz 3:5b17e4656dd0 1880 if(uip_len > 0) {
hudakz 3:5b17e4656dd0 1881 uip_add_rcv_nxt(uip_len);
hudakz 3:5b17e4656dd0 1882 }
hudakz 3:5b17e4656dd0 1883
hudakz 3:5b17e4656dd0 1884 if(BUF->flags & TCP_FIN) {
hudakz 3:5b17e4656dd0 1885 if(uip_flags & UIP_ACKDATA) {
hudakz 3:5b17e4656dd0 1886 uip_connr->tcpstateflags = UIP_TIME_WAIT;
hudakz 3:5b17e4656dd0 1887 uip_connr->timer = 0;
hudakz 3:5b17e4656dd0 1888 uip_connr->len = 0;
hudakz 3:5b17e4656dd0 1889 }
hudakz 3:5b17e4656dd0 1890 else {
hudakz 3:5b17e4656dd0 1891 uip_connr->tcpstateflags = UIP_CLOSING;
hudakz 3:5b17e4656dd0 1892 }
hudakz 3:5b17e4656dd0 1893
hudakz 3:5b17e4656dd0 1894 uip_add_rcv_nxt(1);
hudakz 3:5b17e4656dd0 1895 uip_flags = UIP_CLOSE;
hudakz 3:5b17e4656dd0 1896 UIP_APPCALL();
hudakz 3:5b17e4656dd0 1897 goto tcp_send_ack;
hudakz 3:5b17e4656dd0 1898 }
hudakz 3:5b17e4656dd0 1899 else
hudakz 3:5b17e4656dd0 1900 if(uip_flags & UIP_ACKDATA) {
hudakz 3:5b17e4656dd0 1901 uip_connr->tcpstateflags = UIP_FIN_WAIT_2;
hudakz 3:5b17e4656dd0 1902 uip_connr->len = 0;
hudakz 3:5b17e4656dd0 1903 goto drop;
hudakz 3:5b17e4656dd0 1904 }
hudakz 3:5b17e4656dd0 1905
hudakz 3:5b17e4656dd0 1906 if(uip_len > 0) {
hudakz 3:5b17e4656dd0 1907 goto tcp_send_ack;
hudakz 3:5b17e4656dd0 1908 }
hudakz 3:5b17e4656dd0 1909
hudakz 3:5b17e4656dd0 1910 goto drop;
hudakz 3:5b17e4656dd0 1911
hudakz 3:5b17e4656dd0 1912 case UIP_FIN_WAIT_2:
hudakz 3:5b17e4656dd0 1913 if(uip_len > 0) {
hudakz 3:5b17e4656dd0 1914 uip_add_rcv_nxt(uip_len);
hudakz 3:5b17e4656dd0 1915 }
hudakz 3:5b17e4656dd0 1916
hudakz 3:5b17e4656dd0 1917 if(BUF->flags & TCP_FIN) {
hudakz 3:5b17e4656dd0 1918 uip_connr->tcpstateflags = UIP_TIME_WAIT;
hudakz 3:5b17e4656dd0 1919 uip_connr->timer = 0;
hudakz 3:5b17e4656dd0 1920 uip_add_rcv_nxt(1);
hudakz 3:5b17e4656dd0 1921 uip_flags = UIP_CLOSE;
hudakz 3:5b17e4656dd0 1922 UIP_APPCALL();
hudakz 3:5b17e4656dd0 1923 goto tcp_send_ack;
hudakz 3:5b17e4656dd0 1924 }
hudakz 3:5b17e4656dd0 1925
hudakz 3:5b17e4656dd0 1926 if(uip_len > 0) {
hudakz 3:5b17e4656dd0 1927 goto tcp_send_ack;
hudakz 3:5b17e4656dd0 1928 }
hudakz 3:5b17e4656dd0 1929
hudakz 3:5b17e4656dd0 1930 goto drop;
hudakz 3:5b17e4656dd0 1931
hudakz 3:5b17e4656dd0 1932 case UIP_TIME_WAIT:
hudakz 3:5b17e4656dd0 1933 goto tcp_send_ack;
hudakz 3:5b17e4656dd0 1934
hudakz 3:5b17e4656dd0 1935 case UIP_CLOSING:
hudakz 3:5b17e4656dd0 1936 if(uip_flags & UIP_ACKDATA) {
hudakz 3:5b17e4656dd0 1937 uip_connr->tcpstateflags = UIP_TIME_WAIT;
hudakz 3:5b17e4656dd0 1938 uip_connr->timer = 0;
hudakz 3:5b17e4656dd0 1939 }
hudakz 3:5b17e4656dd0 1940 }
hudakz 3:5b17e4656dd0 1941
hudakz 3:5b17e4656dd0 1942 goto drop;
hudakz 3:5b17e4656dd0 1943
hudakz 3:5b17e4656dd0 1944 /* We jump here when we are ready to send the packet, and just want
hudakz 3:5b17e4656dd0 1945 to set the appropriate TCP sequence numbers in the TCP header. */
hudakz 3:5b17e4656dd0 1946 tcp_send_ack:
hudakz 3:5b17e4656dd0 1947 BUF->flags = TCP_ACK;
hudakz 3:5b17e4656dd0 1948 tcp_send_nodata:
hudakz 3:5b17e4656dd0 1949 uip_len = UIP_IPTCPH_LEN;
hudakz 3:5b17e4656dd0 1950 tcp_send_noopts:
hudakz 3:5b17e4656dd0 1951 BUF->tcpoffset = (UIP_TCPH_LEN / 4) << 4;
hudakz 3:5b17e4656dd0 1952 tcp_send:
hudakz 3:5b17e4656dd0 1953 /* We're done with the input processing. We are now ready to send a
hudakz 3:5b17e4656dd0 1954 reply. Our job is to fill in all the fields of the TCP and IP
hudakz 3:5b17e4656dd0 1955 headers before calculating the checksum and finally send the
hudakz 3:5b17e4656dd0 1956 packet. */
hudakz 3:5b17e4656dd0 1957 BUF->ackno[0] = uip_connr->rcv_nxt[0];
hudakz 3:5b17e4656dd0 1958 BUF->ackno[1] = uip_connr->rcv_nxt[1];
hudakz 3:5b17e4656dd0 1959 BUF->ackno[2] = uip_connr->rcv_nxt[2];
hudakz 3:5b17e4656dd0 1960 BUF->ackno[3] = uip_connr->rcv_nxt[3];
hudakz 3:5b17e4656dd0 1961
hudakz 3:5b17e4656dd0 1962 BUF->seqno[0] = uip_connr->snd_nxt[0];
hudakz 3:5b17e4656dd0 1963 BUF->seqno[1] = uip_connr->snd_nxt[1];
hudakz 3:5b17e4656dd0 1964 BUF->seqno[2] = uip_connr->snd_nxt[2];
hudakz 3:5b17e4656dd0 1965 BUF->seqno[3] = uip_connr->snd_nxt[3];
hudakz 3:5b17e4656dd0 1966
hudakz 3:5b17e4656dd0 1967 BUF->proto = UIP_PROTO_TCP;
hudakz 3:5b17e4656dd0 1968
hudakz 3:5b17e4656dd0 1969 BUF->srcport = uip_connr->lport;
hudakz 3:5b17e4656dd0 1970 BUF->destport = uip_connr->rport;
hudakz 3:5b17e4656dd0 1971
hudakz 3:5b17e4656dd0 1972 uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
hudakz 3:5b17e4656dd0 1973 uip_ipaddr_copy(BUF->destipaddr, uip_connr->ripaddr);
hudakz 3:5b17e4656dd0 1974
hudakz 3:5b17e4656dd0 1975 if(uip_connr->tcpstateflags & UIP_STOPPED) {
hudakz 3:5b17e4656dd0 1976
hudakz 3:5b17e4656dd0 1977 /* If the connection has issued uip_stop(), we advertise a zero
hudakz 3:5b17e4656dd0 1978 window so that the remote host will stop sending data. */
hudakz 3:5b17e4656dd0 1979 BUF->wnd[0] = BUF->wnd[1] = 0;
hudakz 3:5b17e4656dd0 1980 }
hudakz 3:5b17e4656dd0 1981 else {
hudakz 3:5b17e4656dd0 1982 BUF->wnd[0] = ((UIP_RECEIVE_WINDOW) >> 8);
hudakz 3:5b17e4656dd0 1983 BUF->wnd[1] = ((UIP_RECEIVE_WINDOW) & 0xff);
hudakz 3:5b17e4656dd0 1984 }
hudakz 3:5b17e4656dd0 1985
hudakz 3:5b17e4656dd0 1986 tcp_send_noconn:
hudakz 3:5b17e4656dd0 1987 BUF->ttl = UIP_TTL;
hudakz 3:5b17e4656dd0 1988 #if UIP_CONF_IPV6
hudakz 3:5b17e4656dd0 1989 /* For IPv6, the IP length field does not include the IPv6 IP header
hudakz 3:5b17e4656dd0 1990 length. */
hudakz 3:5b17e4656dd0 1991
hudakz 3:5b17e4656dd0 1992 BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);
hudakz 3:5b17e4656dd0 1993 BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);
hudakz 3:5b17e4656dd0 1994 #else /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 1995 BUF->len[0] = (uip_len >> 8);
hudakz 3:5b17e4656dd0 1996 BUF->len[1] = (uip_len & 0xff);
hudakz 3:5b17e4656dd0 1997 #endif /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 1998
hudakz 3:5b17e4656dd0 1999 BUF->urgp[0] = BUF->urgp[1] = 0;
hudakz 3:5b17e4656dd0 2000
hudakz 3:5b17e4656dd0 2001 /* Calculate TCP checksum. */
hudakz 3:5b17e4656dd0 2002 BUF->tcpchksum = 0;
hudakz 3:5b17e4656dd0 2003 BUF->tcpchksum = ~(uip_tcpchksum());
hudakz 3:5b17e4656dd0 2004
hudakz 3:5b17e4656dd0 2005 ip_send_nolen:
hudakz 3:5b17e4656dd0 2006 #if UIP_CONF_IPV6
hudakz 3:5b17e4656dd0 2007 BUF->vtc = 0x60;
hudakz 3:5b17e4656dd0 2008 BUF->tcflow = 0x00;
hudakz 3:5b17e4656dd0 2009 BUF->flow = 0x00;
hudakz 3:5b17e4656dd0 2010 #else /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 2011 BUF->vhl = 0x45;
hudakz 3:5b17e4656dd0 2012 BUF->tos = 0;
hudakz 3:5b17e4656dd0 2013 BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
hudakz 3:5b17e4656dd0 2014 ++ipid;
hudakz 3:5b17e4656dd0 2015 BUF->ipid[0] = ipid >> 8;
hudakz 3:5b17e4656dd0 2016 BUF->ipid[1] = ipid & 0xff;
hudakz 3:5b17e4656dd0 2017
hudakz 3:5b17e4656dd0 2018 /* Calculate IP checksum. */
hudakz 3:5b17e4656dd0 2019 BUF->ipchksum = 0;
hudakz 3:5b17e4656dd0 2020 BUF->ipchksum = ~(uip_ipchksum());
hudakz 3:5b17e4656dd0 2021 DEBUG_PRINTF("uip ip_send_nolen: chkecum 0x%04x\n", uip_ipchksum());
hudakz 3:5b17e4656dd0 2022 #endif /* UIP_CONF_IPV6 */
hudakz 3:5b17e4656dd0 2023
hudakz 3:5b17e4656dd0 2024 UIP_STAT(++uip_stat.tcp.sent);
hudakz 3:5b17e4656dd0 2025 send:
hudakz 3:5b17e4656dd0 2026 DEBUG_PRINTF("Sending packet with length %d (%d)\n", uip_len, (BUF->len[0] << 8) | BUF->len[1]);
hudakz 3:5b17e4656dd0 2027
hudakz 3:5b17e4656dd0 2028 UIP_STAT(++uip_stat.ip.sent);
hudakz 3:5b17e4656dd0 2029
hudakz 3:5b17e4656dd0 2030 /* Return and let the caller do the actual transmission. */
hudakz 3:5b17e4656dd0 2031 uip_flags = 0;
hudakz 3:5b17e4656dd0 2032 return;
hudakz 3:5b17e4656dd0 2033 drop:
hudakz 3:5b17e4656dd0 2034 uip_len = 0;
hudakz 3:5b17e4656dd0 2035 uip_flags = 0;
hudakz 3:5b17e4656dd0 2036 return;
hudakz 3:5b17e4656dd0 2037 }
hudakz 3:5b17e4656dd0 2038
hudakz 3:5b17e4656dd0 2039 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 2040 u16_t htons(u16_t val) {
hudakz 3:5b17e4656dd0 2041 return HTONS(val);
hudakz 3:5b17e4656dd0 2042 }
hudakz 3:5b17e4656dd0 2043
hudakz 3:5b17e4656dd0 2044 /*---------------------------------------------------------------------------*/
hudakz 3:5b17e4656dd0 2045 void uip_send(const void* data, int len) {
hudakz 3:5b17e4656dd0 2046 uip_slen = len;
hudakz 3:5b17e4656dd0 2047 if(len > 0) {
hudakz 3:5b17e4656dd0 2048 if(data != uip_sappdata) {
hudakz 3:5b17e4656dd0 2049 memcpy(uip_sappdata, (data), uip_slen);
hudakz 3:5b17e4656dd0 2050 }
hudakz 3:5b17e4656dd0 2051 }
hudakz 3:5b17e4656dd0 2052 }
hudakz 3:5b17e4656dd0 2053
hudakz 3:5b17e4656dd0 2054 /** @} */