cassyarduino cassyarduino / UIPEthernet

UIPEthernet library for Arduino IDE, Eclipse with arduino plugin and MBED/SMeshStudio (AVR,STM32F,ESP8266,Intel ARC32,Nordic nRF51,Teensy boards,Realtek Ameba(RTL8195A,RTL8710)), ENC28j60 network chip. Compatible with Wiznet W5100 Ethernet library API. Compiled and tested on Nucleo-F302R8. Master repository is: https://github.com/UIPEthernet/UIPEthernet/

utility/uip.h@39:deeb00b81cc9, 2018-01-23 (annotated)

Committer:
cassyarduino
Date:
Tue Jan 23 15:08:43 2018 +0100
Revision:
39:deeb00b81cc9
Parent:
35:f9f3a91fe4d4 
Release: 2.0.4

Who changed what in which revision?

UserRevisionLine numberNew contents of line
cassyarduino 0:e3fb1267e3c3 1
cassyarduino 0:e3fb1267e3c3 2 /**
cassyarduino 0:e3fb1267e3c3 3 * \addtogroup uip
cassyarduino 0:e3fb1267e3c3 4 * @{
cassyarduino 0:e3fb1267e3c3 5 */
cassyarduino 0:e3fb1267e3c3 6
cassyarduino 0:e3fb1267e3c3 7 /**
cassyarduino 0:e3fb1267e3c3 8 * \file
cassyarduino 0:e3fb1267e3c3 9 * Header file for the uIP TCP/IP stack.
cassyarduino 0:e3fb1267e3c3 10 * \author Adam Dunkels <adam@dunkels.com>
cassyarduino 0:e3fb1267e3c3 11 *
cassyarduino 0:e3fb1267e3c3 12 * The uIP TCP/IP stack header file contains definitions for a number
cassyarduino 0:e3fb1267e3c3 13 * of C macros that are used by uIP programs as well as internal uIP
cassyarduino 0:e3fb1267e3c3 14 * structures, TCP/IP header structures and function declarations.
cassyarduino 0:e3fb1267e3c3 15 *
cassyarduino 0:e3fb1267e3c3 16 */
cassyarduino 0:e3fb1267e3c3 17
cassyarduino 0:e3fb1267e3c3 18
cassyarduino 0:e3fb1267e3c3 19 /*
cassyarduino 0:e3fb1267e3c3 20 * Copyright (c) 2001-2003, Adam Dunkels.
cassyarduino 0:e3fb1267e3c3 21 * All rights reserved.
cassyarduino 0:e3fb1267e3c3 22 *
cassyarduino 0:e3fb1267e3c3 23 * Redistribution and use in source and binary forms, with or without
cassyarduino 0:e3fb1267e3c3 24 * modification, are permitted provided that the following conditions
cassyarduino 0:e3fb1267e3c3 25 * are met:
cassyarduino 0:e3fb1267e3c3 26 * 1. Redistributions of source code must retain the above copyright
cassyarduino 0:e3fb1267e3c3 27 * notice, this list of conditions and the following disclaimer.
cassyarduino 0:e3fb1267e3c3 28 * 2. Redistributions in binary form must reproduce the above copyright
cassyarduino 0:e3fb1267e3c3 29 * notice, this list of conditions and the following disclaimer in the
cassyarduino 0:e3fb1267e3c3 30 * documentation and/or other materials provided with the distribution.
cassyarduino 0:e3fb1267e3c3 31 * 3. The name of the author may not be used to endorse or promote
cassyarduino 0:e3fb1267e3c3 32 * products derived from this software without specific prior
cassyarduino 0:e3fb1267e3c3 33 * written permission.
cassyarduino 0:e3fb1267e3c3 34 *
cassyarduino 0:e3fb1267e3c3 35 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
cassyarduino 0:e3fb1267e3c3 36 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
cassyarduino 0:e3fb1267e3c3 37 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
cassyarduino 0:e3fb1267e3c3 38 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
cassyarduino 0:e3fb1267e3c3 39 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
cassyarduino 0:e3fb1267e3c3 40 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
cassyarduino 0:e3fb1267e3c3 41 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
cassyarduino 0:e3fb1267e3c3 42 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
cassyarduino 0:e3fb1267e3c3 43 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
cassyarduino 0:e3fb1267e3c3 44 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
cassyarduino 0:e3fb1267e3c3 45 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
cassyarduino 0:e3fb1267e3c3 46 *
cassyarduino 0:e3fb1267e3c3 47 * This file is part of the uIP TCP/IP stack.
cassyarduino 0:e3fb1267e3c3 48 *
cassyarduino 0:e3fb1267e3c3 49 * $Id: uip.h,v 1.40 2006/06/08 07:12:07 adam Exp $
cassyarduino 0:e3fb1267e3c3 50 *
cassyarduino 0:e3fb1267e3c3 51 */
cassyarduino 0:e3fb1267e3c3 52
cassyarduino 0:e3fb1267e3c3 53 #ifndef __UIP_H__
cassyarduino 0:e3fb1267e3c3 54 #define __UIP_H__
cassyarduino 0:e3fb1267e3c3 55
cassyarduino 0:e3fb1267e3c3 56 #include "uipopt.h"
cassyarduino 0:e3fb1267e3c3 57
cassyarduino 0:e3fb1267e3c3 58 /**
cassyarduino 0:e3fb1267e3c3 59 * Repressentation of an IP address.
cassyarduino 0:e3fb1267e3c3 60 *
cassyarduino 0:e3fb1267e3c3 61 */
cassyarduino 0:e3fb1267e3c3 62 typedef u16_t uip_ip4addr_t[2];
cassyarduino 0:e3fb1267e3c3 63 typedef u16_t uip_ip6addr_t[8];
cassyarduino 0:e3fb1267e3c3 64 #if UIP_CONF_IPV6
cassyarduino 0:e3fb1267e3c3 65 typedef uip_ip6addr_t uip_ipaddr_t;
cassyarduino 0:e3fb1267e3c3 66 #else /* UIP_CONF_IPV6 */
cassyarduino 0:e3fb1267e3c3 67 typedef uip_ip4addr_t uip_ipaddr_t;
cassyarduino 0:e3fb1267e3c3 68 #endif /* UIP_CONF_IPV6 */
cassyarduino 0:e3fb1267e3c3 69
cassyarduino 0:e3fb1267e3c3 70 /*---------------------------------------------------------------------------*/
cassyarduino 0:e3fb1267e3c3 71 /* First, the functions that should be called from the
cassyarduino 0:e3fb1267e3c3 72 * system. Initialization, the periodic timer and incoming packets are
cassyarduino 0:e3fb1267e3c3 73 * handled by the following three functions.
cassyarduino 0:e3fb1267e3c3 74 */
cassyarduino 0:e3fb1267e3c3 75
cassyarduino 0:e3fb1267e3c3 76 /**
cassyarduino 0:e3fb1267e3c3 77 * \defgroup uipconffunc uIP configuration functions
cassyarduino 0:e3fb1267e3c3 78 * @{
cassyarduino 0:e3fb1267e3c3 79 *
cassyarduino 0:e3fb1267e3c3 80 * The uIP configuration functions are used for setting run-time
cassyarduino 0:e3fb1267e3c3 81 * parameters in uIP such as IP addresses.
cassyarduino 0:e3fb1267e3c3 82 */
cassyarduino 0:e3fb1267e3c3 83
cassyarduino 0:e3fb1267e3c3 84 /**
cassyarduino 0:e3fb1267e3c3 85 * Set the IP address of this host.
cassyarduino 0:e3fb1267e3c3 86 *
cassyarduino 0:e3fb1267e3c3 87 * The IP address is represented as a 4-byte array where the first
cassyarduino 0:e3fb1267e3c3 88 * octet of the IP address is put in the first member of the 4-byte
cassyarduino 0:e3fb1267e3c3 89 * array.
cassyarduino 0:e3fb1267e3c3 90 *
cassyarduino 0:e3fb1267e3c3 91 * Example:
cassyarduino 0:e3fb1267e3c3 92 \code
cassyarduino 0:e3fb1267e3c3 93
cassyarduino 0:e3fb1267e3c3 94 uip_ipaddr_t addr;
cassyarduino 0:e3fb1267e3c3 95
cassyarduino 0:e3fb1267e3c3 96 uip_ipaddr(&addr, 192,168,1,2);
cassyarduino 0:e3fb1267e3c3 97 uip_sethostaddr(&addr);
cassyarduino 0:e3fb1267e3c3 98
cassyarduino 0:e3fb1267e3c3 99 \endcode
cassyarduino 0:e3fb1267e3c3 100 * \param addr A pointer to an IP address of type uip_ipaddr_t;
cassyarduino 0:e3fb1267e3c3 101 *
cassyarduino 0:e3fb1267e3c3 102 * \sa uip_ipaddr()
cassyarduino 0:e3fb1267e3c3 103 *
cassyarduino 0:e3fb1267e3c3 104 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 105 */
cassyarduino 0:e3fb1267e3c3 106 #define uip_sethostaddr(addr) uip_ipaddr_copy(uip_hostaddr, (addr))
cassyarduino 0:e3fb1267e3c3 107
cassyarduino 0:e3fb1267e3c3 108 /**
cassyarduino 0:e3fb1267e3c3 109 * Get the IP address of this host.
cassyarduino 0:e3fb1267e3c3 110 *
cassyarduino 0:e3fb1267e3c3 111 * The IP address is represented as a 4-byte array where the first
cassyarduino 0:e3fb1267e3c3 112 * octet of the IP address is put in the first member of the 4-byte
cassyarduino 0:e3fb1267e3c3 113 * array.
cassyarduino 0:e3fb1267e3c3 114 *
cassyarduino 0:e3fb1267e3c3 115 * Example:
cassyarduino 0:e3fb1267e3c3 116 \code
cassyarduino 0:e3fb1267e3c3 117 uip_ipaddr_t hostaddr;
cassyarduino 0:e3fb1267e3c3 118
cassyarduino 0:e3fb1267e3c3 119 uip_gethostaddr(&hostaddr);
cassyarduino 0:e3fb1267e3c3 120 \endcode
cassyarduino 0:e3fb1267e3c3 121 * \param addr A pointer to a uip_ipaddr_t variable that will be
cassyarduino 0:e3fb1267e3c3 122 * filled in with the currently configured IP address.
cassyarduino 0:e3fb1267e3c3 123 *
cassyarduino 0:e3fb1267e3c3 124 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 125 */
cassyarduino 0:e3fb1267e3c3 126 #define uip_gethostaddr(addr) uip_ipaddr_copy((addr), uip_hostaddr)
cassyarduino 0:e3fb1267e3c3 127
cassyarduino 0:e3fb1267e3c3 128 /**
cassyarduino 0:e3fb1267e3c3 129 * Set the default router's IP address.
cassyarduino 0:e3fb1267e3c3 130 *
cassyarduino 0:e3fb1267e3c3 131 * \param addr A pointer to a uip_ipaddr_t variable containing the IP
cassyarduino 0:e3fb1267e3c3 132 * address of the default router.
cassyarduino 0:e3fb1267e3c3 133 *
cassyarduino 0:e3fb1267e3c3 134 * \sa uip_ipaddr()
cassyarduino 0:e3fb1267e3c3 135 *
cassyarduino 0:e3fb1267e3c3 136 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 137 */
cassyarduino 0:e3fb1267e3c3 138 #define uip_setdraddr(addr) uip_ipaddr_copy(uip_draddr, (addr))
cassyarduino 0:e3fb1267e3c3 139
cassyarduino 0:e3fb1267e3c3 140 /**
cassyarduino 0:e3fb1267e3c3 141 * Set the netmask.
cassyarduino 0:e3fb1267e3c3 142 *
cassyarduino 0:e3fb1267e3c3 143 * \param addr A pointer to a uip_ipaddr_t variable containing the IP
cassyarduino 0:e3fb1267e3c3 144 * address of the netmask.
cassyarduino 0:e3fb1267e3c3 145 *
cassyarduino 0:e3fb1267e3c3 146 * \sa uip_ipaddr()
cassyarduino 0:e3fb1267e3c3 147 *
cassyarduino 0:e3fb1267e3c3 148 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 149 */
cassyarduino 0:e3fb1267e3c3 150 #define uip_setnetmask(addr) uip_ipaddr_copy(uip_netmask, (addr))
cassyarduino 0:e3fb1267e3c3 151
cassyarduino 0:e3fb1267e3c3 152
cassyarduino 0:e3fb1267e3c3 153 /**
cassyarduino 0:e3fb1267e3c3 154 * Get the default router's IP address.
cassyarduino 0:e3fb1267e3c3 155 *
cassyarduino 0:e3fb1267e3c3 156 * \param addr A pointer to a uip_ipaddr_t variable that will be
cassyarduino 0:e3fb1267e3c3 157 * filled in with the IP address of the default router.
cassyarduino 0:e3fb1267e3c3 158 *
cassyarduino 0:e3fb1267e3c3 159 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 160 */
cassyarduino 0:e3fb1267e3c3 161 #define uip_getdraddr(addr) uip_ipaddr_copy((addr), uip_draddr)
cassyarduino 0:e3fb1267e3c3 162
cassyarduino 0:e3fb1267e3c3 163 /**
cassyarduino 0:e3fb1267e3c3 164 * Get the netmask.
cassyarduino 0:e3fb1267e3c3 165 *
cassyarduino 0:e3fb1267e3c3 166 * \param addr A pointer to a uip_ipaddr_t variable that will be
cassyarduino 0:e3fb1267e3c3 167 * filled in with the value of the netmask.
cassyarduino 0:e3fb1267e3c3 168 *
cassyarduino 0:e3fb1267e3c3 169 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 170 */
cassyarduino 0:e3fb1267e3c3 171 #define uip_getnetmask(addr) uip_ipaddr_copy((addr), uip_netmask)
cassyarduino 0:e3fb1267e3c3 172
cassyarduino 0:e3fb1267e3c3 173 /** @} */
cassyarduino 0:e3fb1267e3c3 174
cassyarduino 0:e3fb1267e3c3 175 /**
cassyarduino 0:e3fb1267e3c3 176 * \defgroup uipinit uIP initialization functions
cassyarduino 0:e3fb1267e3c3 177 * @{
cassyarduino 0:e3fb1267e3c3 178 *
cassyarduino 0:e3fb1267e3c3 179 * The uIP initialization functions are used for booting uIP.
cassyarduino 0:e3fb1267e3c3 180 */
cassyarduino 0:e3fb1267e3c3 181
cassyarduino 0:e3fb1267e3c3 182 /**
cassyarduino 0:e3fb1267e3c3 183 * uIP initialization function.
cassyarduino 0:e3fb1267e3c3 184 *
cassyarduino 0:e3fb1267e3c3 185 * This function should be called at boot up to initilize the uIP
cassyarduino 0:e3fb1267e3c3 186 * TCP/IP stack.
cassyarduino 0:e3fb1267e3c3 187 */
cassyarduino 0:e3fb1267e3c3 188 void uip_init(void);
cassyarduino 0:e3fb1267e3c3 189
cassyarduino 0:e3fb1267e3c3 190 /**
cassyarduino 0:e3fb1267e3c3 191 * uIP initialization function.
cassyarduino 0:e3fb1267e3c3 192 *
cassyarduino 0:e3fb1267e3c3 193 * This function may be used at boot time to set the initial ip_id.
cassyarduino 0:e3fb1267e3c3 194 */
cassyarduino 0:e3fb1267e3c3 195 void uip_setipid(u16_t id);
cassyarduino 0:e3fb1267e3c3 196
cassyarduino 0:e3fb1267e3c3 197 /** @} */
cassyarduino 0:e3fb1267e3c3 198
cassyarduino 0:e3fb1267e3c3 199 /**
cassyarduino 0:e3fb1267e3c3 200 * \defgroup uipdevfunc uIP device driver functions
cassyarduino 0:e3fb1267e3c3 201 * @{
cassyarduino 0:e3fb1267e3c3 202 *
cassyarduino 0:e3fb1267e3c3 203 * These functions are used by a network device driver for interacting
cassyarduino 0:e3fb1267e3c3 204 * with uIP.
cassyarduino 0:e3fb1267e3c3 205 */
cassyarduino 0:e3fb1267e3c3 206
cassyarduino 0:e3fb1267e3c3 207 /**
cassyarduino 0:e3fb1267e3c3 208 * Process an incoming packet.
cassyarduino 0:e3fb1267e3c3 209 *
cassyarduino 0:e3fb1267e3c3 210 * This function should be called when the device driver has received
cassyarduino 0:e3fb1267e3c3 211 * a packet from the network. The packet from the device driver must
cassyarduino 0:e3fb1267e3c3 212 * be present in the uip_buf buffer, and the length of the packet
cassyarduino 0:e3fb1267e3c3 213 * should be placed in the uip_len variable.
cassyarduino 0:e3fb1267e3c3 214 *
cassyarduino 0:e3fb1267e3c3 215 * When the function returns, there may be an outbound packet placed
cassyarduino 0:e3fb1267e3c3 216 * in the uip_buf packet buffer. If so, the uip_len variable is set to
cassyarduino 0:e3fb1267e3c3 217 * the length of the packet. If no packet is to be sent out, the
cassyarduino 0:e3fb1267e3c3 218 * uip_len variable is set to 0.
cassyarduino 0:e3fb1267e3c3 219 *
cassyarduino 0:e3fb1267e3c3 220 * The usual way of calling the function is presented by the source
cassyarduino 0:e3fb1267e3c3 221 * code below.
cassyarduino 0:e3fb1267e3c3 222 \code
cassyarduino 0:e3fb1267e3c3 223 uip_len = devicedriver_poll();
cassyarduino 0:e3fb1267e3c3 224 if(uip_len > 0) {
cassyarduino 0:e3fb1267e3c3 225 uip_input();
cassyarduino 0:e3fb1267e3c3 226 if(uip_len > 0) {
cassyarduino 0:e3fb1267e3c3 227 devicedriver_send();
cassyarduino 0:e3fb1267e3c3 228 }
cassyarduino 0:e3fb1267e3c3 229 }
cassyarduino 0:e3fb1267e3c3 230 \endcode
cassyarduino 0:e3fb1267e3c3 231 *
cassyarduino 0:e3fb1267e3c3 232 * \note If you are writing a uIP device driver that needs ARP
cassyarduino 0:e3fb1267e3c3 233 * (Address Resolution Protocol), e.g., when running uIP over
cassyarduino 0:e3fb1267e3c3 234 * Ethernet, you will need to call the uIP ARP code before calling
cassyarduino 0:e3fb1267e3c3 235 * this function:
cassyarduino 0:e3fb1267e3c3 236 \code
cassyarduino 0:e3fb1267e3c3 237 #define BUF ((struct uip_eth_hdr *)&uip_buf[0])
cassyarduino 0:e3fb1267e3c3 238 uip_len = ethernet_devicedrver_poll();
cassyarduino 0:e3fb1267e3c3 239 if(uip_len > 0) {
cassyarduino 0:e3fb1267e3c3 240 if(BUF->type == HTONS(UIP_ETHTYPE_IP)) {
cassyarduino 0:e3fb1267e3c3 241 uip_arp_ipin();
cassyarduino 0:e3fb1267e3c3 242 uip_input();
cassyarduino 0:e3fb1267e3c3 243 if(uip_len > 0) {
cassyarduino 0:e3fb1267e3c3 244 uip_arp_out();
cassyarduino 0:e3fb1267e3c3 245 ethernet_devicedriver_send();
cassyarduino 0:e3fb1267e3c3 246 }
cassyarduino 0:e3fb1267e3c3 247 } else if(BUF->type == HTONS(UIP_ETHTYPE_ARP)) {
cassyarduino 0:e3fb1267e3c3 248 uip_arp_arpin();
cassyarduino 0:e3fb1267e3c3 249 if(uip_len > 0) {
cassyarduino 0:e3fb1267e3c3 250 ethernet_devicedriver_send();
cassyarduino 0:e3fb1267e3c3 251 }
cassyarduino 0:e3fb1267e3c3 252 }
cassyarduino 0:e3fb1267e3c3 253 \endcode
cassyarduino 0:e3fb1267e3c3 254 *
cassyarduino 0:e3fb1267e3c3 255 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 256 */
cassyarduino 0:e3fb1267e3c3 257 #define uip_input() uip_process(UIP_DATA)
cassyarduino 0:e3fb1267e3c3 258
cassyarduino 0:e3fb1267e3c3 259 /**
cassyarduino 0:e3fb1267e3c3 260 * Periodic processing for a connection identified by its number.
cassyarduino 0:e3fb1267e3c3 261 *
cassyarduino 0:e3fb1267e3c3 262 * This function does the necessary periodic processing (timers,
cassyarduino 0:e3fb1267e3c3 263 * polling) for a uIP TCP conneciton, and should be called when the
cassyarduino 0:e3fb1267e3c3 264 * periodic uIP timer goes off. It should be called for every
cassyarduino 0:e3fb1267e3c3 265 * connection, regardless of whether they are open of closed.
cassyarduino 0:e3fb1267e3c3 266 *
cassyarduino 0:e3fb1267e3c3 267 * When the function returns, it may have an outbound packet waiting
cassyarduino 0:e3fb1267e3c3 268 * for service in the uIP packet buffer, and if so the uip_len
cassyarduino 0:e3fb1267e3c3 269 * variable is set to a value larger than zero. The device driver
cassyarduino 0:e3fb1267e3c3 270 * should be called to send out the packet.
cassyarduino 0:e3fb1267e3c3 271 *
cassyarduino 0:e3fb1267e3c3 272 * The ususal way of calling the function is through a for() loop like
cassyarduino 0:e3fb1267e3c3 273 * this:
cassyarduino 0:e3fb1267e3c3 274 \code
cassyarduino 0:e3fb1267e3c3 275 for(i = 0; i < UIP_CONNS; ++i) {
cassyarduino 0:e3fb1267e3c3 276 uip_periodic(i);
cassyarduino 0:e3fb1267e3c3 277 if(uip_len > 0) {
cassyarduino 0:e3fb1267e3c3 278 devicedriver_send();
cassyarduino 0:e3fb1267e3c3 279 }
cassyarduino 0:e3fb1267e3c3 280 }
cassyarduino 0:e3fb1267e3c3 281 \endcode
cassyarduino 0:e3fb1267e3c3 282 *
cassyarduino 0:e3fb1267e3c3 283 * \note If you are writing a uIP device driver that needs ARP
cassyarduino 0:e3fb1267e3c3 284 * (Address Resolution Protocol), e.g., when running uIP over
cassyarduino 0:e3fb1267e3c3 285 * Ethernet, you will need to call the uip_arp_out() function before
cassyarduino 0:e3fb1267e3c3 286 * calling the device driver:
cassyarduino 0:e3fb1267e3c3 287 \code
cassyarduino 0:e3fb1267e3c3 288 for(i = 0; i < UIP_CONNS; ++i) {
cassyarduino 0:e3fb1267e3c3 289 uip_periodic(i);
cassyarduino 0:e3fb1267e3c3 290 if(uip_len > 0) {
cassyarduino 0:e3fb1267e3c3 291 uip_arp_out();
cassyarduino 0:e3fb1267e3c3 292 ethernet_devicedriver_send();
cassyarduino 0:e3fb1267e3c3 293 }
cassyarduino 0:e3fb1267e3c3 294 }
cassyarduino 0:e3fb1267e3c3 295 \endcode
cassyarduino 0:e3fb1267e3c3 296 *
cassyarduino 0:e3fb1267e3c3 297 * \param conn The number of the connection which is to be periodically polled.
cassyarduino 0:e3fb1267e3c3 298 *
cassyarduino 0:e3fb1267e3c3 299 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 300 */
cassyarduino 0:e3fb1267e3c3 301 #define uip_periodic(conn) do { uip_conn = &uip_conns[conn]; \
cassyarduino 0:e3fb1267e3c3 302 uip_process(UIP_TIMER); } while (0)
cassyarduino 0:e3fb1267e3c3 303
cassyarduino 0:e3fb1267e3c3 304 /**
cassyarduino 0:e3fb1267e3c3 305 *
cassyarduino 0:e3fb1267e3c3 306 *
cassyarduino 0:e3fb1267e3c3 307 */
cassyarduino 0:e3fb1267e3c3 308 #define uip_conn_active(conn) (uip_conns[conn].tcpstateflags != UIP_CLOSED)
cassyarduino 0:e3fb1267e3c3 309
cassyarduino 0:e3fb1267e3c3 310 /**
cassyarduino 0:e3fb1267e3c3 311 * Perform periodic processing for a connection identified by a pointer
cassyarduino 0:e3fb1267e3c3 312 * to its structure.
cassyarduino 0:e3fb1267e3c3 313 *
cassyarduino 0:e3fb1267e3c3 314 * Same as uip_periodic() but takes a pointer to the actual uip_conn
cassyarduino 0:e3fb1267e3c3 315 * struct instead of an integer as its argument. This function can be
cassyarduino 0:e3fb1267e3c3 316 * used to force periodic processing of a specific connection.
cassyarduino 0:e3fb1267e3c3 317 *
cassyarduino 0:e3fb1267e3c3 318 * \param conn A pointer to the uip_conn struct for the connection to
cassyarduino 0:e3fb1267e3c3 319 * be processed.
cassyarduino 0:e3fb1267e3c3 320 *
cassyarduino 0:e3fb1267e3c3 321 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 322 */
cassyarduino 0:e3fb1267e3c3 323 #define uip_periodic_conn(conn) do { uip_conn = conn; \
cassyarduino 0:e3fb1267e3c3 324 uip_process(UIP_TIMER); } while (0)
cassyarduino 0:e3fb1267e3c3 325
cassyarduino 0:e3fb1267e3c3 326 /**
cassyarduino 0:e3fb1267e3c3 327 * Reuqest that a particular connection should be polled.
cassyarduino 0:e3fb1267e3c3 328 *
cassyarduino 0:e3fb1267e3c3 329 * Similar to uip_periodic_conn() but does not perform any timer
cassyarduino 0:e3fb1267e3c3 330 * processing. The application is polled for new data.
cassyarduino 0:e3fb1267e3c3 331 *
cassyarduino 0:e3fb1267e3c3 332 * \param conn A pointer to the uip_conn struct for the connection to
cassyarduino 0:e3fb1267e3c3 333 * be processed.
cassyarduino 0:e3fb1267e3c3 334 *
cassyarduino 0:e3fb1267e3c3 335 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 336 */
cassyarduino 0:e3fb1267e3c3 337 #define uip_poll_conn(conn) do { uip_conn = conn; \
cassyarduino 0:e3fb1267e3c3 338 uip_process(UIP_POLL_REQUEST); } while (0)
cassyarduino 0:e3fb1267e3c3 339
cassyarduino 0:e3fb1267e3c3 340
cassyarduino 0:e3fb1267e3c3 341 #if UIP_UDP
cassyarduino 0:e3fb1267e3c3 342 /**
cassyarduino 0:e3fb1267e3c3 343 * Periodic processing for a UDP connection identified by its number.
cassyarduino 0:e3fb1267e3c3 344 *
cassyarduino 0:e3fb1267e3c3 345 * This function is essentially the same as uip_periodic(), but for
cassyarduino 0:e3fb1267e3c3 346 * UDP connections. It is called in a similar fashion as the
cassyarduino 0:e3fb1267e3c3 347 * uip_periodic() function:
cassyarduino 0:e3fb1267e3c3 348 \code
cassyarduino 0:e3fb1267e3c3 349 for(i = 0; i < UIP_UDP_CONNS; i++) {
cassyarduino 0:e3fb1267e3c3 350 uip_udp_periodic(i);
cassyarduino 0:e3fb1267e3c3 351 if(uip_len > 0) {
cassyarduino 0:e3fb1267e3c3 352 devicedriver_send();
cassyarduino 0:e3fb1267e3c3 353 }
cassyarduino 0:e3fb1267e3c3 354 }
cassyarduino 0:e3fb1267e3c3 355 \endcode
cassyarduino 0:e3fb1267e3c3 356 *
cassyarduino 0:e3fb1267e3c3 357 * \note As for the uip_periodic() function, special care has to be
cassyarduino 0:e3fb1267e3c3 358 * taken when using uIP together with ARP and Ethernet:
cassyarduino 0:e3fb1267e3c3 359 \code
cassyarduino 0:e3fb1267e3c3 360 for(i = 0; i < UIP_UDP_CONNS; i++) {
cassyarduino 0:e3fb1267e3c3 361 uip_udp_periodic(i);
cassyarduino 0:e3fb1267e3c3 362 if(uip_len > 0) {
cassyarduino 0:e3fb1267e3c3 363 uip_arp_out();
cassyarduino 0:e3fb1267e3c3 364 ethernet_devicedriver_send();
cassyarduino 0:e3fb1267e3c3 365 }
cassyarduino 0:e3fb1267e3c3 366 }
cassyarduino 0:e3fb1267e3c3 367 \endcode
cassyarduino 0:e3fb1267e3c3 368 *
cassyarduino 0:e3fb1267e3c3 369 * \param conn The number of the UDP connection to be processed.
cassyarduino 0:e3fb1267e3c3 370 *
cassyarduino 0:e3fb1267e3c3 371 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 372 */
cassyarduino 0:e3fb1267e3c3 373 #define uip_udp_periodic(conn) do { uip_udp_conn = &uip_udp_conns[conn]; \
cassyarduino 0:e3fb1267e3c3 374 uip_process(UIP_UDP_TIMER); } while (0)
cassyarduino 0:e3fb1267e3c3 375
cassyarduino 0:e3fb1267e3c3 376 /**
cassyarduino 0:e3fb1267e3c3 377 * Periodic processing for a UDP connection identified by a pointer to
cassyarduino 0:e3fb1267e3c3 378 * its structure.
cassyarduino 0:e3fb1267e3c3 379 *
cassyarduino 0:e3fb1267e3c3 380 * Same as uip_udp_periodic() but takes a pointer to the actual
cassyarduino 0:e3fb1267e3c3 381 * uip_conn struct instead of an integer as its argument. This
cassyarduino 0:e3fb1267e3c3 382 * function can be used to force periodic processing of a specific
cassyarduino 0:e3fb1267e3c3 383 * connection.
cassyarduino 0:e3fb1267e3c3 384 *
cassyarduino 0:e3fb1267e3c3 385 * \param conn A pointer to the uip_udp_conn struct for the connection
cassyarduino 0:e3fb1267e3c3 386 * to be processed.
cassyarduino 0:e3fb1267e3c3 387 *
cassyarduino 0:e3fb1267e3c3 388 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 389 */
cassyarduino 0:e3fb1267e3c3 390 #define uip_udp_periodic_conn(conn) do { uip_udp_conn = conn; \
cassyarduino 0:e3fb1267e3c3 391 uip_process(UIP_UDP_TIMER); } while (0)
cassyarduino 0:e3fb1267e3c3 392
cassyarduino 0:e3fb1267e3c3 393
cassyarduino 0:e3fb1267e3c3 394 #endif /* UIP_UDP */
cassyarduino 0:e3fb1267e3c3 395
cassyarduino 0:e3fb1267e3c3 396 /**
cassyarduino 0:e3fb1267e3c3 397 * The uIP packet buffer.
cassyarduino 0:e3fb1267e3c3 398 *
cassyarduino 0:e3fb1267e3c3 399 * The uip_buf array is used to hold incoming and outgoing
cassyarduino 0:e3fb1267e3c3 400 * packets. The device driver should place incoming data into this
cassyarduino 0:e3fb1267e3c3 401 * buffer. When sending data, the device driver should read the link
cassyarduino 0:e3fb1267e3c3 402 * level headers and the TCP/IP headers from this buffer. The size of
cassyarduino 0:e3fb1267e3c3 403 * the link level headers is configured by the UIP_LLH_LEN define.
cassyarduino 0:e3fb1267e3c3 404 *
cassyarduino 0:e3fb1267e3c3 405 * \note The application data need not be placed in this buffer, so
cassyarduino 0:e3fb1267e3c3 406 * the device driver must read it from the place pointed to by the
cassyarduino 0:e3fb1267e3c3 407 * uip_appdata pointer as illustrated by the following example:
cassyarduino 0:e3fb1267e3c3 408 \code
cassyarduino 0:e3fb1267e3c3 409 void
cassyarduino 0:e3fb1267e3c3 410 devicedriver_send(void)
cassyarduino 0:e3fb1267e3c3 411 {
cassyarduino 0:e3fb1267e3c3 412 hwsend(&uip_buf[0], UIP_LLH_LEN);
cassyarduino 0:e3fb1267e3c3 413 if(uip_len <= UIP_LLH_LEN + UIP_TCPIP_HLEN) {
cassyarduino 0:e3fb1267e3c3 414 hwsend(&uip_buf[UIP_LLH_LEN], uip_len - UIP_LLH_LEN);
cassyarduino 0:e3fb1267e3c3 415 } else {
cassyarduino 0:e3fb1267e3c3 416 hwsend(&uip_buf[UIP_LLH_LEN], UIP_TCPIP_HLEN);
cassyarduino 0:e3fb1267e3c3 417 hwsend(uip_appdata, uip_len - UIP_TCPIP_HLEN - UIP_LLH_LEN);
cassyarduino 0:e3fb1267e3c3 418 }
cassyarduino 0:e3fb1267e3c3 419 }
cassyarduino 0:e3fb1267e3c3 420 \endcode
cassyarduino 0:e3fb1267e3c3 421 */
cassyarduino 0:e3fb1267e3c3 422 extern u8_t uip_buf[UIP_BUFSIZE+2];
cassyarduino 0:e3fb1267e3c3 423
cassyarduino 0:e3fb1267e3c3 424 /** @} */
cassyarduino 0:e3fb1267e3c3 425
cassyarduino 0:e3fb1267e3c3 426 /*---------------------------------------------------------------------------*/
cassyarduino 0:e3fb1267e3c3 427 /* Functions that are used by the uIP application program. Opening and
cassyarduino 0:e3fb1267e3c3 428 * closing connections, sending and receiving data, etc. is all
cassyarduino 0:e3fb1267e3c3 429 * handled by the functions below.
cassyarduino 0:e3fb1267e3c3 430 */
cassyarduino 0:e3fb1267e3c3 431 /**
cassyarduino 0:e3fb1267e3c3 432 * \defgroup uipappfunc uIP application functions
cassyarduino 0:e3fb1267e3c3 433 * @{
cassyarduino 0:e3fb1267e3c3 434 *
cassyarduino 0:e3fb1267e3c3 435 * Functions used by an application running of top of uIP.
cassyarduino 0:e3fb1267e3c3 436 */
cassyarduino 0:e3fb1267e3c3 437
cassyarduino 0:e3fb1267e3c3 438 /**
cassyarduino 0:e3fb1267e3c3 439 * Start listening to the specified port.
cassyarduino 0:e3fb1267e3c3 440 *
cassyarduino 0:e3fb1267e3c3 441 * \note Since this function expects the port number in network byte
cassyarduino 0:e3fb1267e3c3 442 * order, a conversion using HTONS() or htons() is necessary.
cassyarduino 0:e3fb1267e3c3 443 *
cassyarduino 0:e3fb1267e3c3 444 \code
cassyarduino 0:e3fb1267e3c3 445 uip_listen(HTONS(80));
cassyarduino 0:e3fb1267e3c3 446 \endcode
cassyarduino 0:e3fb1267e3c3 447 *
cassyarduino 0:e3fb1267e3c3 448 * \param port A 16-bit port number in network byte order.
cassyarduino 0:e3fb1267e3c3 449 */
cassyarduino 0:e3fb1267e3c3 450 void uip_listen(u16_t port);
cassyarduino 0:e3fb1267e3c3 451
cassyarduino 0:e3fb1267e3c3 452 /**
cassyarduino 0:e3fb1267e3c3 453 * Stop listening to the specified port.
cassyarduino 0:e3fb1267e3c3 454 *
cassyarduino 0:e3fb1267e3c3 455 * \note Since this function expects the port number in network byte
cassyarduino 0:e3fb1267e3c3 456 * order, a conversion using HTONS() or htons() is necessary.
cassyarduino 0:e3fb1267e3c3 457 *
cassyarduino 0:e3fb1267e3c3 458 \code
cassyarduino 0:e3fb1267e3c3 459 uip_unlisten(HTONS(80));
cassyarduino 0:e3fb1267e3c3 460 \endcode
cassyarduino 0:e3fb1267e3c3 461 *
cassyarduino 0:e3fb1267e3c3 462 * \param port A 16-bit port number in network byte order.
cassyarduino 0:e3fb1267e3c3 463 */
cassyarduino 0:e3fb1267e3c3 464 void uip_unlisten(u16_t port);
cassyarduino 0:e3fb1267e3c3 465
cassyarduino 0:e3fb1267e3c3 466 /**
cassyarduino 0:e3fb1267e3c3 467 * Connect to a remote host using TCP.
cassyarduino 0:e3fb1267e3c3 468 *
cassyarduino 0:e3fb1267e3c3 469 * This function is used to start a new connection to the specified
cassyarduino 0:e3fb1267e3c3 470 * port on the specied host. It allocates a new connection identifier,
cassyarduino 0:e3fb1267e3c3 471 * sets the connection to the SYN_SENT state and sets the
cassyarduino 0:e3fb1267e3c3 472 * retransmission timer to 0. This will cause a TCP SYN segment to be
cassyarduino 0:e3fb1267e3c3 473 * sent out the next time this connection is periodically processed,
cassyarduino 0:e3fb1267e3c3 474 * which usually is done within 0.5 seconds after the call to
cassyarduino 0:e3fb1267e3c3 475 * uip_connect().
cassyarduino 0:e3fb1267e3c3 476 *
cassyarduino 0:e3fb1267e3c3 477 * \note This function is avaliable only if support for active open
cassyarduino 0:e3fb1267e3c3 478 * has been configured by defining UIP_ACTIVE_OPEN to 1 in uipopt.h.
cassyarduino 0:e3fb1267e3c3 479 *
cassyarduino 0:e3fb1267e3c3 480 * \note Since this function requires the port number to be in network
cassyarduino 0:e3fb1267e3c3 481 * byte order, a conversion using HTONS() or htons() is necessary.
cassyarduino 0:e3fb1267e3c3 482 *
cassyarduino 0:e3fb1267e3c3 483 \code
cassyarduino 0:e3fb1267e3c3 484 uip_ipaddr_t ipaddr;
cassyarduino 0:e3fb1267e3c3 485
cassyarduino 0:e3fb1267e3c3 486 uip_ipaddr(&ipaddr, 192,168,1,2);
cassyarduino 0:e3fb1267e3c3 487 uip_connect(&ipaddr, HTONS(80));
cassyarduino 0:e3fb1267e3c3 488 \endcode
cassyarduino 0:e3fb1267e3c3 489 *
cassyarduino 0:e3fb1267e3c3 490 * \param ripaddr The IP address of the remote hot.
cassyarduino 0:e3fb1267e3c3 491 *
cassyarduino 0:e3fb1267e3c3 492 * \param port A 16-bit port number in network byte order.
cassyarduino 0:e3fb1267e3c3 493 *
cassyarduino 0:e3fb1267e3c3 494 * \return A pointer to the uIP connection identifier for the new connection,
cassyarduino 0:e3fb1267e3c3 495 * or NULL if no connection could be allocated.
cassyarduino 0:e3fb1267e3c3 496 *
cassyarduino 0:e3fb1267e3c3 497 */
cassyarduino 0:e3fb1267e3c3 498 struct uip_conn *uip_connect(uip_ipaddr_t *ripaddr, u16_t port);
cassyarduino 0:e3fb1267e3c3 499
cassyarduino 0:e3fb1267e3c3 500
cassyarduino 0:e3fb1267e3c3 501
cassyarduino 0:e3fb1267e3c3 502 /**
cassyarduino 0:e3fb1267e3c3 503 * \internal
cassyarduino 0:e3fb1267e3c3 504 *
cassyarduino 0:e3fb1267e3c3 505 * Check if a connection has outstanding (i.e., unacknowledged) data.
cassyarduino 0:e3fb1267e3c3 506 *
cassyarduino 0:e3fb1267e3c3 507 * \param conn A pointer to the uip_conn structure for the connection.
cassyarduino 0:e3fb1267e3c3 508 *
cassyarduino 0:e3fb1267e3c3 509 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 510 */
cassyarduino 0:e3fb1267e3c3 511 #define uip_outstanding(conn) ((conn)->len)
cassyarduino 0:e3fb1267e3c3 512
cassyarduino 0:e3fb1267e3c3 513 /**
cassyarduino 0:e3fb1267e3c3 514 * Send data on the current connection.
cassyarduino 0:e3fb1267e3c3 515 *
cassyarduino 0:e3fb1267e3c3 516 * This function is used to send out a single segment of TCP
cassyarduino 0:e3fb1267e3c3 517 * data. Only applications that have been invoked by uIP for event
cassyarduino 0:e3fb1267e3c3 518 * processing can send data.
cassyarduino 0:e3fb1267e3c3 519 *
cassyarduino 0:e3fb1267e3c3 520 * The amount of data that actually is sent out after a call to this
cassyarduino 0:e3fb1267e3c3 521 * funcion is determined by the maximum amount of data TCP allows. uIP
cassyarduino 0:e3fb1267e3c3 522 * will automatically crop the data so that only the appropriate
cassyarduino 0:e3fb1267e3c3 523 * amount of data is sent. The function uip_mss() can be used to query
cassyarduino 0:e3fb1267e3c3 524 * uIP for the amount of data that actually will be sent.
cassyarduino 0:e3fb1267e3c3 525 *
cassyarduino 0:e3fb1267e3c3 526 * \note This function does not guarantee that the sent data will
cassyarduino 0:e3fb1267e3c3 527 * arrive at the destination. If the data is lost in the network, the
cassyarduino 0:e3fb1267e3c3 528 * application will be invoked with the uip_rexmit() event being
cassyarduino 0:e3fb1267e3c3 529 * set. The application will then have to resend the data using this
cassyarduino 0:e3fb1267e3c3 530 * function.
cassyarduino 0:e3fb1267e3c3 531 *
cassyarduino 0:e3fb1267e3c3 532 * \param data A pointer to the data which is to be sent.
cassyarduino 0:e3fb1267e3c3 533 *
cassyarduino 0:e3fb1267e3c3 534 * \param len The maximum amount of data bytes to be sent.
cassyarduino 0:e3fb1267e3c3 535 *
cassyarduino 0:e3fb1267e3c3 536 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 537 */
cassyarduino 0:e3fb1267e3c3 538 void uip_send(const void *data, int len);
cassyarduino 0:e3fb1267e3c3 539
cassyarduino 0:e3fb1267e3c3 540 /**
cassyarduino 0:e3fb1267e3c3 541 * The length of any incoming data that is currently avaliable (if avaliable)
cassyarduino 0:e3fb1267e3c3 542 * in the uip_appdata buffer.
cassyarduino 0:e3fb1267e3c3 543 *
cassyarduino 0:e3fb1267e3c3 544 * The test function uip_data() must first be used to check if there
cassyarduino 0:e3fb1267e3c3 545 * is any data available at all.
cassyarduino 0:e3fb1267e3c3 546 *
cassyarduino 0:e3fb1267e3c3 547 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 548 */
cassyarduino 0:e3fb1267e3c3 549 /*void uip_datalen(void);*/
cassyarduino 0:e3fb1267e3c3 550 #define uip_datalen() uip_len
cassyarduino 0:e3fb1267e3c3 551
cassyarduino 0:e3fb1267e3c3 552 /**
cassyarduino 0:e3fb1267e3c3 553 * The length of any out-of-band data (urgent data) that has arrived
cassyarduino 0:e3fb1267e3c3 554 * on the connection.
cassyarduino 0:e3fb1267e3c3 555 *
cassyarduino 0:e3fb1267e3c3 556 * \note The configuration parameter UIP_URGDATA must be set for this
cassyarduino 0:e3fb1267e3c3 557 * function to be enabled.
cassyarduino 0:e3fb1267e3c3 558 *
cassyarduino 0:e3fb1267e3c3 559 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 560 */
cassyarduino 0:e3fb1267e3c3 561 #define uip_urgdatalen() uip_urglen
cassyarduino 0:e3fb1267e3c3 562
cassyarduino 0:e3fb1267e3c3 563 /**
cassyarduino 0:e3fb1267e3c3 564 * Close the current connection.
cassyarduino 0:e3fb1267e3c3 565 *
cassyarduino 0:e3fb1267e3c3 566 * This function will close the current connection in a nice way.
cassyarduino 0:e3fb1267e3c3 567 *
cassyarduino 0:e3fb1267e3c3 568 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 569 */
cassyarduino 0:e3fb1267e3c3 570 #define uip_close() (uip_flags = UIP_CLOSE)
cassyarduino 0:e3fb1267e3c3 571
cassyarduino 0:e3fb1267e3c3 572 /**
cassyarduino 0:e3fb1267e3c3 573 * Abort the current connection.
cassyarduino 0:e3fb1267e3c3 574 *
cassyarduino 0:e3fb1267e3c3 575 * This function will abort (reset) the current connection, and is
cassyarduino 0:e3fb1267e3c3 576 * usually used when an error has occured that prevents using the
cassyarduino 0:e3fb1267e3c3 577 * uip_close() function.
cassyarduino 0:e3fb1267e3c3 578 *
cassyarduino 0:e3fb1267e3c3 579 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 580 */
cassyarduino 0:e3fb1267e3c3 581 #define uip_abort() (uip_flags = UIP_ABORT)
cassyarduino 0:e3fb1267e3c3 582
cassyarduino 0:e3fb1267e3c3 583 /**
cassyarduino 0:e3fb1267e3c3 584 * Tell the sending host to stop sending data.
cassyarduino 0:e3fb1267e3c3 585 *
cassyarduino 0:e3fb1267e3c3 586 * This function will close our receiver's window so that we stop
cassyarduino 0:e3fb1267e3c3 587 * receiving data for the current connection.
cassyarduino 0:e3fb1267e3c3 588 *
cassyarduino 0:e3fb1267e3c3 589 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 590 */
cassyarduino 0:e3fb1267e3c3 591 #define uip_stop() (uip_conn->tcpstateflags |= UIP_STOPPED)
cassyarduino 0:e3fb1267e3c3 592
cassyarduino 0:e3fb1267e3c3 593 /**
cassyarduino 0:e3fb1267e3c3 594 * Find out if the current connection has been previously stopped with
cassyarduino 0:e3fb1267e3c3 595 * uip_stop().
cassyarduino 0:e3fb1267e3c3 596 *
cassyarduino 0:e3fb1267e3c3 597 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 598 */
cassyarduino 0:e3fb1267e3c3 599 #define uip_stopped(conn) ((conn)->tcpstateflags & UIP_STOPPED)
cassyarduino 0:e3fb1267e3c3 600
cassyarduino 0:e3fb1267e3c3 601 /**
cassyarduino 0:e3fb1267e3c3 602 * Restart the current connection, if is has previously been stopped
cassyarduino 0:e3fb1267e3c3 603 * with uip_stop().
cassyarduino 0:e3fb1267e3c3 604 *
cassyarduino 0:e3fb1267e3c3 605 * This function will open the receiver's window again so that we
cassyarduino 0:e3fb1267e3c3 606 * start receiving data for the current connection.
cassyarduino 0:e3fb1267e3c3 607 *
cassyarduino 0:e3fb1267e3c3 608 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 609 */
cassyarduino 0:e3fb1267e3c3 610 #define uip_restart() do { uip_flags |= UIP_NEWDATA; \
cassyarduino 0:e3fb1267e3c3 611 uip_conn->tcpstateflags &= ~UIP_STOPPED; \
cassyarduino 0:e3fb1267e3c3 612 } while(0)
cassyarduino 0:e3fb1267e3c3 613
cassyarduino 0:e3fb1267e3c3 614
cassyarduino 0:e3fb1267e3c3 615 /* uIP tests that can be made to determine in what state the current
cassyarduino 0:e3fb1267e3c3 616 connection is, and what the application function should do. */
cassyarduino 0:e3fb1267e3c3 617
cassyarduino 0:e3fb1267e3c3 618 /**
cassyarduino 0:e3fb1267e3c3 619 * Is the current connection a UDP connection?
cassyarduino 0:e3fb1267e3c3 620 *
cassyarduino 0:e3fb1267e3c3 621 * This function checks whether the current connection is a UDP connection.
cassyarduino 0:e3fb1267e3c3 622 *
cassyarduino 0:e3fb1267e3c3 623 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 624 *
cassyarduino 0:e3fb1267e3c3 625 */
cassyarduino 0:e3fb1267e3c3 626 #define uip_udpconnection() (uip_conn == NULL)
cassyarduino 0:e3fb1267e3c3 627
cassyarduino 0:e3fb1267e3c3 628 /**
cassyarduino 0:e3fb1267e3c3 629 * Is new incoming data available?
cassyarduino 0:e3fb1267e3c3 630 *
cassyarduino 0:e3fb1267e3c3 631 * Will reduce to non-zero if there is new data for the application
cassyarduino 0:e3fb1267e3c3 632 * present at the uip_appdata pointer. The size of the data is
cassyarduino 0:e3fb1267e3c3 633 * avaliable through the uip_len variable.
cassyarduino 0:e3fb1267e3c3 634 *
cassyarduino 0:e3fb1267e3c3 635 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 636 */
cassyarduino 0:e3fb1267e3c3 637 #define uip_newdata() (uip_flags & UIP_NEWDATA)
cassyarduino 0:e3fb1267e3c3 638
cassyarduino 0:e3fb1267e3c3 639 /**
cassyarduino 0:e3fb1267e3c3 640 * Has previously sent data been acknowledged?
cassyarduino 0:e3fb1267e3c3 641 *
cassyarduino 0:e3fb1267e3c3 642 * Will reduce to non-zero if the previously sent data has been
cassyarduino 0:e3fb1267e3c3 643 * acknowledged by the remote host. This means that the application
cassyarduino 0:e3fb1267e3c3 644 * can send new data.
cassyarduino 0:e3fb1267e3c3 645 *
cassyarduino 0:e3fb1267e3c3 646 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 647 */
cassyarduino 0:e3fb1267e3c3 648 #define uip_acked() (uip_flags & UIP_ACKDATA)
cassyarduino 0:e3fb1267e3c3 649
cassyarduino 0:e3fb1267e3c3 650 /**
cassyarduino 0:e3fb1267e3c3 651 * Has the connection just been connected?
cassyarduino 0:e3fb1267e3c3 652 *
cassyarduino 0:e3fb1267e3c3 653 * Reduces to non-zero if the current connection has been connected to
cassyarduino 0:e3fb1267e3c3 654 * a remote host. This will happen both if the connection has been
cassyarduino 0:e3fb1267e3c3 655 * actively opened (with uip_connect()) or passively opened (with
cassyarduino 0:e3fb1267e3c3 656 * uip_listen()).
cassyarduino 0:e3fb1267e3c3 657 *
cassyarduino 0:e3fb1267e3c3 658 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 659 */
cassyarduino 0:e3fb1267e3c3 660 #define uip_connected() (uip_flags & UIP_CONNECTED)
cassyarduino 0:e3fb1267e3c3 661
cassyarduino 0:e3fb1267e3c3 662 /**
cassyarduino 0:e3fb1267e3c3 663 * Has the connection been closed by the other end?
cassyarduino 0:e3fb1267e3c3 664 *
cassyarduino 0:e3fb1267e3c3 665 * Is non-zero if the connection has been closed by the remote
cassyarduino 0:e3fb1267e3c3 666 * host. The application may then do the necessary clean-ups.
cassyarduino 0:e3fb1267e3c3 667 *
cassyarduino 0:e3fb1267e3c3 668 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 669 */
cassyarduino 0:e3fb1267e3c3 670 #define uip_closed() (uip_flags & UIP_CLOSE)
cassyarduino 0:e3fb1267e3c3 671
cassyarduino 0:e3fb1267e3c3 672 /**
cassyarduino 0:e3fb1267e3c3 673 * Has the connection been aborted by the other end?
cassyarduino 0:e3fb1267e3c3 674 *
cassyarduino 0:e3fb1267e3c3 675 * Non-zero if the current connection has been aborted (reset) by the
cassyarduino 0:e3fb1267e3c3 676 * remote host.
cassyarduino 0:e3fb1267e3c3 677 *
cassyarduino 0:e3fb1267e3c3 678 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 679 */
cassyarduino 0:e3fb1267e3c3 680 #define uip_aborted() (uip_flags & UIP_ABORT)
cassyarduino 0:e3fb1267e3c3 681
cassyarduino 0:e3fb1267e3c3 682 /**
cassyarduino 0:e3fb1267e3c3 683 * Has the connection timed out?
cassyarduino 0:e3fb1267e3c3 684 *
cassyarduino 0:e3fb1267e3c3 685 * Non-zero if the current connection has been aborted due to too many
cassyarduino 0:e3fb1267e3c3 686 * retransmissions.
cassyarduino 0:e3fb1267e3c3 687 *
cassyarduino 0:e3fb1267e3c3 688 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 689 */
cassyarduino 0:e3fb1267e3c3 690 #define uip_timedout() (uip_flags & UIP_TIMEDOUT)
cassyarduino 0:e3fb1267e3c3 691
cassyarduino 0:e3fb1267e3c3 692 /**
cassyarduino 0:e3fb1267e3c3 693 * Do we need to retransmit previously data?
cassyarduino 0:e3fb1267e3c3 694 *
cassyarduino 0:e3fb1267e3c3 695 * Reduces to non-zero if the previously sent data has been lost in
cassyarduino 0:e3fb1267e3c3 696 * the network, and the application should retransmit it. The
cassyarduino 0:e3fb1267e3c3 697 * application should send the exact same data as it did the last
cassyarduino 0:e3fb1267e3c3 698 * time, using the uip_send() function.
cassyarduino 0:e3fb1267e3c3 699 *
cassyarduino 0:e3fb1267e3c3 700 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 701 */
cassyarduino 0:e3fb1267e3c3 702 #define uip_rexmit() (uip_flags & UIP_REXMIT)
cassyarduino 0:e3fb1267e3c3 703
cassyarduino 0:e3fb1267e3c3 704 /**
cassyarduino 0:e3fb1267e3c3 705 * Is the connection being polled by uIP?
cassyarduino 0:e3fb1267e3c3 706 *
cassyarduino 0:e3fb1267e3c3 707 * Is non-zero if the reason the application is invoked is that the
cassyarduino 0:e3fb1267e3c3 708 * current connection has been idle for a while and should be
cassyarduino 0:e3fb1267e3c3 709 * polled.
cassyarduino 0:e3fb1267e3c3 710 *
cassyarduino 0:e3fb1267e3c3 711 * The polling event can be used for sending data without having to
cassyarduino 0:e3fb1267e3c3 712 * wait for the remote host to send data.
cassyarduino 0:e3fb1267e3c3 713 *
cassyarduino 0:e3fb1267e3c3 714 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 715 */
cassyarduino 0:e3fb1267e3c3 716 #define uip_poll() (uip_flags & UIP_POLL)
cassyarduino 0:e3fb1267e3c3 717
cassyarduino 0:e3fb1267e3c3 718 /**
cassyarduino 0:e3fb1267e3c3 719 * Get the initial maxium segment size (MSS) of the current
cassyarduino 0:e3fb1267e3c3 720 * connection.
cassyarduino 0:e3fb1267e3c3 721 *
cassyarduino 0:e3fb1267e3c3 722 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 723 */
cassyarduino 0:e3fb1267e3c3 724 #define uip_initialmss() (uip_conn->initialmss)
cassyarduino 0:e3fb1267e3c3 725
cassyarduino 0:e3fb1267e3c3 726 /**
cassyarduino 0:e3fb1267e3c3 727 * Get the current maxium segment size that can be sent on the current
cassyarduino 0:e3fb1267e3c3 728 * connection.
cassyarduino 0:e3fb1267e3c3 729 *
cassyarduino 0:e3fb1267e3c3 730 * The current maxiumum segment size that can be sent on the
cassyarduino 0:e3fb1267e3c3 731 * connection is computed from the receiver's window and the MSS of
cassyarduino 0:e3fb1267e3c3 732 * the connection (which also is available by calling
cassyarduino 0:e3fb1267e3c3 733 * uip_initialmss()).
cassyarduino 0:e3fb1267e3c3 734 *
cassyarduino 0:e3fb1267e3c3 735 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 736 */
cassyarduino 0:e3fb1267e3c3 737 #define uip_mss() (uip_conn->mss)
cassyarduino 0:e3fb1267e3c3 738
cassyarduino 0:e3fb1267e3c3 739 /**
cassyarduino 0:e3fb1267e3c3 740 * Set up a new UDP connection.
cassyarduino 0:e3fb1267e3c3 741 *
cassyarduino 0:e3fb1267e3c3 742 * This function sets up a new UDP connection. The function will
cassyarduino 0:e3fb1267e3c3 743 * automatically allocate an unused local port for the new
cassyarduino 0:e3fb1267e3c3 744 * connection. However, another port can be chosen by using the
cassyarduino 0:e3fb1267e3c3 745 * uip_udp_bind() call, after the uip_udp_new() function has been
cassyarduino 0:e3fb1267e3c3 746 * called.
cassyarduino 0:e3fb1267e3c3 747 *
cassyarduino 0:e3fb1267e3c3 748 * Example:
cassyarduino 0:e3fb1267e3c3 749 \code
cassyarduino 0:e3fb1267e3c3 750 uip_ipaddr_t addr;
cassyarduino 0:e3fb1267e3c3 751 struct uip_udp_conn *c;
cassyarduino 0:e3fb1267e3c3 752
cassyarduino 0:e3fb1267e3c3 753 uip_ipaddr(&addr, 192,168,2,1);
cassyarduino 0:e3fb1267e3c3 754 c = uip_udp_new(&addr, HTONS(12345));
cassyarduino 0:e3fb1267e3c3 755 if(c != NULL) {
cassyarduino 0:e3fb1267e3c3 756 uip_udp_bind(c, HTONS(12344));
cassyarduino 0:e3fb1267e3c3 757 }
cassyarduino 0:e3fb1267e3c3 758 \endcode
cassyarduino 0:e3fb1267e3c3 759 * \param ripaddr The IP address of the remote host.
cassyarduino 0:e3fb1267e3c3 760 *
cassyarduino 0:e3fb1267e3c3 761 * \param rport The remote port number in network byte order.
cassyarduino 0:e3fb1267e3c3 762 *
cassyarduino 0:e3fb1267e3c3 763 * \return The uip_udp_conn structure for the new connection or NULL
cassyarduino 0:e3fb1267e3c3 764 * if no connection could be allocated.
cassyarduino 0:e3fb1267e3c3 765 */
cassyarduino 0:e3fb1267e3c3 766 struct uip_udp_conn *uip_udp_new(uip_ipaddr_t *ripaddr, u16_t rport);
cassyarduino 0:e3fb1267e3c3 767
cassyarduino 0:e3fb1267e3c3 768 /**
cassyarduino 0:e3fb1267e3c3 769 * Removed a UDP connection.
cassyarduino 0:e3fb1267e3c3 770 *
cassyarduino 0:e3fb1267e3c3 771 * \param conn A pointer to the uip_udp_conn structure for the connection.
cassyarduino 0:e3fb1267e3c3 772 *
cassyarduino 0:e3fb1267e3c3 773 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 774 */
cassyarduino 0:e3fb1267e3c3 775 #define uip_udp_remove(conn) (conn)->lport = 0
cassyarduino 0:e3fb1267e3c3 776
cassyarduino 0:e3fb1267e3c3 777 /**
cassyarduino 0:e3fb1267e3c3 778 * Bind a UDP connection to a local port.
cassyarduino 0:e3fb1267e3c3 779 *
cassyarduino 0:e3fb1267e3c3 780 * \param conn A pointer to the uip_udp_conn structure for the
cassyarduino 0:e3fb1267e3c3 781 * connection.
cassyarduino 0:e3fb1267e3c3 782 *
cassyarduino 0:e3fb1267e3c3 783 * \param port The local port number, in network byte order.
cassyarduino 0:e3fb1267e3c3 784 *
cassyarduino 0:e3fb1267e3c3 785 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 786 */
cassyarduino 0:e3fb1267e3c3 787 #define uip_udp_bind(conn, port) (conn)->lport = port
cassyarduino 0:e3fb1267e3c3 788
cassyarduino 0:e3fb1267e3c3 789 /**
cassyarduino 0:e3fb1267e3c3 790 * Send a UDP datagram of length len on the current connection.
cassyarduino 0:e3fb1267e3c3 791 *
cassyarduino 0:e3fb1267e3c3 792 * This function can only be called in response to a UDP event (poll
cassyarduino 0:e3fb1267e3c3 793 * or newdata). The data must be present in the uip_buf buffer, at the
cassyarduino 0:e3fb1267e3c3 794 * place pointed to by the uip_appdata pointer.
cassyarduino 0:e3fb1267e3c3 795 *
cassyarduino 0:e3fb1267e3c3 796 * \param len The length of the data in the uip_buf buffer.
cassyarduino 0:e3fb1267e3c3 797 *
cassyarduino 0:e3fb1267e3c3 798 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 799 */
cassyarduino 0:e3fb1267e3c3 800 #define uip_udp_send(len) uip_send((char *)uip_appdata, len)
cassyarduino 0:e3fb1267e3c3 801
cassyarduino 0:e3fb1267e3c3 802 /** @} */
cassyarduino 0:e3fb1267e3c3 803
cassyarduino 0:e3fb1267e3c3 804 /* uIP convenience and converting functions. */
cassyarduino 0:e3fb1267e3c3 805
cassyarduino 0:e3fb1267e3c3 806 /**
cassyarduino 0:e3fb1267e3c3 807 * \defgroup uipconvfunc uIP conversion functions
cassyarduino 0:e3fb1267e3c3 808 * @{
cassyarduino 0:e3fb1267e3c3 809 *
cassyarduino 0:e3fb1267e3c3 810 * These functions can be used for converting between different data
cassyarduino 0:e3fb1267e3c3 811 * formats used by uIP.
cassyarduino 0:e3fb1267e3c3 812 */
cassyarduino 0:e3fb1267e3c3 813
cassyarduino 0:e3fb1267e3c3 814 /**
cassyarduino 0:e3fb1267e3c3 815 * Construct an IP address from four bytes.
cassyarduino 0:e3fb1267e3c3 816 *
cassyarduino 0:e3fb1267e3c3 817 * This function constructs an IP address of the type that uIP handles
cassyarduino 0:e3fb1267e3c3 818 * internally from four bytes. The function is handy for specifying IP
cassyarduino 0:e3fb1267e3c3 819 * addresses to use with e.g. the uip_connect() function.
cassyarduino 0:e3fb1267e3c3 820 *
cassyarduino 0:e3fb1267e3c3 821 * Example:
cassyarduino 0:e3fb1267e3c3 822 \code
cassyarduino 0:e3fb1267e3c3 823 uip_ipaddr_t ipaddr;
cassyarduino 0:e3fb1267e3c3 824 struct uip_conn *c;
cassyarduino 0:e3fb1267e3c3 825
cassyarduino 0:e3fb1267e3c3 826 uip_ipaddr(&ipaddr, 192,168,1,2);
cassyarduino 0:e3fb1267e3c3 827 c = uip_connect(&ipaddr, HTONS(80));
cassyarduino 0:e3fb1267e3c3 828 \endcode
cassyarduino 0:e3fb1267e3c3 829 *
cassyarduino 0:e3fb1267e3c3 830 * \param addr A pointer to a uip_ipaddr_t variable that will be
cassyarduino 0:e3fb1267e3c3 831 * filled in with the IP address.
cassyarduino 0:e3fb1267e3c3 832 *
cassyarduino 0:e3fb1267e3c3 833 * \param addr0 The first octet of the IP address.
cassyarduino 0:e3fb1267e3c3 834 * \param addr1 The second octet of the IP address.
cassyarduino 0:e3fb1267e3c3 835 * \param addr2 The third octet of the IP address.
cassyarduino 0:e3fb1267e3c3 836 * \param addr3 The forth octet of the IP address.
cassyarduino 0:e3fb1267e3c3 837 *
cassyarduino 0:e3fb1267e3c3 838 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 839 */
cassyarduino 0:e3fb1267e3c3 840 #define uip_ipaddr(addr, addr0,addr1,addr2,addr3) do { \
cassyarduino 0:e3fb1267e3c3 841 ((u16_t *)(addr))[0] = HTONS(((addr0) << 8) | (addr1)); \
cassyarduino 0:e3fb1267e3c3 842 ((u16_t *)(addr))[1] = HTONS(((addr2) << 8) | (addr3)); \
cassyarduino 0:e3fb1267e3c3 843 } while(0)
cassyarduino 0:e3fb1267e3c3 844
cassyarduino 0:e3fb1267e3c3 845 /**
cassyarduino 0:e3fb1267e3c3 846 * Construct an IPv6 address from eight 16-bit words.
cassyarduino 0:e3fb1267e3c3 847 *
cassyarduino 0:e3fb1267e3c3 848 * This function constructs an IPv6 address.
cassyarduino 0:e3fb1267e3c3 849 *
cassyarduino 0:e3fb1267e3c3 850 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 851 */
cassyarduino 0:e3fb1267e3c3 852 #define uip_ip6addr(addr, addr0,addr1,addr2,addr3,addr4,addr5,addr6,addr7) do { \
cassyarduino 0:e3fb1267e3c3 853 ((u16_t *)(addr))[0] = HTONS((addr0)); \
cassyarduino 0:e3fb1267e3c3 854 ((u16_t *)(addr))[1] = HTONS((addr1)); \
cassyarduino 0:e3fb1267e3c3 855 ((u16_t *)(addr))[2] = HTONS((addr2)); \
cassyarduino 0:e3fb1267e3c3 856 ((u16_t *)(addr))[3] = HTONS((addr3)); \
cassyarduino 0:e3fb1267e3c3 857 ((u16_t *)(addr))[4] = HTONS((addr4)); \
cassyarduino 0:e3fb1267e3c3 858 ((u16_t *)(addr))[5] = HTONS((addr5)); \
cassyarduino 0:e3fb1267e3c3 859 ((u16_t *)(addr))[6] = HTONS((addr6)); \
cassyarduino 0:e3fb1267e3c3 860 ((u16_t *)(addr))[7] = HTONS((addr7)); \
cassyarduino 0:e3fb1267e3c3 861 } while(0)
cassyarduino 0:e3fb1267e3c3 862
cassyarduino 0:e3fb1267e3c3 863 /**
cassyarduino 0:e3fb1267e3c3 864 * Copy an IP address to another IP address.
cassyarduino 0:e3fb1267e3c3 865 *
cassyarduino 0:e3fb1267e3c3 866 * Copies an IP address from one place to another.
cassyarduino 0:e3fb1267e3c3 867 *
cassyarduino 0:e3fb1267e3c3 868 * Example:
cassyarduino 0:e3fb1267e3c3 869 \code
cassyarduino 0:e3fb1267e3c3 870 uip_ipaddr_t ipaddr1, ipaddr2;
cassyarduino 0:e3fb1267e3c3 871
cassyarduino 0:e3fb1267e3c3 872 uip_ipaddr(&ipaddr1, 192,16,1,2);
cassyarduino 0:e3fb1267e3c3 873 uip_ipaddr_copy(&ipaddr2, &ipaddr1);
cassyarduino 0:e3fb1267e3c3 874 \endcode
cassyarduino 0:e3fb1267e3c3 875 *
cassyarduino 0:e3fb1267e3c3 876 * \param dest The destination for the copy.
cassyarduino 0:e3fb1267e3c3 877 * \param src The source from where to copy.
cassyarduino 0:e3fb1267e3c3 878 *
cassyarduino 0:e3fb1267e3c3 879 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 880 */
cassyarduino 0:e3fb1267e3c3 881 #if !UIP_CONF_IPV6
cassyarduino 0:e3fb1267e3c3 882 #define uip_ipaddr_copy(dest, src) do { \
cassyarduino 0:e3fb1267e3c3 883 ((u16_t *)dest)[0] = ((u16_t *)src)[0]; \
cassyarduino 0:e3fb1267e3c3 884 ((u16_t *)dest)[1] = ((u16_t *)src)[1]; \
cassyarduino 0:e3fb1267e3c3 885 } while(0)
cassyarduino 0:e3fb1267e3c3 886 #else /* !UIP_CONF_IPV6 */
cassyarduino 0:e3fb1267e3c3 887 #define uip_ipaddr_copy(dest, src) memcpy(dest, src, sizeof(uip_ip6addr_t))
cassyarduino 0:e3fb1267e3c3 888 #endif /* !UIP_CONF_IPV6 */
cassyarduino 0:e3fb1267e3c3 889
cassyarduino 0:e3fb1267e3c3 890 /**
cassyarduino 0:e3fb1267e3c3 891 * Compare two IP addresses
cassyarduino 0:e3fb1267e3c3 892 *
cassyarduino 0:e3fb1267e3c3 893 * Compares two IP addresses.
cassyarduino 0:e3fb1267e3c3 894 *
cassyarduino 0:e3fb1267e3c3 895 * Example:
cassyarduino 0:e3fb1267e3c3 896 \code
cassyarduino 0:e3fb1267e3c3 897 uip_ipaddr_t ipaddr1, ipaddr2;
cassyarduino 0:e3fb1267e3c3 898
cassyarduino 0:e3fb1267e3c3 899 uip_ipaddr(&ipaddr1, 192,16,1,2);
cassyarduino 0:e3fb1267e3c3 900 if(uip_ipaddr_cmp(&ipaddr2, &ipaddr1)) {
cassyarduino 0:e3fb1267e3c3 901 printf("They are the same");
cassyarduino 0:e3fb1267e3c3 902 }
cassyarduino 0:e3fb1267e3c3 903 \endcode
cassyarduino 0:e3fb1267e3c3 904 *
cassyarduino 0:e3fb1267e3c3 905 * \param addr1 The first IP address.
cassyarduino 0:e3fb1267e3c3 906 * \param addr2 The second IP address.
cassyarduino 0:e3fb1267e3c3 907 *
cassyarduino 0:e3fb1267e3c3 908 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 909 */
cassyarduino 0:e3fb1267e3c3 910 #if !UIP_CONF_IPV6
cassyarduino 0:e3fb1267e3c3 911 #define uip_ipaddr_cmp(addr1, addr2) (((u16_t *)addr1)[0] == ((u16_t *)addr2)[0] && \
cassyarduino 0:e3fb1267e3c3 912 ((u16_t *)addr1)[1] == ((u16_t *)addr2)[1])
cassyarduino 0:e3fb1267e3c3 913 #else /* !UIP_CONF_IPV6 */
cassyarduino 0:e3fb1267e3c3 914 #define uip_ipaddr_cmp(addr1, addr2) (memcmp(addr1, addr2, sizeof(uip_ip6addr_t)) == 0)
cassyarduino 0:e3fb1267e3c3 915 #endif /* !UIP_CONF_IPV6 */
cassyarduino 0:e3fb1267e3c3 916
cassyarduino 0:e3fb1267e3c3 917 /**
cassyarduino 0:e3fb1267e3c3 918 * Compare two IP addresses with netmasks
cassyarduino 0:e3fb1267e3c3 919 *
cassyarduino 0:e3fb1267e3c3 920 * Compares two IP addresses with netmasks. The masks are used to mask
cassyarduino 0:e3fb1267e3c3 921 * out the bits that are to be compared.
cassyarduino 0:e3fb1267e3c3 922 *
cassyarduino 0:e3fb1267e3c3 923 * Example:
cassyarduino 0:e3fb1267e3c3 924 \code
cassyarduino 0:e3fb1267e3c3 925 uip_ipaddr_t ipaddr1, ipaddr2, mask;
cassyarduino 0:e3fb1267e3c3 926
cassyarduino 0:e3fb1267e3c3 927 uip_ipaddr(&mask, 255,255,255,0);
cassyarduino 0:e3fb1267e3c3 928 uip_ipaddr(&ipaddr1, 192,16,1,2);
cassyarduino 0:e3fb1267e3c3 929 uip_ipaddr(&ipaddr2, 192,16,1,3);
cassyarduino 0:e3fb1267e3c3 930 if(uip_ipaddr_maskcmp(&ipaddr1, &ipaddr2, &mask)) {
cassyarduino 0:e3fb1267e3c3 931 printf("They are the same");
cassyarduino 0:e3fb1267e3c3 932 }
cassyarduino 0:e3fb1267e3c3 933 \endcode
cassyarduino 0:e3fb1267e3c3 934 *
cassyarduino 0:e3fb1267e3c3 935 * \param addr1 The first IP address.
cassyarduino 0:e3fb1267e3c3 936 * \param addr2 The second IP address.
cassyarduino 0:e3fb1267e3c3 937 * \param mask The netmask.
cassyarduino 0:e3fb1267e3c3 938 *
cassyarduino 0:e3fb1267e3c3 939 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 940 */
cassyarduino 0:e3fb1267e3c3 941 #define uip_ipaddr_maskcmp(addr1, addr2, mask) \
cassyarduino 0:e3fb1267e3c3 942 (((((u16_t *)addr1)[0] & ((u16_t *)mask)[0]) == \
cassyarduino 0:e3fb1267e3c3 943 (((u16_t *)addr2)[0] & ((u16_t *)mask)[0])) && \
cassyarduino 0:e3fb1267e3c3 944 ((((u16_t *)addr1)[1] & ((u16_t *)mask)[1]) == \
cassyarduino 0:e3fb1267e3c3 945 (((u16_t *)addr2)[1] & ((u16_t *)mask)[1])))
cassyarduino 0:e3fb1267e3c3 946
cassyarduino 0:e3fb1267e3c3 947
cassyarduino 0:e3fb1267e3c3 948 /**
cassyarduino 0:e3fb1267e3c3 949 * Mask out the network part of an IP address.
cassyarduino 0:e3fb1267e3c3 950 *
cassyarduino 0:e3fb1267e3c3 951 * Masks out the network part of an IP address, given the address and
cassyarduino 0:e3fb1267e3c3 952 * the netmask.
cassyarduino 0:e3fb1267e3c3 953 *
cassyarduino 0:e3fb1267e3c3 954 * Example:
cassyarduino 0:e3fb1267e3c3 955 \code
cassyarduino 0:e3fb1267e3c3 956 uip_ipaddr_t ipaddr1, ipaddr2, netmask;
cassyarduino 0:e3fb1267e3c3 957
cassyarduino 0:e3fb1267e3c3 958 uip_ipaddr(&ipaddr1, 192,16,1,2);
cassyarduino 0:e3fb1267e3c3 959 uip_ipaddr(&netmask, 255,255,255,0);
cassyarduino 0:e3fb1267e3c3 960 uip_ipaddr_mask(&ipaddr2, &ipaddr1, &netmask);
cassyarduino 0:e3fb1267e3c3 961 \endcode
cassyarduino 0:e3fb1267e3c3 962 *
cassyarduino 0:e3fb1267e3c3 963 * In the example above, the variable "ipaddr2" will contain the IP
cassyarduino 0:e3fb1267e3c3 964 * address 192.168.1.0.
cassyarduino 0:e3fb1267e3c3 965 *
cassyarduino 0:e3fb1267e3c3 966 * \param dest Where the result is to be placed.
cassyarduino 0:e3fb1267e3c3 967 * \param src The IP address.
cassyarduino 0:e3fb1267e3c3 968 * \param mask The netmask.
cassyarduino 0:e3fb1267e3c3 969 *
cassyarduino 0:e3fb1267e3c3 970 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 971 */
cassyarduino 0:e3fb1267e3c3 972 #define uip_ipaddr_mask(dest, src, mask) do { \
cassyarduino 0:e3fb1267e3c3 973 ((u16_t *)dest)[0] = ((u16_t *)src)[0] & ((u16_t *)mask)[0]; \
cassyarduino 0:e3fb1267e3c3 974 ((u16_t *)dest)[1] = ((u16_t *)src)[1] & ((u16_t *)mask)[1]; \
cassyarduino 0:e3fb1267e3c3 975 } while(0)
cassyarduino 0:e3fb1267e3c3 976
cassyarduino 0:e3fb1267e3c3 977 /**
cassyarduino 0:e3fb1267e3c3 978 * Pick the first octet of an IP address.
cassyarduino 0:e3fb1267e3c3 979 *
cassyarduino 0:e3fb1267e3c3 980 * Picks out the first octet of an IP address.
cassyarduino 0:e3fb1267e3c3 981 *
cassyarduino 0:e3fb1267e3c3 982 * Example:
cassyarduino 0:e3fb1267e3c3 983 \code
cassyarduino 0:e3fb1267e3c3 984 uip_ipaddr_t ipaddr;
cassyarduino 0:e3fb1267e3c3 985 u8_t octet;
cassyarduino 0:e3fb1267e3c3 986
cassyarduino 0:e3fb1267e3c3 987 uip_ipaddr(&ipaddr, 1,2,3,4);
cassyarduino 0:e3fb1267e3c3 988 octet = uip_ipaddr1(&ipaddr);
cassyarduino 0:e3fb1267e3c3 989 \endcode
cassyarduino 0:e3fb1267e3c3 990 *
cassyarduino 0:e3fb1267e3c3 991 * In the example above, the variable "octet" will contain the value 1.
cassyarduino 0:e3fb1267e3c3 992 *
cassyarduino 0:e3fb1267e3c3 993 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 994 */
cassyarduino 0:e3fb1267e3c3 995 #define uip_ipaddr1(addr) (htons(((u16_t *)(addr))[0]) >> 8)
cassyarduino 0:e3fb1267e3c3 996
cassyarduino 0:e3fb1267e3c3 997 /**
cassyarduino 0:e3fb1267e3c3 998 * Pick the second octet of an IP address.
cassyarduino 0:e3fb1267e3c3 999 *
cassyarduino 0:e3fb1267e3c3 1000 * Picks out the second octet of an IP address.
cassyarduino 0:e3fb1267e3c3 1001 *
cassyarduino 0:e3fb1267e3c3 1002 * Example:
cassyarduino 0:e3fb1267e3c3 1003 \code
cassyarduino 0:e3fb1267e3c3 1004 uip_ipaddr_t ipaddr;
cassyarduino 0:e3fb1267e3c3 1005 u8_t octet;
cassyarduino 0:e3fb1267e3c3 1006
cassyarduino 0:e3fb1267e3c3 1007 uip_ipaddr(&ipaddr, 1,2,3,4);
cassyarduino 0:e3fb1267e3c3 1008 octet = uip_ipaddr2(&ipaddr);
cassyarduino 0:e3fb1267e3c3 1009 \endcode
cassyarduino 0:e3fb1267e3c3 1010 *
cassyarduino 0:e3fb1267e3c3 1011 * In the example above, the variable "octet" will contain the value 2.
cassyarduino 0:e3fb1267e3c3 1012 *
cassyarduino 0:e3fb1267e3c3 1013 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 1014 */
cassyarduino 0:e3fb1267e3c3 1015 #define uip_ipaddr2(addr) (htons(((u16_t *)(addr))[0]) & 0xff)
cassyarduino 0:e3fb1267e3c3 1016
cassyarduino 0:e3fb1267e3c3 1017 /**
cassyarduino 0:e3fb1267e3c3 1018 * Pick the third octet of an IP address.
cassyarduino 0:e3fb1267e3c3 1019 *
cassyarduino 0:e3fb1267e3c3 1020 * Picks out the third octet of an IP address.
cassyarduino 0:e3fb1267e3c3 1021 *
cassyarduino 0:e3fb1267e3c3 1022 * Example:
cassyarduino 0:e3fb1267e3c3 1023 \code
cassyarduino 0:e3fb1267e3c3 1024 uip_ipaddr_t ipaddr;
cassyarduino 0:e3fb1267e3c3 1025 u8_t octet;
cassyarduino 0:e3fb1267e3c3 1026
cassyarduino 0:e3fb1267e3c3 1027 uip_ipaddr(&ipaddr, 1,2,3,4);
cassyarduino 0:e3fb1267e3c3 1028 octet = uip_ipaddr3(&ipaddr);
cassyarduino 0:e3fb1267e3c3 1029 \endcode
cassyarduino 0:e3fb1267e3c3 1030 *
cassyarduino 0:e3fb1267e3c3 1031 * In the example above, the variable "octet" will contain the value 3.
cassyarduino 0:e3fb1267e3c3 1032 *
cassyarduino 0:e3fb1267e3c3 1033 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 1034 */
cassyarduino 0:e3fb1267e3c3 1035 #define uip_ipaddr3(addr) (htons(((u16_t *)(addr))[1]) >> 8)
cassyarduino 0:e3fb1267e3c3 1036
cassyarduino 0:e3fb1267e3c3 1037 /**
cassyarduino 0:e3fb1267e3c3 1038 * Pick the fourth octet of an IP address.
cassyarduino 0:e3fb1267e3c3 1039 *
cassyarduino 0:e3fb1267e3c3 1040 * Picks out the fourth octet of an IP address.
cassyarduino 0:e3fb1267e3c3 1041 *
cassyarduino 0:e3fb1267e3c3 1042 * Example:
cassyarduino 0:e3fb1267e3c3 1043 \code
cassyarduino 0:e3fb1267e3c3 1044 uip_ipaddr_t ipaddr;
cassyarduino 0:e3fb1267e3c3 1045 u8_t octet;
cassyarduino 0:e3fb1267e3c3 1046
cassyarduino 0:e3fb1267e3c3 1047 uip_ipaddr(&ipaddr, 1,2,3,4);
cassyarduino 0:e3fb1267e3c3 1048 octet = uip_ipaddr4(&ipaddr);
cassyarduino 0:e3fb1267e3c3 1049 \endcode
cassyarduino 0:e3fb1267e3c3 1050 *
cassyarduino 0:e3fb1267e3c3 1051 * In the example above, the variable "octet" will contain the value 4.
cassyarduino 0:e3fb1267e3c3 1052 *
cassyarduino 0:e3fb1267e3c3 1053 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 1054 */
cassyarduino 0:e3fb1267e3c3 1055 #define uip_ipaddr4(addr) (htons(((u16_t *)(addr))[1]) & 0xff)
cassyarduino 0:e3fb1267e3c3 1056
cassyarduino 0:e3fb1267e3c3 1057 /**
cassyarduino 0:e3fb1267e3c3 1058 * Convert 16-bit quantity from host byte order to network byte order.
cassyarduino 0:e3fb1267e3c3 1059 *
cassyarduino 0:e3fb1267e3c3 1060 * This macro is primarily used for converting constants from host
cassyarduino 0:e3fb1267e3c3 1061 * byte order to network byte order. For converting variables to
cassyarduino 0:e3fb1267e3c3 1062 * network byte order, use the htons() function instead.
cassyarduino 0:e3fb1267e3c3 1063 *
cassyarduino 0:e3fb1267e3c3 1064 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 1065 */
cassyarduino 0:e3fb1267e3c3 1066 #ifndef HTONS
cassyarduino 0:e3fb1267e3c3 1067 # if UIP_BYTE_ORDER == UIP_BIG_ENDIAN
cassyarduino 0:e3fb1267e3c3 1068 # define HTONS(n) (n)
cassyarduino 0:e3fb1267e3c3 1069 # else /* UIP_BYTE_ORDER == UIP_BIG_ENDIAN */
cassyarduino 0:e3fb1267e3c3 1070 # define HTONS(n) (u16_t)((((u16_t) (n)) << 8) | (((u16_t) (n)) >> 8))
cassyarduino 0:e3fb1267e3c3 1071 # endif /* UIP_BYTE_ORDER == UIP_BIG_ENDIAN */
cassyarduino 0:e3fb1267e3c3 1072 #else
cassyarduino 0:e3fb1267e3c3 1073 #error "HTONS already defined!"
cassyarduino 0:e3fb1267e3c3 1074 #endif /* HTONS */
cassyarduino 0:e3fb1267e3c3 1075
cassyarduino 0:e3fb1267e3c3 1076 /**
cassyarduino 0:e3fb1267e3c3 1077 * Convert 16-bit quantity from host byte order to network byte order.
cassyarduino 0:e3fb1267e3c3 1078 *
cassyarduino 0:e3fb1267e3c3 1079 * This function is primarily used for converting variables from host
cassyarduino 0:e3fb1267e3c3 1080 * byte order to network byte order. For converting constants to
cassyarduino 0:e3fb1267e3c3 1081 * network byte order, use the HTONS() macro instead.
cassyarduino 0:e3fb1267e3c3 1082 */
cassyarduino 0:e3fb1267e3c3 1083 #ifndef htons
cassyarduino 0:e3fb1267e3c3 1084 u16_t htons(u16_t val);
cassyarduino 0:e3fb1267e3c3 1085 #endif /* htons */
cassyarduino 0:e3fb1267e3c3 1086 #ifndef ntohs
cassyarduino 0:e3fb1267e3c3 1087 #define ntohs htons
cassyarduino 0:e3fb1267e3c3 1088 #endif
cassyarduino 0:e3fb1267e3c3 1089
cassyarduino 0:e3fb1267e3c3 1090 #ifndef htonl
cassyarduino 0:e3fb1267e3c3 1091 # if UIP_BYTE_ORDER == UIP_BIG_ENDIAN
cassyarduino 0:e3fb1267e3c3 1092 # define htonl(n) (n)
cassyarduino 0:e3fb1267e3c3 1093 # else /* UIP_BYTE_ORDER == UIP_BIG_ENDIAN */
cassyarduino 0:e3fb1267e3c3 1094 # define htonl(x) ( ((x)<<24 & 0xFF000000UL) | \
cassyarduino 0:e3fb1267e3c3 1095 ((x)<< 8 & 0x00FF0000UL) | \
cassyarduino 0:e3fb1267e3c3 1096 ((x)>> 8 & 0x0000FF00UL) | \
cassyarduino 0:e3fb1267e3c3 1097 ((x)>>24 & 0x000000FFUL) )
cassyarduino 0:e3fb1267e3c3 1098 # endif /* UIP_BYTE_ORDER == UIP_BIG_ENDIAN */
cassyarduino 0:e3fb1267e3c3 1099 #endif /* htonl */
cassyarduino 0:e3fb1267e3c3 1100
cassyarduino 0:e3fb1267e3c3 1101 #ifndef ntohl
cassyarduino 0:e3fb1267e3c3 1102 #define ntohl(x) htonl(x)
cassyarduino 0:e3fb1267e3c3 1103 #endif
cassyarduino 0:e3fb1267e3c3 1104
cassyarduino 0:e3fb1267e3c3 1105 /** @} */
cassyarduino 0:e3fb1267e3c3 1106
cassyarduino 0:e3fb1267e3c3 1107 /**
cassyarduino 0:e3fb1267e3c3 1108 * Pointer to the application data in the packet buffer.
cassyarduino 0:e3fb1267e3c3 1109 *
cassyarduino 0:e3fb1267e3c3 1110 * This pointer points to the application data when the application is
cassyarduino 0:e3fb1267e3c3 1111 * called. If the application wishes to send data, the application may
cassyarduino 0:e3fb1267e3c3 1112 * use this space to write the data into before calling uip_send().
cassyarduino 0:e3fb1267e3c3 1113 */
cassyarduino 0:e3fb1267e3c3 1114 extern void *uip_appdata;
cassyarduino 0:e3fb1267e3c3 1115
cassyarduino 0:e3fb1267e3c3 1116 #if UIP_URGDATA > 0
cassyarduino 0:e3fb1267e3c3 1117 /* u8_t *uip_urgdata:
cassyarduino 0:e3fb1267e3c3 1118 *
cassyarduino 0:e3fb1267e3c3 1119 * This pointer points to any urgent data that has been received. Only
cassyarduino 0:e3fb1267e3c3 1120 * present if compiled with support for urgent data (UIP_URGDATA).
cassyarduino 0:e3fb1267e3c3 1121 */
cassyarduino 0:e3fb1267e3c3 1122 extern void *uip_urgdata;
cassyarduino 0:e3fb1267e3c3 1123 #endif /* UIP_URGDATA > 0 */
cassyarduino 0:e3fb1267e3c3 1124
cassyarduino 0:e3fb1267e3c3 1125
cassyarduino 0:e3fb1267e3c3 1126 /**
cassyarduino 0:e3fb1267e3c3 1127 * \defgroup uipdrivervars Variables used in uIP device drivers
cassyarduino 0:e3fb1267e3c3 1128 * @{
cassyarduino 0:e3fb1267e3c3 1129 *
cassyarduino 0:e3fb1267e3c3 1130 * uIP has a few global variables that are used in device drivers for
cassyarduino 0:e3fb1267e3c3 1131 * uIP.
cassyarduino 0:e3fb1267e3c3 1132 */
cassyarduino 0:e3fb1267e3c3 1133
cassyarduino 0:e3fb1267e3c3 1134 /**
cassyarduino 0:e3fb1267e3c3 1135 * The length of the packet in the uip_buf buffer.
cassyarduino 0:e3fb1267e3c3 1136 *
cassyarduino 0:e3fb1267e3c3 1137 * The global variable uip_len holds the length of the packet in the
cassyarduino 0:e3fb1267e3c3 1138 * uip_buf buffer.
cassyarduino 0:e3fb1267e3c3 1139 *
cassyarduino 0:e3fb1267e3c3 1140 * When the network device driver calls the uIP input function,
cassyarduino 0:e3fb1267e3c3 1141 * uip_len should be set to the length of the packet in the uip_buf
cassyarduino 0:e3fb1267e3c3 1142 * buffer.
cassyarduino 0:e3fb1267e3c3 1143 *
cassyarduino 0:e3fb1267e3c3 1144 * When sending packets, the device driver should use the contents of
cassyarduino 0:e3fb1267e3c3 1145 * the uip_len variable to determine the length of the outgoing
cassyarduino 0:e3fb1267e3c3 1146 * packet.
cassyarduino 0:e3fb1267e3c3 1147 *
cassyarduino 0:e3fb1267e3c3 1148 */
cassyarduino 0:e3fb1267e3c3 1149 extern u16_t uip_len;
cassyarduino 0:e3fb1267e3c3 1150
cassyarduino 0:e3fb1267e3c3 1151 /** @} */
cassyarduino 0:e3fb1267e3c3 1152
cassyarduino 0:e3fb1267e3c3 1153 #if UIP_URGDATA > 0
cassyarduino 0:e3fb1267e3c3 1154 extern u16_t uip_urglen, uip_surglen;
cassyarduino 0:e3fb1267e3c3 1155 #endif /* UIP_URGDATA > 0 */
cassyarduino 0:e3fb1267e3c3 1156
cassyarduino 0:e3fb1267e3c3 1157
cassyarduino 0:e3fb1267e3c3 1158 /**
cassyarduino 0:e3fb1267e3c3 1159 * Representation of a uIP TCP connection.
cassyarduino 0:e3fb1267e3c3 1160 *
cassyarduino 0:e3fb1267e3c3 1161 * The uip_conn structure is used for identifying a connection. All
cassyarduino 0:e3fb1267e3c3 1162 * but one field in the structure are to be considered read-only by an
cassyarduino 0:e3fb1267e3c3 1163 * application. The only exception is the appstate field whos purpose
cassyarduino 0:e3fb1267e3c3 1164 * is to let the application store application-specific state (e.g.,
cassyarduino 0:e3fb1267e3c3 1165 * file pointers) for the connection. The type of this field is
cassyarduino 0:e3fb1267e3c3 1166 * configured in the "uipopt.h" header file.
cassyarduino 0:e3fb1267e3c3 1167 */
cassyarduino 0:e3fb1267e3c3 1168 struct uip_conn {
cassyarduino 0:e3fb1267e3c3 1169 uip_ipaddr_t ripaddr; /**< The IP address of the remote host. */
cassyarduino 0:e3fb1267e3c3 1170
cassyarduino 0:e3fb1267e3c3 1171 u16_t lport; /**< The local TCP port, in network byte order. */
cassyarduino 0:e3fb1267e3c3 1172 u16_t rport; /**< The local remote TCP port, in network byte
cassyarduino 0:e3fb1267e3c3 1173 order. */
cassyarduino 0:e3fb1267e3c3 1174
cassyarduino 0:e3fb1267e3c3 1175 u8_t rcv_nxt[4]; /**< The sequence number that we expect to
cassyarduino 0:e3fb1267e3c3 1176 receive next. */
cassyarduino 0:e3fb1267e3c3 1177 u8_t snd_nxt[4]; /**< The sequence number that was last sent by
cassyarduino 0:e3fb1267e3c3 1178 us. */
cassyarduino 0:e3fb1267e3c3 1179 u16_t len; /**< Length of the data that was previously sent. */
cassyarduino 0:e3fb1267e3c3 1180 u16_t mss; /**< Current maximum segment size for the
cassyarduino 0:e3fb1267e3c3 1181 connection. */
cassyarduino 0:e3fb1267e3c3 1182 u16_t initialmss; /**< Initial maximum segment size for the
cassyarduino 0:e3fb1267e3c3 1183 connection. */
cassyarduino 0:e3fb1267e3c3 1184 u8_t sa; /**< Retransmission time-out calculation state
cassyarduino 0:e3fb1267e3c3 1185 variable. */
cassyarduino 0:e3fb1267e3c3 1186 u8_t sv; /**< Retransmission time-out calculation state
cassyarduino 0:e3fb1267e3c3 1187 variable. */
cassyarduino 0:e3fb1267e3c3 1188 u8_t rto; /**< Retransmission time-out. */
cassyarduino 0:e3fb1267e3c3 1189 u8_t tcpstateflags; /**< TCP state and flags. */
cassyarduino 0:e3fb1267e3c3 1190 u8_t timer; /**< The retransmission timer. */
cassyarduino 0:e3fb1267e3c3 1191 u8_t nrtx; /**< The number of retransmissions for the last
cassyarduino 0:e3fb1267e3c3 1192 segment sent. */
cassyarduino 0:e3fb1267e3c3 1193
cassyarduino 0:e3fb1267e3c3 1194 /** The application state. */
cassyarduino 0:e3fb1267e3c3 1195 uip_tcp_appstate_t appstate;
cassyarduino 0:e3fb1267e3c3 1196 };
cassyarduino 0:e3fb1267e3c3 1197
cassyarduino 0:e3fb1267e3c3 1198
cassyarduino 0:e3fb1267e3c3 1199 /**
cassyarduino 0:e3fb1267e3c3 1200 * Pointer to the current TCP connection.
cassyarduino 0:e3fb1267e3c3 1201 *
cassyarduino 0:e3fb1267e3c3 1202 * The uip_conn pointer can be used to access the current TCP
cassyarduino 0:e3fb1267e3c3 1203 * connection.
cassyarduino 0:e3fb1267e3c3 1204 */
cassyarduino 0:e3fb1267e3c3 1205 extern struct uip_conn *uip_conn;
cassyarduino 0:e3fb1267e3c3 1206 /* The array containing all uIP connections. */
cassyarduino 0:e3fb1267e3c3 1207 extern struct uip_conn uip_conns[UIP_CONNS];
cassyarduino 0:e3fb1267e3c3 1208 /**
cassyarduino 0:e3fb1267e3c3 1209 * \addtogroup uiparch
cassyarduino 0:e3fb1267e3c3 1210 * @{
cassyarduino 0:e3fb1267e3c3 1211 */
cassyarduino 0:e3fb1267e3c3 1212
cassyarduino 0:e3fb1267e3c3 1213 /**
cassyarduino 0:e3fb1267e3c3 1214 * 4-byte array used for the 32-bit sequence number calculations.
cassyarduino 0:e3fb1267e3c3 1215 */
cassyarduino 0:e3fb1267e3c3 1216 extern u8_t uip_acc32[4];
cassyarduino 0:e3fb1267e3c3 1217
cassyarduino 0:e3fb1267e3c3 1218 /** @} */
cassyarduino 0:e3fb1267e3c3 1219
cassyarduino 0:e3fb1267e3c3 1220
cassyarduino 0:e3fb1267e3c3 1221 #if UIP_UDP
cassyarduino 0:e3fb1267e3c3 1222 /**
cassyarduino 0:e3fb1267e3c3 1223 * Representation of a uIP UDP connection.
cassyarduino 0:e3fb1267e3c3 1224 */
cassyarduino 0:e3fb1267e3c3 1225 struct uip_udp_conn {
cassyarduino 0:e3fb1267e3c3 1226 uip_ipaddr_t ripaddr; /**< The IP address of the remote peer. */
cassyarduino 0:e3fb1267e3c3 1227 u16_t lport; /**< The local port number in network byte order. */
cassyarduino 0:e3fb1267e3c3 1228 u16_t rport; /**< The remote port number in network byte order. */
cassyarduino 0:e3fb1267e3c3 1229 u8_t ttl; /**< Default time-to-live. */
cassyarduino 0:e3fb1267e3c3 1230
cassyarduino 0:e3fb1267e3c3 1231 /** The application state. */
cassyarduino 0:e3fb1267e3c3 1232 uip_udp_appstate_t appstate;
cassyarduino 0:e3fb1267e3c3 1233 };
cassyarduino 0:e3fb1267e3c3 1234
cassyarduino 0:e3fb1267e3c3 1235 /**
cassyarduino 0:e3fb1267e3c3 1236 * The current UDP connection.
cassyarduino 0:e3fb1267e3c3 1237 */
cassyarduino 0:e3fb1267e3c3 1238 extern struct uip_udp_conn *uip_udp_conn;
cassyarduino 0:e3fb1267e3c3 1239 extern struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
cassyarduino 0:e3fb1267e3c3 1240 #endif /* UIP_UDP */
cassyarduino 0:e3fb1267e3c3 1241
cassyarduino 0:e3fb1267e3c3 1242 /**
cassyarduino 0:e3fb1267e3c3 1243 * The structure holding the TCP/IP statistics that are gathered if
cassyarduino 0:e3fb1267e3c3 1244 * UIP_STATISTICS is set to 1.
cassyarduino 0:e3fb1267e3c3 1245 *
cassyarduino 0:e3fb1267e3c3 1246 */
cassyarduino 0:e3fb1267e3c3 1247 struct uip_stats {
cassyarduino 0:e3fb1267e3c3 1248 struct {
cassyarduino 0:e3fb1267e3c3 1249 uip_stats_t drop; /**< Number of dropped packets at the IP
cassyarduino 0:e3fb1267e3c3 1250 layer. */
cassyarduino 0:e3fb1267e3c3 1251 uip_stats_t recv; /**< Number of received packets at the IP
cassyarduino 0:e3fb1267e3c3 1252 layer. */
cassyarduino 0:e3fb1267e3c3 1253 uip_stats_t sent; /**< Number of sent packets at the IP
cassyarduino 0:e3fb1267e3c3 1254 layer. */
cassyarduino 0:e3fb1267e3c3 1255 uip_stats_t vhlerr; /**< Number of packets dropped due to wrong
cassyarduino 0:e3fb1267e3c3 1256 IP version or header length. */
cassyarduino 0:e3fb1267e3c3 1257 uip_stats_t hblenerr; /**< Number of packets dropped due to wrong
cassyarduino 0:e3fb1267e3c3 1258 IP length, high byte. */
cassyarduino 0:e3fb1267e3c3 1259 uip_stats_t lblenerr; /**< Number of packets dropped due to wrong
cassyarduino 0:e3fb1267e3c3 1260 IP length, low byte. */
cassyarduino 0:e3fb1267e3c3 1261 uip_stats_t fragerr; /**< Number of packets dropped since they
cassyarduino 0:e3fb1267e3c3 1262 were IP fragments. */
cassyarduino 0:e3fb1267e3c3 1263 uip_stats_t chkerr; /**< Number of packets dropped due to IP
cassyarduino 0:e3fb1267e3c3 1264 checksum errors. */
cassyarduino 0:e3fb1267e3c3 1265 uip_stats_t protoerr; /**< Number of packets dropped since they
cassyarduino 0:e3fb1267e3c3 1266 were neither ICMP, UDP nor TCP. */
cassyarduino 0:e3fb1267e3c3 1267 } ip; /**< IP statistics. */
cassyarduino 0:e3fb1267e3c3 1268 struct {
cassyarduino 0:e3fb1267e3c3 1269 uip_stats_t drop; /**< Number of dropped ICMP packets. */
cassyarduino 0:e3fb1267e3c3 1270 uip_stats_t recv; /**< Number of received ICMP packets. */
cassyarduino 0:e3fb1267e3c3 1271 uip_stats_t sent; /**< Number of sent ICMP packets. */
cassyarduino 0:e3fb1267e3c3 1272 uip_stats_t typeerr; /**< Number of ICMP packets with a wrong
cassyarduino 0:e3fb1267e3c3 1273 type. */
cassyarduino 0:e3fb1267e3c3 1274 } icmp; /**< ICMP statistics. */
cassyarduino 0:e3fb1267e3c3 1275 struct {
cassyarduino 0:e3fb1267e3c3 1276 uip_stats_t drop; /**< Number of dropped TCP segments. */
cassyarduino 0:e3fb1267e3c3 1277 uip_stats_t recv; /**< Number of recived TCP segments. */
cassyarduino 0:e3fb1267e3c3 1278 uip_stats_t sent; /**< Number of sent TCP segments. */
cassyarduino 0:e3fb1267e3c3 1279 uip_stats_t chkerr; /**< Number of TCP segments with a bad
cassyarduino 0:e3fb1267e3c3 1280 checksum. */
cassyarduino 0:e3fb1267e3c3 1281 uip_stats_t ackerr; /**< Number of TCP segments with a bad ACK
cassyarduino 0:e3fb1267e3c3 1282 number. */
cassyarduino 0:e3fb1267e3c3 1283 uip_stats_t rst; /**< Number of recevied TCP RST (reset) segments. */
cassyarduino 0:e3fb1267e3c3 1284 uip_stats_t rexmit; /**< Number of retransmitted TCP segments. */
cassyarduino 0:e3fb1267e3c3 1285 uip_stats_t syndrop; /**< Number of dropped SYNs due to too few
cassyarduino 0:e3fb1267e3c3 1286 connections was avaliable. */
cassyarduino 0:e3fb1267e3c3 1287 uip_stats_t synrst; /**< Number of SYNs for closed ports,
cassyarduino 0:e3fb1267e3c3 1288 triggering a RST. */
cassyarduino 0:e3fb1267e3c3 1289 } tcp; /**< TCP statistics. */
cassyarduino 0:e3fb1267e3c3 1290 #if UIP_UDP
cassyarduino 0:e3fb1267e3c3 1291 struct {
cassyarduino 0:e3fb1267e3c3 1292 uip_stats_t drop; /**< Number of dropped UDP segments. */
cassyarduino 0:e3fb1267e3c3 1293 uip_stats_t recv; /**< Number of recived UDP segments. */
cassyarduino 0:e3fb1267e3c3 1294 uip_stats_t sent; /**< Number of sent UDP segments. */
cassyarduino 0:e3fb1267e3c3 1295 uip_stats_t chkerr; /**< Number of UDP segments with a bad
cassyarduino 0:e3fb1267e3c3 1296 checksum. */
cassyarduino 0:e3fb1267e3c3 1297 } udp; /**< UDP statistics. */
cassyarduino 0:e3fb1267e3c3 1298 #endif /* UIP_UDP */
cassyarduino 0:e3fb1267e3c3 1299 };
cassyarduino 0:e3fb1267e3c3 1300
cassyarduino 0:e3fb1267e3c3 1301 /**
cassyarduino 0:e3fb1267e3c3 1302 * The uIP TCP/IP statistics.
cassyarduino 0:e3fb1267e3c3 1303 *
cassyarduino 0:e3fb1267e3c3 1304 * This is the variable in which the uIP TCP/IP statistics are gathered.
cassyarduino 0:e3fb1267e3c3 1305 */
cassyarduino 0:e3fb1267e3c3 1306 extern struct uip_stats uip_stat;
cassyarduino 0:e3fb1267e3c3 1307
cassyarduino 0:e3fb1267e3c3 1308
cassyarduino 0:e3fb1267e3c3 1309 /*---------------------------------------------------------------------------*/
cassyarduino 0:e3fb1267e3c3 1310 /* All the stuff below this point is internal to uIP and should not be
cassyarduino 0:e3fb1267e3c3 1311 * used directly by an application or by a device driver.
cassyarduino 0:e3fb1267e3c3 1312 */
cassyarduino 0:e3fb1267e3c3 1313 /*---------------------------------------------------------------------------*/
cassyarduino 0:e3fb1267e3c3 1314 /* u8_t uip_flags:
cassyarduino 0:e3fb1267e3c3 1315 *
cassyarduino 0:e3fb1267e3c3 1316 * When the application is called, uip_flags will contain the flags
cassyarduino 0:e3fb1267e3c3 1317 * that are defined in this file. Please read below for more
cassyarduino 0:e3fb1267e3c3 1318 * infomation.
cassyarduino 0:e3fb1267e3c3 1319 */
cassyarduino 0:e3fb1267e3c3 1320 extern u8_t uip_flags;
cassyarduino 0:e3fb1267e3c3 1321
cassyarduino 0:e3fb1267e3c3 1322 /* The following flags may be set in the global variable uip_flags
cassyarduino 0:e3fb1267e3c3 1323 before calling the application callback. The UIP_ACKDATA,
cassyarduino 0:e3fb1267e3c3 1324 UIP_NEWDATA, and UIP_CLOSE flags may both be set at the same time,
cassyarduino 0:e3fb1267e3c3 1325 whereas the others are mutualy exclusive. Note that these flags
cassyarduino 0:e3fb1267e3c3 1326 should *NOT* be accessed directly, but only through the uIP
cassyarduino 0:e3fb1267e3c3 1327 functions/macros. */
cassyarduino 0:e3fb1267e3c3 1328
cassyarduino 0:e3fb1267e3c3 1329 #define UIP_ACKDATA 1 /* Signifies that the outstanding data was
cassyarduino 0:e3fb1267e3c3 1330 acked and the application should send
cassyarduino 0:e3fb1267e3c3 1331 out new data instead of retransmitting
cassyarduino 0:e3fb1267e3c3 1332 the last data. */
cassyarduino 0:e3fb1267e3c3 1333 #define UIP_NEWDATA 2 /* Flags the fact that the peer has sent
cassyarduino 0:e3fb1267e3c3 1334 us new data. */
cassyarduino 0:e3fb1267e3c3 1335 #define UIP_REXMIT 4 /* Tells the application to retransmit the
cassyarduino 0:e3fb1267e3c3 1336 data that was last sent. */
cassyarduino 0:e3fb1267e3c3 1337 #define UIP_POLL 8 /* Used for polling the application, to
cassyarduino 0:e3fb1267e3c3 1338 check if the application has data that
cassyarduino 0:e3fb1267e3c3 1339 it wants to send. */
cassyarduino 0:e3fb1267e3c3 1340 #define UIP_CLOSE 16 /* The remote host has closed the
cassyarduino 0:e3fb1267e3c3 1341 connection, thus the connection has
cassyarduino 0:e3fb1267e3c3 1342 gone away. Or the application signals
cassyarduino 0:e3fb1267e3c3 1343 that it wants to close the
cassyarduino 0:e3fb1267e3c3 1344 connection. */
cassyarduino 0:e3fb1267e3c3 1345 #define UIP_ABORT 32 /* The remote host has aborted the
cassyarduino 0:e3fb1267e3c3 1346 connection, thus the connection has
cassyarduino 0:e3fb1267e3c3 1347 gone away. Or the application signals
cassyarduino 0:e3fb1267e3c3 1348 that it wants to abort the
cassyarduino 0:e3fb1267e3c3 1349 connection. */
cassyarduino 0:e3fb1267e3c3 1350 #define UIP_CONNECTED 64 /* We have got a connection from a remote
cassyarduino 0:e3fb1267e3c3 1351 host and have set up a new connection
cassyarduino 0:e3fb1267e3c3 1352 for it, or an active connection has
cassyarduino 0:e3fb1267e3c3 1353 been successfully established. */
cassyarduino 0:e3fb1267e3c3 1354
cassyarduino 0:e3fb1267e3c3 1355 #define UIP_TIMEDOUT 128 /* The connection has been aborted due to
cassyarduino 0:e3fb1267e3c3 1356 too many retransmissions. */
cassyarduino 0:e3fb1267e3c3 1357
cassyarduino 0:e3fb1267e3c3 1358 /* uip_process(flag):
cassyarduino 0:e3fb1267e3c3 1359 *
cassyarduino 0:e3fb1267e3c3 1360 * The actual uIP function which does all the work.
cassyarduino 0:e3fb1267e3c3 1361 */
cassyarduino 0:e3fb1267e3c3 1362 void uip_process(u8_t flag);
cassyarduino 0:e3fb1267e3c3 1363
cassyarduino 0:e3fb1267e3c3 1364 /* The following flags are passed as an argument to the uip_process()
cassyarduino 0:e3fb1267e3c3 1365 function. They are used to distinguish between the two cases where
cassyarduino 0:e3fb1267e3c3 1366 uip_process() is called. It can be called either because we have
cassyarduino 0:e3fb1267e3c3 1367 incoming data that should be processed, or because the periodic
cassyarduino 0:e3fb1267e3c3 1368 timer has fired. These values are never used directly, but only in
cassyarduino 0:e3fb1267e3c3 1369 the macrose defined in this file. */
cassyarduino 0:e3fb1267e3c3 1370
cassyarduino 0:e3fb1267e3c3 1371 #define UIP_DATA 1 /* Tells uIP that there is incoming
cassyarduino 0:e3fb1267e3c3 1372 data in the uip_buf buffer. The
cassyarduino 0:e3fb1267e3c3 1373 length of the data is stored in the
cassyarduino 0:e3fb1267e3c3 1374 global variable uip_len. */
cassyarduino 0:e3fb1267e3c3 1375 #define UIP_TIMER 2 /* Tells uIP that the periodic timer
cassyarduino 0:e3fb1267e3c3 1376 has fired. */
cassyarduino 0:e3fb1267e3c3 1377 #define UIP_POLL_REQUEST 3 /* Tells uIP that a connection should
cassyarduino 0:e3fb1267e3c3 1378 be polled. */
cassyarduino 0:e3fb1267e3c3 1379 #define UIP_UDP_SEND_CONN 4 /* Tells uIP that a UDP datagram
cassyarduino 0:e3fb1267e3c3 1380 should be constructed in the
cassyarduino 0:e3fb1267e3c3 1381 uip_buf buffer. */
cassyarduino 0:e3fb1267e3c3 1382 #if UIP_UDP
cassyarduino 0:e3fb1267e3c3 1383 #define UIP_UDP_TIMER 5
cassyarduino 0:e3fb1267e3c3 1384 #endif /* UIP_UDP */
cassyarduino 0:e3fb1267e3c3 1385
cassyarduino 0:e3fb1267e3c3 1386 /* The TCP states used in the uip_conn->tcpstateflags. */
cassyarduino 0:e3fb1267e3c3 1387 #define UIP_CLOSED 0
cassyarduino 0:e3fb1267e3c3 1388 #define UIP_SYN_RCVD 1
cassyarduino 0:e3fb1267e3c3 1389 #define UIP_SYN_SENT 2
cassyarduino 0:e3fb1267e3c3 1390 #define UIP_ESTABLISHED 3
cassyarduino 0:e3fb1267e3c3 1391 #define UIP_FIN_WAIT_1 4
cassyarduino 0:e3fb1267e3c3 1392 #define UIP_FIN_WAIT_2 5
cassyarduino 0:e3fb1267e3c3 1393 #define UIP_CLOSING 6
cassyarduino 0:e3fb1267e3c3 1394 #define UIP_TIME_WAIT 7
cassyarduino 0:e3fb1267e3c3 1395 #define UIP_LAST_ACK 8
cassyarduino 0:e3fb1267e3c3 1396 #define UIP_TS_MASK 15
cassyarduino 0:e3fb1267e3c3 1397
cassyarduino 0:e3fb1267e3c3 1398 #define UIP_STOPPED 16
cassyarduino 0:e3fb1267e3c3 1399
cassyarduino 0:e3fb1267e3c3 1400 /* The TCP and IP headers. */
cassyarduino 0:e3fb1267e3c3 1401 struct uip_tcpip_hdr {
cassyarduino 0:e3fb1267e3c3 1402 #if UIP_CONF_IPV6
cassyarduino 0:e3fb1267e3c3 1403 /* IPv6 header. */
cassyarduino 0:e3fb1267e3c3 1404 u8_t vtc,
cassyarduino 0:e3fb1267e3c3 1405 tcflow;
cassyarduino 0:e3fb1267e3c3 1406 u16_t flow;
cassyarduino 0:e3fb1267e3c3 1407 u8_t len[2];
cassyarduino 0:e3fb1267e3c3 1408 u8_t proto, ttl;
cassyarduino 0:e3fb1267e3c3 1409 uip_ip6addr_t srcipaddr, destipaddr;
cassyarduino 0:e3fb1267e3c3 1410 #else /* UIP_CONF_IPV6 */
cassyarduino 0:e3fb1267e3c3 1411 /* IPv4 header. */
cassyarduino 0:e3fb1267e3c3 1412 u8_t vhl,
cassyarduino 0:e3fb1267e3c3 1413 tos,
cassyarduino 0:e3fb1267e3c3 1414 len[2],
cassyarduino 0:e3fb1267e3c3 1415 ipid[2],
cassyarduino 0:e3fb1267e3c3 1416 ipoffset[2],
cassyarduino 0:e3fb1267e3c3 1417 ttl,
cassyarduino 0:e3fb1267e3c3 1418 proto;
cassyarduino 0:e3fb1267e3c3 1419 u16_t ipchksum;
cassyarduino 0:e3fb1267e3c3 1420 u16_t srcipaddr[2],
cassyarduino 0:e3fb1267e3c3 1421 destipaddr[2];
cassyarduino 0:e3fb1267e3c3 1422 #endif /* UIP_CONF_IPV6 */
cassyarduino 0:e3fb1267e3c3 1423
cassyarduino 0:e3fb1267e3c3 1424 /* TCP header. */
cassyarduino 0:e3fb1267e3c3 1425 u16_t srcport,
cassyarduino 0:e3fb1267e3c3 1426 destport;
cassyarduino 0:e3fb1267e3c3 1427 u8_t seqno[4],
cassyarduino 0:e3fb1267e3c3 1428 ackno[4],
cassyarduino 0:e3fb1267e3c3 1429 tcpoffset,
cassyarduino 0:e3fb1267e3c3 1430 flags,
cassyarduino 0:e3fb1267e3c3 1431 wnd[2];
cassyarduino 0:e3fb1267e3c3 1432 u16_t tcpchksum;
cassyarduino 0:e3fb1267e3c3 1433 u8_t urgp[2];
cassyarduino 0:e3fb1267e3c3 1434 u8_t optdata[4];
cassyarduino 0:e3fb1267e3c3 1435 };
cassyarduino 0:e3fb1267e3c3 1436
cassyarduino 0:e3fb1267e3c3 1437 /* The ICMP and IP headers. */
cassyarduino 0:e3fb1267e3c3 1438 struct uip_icmpip_hdr {
cassyarduino 0:e3fb1267e3c3 1439 #if UIP_CONF_IPV6
cassyarduino 0:e3fb1267e3c3 1440 /* IPv6 header. */
cassyarduino 0:e3fb1267e3c3 1441 u8_t vtc,
cassyarduino 0:e3fb1267e3c3 1442 tcf;
cassyarduino 0:e3fb1267e3c3 1443 u16_t flow;
cassyarduino 0:e3fb1267e3c3 1444 u8_t len[2];
cassyarduino 0:e3fb1267e3c3 1445 u8_t proto, ttl;
cassyarduino 0:e3fb1267e3c3 1446 uip_ip6addr_t srcipaddr, destipaddr;
cassyarduino 0:e3fb1267e3c3 1447 #else /* UIP_CONF_IPV6 */
cassyarduino 0:e3fb1267e3c3 1448 /* IPv4 header. */
cassyarduino 0:e3fb1267e3c3 1449 u8_t vhl,
cassyarduino 0:e3fb1267e3c3 1450 tos,
cassyarduino 0:e3fb1267e3c3 1451 len[2],
cassyarduino 0:e3fb1267e3c3 1452 ipid[2],
cassyarduino 0:e3fb1267e3c3 1453 ipoffset[2],
cassyarduino 0:e3fb1267e3c3 1454 ttl,
cassyarduino 0:e3fb1267e3c3 1455 proto;
cassyarduino 0:e3fb1267e3c3 1456 u16_t ipchksum;
cassyarduino 0:e3fb1267e3c3 1457 u16_t srcipaddr[2],
cassyarduino 0:e3fb1267e3c3 1458 destipaddr[2];
cassyarduino 0:e3fb1267e3c3 1459 #endif /* UIP_CONF_IPV6 */
cassyarduino 0:e3fb1267e3c3 1460
cassyarduino 0:e3fb1267e3c3 1461 /* ICMP (echo) header. */
cassyarduino 0:e3fb1267e3c3 1462 u8_t type, icode;
cassyarduino 0:e3fb1267e3c3 1463 u16_t icmpchksum;
cassyarduino 0:e3fb1267e3c3 1464 #if !UIP_CONF_IPV6
cassyarduino 0:e3fb1267e3c3 1465 u16_t id, seqno;
cassyarduino 0:e3fb1267e3c3 1466 #else /* !UIP_CONF_IPV6 */
cassyarduino 0:e3fb1267e3c3 1467 u8_t flags, reserved1, reserved2, reserved3;
cassyarduino 0:e3fb1267e3c3 1468 u8_t icmp6data[16];
cassyarduino 0:e3fb1267e3c3 1469 u8_t options[1];
cassyarduino 0:e3fb1267e3c3 1470 #endif /* !UIP_CONF_IPV6 */
cassyarduino 0:e3fb1267e3c3 1471 };
cassyarduino 0:e3fb1267e3c3 1472
cassyarduino 0:e3fb1267e3c3 1473
cassyarduino 0:e3fb1267e3c3 1474 /* The UDP and IP headers. */
cassyarduino 0:e3fb1267e3c3 1475 struct uip_udpip_hdr {
cassyarduino 0:e3fb1267e3c3 1476 #if UIP_CONF_IPV6
cassyarduino 0:e3fb1267e3c3 1477 /* IPv6 header. */
cassyarduino 0:e3fb1267e3c3 1478 u8_t vtc,
cassyarduino 0:e3fb1267e3c3 1479 tcf;
cassyarduino 0:e3fb1267e3c3 1480 u16_t flow;
cassyarduino 0:e3fb1267e3c3 1481 u8_t len[2];
cassyarduino 0:e3fb1267e3c3 1482 u8_t proto, ttl;
cassyarduino 0:e3fb1267e3c3 1483 uip_ip6addr_t srcipaddr, destipaddr;
cassyarduino 0:e3fb1267e3c3 1484 #else /* UIP_CONF_IPV6 */
cassyarduino 0:e3fb1267e3c3 1485 /* IP header. */
cassyarduino 0:e3fb1267e3c3 1486 u8_t vhl,
cassyarduino 0:e3fb1267e3c3 1487 tos,
cassyarduino 0:e3fb1267e3c3 1488 len[2],
cassyarduino 0:e3fb1267e3c3 1489 ipid[2],
cassyarduino 0:e3fb1267e3c3 1490 ipoffset[2],
cassyarduino 0:e3fb1267e3c3 1491 ttl,
cassyarduino 0:e3fb1267e3c3 1492 proto;
cassyarduino 0:e3fb1267e3c3 1493 u16_t ipchksum;
cassyarduino 0:e3fb1267e3c3 1494 u16_t srcipaddr[2],
cassyarduino 0:e3fb1267e3c3 1495 destipaddr[2];
cassyarduino 0:e3fb1267e3c3 1496 #endif /* UIP_CONF_IPV6 */
cassyarduino 0:e3fb1267e3c3 1497
cassyarduino 0:e3fb1267e3c3 1498 /* UDP header. */
cassyarduino 0:e3fb1267e3c3 1499 u16_t srcport,
cassyarduino 0:e3fb1267e3c3 1500 destport;
cassyarduino 0:e3fb1267e3c3 1501 u16_t udplen;
cassyarduino 0:e3fb1267e3c3 1502 u16_t udpchksum;
cassyarduino 0:e3fb1267e3c3 1503 };
cassyarduino 0:e3fb1267e3c3 1504
cassyarduino 0:e3fb1267e3c3 1505
cassyarduino 0:e3fb1267e3c3 1506
cassyarduino 0:e3fb1267e3c3 1507 /**
cassyarduino 0:e3fb1267e3c3 1508 * The buffer size available for user data in the \ref uip_buf buffer.
cassyarduino 0:e3fb1267e3c3 1509 *
cassyarduino 0:e3fb1267e3c3 1510 * This macro holds the available size for user data in the \ref
cassyarduino 0:e3fb1267e3c3 1511 * uip_buf buffer. The macro is intended to be used for checking
cassyarduino 0:e3fb1267e3c3 1512 * bounds of available user data.
cassyarduino 0:e3fb1267e3c3 1513 *
cassyarduino 0:e3fb1267e3c3 1514 * Example:
cassyarduino 0:e3fb1267e3c3 1515 \code
cassyarduino 0:e3fb1267e3c3 1516 snprintf(uip_appdata, UIP_APPDATA_SIZE, "%u\n", i);
cassyarduino 0:e3fb1267e3c3 1517 \endcode
cassyarduino 0:e3fb1267e3c3 1518 *
cassyarduino 0:e3fb1267e3c3 1519 * \hideinitializer
cassyarduino 0:e3fb1267e3c3 1520 */
cassyarduino 0:e3fb1267e3c3 1521 #define UIP_APPDATA_SIZE (UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN)
cassyarduino 0:e3fb1267e3c3 1522
cassyarduino 0:e3fb1267e3c3 1523
cassyarduino 0:e3fb1267e3c3 1524 #define UIP_PROTO_ICMP 1
cassyarduino 0:e3fb1267e3c3 1525 #define UIP_PROTO_TCP 6
cassyarduino 0:e3fb1267e3c3 1526 #define UIP_PROTO_UDP 17
cassyarduino 0:e3fb1267e3c3 1527 #define UIP_PROTO_ICMP6 58
cassyarduino 0:e3fb1267e3c3 1528
cassyarduino 0:e3fb1267e3c3 1529 /* Header sizes. */
cassyarduino 0:e3fb1267e3c3 1530 #if UIP_CONF_IPV6
cassyarduino 0:e3fb1267e3c3 1531 #define UIP_IPH_LEN 40
cassyarduino 0:e3fb1267e3c3 1532 #else /* UIP_CONF_IPV6 */
cassyarduino 0:e3fb1267e3c3 1533 #define UIP_IPH_LEN 20 /* Size of IP header */
cassyarduino 0:e3fb1267e3c3 1534 #endif /* UIP_CONF_IPV6 */
cassyarduino 0:e3fb1267e3c3 1535 #define UIP_UDPH_LEN 8 /* Size of UDP header */
cassyarduino 0:e3fb1267e3c3 1536 #define UIP_TCPH_LEN 20 /* Size of TCP header */
cassyarduino 0:e3fb1267e3c3 1537 #define UIP_IPUDPH_LEN (UIP_UDPH_LEN + UIP_IPH_LEN) /* Size of IP +
cassyarduino 0:e3fb1267e3c3 1538 UDP
cassyarduino 0:e3fb1267e3c3 1539 header */
cassyarduino 0:e3fb1267e3c3 1540 #define UIP_IPTCPH_LEN (UIP_TCPH_LEN + UIP_IPH_LEN) /* Size of IP +
cassyarduino 0:e3fb1267e3c3 1541 TCP
cassyarduino 0:e3fb1267e3c3 1542 header */
cassyarduino 0:e3fb1267e3c3 1543 #define UIP_TCPIP_HLEN UIP_IPTCPH_LEN
cassyarduino 0:e3fb1267e3c3 1544
cassyarduino 0:e3fb1267e3c3 1545
cassyarduino 0:e3fb1267e3c3 1546 #if UIP_FIXEDADDR
cassyarduino 0:e3fb1267e3c3 1547 extern const uip_ipaddr_t uip_hostaddr, uip_netmask, uip_draddr;
cassyarduino 0:e3fb1267e3c3 1548 #else /* UIP_FIXEDADDR */
cassyarduino 0:e3fb1267e3c3 1549 extern uip_ipaddr_t uip_hostaddr, uip_netmask, uip_draddr;
cassyarduino 0:e3fb1267e3c3 1550 #endif /* UIP_FIXEDADDR */
cassyarduino 0:e3fb1267e3c3 1551
cassyarduino 0:e3fb1267e3c3 1552
cassyarduino 0:e3fb1267e3c3 1553
cassyarduino 0:e3fb1267e3c3 1554 /**
cassyarduino 0:e3fb1267e3c3 1555 * Representation of a 48-bit Ethernet address.
cassyarduino 0:e3fb1267e3c3 1556 */
cassyarduino 0:e3fb1267e3c3 1557 struct uip_eth_addr {
cassyarduino 0:e3fb1267e3c3 1558 u8_t addr[6];
cassyarduino 0:e3fb1267e3c3 1559 };
cassyarduino 0:e3fb1267e3c3 1560
cassyarduino 0:e3fb1267e3c3 1561 /**
cassyarduino 0:e3fb1267e3c3 1562 * Calculate the Internet checksum over a buffer.
cassyarduino 0:e3fb1267e3c3 1563 *
cassyarduino 0:e3fb1267e3c3 1564 * The Internet checksum is the one's complement of the one's
cassyarduino 0:e3fb1267e3c3 1565 * complement sum of all 16-bit words in the buffer.
cassyarduino 0:e3fb1267e3c3 1566 *
cassyarduino 0:e3fb1267e3c3 1567 * See RFC1071.
cassyarduino 0:e3fb1267e3c3 1568 *
cassyarduino 0:e3fb1267e3c3 1569 * \param buf A pointer to the buffer over which the checksum is to be
cassyarduino 0:e3fb1267e3c3 1570 * computed.
cassyarduino 0:e3fb1267e3c3 1571 *
cassyarduino 0:e3fb1267e3c3 1572 * \param len The length of the buffer over which the checksum is to
cassyarduino 0:e3fb1267e3c3 1573 * be computed.
cassyarduino 0:e3fb1267e3c3 1574 *
cassyarduino 0:e3fb1267e3c3 1575 * \return The Internet checksum of the buffer.
cassyarduino 0:e3fb1267e3c3 1576 */
cassyarduino 0:e3fb1267e3c3 1577 u16_t uip_chksum(u16_t *buf, u16_t len);
cassyarduino 0:e3fb1267e3c3 1578
cassyarduino 0:e3fb1267e3c3 1579 /**
cassyarduino 0:e3fb1267e3c3 1580 * Calculate the IP header checksum of the packet header in uip_buf.
cassyarduino 0:e3fb1267e3c3 1581 *
cassyarduino 0:e3fb1267e3c3 1582 * The IP header checksum is the Internet checksum of the 20 bytes of
cassyarduino 0:e3fb1267e3c3 1583 * the IP header.
cassyarduino 0:e3fb1267e3c3 1584 *
cassyarduino 0:e3fb1267e3c3 1585 * \return The IP header checksum of the IP header in the uip_buf
cassyarduino 0:e3fb1267e3c3 1586 * buffer.
cassyarduino 0:e3fb1267e3c3 1587 */
cassyarduino 0:e3fb1267e3c3 1588 u16_t uip_ipchksum(void);
cassyarduino 0:e3fb1267e3c3 1589
cassyarduino 0:e3fb1267e3c3 1590 /**
cassyarduino 0:e3fb1267e3c3 1591 * Calculate the TCP checksum of the packet in uip_buf and uip_appdata.
cassyarduino 0:e3fb1267e3c3 1592 *
cassyarduino 0:e3fb1267e3c3 1593 * The TCP checksum is the Internet checksum of data contents of the
cassyarduino 0:e3fb1267e3c3 1594 * TCP segment, and a pseudo-header as defined in RFC793.
cassyarduino 0:e3fb1267e3c3 1595 *
cassyarduino 0:e3fb1267e3c3 1596 * \return The TCP checksum of the TCP segment in uip_buf and pointed
cassyarduino 0:e3fb1267e3c3 1597 * to by uip_appdata.
cassyarduino 0:e3fb1267e3c3 1598 */
cassyarduino 0:e3fb1267e3c3 1599 u16_t uip_tcpchksum(void);
cassyarduino 0:e3fb1267e3c3 1600
cassyarduino 0:e3fb1267e3c3 1601 /**
cassyarduino 0:e3fb1267e3c3 1602 * Calculate the UDP checksum of the packet in uip_buf and uip_appdata.
cassyarduino 0:e3fb1267e3c3 1603 *
cassyarduino 0:e3fb1267e3c3 1604 * The UDP checksum is the Internet checksum of data contents of the
cassyarduino 0:e3fb1267e3c3 1605 * UDP segment, and a pseudo-header as defined in RFC768.
cassyarduino 0:e3fb1267e3c3 1606 *
cassyarduino 0:e3fb1267e3c3 1607 * \return The UDP checksum of the UDP segment in uip_buf and pointed
cassyarduino 0:e3fb1267e3c3 1608 * to by uip_appdata.
cassyarduino 0:e3fb1267e3c3 1609 */
cassyarduino 0:e3fb1267e3c3 1610 u16_t uip_udpchksum(void);
cassyarduino 0:e3fb1267e3c3 1611
cassyarduino 0:e3fb1267e3c3 1612
cassyarduino 0:e3fb1267e3c3 1613 #endif /* __UIP_H__ */
cassyarduino 0:e3fb1267e3c3 1614
cassyarduino 0:e3fb1267e3c3 1615
cassyarduino 0:e3fb1267e3c3 1616 /** @} */