* * \param port A 16-bit port number in network byte order. */void uip_unlisten(u16_t port);/** * Connect to a remote host using TCP. * * This function is used to start a new connection to the specified * port on the specied host. It allocates a new connection identifier, * sets the connection to the SYN_SENT state and sets the * retransmission timer to 0. This will cause a TCP SYN segment to be * sent out the next time this connection is periodically processed, * which usually is done within 0.5 seconds after the call to * uip_connect(). * * \note This function is avaliable only if support for active open * has been configured by defining UIP_ACTIVE_OPEN to 1 in uipopt.h. * * \note Since this function requires the port number to be in network * byte order, a convertion using HTONS() or htons() is necessary. * \code u16_t ipaddr[2]; uip_ipaddr(ipaddr, 192,168,1,2); uip_connect(ipaddr, HTONS(80));  \endcode *  * \param ripaddr A pointer to a 4-byte array representing the IP * address of the remote hot. * * \param port A 16-bit port number in network byte order. * * \return A pointer to the uIP connection identifier for the new connection, * or NULL if no connection could be allocated.    * */struct uip_conn *uip_connect(u16_t *ripaddr, u16_t port);/** * \internal * * Check if a connection has outstanding (i.e., unacknowledged) data. * * \param conn A pointer to the uip_conn structure for the connection. * * \hideinitializer */#define uip_outstanding(conn) ((conn)->len)/** * Send data on the current connection. * * This function is used to send out a single segment of TCP * data. Only applications that have been invoked by uIP for event * processing can send data.  * * The amount of data that actually is sent out after a call to this * funcion is determined by the maximum amount of data TCP allows. uIP * will automatically crop the data so that only the appropriate * amount of data is sent. The function uip_mss() can be used to query * uIP for the amount of data that actually will be sent. *  * \note This function does not guarantee that the sent data will * arrive at the destination. If the data is lost in the network, the * application will be invoked with the uip_rexmit() event being * set. The application will then have to resend the data using this * function. *  * \param data A pointer to the data which is to be sent. * * \param len The maximum amount of data bytes to be sent. * * \hideinitializer */#define uip_send(data, len) do { uip_sappdata = (data); uip_slen = (len);} while(0)   /** * The length of any incoming data that is currently avaliable (if avaliable) * in the uip_appdata buffer. * * The test function uip_data() must first be used to check if there * is any data available at all. * * \hideinitializer */#define uip_datalen()       uip_len/** * The length of any out-of-band data (urgent data) that has arrived * on the connection. * * \note The configuration parameter UIP_URGDATA must be set for this * function to be enabled. * * \hideinitializer */#define uip_urgdatalen()    uip_urglen/** * Close the current connection. * * This function will close the current connection in a nice way. * * \hideinitializer */#define uip_close()         (uip_flags = UIP_CLOSE)/** * Abort the current connection. * * This function will abort (reset) the current connection, and is * usually used when an error has occured that prevents using the * uip_close() function. * * \hideinitializer */#define uip_abort()         (uip_flags = UIP_ABORT)/** * Tell the sending host to stop sending data. * * This function will close our receiver's window so that we stop * receiving data for the current connection. * * \hideinitializer */#define uip_stop()          (uip_conn->tcpstateflags |= UIP_STOPPED)/** * Find out if the current connection has been previously stopped with * uip_stop(). * * \hideinitializer */#define uip_stopped(conn)   ((conn)->tcpstateflags & UIP_STOPPED)/** * Restart the current connection, if is has previously been stopped * with uip_stop(). * * This function will open the receiver's window again so that we * start receiving data for the current connection. * * \hideinitializer */#define uip_restart()         do { uip_flags |= UIP_NEWDATA; \                                   uip_conn->tcpstateflags &= ~UIP_STOPPED; \                              } while(0)/* uIP tests that can be made to determine in what state the current   connection is, and what the application function should do. *//** * Is new incoming data available? * * Will reduce to non-zero if there is new data for the application * present at the uip_appdata pointer. The size of the data is * avaliable through the uip_len variable. * * \hideinitializer */#define uip_newdata()   (uip_flags & UIP_NEWDATA)/** * Has previously sent data been acknowledged? * * Will reduce to non-zero if the previously sent data has been * acknowledged by the remote host. This means that the application * can send new data.  * * \hideinitializer */#define uip_acked()   (uip_flags & UIP_ACKDATA)/** * Has the connection just been connected?   * * Reduces to non-zero if the current connection has been connected to * a remote host. This will happen both if the connection has been * actively opened (with uip_connect()) or passively opened (with * uip_listen()). * * \hideinitializer */#define uip_connected() (uip_flags & UIP_CONNECTED)/** * Has the connection been closed by the other end? * * Is non-zero if the connection has been closed by the remote * host. The application may then do the necessary clean-ups. * * \hideinitializer */#define uip_closed()    (uip_flags & UIP_CLOSE)/** * Has the connection been aborted by the other end? * * Non-zero if the current connection has been aborted (reset) by the * remote host. * * \hideinitializer */#define uip_aborted()    (uip_flags & UIP_ABORT)/** * Has the connection timed out? * * Non-zero if the current connection has been aborted due to too many * retransmissions. * * \hideinitializer */#define uip_timedout()    (uip_flags & UIP_TIMEDOUT)/** * Do we need to retransmit previously data? * * Reduces to non-zero if the previously sent data has been lost in * the network, and the application should retransmit it. The * application should send the exact same data as it did the last * time, using the uip_send() function. * * \hideinitializer */#define uip_rexmit()     (uip_flags & UIP_REXMIT)/** * Is the connection being polled by uIP? * * Is non-zero if the reason the application is invoked is that the * current connection has been idle for a while and should be * polled. * * The polling event can be used for sending data without having to * wait for the remote host to send data. * * \hideinitializer */ #define uip_poll()       (uip_flags & UIP_POLL)/** * Get the initial maxium segment size (MSS) of the current * connection. * * \hideinitializer */#define uip_initialmss()             (uip_conn->initialmss)/** * Get the current maxium segment size that can be sent on the current * connection. * * The current maxiumum segment size that can be sent on the * connection is computed from the receiver's window and the MSS of * the connection (which also is available by calling * uip_initialmss()). * * \hideinitializer */#define uip_mss()             (uip_conn->mss)/** * Set up a new UDP connection. * * \param ripaddr A pointer to a 4-byte structure representing the IP * address of the remote host. * * \param rport The remote port number in network byte order. * * \return The uip_udp_conn structure for the new connection or NULL * if no connection could be allocated. */struct uip_udp_conn *uip_udp_new(u16_t *ripaddr, u16_t rport);/** * Removed a UDP connection. * * \param conn A pointer to the uip_udp_conn structure for the connection. * * \hideinitializer */#define uip_udp_remove(conn) (conn)->lport = 0/** * Send a UDP datagram of length len on the current connection. * * This function can only be called in response to a UDP event (poll * or newdata). The data must be present in the uip_buf buffer, at the * place pointed to by the uip_appdata pointer. * * \param len The length of the data in the uip_buf buffer. * * \hideinitializer */#define uip_udp_send(len) uip_slen = (len)/** @} *//* uIP convenience and converting functions. *//** * \defgroup uipconvfunc uIP conversion functions * @{ * * These functions can be used for converting between different data * formats used by uIP. */ /** * Pack an IP address into a 4-byte array which is used by uIP to * represent IP addresses. * * Example: \code u16_t ipaddr[2]; uip_ipaddr(&ipaddr, 192,168,1,2);  \endcode * * \param addr A pointer to a 4-byte array that will be filled in with * the IP addres. * \param addr0 The first octet of the IP address. * \param addr1 The second octet of the IP address. * \param addr2 The third octet of the IP address. * \param addr3 The forth octet of the IP address.  * * \hideinitializer */#define uip_ipaddr(addr, addr0,addr1,addr2,addr3) do { \                     (addr)[0] = HTONS(((addr0) << 8) | (addr1)); \                     (addr)[1] = HTONS(((addr2) << 8) | (addr3)); \                  } while(0)/** * Convert 16-bit quantity from host byte order to network byte order. * * This macro is primarily used for converting constants from host * byte order to network byte order. For converting variables to * network byte order, use the htons() function instead. * * \hideinitializer */#ifndef HTONS#   if BYTE_ORDER == BIG_ENDIAN#      define HTONS(n) (n)#   else /* BYTE_ORDER == BIG_ENDIAN */#      define HTONS(n) ((((u16_t)((n) & 0xff)) << 8) | (((n) & 0xff00) >> 8))