Rev Author Line No. Line
3328 povik 1 /**
2 * \addtogroup uip
3 * @{
4 */
5  
6 /**
7 * \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  
17  
18 /*
19 * Copyright (c) 2001-2003, Adam Dunkels.
20 * 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.
30 * 3. The name of the author may not be used to endorse or promote
31 * 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 *
48 * $Id: uip.h,v 1.36.2.7 2003/10/07 13:47:51 adam Exp $
49 *
50 */
51  
52 #ifndef __UIP_H__
53 #define __UIP_H__
54  
55 #include "uipopt.h"
56  
57 /*-----------------------------------------------------------------------------------*/
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  
63 /**
64 * \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 /**
72 * Set the IP address of this host.
73 *
74 * 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.
77 *
78 * \param addr A pointer to a 4-byte representation of the IP address.
79 *
80 * \hideinitializer
81 */
82 #define uip_sethostaddr(addr) do { uip_hostaddr[0] = addr[0]; \
83 uip_hostaddr[1] = addr[1]; } while(0)
84  
85 /**
86 * Get the IP address of this host.
87 *
88 * 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.
94 *
95 * \hideinitializer
96 */
97 #define uip_gethostaddr(addr) do { addr[0] = uip_hostaddr[0]; \
98 addr[1] = uip_hostaddr[1]; } while(0)
99  
100 /** @} */
101  
102 /**
103 * \defgroup uipinit uIP initialization functions
104 * @{
105 *
106 * The uIP initialization functions are used for booting uIP.
107 */
108  
109 /**
110 * uIP initialization function.
111 *
112 * This function should be called at boot up to initilize the uIP
113 * TCP/IP stack.
114 */
115 void uip_init(void);
116  
117 /** @} */
118  
119 /**
120 * \defgroup uipdevfunc uIP device driver functions
121 * @{
122 *
123 * These functions are used by a network device driver for interacting
124 * with uIP.
125 */
126  
127 /**
128 * Process an incoming packet.
129 *
130 * This function should be called when the device driver has received
131 * a packet from the network. The packet from the device driver must
132 * be present in the uip_buf buffer, and the length of the packet
133 * should be placed in the uip_len variable.
134 *
135 * When the function returns, there may be an outbound packet placed
136 * in the uip_buf packet buffer. If so, the uip_len variable is set to
137 * the length of the packet. If no packet is to be sent out, the
138 * uip_len variable is set to 0.
139 *
140 * The usual way of calling the function is presented by the source
141 * code below.
142 \code
143 uip_len = devicedriver_poll();
144 if(uip_len > 0) {
145 uip_input();
146 if(uip_len > 0) {
147 devicedriver_send();
148 }
149 }
150 \endcode
151 *
152 * \note If you are writing a uIP device driver that needs ARP
153 * (Address Resolution Protocol), e.g., when running uIP over
154 * Ethernet, you will need to call the uIP ARP code before calling
155 * this function:
156 \code
157 #define BUF ((struct uip_eth_hdr *)&uip_buf[0])
158 uip_len = ethernet_devicedrver_poll();
159 if(uip_len > 0) {
160 if(BUF->type == HTONS(UIP_ETHTYPE_IP)) {
161 uip_arp_ipin();
162 uip_input();
163 if(uip_len > 0) {
164 uip_arp_out();
165 ethernet_devicedriver_send();
166 }
167 } else if(BUF->type == HTONS(UIP_ETHTYPE_ARP)) {
168 uip_arp_arpin();
169 if(uip_len > 0) {
170 ethernet_devicedriver_send();
171 }
172 }
173 \endcode
174 *
175 * \hideinitializer
176 */
177 #define uip_input() uip_process(UIP_DATA)
178  
179 /**
180 * Periodic processing for a connection identified by its number.
181 *
182 * This function does the necessary periodic processing (timers,
183 * polling) for a uIP TCP conneciton, and should be called when the
184 * periodic uIP timer goes off. It should be called for every
185 * connection, regardless of whether they are open of closed.
186 *
187 * When the function returns, it may have an outbound packet waiting
188 * for service in the uIP packet buffer, and if so the uip_len
189 * variable is set to a value larger than zero. The device driver
190 * should be called to send out the packet.
191 *
192 * The ususal way of calling the function is through a for() loop like
193 * this:
194 \code
195 for(i = 0; i < UIP_CONNS; ++i) {
196 uip_periodic(i);
197 if(uip_len > 0) {
198 devicedriver_send();
199 }
200 }
201 \endcode
202 *
203 * \note If you are writing a uIP device driver that needs ARP
204 * (Address Resolution Protocol), e.g., when running uIP over
205 * Ethernet, you will need to call the uip_arp_out() function before
206 * calling the device driver:
207 \code
208 for(i = 0; i < UIP_CONNS; ++i) {
209 uip_periodic(i);
210 if(uip_len > 0) {
211 uip_arp_out();
212 ethernet_devicedriver_send();
213 }
214 }
215 \endcode
216 *
217 * \param conn The number of the connection which is to be periodically polled.
218 *
219 * \hideinitializer
220 */
221 #define uip_periodic(conn) do { uip_conn = &uip_conns[conn]; \
222 uip_process(UIP_TIMER); } while (0)
223  
224 /**
225 * Periodic processing for a connection identified by a pointer to its structure.
226 *
227 * Same as uip_periodic() but takes a pointer to the actual uip_conn
228 * struct instead of an integer as its argument. This function can be
229 * used to force periodic processing of a specific connection.
230 *
231 * \param conn A pointer to the uip_conn struct for the connection to
232 * be processed.
233 *
234 * \hideinitializer
235 */
236 #define uip_periodic_conn(conn) do { uip_conn = conn; \
237 uip_process(UIP_TIMER); } while (0)
238  
239 #if UIP_UDP
240 /**
241 * Periodic processing for a UDP connection identified by its number.
242 *
243 * This function is essentially the same as uip_prerioic(), but for
244 * UDP connections. It is called in a similar fashion as the
245 * uip_periodic() function:
246 \code
247 for(i = 0; i < UIP_UDP_CONNS; i++) {
248 uip_udp_periodic(i);
249 if(uip_len > 0) {
250 devicedriver_send();
251 }
252 }
253 \endcode
254 *
255 * \note As for the uip_periodic() function, special care has to be
256 * taken when using uIP together with ARP and Ethernet:
257 \code
258 for(i = 0; i < UIP_UDP_CONNS; i++) {
259 uip_udp_periodic(i);
260 if(uip_len > 0) {
261 uip_arp_out();
262 ethernet_devicedriver_send();
263 }
264 }
265 \endcode
266 *
267 * \param conn The number of the UDP connection to be processed.
268 *
269 * \hideinitializer
270 */
271 #define uip_udp_periodic(conn) do { uip_udp_conn = &uip_udp_conns[conn]; \
272 uip_process(UIP_UDP_TIMER); } while (0)
273  
274 /**
275 * Periodic processing for a UDP connection identified by a pointer to
276 * its structure.
277 *
278 * Same as uip_udp_periodic() but takes a pointer to the actual
279 * uip_conn struct instead of an integer as its argument. This
280 * function can be used to force periodic processing of a specific
281 * connection.
282 *
283 * \param conn A pointer to the uip_udp_conn struct for the connection
284 * to be processed.
285 *
286 * \hideinitializer
287 */
288 #define uip_udp_periodic_conn(conn) do { uip_udp_conn = conn; \
289 uip_process(UIP_UDP_TIMER); } while (0)
290  
291  
292 #endif /* UIP_UDP */
293  
294 /**
295 * The uIP packet buffer.
296 *
297 * The uip_buf array is used to hold incoming and outgoing
298 * packets. The device driver should place incoming data into this
299 * buffer. When sending data, the device driver should read the link
300 * level headers and the TCP/IP headers from this buffer. The size of
301 * the link level headers is configured by the UIP_LLH_LEN define.
302 *
303 * \note The application data need not be placed in this buffer, so
304 * the device driver must read it from the place pointed to by the
305 * uip_appdata pointer as illustrated by the following example:
306 \code
307 void
308 devicedriver_send(void)
309 {
310 hwsend(&uip_buf[0], UIP_LLH_LEN);
311 hwsend(&uip_buf[UIP_LLH_LEN], 40);
312 hwsend(uip_appdata, uip_len - 40 - UIP_LLH_LEN);
313 }
314 \endcode
315 */
316 extern u8_t uip_buf[UIP_BUFSIZE+2]; /*_RB_ __attribute__ ((aligned (4)));*/
317  
318 /** @} */
319  
320 /*-----------------------------------------------------------------------------------*/
321 /* Functions that are used by the uIP application program. Opening and
322 * closing connections, sending and receiving data, etc. is all
323 * handled by the functions below.
324 */
325 /**
326 * \defgroup uipappfunc uIP application functions
327 * @{
328 *
329 * Functions used by an application running of top of uIP.
330 */
331  
332 /**
333 * Start listening to the specified port.
334 *
335 * \note Since this function expects the port number in network byte
336 * order, a conversion using HTONS() or htons() is necessary.
337 *
338 \code
339 uip_listen(HTONS(80));
340 \endcode
341 *
342 * \param port A 16-bit port number in network byte order.
343 */
344 void uip_listen(u16_t port);
345  
346 /**
347 * Stop listening to the specified port.
348 *
349 * \note Since this function expects the port number in network byte
350 * order, a conversion using HTONS() or htons() is necessary.
351 *
352 \code
353 uip_unlisten(HTONS(80));
354 \endcode
355 *
356 * \param port A 16-bit port number in network byte order.
357 */
358 void uip_unlisten(u16_t port);
359  
360 /**
361 * Connect to a remote host using TCP.
362 *
363 * This function is used to start a new connection to the specified
364 * port on the specied host. It allocates a new connection identifier,
365 * sets the connection to the SYN_SENT state and sets the
366 * retransmission timer to 0. This will cause a TCP SYN segment to be
367 * sent out the next time this connection is periodically processed,
368 * which usually is done within 0.5 seconds after the call to
369 * uip_connect().
370 *
371 * \note This function is avaliable only if support for active open
372 * has been configured by defining UIP_ACTIVE_OPEN to 1 in uipopt.h.
373 *
374 * \note Since this function requires the port number to be in network
375 * byte order, a convertion using HTONS() or htons() is necessary.
376 *
377 \code
378 u16_t ipaddr[2];
379  
380 uip_ipaddr(ipaddr, 192,168,1,2);
381 uip_connect(ipaddr, HTONS(80));
382 \endcode
383 *
384 * \param ripaddr A pointer to a 4-byte array representing the IP
385 * address of the remote hot.
386 *
387 * \param port A 16-bit port number in network byte order.
388 *
389 * \return A pointer to the uIP connection identifier for the new connection,
390 * or NULL if no connection could be allocated.
391 *
392 */
393 struct uip_conn *uip_connect(u16_t *ripaddr, u16_t port);
394  
395  
396  
397 /**
398 * \internal
399 *
400 * Check if a connection has outstanding (i.e., unacknowledged) data.
401 *
402 * \param conn A pointer to the uip_conn structure for the connection.
403 *
404 * \hideinitializer
405 */
406 #define uip_outstanding(conn) ((conn)->len)
407  
408 /**
409 * Send data on the current connection.
410 *
411 * This function is used to send out a single segment of TCP
412 * data. Only applications that have been invoked by uIP for event
413 * processing can send data.
414 *
415 * The amount of data that actually is sent out after a call to this
416 * funcion is determined by the maximum amount of data TCP allows. uIP
417 * will automatically crop the data so that only the appropriate
418 * amount of data is sent. The function uip_mss() can be used to query
419 * uIP for the amount of data that actually will be sent.
420 *
421 * \note This function does not guarantee that the sent data will
422 * arrive at the destination. If the data is lost in the network, the
423 * application will be invoked with the uip_rexmit() event being
424 * set. The application will then have to resend the data using this
425 * function.
426 *
427 * \param data A pointer to the data which is to be sent.
428 *
429 * \param len The maximum amount of data bytes to be sent.
430 *
431 * \hideinitializer
432 */
433 #define uip_send(data, len) do { uip_sappdata = (data); uip_slen = (len);} while(0)
434  
435 /**
436 * The length of any incoming data that is currently avaliable (if avaliable)
437 * in the uip_appdata buffer.
438 *
439 * The test function uip_data() must first be used to check if there
440 * is any data available at all.
441 *
442 * \hideinitializer
443 */
444 #define uip_datalen() uip_len
445  
446 /**
447 * The length of any out-of-band data (urgent data) that has arrived
448 * on the connection.
449 *
450 * \note The configuration parameter UIP_URGDATA must be set for this
451 * function to be enabled.
452 *
453 * \hideinitializer
454 */
455 #define uip_urgdatalen() uip_urglen
456  
457 /**
458 * Close the current connection.
459 *
460 * This function will close the current connection in a nice way.
461 *
462 * \hideinitializer
463 */
464 #define uip_close() (uip_flags = UIP_CLOSE)
465  
466 /**
467 * Abort the current connection.
468 *
469 * This function will abort (reset) the current connection, and is
470 * usually used when an error has occured that prevents using the
471 * uip_close() function.
472 *
473 * \hideinitializer
474 */
475 #define uip_abort() (uip_flags = UIP_ABORT)
476  
477 /**
478 * Tell the sending host to stop sending data.
479 *
480 * This function will close our receiver's window so that we stop
481 * receiving data for the current connection.
482 *
483 * \hideinitializer
484 */
485 #define uip_stop() (uip_conn->tcpstateflags |= UIP_STOPPED)
486  
487 /**
488 * Find out if the current connection has been previously stopped with
489 * uip_stop().
490 *
491 * \hideinitializer
492 */
493 #define uip_stopped(conn) ((conn)->tcpstateflags & UIP_STOPPED)
494  
495 /**
496 * Restart the current connection, if is has previously been stopped
497 * with uip_stop().
498 *
499 * This function will open the receiver's window again so that we
500 * start receiving data for the current connection.
501 *
502 * \hideinitializer
503 */
504 #define uip_restart() do { uip_flags |= UIP_NEWDATA; \
505 uip_conn->tcpstateflags &= ~UIP_STOPPED; \
506 } while(0)
507  
508  
509 /* uIP tests that can be made to determine in what state the current
510 connection is, and what the application function should do. */
511  
512 /**
513 * Is new incoming data available?
514 *
515 * Will reduce to non-zero if there is new data for the application
516 * present at the uip_appdata pointer. The size of the data is
517 * avaliable through the uip_len variable.
518 *
519 * \hideinitializer
520 */
521 #define uip_newdata() (uip_flags & UIP_NEWDATA)
522  
523 /**
524 * Has previously sent data been acknowledged?
525 *
526 * Will reduce to non-zero if the previously sent data has been
527 * acknowledged by the remote host. This means that the application
528 * can send new data.
529 *
530 * \hideinitializer
531 */
532 #define uip_acked() (uip_flags & UIP_ACKDATA)
533  
534 /**
535 * Has the connection just been connected?
536 *
537 * Reduces to non-zero if the current connection has been connected to
538 * a remote host. This will happen both if the connection has been
539 * actively opened (with uip_connect()) or passively opened (with
540 * uip_listen()).
541 *
542 * \hideinitializer
543 */
544 #define uip_connected() (uip_flags & UIP_CONNECTED)
545  
546 /**
547 * Has the connection been closed by the other end?
548 *
549 * Is non-zero if the connection has been closed by the remote
550 * host. The application may then do the necessary clean-ups.
551 *
552 * \hideinitializer
553 */
554 #define uip_closed() (uip_flags & UIP_CLOSE)
555  
556 /**
557 * Has the connection been aborted by the other end?
558 *
559 * Non-zero if the current connection has been aborted (reset) by the
560 * remote host.
561 *
562 * \hideinitializer
563 */
564 #define uip_aborted() (uip_flags & UIP_ABORT)
565  
566 /**
567 * Has the connection timed out?
568 *
569 * Non-zero if the current connection has been aborted due to too many
570 * retransmissions.
571 *
572 * \hideinitializer
573 */
574 #define uip_timedout() (uip_flags & UIP_TIMEDOUT)
575  
576 /**
577 * Do we need to retransmit previously data?
578 *
579 * Reduces to non-zero if the previously sent data has been lost in
580 * the network, and the application should retransmit it. The
581 * application should send the exact same data as it did the last
582 * time, using the uip_send() function.
583 *
584 * \hideinitializer
585 */
586 #define uip_rexmit() (uip_flags & UIP_REXMIT)
587  
588 /**
589 * Is the connection being polled by uIP?
590 *
591 * Is non-zero if the reason the application is invoked is that the
592 * current connection has been idle for a while and should be
593 * polled.
594 *
595 * The polling event can be used for sending data without having to
596 * wait for the remote host to send data.
597 *
598 * \hideinitializer
599 */
600 #define uip_poll() (uip_flags & UIP_POLL)
601  
602 /**
603 * Get the initial maxium segment size (MSS) of the current
604 * connection.
605 *
606 * \hideinitializer
607 */
608 #define uip_initialmss() (uip_conn->initialmss)
609  
610 /**
611 * Get the current maxium segment size that can be sent on the current
612 * connection.
613 *
614 * The current maxiumum segment size that can be sent on the
615 * connection is computed from the receiver's window and the MSS of
616 * the connection (which also is available by calling
617 * uip_initialmss()).
618 *
619 * \hideinitializer
620 */
621 #define uip_mss() (uip_conn->mss)
622  
623 /**
624 * Set up a new UDP connection.
625 *
626 * \param ripaddr A pointer to a 4-byte structure representing the IP
627 * address of the remote host.
628 *
629 * \param rport The remote port number in network byte order.
630 *
631 * \return The uip_udp_conn structure for the new connection or NULL
632 * if no connection could be allocated.
633 */
634 struct uip_udp_conn *uip_udp_new(u16_t *ripaddr, u16_t rport);
635  
636 /**
637 * Removed a UDP connection.
638 *
639 * \param conn A pointer to the uip_udp_conn structure for the connection.
640 *
641 * \hideinitializer
642 */
643 #define uip_udp_remove(conn) (conn)->lport = 0
644  
645 /**
646 * Send a UDP datagram of length len on the current connection.
647 *
648 * This function can only be called in response to a UDP event (poll
649 * or newdata). The data must be present in the uip_buf buffer, at the
650 * place pointed to by the uip_appdata pointer.
651 *
652 * \param len The length of the data in the uip_buf buffer.
653 *
654 * \hideinitializer
655 */
656 #define uip_udp_send(len) uip_slen = (len)
657  
658 /** @} */
659  
660 /* uIP convenience and converting functions. */
661  
662 /**
663 * \defgroup uipconvfunc uIP conversion functions
664 * @{
665 *
666 * These functions can be used for converting between different data
667 * formats used by uIP.
668 */
669  
670 /**
671 * Pack an IP address into a 4-byte array which is used by uIP to
672 * represent IP addresses.
673 *
674 * Example:
675 \code
676 u16_t ipaddr[2];
677  
678 uip_ipaddr(&ipaddr, 192,168,1,2);
679 \endcode
680 *
681 * \param addr A pointer to a 4-byte array that will be filled in with
682 * the IP addres.
683 * \param addr0 The first octet of the IP address.
684 * \param addr1 The second octet of the IP address.
685 * \param addr2 The third octet of the IP address.
686 * \param addr3 The forth octet of the IP address.
687 *
688 * \hideinitializer
689 */
690 #define uip_ipaddr(addr, addr0,addr1,addr2,addr3) do { \
691 (addr)[0] = HTONS(((addr0) << 8) | (addr1)); \
692 (addr)[1] = HTONS(((addr2) << 8) | (addr3)); \
693 } while(0)
694  
695 /**
696 * Convert 16-bit quantity from host byte order to network byte order.
697 *
698 * This macro is primarily used for converting constants from host
699 * byte order to network byte order. For converting variables to
700 * network byte order, use the htons() function instead.
701 *
702 * \hideinitializer
703 */
704 #ifndef HTONS
705 # if BYTE_ORDER == BIG_ENDIAN
706 # define HTONS(n) (n)
707 # else /* BYTE_ORDER == BIG_ENDIAN */
708 # define HTONS(n) ((((u16_t)((n) & 0xff)) << 8) | (((n) & 0xff00) >> 8))
709 # endif /* BYTE_ORDER == BIG_ENDIAN */
710 #endif /* HTONS */
711  
712 /**
713 * Convert 16-bit quantity from host byte order to network byte order.
714 *
715 * This function is primarily used for converting variables from host
716 * byte order to network byte order. For converting constants to
717 * network byte order, use the HTONS() macro instead.
718 */
719 #ifndef htons
720 u16_t htons(u16_t val);
721 #endif /* htons */
722  
723 /** @} */
724  
725 /**
726 * Pointer to the application data in the packet buffer.
727 *
728 * This pointer points to the application data when the application is
729 * called. If the application wishes to send data, the application may
730 * use this space to write the data into before calling uip_send().
731 */
732 extern volatile u8_t *uip_appdata;
733 extern volatile u8_t *uip_sappdata;
734  
735 #if UIP_URGDATA > 0
736 /* u8_t *uip_urgdata:
737 *
738 * This pointer points to any urgent data that has been received. Only
739 * present if compiled with support for urgent data (UIP_URGDATA).
740 */
741 extern volatile u8_t *uip_urgdata;
742 #endif /* UIP_URGDATA > 0 */
743  
744  
745 /* u[8|16]_t uip_len:
746 *
747 * When the application is called, uip_len contains the length of any
748 * new data that has been received from the remote host. The
749 * application should set this variable to the size of any data that
750 * the application wishes to send. When the network device driver
751 * output function is called, uip_len should contain the length of the
752 * outgoing packet.
753 */
754 extern u16_t uip_len, uip_slen;
755  
756 #if UIP_URGDATA > 0
757 extern u8_t uip_urglen, uip_surglen;
758 #endif /* UIP_URGDATA > 0 */
759  
760  
761 /**
762 * Representation of a uIP TCP connection.
763 *
764 * The uip_conn structure is used for identifying a connection. All
765 * but one field in the structure are to be considered read-only by an
766 * application. The only exception is the appstate field whos purpose
767 * is to let the application store application-specific state (e.g.,
768 * file pointers) for the connection. The size of this field is
769 * configured in the "uipopt.h" header file.
770 */
771 struct uip_conn {
772 u16_t ripaddr[2]; /**< The IP address of the remote host. */
773  
774 u16_t lport; /**< The local TCP port, in network byte order. */
775 u16_t rport; /**< The local remote TCP port, in network byte
776 order. */
777  
778 u8_t rcv_nxt[4]; /**< The sequence number that we expect to
779 receive next. */
780 u8_t snd_nxt[4]; /**< The sequence number that was last sent by
781 us. */
782 u16_t len; /**< Length of the data that was previously sent. */
783 u16_t mss; /**< Current maximum segment size for the
784 connection. */
785 u16_t initialmss; /**< Initial maximum segment size for the
786 connection. */
787 u8_t sa; /**< Retransmission time-out calculation state
788 variable. */
789 u8_t sv; /**< Retransmission time-out calculation state
790 variable. */
791 u8_t rto; /**< Retransmission time-out. */
792 u8_t tcpstateflags; /**< TCP state and flags. */
793 u8_t timer; /**< The retransmission timer. */
794 u8_t nrtx; /**< The number of retransmissions for the last
795 segment sent. */
796  
797 /** The application state. */
798 u8_t appstate[UIP_APPSTATE_SIZE];
799 };
800  
801  
802 /* Pointer to the current connection. */
803 extern struct uip_conn *uip_conn;
804 /* The array containing all uIP connections. */
805 extern struct uip_conn uip_conns[UIP_CONNS];
806 /**
807 * \addtogroup uiparch
808 * @{
809 */
810  
811 /**
812 * 4-byte array used for the 32-bit sequence number calculations.
813 */
814 extern volatile u8_t uip_acc32[4];
815  
816 /** @} */
817  
818  
819 #if UIP_UDP
820 /**
821 * Representation of a uIP UDP connection.
822 */
823 struct uip_udp_conn {
824 u16_t ripaddr[2]; /**< The IP address of the remote peer. */
825 u16_t lport; /**< The local port number in network byte order. */
826 u16_t rport; /**< The remote port number in network byte order. */
827 };
828  
829 extern struct uip_udp_conn *uip_udp_conn;
830 extern struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
831 #endif /* UIP_UDP */
832  
833 /**
834 * The structure holding the TCP/IP statistics that are gathered if
835 * UIP_STATISTICS is set to 1.
836 *
837 */
838 struct uip_stats {
839 struct {
840 uip_stats_t drop; /**< Number of dropped packets at the IP
841 layer. */
842 uip_stats_t recv; /**< Number of received packets at the IP
843 layer. */
844 uip_stats_t sent; /**< Number of sent packets at the IP
845 layer. */
846 uip_stats_t vhlerr; /**< Number of packets dropped due to wrong
847 IP version or header length. */
848 uip_stats_t hblenerr; /**< Number of packets dropped due to wrong
849 IP length, high byte. */
850 uip_stats_t lblenerr; /**< Number of packets dropped due to wrong
851 IP length, low byte. */
852 uip_stats_t fragerr; /**< Number of packets dropped since they
853 were IP fragments. */
854 uip_stats_t chkerr; /**< Number of packets dropped due to IP
855 checksum errors. */
856 uip_stats_t protoerr; /**< Number of packets dropped since they
857 were neither ICMP, UDP nor TCP. */
858 } ip; /**< IP statistics. */
859 struct {
860 uip_stats_t drop; /**< Number of dropped ICMP packets. */
861 uip_stats_t recv; /**< Number of received ICMP packets. */
862 uip_stats_t sent; /**< Number of sent ICMP packets. */
863 uip_stats_t typeerr; /**< Number of ICMP packets with a wrong
864 type. */
865 } icmp; /**< ICMP statistics. */
866 struct {
867 uip_stats_t drop; /**< Number of dropped TCP segments. */
868 uip_stats_t recv; /**< Number of recived TCP segments. */
869 uip_stats_t sent; /**< Number of sent TCP segments. */
870 uip_stats_t chkerr; /**< Number of TCP segments with a bad
871 checksum. */
872 uip_stats_t ackerr; /**< Number of TCP segments with a bad ACK
873 number. */
874 uip_stats_t rst; /**< Number of recevied TCP RST (reset) segments. */
875 uip_stats_t rexmit; /**< Number of retransmitted TCP segments. */
876 uip_stats_t syndrop; /**< Number of dropped SYNs due to too few
877 connections was avaliable. */
878 uip_stats_t synrst; /**< Number of SYNs for closed ports,
879 triggering a RST. */
880 } tcp; /**< TCP statistics. */
881 };
882  
883 /**
884 * The uIP TCP/IP statistics.
885 *
886 * This is the variable in which the uIP TCP/IP statistics are gathered.
887 */
888 extern struct uip_stats uip_stat;
889  
890  
891 /*-----------------------------------------------------------------------------------*/
892 /* All the stuff below this point is internal to uIP and should not be
893 * used directly by an application or by a device driver.
894 */
895 /*-----------------------------------------------------------------------------------*/
896 /* u8_t uip_flags:
897 *
898 * When the application is called, uip_flags will contain the flags
899 * that are defined in this file. Please read below for more
900 * infomation.
901 */
902 extern volatile u8_t uip_flags;
903  
904 /* The following flags may be set in the global variable uip_flags
905 before calling the application callback. The UIP_ACKDATA and
906 UIP_NEWDATA flags may both be set at the same time, whereas the
907 others are mutualy exclusive. Note that these flags should *NOT* be
908 accessed directly, but through the uIP functions/macros. */
909  
910 #define UIP_ACKDATA 1 /* Signifies that the outstanding data was
911 acked and the application should send
912 out new data instead of retransmitting
913 the last data. */
914 #define UIP_NEWDATA 2 /* Flags the fact that the peer has sent
915 us new data. */
916 #define UIP_REXMIT 4 /* Tells the application to retransmit the
917 data that was last sent. */
918 #define UIP_POLL 8 /* Used for polling the application, to
919 check if the application has data that
920 it wants to send. */
921 #define UIP_CLOSE 16 /* The remote host has closed the
922 connection, thus the connection has
923 gone away. Or the application signals
924 that it wants to close the
925 connection. */
926 #define UIP_ABORT 32 /* The remote host has aborted the
927 connection, thus the connection has
928 gone away. Or the application signals
929 that it wants to abort the
930 connection. */
931 #define UIP_CONNECTED 64 /* We have got a connection from a remote
932 host and have set up a new connection
933 for it, or an active connection has
934 been successfully established. */
935  
936 #define UIP_TIMEDOUT 128 /* The connection has been aborted due to
937 too many retransmissions. */
938  
939  
940 /* uip_process(flag):
941 *
942 * The actual uIP function which does all the work.
943 */
944 void uip_process(u8_t flag);
945  
946 void udp_appcall(void);
947  
948 /* The following flags are passed as an argument to the uip_process()
949 function. They are used to distinguish between the two cases where
950 uip_process() is called. It can be called either because we have
951 incoming data that should be processed, or because the periodic
952 timer has fired. */
953  
954 #define UIP_DATA 1 /* Tells uIP that there is incoming data in
955 the uip_buf buffer. The length of the
956 data is stored in the global variable
957 uip_len. */
958 #define UIP_TIMER 2 /* Tells uIP that the periodic timer has
959 fired. */
960 #if UIP_UDP
961 #define UIP_UDP_TIMER 3
962 #endif /* UIP_UDP */
963  
964 /* The TCP states used in the uip_conn->tcpstateflags. */
965 #define CLOSED 0
966 #define SYN_RCVD 1
967 #define SYN_SENT 2
968 #define ESTABLISHED 3
969 #define FIN_WAIT_1 4
970 #define FIN_WAIT_2 5
971 #define CLOSING 6
972 #define TIME_WAIT 7
973 #define LAST_ACK 8
974 #define TS_MASK 15
975  
976 #define UIP_STOPPED 16
977  
978 #define UIP_TCPIP_HLEN 40
979  
980 /* The TCP and IP headers. */
981 typedef struct {
982 /* IP header. */
983 u8_t vhl,
984 tos,
985 len[2],
986 ipid[2],
987 ipoffset[2],
988 ttl,
989 proto;
990 u16_t ipchksum;
991 u16_t srcipaddr[2],
992 destipaddr[2];
993  
994 /* TCP header. */
995 u16_t srcport,
996 destport;
997 u8_t seqno[4],
998 ackno[4],
999 tcpoffset,
1000 flags,
1001 wnd[2];
1002 u16_t tcpchksum;
1003 u8_t urgp[2];
1004 u8_t optdata[4];
1005 } uip_tcpip_hdr;
1006  
1007 /* The ICMP and IP headers. */
1008 typedef struct {
1009 /* IP header. */
1010 u8_t vhl,
1011 tos,
1012 len[2],
1013 ipid[2],
1014 ipoffset[2],
1015 ttl,
1016 proto;
1017 u16_t ipchksum;
1018 u16_t srcipaddr[2],
1019 destipaddr[2];
1020 /* ICMP (echo) header. */
1021 u8_t type, icode;
1022 u16_t icmpchksum;
1023 u16_t id, seqno;
1024 } uip_icmpip_hdr;
1025  
1026  
1027 /* The UDP and IP headers. */
1028 typedef struct {
1029 /* IP header. */
1030 u8_t vhl,
1031 tos,
1032 len[2],
1033 ipid[2],
1034 ipoffset[2],
1035 ttl,
1036 proto;
1037 u16_t ipchksum;
1038 u16_t srcipaddr[2],
1039 destipaddr[2];
1040  
1041 /* UDP header. */
1042 u16_t srcport,
1043 destport;
1044 u16_t udplen;
1045 u16_t udpchksum;
1046 } uip_udpip_hdr;
1047  
1048 #define UIP_PROTO_ICMP 1
1049 #define UIP_PROTO_TCP 6
1050 #define UIP_PROTO_UDP 17
1051  
1052 #if UIP_FIXEDADDR
1053 extern const u16_t uip_hostaddr[2];
1054 #else /* UIP_FIXEDADDR */
1055 extern u16_t uip_hostaddr[2];
1056 #endif /* UIP_FIXEDADDR */
1057  
1058 #endif /* __UIP_H__ */
1059  
1060  
1061 /** @} */
1062