uIP 1.0: uip/uip.h Source File

00001 
+00002 /**
+00003  * \addtogroup uip
+00004  * @{
+00005  */
+00006 
+00007 /**
+00008  * \file
+00009  * Header file for the uIP TCP/IP stack.
+00010  * \author Adam Dunkels <adam@dunkels.com>
+00011  *
+00012  * The uIP TCP/IP stack header file contains definitions for a number
+00013  * of C macros that are used by uIP programs as well as internal uIP
+00014  * structures, TCP/IP header structures and function declarations.
+00015  *
+00016  */
+00017 
+00018 
+00019 /*
+00020  * Copyright (c) 2001-2003, Adam Dunkels.
+00021  * All rights reserved.
+00022  *
+00023  * Redistribution and use in source and binary forms, with or without
+00024  * modification, are permitted provided that the following conditions
+00025  * are met:
+00026  * 1. Redistributions of source code must retain the above copyright
+00027  *    notice, this list of conditions and the following disclaimer.
+00028  * 2. Redistributions in binary form must reproduce the above copyright
+00029  *    notice, this list of conditions and the following disclaimer in the
+00030  *    documentation and/or other materials provided with the distribution.
+00031  * 3. The name of the author may not be used to endorse or promote
+00032  *    products derived from this software without specific prior
+00033  *    written permission.
+00034  *
+00035  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+00036  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+00037  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+00038  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+00039  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+00040  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+00041  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+00042  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+00043  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+00044  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+00045  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+00046  *
+00047  * This file is part of the uIP TCP/IP stack.
+00048  *
+00049  * $Id: uip.h,v 1.40 2006/06/08 07:12:07 adam Exp $
+00050  *
+00051  */
+00052 
+00053 #ifndef __UIP_H__
+00054 #define __UIP_H__
+00055 
+00056 #include "uipopt.h"
+00057 
+00058 /**
+00059  * Repressentation of an IP address.
+00060  *
+00061  */
+00062 typedef u16_t uip_ip4addr_t[2];
+00063 typedef u16_t uip_ip6addr_t[8];
+00064 #if UIP_CONF_IPV6
+00065 typedef uip_ip6addr_t uip_ipaddr_t;
+00066 #else /* UIP_CONF_IPV6 */
+00067 typedef uip_ip4addr_t uip_ipaddr_t;
+00068 #endif /* UIP_CONF_IPV6 */
+00069 
+00070 /*---------------------------------------------------------------------------*/
+00071 /* First, the functions that should be called from the
+00072  * system. Initialization, the periodic timer and incoming packets are
+00073  * handled by the following three functions.
+00074  */
+00075 
+00076 /**
+00077  * \defgroup uipconffunc uIP configuration functions
+00078  * @{
+00079  *
+00080  * The uIP configuration functions are used for setting run-time
+00081  * parameters in uIP such as IP addresses.
+00082  */
+00083 
+00084 /**
+00085  * Set the IP address of this host.
+00086  *
+00087  * The IP address is represented as a 4-byte array where the first
+00088  * octet of the IP address is put in the first member of the 4-byte
+00089  * array.
+00090  *
+00091  * Example:
+00092  \code
+00093 
+00094  uip_ipaddr_t addr;
+00095 
+00096  uip_ipaddr(&addr, 192,168,1,2);
+00097  uip_sethostaddr(&addr);
+00098  
+00099  \endcode
+00100  * \param addr A pointer to an IP address of type uip_ipaddr_t;
+00101  *
+00102  * \sa uip_ipaddr()
+00103  *
+00104  * \hideinitializer
+00105  */
+00106 #define uip_sethostaddr(addr) uip_ipaddr_copy(uip_hostaddr, (addr))
+00107 
+00108 /**
+00109  * Get the IP address of this host.
+00110  *
+00111  * The IP address is represented as a 4-byte array where the first
+00112  * octet of the IP address is put in the first member of the 4-byte
+00113  * array.
+00114  *
+00115  * Example:
+00116  \code
+00117  uip_ipaddr_t hostaddr;
+00118 
+00119  uip_gethostaddr(&hostaddr);
+00120  \endcode
+00121  * \param addr A pointer to a uip_ipaddr_t variable that will be
+00122  * filled in with the currently configured IP address.
+00123  *
+00124  * \hideinitializer
+00125  */
+00126 #define uip_gethostaddr(addr) uip_ipaddr_copy((addr), uip_hostaddr)
+00127 
+00128 /**
+00129  * Set the default router's IP address.
+00130  *
+00131  * \param addr A pointer to a uip_ipaddr_t variable containing the IP
+00132  * address of the default router.
+00133  *
+00134  * \sa uip_ipaddr()
+00135  *
+00136  * \hideinitializer
+00137  */
+00138 #define uip_setdraddr(addr) uip_ipaddr_copy(uip_draddr, (addr))
+00139 
+00140 /**
+00141  * Set the netmask.
+00142  *
+00143  * \param addr A pointer to a uip_ipaddr_t variable containing the IP
+00144  * address of the netmask.
+00145  *
+00146  * \sa uip_ipaddr()
+00147  *
+00148  * \hideinitializer
+00149  */
+00150 #define uip_setnetmask(addr) uip_ipaddr_copy(uip_netmask, (addr))
+00151 
+00152 
+00153 /**
+00154  * Get the default router's IP address.
+00155  *
+00156  * \param addr A pointer to a uip_ipaddr_t variable that will be
+00157  * filled in with the IP address of the default router.
+00158  *
+00159  * \hideinitializer
+00160  */
+00161 #define uip_getdraddr(addr) uip_ipaddr_copy((addr), uip_draddr)
+00162 
+00163 /**
+00164  * Get the netmask.
+00165  *
+00166  * \param addr A pointer to a uip_ipaddr_t variable that will be
+00167  * filled in with the value of the netmask.
+00168  *
+00169  * \hideinitializer
+00170  */
+00171 #define uip_getnetmask(addr) uip_ipaddr_copy((addr), uip_netmask)
+00172 
+00173 /** @} */
+00174 
+00175 /**
+00176  * \defgroup uipinit uIP initialization functions
+00177  * @{
+00178  *
+00179  * The uIP initialization functions are used for booting uIP.
+00180  */
+00181 
+00182 /**
+00183  * uIP initialization function.
+00184  *
+00185  * This function should be called at boot up to initilize the uIP
+00186  * TCP/IP stack.
+00187  */
+00188 void uip_init(void);
+00189 
+00190 /**
+00191  * uIP initialization function.
+00192  *
+00193  * This function may be used at boot time to set the initial ip_id.
+00194  */
+00195 void uip_setipid(u16_t id);
+00196 
+00197 /** @} */
+00198 
+00199 /**
+00200  * \defgroup uipdevfunc uIP device driver functions
+00201  * @{
+00202  *
+00203  * These functions are used by a network device driver for interacting
+00204  * with uIP.
+00205  */
+00206 
+00207 /**
+00208  * Process an incoming packet.
+00209  *
+00210  * This function should be called when the device driver has received
+00211  * a packet from the network. The packet from the device driver must
+00212  * be present in the uip_buf buffer, and the length of the packet
+00213  * should be placed in the uip_len variable.
+00214  *
+00215  * When the function returns, there may be an outbound packet placed
+00216  * in the uip_buf packet buffer. If so, the uip_len variable is set to
+00217  * the length of the packet. If no packet is to be sent out, the
+00218  * uip_len variable is set to 0.
+00219  *
+00220  * The usual way of calling the function is presented by the source
+00221  * code below.
+00222  \code
+00223   uip_len = devicedriver_poll();
+00224   if(uip_len > 0) {
+00225     uip_input();
+00226     if(uip_len > 0) {
+00227       devicedriver_send();
+00228     }
+00229   }
+00230  \endcode
+00231  *
+00232  * \note If you are writing a uIP device driver that needs ARP
+00233  * (Address Resolution Protocol), e.g., when running uIP over
+00234  * Ethernet, you will need to call the uIP ARP code before calling
+00235  * this function:
+00236  \code
+00237   #define BUF ((struct uip_eth_hdr *)&uip_buf[0])
+00238   uip_len = ethernet_devicedrver_poll();
+00239   if(uip_len > 0) {
+00240     if(BUF->type == HTONS(UIP_ETHTYPE_IP)) {
+00241       uip_arp_ipin();
+00242       uip_input();
+00243       if(uip_len > 0) {
+00244         uip_arp_out();
+00245         ethernet_devicedriver_send();
+00246       }
+00247     } else if(BUF->type == HTONS(UIP_ETHTYPE_ARP)) {
+00248       uip_arp_arpin();
+00249       if(uip_len > 0) {
+00250         ethernet_devicedriver_send();
+00251       }
+00252     }
+00253  \endcode
+00254  *
+00255  * \hideinitializer
+00256  */
+00257 #define uip_input()        uip_process(UIP_DATA)
+00258 
+00259 /**
+00260  * Periodic processing for a connection identified by its number.
+00261  *
+00262  * This function does the necessary periodic processing (timers,
+00263  * polling) for a uIP TCP conneciton, and should be called when the
+00264  * periodic uIP timer goes off. It should be called for every
+00265  * connection, regardless of whether they are open of closed.
+00266  *
+00267  * When the function returns, it may have an outbound packet waiting
+00268  * for service in the uIP packet buffer, and if so the uip_len
+00269  * variable is set to a value larger than zero. The device driver
+00270  * should be called to send out the packet.
+00271  *
+00272  * The ususal way of calling the function is through a for() loop like
+00273  * this:
+00274  \code
+00275   for(i = 0; i < UIP_CONNS; ++i) {
+00276     uip_periodic(i);
+00277     if(uip_len > 0) {
+00278       devicedriver_send();
+00279     }
+00280   }
+00281  \endcode
+00282  *
+00283  * \note If you are writing a uIP device driver that needs ARP
+00284  * (Address Resolution Protocol), e.g., when running uIP over
+00285  * Ethernet, you will need to call the uip_arp_out() function before
+00286  * calling the device driver:
+00287  \code
+00288   for(i = 0; i < UIP_CONNS; ++i) {
+00289     uip_periodic(i);
+00290     if(uip_len > 0) {
+00291       uip_arp_out();
+00292       ethernet_devicedriver_send();
+00293     }
+00294   }
+00295  \endcode
+00296  *
+00297  * \param conn The number of the connection which is to be periodically polled.
+00298  *
+00299  * \hideinitializer
+00300  */
+00301 #define uip_periodic(conn) do { uip_conn = &uip_conns[conn]; \
+00302                                 uip_process(UIP_TIMER); } while (0)
+00303 
+00304 /**
+00305  *
+00306  *
+00307  */
+00308 #define uip_conn_active(conn) (uip_conns[conn].tcpstateflags != UIP_CLOSED)
+00309 
+00310 /**
+00311  * Perform periodic processing for a connection identified by a pointer
+00312  * to its structure.
+00313  *
+00314  * Same as uip_periodic() but takes a pointer to the actual uip_conn
+00315  * struct instead of an integer as its argument. This function can be
+00316  * used to force periodic processing of a specific connection.
+00317  *
+00318  * \param conn A pointer to the uip_conn struct for the connection to
+00319  * be processed.
+00320  *
+00321  * \hideinitializer
+00322  */
+00323 #define uip_periodic_conn(conn) do { uip_conn = conn; \
+00324                                      uip_process(UIP_TIMER); } while (0)
+00325 
+00326 /**
+00327  * Reuqest that a particular connection should be polled.
+00328  *
+00329  * Similar to uip_periodic_conn() but does not perform any timer
+00330  * processing. The application is polled for new data.
+00331  *
+00332  * \param conn A pointer to the uip_conn struct for the connection to
+00333  * be processed.
+00334  *
+00335  * \hideinitializer
+00336  */
+00337 #define uip_poll_conn(conn) do { uip_conn = conn; \
+00338                                  uip_process(UIP_POLL_REQUEST); } while (0)
+00339 
+00340 
+00341 #if UIP_UDP
+00342 /**
+00343  * Periodic processing for a UDP connection identified by its number.
+00344  *
+00345  * This function is essentially the same as uip_periodic(), but for
+00346  * UDP connections. It is called in a similar fashion as the
+00347  * uip_periodic() function:
+00348  \code
+00349   for(i = 0; i < UIP_UDP_CONNS; i++) {
+00350     uip_udp_periodic(i);
+00351     if(uip_len > 0) {
+00352       devicedriver_send();
+00353     }
+00354   }
+00355  \endcode
+00356  *
+00357  * \note As for the uip_periodic() function, special care has to be
+00358  * taken when using uIP together with ARP and Ethernet:
+00359  \code
+00360   for(i = 0; i < UIP_UDP_CONNS; i++) {
+00361     uip_udp_periodic(i);
+00362     if(uip_len > 0) {
+00363       uip_arp_out();
+00364       ethernet_devicedriver_send();
+00365     }
+00366   }
+00367  \endcode
+00368  *
+00369  * \param conn The number of the UDP connection to be processed.
+00370  *
+00371  * \hideinitializer
+00372  */
+00373 #define uip_udp_periodic(conn) do { uip_udp_conn = &uip_udp_conns[conn]; \
+00374                                 uip_process(UIP_UDP_TIMER); } while (0)
+00375 
+00376 /**
+00377  * Periodic processing for a UDP connection identified by a pointer to
+00378  * its structure.
+00379  *
+00380  * Same as uip_udp_periodic() but takes a pointer to the actual
+00381  * uip_conn struct instead of an integer as its argument. This
+00382  * function can be used to force periodic processing of a specific
+00383  * connection.
+00384  *
+00385  * \param conn A pointer to the uip_udp_conn struct for the connection
+00386  * to be processed.
+00387  *
+00388  * \hideinitializer
+00389  */
+00390 #define uip_udp_periodic_conn(conn) do { uip_udp_conn = conn; \
+00391                                          uip_process(UIP_UDP_TIMER); } while (0)
+00392 
+00393 
+00394 #endif /* UIP_UDP */
+00395 
+00396 /**
+00397  * The uIP packet buffer.
+00398  *
+00399  * The uip_buf array is used to hold incoming and outgoing
+00400  * packets. The device driver should place incoming data into this
+00401  * buffer. When sending data, the device driver should read the link
+00402  * level headers and the TCP/IP headers from this buffer. The size of
+00403  * the link level headers is configured by the UIP_LLH_LEN define.
+00404  *
+00405  * \note The application data need not be placed in this buffer, so
+00406  * the device driver must read it from the place pointed to by the
+00407  * uip_appdata pointer as illustrated by the following example:
+00408  \code
+00409  void
+00410  devicedriver_send(void)
+00411  {
+00412     hwsend(&uip_buf[0], UIP_LLH_LEN);
+00413     if(uip_len <= UIP_LLH_LEN + UIP_TCPIP_HLEN) {
+00414       hwsend(&uip_buf[UIP_LLH_LEN], uip_len - UIP_LLH_LEN);
+00415     } else {
+00416       hwsend(&uip_buf[UIP_LLH_LEN], UIP_TCPIP_HLEN);
+00417       hwsend(uip_appdata, uip_len - UIP_TCPIP_HLEN - UIP_LLH_LEN);
+00418     }
+00419  }
+00420  \endcode
+00421  */
+00422 extern u8_t uip_buf[UIP_BUFSIZE+2];
+00423 
+00424 /** @} */
+00425 
+00426 /*---------------------------------------------------------------------------*/
+00427 /* Functions that are used by the uIP application program. Opening and
+00428  * closing connections, sending and receiving data, etc. is all
+00429  * handled by the functions below.
+00430 */
+00431 /**
+00432  * \defgroup uipappfunc uIP application functions
+00433  * @{
+00434  *
+00435  * Functions used by an application running of top of uIP.
+00436  */
+00437 
+00438 /**
+00439  * Start listening to the specified port.
+00440  *
+00441  * \note Since this function expects the port number in network byte
+00442  * order, a conversion using HTONS() or htons() is necessary.
+00443  *
+00444  \code
+00445  uip_listen(HTONS(80));
+00446  \endcode
+00447  *
+00448  * \param port A 16-bit port number in network byte order.
+00449  */
+00450 void uip_listen(u16_t port);
+00451 
+00452 /**
+00453  * Stop listening to the specified port.
+00454  *
+00455  * \note Since this function expects the port number in network byte
+00456  * order, a conversion using HTONS() or htons() is necessary.
+00457  *
+00458  \code
+00459  uip_unlisten(HTONS(80));
+00460  \endcode
+00461  *
+00462  * \param port A 16-bit port number in network byte order.
+00463  */
+00464 void uip_unlisten(u16_t port);
+00465 
+00466 /**
+00467  * Connect to a remote host using TCP.
+00468  *
+00469  * This function is used to start a new connection to the specified
+00470  * port on the specied host. It allocates a new connection identifier,
+00471  * sets the connection to the SYN_SENT state and sets the
+00472  * retransmission timer to 0. This will cause a TCP SYN segment to be
+00473  * sent out the next time this connection is periodically processed,
+00474  * which usually is done within 0.5 seconds after the call to
+00475  * uip_connect().
+00476  *
+00477  * \note This function is avaliable only if support for active open
+00478  * has been configured by defining UIP_ACTIVE_OPEN to 1 in uipopt.h.
+00479  *
+00480  * \note Since this function requires the port number to be in network
+00481  * byte order, a conversion using HTONS() or htons() is necessary.
+00482  *
+00483  \code
+00484  uip_ipaddr_t ipaddr;
+00485 
+00486  uip_ipaddr(&ipaddr, 192,168,1,2);
+00487  uip_connect(&ipaddr, HTONS(80));
+00488  \endcode
+00489  *
+00490  * \param ripaddr The IP address of the remote hot.
+00491  *
+00492  * \param port A 16-bit port number in network byte order.
+00493  *
+00494  * \return A pointer to the uIP connection identifier for the new connection,
+00495  * or NULL if no connection could be allocated.
+00496  *
+00497  */
+00498 struct uip_conn *uip_connect(uip_ipaddr_t *ripaddr, u16_t port);
+00499 
+00500 
+00501 
+00502 /**
+00503  * \internal
+00504  *
+00505  * Check if a connection has outstanding (i.e., unacknowledged) data.
+00506  *
+00507  * \param conn A pointer to the uip_conn structure for the connection.
+00508  *
+00509  * \hideinitializer
+00510  */
+00511 #define uip_outstanding(conn) ((conn)->len)
+00512 
+00513 /**
+00514  * Send data on the current connection.
+00515  *
+00516  * This function is used to send out a single segment of TCP
+00517  * data. Only applications that have been invoked by uIP for event
+00518  * processing can send data.
+00519  *
+00520  * The amount of data that actually is sent out after a call to this
+00521  * funcion is determined by the maximum amount of data TCP allows. uIP
+00522  * will automatically crop the data so that only the appropriate
+00523  * amount of data is sent. The function uip_mss() can be used to query
+00524  * uIP for the amount of data that actually will be sent.
+00525  *
+00526  * \note This function does not guarantee that the sent data will
+00527  * arrive at the destination. If the data is lost in the network, the
+00528  * application will be invoked with the uip_rexmit() event being
+00529  * set. The application will then have to resend the data using this
+00530  * function.
+00531  *
+00532  * \param data A pointer to the data which is to be sent.
+00533  *
+00534  * \param len The maximum amount of data bytes to be sent.
+00535  *
+00536  * \hideinitializer
+00537  */
+00538 void uip_send(const void *data, int len);
+00539 
+00540 /**
+00541  * The length of any incoming data that is currently avaliable (if avaliable)
+00542  * in the uip_appdata buffer.
+00543  *
+00544  * The test function uip_data() must first be used to check if there
+00545  * is any data available at all.
+00546  *
+00547  * \hideinitializer
+00548  */
+00549 /*void uip_datalen(void);*/
+00550 #define uip_datalen()       uip_len
+00551 
+00552 /**
+00553  * The length of any out-of-band data (urgent data) that has arrived
+00554  * on the connection.
+00555  *
+00556  * \note The configuration parameter UIP_URGDATA must be set for this
+00557  * function to be enabled.
+00558  *
+00559  * \hideinitializer
+00560  */
+00561 #define uip_urgdatalen()    uip_urglen
+00562 
+00563 /**
+00564  * Close the current connection.
+00565  *
+00566  * This function will close the current connection in a nice way.
+00567  *
+00568  * \hideinitializer
+00569  */
+00570 #define uip_close()         (uip_flags = UIP_CLOSE)
+00571 
+00572 /**
+00573  * Abort the current connection.
+00574  *
+00575  * This function will abort (reset) the current connection, and is
+00576  * usually used when an error has occured that prevents using the
+00577  * uip_close() function.
+00578  *
+00579  * \hideinitializer
+00580  */
+00581 #define uip_abort()         (uip_flags = UIP_ABORT)
+00582 
+00583 /**
+00584  * Tell the sending host to stop sending data.
+00585  *
+00586  * This function will close our receiver's window so that we stop
+00587  * receiving data for the current connection.
+00588  *
+00589  * \hideinitializer
+00590  */
+00591 #define uip_stop()          (uip_conn->tcpstateflags |= UIP_STOPPED)
+00592 
+00593 /**
+00594  * Find out if the current connection has been previously stopped with
+00595  * uip_stop().
+00596  *
+00597  * \hideinitializer
+00598  */
+00599 #define uip_stopped(conn)   ((conn)->tcpstateflags & UIP_STOPPED)
+00600 
+00601 /**
+00602  * Restart the current connection, if is has previously been stopped
+00603  * with uip_stop().
+00604  *
+00605  * This function will open the receiver's window again so that we
+00606  * start receiving data for the current connection.
+00607  *
+00608  * \hideinitializer
+00609  */
+00610 #define uip_restart()         do { uip_flags |= UIP_NEWDATA; \
+00611                                    uip_conn->tcpstateflags &= ~UIP_STOPPED; \
+00612                               } while(0)
+00613 
+00614 
+00615 /* uIP tests that can be made to determine in what state the current
+00616    connection is, and what the application function should do. */
+00617 
+00618 /**
+00619  * Is the current connection a UDP connection?
+00620  *
+00621  * This function checks whether the current connection is a UDP connection.
+00622  *
+00623  * \hideinitializer
+00624  *
+00625  */
+00626 #define uip_udpconnection() (uip_conn == NULL)
+00627 
+00628 /**
+00629  * Is new incoming data available?
+00630  *
+00631  * Will reduce to non-zero if there is new data for the application
+00632  * present at the uip_appdata pointer. The size of the data is
+00633  * avaliable through the uip_len variable.
+00634  *
+00635  * \hideinitializer
+00636  */
+00637 #define uip_newdata()   (uip_flags & UIP_NEWDATA)
+00638 
+00639 /**
+00640  * Has previously sent data been acknowledged?
+00641  *
+00642  * Will reduce to non-zero if the previously sent data has been
+00643  * acknowledged by the remote host. This means that the application
+00644  * can send new data.
+00645  *
+00646  * \hideinitializer
+00647  */
+00648 #define uip_acked()   (uip_flags & UIP_ACKDATA)
+00649 
+00650 /**
+00651  * Has the connection just been connected?
+00652  *
+00653  * Reduces to non-zero if the current connection has been connected to
+00654  * a remote host. This will happen both if the connection has been
+00655  * actively opened (with uip_connect()) or passively opened (with
+00656  * uip_listen()).
+00657  *
+00658  * \hideinitializer
+00659  */
+00660 #define uip_connected() (uip_flags & UIP_CONNECTED)
+00661 
+00662 /**
+00663  * Has the connection been closed by the other end?
+00664  *
+00665  * Is non-zero if the connection has been closed by the remote
+00666  * host. The application may then do the necessary clean-ups.
+00667  *
+00668  * \hideinitializer
+00669  */
+00670 #define uip_closed()    (uip_flags & UIP_CLOSE)
+00671 
+00672 /**
+00673  * Has the connection been aborted by the other end?
+00674  *
+00675  * Non-zero if the current connection has been aborted (reset) by the
+00676  * remote host.
+00677  *
+00678  * \hideinitializer
+00679  */
+00680 #define uip_aborted()    (uip_flags & UIP_ABORT)
+00681 
+00682 /**
+00683  * Has the connection timed out?
+00684  *
+00685  * Non-zero if the current connection has been aborted due to too many
+00686  * retransmissions.
+00687  *
+00688  * \hideinitializer
+00689  */
+00690 #define uip_timedout()    (uip_flags & UIP_TIMEDOUT)
+00691 
+00692 /**
+00693  * Do we need to retransmit previously data?
+00694  *
+00695  * Reduces to non-zero if the previously sent data has been lost in
+00696  * the network, and the application should retransmit it. The
+00697  * application should send the exact same data as it did the last
+00698  * time, using the uip_send() function.
+00699  *
+00700  * \hideinitializer
+00701  */
+00702 #define uip_rexmit()     (uip_flags & UIP_REXMIT)
+00703 
+00704 /**
+00705  * Is the connection being polled by uIP?
+00706  *
+00707  * Is non-zero if the reason the application is invoked is that the
+00708  * current connection has been idle for a while and should be
+00709  * polled.
+00710  *
+00711  * The polling event can be used for sending data without having to
+00712  * wait for the remote host to send data.
+00713  *
+00714  * \hideinitializer
+00715  */
+00716 #define uip_poll()       (uip_flags & UIP_POLL)
+00717 
+00718 /**
+00719  * Get the initial maxium segment size (MSS) of the current
+00720  * connection.
+00721  *
+00722  * \hideinitializer
+00723  */
+00724 #define uip_initialmss()             (uip_conn->initialmss)
+00725 
+00726 /**
+00727  * Get the current maxium segment size that can be sent on the current
+00728  * connection.
+00729  *
+00730  * The current maxiumum segment size that can be sent on the
+00731  * connection is computed from the receiver's window and the MSS of
+00732  * the connection (which also is available by calling
+00733  * uip_initialmss()).
+00734  *
+00735  * \hideinitializer
+00736  */
+00737 #define uip_mss()             (uip_conn->mss)
+00738 
+00739 /**
+00740  * Set up a new UDP connection.
+00741  *
+00742  * This function sets up a new UDP connection. The function will
+00743  * automatically allocate an unused local port for the new
+00744  * connection. However, another port can be chosen by using the
+00745  * uip_udp_bind() call, after the uip_udp_new() function has been
+00746  * called.
+00747  *
+00748  * Example:
+00749  \code
+00750  uip_ipaddr_t addr;
+00751  struct uip_udp_conn *c;
+00752  
+00753  uip_ipaddr(&addr, 192,168,2,1);
+00754  c = uip_udp_new(&addr, HTONS(12345));
+00755  if(c != NULL) {
+00756    uip_udp_bind(c, HTONS(12344));
+00757  }
+00758  \endcode
+00759  * \param ripaddr The IP address of the remote host.
+00760  *
+00761  * \param rport The remote port number in network byte order.
+00762  *
+00763  * \return The uip_udp_conn structure for the new connection or NULL
+00764  * if no connection could be allocated.
+00765  */
+00766 struct uip_udp_conn *uip_udp_new(uip_ipaddr_t *ripaddr, u16_t rport);
+00767 
+00768 /**
+00769  * Removed a UDP connection.
+00770  *
+00771  * \param conn A pointer to the uip_udp_conn structure for the connection.
+00772  *
+00773  * \hideinitializer
+00774  */
+00775 #define uip_udp_remove(conn) (conn)->lport = 0
+00776 
+00777 /**
+00778  * Bind a UDP connection to a local port.
+00779  *
+00780  * \param conn A pointer to the uip_udp_conn structure for the
+00781  * connection.
+00782  *
+00783  * \param port The local port number, in network byte order.
+00784  *
+00785  * \hideinitializer
+00786  */
+00787 #define uip_udp_bind(conn, port) (conn)->lport = port
+00788 
+00789 /**
+00790  * Send a UDP datagram of length len on the current connection.
+00791  *
+00792  * This function can only be called in response to a UDP event (poll
+00793  * or newdata). The data must be present in the uip_buf buffer, at the
+00794  * place pointed to by the uip_appdata pointer.
+00795  *
+00796  * \param len The length of the data in the uip_buf buffer.
+00797  *
+00798  * \hideinitializer
+00799  */
+00800 #define uip_udp_send(len) uip_send((char *)uip_appdata, len)
+00801 
+00802 /** @} */
+00803 
+00804 /* uIP convenience and converting functions. */
+00805 
+00806 /**
+00807  * \defgroup uipconvfunc uIP conversion functions
+00808  * @{
+00809  *
+00810  * These functions can be used for converting between different data
+00811  * formats used by uIP.
+00812  */
+00813  
+00814 /**
+00815  * Construct an IP address from four bytes.
+00816  *
+00817  * This function constructs an IP address of the type that uIP handles
+00818  * internally from four bytes. The function is handy for specifying IP
+00819  * addresses to use with e.g. the uip_connect() function.
+00820  *
+00821  * Example:
+00822  \code
+00823  uip_ipaddr_t ipaddr;
+00824  struct uip_conn *c;
+00825  
+00826  uip_ipaddr(&ipaddr, 192,168,1,2);
+00827  c = uip_connect(&ipaddr, HTONS(80));
+00828  \endcode
+00829  *
+00830  * \param addr A pointer to a uip_ipaddr_t variable that will be
+00831  * filled in with the IP address.
+00832  *
+00833  * \param addr0 The first octet of the IP address.
+00834  * \param addr1 The second octet of the IP address.
+00835  * \param addr2 The third octet of the IP address.
+00836  * \param addr3 The forth octet of the IP address.
+00837  *
+00838  * \hideinitializer
+00839  */
+00840 #define uip_ipaddr(addr, addr0,addr1,addr2,addr3) do { \
+00841                      ((u16_t *)(addr))[0] = HTONS(((addr0) << 8) | (addr1)); \
+00842                      ((u16_t *)(addr))[1] = HTONS(((addr2) << 8) | (addr3)); \
+00843                   } while(0)
+00844 
+00845 /**
+00846  * Construct an IPv6 address from eight 16-bit words.
+00847  *
+00848  * This function constructs an IPv6 address.
+00849  *
+00850  * \hideinitializer
+00851  */
+00852 #define uip_ip6addr(addr, addr0,addr1,addr2,addr3,addr4,addr5,addr6,addr7) do { \
+00853                      ((u16_t *)(addr))[0] = HTONS((addr0)); \
+00854                      ((u16_t *)(addr))[1] = HTONS((addr1)); \
+00855                      ((u16_t *)(addr))[2] = HTONS((addr2)); \
+00856                      ((u16_t *)(addr))[3] = HTONS((addr3)); \
+00857                      ((u16_t *)(addr))[4] = HTONS((addr4)); \
+00858                      ((u16_t *)(addr))[5] = HTONS((addr5)); \
+00859                      ((u16_t *)(addr))[6] = HTONS((addr6)); \
+00860                      ((u16_t *)(addr))[7] = HTONS((addr7)); \
+00861                   } while(0)
+00862 
+00863 /**
+00864  * Copy an IP address to another IP address.
+00865  *
+00866  * Copies an IP address from one place to another.
+00867  *
+00868  * Example:
+00869  \code
+00870  uip_ipaddr_t ipaddr1, ipaddr2;
+00871 
+00872  uip_ipaddr(&ipaddr1, 192,16,1,2);
+00873  uip_ipaddr_copy(&ipaddr2, &ipaddr1);
+00874  \endcode
+00875  *
+00876  * \param dest The destination for the copy.
+00877  * \param src The source from where to copy.
+00878  *
+00879  * \hideinitializer
+00880  */
+00881 #if !UIP_CONF_IPV6
+00882 #define uip_ipaddr_copy(dest, src) do { \
+00883                      ((u16_t *)dest)[0] = ((u16_t *)src)[0]; \
+00884                      ((u16_t *)dest)[1] = ((u16_t *)src)[1]; \
+00885                   } while(0)
+00886 #else /* !UIP_CONF_IPV6 */
+00887 #define uip_ipaddr_copy(dest, src) memcpy(dest, src, sizeof(uip_ip6addr_t))
+00888 #endif /* !UIP_CONF_IPV6 */
+00889 
+00890 /**
+00891  * Compare two IP addresses
+00892  *
+00893  * Compares two IP addresses.
+00894  *
+00895  * Example:
+00896  \code
+00897  uip_ipaddr_t ipaddr1, ipaddr2;
+00898 
+00899  uip_ipaddr(&ipaddr1, 192,16,1,2);
+00900  if(uip_ipaddr_cmp(&ipaddr2, &ipaddr1)) {
+00901     printf("They are the same");
+00902  }
+00903  \endcode
+00904  *
+00905  * \param addr1 The first IP address.
+00906  * \param addr2 The second IP address.
+00907  *
+00908  * \hideinitializer
+00909  */
+00910 #if !UIP_CONF_IPV6
+00911 #define uip_ipaddr_cmp(addr1, addr2) (((u16_t *)addr1)[0] == ((u16_t *)addr2)[0] && \
+00912                                       ((u16_t *)addr1)[1] == ((u16_t *)addr2)[1])
+00913 #else /* !UIP_CONF_IPV6 */
+00914 #define uip_ipaddr_cmp(addr1, addr2) (memcmp(addr1, addr2, sizeof(uip_ip6addr_t)) == 0)
+00915 #endif /* !UIP_CONF_IPV6 */
+00916 
+00917 /**
+00918  * Compare two IP addresses with netmasks
+00919  *
+00920  * Compares two IP addresses with netmasks. The masks are used to mask
+00921  * out the bits that are to be compared.
+00922  *
+00923  * Example:
+00924  \code
+00925  uip_ipaddr_t ipaddr1, ipaddr2, mask;
+00926 
+00927  uip_ipaddr(&mask, 255,255,255,0);
+00928  uip_ipaddr(&ipaddr1, 192,16,1,2);
+00929  uip_ipaddr(&ipaddr2, 192,16,1,3);
+00930  if(uip_ipaddr_maskcmp(&ipaddr1, &ipaddr2, &mask)) {
+00931     printf("They are the same");
+00932  }
+00933  \endcode
+00934  *
+00935  * \param addr1 The first IP address.
+00936  * \param addr2 The second IP address.
+00937  * \param mask The netmask.
+00938  *
+00939  * \hideinitializer
+00940  */
+00941 #define uip_ipaddr_maskcmp(addr1, addr2, mask) \
+00942                           (((((u16_t *)addr1)[0] & ((u16_t *)mask)[0]) == \
+00943                             (((u16_t *)addr2)[0] & ((u16_t *)mask)[0])) && \
+00944                            ((((u16_t *)addr1)[1] & ((u16_t *)mask)[1]) == \
+00945                             (((u16_t *)addr2)[1] & ((u16_t *)mask)[1])))
+00946 
+00947 
+00948 /**
+00949  * Mask out the network part of an IP address.
+00950  *
+00951  * Masks out the network part of an IP address, given the address and
+00952  * the netmask.
+00953  *
+00954  * Example:
+00955  \code
+00956  uip_ipaddr_t ipaddr1, ipaddr2, netmask;
+00957 
+00958  uip_ipaddr(&ipaddr1, 192,16,1,2);
+00959  uip_ipaddr(&netmask, 255,255,255,0);
+00960  uip_ipaddr_mask(&ipaddr2, &ipaddr1, &netmask);
+00961  \endcode
+00962  *
+00963  * In the example above, the variable "ipaddr2" will contain the IP
+00964  * address 192.168.1.0.
+00965  *
+00966  * \param dest Where the result is to be placed.
+00967  * \param src The IP address.
+00968  * \param mask The netmask.
+00969  *
+00970  * \hideinitializer
+00971  */
+00972 #define uip_ipaddr_mask(dest, src, mask) do { \
+00973                      ((u16_t *)dest)[0] = ((u16_t *)src)[0] & ((u16_t *)mask)[0]; \
+00974                      ((u16_t *)dest)[1] = ((u16_t *)src)[1] & ((u16_t *)mask)[1]; \
+00975                   } while(0)
+00976 
+00977 /**
+00978  * Pick the first octet of an IP address.
+00979  *
+00980  * Picks out the first octet of an IP address.
+00981  *
+00982  * Example:
+00983  \code
+00984  uip_ipaddr_t ipaddr;
+00985  u8_t octet;
+00986 
+00987  uip_ipaddr(&ipaddr, 1,2,3,4);
+00988  octet = uip_ipaddr1(&ipaddr);
+00989  \endcode
+00990  *
+00991  * In the example above, the variable "octet" will contain the value 1.
+00992  *
+00993  * \hideinitializer
+00994  */
+00995 #define uip_ipaddr1(addr) (htons(((u16_t *)(addr))[0]) >> 8)
+00996 
+00997 /**
+00998  * Pick the second octet of an IP address.
+00999  *
+01000  * Picks out the second octet of an IP address.
+01001  *
+01002  * Example:
+01003  \code
+01004  uip_ipaddr_t ipaddr;
+01005  u8_t octet;
+01006 
+01007  uip_ipaddr(&ipaddr, 1,2,3,4);
+01008  octet = uip_ipaddr2(&ipaddr);
+01009  \endcode
+01010  *
+01011  * In the example above, the variable "octet" will contain the value 2.
+01012  *
+01013  * \hideinitializer
+01014  */
+01015 #define uip_ipaddr2(addr) (htons(((u16_t *)(addr))[0]) & 0xff)
+01016 
+01017 /**
+01018  * Pick the third octet of an IP address.
+01019  *
+01020  * Picks out the third octet of an IP address.
+01021  *
+01022  * Example:
+01023  \code
+01024  uip_ipaddr_t ipaddr;
+01025  u8_t octet;
+01026 
+01027  uip_ipaddr(&ipaddr, 1,2,3,4);
+01028  octet = uip_ipaddr3(&ipaddr);
+01029  \endcode
+01030  *
+01031  * In the example above, the variable "octet" will contain the value 3.
+01032  *
+01033  * \hideinitializer
+01034  */
+01035 #define uip_ipaddr3(addr) (htons(((u16_t *)(addr))[1]) >> 8)
+01036 
+01037 /**
+01038  * Pick the fourth octet of an IP address.
+01039  *
+01040  * Picks out the fourth octet of an IP address.
+01041  *
+01042  * Example:
+01043  \code
+01044  uip_ipaddr_t ipaddr;
+01045  u8_t octet;
+01046 
+01047  uip_ipaddr(&ipaddr, 1,2,3,4);
+01048  octet = uip_ipaddr4(&ipaddr);
+01049  \endcode
+01050  *
+01051  * In the example above, the variable "octet" will contain the value 4.
+01052  *
+01053  * \hideinitializer
+01054  */
+01055 #define uip_ipaddr4(addr) (htons(((u16_t *)(addr))[1]) & 0xff)
+01056 
+01057 /**
+01058  * Convert 16-bit quantity from host byte order to network byte order.
+01059  *
+01060  * This macro is primarily used for converting constants from host
+01061  * byte order to network byte order. For converting variables to
+01062  * network byte order, use the htons() function instead.
+01063  *
+01064  * \hideinitializer
+01065  */
+01066 #ifndef HTONS
+01067 #   if UIP_BYTE_ORDER == UIP_BIG_ENDIAN
+01068 #      define HTONS(n) (n)
+01069 #   else /* UIP_BYTE_ORDER == UIP_BIG_ENDIAN */
+01070 #      define HTONS(n) (u16_t)((((u16_t) (n)) << 8) | (((u16_t) (n)) >> 8))
+01071 #   endif /* UIP_BYTE_ORDER == UIP_BIG_ENDIAN */
+01072 #else
+01073 #error "HTONS already defined!"
+01074 #endif /* HTONS */
+01075 
+01076 /**
+01077  * Convert 16-bit quantity from host byte order to network byte order.
+01078  *
+01079  * This function is primarily used for converting variables from host
+01080  * byte order to network byte order. For converting constants to
+01081  * network byte order, use the HTONS() macro instead.
+01082  */
+01083 #ifndef htons
+01084 u16_t htons(u16_t val);
+01085 #endif /* htons */
+01086 #ifndef ntohs
+01087 #define ntohs htons
+01088 #endif
+01089 
+01090 /** @} */
+01091 
+01092 /**
+01093  * Pointer to the application data in the packet buffer.
+01094  *
+01095  * This pointer points to the application data when the application is
+01096  * called. If the application wishes to send data, the application may
+01097  * use this space to write the data into before calling uip_send().
+01098  */
+01099 extern void *uip_appdata;
+01100 
+01101 #if UIP_URGDATA > 0
+01102 /* u8_t *uip_urgdata:
+01103  *
+01104  * This pointer points to any urgent data that has been received. Only
+01105  * present if compiled with support for urgent data (UIP_URGDATA).
+01106  */
+01107 extern void *uip_urgdata;
+01108 #endif /* UIP_URGDATA > 0 */
+01109 
+01110 
+01111 /**
+01112  * \defgroup uipdrivervars Variables used in uIP device drivers
+01113  * @{
+01114  *
+01115  * uIP has a few global variables that are used in device drivers for
+01116  * uIP.
+01117  */
+01118 
+01119 /**
+01120  * The length of the packet in the uip_buf buffer.
+01121  *
+01122  * The global variable uip_len holds the length of the packet in the
+01123  * uip_buf buffer.
+01124  *
+01125  * When the network device driver calls the uIP input function,
+01126  * uip_len should be set to the length of the packet in the uip_buf
+01127  * buffer.
+01128  *
+01129  * When sending packets, the device driver should use the contents of
+01130  * the uip_len variable to determine the length of the outgoing
+01131  * packet.
+01132  *
+01133  */
+01134 extern u16_t uip_len;
+01135 
+01136 /** @} */
+01137 
+01138 #if UIP_URGDATA > 0
+01139 extern u16_t uip_urglen, uip_surglen;
+01140 #endif /* UIP_URGDATA > 0 */
+01141 
+01142 
+01143 /**
+01144  * Representation of a uIP TCP connection.
+01145  *
+01146  * The uip_conn structure is used for identifying a connection. All
+01147  * but one field in the structure are to be considered read-only by an
+01148  * application. The only exception is the appstate field whos purpose
+01149  * is to let the application store application-specific state (e.g.,
+01150  * file pointers) for the connection. The type of this field is
+01151  * configured in the "uipopt.h" header file.
+01152  */
+01153 struct uip_conn {
+01154   uip_ipaddr_t ripaddr;   /**< The IP address of the remote host. */
+01155   
+01156   u16_t lport;        /**< The local TCP port, in network byte order. */
+01157   u16_t rport;        /**< The local remote TCP port, in network byte
+01158                          order. */
+01159   
+01160   u8_t rcv_nxt[4];    /**< The sequence number that we expect to
+01161                          receive next. */
+01162   u8_t snd_nxt[4];    /**< The sequence number that was last sent by
+01163                          us. */
+01164   u16_t len;          /**< Length of the data that was previously sent. */
+01165   u16_t mss;          /**< Current maximum segment size for the
+01166                          connection. */
+01167   u16_t initialmss;   /**< Initial maximum segment size for the
+01168                          connection. */
+01169   u8_t sa;            /**< Retransmission time-out calculation state
+01170                          variable. */
+01171   u8_t sv;            /**< Retransmission time-out calculation state
+01172                          variable. */
+01173   u8_t rto;           /**< Retransmission time-out. */
+01174   u8_t tcpstateflags; /**< TCP state and flags. */
+01175   u8_t timer;         /**< The retransmission timer. */
+01176   u8_t nrtx;          /**< The number of retransmissions for the last
+01177                          segment sent. */
+01178 
+01179   /** The application state. */
+01180   uip_tcp_appstate_t appstate;
+01181 };
+01182 
+01183 
+01184 /**
+01185  * Pointer to the current TCP connection.
+01186  *
+01187  * The uip_conn pointer can be used to access the current TCP
+01188  * connection.
+01189  */
+01190 extern struct uip_conn *uip_conn;
+01191 /* The array containing all uIP connections. */
+01192 extern struct uip_conn uip_conns[UIP_CONNS];
+01193 /**
+01194  * \addtogroup uiparch
+01195  * @{
+01196  */
+01197 
+01198 /**
+01199  * 4-byte array used for the 32-bit sequence number calculations.
+01200  */
+01201 extern u8_t uip_acc32[4];
+01202 
+01203 /** @} */
+01204 
+01205 
+01206 #if UIP_UDP
+01207 /**
+01208  * Representation of a uIP UDP connection.
+01209  */
+01210 struct uip_udp_conn {
+01211   uip_ipaddr_t ripaddr;   /**< The IP address of the remote peer. */
+01212   u16_t lport;        /**< The local port number in network byte order. */
+01213   u16_t rport;        /**< The remote port number in network byte order. */
+01214   u8_t  ttl;          /**< Default time-to-live. */
+01215 
+01216   /** The application state. */
+01217   uip_udp_appstate_t appstate;
+01218 };
+01219 
+01220 /**
+01221  * The current UDP connection.
+01222  */
+01223 extern struct uip_udp_conn *uip_udp_conn;
+01224 extern struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
+01225 #endif /* UIP_UDP */
+01226 
+01227 /**
+01228  * The structure holding the TCP/IP statistics that are gathered if
+01229  * UIP_STATISTICS is set to 1.
+01230  *
+01231  */
+01232 struct uip_stats {
+01233   struct {
+01234     uip_stats_t drop;     /**< Number of dropped packets at the IP
+01235                              layer. */
+01236     uip_stats_t recv;     /**< Number of received packets at the IP
+01237                              layer. */
+01238     uip_stats_t sent;     /**< Number of sent packets at the IP
+01239                              layer. */
+01240     uip_stats_t vhlerr;   /**< Number of packets dropped due to wrong
+01241                              IP version or header length. */
+01242     uip_stats_t hblenerr; /**< Number of packets dropped due to wrong
+01243                              IP length, high byte. */
+01244     uip_stats_t lblenerr; /**< Number of packets dropped due to wrong
+01245                              IP length, low byte. */
+01246     uip_stats_t fragerr;  /**< Number of packets dropped since they
+01247                              were IP fragments. */
+01248     uip_stats_t chkerr;   /**< Number of packets dropped due to IP
+01249                              checksum errors. */
+01250     uip_stats_t protoerr; /**< Number of packets dropped since they
+01251                              were neither ICMP, UDP nor TCP. */
+01252   } ip;                   /**< IP statistics. */
+01253   struct {
+01254     uip_stats_t drop;     /**< Number of dropped ICMP packets. */
+01255     uip_stats_t recv;     /**< Number of received ICMP packets. */
+01256     uip_stats_t sent;     /**< Number of sent ICMP packets. */
+01257     uip_stats_t typeerr;  /**< Number of ICMP packets with a wrong
+01258                              type. */
+01259   } icmp;                 /**< ICMP statistics. */
+01260   struct {
+01261     uip_stats_t drop;     /**< Number of dropped TCP segments. */
+01262     uip_stats_t recv;     /**< Number of recived TCP segments. */
+01263     uip_stats_t sent;     /**< Number of sent TCP segments. */
+01264     uip_stats_t chkerr;   /**< Number of TCP segments with a bad
+01265                              checksum. */
+01266     uip_stats_t ackerr;   /**< Number of TCP segments with a bad ACK
+01267                              number. */
+01268     uip_stats_t rst;      /**< Number of recevied TCP RST (reset) segments. */
+01269     uip_stats_t rexmit;   /**< Number of retransmitted TCP segments. */
+01270     uip_stats_t syndrop;  /**< Number of dropped SYNs due to too few
+01271                              connections was avaliable. */
+01272     uip_stats_t synrst;   /**< Number of SYNs for closed ports,
+01273                              triggering a RST. */
+01274   } tcp;                  /**< TCP statistics. */
+01275 #if UIP_UDP
+01276   struct {
+01277     uip_stats_t drop;     /**< Number of dropped UDP segments. */
+01278     uip_stats_t recv;     /**< Number of recived UDP segments. */
+01279     uip_stats_t sent;     /**< Number of sent UDP segments. */
+01280     uip_stats_t chkerr;   /**< Number of UDP segments with a bad
+01281                              checksum. */
+01282   } udp;                  /**< UDP statistics. */
+01283 #endif /* UIP_UDP */
+01284 };
+01285 
+01286 /**
+01287  * The uIP TCP/IP statistics.
+01288  *
+01289  * This is the variable in which the uIP TCP/IP statistics are gathered.
+01290  */
+01291 extern struct uip_stats uip_stat;
+01292 
+01293 
+01294 /*---------------------------------------------------------------------------*/
+01295 /* All the stuff below this point is internal to uIP and should not be
+01296  * used directly by an application or by a device driver.
+01297  */
+01298 /*---------------------------------------------------------------------------*/
+01299 /* u8_t uip_flags:
+01300  *
+01301  * When the application is called, uip_flags will contain the flags
+01302  * that are defined in this file. Please read below for more
+01303  * infomation.
+01304  */
+01305 extern u8_t uip_flags;
+01306 
+01307 /* The following flags may be set in the global variable uip_flags
+01308    before calling the application callback. The UIP_ACKDATA,
+01309    UIP_NEWDATA, and UIP_CLOSE flags may both be set at the same time,
+01310    whereas the others are mutualy exclusive. Note that these flags
+01311    should *NOT* be accessed directly, but only through the uIP
+01312    functions/macros. */
+01313 
+01314 #define UIP_ACKDATA   1     /* Signifies that the outstanding data was
+01315                                acked and the application should send
+01316                                out new data instead of retransmitting
+01317                                the last data. */
+01318 #define UIP_NEWDATA   2     /* Flags the fact that the peer has sent
+01319                                us new data. */
+01320 #define UIP_REXMIT    4     /* Tells the application to retransmit the
+01321                                data that was last sent. */
+01322 #define UIP_POLL      8     /* Used for polling the application, to
+01323                                check if the application has data that
+01324                                it wants to send. */
+01325 #define UIP_CLOSE     16    /* The remote host has closed the
+01326                                connection, thus the connection has
+01327                                gone away. Or the application signals
+01328                                that it wants to close the
+01329                                connection. */
+01330 #define UIP_ABORT     32    /* The remote host has aborted the
+01331                                connection, thus the connection has
+01332                                gone away. Or the application signals
+01333                                that it wants to abort the
+01334                                connection. */
+01335 #define UIP_CONNECTED 64    /* We have got a connection from a remote
+01336                                host and have set up a new connection
+01337                                for it, or an active connection has
+01338                                been successfully established. */
+01339 
+01340 #define UIP_TIMEDOUT  128   /* The connection has been aborted due to
+01341                                too many retransmissions. */
+01342 
+01343 /* uip_process(flag):
+01344  *
+01345  * The actual uIP function which does all the work.
+01346  */
+01347 void uip_process(u8_t flag);
+01348 
+01349 /* The following flags are passed as an argument to the uip_process()
+01350    function. They are used to distinguish between the two cases where
+01351    uip_process() is called. It can be called either because we have
+01352    incoming data that should be processed, or because the periodic
+01353    timer has fired. These values are never used directly, but only in
+01354    the macrose defined in this file. */
+01355  
+01356 #define UIP_DATA          1     /* Tells uIP that there is incoming
+01357                                    data in the uip_buf buffer. The
+01358                                    length of the data is stored in the
+01359                                    global variable uip_len. */
+01360 #define UIP_TIMER         2     /* Tells uIP that the periodic timer
+01361                                    has fired. */
+01362 #define UIP_POLL_REQUEST  3     /* Tells uIP that a connection should
+01363                                    be polled. */
+01364 #define UIP_UDP_SEND_CONN 4     /* Tells uIP that a UDP datagram
+01365                                    should be constructed in the
+01366                                    uip_buf buffer. */
+01367 #if UIP_UDP
+01368 #define UIP_UDP_TIMER     5
+01369 #endif /* UIP_UDP */
+01370 
+01371 /* The TCP states used in the uip_conn->tcpstateflags. */
+01372 #define UIP_CLOSED      0
+01373 #define UIP_SYN_RCVD    1
+01374 #define UIP_SYN_SENT    2
+01375 #define UIP_ESTABLISHED 3
+01376 #define UIP_FIN_WAIT_1  4
+01377 #define UIP_FIN_WAIT_2  5
+01378 #define UIP_CLOSING     6
+01379 #define UIP_TIME_WAIT   7
+01380 #define UIP_LAST_ACK    8
+01381 #define UIP_TS_MASK     15
+01382   
+01383 #define UIP_STOPPED      16
+01384 
+01385 /* The TCP and IP headers. */
+01386 struct uip_tcpip_hdr {
+01387 #if UIP_CONF_IPV6
+01388   /* IPv6 header. */
+01389   u8_t vtc,
+01390     tcflow;
+01391   u16_t flow;
+01392   u8_t len[2];
+01393   u8_t proto, ttl;
+01394   uip_ip6addr_t srcipaddr, destipaddr;
+01395 #else /* UIP_CONF_IPV6 */
+01396   /* IPv4 header. */
+01397   u8_t vhl,
+01398     tos,
+01399     len[2],
+01400     ipid[2],
+01401     ipoffset[2],
+01402     ttl,
+01403     proto;
+01404   u16_t ipchksum;
+01405   u16_t srcipaddr[2],
+01406     destipaddr[2];
+01407 #endif /* UIP_CONF_IPV6 */
+01408   
+01409   /* TCP header. */
+01410   u16_t srcport,
+01411     destport;
+01412   u8_t seqno[4],
+01413     ackno[4],
+01414     tcpoffset,
+01415     flags,
+01416     wnd[2];
+01417   u16_t tcpchksum;
+01418   u8_t urgp[2];
+01419   u8_t optdata[4];
+01420 };
+01421 
+01422 /* The ICMP and IP headers. */
+01423 struct uip_icmpip_hdr {
+01424 #if UIP_CONF_IPV6
+01425   /* IPv6 header. */
+01426   u8_t vtc,
+01427     tcf;
+01428   u16_t flow;
+01429   u8_t len[2];
+01430   u8_t proto, ttl;
+01431   uip_ip6addr_t srcipaddr, destipaddr;
+01432 #else /* UIP_CONF_IPV6 */
+01433   /* IPv4 header. */
+01434   u8_t vhl,
+01435     tos,
+01436     len[2],
+01437     ipid[2],
+01438     ipoffset[2],
+01439     ttl,
+01440     proto;
+01441   u16_t ipchksum;
+01442   u16_t srcipaddr[2],
+01443     destipaddr[2];
+01444 #endif /* UIP_CONF_IPV6 */
+01445   
+01446   /* ICMP (echo) header. */
+01447   u8_t type, icode;
+01448   u16_t icmpchksum;
+01449 #if !UIP_CONF_IPV6
+01450   u16_t id, seqno;
+01451 #else /* !UIP_CONF_IPV6 */
+01452   u8_t flags, reserved1, reserved2, reserved3;
+01453   u8_t icmp6data[16];
+01454   u8_t options[1];
+01455 #endif /* !UIP_CONF_IPV6 */
+01456 };
+01457 
+01458 
+01459 /* The UDP and IP headers. */
+01460 struct uip_udpip_hdr {
+01461 #if UIP_CONF_IPV6
+01462   /* IPv6 header. */
+01463   u8_t vtc,
+01464     tcf;
+01465   u16_t flow;
+01466   u8_t len[2];
+01467   u8_t proto, ttl;
+01468   uip_ip6addr_t srcipaddr, destipaddr;
+01469 #else /* UIP_CONF_IPV6 */
+01470   /* IP header. */
+01471   u8_t vhl,
+01472     tos,
+01473     len[2],
+01474     ipid[2],
+01475     ipoffset[2],
+01476     ttl,
+01477     proto;
+01478   u16_t ipchksum;
+01479   u16_t srcipaddr[2],
+01480     destipaddr[2];
+01481 #endif /* UIP_CONF_IPV6 */
+01482   
+01483   /* UDP header. */
+01484   u16_t srcport,
+01485     destport;
+01486   u16_t udplen;
+01487   u16_t udpchksum;
+01488 };
+01489 
+01490 
+01491 
+01492 /**
+01493  * The buffer size available for user data in the \ref uip_buf buffer.
+01494  *
+01495  * This macro holds the available size for user data in the \ref
+01496  * uip_buf buffer. The macro is intended to be used for checking
+01497  * bounds of available user data.
+01498  *
+01499  * Example:
+01500  \code
+01501  snprintf(uip_appdata, UIP_APPDATA_SIZE, "%u\n", i);
+01502  \endcode
+01503  *
+01504  * \hideinitializer
+01505  */
+01506 #define UIP_APPDATA_SIZE (UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN)
+01507 
+01508 
+01509 #define UIP_PROTO_ICMP  1
+01510 #define UIP_PROTO_TCP   6
+01511 #define UIP_PROTO_UDP   17
+01512 #define UIP_PROTO_ICMP6 58
+01513 
+01514 /* Header sizes. */
+01515 #if UIP_CONF_IPV6
+01516 #define UIP_IPH_LEN    40
+01517 #else /* UIP_CONF_IPV6 */
+01518 #define UIP_IPH_LEN    20    /* Size of IP header */
+01519 #endif /* UIP_CONF_IPV6 */
+01520 #define UIP_UDPH_LEN    8    /* Size of UDP header */
+01521 #define UIP_TCPH_LEN   20    /* Size of TCP header */
+01522 #define UIP_IPUDPH_LEN (UIP_UDPH_LEN + UIP_IPH_LEN)    /* Size of IP +
+01523                                                           UDP
+01524                                                           header */
+01525 #define UIP_IPTCPH_LEN (UIP_TCPH_LEN + UIP_IPH_LEN)    /* Size of IP +
+01526                                                           TCP
+01527                                                           header */
+01528 #define UIP_TCPIP_HLEN UIP_IPTCPH_LEN
+01529 
+01530 
+01531 #if UIP_FIXEDADDR
+01532 extern const uip_ipaddr_t uip_hostaddr, uip_netmask, uip_draddr;
+01533 #else /* UIP_FIXEDADDR */
+01534 extern uip_ipaddr_t uip_hostaddr, uip_netmask, uip_draddr;
+01535 #endif /* UIP_FIXEDADDR */
+01536 
+01537 
+01538 
+01539 /**
+01540  * Representation of a 48-bit Ethernet address.
+01541  */
+01542 struct uip_eth_addr {
+01543   u8_t addr[6];
+01544 };
+01545 
+01546 /**
+01547  * Calculate the Internet checksum over a buffer.
+01548  *
+01549  * The Internet checksum is the one's complement of the one's
+01550  * complement sum of all 16-bit words in the buffer.
+01551  *
+01552  * See RFC1071.
+01553  *
+01554  * \param buf A pointer to the buffer over which the checksum is to be
+01555  * computed.
+01556  *
+01557  * \param len The length of the buffer over which the checksum is to
+01558  * be computed.
+01559  *
+01560  * \return The Internet checksum of the buffer.
+01561  */
+01562 u16_t uip_chksum(u16_t *buf, u16_t len);
+01563 
+01564 /**
+01565  * Calculate the IP header checksum of the packet header in uip_buf.
+01566  *
+01567  * The IP header checksum is the Internet checksum of the 20 bytes of
+01568  * the IP header.
+01569  *
+01570  * \return The IP header checksum of the IP header in the uip_buf
+01571  * buffer.
+01572  */
+01573 u16_t uip_ipchksum(void);
+01574 
+01575 /**
+01576  * Calculate the TCP checksum of the packet in uip_buf and uip_appdata.
+01577  *
+01578  * The TCP checksum is the Internet checksum of data contents of the
+01579  * TCP segment, and a pseudo-header as defined in RFC793.
+01580  *
+01581  * \return The TCP checksum of the TCP segment in uip_buf and pointed
+01582  * to by uip_appdata.
+01583  */
+01584 u16_t uip_tcpchksum(void);
+01585 
+01586 /**
+01587  * Calculate the UDP checksum of the packet in uip_buf and uip_appdata.
+01588  *
+01589  * The UDP checksum is the Internet checksum of data contents of the
+01590  * UDP segment, and a pseudo-header as defined in RFC768.
+01591  *
+01592  * \return The UDP checksum of the UDP segment in uip_buf and pointed
+01593  * to by uip_appdata.
+01594  */
+01595 u16_t uip_udpchksum(void);
+01596 
+01597 
+01598 #endif /* __UIP_H__ */
+01599 
+01600 
+01601 /** @} */
+