blob: 3a3d62e0f11a06b0a7ea8ba2daf12ef2f6eae226 [file] [log] [blame]
adamdunkels1e45c6d2003-09-02 21:47:27 +00001/**
adamdunkels0170b082003-10-01 11:25:37 +00002 * \addtogroup uip
3 * @{
4 */
5
6/**
adamdunkels1e45c6d2003-09-02 21:47:27 +00007 * \file
8 * Header file for the uIP TCP/IP stack.
9 * \author Adam Dunkels <adam@dunkels.com>
10 *
11 * The uIP TCP/IP stack header file contains definitions for a number
12 * of C macros that are used by uIP programs as well as internal uIP
13 * structures, TCP/IP header structures and function declarations.
14 *
15 */
16
adamdunkels0170b082003-10-01 11:25:37 +000017
adamdunkelsca9ddcb2003-03-19 14:13:31 +000018/*
adamdunkels1e45c6d2003-09-02 21:47:27 +000019 * Copyright (c) 2001-2003, Adam Dunkels.
adamdunkelsca9ddcb2003-03-19 14:13:31 +000020 * All rights reserved.
21 *
22 * Redistribution and use in source and binary forms, with or without
23 * modification, are permitted provided that the following conditions
24 * are met:
25 * 1. Redistributions of source code must retain the above copyright
26 * notice, this list of conditions and the following disclaimer.
27 * 2. Redistributions in binary form must reproduce the above copyright
28 * notice, this list of conditions and the following disclaimer in the
29 * documentation and/or other materials provided with the distribution.
adamdunkels1e45c6d2003-09-02 21:47:27 +000030 * 3. The name of the author may not be used to endorse or promote
adamdunkelsca9ddcb2003-03-19 14:13:31 +000031 * products derived from this software without specific prior
32 * written permission.
33 *
34 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
35 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
36 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
38 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
40 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
41 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
42 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
43 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
44 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
45 *
46 * This file is part of the uIP TCP/IP stack.
47 *
oliverschmidt06b40b42006-05-17 15:25:15 +000048 * $Id: uip.h,v 1.20 2006/05/17 15:25:15 oliverschmidt Exp $
adamdunkelsca9ddcb2003-03-19 14:13:31 +000049 *
50 */
51
52#ifndef __UIP_H__
53#define __UIP_H__
54
55#include "uipopt.h"
56
adamdunkelsca9ddcb2003-03-19 14:13:31 +000057/*-----------------------------------------------------------------------------------*/
58/* First, the functions that should be called from the
59 * system. Initialization, the periodic timer and incoming packets are
60 * handled by the following three functions.
61 */
62
adamdunkels1e45c6d2003-09-02 21:47:27 +000063/**
adamdunkels0170b082003-10-01 11:25:37 +000064 * \defgroup uipconffunc uIP configuration functions
65 * @{
66 *
67 * The uIP configuration functions are used for setting run-time
68 * parameters in uIP such as IP addresses.
69 */
70
71/**
adamdunkels1e45c6d2003-09-02 21:47:27 +000072 * Set the IP address of this host.
adamdunkelsca9ddcb2003-03-19 14:13:31 +000073 *
adamdunkels1e45c6d2003-09-02 21:47:27 +000074 * The IP address is represented as a 4-byte array where the first
75 * octet of the IP address is put in the first member of the 4-byte
76 * array.
adamdunkelsca9ddcb2003-03-19 14:13:31 +000077 *
adamdunkels1e45c6d2003-09-02 21:47:27 +000078 * \param addr A pointer to a 4-byte representation of the IP address.
adamdunkelsb489e7a2003-10-14 11:12:50 +000079 *
80 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +000081 */
adamdunkels18076c62004-06-06 06:16:03 +000082#define uip_sethostaddr(addr) do { uip_hostaddr[0] = ((u16_t *)(addr))[0]; \
83 uip_hostaddr[1] = ((u16_t *)(addr))[1]; } while(0)
adamdunkelsca9ddcb2003-03-19 14:13:31 +000084
adamdunkels1e45c6d2003-09-02 21:47:27 +000085/**
86 * Get the IP address of this host.
adamdunkels66c6af62003-04-16 18:28:16 +000087 *
adamdunkels1e45c6d2003-09-02 21:47:27 +000088 * The IP address is represented as a 4-byte array where the first
89 * octet of the IP address is put in the first member of the 4-byte
90 * array.
91 *
92 * \param addr A pointer to a 4-byte array that will be filled in with
93 * the currently configured IP address.
adamdunkelsb489e7a2003-10-14 11:12:50 +000094 *
95 * \hideinitializer
adamdunkels66c6af62003-04-16 18:28:16 +000096 */
adamdunkels18076c62004-06-06 06:16:03 +000097#define uip_gethostaddr(addr) do { ((u16_t *)(addr))[0] = uip_hostaddr[0]; \
98 ((u16_t *)(addr))[1] = uip_hostaddr[1]; } while(0)
99
100/**
101 * Set the default router's IP address.
102 *
103 * \param addr A pointer to a 4-byte array containing the IP address
104 * of the default router.
105 *
106 * \hideinitializer
107 */
108#define uip_setdraddr(addr) do { uip_draddr[0] = ((u16_t *)(addr))[0]; \
109 uip_draddr[1] = ((u16_t *)(addr))[1]; } while(0)
110
111/**
112 * Set the netmask.
113 *
114 * \param addr A pointer to a 4-byte array containing the IP address
115 * of the netmask.
116 *
117 * \hideinitializer
118 */
119#define uip_setnetmask(addr) do { uip_netmask[0] = ((u16_t *)(addr))[0]; \
120 uip_netmask[1] = ((u16_t *)(addr))[1]; } while(0)
121
122
123/**
124 * Get the default router's IP address.
125 *
126 * \param addr A pointer to a 4-byte array that will be filled in with
127 * the IP address of the default router.
128 *
129 * \hideinitializer
130 */
131#define uip_getdraddr(addr) do { ((u16_t *)(addr))[0] = uip_draddr[0]; \
132 ((u16_t *)(addr))[1] = uip_draddr[1]; } while(0)
133
134/**
135 * Get the netmask.
136 *
137 * \param addr A pointer to a 4-byte array that will be filled in with
138 * the value of the netmask.
139 *
140 * \hideinitializer
141 */
142#define uip_getnetmask(addr) do { ((u16_t *)(addr))[0] = uip_netmask[0]; \
143 ((u16_t *)(addr))[1] = uip_netmask[1]; } while(0)
adamdunkels66c6af62003-04-16 18:28:16 +0000144
adamdunkels0170b082003-10-01 11:25:37 +0000145/** @} */
146
adamdunkelsb489e7a2003-10-14 11:12:50 +0000147/**
148 * \defgroup uipinit uIP initialization functions
149 * @{
150 *
151 * The uIP initialization functions are used for booting uIP.
152 */
adamdunkels0170b082003-10-01 11:25:37 +0000153
154/**
155 * uIP initialization function.
156 *
157 * This function should be called at boot up to initilize the uIP
158 * TCP/IP stack.
159 */
160void uip_init(void);
161
adamdunkelsb489e7a2003-10-14 11:12:50 +0000162/** @} */
163
adamdunkels0170b082003-10-01 11:25:37 +0000164/**
165 * \defgroup uipdevfunc uIP device driver functions
166 * @{
167 *
168 * These functions are used by a network device driver for interacting
169 * with uIP.
170 */
171
adamdunkels1e45c6d2003-09-02 21:47:27 +0000172/**
173 * Process an incoming packet.
174 *
175 * This function should be called when the device driver has received
176 * a packet from the network. The packet from the device driver must
177 * be present in the uip_buf buffer, and the length of the packet
178 * should be placed in the uip_len variable.
179 *
180 * When the function returns, there may be an outbound packet placed
181 * in the uip_buf packet buffer. If so, the uip_len variable is set to
182 * the length of the packet. If no packet is to be sent out, the
183 * uip_len variable is set to 0.
184 *
185 * The usual way of calling the function is presented by the source
186 * code below.
187 \code
188 uip_len = devicedriver_poll();
189 if(uip_len > 0) {
190 uip_input();
191 if(uip_len > 0) {
192 devicedriver_send();
193 }
194 }
195 \endcode
196 *
197 * \note If you are writing a uIP device driver that needs ARP
198 * (Address Resolution Protocol), e.g., when running uIP over
199 * Ethernet, you will need to call the uIP ARP code before calling
200 * this function:
201 \code
202 #define BUF ((struct uip_eth_hdr *)&uip_buf[0])
203 uip_len = ethernet_devicedrver_poll();
204 if(uip_len > 0) {
205 if(BUF->type == HTONS(UIP_ETHTYPE_IP)) {
206 uip_arp_ipin();
adamdunkels1e45c6d2003-09-02 21:47:27 +0000207 uip_input();
208 if(uip_len > 0) {
209 uip_arp_out();
210 ethernet_devicedriver_send();
211 }
212 } else if(BUF->type == HTONS(UIP_ETHTYPE_ARP)) {
213 uip_arp_arpin();
214 if(uip_len > 0) {
215 ethernet_devicedriver_send();
216 }
217 }
218 \endcode
adamdunkelsb489e7a2003-10-14 11:12:50 +0000219 *
220 * \hideinitializer
adamdunkels1e45c6d2003-09-02 21:47:27 +0000221 */
222#define uip_input() uip_process(UIP_DATA)
223
224/**
adamdunkels1e45c6d2003-09-02 21:47:27 +0000225 * Periodic processing for a connection identified by its number.
226 *
227 * This function does the necessary periodic processing (timers,
228 * polling) for a uIP TCP conneciton, and should be called when the
229 * periodic uIP timer goes off. It should be called for every
230 * connection, regardless of whether they are open of closed.
231 *
232 * When the function returns, it may have an outbound packet waiting
233 * for service in the uIP packet buffer, and if so the uip_len
234 * variable is set to a value larger than zero. The device driver
235 * should be called to send out the packet.
236 *
237 * The ususal way of calling the function is through a for() loop like
238 * this:
239 \code
240 for(i = 0; i < UIP_CONNS; ++i) {
241 uip_periodic(i);
242 if(uip_len > 0) {
243 devicedriver_send();
244 }
245 }
246 \endcode
247 *
248 * \note If you are writing a uIP device driver that needs ARP
249 * (Address Resolution Protocol), e.g., when running uIP over
250 * Ethernet, you will need to call the uip_arp_out() function before
251 * calling the device driver:
252 \code
253 for(i = 0; i < UIP_CONNS; ++i) {
254 uip_periodic(i);
255 if(uip_len > 0) {
256 uip_arp_out();
257 ethernet_devicedriver_send();
258 }
259 }
260 \endcode
261 *
262 * \param conn The number of the connection which is to be periodically polled.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000263 *
264 * \hideinitializer
adamdunkels1e45c6d2003-09-02 21:47:27 +0000265 */
266#define uip_periodic(conn) do { uip_conn = &uip_conns[conn]; \
267 uip_process(UIP_TIMER); } while (0)
268
269/**
adamdunkels36d49be2005-02-27 09:52:43 +0000270 * Perform periodic processing for a connection identified by a pointer
adamdunkels3335cd92005-02-27 09:44:33 +0000271 * to its structure.
adamdunkels1e45c6d2003-09-02 21:47:27 +0000272 *
273 * Same as uip_periodic() but takes a pointer to the actual uip_conn
274 * struct instead of an integer as its argument. This function can be
275 * used to force periodic processing of a specific connection.
276 *
277 * \param conn A pointer to the uip_conn struct for the connection to
278 * be processed.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000279 *
280 * \hideinitializer
adamdunkels1e45c6d2003-09-02 21:47:27 +0000281 */
282#define uip_periodic_conn(conn) do { uip_conn = conn; \
283 uip_process(UIP_TIMER); } while (0)
284
adamdunkels3335cd92005-02-27 09:44:33 +0000285/**
286 * Reuqest that a particular connection should be polled.
287 *
288 * Similar to uip_periodic_conn() but does not perform any timer
289 * processing. The application is polled for new data.
290 *
291 * \param conn A pointer to the uip_conn struct for the connection to
292 * be processed.
293 *
294 * \hideinitializer
295 */
296#define uip_poll_conn(conn) do { uip_conn = conn; \
297 uip_process(UIP_POLL_REQUEST); } while (0)
298
299
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000300#if UIP_UDP
adamdunkels1e45c6d2003-09-02 21:47:27 +0000301/**
302 * Periodic processing for a UDP connection identified by its number.
303 *
adamdunkels7461bcb2005-02-07 07:00:54 +0000304 * This function is essentially the same as uip_periodic(), but for
adamdunkels1e45c6d2003-09-02 21:47:27 +0000305 * UDP connections. It is called in a similar fashion as the
306 * uip_periodic() function:
307 \code
308 for(i = 0; i < UIP_UDP_CONNS; i++) {
309 uip_udp_periodic(i);
310 if(uip_len > 0) {
311 devicedriver_send();
312 }
313 }
314 \endcode
315 *
316 * \note As for the uip_periodic() function, special care has to be
317 * taken when using uIP together with ARP and Ethernet:
318 \code
319 for(i = 0; i < UIP_UDP_CONNS; i++) {
320 uip_udp_periodic(i);
321 if(uip_len > 0) {
322 uip_arp_out();
323 ethernet_devicedriver_send();
324 }
325 }
326 \endcode
327 *
328 * \param conn The number of the UDP connection to be processed.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000329 *
330 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000331 */
332#define uip_udp_periodic(conn) do { uip_udp_conn = &uip_udp_conns[conn]; \
333 uip_process(UIP_UDP_TIMER); } while (0)
adamdunkelseb91d5f2003-08-20 20:58:08 +0000334
adamdunkels1e45c6d2003-09-02 21:47:27 +0000335/**
336 * Periodic processing for a UDP connection identified by a pointer to
337 * its structure.
338 *
339 * Same as uip_udp_periodic() but takes a pointer to the actual
340 * uip_conn struct instead of an integer as its argument. This
341 * function can be used to force periodic processing of a specific
342 * connection.
343 *
344 * \param conn A pointer to the uip_udp_conn struct for the connection
345 * to be processed.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000346 *
347 * \hideinitializer
adamdunkelseb91d5f2003-08-20 20:58:08 +0000348 */
349#define uip_udp_periodic_conn(conn) do { uip_udp_conn = conn; \
350 uip_process(UIP_UDP_TIMER); } while (0)
adamdunkelsb489e7a2003-10-14 11:12:50 +0000351
352
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000353#endif /* UIP_UDP */
adamdunkels0170b082003-10-01 11:25:37 +0000354
355/**
356 * The uIP packet buffer.
357 *
358 * The uip_buf array is used to hold incoming and outgoing
359 * packets. The device driver should place incoming data into this
360 * buffer. When sending data, the device driver should read the link
361 * level headers and the TCP/IP headers from this buffer. The size of
362 * the link level headers is configured by the UIP_LLH_LEN define.
363 *
364 * \note The application data need not be placed in this buffer, so
365 * the device driver must read it from the place pointed to by the
366 * uip_appdata pointer as illustrated by the following example:
367 \code
368 void
369 devicedriver_send(void)
370 {
adamdunkels7461bcb2005-02-07 07:00:54 +0000371 hwsend(&uip_buf[0], UIP_LLH_LEN);
oliverschmidt37420872005-02-23 22:38:43 +0000372 if(uip_len <= UIP_LLH_LEN + UIP_TCPIP_HLEN) {
adamdunkels7461bcb2005-02-07 07:00:54 +0000373 hwsend(&uip_buf[UIP_LLH_LEN], uip_len - UIP_LLH_LEN);
374 } else {
oliverschmidt37420872005-02-23 22:38:43 +0000375 hwsend(&uip_buf[UIP_LLH_LEN], UIP_TCPIP_HLEN);
376 hwsend(uip_appdata, uip_len - UIP_TCPIP_HLEN - UIP_LLH_LEN);
adamdunkels7461bcb2005-02-07 07:00:54 +0000377 }
adamdunkels0170b082003-10-01 11:25:37 +0000378 }
379 \endcode
380 */
381extern u8_t uip_buf[UIP_BUFSIZE+2];
382
383/** @} */
384
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000385/*-----------------------------------------------------------------------------------*/
386/* Functions that are used by the uIP application program. Opening and
387 * closing connections, sending and receiving data, etc. is all
388 * handled by the functions below.
389*/
adamdunkels0170b082003-10-01 11:25:37 +0000390/**
391 * \defgroup uipappfunc uIP application functions
392 * @{
393 *
394 * Functions used by an application running of top of uIP.
395 */
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000396
adamdunkels1e45c6d2003-09-02 21:47:27 +0000397/**
398 * Start listening to the specified port.
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000399 *
adamdunkels1e45c6d2003-09-02 21:47:27 +0000400 * \note Since this function expects the port number in network byte
401 * order, a conversion using HTONS() or htons() is necessary.
402 *
403 \code
404 uip_listen(HTONS(80));
405 \endcode
406 *
407 * \param port A 16-bit port number in network byte order.
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000408 */
409void uip_listen(u16_t port);
410
adamdunkels1e45c6d2003-09-02 21:47:27 +0000411/**
412 * Stop listening to the specified port.
adamdunkelscd8c3a22003-08-13 22:52:48 +0000413 *
adamdunkels1e45c6d2003-09-02 21:47:27 +0000414 * \note Since this function expects the port number in network byte
415 * order, a conversion using HTONS() or htons() is necessary.
416 *
417 \code
418 uip_unlisten(HTONS(80));
419 \endcode
420 *
421 * \param port A 16-bit port number in network byte order.
adamdunkelscd8c3a22003-08-13 22:52:48 +0000422 */
423void uip_unlisten(u16_t port);
424
adamdunkels1e45c6d2003-09-02 21:47:27 +0000425/**
426 * Connect to a remote host using TCP.
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000427 *
adamdunkels1e45c6d2003-09-02 21:47:27 +0000428 * This function is used to start a new connection to the specified
429 * port on the specied host. It allocates a new connection identifier,
430 * sets the connection to the SYN_SENT state and sets the
431 * retransmission timer to 0. This will cause a TCP SYN segment to be
432 * sent out the next time this connection is periodically processed,
433 * which usually is done within 0.5 seconds after the call to
434 * uip_connect().
435 *
436 * \note This function is avaliable only if support for active open
437 * has been configured by defining UIP_ACTIVE_OPEN to 1 in uipopt.h.
438 *
439 * \note Since this function requires the port number to be in network
adamdunkels7461bcb2005-02-07 07:00:54 +0000440 * byte order, a conversion using HTONS() or htons() is necessary.
adamdunkels1e45c6d2003-09-02 21:47:27 +0000441 *
442 \code
443 u16_t ipaddr[2];
444
445 uip_ipaddr(ipaddr, 192,168,1,2);
446 uip_connect(ipaddr, HTONS(80));
447 \endcode
448 *
449 * \param ripaddr A pointer to a 4-byte array representing the IP
450 * address of the remote hot.
451 *
452 * \param port A 16-bit port number in network byte order.
453 *
454 * \return A pointer to the uIP connection identifier for the new connection,
455 * or NULL if no connection could be allocated.
456 *
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000457 */
458struct uip_conn *uip_connect(u16_t *ripaddr, u16_t port);
459
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000460
461
adamdunkels0170b082003-10-01 11:25:37 +0000462/**
adamdunkelsb489e7a2003-10-14 11:12:50 +0000463 * \internal
464 *
adamdunkels0170b082003-10-01 11:25:37 +0000465 * Check if a connection has outstanding (i.e., unacknowledged) data.
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000466 *
adamdunkels0170b082003-10-01 11:25:37 +0000467 * \param conn A pointer to the uip_conn structure for the connection.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000468 *
469 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000470 */
471#define uip_outstanding(conn) ((conn)->len)
472
adamdunkels0170b082003-10-01 11:25:37 +0000473/**
474 * Send data on the current connection.
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000475 *
adamdunkels0170b082003-10-01 11:25:37 +0000476 * This function is used to send out a single segment of TCP
477 * data. Only applications that have been invoked by uIP for event
478 * processing can send data.
479 *
adamdunkelsb489e7a2003-10-14 11:12:50 +0000480 * The amount of data that actually is sent out after a call to this
481 * funcion is determined by the maximum amount of data TCP allows. uIP
482 * will automatically crop the data so that only the appropriate
483 * amount of data is sent. The function uip_mss() can be used to query
484 * uIP for the amount of data that actually will be sent.
485 *
adamdunkels0170b082003-10-01 11:25:37 +0000486 * \note This function does not guarantee that the sent data will
487 * arrive at the destination. If the data is lost in the network, the
488 * application will be invoked with the uip_rexmit() event being
489 * set. The application will then have to resend the data using this
490 * function.
491 *
492 * \param data A pointer to the data which is to be sent.
493 *
adamdunkelsb489e7a2003-10-14 11:12:50 +0000494 * \param len The maximum amount of data bytes to be sent.
495 *
496 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000497 */
adamdunkels18076c62004-06-06 06:16:03 +0000498#define uip_send(data, len) do { uip_sappdata = (void *)(data); uip_slen = (len);} while(0)
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000499
adamdunkels0170b082003-10-01 11:25:37 +0000500/**
501 * The length of any incoming data that is currently avaliable (if avaliable)
502 * in the uip_appdata buffer.
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000503 *
adamdunkels0170b082003-10-01 11:25:37 +0000504 * The test function uip_data() must first be used to check if there
505 * is any data available at all.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000506 *
507 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000508 */
509#define uip_datalen() uip_len
510
adamdunkels0170b082003-10-01 11:25:37 +0000511/**
512 * The length of any out-of-band data (urgent data) that has arrived
513 * on the connection.
514 *
515 * \note The configuration parameter UIP_URGDATA must be set for this
516 * function to be enabled.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000517 *
518 * \hideinitializer
adamdunkels0170b082003-10-01 11:25:37 +0000519 */
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000520#define uip_urgdatalen() uip_urglen
521
adamdunkels0170b082003-10-01 11:25:37 +0000522/**
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000523 * Close the current connection.
adamdunkels0170b082003-10-01 11:25:37 +0000524 *
525 * This function will close the current connection in a nice way.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000526 *
527 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000528 */
529#define uip_close() (uip_flags = UIP_CLOSE)
530
adamdunkels0170b082003-10-01 11:25:37 +0000531/**
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000532 * Abort the current connection.
adamdunkels0170b082003-10-01 11:25:37 +0000533 *
534 * This function will abort (reset) the current connection, and is
535 * usually used when an error has occured that prevents using the
536 * uip_close() function.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000537 *
538 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000539 */
540#define uip_abort() (uip_flags = UIP_ABORT)
541
adamdunkels0170b082003-10-01 11:25:37 +0000542/**
543 * Tell the sending host to stop sending data.
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000544 *
adamdunkels0170b082003-10-01 11:25:37 +0000545 * This function will close our receiver's window so that we stop
546 * receiving data for the current connection.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000547 *
548 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000549 */
550#define uip_stop() (uip_conn->tcpstateflags |= UIP_STOPPED)
551
adamdunkels0170b082003-10-01 11:25:37 +0000552/**
553 * Find out if the current connection has been previously stopped with
554 * uip_stop().
adamdunkelsb489e7a2003-10-14 11:12:50 +0000555 *
556 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000557 */
558#define uip_stopped(conn) ((conn)->tcpstateflags & UIP_STOPPED)
559
adamdunkels0170b082003-10-01 11:25:37 +0000560/**
561 * Restart the current connection, if is has previously been stopped
562 * with uip_stop().
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000563 *
adamdunkels0170b082003-10-01 11:25:37 +0000564 * This function will open the receiver's window again so that we
565 * start receiving data for the current connection.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000566 *
567 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000568 */
569#define uip_restart() do { uip_flags |= UIP_NEWDATA; \
570 uip_conn->tcpstateflags &= ~UIP_STOPPED; \
571 } while(0)
572
573
574/* uIP tests that can be made to determine in what state the current
575 connection is, and what the application function should do. */
576
adamdunkels0170b082003-10-01 11:25:37 +0000577/**
adamdunkels18076c62004-06-06 06:16:03 +0000578 * Is the current connection a UDP connection?
579 *
580 * This function checks whether the current connection is a UDP connection.
581 *
582 * \hideinitializer
583 *
584 */
585#define uip_udpconnection() (uip_conn == NULL)
586
587/**
adamdunkels0170b082003-10-01 11:25:37 +0000588 * Is new incoming data available?
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000589 *
590 * Will reduce to non-zero if there is new data for the application
591 * present at the uip_appdata pointer. The size of the data is
592 * avaliable through the uip_len variable.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000593 *
594 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000595 */
596#define uip_newdata() (uip_flags & UIP_NEWDATA)
597
adamdunkels0170b082003-10-01 11:25:37 +0000598/**
599 * Has previously sent data been acknowledged?
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000600 *
601 * Will reduce to non-zero if the previously sent data has been
602 * acknowledged by the remote host. This means that the application
adamdunkels0170b082003-10-01 11:25:37 +0000603 * can send new data.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000604 *
605 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000606 */
607#define uip_acked() (uip_flags & UIP_ACKDATA)
adamdunkels0170b082003-10-01 11:25:37 +0000608
609/**
adamdunkels0170b082003-10-01 11:25:37 +0000610 * Has the connection just been connected?
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000611 *
612 * Reduces to non-zero if the current connection has been connected to
613 * a remote host. This will happen both if the connection has been
614 * actively opened (with uip_connect()) or passively opened (with
615 * uip_listen()).
adamdunkelsb489e7a2003-10-14 11:12:50 +0000616 *
617 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000618 */
619#define uip_connected() (uip_flags & UIP_CONNECTED)
620
adamdunkels0170b082003-10-01 11:25:37 +0000621/**
622 * Has the connection been closed by the other end?
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000623 *
624 * Is non-zero if the connection has been closed by the remote
adamdunkels0170b082003-10-01 11:25:37 +0000625 * host. The application may then do the necessary clean-ups.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000626 *
627 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000628 */
629#define uip_closed() (uip_flags & UIP_CLOSE)
630
adamdunkels0170b082003-10-01 11:25:37 +0000631/**
632 * Has the connection been aborted by the other end?
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000633 *
634 * Non-zero if the current connection has been aborted (reset) by the
635 * remote host.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000636 *
637 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000638 */
639#define uip_aborted() (uip_flags & UIP_ABORT)
640
adamdunkels0170b082003-10-01 11:25:37 +0000641/**
642 * Has the connection timed out?
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000643 *
644 * Non-zero if the current connection has been aborted due to too many
645 * retransmissions.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000646 *
647 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000648 */
adamdunkels399a0782004-02-16 20:52:07 +0000649#define uip_timedout() (uip_flags & UIP_TIMEDOUT)
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000650
adamdunkels0170b082003-10-01 11:25:37 +0000651/**
652 * Do we need to retransmit previously data?
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000653 *
654 * Reduces to non-zero if the previously sent data has been lost in
655 * the network, and the application should retransmit it. The
adamdunkels0170b082003-10-01 11:25:37 +0000656 * application should send the exact same data as it did the last
657 * time, using the uip_send() function.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000658 *
659 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000660 */
661#define uip_rexmit() (uip_flags & UIP_REXMIT)
662
adamdunkels0170b082003-10-01 11:25:37 +0000663/**
664 * Is the connection being polled by uIP?
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000665 *
666 * Is non-zero if the reason the application is invoked is that the
667 * current connection has been idle for a while and should be
668 * polled.
adamdunkels0170b082003-10-01 11:25:37 +0000669 *
670 * The polling event can be used for sending data without having to
671 * wait for the remote host to send data.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000672 *
673 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000674 */
675#define uip_poll() (uip_flags & UIP_POLL)
676
adamdunkels0170b082003-10-01 11:25:37 +0000677/**
678 * Get the initial maxium segment size (MSS) of the current
679 * connection.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000680 *
681 * \hideinitializer
adamdunkels0170b082003-10-01 11:25:37 +0000682 */
683#define uip_initialmss() (uip_conn->initialmss)
684
685/**
adamdunkelsb489e7a2003-10-14 11:12:50 +0000686 * Get the current maxium segment size that can be sent on the current
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000687 * connection.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000688 *
689 * The current maxiumum segment size that can be sent on the
690 * connection is computed from the receiver's window and the MSS of
691 * the connection (which also is available by calling
692 * uip_initialmss()).
693 *
694 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000695 */
696#define uip_mss() (uip_conn->mss)
697
adamdunkelsb489e7a2003-10-14 11:12:50 +0000698/**
699 * Set up a new UDP connection.
700 *
701 * \param ripaddr A pointer to a 4-byte structure representing the IP
702 * address of the remote host.
703 *
704 * \param rport The remote port number in network byte order.
705 *
706 * \return The uip_udp_conn structure for the new connection or NULL
707 * if no connection could be allocated.
708 */
709struct uip_udp_conn *uip_udp_new(u16_t *ripaddr, u16_t rport);
710
711/**
712 * Removed a UDP connection.
713 *
714 * \param conn A pointer to the uip_udp_conn structure for the connection.
715 *
716 * \hideinitializer
717 */
718#define uip_udp_remove(conn) (conn)->lport = 0
719
720/**
adamdunkels37f0b8d2004-07-04 17:00:50 +0000721 * Bind a UDP connection to a local port.
722 *
723 * \param conn A pointer to the uip_udp_conn structure for the
724 * connection.
725 *
726 * \param port The local port number, in network byte order.
727 *
728 * \hideinitializer
729 */
730#define uip_udp_bind(conn, port) (conn)->lport = port
731
732/**
adamdunkelsb489e7a2003-10-14 11:12:50 +0000733 * Send a UDP datagram of length len on the current connection.
734 *
735 * This function can only be called in response to a UDP event (poll
736 * or newdata). The data must be present in the uip_buf buffer, at the
737 * place pointed to by the uip_appdata pointer.
738 *
739 * \param len The length of the data in the uip_buf buffer.
740 *
741 * \hideinitializer
742 */
743#define uip_udp_send(len) uip_slen = (len)
744
adamdunkels0170b082003-10-01 11:25:37 +0000745/** @} */
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000746
747/* uIP convenience and converting functions. */
748
adamdunkels0170b082003-10-01 11:25:37 +0000749/**
750 * \defgroup uipconvfunc uIP conversion functions
751 * @{
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000752 *
adamdunkels0170b082003-10-01 11:25:37 +0000753 * These functions can be used for converting between different data
754 * formats used by uIP.
755 */
756
757/**
758 * Pack an IP address into a 4-byte array which is used by uIP to
759 * represent IP addresses.
760 *
761 * Example:
762 \code
763 u16_t ipaddr[2];
764
765 uip_ipaddr(&ipaddr, 192,168,1,2);
766 \endcode
767 *
768 * \param addr A pointer to a 4-byte array that will be filled in with
769 * the IP addres.
770 * \param addr0 The first octet of the IP address.
771 * \param addr1 The second octet of the IP address.
772 * \param addr2 The third octet of the IP address.
773 * \param addr3 The forth octet of the IP address.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000774 *
775 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000776 */
777#define uip_ipaddr(addr, addr0,addr1,addr2,addr3) do { \
adamdunkels18076c62004-06-06 06:16:03 +0000778 ((u16_t *)(addr))[0] = HTONS(((addr0) << 8) | (addr1)); \
779 ((u16_t *)(addr))[1] = HTONS(((addr2) << 8) | (addr3)); \
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000780 } while(0)
781
adamdunkels0170b082003-10-01 11:25:37 +0000782/**
adamdunkels18076c62004-06-06 06:16:03 +0000783 * Copy an IP address to another IP address.
784 *
785 * Copies an IP address from one place to another.
786 *
787 * Example:
788 \code
789 u16_t ipaddr1[2], ipaddr2[2];
790
791 uip_ipaddr(ipaddr1, 192,16,1,2);
792 uip_ipaddr_copy(ipaddr2, ipaddr1);
793 \endcode
794 *
795 * \param dest The destination for the copy.
796 * \param src The source from where to copy.
797 *
798 * \hideinitializer
799 */
800#define uip_ipaddr_copy(dest, src) do { \
801 ((u16_t *)dest)[0] = ((u16_t *)src)[0]; \
802 ((u16_t *)dest)[1] = ((u16_t *)src)[1]; \
803 } while(0)
804/**
805 * Compare two IP addresses
806 *
807 * Compares two IP addresses.
808 *
809 * Example:
810 \code
811 u16_t ipaddr1[2], ipaddr2[2];
812
813 uip_ipaddr(ipaddr1, 192,16,1,2);
814 if(uip_ipaddr_cmp(ipaddr2, ipaddr1)) {
815 printf("They are the same");
816 }
817 \endcode
818 *
819 * \param addr1 The first IP address.
820 * \param addr2 The second IP address.
821 *
822 * \hideinitializer
823 */
824#define uip_ipaddr_cmp(addr1, addr2) (((u16_t *)addr1)[0] == ((u16_t *)addr2)[0] && \
825 ((u16_t *)addr1)[1] == ((u16_t *)addr2)[1])
826
827/**
828 * Compare two IP addresses with netmasks
829 *
830 * Compares two IP addresses with netmasks. The masks are used to mask
831 * out the bits that are to be compared.
832 *
833 * Example:
834 \code
835 u16_t ipaddr1[2], ipaddr2[2], mask[2];
836
837 uip_ipaddr(mask, 255,255,255,0);
838 uip_ipaddr(ipaddr1, 192,16,1,2);
839 uip_ipaddr(ipaddr2, 192,16,1,3);
840 if(uip_ipaddr_maskcmp(ipaddr1, ipaddr2, mask)) {
841 printf("They are the same");
842 }
843 \endcode
844 *
845 * \param addr1 The first IP address.
846 * \param addr2 The second IP address.
847 * \param mask The netmask.
848 *
849 * \hideinitializer
850 */
851#define uip_ipaddr_maskcmp(addr1, addr2, mask) \
852 (((((u16_t *)addr1)[0] & ((u16_t *)mask)[0]) == \
853 (((u16_t *)addr2)[0] & ((u16_t *)mask)[0])) && \
854 ((((u16_t *)addr1)[1] & ((u16_t *)mask)[1]) == \
855 (((u16_t *)addr2)[1] & ((u16_t *)mask)[1])))
856
857
858/**
859 * Mask out the network part of an IP address.
860 *
861 * Masks out the network part of an IP address, given the address and
862 * the netmask.
863 *
864 * Example:
865 \code
866 u16_t ipaddr1[2], ipaddr2[2], netmask[2];
867
868 uip_ipaddr(ipaddr1, 192,16,1,2);
869 uip_ipaddr(netmask, 255,255,255,0);
870 uip_ipaddr_mask(ipaddr2, ipaddr1, netmask);
871 \endcode
872 *
873 * In the example above, the variable "ipaddr2" will contain the IP
874 * address 192.168.1.0.
875 *
876 * \param dest Where the result is to be placed.
877 * \param src The IP address.
878 * \param mask The netmask.
879 *
880 * \hideinitializer
881 */
882#define uip_ipaddr_mask(dest, src, mask) do { \
883 ((u16_t *)dest)[0] = ((u16_t *)src)[0] & ((u16_t *)mask)[0]; \
884 ((u16_t *)dest)[1] = ((u16_t *)src)[1] & ((u16_t *)mask)[1]; \
885 } while(0)
886
887/**
888 * Pick the first octet of an IP address.
889 *
890 * Picks out the first octet of an IP address.
891 *
892 * Example:
893 \code
894 u16_t ipaddr[2];
895 u8_t octet;
896
897 uip_ipaddr(ipaddr, 1,2,3,4);
898 octet = uip_ipaddr1(ipaddr);
899 \endcode
900 *
901 * In the example above, the variable "octet" will contain the value 1.
902 *
903 * \hideinitializer
904 */
905#define uip_ipaddr1(addr) (htons(((u16_t *)(addr))[0]) >> 8)
906
907/**
908 * Pick the second octet of an IP address.
909 *
910 * Picks out the second octet of an IP address.
911 *
912 * Example:
913 \code
914 u16_t ipaddr[2];
915 u8_t octet;
916
917 uip_ipaddr(ipaddr, 1,2,3,4);
918 octet = uip_ipaddr2(ipaddr);
919 \endcode
920 *
921 * In the example above, the variable "octet" will contain the value 2.
922 *
923 * \hideinitializer
924 */
925#define uip_ipaddr2(addr) (htons(((u16_t *)(addr))[0]) & 0xff)
926
927/**
928 * Pick the third octet of an IP address.
929 *
930 * Picks out the third octet of an IP address.
931 *
932 * Example:
933 \code
934 u16_t ipaddr[2];
935 u8_t octet;
936
937 uip_ipaddr(ipaddr, 1,2,3,4);
938 octet = uip_ipaddr3(ipaddr);
939 \endcode
940 *
941 * In the example above, the variable "octet" will contain the value 3.
942 *
943 * \hideinitializer
944 */
945#define uip_ipaddr3(addr) (htons(((u16_t *)(addr))[1]) >> 8)
946
947/**
948 * Pick the fourth octet of an IP address.
949 *
950 * Picks out the fourth octet of an IP address.
951 *
952 * Example:
953 \code
954 u16_t ipaddr[2];
955 u8_t octet;
956
957 uip_ipaddr(ipaddr, 1,2,3,4);
958 octet = uip_ipaddr4(ipaddr);
959 \endcode
960 *
961 * In the example above, the variable "octet" will contain the value 4.
962 *
963 * \hideinitializer
964 */
965#define uip_ipaddr4(addr) (htons(((u16_t *)(addr))[1]) & 0xff)
966
967/**
adamdunkels0170b082003-10-01 11:25:37 +0000968 * Convert 16-bit quantity from host byte order to network byte order.
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000969 *
adamdunkels0170b082003-10-01 11:25:37 +0000970 * This macro is primarily used for converting constants from host
971 * byte order to network byte order. For converting variables to
972 * network byte order, use the htons() function instead.
adamdunkelsb489e7a2003-10-14 11:12:50 +0000973 *
974 * \hideinitializer
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000975 */
adamdunkels47ec7fa2003-03-28 12:11:17 +0000976#ifndef HTONS
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000977# if BYTE_ORDER == BIG_ENDIAN
adamdunkels47ec7fa2003-03-28 12:11:17 +0000978# define HTONS(n) (n)
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000979# else /* BYTE_ORDER == BIG_ENDIAN */
adamdunkels47ec7fa2003-03-28 12:11:17 +0000980# define HTONS(n) ((((u16_t)((n) & 0xff)) << 8) | (((n) & 0xff00) >> 8))
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000981# endif /* BYTE_ORDER == BIG_ENDIAN */
adamdunkels47ec7fa2003-03-28 12:11:17 +0000982#endif /* HTONS */
983
adamdunkels0170b082003-10-01 11:25:37 +0000984/**
985 * Convert 16-bit quantity from host byte order to network byte order.
986 *
987 * This function is primarily used for converting variables from host
988 * byte order to network byte order. For converting constants to
989 * network byte order, use the HTONS() macro instead.
990 */
adamdunkels47ec7fa2003-03-28 12:11:17 +0000991u16_t htons(u16_t val);
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000992
adamdunkels0170b082003-10-01 11:25:37 +0000993/** @} */
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000994
adamdunkels0170b082003-10-01 11:25:37 +0000995/**
996 * Pointer to the application data in the packet buffer.
adamdunkelsca9ddcb2003-03-19 14:13:31 +0000997 *
998 * This pointer points to the application data when the application is
adamdunkels0170b082003-10-01 11:25:37 +0000999 * called. If the application wishes to send data, the application may
1000 * use this space to write the data into before calling uip_send().
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001001 */
adamdunkels18076c62004-06-06 06:16:03 +00001002extern u8_t *uip_appdata;
1003extern u8_t *uip_sappdata;
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001004
1005#if UIP_URGDATA > 0
1006/* u8_t *uip_urgdata:
1007 *
1008 * This pointer points to any urgent data that has been received. Only
1009 * present if compiled with support for urgent data (UIP_URGDATA).
1010 */
adamdunkels18076c62004-06-06 06:16:03 +00001011extern u8_t *uip_urgdata;
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001012#endif /* UIP_URGDATA > 0 */
1013
1014
1015/* u[8|16]_t uip_len:
1016 *
1017 * When the application is called, uip_len contains the length of any
1018 * new data that has been received from the remote host. The
1019 * application should set this variable to the size of any data that
1020 * the application wishes to send. When the network device driver
1021 * output function is called, uip_len should contain the length of the
1022 * outgoing packet.
1023 */
adamdunkels18076c62004-06-06 06:16:03 +00001024extern u16_t uip_len, uip_slen;
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001025
1026#if UIP_URGDATA > 0
adamdunkels18076c62004-06-06 06:16:03 +00001027extern u8_t uip_urglen, uip_surglen;
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001028#endif /* UIP_URGDATA > 0 */
1029
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001030
adamdunkels0170b082003-10-01 11:25:37 +00001031/**
1032 * Representation of a uIP TCP connection.
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001033 *
1034 * The uip_conn structure is used for identifying a connection. All
1035 * but one field in the structure are to be considered read-only by an
1036 * application. The only exception is the appstate field whos purpose
1037 * is to let the application store application-specific state (e.g.,
1038 * file pointers) for the connection. The size of this field is
1039 * configured in the "uipopt.h" header file.
1040 */
1041struct uip_conn {
adamdunkels0170b082003-10-01 11:25:37 +00001042 u16_t ripaddr[2]; /**< The IP address of the remote host. */
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001043
adamdunkels0170b082003-10-01 11:25:37 +00001044 u16_t lport; /**< The local TCP port, in network byte order. */
1045 u16_t rport; /**< The local remote TCP port, in network byte
1046 order. */
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001047
adamdunkels0170b082003-10-01 11:25:37 +00001048 u8_t rcv_nxt[4]; /**< The sequence number that we expect to
1049 receive next. */
1050 u8_t snd_nxt[4]; /**< The sequence number that was last sent by
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001051 us. */
adamdunkels0170b082003-10-01 11:25:37 +00001052 u16_t len; /**< Length of the data that was previously sent. */
1053 u16_t mss; /**< Current maximum segment size for the
1054 connection. */
1055 u16_t initialmss; /**< Initial maximum segment size for the
1056 connection. */
adamdunkelsb489e7a2003-10-14 11:12:50 +00001057 u8_t sa; /**< Retransmission time-out calculation state
1058 variable. */
1059 u8_t sv; /**< Retransmission time-out calculation state
1060 variable. */
1061 u8_t rto; /**< Retransmission time-out. */
adamdunkels0170b082003-10-01 11:25:37 +00001062 u8_t tcpstateflags; /**< TCP state and flags. */
1063 u8_t timer; /**< The retransmission timer. */
1064 u8_t nrtx; /**< The number of retransmissions for the last
1065 segment sent. */
1066
1067 /** The application state. */
1068 u8_t appstate[UIP_APPSTATE_SIZE];
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001069};
1070
adamdunkels0170b082003-10-01 11:25:37 +00001071
1072/* Pointer to the current connection. */
1073extern struct uip_conn *uip_conn;
1074/* The array containing all uIP connections. */
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001075extern struct uip_conn uip_conns[UIP_CONNS];
adamdunkels0170b082003-10-01 11:25:37 +00001076/**
1077 * \addtogroup uiparch
1078 * @{
1079 */
1080
1081/**
1082 * 4-byte array used for the 32-bit sequence number calculations.
1083 */
adamdunkels18076c62004-06-06 06:16:03 +00001084extern u8_t uip_acc32[4];
adamdunkels0170b082003-10-01 11:25:37 +00001085
1086/** @} */
1087
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001088
1089#if UIP_UDP
adamdunkels1e45c6d2003-09-02 21:47:27 +00001090/**
1091 * Representation of a uIP UDP connection.
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001092 */
1093struct uip_udp_conn {
adamdunkelsb489e7a2003-10-14 11:12:50 +00001094 u16_t ripaddr[2]; /**< The IP address of the remote peer. */
1095 u16_t lport; /**< The local port number in network byte order. */
1096 u16_t rport; /**< The remote port number in network byte order. */
adamdunkels399a0782004-02-16 20:52:07 +00001097
1098 /** The application state. */
1099 u8_t appstate[UIP_APPSTATE_SIZE];
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001100};
1101
1102extern struct uip_udp_conn *uip_udp_conn;
1103extern struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
1104#endif /* UIP_UDP */
1105
adamdunkelsb489e7a2003-10-14 11:12:50 +00001106/**
1107 * The structure holding the TCP/IP statistics that are gathered if
1108 * UIP_STATISTICS is set to 1.
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001109 *
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001110 */
1111struct uip_stats {
1112 struct {
adamdunkelsb489e7a2003-10-14 11:12:50 +00001113 uip_stats_t drop; /**< Number of dropped packets at the IP
1114 layer. */
1115 uip_stats_t recv; /**< Number of received packets at the IP
1116 layer. */
1117 uip_stats_t sent; /**< Number of sent packets at the IP
1118 layer. */
1119 uip_stats_t vhlerr; /**< Number of packets dropped due to wrong
1120 IP version or header length. */
1121 uip_stats_t hblenerr; /**< Number of packets dropped due to wrong
1122 IP length, high byte. */
1123 uip_stats_t lblenerr; /**< Number of packets dropped due to wrong
1124 IP length, low byte. */
1125 uip_stats_t fragerr; /**< Number of packets dropped since they
1126 were IP fragments. */
1127 uip_stats_t chkerr; /**< Number of packets dropped due to IP
1128 checksum errors. */
1129 uip_stats_t protoerr; /**< Number of packets dropped since they
1130 were neither ICMP, UDP nor TCP. */
1131 } ip; /**< IP statistics. */
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001132 struct {
adamdunkelsb489e7a2003-10-14 11:12:50 +00001133 uip_stats_t drop; /**< Number of dropped ICMP packets. */
1134 uip_stats_t recv; /**< Number of received ICMP packets. */
1135 uip_stats_t sent; /**< Number of sent ICMP packets. */
1136 uip_stats_t typeerr; /**< Number of ICMP packets with a wrong
1137 type. */
1138 } icmp; /**< ICMP statistics. */
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001139 struct {
adamdunkelsb489e7a2003-10-14 11:12:50 +00001140 uip_stats_t drop; /**< Number of dropped TCP segments. */
1141 uip_stats_t recv; /**< Number of recived TCP segments. */
1142 uip_stats_t sent; /**< Number of sent TCP segments. */
1143 uip_stats_t chkerr; /**< Number of TCP segments with a bad
1144 checksum. */
1145 uip_stats_t ackerr; /**< Number of TCP segments with a bad ACK
1146 number. */
1147 uip_stats_t rst; /**< Number of recevied TCP RST (reset) segments. */
1148 uip_stats_t rexmit; /**< Number of retransmitted TCP segments. */
1149 uip_stats_t syndrop; /**< Number of dropped SYNs due to too few
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001150 connections was avaliable. */
adamdunkelsb489e7a2003-10-14 11:12:50 +00001151 uip_stats_t synrst; /**< Number of SYNs for closed ports,
1152 triggering a RST. */
1153 } tcp; /**< TCP statistics. */
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001154};
1155
adamdunkelsb489e7a2003-10-14 11:12:50 +00001156/**
1157 * The uIP TCP/IP statistics.
1158 *
1159 * This is the variable in which the uIP TCP/IP statistics are gathered.
1160 */
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001161extern struct uip_stats uip_stat;
1162
1163
1164/*-----------------------------------------------------------------------------------*/
1165/* All the stuff below this point is internal to uIP and should not be
1166 * used directly by an application or by a device driver.
1167 */
1168/*-----------------------------------------------------------------------------------*/
1169/* u8_t uip_flags:
1170 *
1171 * When the application is called, uip_flags will contain the flags
1172 * that are defined in this file. Please read below for more
1173 * infomation.
1174 */
adamdunkels18076c62004-06-06 06:16:03 +00001175extern u8_t uip_flags;
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001176
1177/* The following flags may be set in the global variable uip_flags
1178 before calling the application callback. The UIP_ACKDATA and
1179 UIP_NEWDATA flags may both be set at the same time, whereas the
1180 others are mutualy exclusive. Note that these flags should *NOT* be
1181 accessed directly, but through the uIP functions/macros. */
1182
1183#define UIP_ACKDATA 1 /* Signifies that the outstanding data was
1184 acked and the application should send
1185 out new data instead of retransmitting
1186 the last data. */
1187#define UIP_NEWDATA 2 /* Flags the fact that the peer has sent
1188 us new data. */
1189#define UIP_REXMIT 4 /* Tells the application to retransmit the
1190 data that was last sent. */
1191#define UIP_POLL 8 /* Used for polling the application, to
1192 check if the application has data that
1193 it wants to send. */
1194#define UIP_CLOSE 16 /* The remote host has closed the
1195 connection, thus the connection has
1196 gone away. Or the application signals
1197 that it wants to close the
1198 connection. */
1199#define UIP_ABORT 32 /* The remote host has aborted the
1200 connection, thus the connection has
1201 gone away. Or the application signals
1202 that it wants to abort the
1203 connection. */
1204#define UIP_CONNECTED 64 /* We have got a connection from a remote
1205 host and have set up a new connection
1206 for it, or an active connection has
1207 been successfully established. */
1208
1209#define UIP_TIMEDOUT 128 /* The connection has been aborted due to
1210 too many retransmissions. */
1211
1212
1213/* uip_process(flag):
1214 *
1215 * The actual uIP function which does all the work.
1216 */
1217void uip_process(u8_t flag);
1218
1219/* The following flags are passed as an argument to the uip_process()
1220 function. They are used to distinguish between the two cases where
1221 uip_process() is called. It can be called either because we have
1222 incoming data that should be processed, or because the periodic
adamdunkels3335cd92005-02-27 09:44:33 +00001223 timer has fired. These values are never used directly, but only in
1224 the macrose defined in this file. */
1225
1226#define UIP_DATA 1 /* Tells uIP that there is incoming
1227 data in the uip_buf buffer. The
1228 length of the data is stored in the
1229 global variable uip_len. */
1230#define UIP_TIMER 2 /* Tells uIP that the periodic timer
1231 has fired. */
1232#define UIP_POLL_REQUEST 3 /* Tells uIP that a connection should
1233 be polled. */
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001234#if UIP_UDP
adamdunkels3335cd92005-02-27 09:44:33 +00001235#define UIP_UDP_TIMER 4
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001236#endif /* UIP_UDP */
1237
1238/* The TCP states used in the uip_conn->tcpstateflags. */
1239#define CLOSED 0
1240#define SYN_RCVD 1
1241#define SYN_SENT 2
1242#define ESTABLISHED 3
1243#define FIN_WAIT_1 4
1244#define FIN_WAIT_2 5
1245#define CLOSING 6
1246#define TIME_WAIT 7
1247#define LAST_ACK 8
1248#define TS_MASK 15
1249
1250#define UIP_STOPPED 16
1251
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001252#define UIP_TCPIP_HLEN 40
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001253
adamdunkels0dd56df2005-03-09 10:21:04 +00001254/**
1255 * The buffer size available for user data in the \ref uip_buf buffer.
1256 *
1257 * This macro holds the available size for user data in the \ref
1258 * uip_buf buffer. The macro is intended to be used for checking
1259 * bounds of available user data.
1260 *
1261 * Example:
1262 \code
1263 snprintf(uip_appdata, UIP_APPDATA_SIZE, "%u\n", i);
1264 \endcode
1265 *
1266 * \hideinitializer
1267 */
1268#define UIP_APPDATA_SIZE (UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN)
1269
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001270/* The TCP and IP headers. */
1271typedef struct {
1272 /* IP header. */
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001273 u8_t vhl,
1274 tos,
1275 len[2],
1276 ipid[2],
1277 ipoffset[2],
1278 ttl,
1279 proto;
1280 u16_t ipchksum;
1281 u16_t srcipaddr[2],
1282 destipaddr[2];
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001283
1284 /* TCP header. */
1285 u16_t srcport,
1286 destport;
1287 u8_t seqno[4],
1288 ackno[4],
1289 tcpoffset,
1290 flags,
1291 wnd[2];
1292 u16_t tcpchksum;
1293 u8_t urgp[2];
1294 u8_t optdata[4];
1295} uip_tcpip_hdr;
1296
1297/* The ICMP and IP headers. */
1298typedef struct {
1299 /* IP header. */
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001300 u8_t vhl,
1301 tos,
1302 len[2],
1303 ipid[2],
1304 ipoffset[2],
1305 ttl,
1306 proto;
1307 u16_t ipchksum;
1308 u16_t srcipaddr[2],
1309 destipaddr[2];
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001310 /* ICMP (echo) header. */
1311 u8_t type, icode;
1312 u16_t icmpchksum;
1313 u16_t id, seqno;
1314} uip_icmpip_hdr;
1315
1316
1317/* The UDP and IP headers. */
1318typedef struct {
1319 /* IP header. */
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001320 u8_t vhl,
1321 tos,
1322 len[2],
1323 ipid[2],
1324 ipoffset[2],
1325 ttl,
1326 proto;
1327 u16_t ipchksum;
1328 u16_t srcipaddr[2],
1329 destipaddr[2];
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001330
1331 /* UDP header. */
1332 u16_t srcport,
1333 destport;
1334 u16_t udplen;
1335 u16_t udpchksum;
1336} uip_udpip_hdr;
1337
1338#define UIP_PROTO_ICMP 1
1339#define UIP_PROTO_TCP 6
1340#define UIP_PROTO_UDP 17
1341
adamdunkels72a83032005-02-22 22:32:40 +00001342/* Header sizes. */
1343#define UIP_IPH_LEN 20 /* Size of IP header */
1344#define UIP_UDPH_LEN 8 /* Size of UDP header */
1345#define UIP_TCPH_LEN 20 /* Size of TCP header */
1346#define UIP_IPUDPH_LEN 28 /* Size of IP + UDP header */
1347#define UIP_IPTCPH_LEN 40 /* Size of IP + TCP header */
1348
adamdunkels18076c62004-06-06 06:16:03 +00001349
1350
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001351#if UIP_FIXEDADDR
adamdunkels18076c62004-06-06 06:16:03 +00001352extern const u16_t uip_hostaddr[2], uip_netmask[2], uip_draddr[2];
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001353#else /* UIP_FIXEDADDR */
adamdunkels18076c62004-06-06 06:16:03 +00001354extern u16_t uip_hostaddr[2], uip_netmask[2], uip_draddr[2];
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001355#endif /* UIP_FIXEDADDR */
1356
adamdunkels18076c62004-06-06 06:16:03 +00001357
1358
adamdunkelsb380a3e2004-09-17 20:59:23 +00001359/**
1360 * Representation of a 48-bit Ethernet address.
1361 */
1362struct uip_eth_addr {
1363 u8_t addr[6];
1364};
1365
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001366#endif /* __UIP_H__ */
1367
1368
adamdunkels0170b082003-10-01 11:25:37 +00001369/** @} */
adamdunkelsca9ddcb2003-03-19 14:13:31 +00001370