Mercurial > templog
comparison network/uip.h @ 107:56d09a0969b5 avr-http
Import uIP and the PPP implementation from
https://code.google.com/p/avrusbmodem/
author | Matt Johnston <matt@ucc.asn.au> |
---|---|
date | Fri, 07 Sep 2012 23:53:53 +0800 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
106:5c8404549cc0 | 107:56d09a0969b5 |
---|---|
1 | |
2 /** | |
3 * \addtogroup uip | |
4 * @{ | |
5 */ | |
6 | |
7 /** | |
8 * \file | |
9 * Header file for the uIP TCP/IP stack. | |
10 * \author Adam Dunkels <[email protected]> | |
11 * \author Julien Abeille <[email protected]> (IPv6 related code) | |
12 * \author Mathilde Durvy <[email protected]> (IPv6 related code) | |
13 * | |
14 * The uIP TCP/IP stack header file contains definitions for a number | |
15 * of C macros that are used by uIP programs as well as internal uIP | |
16 * structures, TCP/IP header structures and function declarations. | |
17 * | |
18 */ | |
19 | |
20 /* | |
21 * Copyright (c) 2001-2003, Adam Dunkels. | |
22 * All rights reserved. | |
23 * | |
24 * Redistribution and use in source and binary forms, with or without | |
25 * modification, are permitted provided that the following conditions | |
26 * are met: | |
27 * 1. Redistributions of source code must retain the above copyright | |
28 * notice, this list of conditions and the following disclaimer. | |
29 * 2. Redistributions in binary form must reproduce the above copyright | |
30 * notice, this list of conditions and the following disclaimer in the | |
31 * documentation and/or other materials provided with the distribution. | |
32 * 3. The name of the author may not be used to endorse or promote | |
33 * products derived from this software without specific prior | |
34 * written permission. | |
35 * | |
36 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS | |
37 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |
38 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
39 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY | |
40 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
41 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE | |
42 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
43 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | |
44 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | |
45 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | |
46 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
47 * | |
48 * This file is part of the uIP TCP/IP stack. | |
49 * | |
50 * $Id: uip.h,v 1.35 2010/10/19 18:29:04 adamdunkels Exp $ | |
51 * | |
52 */ | |
53 | |
54 #ifndef __UIP_H__ | |
55 #define __UIP_H__ | |
56 | |
57 #include "uipopt.h" | |
58 #define CCIF | |
59 | |
60 /** | |
61 * Representation of an IP address. | |
62 * | |
63 */ | |
64 #if UIP_CONF_IPV6 | |
65 typedef union uip_ip6addr_t { | |
66 u8_t u8[16]; /* Initializer, must come first!!! */ | |
67 u16_t u16[8]; | |
68 } uip_ip6addr_t; | |
69 | |
70 typedef uip_ip6addr_t uip_ipaddr_t; | |
71 #else /* UIP_CONF_IPV6 */ | |
72 typedef union uip_ip4addr_t { | |
73 u8_t u8[4]; /* Initializer, must come first!!! */ | |
74 u16_t u16[2]; | |
75 #if 0 | |
76 u32_t u32; | |
77 #endif | |
78 } uip_ip4addr_t; | |
79 typedef uip_ip4addr_t uip_ipaddr_t; | |
80 #endif /* UIP_CONF_IPV6 */ | |
81 | |
82 | |
83 /*---------------------------------------------------------------------------*/ | |
84 | |
85 /** \brief 16 bit 802.15.4 address */ | |
86 typedef struct uip_802154_shortaddr { | |
87 u8_t addr[2]; | |
88 } uip_802154_shortaddr; | |
89 /** \brief 64 bit 802.15.4 address */ | |
90 typedef struct uip_802154_longaddr { | |
91 u8_t addr[8]; | |
92 } uip_802154_longaddr; | |
93 | |
94 /** \brief 802.11 address */ | |
95 typedef struct uip_80211_addr { | |
96 u8_t addr[6]; | |
97 } uip_80211_addr; | |
98 | |
99 /** \brief 802.3 address */ | |
100 typedef struct uip_eth_addr { | |
101 u8_t addr[6]; | |
102 } uip_eth_addr; | |
103 | |
104 | |
105 #if UIP_CONF_LL_802154 | |
106 /** \brief 802.15.4 address */ | |
107 typedef uip_802154_longaddr uip_lladdr_t; | |
108 #define UIP_802154_SHORTADDR_LEN 2 | |
109 #define UIP_802154_LONGADDR_LEN 8 | |
110 #define UIP_LLADDR_LEN UIP_802154_LONGADDR_LEN | |
111 #else /*UIP_CONF_LL_802154*/ | |
112 #if UIP_CONF_LL_80211 | |
113 /** \brief 802.11 address */ | |
114 typedef uip_80211_addr uip_lladdr_t; | |
115 #define UIP_LLADDR_LEN 6 | |
116 #else /*UIP_CONF_LL_80211*/ | |
117 /** \brief Ethernet address */ | |
118 typedef uip_eth_addr uip_lladdr_t; | |
119 #define UIP_LLADDR_LEN 6 | |
120 #endif /*UIP_CONF_LL_80211*/ | |
121 #endif /*UIP_CONF_LL_802154*/ | |
122 | |
123 //#include "net/tcpip.h" | |
124 | |
125 /*---------------------------------------------------------------------------*/ | |
126 /* First, the functions that should be called from the | |
127 * system. Initialization, the periodic timer, and incoming packets are | |
128 * handled by the following three functions. | |
129 */ | |
130 /** | |
131 * \defgroup uipconffunc uIP configuration functions | |
132 * @{ | |
133 * | |
134 * The uIP configuration functions are used for setting run-time | |
135 * parameters in uIP such as IP addresses. | |
136 */ | |
137 | |
138 /** | |
139 * Set the IP address of this host. | |
140 * | |
141 * The IP address is represented as a 4-byte array where the first | |
142 * octet of the IP address is put in the first member of the 4-byte | |
143 * array. | |
144 * | |
145 * Example: | |
146 \code | |
147 | |
148 uip_ipaddr_t addr; | |
149 | |
150 uip_ipaddr(&addr, 192,168,1,2); | |
151 uip_sethostaddr(&addr); | |
152 | |
153 \endcode | |
154 * \param addr A pointer to an IP address of type uip_ipaddr_t; | |
155 * | |
156 * \sa uip_ipaddr() | |
157 * | |
158 * \hideinitializer | |
159 */ | |
160 #define uip_sethostaddr(addr) uip_ipaddr_copy(&uip_hostaddr, (addr)) | |
161 | |
162 /** | |
163 * Get the IP address of this host. | |
164 * | |
165 * The IP address is represented as a 4-byte array where the first | |
166 * octet of the IP address is put in the first member of the 4-byte | |
167 * array. | |
168 * | |
169 * Example: | |
170 \code | |
171 uip_ipaddr_t hostaddr; | |
172 | |
173 uip_gethostaddr(&hostaddr); | |
174 \endcode | |
175 * \param addr A pointer to a uip_ipaddr_t variable that will be | |
176 * filled in with the currently configured IP address. | |
177 * | |
178 * \hideinitializer | |
179 */ | |
180 #define uip_gethostaddr(addr) uip_ipaddr_copy((addr), &uip_hostaddr) | |
181 | |
182 /** | |
183 * Set the default router's IP address. | |
184 * | |
185 * \param addr A pointer to a uip_ipaddr_t variable containing the IP | |
186 * address of the default router. | |
187 * | |
188 * \sa uip_ipaddr() | |
189 * | |
190 * \hideinitializer | |
191 */ | |
192 #define uip_setdraddr(addr) uip_ipaddr_copy(&uip_draddr, (addr)) | |
193 | |
194 /** | |
195 * Set the netmask. | |
196 * | |
197 * \param addr A pointer to a uip_ipaddr_t variable containing the IP | |
198 * address of the netmask. | |
199 * | |
200 * \sa uip_ipaddr() | |
201 * | |
202 * \hideinitializer | |
203 */ | |
204 #define uip_setnetmask(addr) uip_ipaddr_copy(&uip_netmask, (addr)) | |
205 | |
206 | |
207 /** | |
208 * Get the default router's IP address. | |
209 * | |
210 * \param addr A pointer to a uip_ipaddr_t variable that will be | |
211 * filled in with the IP address of the default router. | |
212 * | |
213 * \hideinitializer | |
214 */ | |
215 #define uip_getdraddr(addr) uip_ipaddr_copy((addr), &uip_draddr) | |
216 | |
217 /** | |
218 * Get the netmask. | |
219 * | |
220 * \param addr A pointer to a uip_ipaddr_t variable that will be | |
221 * filled in with the value of the netmask. | |
222 * | |
223 * \hideinitializer | |
224 */ | |
225 #define uip_getnetmask(addr) uip_ipaddr_copy((addr), &uip_netmask) | |
226 | |
227 /** @} */ | |
228 | |
229 /** | |
230 * \defgroup uipinit uIP initialization functions | |
231 * @{ | |
232 * | |
233 * The uIP initialization functions are used for booting uIP. | |
234 */ | |
235 | |
236 /** | |
237 * uIP initialization function. | |
238 * | |
239 * This function should be called at boot up to initilize the uIP | |
240 * TCP/IP stack. | |
241 */ | |
242 void uip_init(void); | |
243 | |
244 /** | |
245 * uIP initialization function. | |
246 * | |
247 * This function may be used at boot time to set the initial ip_id. | |
248 */ | |
249 void uip_setipid(u16_t id); | |
250 | |
251 /** @} */ | |
252 | |
253 /** | |
254 * \defgroup uipdevfunc uIP device driver functions | |
255 * @{ | |
256 * | |
257 * These functions are used by a network device driver for interacting | |
258 * with uIP. | |
259 */ | |
260 | |
261 /** | |
262 * Process an incoming packet. | |
263 * | |
264 * This function should be called when the device driver has received | |
265 * a packet from the network. The packet from the device driver must | |
266 * be present in the uip_buf buffer, and the length of the packet | |
267 * should be placed in the uip_len variable. | |
268 * | |
269 * When the function returns, there may be an outbound packet placed | |
270 * in the uip_buf packet buffer. If so, the uip_len variable is set to | |
271 * the length of the packet. If no packet is to be sent out, the | |
272 * uip_len variable is set to 0. | |
273 * | |
274 * The usual way of calling the function is presented by the source | |
275 * code below. | |
276 \code | |
277 uip_len = devicedriver_poll(); | |
278 if(uip_len > 0) { | |
279 uip_input(); | |
280 if(uip_len > 0) { | |
281 devicedriver_send(); | |
282 } | |
283 } | |
284 \endcode | |
285 * | |
286 * \note If you are writing a uIP device driver that needs ARP | |
287 * (Address Resolution Protocol), e.g., when running uIP over | |
288 * Ethernet, you will need to call the uIP ARP code before calling | |
289 * this function: | |
290 \code | |
291 #define BUF ((struct uip_eth_hdr *)&uip_buf[0]) | |
292 uip_len = ethernet_devicedrver_poll(); | |
293 if(uip_len > 0) { | |
294 if(BUF->type == UIP_HTONS(UIP_ETHTYPE_IP)) { | |
295 uip_arp_ipin(); | |
296 uip_input(); | |
297 if(uip_len > 0) { | |
298 uip_arp_out(); | |
299 ethernet_devicedriver_send(); | |
300 } | |
301 } else if(BUF->type == UIP_HTONS(UIP_ETHTYPE_ARP)) { | |
302 uip_arp_arpin(); | |
303 if(uip_len > 0) { | |
304 ethernet_devicedriver_send(); | |
305 } | |
306 } | |
307 \endcode | |
308 * | |
309 * \hideinitializer | |
310 */ | |
311 #define uip_input() uip_process(UIP_DATA) | |
312 | |
313 | |
314 /** | |
315 * Periodic processing for a connection identified by its number. | |
316 * | |
317 * This function does the necessary periodic processing (timers, | |
318 * polling) for a uIP TCP conneciton, and should be called when the | |
319 * periodic uIP timer goes off. It should be called for every | |
320 * connection, regardless of whether they are open of closed. | |
321 * | |
322 * When the function returns, it may have an outbound packet waiting | |
323 * for service in the uIP packet buffer, and if so the uip_len | |
324 * variable is set to a value larger than zero. The device driver | |
325 * should be called to send out the packet. | |
326 * | |
327 * The usual way of calling the function is through a for() loop like | |
328 * this: | |
329 \code | |
330 for(i = 0; i < UIP_CONNS; ++i) { | |
331 uip_periodic(i); | |
332 if(uip_len > 0) { | |
333 devicedriver_send(); | |
334 } | |
335 } | |
336 \endcode | |
337 * | |
338 * \note If you are writing a uIP device driver that needs ARP | |
339 * (Address Resolution Protocol), e.g., when running uIP over | |
340 * Ethernet, you will need to call the uip_arp_out() function before | |
341 * calling the device driver: | |
342 \code | |
343 for(i = 0; i < UIP_CONNS; ++i) { | |
344 uip_periodic(i); | |
345 if(uip_len > 0) { | |
346 uip_arp_out(); | |
347 ethernet_devicedriver_send(); | |
348 } | |
349 } | |
350 \endcode | |
351 * | |
352 * \param conn The number of the connection which is to be periodically polled. | |
353 * | |
354 * \hideinitializer | |
355 */ | |
356 #if UIP_TCP | |
357 #define uip_periodic(conn) do { uip_conn = &uip_conns[conn]; \ | |
358 uip_process(UIP_TIMER); } while (0) | |
359 | |
360 /** | |
361 * | |
362 * | |
363 */ | |
364 #define uip_conn_active(conn) (uip_conns[conn].tcpstateflags != UIP_CLOSED) | |
365 | |
366 /** | |
367 * Perform periodic processing for a connection identified by a pointer | |
368 * to its structure. | |
369 * | |
370 * Same as uip_periodic() but takes a pointer to the actual uip_conn | |
371 * struct instead of an integer as its argument. This function can be | |
372 * used to force periodic processing of a specific connection. | |
373 * | |
374 * \param conn A pointer to the uip_conn struct for the connection to | |
375 * be processed. | |
376 * | |
377 * \hideinitializer | |
378 */ | |
379 #define uip_periodic_conn(conn) do { uip_conn = conn; \ | |
380 uip_process(UIP_TIMER); } while (0) | |
381 | |
382 /** | |
383 * Request that a particular connection should be polled. | |
384 * | |
385 * Similar to uip_periodic_conn() but does not perform any timer | |
386 * processing. The application is polled for new data. | |
387 * | |
388 * \param conn A pointer to the uip_conn struct for the connection to | |
389 * be processed. | |
390 * | |
391 * \hideinitializer | |
392 */ | |
393 #define uip_poll_conn(conn) do { uip_conn = conn; \ | |
394 uip_process(UIP_POLL_REQUEST); } while (0) | |
395 | |
396 #endif /* UIP_TCP */ | |
397 | |
398 #if UIP_UDP | |
399 /** | |
400 * Periodic processing for a UDP connection identified by its number. | |
401 * | |
402 * This function is essentially the same as uip_periodic(), but for | |
403 * UDP connections. It is called in a similar fashion as the | |
404 * uip_periodic() function: | |
405 \code | |
406 for(i = 0; i < UIP_UDP_CONNS; i++) { | |
407 uip_udp_periodic(i); | |
408 if(uip_len > 0) { | |
409 devicedriver_send(); | |
410 } | |
411 } | |
412 \endcode | |
413 * | |
414 * \note As for the uip_periodic() function, special care has to be | |
415 * taken when using uIP together with ARP and Ethernet: | |
416 \code | |
417 for(i = 0; i < UIP_UDP_CONNS; i++) { | |
418 uip_udp_periodic(i); | |
419 if(uip_len > 0) { | |
420 uip_arp_out(); | |
421 ethernet_devicedriver_send(); | |
422 } | |
423 } | |
424 \endcode | |
425 * | |
426 * \param conn The number of the UDP connection to be processed. | |
427 * | |
428 * \hideinitializer | |
429 */ | |
430 #define uip_udp_periodic(conn) do { uip_udp_conn = &uip_udp_conns[conn]; \ | |
431 uip_process(UIP_UDP_TIMER); } while(0) | |
432 | |
433 /** | |
434 * Periodic processing for a UDP connection identified by a pointer to | |
435 * its structure. | |
436 * | |
437 * Same as uip_udp_periodic() but takes a pointer to the actual | |
438 * uip_conn struct instead of an integer as its argument. This | |
439 * function can be used to force periodic processing of a specific | |
440 * connection. | |
441 * | |
442 * \param conn A pointer to the uip_udp_conn struct for the connection | |
443 * to be processed. | |
444 * | |
445 * \hideinitializer | |
446 */ | |
447 #define uip_udp_periodic_conn(conn) do { uip_udp_conn = conn; \ | |
448 uip_process(UIP_UDP_TIMER); } while(0) | |
449 #endif /* UIP_UDP */ | |
450 | |
451 /** \brief Abandon the reassembly of the current packet */ | |
452 void uip_reass_over(void); | |
453 | |
454 /** | |
455 * The uIP packet buffer. | |
456 * | |
457 * The uip_buf array is used to hold incoming and outgoing | |
458 * packets. The device driver should place incoming data into this | |
459 * buffer. When sending data, the device driver should read the link | |
460 * level headers and the TCP/IP headers from this buffer. The size of | |
461 * the link level headers is configured by the UIP_LLH_LEN define. | |
462 * | |
463 * \note The application data need not be placed in this buffer, so | |
464 * the device driver must read it from the place pointed to by the | |
465 * uip_appdata pointer as illustrated by the following example: | |
466 \code | |
467 void | |
468 devicedriver_send(void) | |
469 { | |
470 hwsend(&uip_buf[0], UIP_LLH_LEN); | |
471 if(uip_len <= UIP_LLH_LEN + UIP_TCPIP_HLEN) { | |
472 hwsend(&uip_buf[UIP_LLH_LEN], uip_len - UIP_LLH_LEN); | |
473 } else { | |
474 hwsend(&uip_buf[UIP_LLH_LEN], UIP_TCPIP_HLEN); | |
475 hwsend(uip_appdata, uip_len - UIP_TCPIP_HLEN - UIP_LLH_LEN); | |
476 } | |
477 } | |
478 \endcode | |
479 */ | |
480 | |
481 typedef union { | |
482 uint32_t u32[(UIP_BUFSIZE + 3) / 4]; | |
483 uint8_t u8[UIP_BUFSIZE]; | |
484 } uip_buf_t; | |
485 | |
486 CCIF extern uip_buf_t uip_aligned_buf; | |
487 #define uip_buf (uip_aligned_buf.u8) | |
488 | |
489 | |
490 /** @} */ | |
491 | |
492 /*---------------------------------------------------------------------------*/ | |
493 /* Functions that are used by the uIP application program. Opening and | |
494 * closing connections, sending and receiving data, etc. is all | |
495 * handled by the functions below. | |
496 */ | |
497 /** | |
498 * \defgroup uipappfunc uIP application functions | |
499 * @{ | |
500 * | |
501 * Functions used by an application running of top of uIP. | |
502 */ | |
503 | |
504 /** | |
505 * Start listening to the specified port. | |
506 * | |
507 * \note Since this function expects the port number in network byte | |
508 * order, a conversion using UIP_HTONS() or uip_htons() is necessary. | |
509 * | |
510 \code | |
511 uip_listen(UIP_HTONS(80)); | |
512 \endcode | |
513 * | |
514 * \param port A 16-bit port number in network byte order. | |
515 */ | |
516 void uip_listen(u16_t port); | |
517 | |
518 /** | |
519 * Stop listening to the specified port. | |
520 * | |
521 * \note Since this function expects the port number in network byte | |
522 * order, a conversion using UIP_HTONS() or uip_htons() is necessary. | |
523 * | |
524 \code | |
525 uip_unlisten(UIP_HTONS(80)); | |
526 \endcode | |
527 * | |
528 * \param port A 16-bit port number in network byte order. | |
529 */ | |
530 void uip_unlisten(u16_t port); | |
531 | |
532 /** | |
533 * Connect to a remote host using TCP. | |
534 * | |
535 * This function is used to start a new connection to the specified | |
536 * port on the specified host. It allocates a new connection identifier, | |
537 * sets the connection to the SYN_SENT state and sets the | |
538 * retransmission timer to 0. This will cause a TCP SYN segment to be | |
539 * sent out the next time this connection is periodically processed, | |
540 * which usually is done within 0.5 seconds after the call to | |
541 * uip_connect(). | |
542 * | |
543 * \note This function is available only if support for active open | |
544 * has been configured by defining UIP_ACTIVE_OPEN to 1 in uipopt.h. | |
545 * | |
546 * \note Since this function requires the port number to be in network | |
547 * byte order, a conversion using UIP_HTONS() or uip_htons() is necessary. | |
548 * | |
549 \code | |
550 uip_ipaddr_t ipaddr; | |
551 | |
552 uip_ipaddr(&ipaddr, 192,168,1,2); | |
553 uip_connect(&ipaddr, UIP_HTONS(80)); | |
554 \endcode | |
555 * | |
556 * \param ripaddr The IP address of the remote host. | |
557 * | |
558 * \param port A 16-bit port number in network byte order. | |
559 * | |
560 * \return A pointer to the uIP connection identifier for the new connection, | |
561 * or NULL if no connection could be allocated. | |
562 * | |
563 */ | |
564 struct uip_conn *uip_connect(uip_ipaddr_t *ripaddr, u16_t port); | |
565 | |
566 | |
567 | |
568 /** | |
569 * \internal | |
570 * | |
571 * Check if a connection has outstanding (i.e., unacknowledged) data. | |
572 * | |
573 * \param conn A pointer to the uip_conn structure for the connection. | |
574 * | |
575 * \hideinitializer | |
576 */ | |
577 #define uip_outstanding(conn) ((conn)->len) | |
578 | |
579 /** | |
580 * Send data on the current connection. | |
581 * | |
582 * This function is used to send out a single segment of TCP | |
583 * data. Only applications that have been invoked by uIP for event | |
584 * processing can send data. | |
585 * | |
586 * The amount of data that actually is sent out after a call to this | |
587 * function is determined by the maximum amount of data TCP allows. uIP | |
588 * will automatically crop the data so that only the appropriate | |
589 * amount of data is sent. The function uip_mss() can be used to query | |
590 * uIP for the amount of data that actually will be sent. | |
591 * | |
592 * \note This function does not guarantee that the sent data will | |
593 * arrive at the destination. If the data is lost in the network, the | |
594 * application will be invoked with the uip_rexmit() event being | |
595 * set. The application will then have to resend the data using this | |
596 * function. | |
597 * | |
598 * \param data A pointer to the data which is to be sent. | |
599 * | |
600 * \param len The maximum amount of data bytes to be sent. | |
601 * | |
602 * \hideinitializer | |
603 */ | |
604 CCIF void uip_send(const void *data, int len); | |
605 | |
606 /** | |
607 * The length of any incoming data that is currently available (if available) | |
608 * in the uip_appdata buffer. | |
609 * | |
610 * The test function uip_data() must first be used to check if there | |
611 * is any data available at all. | |
612 * | |
613 * \hideinitializer | |
614 */ | |
615 /*void uip_datalen(void);*/ | |
616 #define uip_datalen() uip_len | |
617 | |
618 /** | |
619 * The length of any out-of-band data (urgent data) that has arrived | |
620 * on the connection. | |
621 * | |
622 * \note The configuration parameter UIP_URGDATA must be set for this | |
623 * function to be enabled. | |
624 * | |
625 * \hideinitializer | |
626 */ | |
627 #define uip_urgdatalen() uip_urglen | |
628 | |
629 /** | |
630 * Close the current connection. | |
631 * | |
632 * This function will close the current connection in a nice way. | |
633 * | |
634 * \hideinitializer | |
635 */ | |
636 #define uip_close() (uip_flags = UIP_CLOSE) | |
637 | |
638 /** | |
639 * Abort the current connection. | |
640 * | |
641 * This function will abort (reset) the current connection, and is | |
642 * usually used when an error has occurred that prevents using the | |
643 * uip_close() function. | |
644 * | |
645 * \hideinitializer | |
646 */ | |
647 #define uip_abort() (uip_flags = UIP_ABORT) | |
648 | |
649 /** | |
650 * Tell the sending host to stop sending data. | |
651 * | |
652 * This function will close our receiver's window so that we stop | |
653 * receiving data for the current connection. | |
654 * | |
655 * \hideinitializer | |
656 */ | |
657 #define uip_stop() (uip_conn->tcpstateflags |= UIP_STOPPED) | |
658 | |
659 /** | |
660 * Find out if the current connection has been previously stopped with | |
661 * uip_stop(). | |
662 * | |
663 * \hideinitializer | |
664 */ | |
665 #define uip_stopped(conn) ((conn)->tcpstateflags & UIP_STOPPED) | |
666 | |
667 /** | |
668 * Restart the current connection, if is has previously been stopped | |
669 * with uip_stop(). | |
670 * | |
671 * This function will open the receiver's window again so that we | |
672 * start receiving data for the current connection. | |
673 * | |
674 * \hideinitializer | |
675 */ | |
676 #define uip_restart() do { uip_flags |= UIP_NEWDATA; \ | |
677 uip_conn->tcpstateflags &= ~UIP_STOPPED; \ | |
678 } while(0) | |
679 | |
680 | |
681 /* uIP tests that can be made to determine in what state the current | |
682 connection is, and what the application function should do. */ | |
683 | |
684 /** | |
685 * Is the current connection a UDP connection? | |
686 * | |
687 * This function checks whether the current connection is a UDP connection. | |
688 * | |
689 * \hideinitializer | |
690 * | |
691 */ | |
692 #define uip_udpconnection() (uip_conn == NULL) | |
693 | |
694 /** | |
695 * Is new incoming data available? | |
696 * | |
697 * Will reduce to non-zero if there is new data for the application | |
698 * present at the uip_appdata pointer. The size of the data is | |
699 * available through the uip_len variable. | |
700 * | |
701 * \hideinitializer | |
702 */ | |
703 #define uip_newdata() (uip_flags & UIP_NEWDATA) | |
704 | |
705 /** | |
706 * Has previously sent data been acknowledged? | |
707 * | |
708 * Will reduce to non-zero if the previously sent data has been | |
709 * acknowledged by the remote host. This means that the application | |
710 * can send new data. | |
711 * | |
712 * \hideinitializer | |
713 */ | |
714 #define uip_acked() (uip_flags & UIP_ACKDATA) | |
715 | |
716 /** | |
717 * Has the connection just been connected? | |
718 * | |
719 * Reduces to non-zero if the current connection has been connected to | |
720 * a remote host. This will happen both if the connection has been | |
721 * actively opened (with uip_connect()) or passively opened (with | |
722 * uip_listen()). | |
723 * | |
724 * \hideinitializer | |
725 */ | |
726 #define uip_connected() (uip_flags & UIP_CONNECTED) | |
727 | |
728 /** | |
729 * Has the connection been closed by the other end? | |
730 * | |
731 * Is non-zero if the connection has been closed by the remote | |
732 * host. The application may then do the necessary clean-ups. | |
733 * | |
734 * \hideinitializer | |
735 */ | |
736 #define uip_closed() (uip_flags & UIP_CLOSE) | |
737 | |
738 /** | |
739 * Has the connection been aborted by the other end? | |
740 * | |
741 * Non-zero if the current connection has been aborted (reset) by the | |
742 * remote host. | |
743 * | |
744 * \hideinitializer | |
745 */ | |
746 #define uip_aborted() (uip_flags & UIP_ABORT) | |
747 | |
748 /** | |
749 * Has the connection timed out? | |
750 * | |
751 * Non-zero if the current connection has been aborted due to too many | |
752 * retransmissions. | |
753 * | |
754 * \hideinitializer | |
755 */ | |
756 #define uip_timedout() (uip_flags & UIP_TIMEDOUT) | |
757 | |
758 /** | |
759 * Do we need to retransmit previously data? | |
760 * | |
761 * Reduces to non-zero if the previously sent data has been lost in | |
762 * the network, and the application should retransmit it. The | |
763 * application should send the exact same data as it did the last | |
764 * time, using the uip_send() function. | |
765 * | |
766 * \hideinitializer | |
767 */ | |
768 #define uip_rexmit() (uip_flags & UIP_REXMIT) | |
769 | |
770 /** | |
771 * Is the connection being polled by uIP? | |
772 * | |
773 * Is non-zero if the reason the application is invoked is that the | |
774 * current connection has been idle for a while and should be | |
775 * polled. | |
776 * | |
777 * The polling event can be used for sending data without having to | |
778 * wait for the remote host to send data. | |
779 * | |
780 * \hideinitializer | |
781 */ | |
782 #define uip_poll() (uip_flags & UIP_POLL) | |
783 | |
784 /** | |
785 * Get the initial maximum segment size (MSS) of the current | |
786 * connection. | |
787 * | |
788 * \hideinitializer | |
789 */ | |
790 #define uip_initialmss() (uip_conn->initialmss) | |
791 | |
792 /** | |
793 * Get the current maximum segment size that can be sent on the current | |
794 * connection. | |
795 * | |
796 * The current maximum segment size that can be sent on the | |
797 * connection is computed from the receiver's window and the MSS of | |
798 * the connection (which also is available by calling | |
799 * uip_initialmss()). | |
800 * | |
801 * \hideinitializer | |
802 */ | |
803 #define uip_mss() (uip_conn->mss) | |
804 | |
805 /** | |
806 * Set up a new UDP connection. | |
807 * | |
808 * This function sets up a new UDP connection. The function will | |
809 * automatically allocate an unused local port for the new | |
810 * connection. However, another port can be chosen by using the | |
811 * uip_udp_bind() call, after the uip_udp_new() function has been | |
812 * called. | |
813 * | |
814 * Example: | |
815 \code | |
816 uip_ipaddr_t addr; | |
817 struct uip_udp_conn *c; | |
818 | |
819 uip_ipaddr(&addr, 192,168,2,1); | |
820 c = uip_udp_new(&addr, UIP_HTONS(12345)); | |
821 if(c != NULL) { | |
822 uip_udp_bind(c, UIP_HTONS(12344)); | |
823 } | |
824 \endcode | |
825 * \param ripaddr The IP address of the remote host. | |
826 * | |
827 * \param rport The remote port number in network byte order. | |
828 * | |
829 * \return The uip_udp_conn structure for the new connection or NULL | |
830 * if no connection could be allocated. | |
831 */ | |
832 struct uip_udp_conn *uip_udp_new(const uip_ipaddr_t *ripaddr, u16_t rport); | |
833 | |
834 /** | |
835 * Removed a UDP connection. | |
836 * | |
837 * \param conn A pointer to the uip_udp_conn structure for the connection. | |
838 * | |
839 * \hideinitializer | |
840 */ | |
841 #define uip_udp_remove(conn) (conn)->lport = 0 | |
842 | |
843 /** | |
844 * Bind a UDP connection to a local port. | |
845 * | |
846 * \param conn A pointer to the uip_udp_conn structure for the | |
847 * connection. | |
848 * | |
849 * \param port The local port number, in network byte order. | |
850 * | |
851 * \hideinitializer | |
852 */ | |
853 #define uip_udp_bind(conn, port) (conn)->lport = port | |
854 | |
855 /** | |
856 * Send a UDP datagram of length len on the current connection. | |
857 * | |
858 * This function can only be called in response to a UDP event (poll | |
859 * or newdata). The data must be present in the uip_buf buffer, at the | |
860 * place pointed to by the uip_appdata pointer. | |
861 * | |
862 * \param len The length of the data in the uip_buf buffer. | |
863 * | |
864 * \hideinitializer | |
865 */ | |
866 #define uip_udp_send(len) uip_send((char *)uip_appdata, len) | |
867 | |
868 /** @} */ | |
869 | |
870 /* uIP convenience and converting functions. */ | |
871 | |
872 /** | |
873 * \defgroup uipconvfunc uIP conversion functions | |
874 * @{ | |
875 * | |
876 * These functions can be used for converting between different data | |
877 * formats used by uIP. | |
878 */ | |
879 | |
880 /** | |
881 * Convert an IP address to four bytes separated by commas. | |
882 * | |
883 * Example: | |
884 \code | |
885 uip_ipaddr_t ipaddr; | |
886 printf("ipaddr=%d.%d.%d.%d\n", uip_ipaddr_to_quad(&ipaddr)); | |
887 \endcode | |
888 * | |
889 * \param a A pointer to a uip_ipaddr_t. | |
890 * \hideinitializer | |
891 */ | |
892 #define uip_ipaddr_to_quad(a) (a)->u8[0],(a)->u8[1],(a)->u8[2],(a)->u8[3] | |
893 | |
894 /** | |
895 * Construct an IP address from four bytes. | |
896 * | |
897 * This function constructs an IP address of the type that uIP handles | |
898 * internally from four bytes. The function is handy for specifying IP | |
899 * addresses to use with e.g. the uip_connect() function. | |
900 * | |
901 * Example: | |
902 \code | |
903 uip_ipaddr_t ipaddr; | |
904 struct uip_conn *c; | |
905 | |
906 uip_ipaddr(&ipaddr, 192,168,1,2); | |
907 c = uip_connect(&ipaddr, UIP_HTONS(80)); | |
908 \endcode | |
909 * | |
910 * \param addr A pointer to a uip_ipaddr_t variable that will be | |
911 * filled in with the IP address. | |
912 * | |
913 * \param addr0 The first octet of the IP address. | |
914 * \param addr1 The second octet of the IP address. | |
915 * \param addr2 The third octet of the IP address. | |
916 * \param addr3 The forth octet of the IP address. | |
917 * | |
918 * \hideinitializer | |
919 */ | |
920 #define uip_ipaddr(addr, addr0,addr1,addr2,addr3) do { \ | |
921 (addr)->u8[0] = addr0; \ | |
922 (addr)->u8[1] = addr1; \ | |
923 (addr)->u8[2] = addr2; \ | |
924 (addr)->u8[3] = addr3; \ | |
925 } while(0) | |
926 | |
927 /** | |
928 * Construct an IPv6 address from eight 16-bit words. | |
929 * | |
930 * This function constructs an IPv6 address. | |
931 * | |
932 * \hideinitializer | |
933 */ | |
934 #define uip_ip6addr(addr, addr0,addr1,addr2,addr3,addr4,addr5,addr6,addr7) do { \ | |
935 (addr)->u16[0] = UIP_HTONS(addr0); \ | |
936 (addr)->u16[1] = UIP_HTONS(addr1); \ | |
937 (addr)->u16[2] = UIP_HTONS(addr2); \ | |
938 (addr)->u16[3] = UIP_HTONS(addr3); \ | |
939 (addr)->u16[4] = UIP_HTONS(addr4); \ | |
940 (addr)->u16[5] = UIP_HTONS(addr5); \ | |
941 (addr)->u16[6] = UIP_HTONS(addr6); \ | |
942 (addr)->u16[7] = UIP_HTONS(addr7); \ | |
943 } while(0) | |
944 | |
945 /** | |
946 * Construct an IPv6 address from eight 8-bit words. | |
947 * | |
948 * This function constructs an IPv6 address. | |
949 * | |
950 * \hideinitializer | |
951 */ | |
952 #define uip_ip6addr_u8(addr, addr0,addr1,addr2,addr3,addr4,addr5,addr6,addr7,addr8,addr9,addr10,addr11,addr12,addr13,addr14,addr15) do { \ | |
953 (addr)->u8[0] = addr0; \ | |
954 (addr)->u8[1] = addr1; \ | |
955 (addr)->u8[2] = addr2; \ | |
956 (addr)->u8[3] = addr3; \ | |
957 (addr)->u8[4] = addr4; \ | |
958 (addr)->u8[5] = addr5; \ | |
959 (addr)->u8[6] = addr6; \ | |
960 (addr)->u8[7] = addr7; \ | |
961 (addr)->u8[8] = addr8; \ | |
962 (addr)->u8[9] = addr9; \ | |
963 (addr)->u8[10] = addr10; \ | |
964 (addr)->u8[11] = addr11; \ | |
965 (addr)->u8[12] = addr12; \ | |
966 (addr)->u8[13] = addr13; \ | |
967 (addr)->u8[14] = addr14; \ | |
968 (addr)->u8[15] = addr15; \ | |
969 } while(0) | |
970 | |
971 | |
972 /** | |
973 * Copy an IP address to another IP address. | |
974 * | |
975 * Copies an IP address from one place to another. | |
976 * | |
977 * Example: | |
978 \code | |
979 uip_ipaddr_t ipaddr1, ipaddr2; | |
980 | |
981 uip_ipaddr(&ipaddr1, 192,16,1,2); | |
982 uip_ipaddr_copy(&ipaddr2, &ipaddr1); | |
983 \endcode | |
984 * | |
985 * \param dest The destination for the copy. | |
986 * \param src The source from where to copy. | |
987 * | |
988 * \hideinitializer | |
989 */ | |
990 #ifndef uip_ipaddr_copy | |
991 #define uip_ipaddr_copy(dest, src) (*(dest) = *(src)) | |
992 #endif | |
993 | |
994 /** | |
995 * Compare two IP addresses | |
996 * | |
997 * Compares two IP addresses. | |
998 * | |
999 * Example: | |
1000 \code | |
1001 uip_ipaddr_t ipaddr1, ipaddr2; | |
1002 | |
1003 uip_ipaddr(&ipaddr1, 192,16,1,2); | |
1004 if(uip_ipaddr_cmp(&ipaddr2, &ipaddr1)) { | |
1005 printf("They are the same"); | |
1006 } | |
1007 \endcode | |
1008 * | |
1009 * \param addr1 The first IP address. | |
1010 * \param addr2 The second IP address. | |
1011 * | |
1012 * \hideinitializer | |
1013 */ | |
1014 #if !UIP_CONF_IPV6 | |
1015 #define uip_ipaddr_cmp(addr1, addr2) ((addr1)->u16[0] == (addr2)->u16[0] && \ | |
1016 (addr1)->u16[1] == (addr2)->u16[1]) | |
1017 #else /* !UIP_CONF_IPV6 */ | |
1018 #define uip_ipaddr_cmp(addr1, addr2) (memcmp(addr1, addr2, sizeof(uip_ip6addr_t)) == 0) | |
1019 #endif /* !UIP_CONF_IPV6 */ | |
1020 | |
1021 /** | |
1022 * Compare two IP addresses with netmasks | |
1023 * | |
1024 * Compares two IP addresses with netmasks. The masks are used to mask | |
1025 * out the bits that are to be compared. | |
1026 * | |
1027 * Example: | |
1028 \code | |
1029 uip_ipaddr_t ipaddr1, ipaddr2, mask; | |
1030 | |
1031 uip_ipaddr(&mask, 255,255,255,0); | |
1032 uip_ipaddr(&ipaddr1, 192,16,1,2); | |
1033 uip_ipaddr(&ipaddr2, 192,16,1,3); | |
1034 if(uip_ipaddr_maskcmp(&ipaddr1, &ipaddr2, &mask)) { | |
1035 printf("They are the same"); | |
1036 } | |
1037 \endcode | |
1038 * | |
1039 * \param addr1 The first IP address. | |
1040 * \param addr2 The second IP address. | |
1041 * \param mask The netmask. | |
1042 * | |
1043 * \hideinitializer | |
1044 */ | |
1045 #if !UIP_CONF_IPV6 | |
1046 #define uip_ipaddr_maskcmp(addr1, addr2, mask) \ | |
1047 (((((u16_t *)addr1)[0] & ((u16_t *)mask)[0]) == \ | |
1048 (((u16_t *)addr2)[0] & ((u16_t *)mask)[0])) && \ | |
1049 ((((u16_t *)addr1)[1] & ((u16_t *)mask)[1]) == \ | |
1050 (((u16_t *)addr2)[1] & ((u16_t *)mask)[1]))) | |
1051 #else | |
1052 #define uip_ipaddr_prefixcmp(addr1, addr2, length) (memcmp(addr1, addr2, length>>3) == 0) | |
1053 #endif | |
1054 | |
1055 | |
1056 /** | |
1057 * Check if an address is a broadcast address for a network. | |
1058 * | |
1059 * Checks if an address is the broadcast address for a network. The | |
1060 * network is defined by an IP address that is on the network and the | |
1061 * network's netmask. | |
1062 * | |
1063 * \param addr The IP address. | |
1064 * \param netaddr The network's IP address. | |
1065 * \param netmask The network's netmask. | |
1066 * | |
1067 * \hideinitializer | |
1068 */ | |
1069 /*#define uip_ipaddr_isbroadcast(addr, netaddr, netmask) | |
1070 ((uip_ipaddr_t *)(addr)).u16 & ((uip_ipaddr_t *)(addr)).u16*/ | |
1071 | |
1072 | |
1073 | |
1074 /** | |
1075 * Mask out the network part of an IP address. | |
1076 * | |
1077 * Masks out the network part of an IP address, given the address and | |
1078 * the netmask. | |
1079 * | |
1080 * Example: | |
1081 \code | |
1082 uip_ipaddr_t ipaddr1, ipaddr2, netmask; | |
1083 | |
1084 uip_ipaddr(&ipaddr1, 192,16,1,2); | |
1085 uip_ipaddr(&netmask, 255,255,255,0); | |
1086 uip_ipaddr_mask(&ipaddr2, &ipaddr1, &netmask); | |
1087 \endcode | |
1088 * | |
1089 * In the example above, the variable "ipaddr2" will contain the IP | |
1090 * address 192.168.1.0. | |
1091 * | |
1092 * \param dest Where the result is to be placed. | |
1093 * \param src The IP address. | |
1094 * \param mask The netmask. | |
1095 * | |
1096 * \hideinitializer | |
1097 */ | |
1098 #define uip_ipaddr_mask(dest, src, mask) do { \ | |
1099 ((u16_t *)dest)[0] = ((u16_t *)src)[0] & ((u16_t *)mask)[0]; \ | |
1100 ((u16_t *)dest)[1] = ((u16_t *)src)[1] & ((u16_t *)mask)[1]; \ | |
1101 } while(0) | |
1102 | |
1103 /** | |
1104 * Pick the first octet of an IP address. | |
1105 * | |
1106 * Picks out the first octet of an IP address. | |
1107 * | |
1108 * Example: | |
1109 \code | |
1110 uip_ipaddr_t ipaddr; | |
1111 u8_t octet; | |
1112 | |
1113 uip_ipaddr(&ipaddr, 1,2,3,4); | |
1114 octet = uip_ipaddr1(&ipaddr); | |
1115 \endcode | |
1116 * | |
1117 * In the example above, the variable "octet" will contain the value 1. | |
1118 * | |
1119 * \hideinitializer | |
1120 */ | |
1121 #define uip_ipaddr1(addr) ((addr)->u8[0]) | |
1122 | |
1123 /** | |
1124 * Pick the second octet of an IP address. | |
1125 * | |
1126 * Picks out the second octet of an IP address. | |
1127 * | |
1128 * Example: | |
1129 \code | |
1130 uip_ipaddr_t ipaddr; | |
1131 u8_t octet; | |
1132 | |
1133 uip_ipaddr(&ipaddr, 1,2,3,4); | |
1134 octet = uip_ipaddr2(&ipaddr); | |
1135 \endcode | |
1136 * | |
1137 * In the example above, the variable "octet" will contain the value 2. | |
1138 * | |
1139 * \hideinitializer | |
1140 */ | |
1141 #define uip_ipaddr2(addr) ((addr)->u8[1]) | |
1142 | |
1143 /** | |
1144 * Pick the third octet of an IP address. | |
1145 * | |
1146 * Picks out the third octet of an IP address. | |
1147 * | |
1148 * Example: | |
1149 \code | |
1150 uip_ipaddr_t ipaddr; | |
1151 u8_t octet; | |
1152 | |
1153 uip_ipaddr(&ipaddr, 1,2,3,4); | |
1154 octet = uip_ipaddr3(&ipaddr); | |
1155 \endcode | |
1156 * | |
1157 * In the example above, the variable "octet" will contain the value 3. | |
1158 * | |
1159 * \hideinitializer | |
1160 */ | |
1161 #define uip_ipaddr3(addr) ((addr)->u8[2]) | |
1162 | |
1163 /** | |
1164 * Pick the fourth octet of an IP address. | |
1165 * | |
1166 * Picks out the fourth octet of an IP address. | |
1167 * | |
1168 * Example: | |
1169 \code | |
1170 uip_ipaddr_t ipaddr; | |
1171 u8_t octet; | |
1172 | |
1173 uip_ipaddr(&ipaddr, 1,2,3,4); | |
1174 octet = uip_ipaddr4(&ipaddr); | |
1175 \endcode | |
1176 * | |
1177 * In the example above, the variable "octet" will contain the value 4. | |
1178 * | |
1179 * \hideinitializer | |
1180 */ | |
1181 #define uip_ipaddr4(addr) ((addr)->u8[3]) | |
1182 | |
1183 /** | |
1184 * Convert 16-bit quantity from host byte order to network byte order. | |
1185 * | |
1186 * This macro is primarily used for converting constants from host | |
1187 * byte order to network byte order. For converting variables to | |
1188 * network byte order, use the uip_htons() function instead. | |
1189 * | |
1190 * \hideinitializer | |
1191 */ | |
1192 #ifndef UIP_HTONS | |
1193 # if UIP_BYTE_ORDER == UIP_BIG_ENDIAN | |
1194 # define UIP_HTONS(n) (n) | |
1195 # define UIP_HTONL(n) (n) | |
1196 # else /* UIP_BYTE_ORDER == UIP_BIG_ENDIAN */ | |
1197 # define UIP_HTONS(n) (u16_t)((((u16_t) (n)) << 8) | (((u16_t) (n)) >> 8)) | |
1198 # define UIP_HTONL(n) (((u32_t)UIP_HTONS(n) << 16) | UIP_HTONS((u32_t)(n) >> 16)) | |
1199 # endif /* UIP_BYTE_ORDER == UIP_BIG_ENDIAN */ | |
1200 #else | |
1201 #error "UIP_HTONS already defined!" | |
1202 #endif /* UIP_HTONS */ | |
1203 | |
1204 /** | |
1205 * Convert 16-bit quantity from host byte order to network byte order. | |
1206 * | |
1207 * This function is primarily used for converting variables from host | |
1208 * byte order to network byte order. For converting constants to | |
1209 * network byte order, use the UIP_HTONS() macro instead. | |
1210 */ | |
1211 #ifndef uip_htons | |
1212 CCIF u16_t uip_htons(u16_t val); | |
1213 #endif /* uip_htons */ | |
1214 #ifndef uip_ntohs | |
1215 #define uip_ntohs uip_htons | |
1216 #endif | |
1217 | |
1218 #ifndef uip_htonl | |
1219 CCIF u32_t uip_htonl(u32_t val); | |
1220 #endif /* uip_htonl */ | |
1221 #ifndef uip_ntohl | |
1222 #define uip_ntohl uip_htonl | |
1223 #endif | |
1224 | |
1225 /** @} */ | |
1226 | |
1227 /** | |
1228 * Pointer to the application data in the packet buffer. | |
1229 * | |
1230 * This pointer points to the application data when the application is | |
1231 * called. If the application wishes to send data, the application may | |
1232 * use this space to write the data into before calling uip_send(). | |
1233 */ | |
1234 CCIF extern void *uip_appdata; | |
1235 | |
1236 #if UIP_URGDATA > 0 | |
1237 /* u8_t *uip_urgdata: | |
1238 * | |
1239 * This pointer points to any urgent data that has been received. Only | |
1240 * present if compiled with support for urgent data (UIP_URGDATA). | |
1241 */ | |
1242 extern void *uip_urgdata; | |
1243 #endif /* UIP_URGDATA > 0 */ | |
1244 | |
1245 | |
1246 /** | |
1247 * \defgroup uipdrivervars Variables used in uIP device drivers | |
1248 * @{ | |
1249 * | |
1250 * uIP has a few global variables that are used in device drivers for | |
1251 * uIP. | |
1252 */ | |
1253 | |
1254 /** | |
1255 * The length of the packet in the uip_buf buffer. | |
1256 * | |
1257 * The global variable uip_len holds the length of the packet in the | |
1258 * uip_buf buffer. | |
1259 * | |
1260 * When the network device driver calls the uIP input function, | |
1261 * uip_len should be set to the length of the packet in the uip_buf | |
1262 * buffer. | |
1263 * | |
1264 * When sending packets, the device driver should use the contents of | |
1265 * the uip_len variable to determine the length of the outgoing | |
1266 * packet. | |
1267 * | |
1268 */ | |
1269 CCIF extern u16_t uip_len; | |
1270 | |
1271 /** | |
1272 * The length of the extension headers | |
1273 */ | |
1274 extern u8_t uip_ext_len; | |
1275 /** @} */ | |
1276 | |
1277 #if UIP_URGDATA > 0 | |
1278 extern u16_t uip_urglen, uip_surglen; | |
1279 #endif /* UIP_URGDATA > 0 */ | |
1280 | |
1281 | |
1282 /** | |
1283 * Representation of a uIP TCP connection. | |
1284 * | |
1285 * The uip_conn structure is used for identifying a connection. All | |
1286 * but one field in the structure are to be considered read-only by an | |
1287 * application. The only exception is the appstate field whose purpose | |
1288 * is to let the application store application-specific state (e.g., | |
1289 * file pointers) for the connection. The type of this field is | |
1290 * configured in the "uipopt.h" header file. | |
1291 */ | |
1292 struct uip_conn { | |
1293 uip_ipaddr_t ripaddr; /**< The IP address of the remote host. */ | |
1294 | |
1295 u16_t lport; /**< The local TCP port, in network byte order. */ | |
1296 u16_t rport; /**< The local remote TCP port, in network byte | |
1297 order. */ | |
1298 | |
1299 u8_t rcv_nxt[4]; /**< The sequence number that we expect to | |
1300 receive next. */ | |
1301 u8_t snd_nxt[4]; /**< The sequence number that was last sent by | |
1302 us. */ | |
1303 u16_t len; /**< Length of the data that was previously sent. */ | |
1304 u16_t mss; /**< Current maximum segment size for the | |
1305 connection. */ | |
1306 u16_t initialmss; /**< Initial maximum segment size for the | |
1307 connection. */ | |
1308 u8_t sa; /**< Retransmission time-out calculation state | |
1309 variable. */ | |
1310 u8_t sv; /**< Retransmission time-out calculation state | |
1311 variable. */ | |
1312 u8_t rto; /**< Retransmission time-out. */ | |
1313 u8_t tcpstateflags; /**< TCP state and flags. */ | |
1314 u8_t timer; /**< The retransmission timer. */ | |
1315 u8_t nrtx; /**< The number of retransmissions for the last | |
1316 segment sent. */ | |
1317 | |
1318 /** The application state. */ | |
1319 uip_tcp_appstate_t appstate; | |
1320 }; | |
1321 | |
1322 | |
1323 /** | |
1324 * Pointer to the current TCP connection. | |
1325 * | |
1326 * The uip_conn pointer can be used to access the current TCP | |
1327 * connection. | |
1328 */ | |
1329 | |
1330 CCIF extern struct uip_conn *uip_conn; | |
1331 #if UIP_TCP | |
1332 /* The array containing all uIP connections. */ | |
1333 CCIF extern struct uip_conn uip_conns[UIP_CONNS]; | |
1334 #endif | |
1335 | |
1336 /** | |
1337 * \addtogroup uiparch | |
1338 * @{ | |
1339 */ | |
1340 | |
1341 /** | |
1342 * 4-byte array used for the 32-bit sequence number calculations. | |
1343 */ | |
1344 extern u8_t uip_acc32[4]; | |
1345 /** @} */ | |
1346 | |
1347 /** | |
1348 * Representation of a uIP UDP connection. | |
1349 */ | |
1350 struct uip_udp_conn { | |
1351 uip_ipaddr_t ripaddr; /**< The IP address of the remote peer. */ | |
1352 u16_t lport; /**< The local port number in network byte order. */ | |
1353 u16_t rport; /**< The remote port number in network byte order. */ | |
1354 u8_t ttl; /**< Default time-to-live. */ | |
1355 | |
1356 /** The application state. */ | |
1357 uip_udp_appstate_t appstate; | |
1358 }; | |
1359 | |
1360 /** | |
1361 * The current UDP connection. | |
1362 */ | |
1363 extern struct uip_udp_conn *uip_udp_conn; | |
1364 extern struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS]; | |
1365 | |
1366 struct uip_fallback_interface { | |
1367 void (*init)(void); | |
1368 void (*output)(void); | |
1369 }; | |
1370 | |
1371 #if UIP_CONF_ICMP6 | |
1372 struct uip_icmp6_conn { | |
1373 uip_icmp6_appstate_t appstate; | |
1374 }; | |
1375 extern struct uip_icmp6_conn uip_icmp6_conns; | |
1376 #endif /*UIP_CONF_ICMP6*/ | |
1377 | |
1378 /** | |
1379 * The uIP TCP/IP statistics. | |
1380 * | |
1381 * This is the variable in which the uIP TCP/IP statistics are gathered. | |
1382 */ | |
1383 #if UIP_STATISTICS == 1 | |
1384 extern struct uip_stats uip_stat; | |
1385 #define UIP_STAT(s) s | |
1386 #else | |
1387 #define UIP_STAT(s) | |
1388 #endif /* UIP_STATISTICS == 1 */ | |
1389 | |
1390 /** | |
1391 * The structure holding the TCP/IP statistics that are gathered if | |
1392 * UIP_STATISTICS is set to 1. | |
1393 * | |
1394 */ | |
1395 struct uip_stats { | |
1396 struct { | |
1397 uip_stats_t recv; /**< Number of received packets at the IP | |
1398 layer. */ | |
1399 uip_stats_t sent; /**< Number of sent packets at the IP | |
1400 layer. */ | |
1401 uip_stats_t forwarded;/**< Number of forwarded packets at the IP | |
1402 layer. */ | |
1403 uip_stats_t drop; /**< Number of dropped packets at the IP | |
1404 layer. */ | |
1405 uip_stats_t vhlerr; /**< Number of packets dropped due to wrong | |
1406 IP version or header length. */ | |
1407 uip_stats_t hblenerr; /**< Number of packets dropped due to wrong | |
1408 IP length, high byte. */ | |
1409 uip_stats_t lblenerr; /**< Number of packets dropped due to wrong | |
1410 IP length, low byte. */ | |
1411 uip_stats_t fragerr; /**< Number of packets dropped since they | |
1412 were IP fragments. */ | |
1413 uip_stats_t chkerr; /**< Number of packets dropped due to IP | |
1414 checksum errors. */ | |
1415 uip_stats_t protoerr; /**< Number of packets dropped since they | |
1416 were neither ICMP, UDP nor TCP. */ | |
1417 } ip; /**< IP statistics. */ | |
1418 struct { | |
1419 uip_stats_t recv; /**< Number of received ICMP packets. */ | |
1420 uip_stats_t sent; /**< Number of sent ICMP packets. */ | |
1421 uip_stats_t drop; /**< Number of dropped ICMP packets. */ | |
1422 uip_stats_t typeerr; /**< Number of ICMP packets with a wrong | |
1423 type. */ | |
1424 uip_stats_t chkerr; /**< Number of ICMP packets with a bad | |
1425 checksum. */ | |
1426 } icmp; /**< ICMP statistics. */ | |
1427 #if UIP_TCP | |
1428 struct { | |
1429 uip_stats_t recv; /**< Number of recived TCP segments. */ | |
1430 uip_stats_t sent; /**< Number of sent TCP segments. */ | |
1431 uip_stats_t drop; /**< Number of dropped TCP segments. */ | |
1432 uip_stats_t chkerr; /**< Number of TCP segments with a bad | |
1433 checksum. */ | |
1434 uip_stats_t ackerr; /**< Number of TCP segments with a bad ACK | |
1435 number. */ | |
1436 uip_stats_t rst; /**< Number of recevied TCP RST (reset) segments. */ | |
1437 uip_stats_t rexmit; /**< Number of retransmitted TCP segments. */ | |
1438 uip_stats_t syndrop; /**< Number of dropped SYNs due to too few | |
1439 connections was avaliable. */ | |
1440 uip_stats_t synrst; /**< Number of SYNs for closed ports, | |
1441 triggering a RST. */ | |
1442 } tcp; /**< TCP statistics. */ | |
1443 #endif | |
1444 #if UIP_UDP | |
1445 struct { | |
1446 uip_stats_t drop; /**< Number of dropped UDP segments. */ | |
1447 uip_stats_t recv; /**< Number of recived UDP segments. */ | |
1448 uip_stats_t sent; /**< Number of sent UDP segments. */ | |
1449 uip_stats_t chkerr; /**< Number of UDP segments with a bad | |
1450 checksum. */ | |
1451 } udp; /**< UDP statistics. */ | |
1452 #endif /* UIP_UDP */ | |
1453 #if UIP_CONF_IPV6 | |
1454 struct { | |
1455 uip_stats_t drop; /**< Number of dropped ND6 packets. */ | |
1456 uip_stats_t recv; /**< Number of recived ND6 packets */ | |
1457 uip_stats_t sent; /**< Number of sent ND6 packets */ | |
1458 } nd6; | |
1459 #endif /*UIP_CONF_IPV6*/ | |
1460 }; | |
1461 | |
1462 | |
1463 /*---------------------------------------------------------------------------*/ | |
1464 /* All the stuff below this point is internal to uIP and should not be | |
1465 * used directly by an application or by a device driver. | |
1466 */ | |
1467 /*---------------------------------------------------------------------------*/ | |
1468 | |
1469 | |
1470 | |
1471 /* u8_t uip_flags: | |
1472 * | |
1473 * When the application is called, uip_flags will contain the flags | |
1474 * that are defined in this file. Please read below for more | |
1475 * information. | |
1476 */ | |
1477 CCIF extern u8_t uip_flags; | |
1478 | |
1479 /* The following flags may be set in the global variable uip_flags | |
1480 before calling the application callback. The UIP_ACKDATA, | |
1481 UIP_NEWDATA, and UIP_CLOSE flags may both be set at the same time, | |
1482 whereas the others are mutually exclusive. Note that these flags | |
1483 should *NOT* be accessed directly, but only through the uIP | |
1484 functions/macros. */ | |
1485 | |
1486 #define UIP_ACKDATA 1 /* Signifies that the outstanding data was | |
1487 acked and the application should send | |
1488 out new data instead of retransmitting | |
1489 the last data. */ | |
1490 #define UIP_NEWDATA 2 /* Flags the fact that the peer has sent | |
1491 us new data. */ | |
1492 #define UIP_REXMIT 4 /* Tells the application to retransmit the | |
1493 data that was last sent. */ | |
1494 #define UIP_POLL 8 /* Used for polling the application, to | |
1495 check if the application has data that | |
1496 it wants to send. */ | |
1497 #define UIP_CLOSE 16 /* The remote host has closed the | |
1498 connection, thus the connection has | |
1499 gone away. Or the application signals | |
1500 that it wants to close the | |
1501 connection. */ | |
1502 #define UIP_ABORT 32 /* The remote host has aborted the | |
1503 connection, thus the connection has | |
1504 gone away. Or the application signals | |
1505 that it wants to abort the | |
1506 connection. */ | |
1507 #define UIP_CONNECTED 64 /* We have got a connection from a remote | |
1508 host and have set up a new connection | |
1509 for it, or an active connection has | |
1510 been successfully established. */ | |
1511 | |
1512 #define UIP_TIMEDOUT 128 /* The connection has been aborted due to | |
1513 too many retransmissions. */ | |
1514 | |
1515 | |
1516 /** | |
1517 * \brief process the options within a hop by hop or destination option header | |
1518 * \retval 0: nothing to send, | |
1519 * \retval 1: drop pkt | |
1520 * \retval 2: ICMP error message to send | |
1521 */ | |
1522 /*static u8_t | |
1523 uip_ext_hdr_options_process(); */ | |
1524 | |
1525 /* uip_process(flag): | |
1526 * | |
1527 * The actual uIP function which does all the work. | |
1528 */ | |
1529 void uip_process(u8_t flag); | |
1530 | |
1531 /* The following flags are passed as an argument to the uip_process() | |
1532 function. They are used to distinguish between the two cases where | |
1533 uip_process() is called. It can be called either because we have | |
1534 incoming data that should be processed, or because the periodic | |
1535 timer has fired. These values are never used directly, but only in | |
1536 the macros defined in this file. */ | |
1537 | |
1538 #define UIP_DATA 1 /* Tells uIP that there is incoming | |
1539 data in the uip_buf buffer. The | |
1540 length of the data is stored in the | |
1541 global variable uip_len. */ | |
1542 #define UIP_TIMER 2 /* Tells uIP that the periodic timer | |
1543 has fired. */ | |
1544 #define UIP_POLL_REQUEST 3 /* Tells uIP that a connection should | |
1545 be polled. */ | |
1546 #define UIP_UDP_SEND_CONN 4 /* Tells uIP that a UDP datagram | |
1547 should be constructed in the | |
1548 uip_buf buffer. */ | |
1549 #if UIP_UDP | |
1550 #define UIP_UDP_TIMER 5 | |
1551 #endif /* UIP_UDP */ | |
1552 | |
1553 /* The TCP states used in the uip_conn->tcpstateflags. */ | |
1554 #define UIP_CLOSED 0 | |
1555 #define UIP_SYN_RCVD 1 | |
1556 #define UIP_SYN_SENT 2 | |
1557 #define UIP_ESTABLISHED 3 | |
1558 #define UIP_FIN_WAIT_1 4 | |
1559 #define UIP_FIN_WAIT_2 5 | |
1560 #define UIP_CLOSING 6 | |
1561 #define UIP_TIME_WAIT 7 | |
1562 #define UIP_LAST_ACK 8 | |
1563 #define UIP_TS_MASK 15 | |
1564 | |
1565 #define UIP_STOPPED 16 | |
1566 | |
1567 /* The TCP and IP headers. */ | |
1568 struct uip_tcpip_hdr { | |
1569 #if UIP_CONF_IPV6 | |
1570 /* IPv6 header. */ | |
1571 u8_t vtc, | |
1572 tcflow; | |
1573 u16_t flow; | |
1574 u8_t len[2]; | |
1575 u8_t proto, ttl; | |
1576 uip_ip6addr_t srcipaddr, destipaddr; | |
1577 #else /* UIP_CONF_IPV6 */ | |
1578 /* IPv4 header. */ | |
1579 u8_t vhl, | |
1580 tos, | |
1581 len[2], | |
1582 ipid[2], | |
1583 ipoffset[2], | |
1584 ttl, | |
1585 proto; | |
1586 u16_t ipchksum; | |
1587 uip_ipaddr_t srcipaddr, destipaddr; | |
1588 #endif /* UIP_CONF_IPV6 */ | |
1589 | |
1590 /* TCP header. */ | |
1591 u16_t srcport, | |
1592 destport; | |
1593 u8_t seqno[4], | |
1594 ackno[4], | |
1595 tcpoffset, | |
1596 flags, | |
1597 wnd[2]; | |
1598 u16_t tcpchksum; | |
1599 u8_t urgp[2]; | |
1600 u8_t optdata[4]; | |
1601 }; | |
1602 | |
1603 /* The ICMP and IP headers. */ | |
1604 struct uip_icmpip_hdr { | |
1605 #if UIP_CONF_IPV6 | |
1606 /* IPv6 header. */ | |
1607 u8_t vtc, | |
1608 tcf; | |
1609 u16_t flow; | |
1610 u8_t len[2]; | |
1611 u8_t proto, ttl; | |
1612 uip_ip6addr_t srcipaddr, destipaddr; | |
1613 #else /* UIP_CONF_IPV6 */ | |
1614 /* IPv4 header. */ | |
1615 u8_t vhl, | |
1616 tos, | |
1617 len[2], | |
1618 ipid[2], | |
1619 ipoffset[2], | |
1620 ttl, | |
1621 proto; | |
1622 u16_t ipchksum; | |
1623 uip_ipaddr_t srcipaddr, destipaddr; | |
1624 #endif /* UIP_CONF_IPV6 */ | |
1625 | |
1626 /* ICMP header. */ | |
1627 u8_t type, icode; | |
1628 u16_t icmpchksum; | |
1629 #if !UIP_CONF_IPV6 | |
1630 u16_t id, seqno; | |
1631 u8_t payload[1]; | |
1632 #endif /* !UIP_CONF_IPV6 */ | |
1633 }; | |
1634 | |
1635 | |
1636 /* The UDP and IP headers. */ | |
1637 struct uip_udpip_hdr { | |
1638 #if UIP_CONF_IPV6 | |
1639 /* IPv6 header. */ | |
1640 u8_t vtc, | |
1641 tcf; | |
1642 u16_t flow; | |
1643 u8_t len[2]; | |
1644 u8_t proto, ttl; | |
1645 uip_ip6addr_t srcipaddr, destipaddr; | |
1646 #else /* UIP_CONF_IPV6 */ | |
1647 /* IP header. */ | |
1648 u8_t vhl, | |
1649 tos, | |
1650 len[2], | |
1651 ipid[2], | |
1652 ipoffset[2], | |
1653 ttl, | |
1654 proto; | |
1655 u16_t ipchksum; | |
1656 uip_ipaddr_t srcipaddr, destipaddr; | |
1657 #endif /* UIP_CONF_IPV6 */ | |
1658 | |
1659 /* UDP header. */ | |
1660 u16_t srcport, | |
1661 destport; | |
1662 u16_t udplen; | |
1663 u16_t udpchksum; | |
1664 }; | |
1665 | |
1666 /* | |
1667 * In IPv6 the length of the L3 headers before the transport header is | |
1668 * not fixed, due to the possibility to include extension option headers | |
1669 * after the IP header. hence we split here L3 and L4 headers | |
1670 */ | |
1671 /* The IP header */ | |
1672 struct uip_ip_hdr { | |
1673 #if UIP_CONF_IPV6 | |
1674 /* IPV6 header */ | |
1675 u8_t vtc; | |
1676 u8_t tcflow; | |
1677 u16_t flow; | |
1678 u8_t len[2]; | |
1679 u8_t proto, ttl; | |
1680 uip_ip6addr_t srcipaddr, destipaddr; | |
1681 #else /* UIP_CONF_IPV6 */ | |
1682 /* IPV4 header */ | |
1683 u8_t vhl, | |
1684 tos, | |
1685 len[2], | |
1686 ipid[2], | |
1687 ipoffset[2], | |
1688 ttl, | |
1689 proto; | |
1690 u16_t ipchksum; | |
1691 uip_ipaddr_t srcipaddr, destipaddr; | |
1692 #endif /* UIP_CONF_IPV6 */ | |
1693 }; | |
1694 | |
1695 | |
1696 /* | |
1697 * IPv6 extension option headers: we are able to process | |
1698 * the 4 extension headers defined in RFC2460 (IPv6): | |
1699 * - Hop by hop option header, destination option header: | |
1700 * These two are not used by any core IPv6 protocol, hence | |
1701 * we just read them and go to the next. They convey options, | |
1702 * the options defined in RFC2460 are Pad1 and PadN, which do | |
1703 * some padding, and that we do not need to read (the length | |
1704 * field in the header is enough) | |
1705 * - Routing header: this one is most notably used by MIPv6, | |
1706 * which we do not implement, hence we just read it and go | |
1707 * to the next | |
1708 * - Fragmentation header: we read this header and are able to | |
1709 * reassemble packets | |
1710 * | |
1711 * We do not offer any means to send packets with extension headers | |
1712 * | |
1713 * We do not implement Authentication and ESP headers, which are | |
1714 * used in IPSec and defined in RFC4302,4303,4305,4385 | |
1715 */ | |
1716 /* common header part */ | |
1717 typedef struct uip_ext_hdr { | |
1718 u8_t next; | |
1719 u8_t len; | |
1720 } uip_ext_hdr; | |
1721 | |
1722 /* Hop by Hop option header */ | |
1723 typedef struct uip_hbho_hdr { | |
1724 u8_t next; | |
1725 u8_t len; | |
1726 } uip_hbho_hdr; | |
1727 | |
1728 /* destination option header */ | |
1729 typedef struct uip_desto_hdr { | |
1730 u8_t next; | |
1731 u8_t len; | |
1732 } uip_desto_hdr; | |
1733 | |
1734 /* We do not define structures for PAD1 and PADN options */ | |
1735 | |
1736 /* | |
1737 * routing header | |
1738 * the routing header as 4 common bytes, then routing header type | |
1739 * specific data there are several types of routing header. Type 0 was | |
1740 * deprecated as per RFC5095 most notable other type is 2, used in | |
1741 * RFC3775 (MIPv6) here we do not implement MIPv6, so we just need to | |
1742 * parse the 4 first bytes | |
1743 */ | |
1744 typedef struct uip_routing_hdr { | |
1745 u8_t next; | |
1746 u8_t len; | |
1747 u8_t routing_type; | |
1748 u8_t seg_left; | |
1749 } uip_routing_hdr; | |
1750 | |
1751 /* fragmentation header */ | |
1752 typedef struct uip_frag_hdr { | |
1753 u8_t next; | |
1754 u8_t res; | |
1755 u16_t offsetresmore; | |
1756 u32_t id; | |
1757 } uip_frag_hdr; | |
1758 | |
1759 /* | |
1760 * an option within the destination or hop by hop option headers | |
1761 * it contains type an length, which is true for all options but PAD1 | |
1762 */ | |
1763 typedef struct uip_ext_hdr_opt { | |
1764 u8_t type; | |
1765 u8_t len; | |
1766 } uip_ext_hdr_opt; | |
1767 | |
1768 /* PADN option */ | |
1769 typedef struct uip_ext_hdr_opt_padn { | |
1770 u8_t opt_type; | |
1771 u8_t opt_len; | |
1772 } uip_ext_hdr_opt_padn; | |
1773 | |
1774 /* TCP header */ | |
1775 struct uip_tcp_hdr { | |
1776 u16_t srcport; | |
1777 u16_t destport; | |
1778 u8_t seqno[4]; | |
1779 u8_t ackno[4]; | |
1780 u8_t tcpoffset; | |
1781 u8_t flags; | |
1782 u8_t wnd[2]; | |
1783 u16_t tcpchksum; | |
1784 u8_t urgp[2]; | |
1785 u8_t optdata[4]; | |
1786 }; | |
1787 | |
1788 /* The ICMP headers. */ | |
1789 struct uip_icmp_hdr { | |
1790 u8_t type, icode; | |
1791 u16_t icmpchksum; | |
1792 #if !UIP_CONF_IPV6 | |
1793 u16_t id, seqno; | |
1794 #endif /* !UIP_CONF_IPV6 */ | |
1795 }; | |
1796 | |
1797 | |
1798 /* The UDP headers. */ | |
1799 struct uip_udp_hdr { | |
1800 u16_t srcport; | |
1801 u16_t destport; | |
1802 u16_t udplen; | |
1803 u16_t udpchksum; | |
1804 }; | |
1805 | |
1806 | |
1807 /** | |
1808 * The buffer size available for user data in the \ref uip_buf buffer. | |
1809 * | |
1810 * This macro holds the available size for user data in the \ref | |
1811 * uip_buf buffer. The macro is intended to be used for checking | |
1812 * bounds of available user data. | |
1813 * | |
1814 * Example: | |
1815 \code | |
1816 snprintf(uip_appdata, UIP_APPDATA_SIZE, "%u\n", i); | |
1817 \endcode | |
1818 * | |
1819 * \hideinitializer | |
1820 */ | |
1821 #define UIP_APPDATA_SIZE (UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN) | |
1822 #define UIP_APPDATA_PTR (void *)&uip_buf[UIP_LLH_LEN + UIP_TCPIP_HLEN] | |
1823 | |
1824 #define UIP_PROTO_ICMP 1 | |
1825 #define UIP_PROTO_TCP 6 | |
1826 #define UIP_PROTO_UDP 17 | |
1827 #define UIP_PROTO_ICMP6 58 | |
1828 | |
1829 | |
1830 #if UIP_CONF_IPV6 | |
1831 /** @{ */ | |
1832 /** \brief extension headers types */ | |
1833 #define UIP_PROTO_HBHO 0 | |
1834 #define UIP_PROTO_DESTO 60 | |
1835 #define UIP_PROTO_ROUTING 43 | |
1836 #define UIP_PROTO_FRAG 44 | |
1837 #define UIP_PROTO_NONE 59 | |
1838 /** @} */ | |
1839 | |
1840 /** @{ */ | |
1841 /** \brief Destination and Hop By Hop extension headers option types */ | |
1842 #define UIP_EXT_HDR_OPT_PAD1 0 | |
1843 #define UIP_EXT_HDR_OPT_PADN 1 | |
1844 /** @} */ | |
1845 | |
1846 /** @{ */ | |
1847 /** | |
1848 * \brief Bitmaps for extension header processing | |
1849 * | |
1850 * When processing extension headers, we should record somehow which one we | |
1851 * see, because you cannot have twice the same header, except for destination | |
1852 * We store all this in one u8_t bitmap one bit for each header expected. The | |
1853 * order in the bitmap is the order recommended in RFC2460 | |
1854 */ | |
1855 #define UIP_EXT_HDR_BITMAP_HBHO 0x01 | |
1856 #define UIP_EXT_HDR_BITMAP_DESTO1 0x02 | |
1857 #define UIP_EXT_HDR_BITMAP_ROUTING 0x04 | |
1858 #define UIP_EXT_HDR_BITMAP_FRAG 0x08 | |
1859 #define UIP_EXT_HDR_BITMAP_AH 0x10 | |
1860 #define UIP_EXT_HDR_BITMAP_ESP 0x20 | |
1861 #define UIP_EXT_HDR_BITMAP_DESTO2 0x40 | |
1862 /** @} */ | |
1863 | |
1864 | |
1865 #endif /* UIP_CONF_IPV6 */ | |
1866 | |
1867 | |
1868 /* Header sizes. */ | |
1869 #if UIP_CONF_IPV6 | |
1870 #define UIP_IPH_LEN 40 | |
1871 #define UIP_FRAGH_LEN 8 | |
1872 #else /* UIP_CONF_IPV6 */ | |
1873 #define UIP_IPH_LEN 20 /* Size of IP header */ | |
1874 #endif /* UIP_CONF_IPV6 */ | |
1875 | |
1876 #define UIP_UDPH_LEN 8 /* Size of UDP header */ | |
1877 #define UIP_TCPH_LEN 20 /* Size of TCP header */ | |
1878 #ifdef UIP_IPH_LEN | |
1879 #define UIP_ICMPH_LEN 4 /* Size of ICMP header */ | |
1880 #endif | |
1881 #define UIP_IPUDPH_LEN (UIP_UDPH_LEN + UIP_IPH_LEN) /* Size of IP + | |
1882 * UDP | |
1883 * header */ | |
1884 #define UIP_IPTCPH_LEN (UIP_TCPH_LEN + UIP_IPH_LEN) /* Size of IP + | |
1885 * TCP | |
1886 * header */ | |
1887 #define UIP_TCPIP_HLEN UIP_IPTCPH_LEN | |
1888 #define UIP_IPICMPH_LEN (UIP_IPH_LEN + UIP_ICMPH_LEN) /* size of ICMP | |
1889 + IP header */ | |
1890 #define UIP_LLIPH_LEN (UIP_LLH_LEN + UIP_IPH_LEN) /* size of L2 | |
1891 + IP header */ | |
1892 #if UIP_CONF_IPV6 | |
1893 /** | |
1894 * The sums below are quite used in ND. When used for uip_buf, we | |
1895 * include link layer length when used for uip_len, we do not, hence | |
1896 * we need values with and without LLH_LEN we do not use capital | |
1897 * letters as these values are variable | |
1898 */ | |
1899 #define uip_l2_l3_hdr_len (UIP_LLH_LEN + UIP_IPH_LEN + uip_ext_len) | |
1900 #define uip_l2_l3_icmp_hdr_len (UIP_LLH_LEN + UIP_IPH_LEN + uip_ext_len + UIP_ICMPH_LEN) | |
1901 #define uip_l3_hdr_len (UIP_IPH_LEN + uip_ext_len) | |
1902 #define uip_l3_icmp_hdr_len (UIP_IPH_LEN + uip_ext_len + UIP_ICMPH_LEN) | |
1903 #endif /*UIP_CONF_IPV6*/ | |
1904 | |
1905 | |
1906 #if UIP_FIXEDADDR | |
1907 CCIF extern const uip_ipaddr_t uip_hostaddr, uip_netmask, uip_draddr; | |
1908 #else /* UIP_FIXEDADDR */ | |
1909 CCIF extern uip_ipaddr_t uip_hostaddr, uip_netmask, uip_draddr; | |
1910 #endif /* UIP_FIXEDADDR */ | |
1911 CCIF extern const uip_ipaddr_t uip_broadcast_addr; | |
1912 CCIF extern const uip_ipaddr_t uip_all_zeroes_addr; | |
1913 | |
1914 #if UIP_FIXEDETHADDR | |
1915 CCIF extern const uip_lladdr_t uip_lladdr; | |
1916 #else | |
1917 CCIF extern uip_lladdr_t uip_lladdr; | |
1918 #endif | |
1919 | |
1920 | |
1921 | |
1922 | |
1923 #ifdef UIP_CONF_IPV6 | |
1924 /** Length of the link local prefix */ | |
1925 #define UIP_LLPREF_LEN 10 | |
1926 | |
1927 /** | |
1928 * \brief Is IPv6 address a the unspecified address | |
1929 * a is of type uip_ipaddr_t | |
1930 */ | |
1931 #define uip_is_addr_loopback(a) \ | |
1932 ((((a)->u16[0]) == 0) && \ | |
1933 (((a)->u16[1]) == 0) && \ | |
1934 (((a)->u16[2]) == 0) && \ | |
1935 (((a)->u16[3]) == 0) && \ | |
1936 (((a)->u16[4]) == 0) && \ | |
1937 (((a)->u16[5]) == 0) && \ | |
1938 (((a)->u16[6]) == 0) && \ | |
1939 (((a)->u16[7]) == 1)) | |
1940 /** | |
1941 * \brief Is IPv6 address a the unspecified address | |
1942 * a is of type uip_ipaddr_t | |
1943 */ | |
1944 #define uip_is_addr_unspecified(a) \ | |
1945 ((((a)->u16[0]) == 0) && \ | |
1946 (((a)->u16[1]) == 0) && \ | |
1947 (((a)->u16[2]) == 0) && \ | |
1948 (((a)->u16[3]) == 0) && \ | |
1949 (((a)->u16[4]) == 0) && \ | |
1950 (((a)->u16[5]) == 0) && \ | |
1951 (((a)->u16[6]) == 0) && \ | |
1952 (((a)->u16[7]) == 0)) | |
1953 | |
1954 /** \brief Is IPv6 address a the link local all-nodes multicast address */ | |
1955 #define uip_is_addr_linklocal_allnodes_mcast(a) \ | |
1956 ((((a)->u8[0]) == 0xff) && \ | |
1957 (((a)->u8[1]) == 0x02) && \ | |
1958 (((a)->u16[1]) == 0) && \ | |
1959 (((a)->u16[2]) == 0) && \ | |
1960 (((a)->u16[3]) == 0) && \ | |
1961 (((a)->u16[4]) == 0) && \ | |
1962 (((a)->u16[5]) == 0) && \ | |
1963 (((a)->u16[6]) == 0) && \ | |
1964 (((a)->u8[14]) == 0) && \ | |
1965 (((a)->u8[15]) == 0x01)) | |
1966 | |
1967 /** \brief Is IPv6 address a the link local all-routers multicast address */ | |
1968 #define uip_is_addr_linklocal_allrouters_mcast(a) \ | |
1969 ((((a)->u8[0]) == 0xff) && \ | |
1970 (((a)->u8[1]) == 0x02) && \ | |
1971 (((a)->u16[1]) == 0) && \ | |
1972 (((a)->u16[2]) == 0) && \ | |
1973 (((a)->u16[3]) == 0) && \ | |
1974 (((a)->u16[4]) == 0) && \ | |
1975 (((a)->u16[5]) == 0) && \ | |
1976 (((a)->u16[6]) == 0) && \ | |
1977 (((a)->u8[14]) == 0) && \ | |
1978 (((a)->u8[15]) == 0x02)) | |
1979 | |
1980 /** | |
1981 * \brief Checks whether the address a is link local. | |
1982 * a is of type uip_ipaddr_t | |
1983 */ | |
1984 #define uip_is_addr_linklocal(a) \ | |
1985 ((a)->u8[0] == 0xfe && \ | |
1986 (a)->u8[1] == 0x80) | |
1987 | |
1988 /** \brief set IP address a to unspecified */ | |
1989 #define uip_create_unspecified(a) uip_ip6addr(a, 0, 0, 0, 0, 0, 0, 0, 0) | |
1990 | |
1991 /** \brief set IP address a to the link local all-nodes multicast address */ | |
1992 #define uip_create_linklocal_allnodes_mcast(a) uip_ip6addr(a, 0xff02, 0, 0, 0, 0, 0, 0, 0x0001) | |
1993 | |
1994 /** \brief set IP address a to the link local all-routers multicast address */ | |
1995 #define uip_create_linklocal_allrouters_mcast(a) uip_ip6addr(a, 0xff02, 0, 0, 0, 0, 0, 0, 0x0002) | |
1996 #define uip_create_linklocal_prefix(addr) do { \ | |
1997 (addr)->u16[0] = UIP_HTONS(0xfe80); \ | |
1998 (addr)->u16[1] = 0; \ | |
1999 (addr)->u16[2] = 0; \ | |
2000 (addr)->u16[3] = 0; \ | |
2001 } while(0) | |
2002 | |
2003 /** | |
2004 * \brief is addr (a) a solicited node multicast address, see RFC3513 | |
2005 * a is of type uip_ipaddr_t* | |
2006 */ | |
2007 #define uip_is_addr_solicited_node(a) \ | |
2008 ((((a)->u8[0]) == 0xFF) && \ | |
2009 (((a)->u8[1]) == 0x02) && \ | |
2010 (((a)->u16[1]) == 0x00) && \ | |
2011 (((a)->u16[2]) == 0x00) && \ | |
2012 (((a)->u16[3]) == 0x00) && \ | |
2013 (((a)->u16[4]) == 0x00) && \ | |
2014 (((a)->u8[10]) == 0x00) && \ | |
2015 (((a)->u8[11]) == 0x01) && \ | |
2016 (((a)->u8[12]) == 0xFF)) | |
2017 | |
2018 /** | |
2019 * \briefput in b the solicited node address corresponding to address a | |
2020 * both a and b are of type uip_ipaddr_t* | |
2021 * */ | |
2022 #define uip_create_solicited_node(a, b) \ | |
2023 (((b)->u8[0]) = 0xFF); \ | |
2024 (((b)->u8[1]) = 0x02); \ | |
2025 (((b)->u16[1]) = 0); \ | |
2026 (((b)->u16[2]) = 0); \ | |
2027 (((b)->u16[3]) = 0); \ | |
2028 (((b)->u16[4]) = 0); \ | |
2029 (((b)->u8[10]) = 0); \ | |
2030 (((b)->u8[11]) = 0x01); \ | |
2031 (((b)->u8[12]) = 0xFF); \ | |
2032 (((b)->u8[13]) = ((a)->u8[13])); \ | |
2033 (((b)->u16[7]) = ((a)->u16[7])) | |
2034 | |
2035 /** | |
2036 * \brief is addr (a) a link local unicast address, see RFC3513 | |
2037 * i.e. is (a) on prefix FE80::/10 | |
2038 * a is of type uip_ipaddr_t* | |
2039 */ | |
2040 #define uip_is_addr_link_local(a) \ | |
2041 ((((a)->u8[0]) == 0xFE) && \ | |
2042 (((a)->u8[1]) == 0x80)) | |
2043 | |
2044 /** | |
2045 * \brief was addr (a) forged based on the mac address m | |
2046 * a type is uip_ipaddr_t | |
2047 * m type is uiplladdr_t | |
2048 */ | |
2049 #if UIP_CONF_LL_802154 | |
2050 #define uip_is_addr_mac_addr_based(a, m) \ | |
2051 ((((a)->u8[8]) == (((m)->addr[0]) ^ 0x02)) && \ | |
2052 (((a)->u8[9]) == (m)->addr[1]) && \ | |
2053 (((a)->u8[10]) == (m)->addr[2]) && \ | |
2054 (((a)->u8[11]) == (m)->addr[3]) && \ | |
2055 (((a)->u8[12]) == (m)->addr[4]) && \ | |
2056 (((a)->u8[13]) == (m)->addr[5]) && \ | |
2057 (((a)->u8[14]) == (m)->addr[6]) && \ | |
2058 (((a)->u8[15]) == (m)->addr[7])) | |
2059 #else | |
2060 | |
2061 #define uip_is_addr_mac_addr_based(a, m) \ | |
2062 ((((a)->u8[8]) == (((m)->addr[0]) | 0x02)) && \ | |
2063 (((a)->u8[9]) == (m)->addr[1]) && \ | |
2064 (((a)->u8[10]) == (m)->addr[2]) && \ | |
2065 (((a)->u8[11]) == 0xff) && \ | |
2066 (((a)->u8[12]) == 0xfe) && \ | |
2067 (((a)->u8[13]) == (m)->addr[3]) && \ | |
2068 (((a)->u8[14]) == (m)->addr[4]) && \ | |
2069 (((a)->u8[15]) == (m)->addr[5])) | |
2070 | |
2071 #endif /*UIP_CONF_LL_802154*/ | |
2072 | |
2073 /** | |
2074 * \brief is address a multicast address, see RFC 3513 | |
2075 * a is of type uip_ipaddr_t* | |
2076 * */ | |
2077 #define uip_is_addr_mcast(a) \ | |
2078 (((a)->u8[0]) == 0xFF) | |
2079 | |
2080 /** | |
2081 * \brief is group-id of multicast address a | |
2082 * the all nodes group-id | |
2083 */ | |
2084 #define uip_is_mcast_group_id_all_nodes(a) \ | |
2085 ((((a)->u16[1]) == 0) && \ | |
2086 (((a)->u16[2]) == 0) && \ | |
2087 (((a)->u16[3]) == 0) && \ | |
2088 (((a)->u16[4]) == 0) && \ | |
2089 (((a)->u16[5]) == 0) && \ | |
2090 (((a)->u16[6]) == 0) && \ | |
2091 (((a)->u8[14]) == 0) && \ | |
2092 (((a)->u8[15]) == 1)) | |
2093 | |
2094 /** | |
2095 * \brief is group-id of multicast address a | |
2096 * the all routers group-id | |
2097 */ | |
2098 #define uip_is_mcast_group_id_all_routers(a) \ | |
2099 ((((a)->u16[1]) == 0) && \ | |
2100 (((a)->u16[2]) == 0) && \ | |
2101 (((a)->u16[3]) == 0) && \ | |
2102 (((a)->u16[4]) == 0) && \ | |
2103 (((a)->u16[5]) == 0) && \ | |
2104 (((a)->u16[6]) == 0) && \ | |
2105 (((a)->u8[14]) == 0) && \ | |
2106 (((a)->u8[15]) == 2)) | |
2107 | |
2108 | |
2109 /** | |
2110 * \brief are last three bytes of both addresses equal? | |
2111 * This is used to compare solicited node multicast addresses | |
2112 */ | |
2113 #define uip_are_solicited_bytes_equal(a, b) \ | |
2114 ((((a)->u8[13]) == ((b)->u8[13])) && \ | |
2115 (((a)->u8[14]) == ((b)->u8[14])) && \ | |
2116 (((a)->u8[15]) == ((b)->u8[15]))) | |
2117 | |
2118 #endif /*UIP_CONF_IPV6*/ | |
2119 | |
2120 /** | |
2121 * Calculate the Internet checksum over a buffer. | |
2122 * | |
2123 * The Internet checksum is the one's complement of the one's | |
2124 * complement sum of all 16-bit words in the buffer. | |
2125 * | |
2126 * See RFC1071. | |
2127 * | |
2128 * \param buf A pointer to the buffer over which the checksum is to be | |
2129 * computed. | |
2130 * | |
2131 * \param len The length of the buffer over which the checksum is to | |
2132 * be computed. | |
2133 * | |
2134 * \return The Internet checksum of the buffer. | |
2135 */ | |
2136 u16_t uip_chksum(u16_t *buf, u16_t len); | |
2137 | |
2138 /** | |
2139 * Calculate the IP header checksum of the packet header in uip_buf. | |
2140 * | |
2141 * The IP header checksum is the Internet checksum of the 20 bytes of | |
2142 * the IP header. | |
2143 * | |
2144 * \return The IP header checksum of the IP header in the uip_buf | |
2145 * buffer. | |
2146 */ | |
2147 u16_t uip_ipchksum(void); | |
2148 | |
2149 /** | |
2150 * Calculate the TCP checksum of the packet in uip_buf and uip_appdata. | |
2151 * | |
2152 * The TCP checksum is the Internet checksum of data contents of the | |
2153 * TCP segment, and a pseudo-header as defined in RFC793. | |
2154 * | |
2155 * \return The TCP checksum of the TCP segment in uip_buf and pointed | |
2156 * to by uip_appdata. | |
2157 */ | |
2158 u16_t uip_tcpchksum(void); | |
2159 | |
2160 /** | |
2161 * Calculate the UDP checksum of the packet in uip_buf and uip_appdata. | |
2162 * | |
2163 * The UDP checksum is the Internet checksum of data contents of the | |
2164 * UDP segment, and a pseudo-header as defined in RFC768. | |
2165 * | |
2166 * \return The UDP checksum of the UDP segment in uip_buf and pointed | |
2167 * to by uip_appdata. | |
2168 */ | |
2169 u16_t uip_udpchksum(void); | |
2170 | |
2171 /** | |
2172 * Calculate the ICMP checksum of the packet in uip_buf. | |
2173 * | |
2174 * \return The ICMP checksum of the ICMP packet in uip_buf | |
2175 */ | |
2176 u16_t uip_icmp6chksum(void); | |
2177 | |
2178 | |
2179 #endif /* __UIP_H__ */ | |
2180 | |
2181 | |
2182 /** @} */ |