Skip to content
Snippets Groups Projects
Select Git revision
  • c13ee1f8fc53f1b71d724de03e5c0c83d4878314
  • master default protected
  • genofire/ble-rewrite
  • koalo/bhi160
  • rahix/simple_menu
  • ch3/splashscreen
  • koalo/bhi160-works-but-dirty
  • ios-workarounds
  • koalo/wip/i2c-for-python
  • renze/safe_mode
  • renze/hatchery_apps
  • schneider/fundamental-test
  • koalo/factory-reset
  • msgctl/gfx_rle
  • msgctl/faultscreen
  • msgctl/textbuffer_api
  • schneider/bonding
  • schneider/bootloader-update-9a0d158
  • schneider/bsec
  • rahix/bma
  • rahix/bhi
  • v1.3
  • v1.2
  • v1.1
  • v1.0
  • release-1
  • bootloader-v1
  • v0.0
28 results

textbuffer.c

Blame
  • Forked from card10 / firmware
    Source project has a limited visibility.
    socket.h 29.66 KiB
    /*****************************************************************************
    *
    *  socket.h  - CC3000 Host Driver Implementation.
    *  Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
    *
    *  Redistribution and use in source and binary forms, with or without
    *  modification, are permitted provided that the following conditions
    *  are met:
    *
    *    Redistributions of source code must retain the above copyright
    *    notice, this list of conditions and the following disclaimer.
    *
    *    Redistributions in binary form must reproduce the above copyright
    *    notice, this list of conditions and the following disclaimer in the
    *    documentation and/or other materials provided with the   
    *    distribution.
    *
    *    Neither the name of Texas Instruments Incorporated nor the names of
    *    its contributors may be used to endorse or promote products derived
    *    from this software without specific prior written permission.
    *
    *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
    *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
    *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
    *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
    *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
    *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
    *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
    *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *
    *****************************************************************************/
    #ifndef __CC3000_SOCKET_H__
    #define __CC3000_SOCKET_H__
    
    #include "cc3000_common.h"
    
    //*****************************************************************************
    //
    //! \addtogroup socket_api
    //! @{
    //
    //*****************************************************************************
    
    
    //*****************************************************************************
    //
    // If building with a C++ compiler, make all of the definitions in this header
    // have a C binding.
    //
    //*****************************************************************************
    #ifdef  __cplusplus
    extern "C" {
    #endif
    
    #define HOSTNAME_MAX_LENGTH (230)  // 230 bytes + header shouldn't exceed 8 bit value
    
    //--------- Address Families --------
    
    #define  AF_INET                2
    #define  AF_INET6               23
    
    //------------ Socket Types ------------
    
    #define  SOCK_STREAM            1
    #define  SOCK_DGRAM             2
    #define  SOCK_RAW               3           // Raw sockets allow new IPv4 protocols to be implemented in user space. A raw socket receives or sends the raw datagram not including link level headers
    #define  SOCK_RDM               4
    #define  SOCK_SEQPACKET         5
    
    //----------- Socket Protocol ----------
    
    #define IPPROTO_IP              0           // dummy for IP
    #define IPPROTO_ICMP            1           // control message protocol
    #define IPPROTO_IPV4            IPPROTO_IP  // IP inside IP
    #define IPPROTO_TCP             6           // tcp
    #define IPPROTO_UDP             17          // user datagram protocol
    #define IPPROTO_IPV6            41          // IPv6 in IPv6
    #define IPPROTO_NONE            59          // No next header
    #define IPPROTO_RAW             255         // raw IP packet
    #define IPPROTO_MAX             256
    
    //----------- Socket retunr codes  -----------
    
    #define SOC_ERROR				(-1)		// error 
    #define SOC_IN_PROGRESS			(-2)		// socket in progress
    
    //----------- Socket Options -----------
    #define  SOL_SOCKET             0xffff		//  socket level
    #define  SOCKOPT_RECV_NONBLOCK         	0	// recv non block mode, set SOCK_ON or SOCK_OFF (default block mode)
    #define  SOCKOPT_RECV_TIMEOUT			1	// optname to configure recv and recvfromtimeout
    #define  SOCKOPT_ACCEPT_NONBLOCK		2	// accept non block mode, set SOCK_ON or SOCK_OFF (default block mode)
    #define  SOCK_ON                0			// socket non-blocking mode	is enabled		
    #define  SOCK_OFF               1			// socket blocking mode is enabled
    
    #define  MAX_PACKET_SIZE        1500
    #define  MAX_LISTEN_QUEUE       4
    
    #define  IOCTL_SOCKET_EVENTMASK
    
    #define ENOBUFS                 55          // No buffer space available
    
    #define __FD_SETSIZE            32
    
    #define  ASIC_ADDR_LEN          8
    	
    #define NO_QUERY_RECIVED        -3
    	
    	
    typedef struct _in_addr_t
    {
        UINT32 s_addr;                   // load with inet_aton()
    } in_addr;
    
    typedef struct _sockaddr_t
    {
        UINT16   sa_family;
        UINT8     sa_data[14];
    } sockaddr;
    
    typedef struct _sockaddr_in_t
    {
        INT16            sin_family;            // e.g. AF_INET
        UINT16   sin_port;              // e.g. htons(3490)
        in_addr          sin_addr;              // see struct in_addr, below
        CHAR             sin_zero[8];           // zero this if you want to
    } sockaddr_in;
    
    typedef UINT32 socklen_t;
    
    // The fd_set member is required to be an array of INT32s.
    typedef INT32 __fd_mask;
    
    // It's easier to assume 8-bit bytes than to get CHAR_BIT.
    #define __NFDBITS               (8 * sizeof (__fd_mask))
    #define __FDELT(d)              ((d) / __NFDBITS)
    #define __FDMASK(d)             ((__fd_mask) 1 << ((d) % __NFDBITS))
    
    // fd_set for select and pselect.
    typedef struct
    {
        __fd_mask fds_bits[__FD_SETSIZE / __NFDBITS];
    #define __FDS_BITS(set)        ((set)->fds_bits)
    } fd_set;
    
    // We don't use `memset' because this would require a prototype and
    //   the array isn't too big.
    #define __FD_ZERO(set)                               \
      do {                                                \
        UINT16 __i;                                 \
        fd_set *__arr = (set);                            \
        for (__i = 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) \
          __FDS_BITS (__arr)[__i] = 0;                    \
      } while (0)
    #define __FD_SET(d, set)       (__FDS_BITS (set)[__FDELT (d)] |= __FDMASK (d))
    #define __FD_CLR(d, set)       (__FDS_BITS (set)[__FDELT (d)] &= ~__FDMASK (d))
    #define __FD_ISSET(d, set)     (__FDS_BITS (set)[__FDELT (d)] & __FDMASK (d))
    
    // Access macros for 'fd_set'.
    #define FD_SET(fd, fdsetp)      __FD_SET (fd, fdsetp)
    #define FD_CLR(fd, fdsetp)      __FD_CLR (fd, fdsetp)
    #define FD_ISSET(fd, fdsetp)    __FD_ISSET (fd, fdsetp)
    #define FD_ZERO(fdsetp)         __FD_ZERO (fdsetp)
    
    //Use in case of Big Endian only
      
    #define htonl(A)    ((((UINT32)(A) & 0xff000000) >> 24) | \
                         (((UINT32)(A) & 0x00ff0000) >> 8) | \
                         (((UINT32)(A) & 0x0000ff00) << 8) | \
                         (((UINT32)(A) & 0x000000ff) << 24))
    
    #define ntohl                   htonl
    
    //Use in case of Big Endian only
    #define htons(A)     ((((UINT32)(A) & 0xff00) >> 8) | \
                          (((UINT32)(A) & 0x00ff) << 8))
    
    
    #define ntohs                   htons
    
    // mDNS port - 5353    mDNS multicast address - 224.0.0.251 
    #define SET_mDNS_ADD(sockaddr)     	   	sockaddr.sa_data[0] = 0x14; \
    																								sockaddr.sa_data[1] = 0xe9; \
    																								sockaddr.sa_data[2] = 0xe0; \
    																								sockaddr.sa_data[3] = 0x0; \
    																								sockaddr.sa_data[4] = 0x0; \
    																								sockaddr.sa_data[5] = 0xfb; 
    
    
    //*****************************************************************************
    //
    // Prototypes for the APIs.
    //
    //*****************************************************************************
    
    //*****************************************************************************
    //
    //! socket
    //!
    //!  @param  domain    selects the protocol family which will be used for 
    //!                    communication. On this version only AF_INET is supported
    //!  @param  type      specifies the communication semantics. On this version 
    //!                    only SOCK_STREAM, SOCK_DGRAM, SOCK_RAW are supported
    //!  @param  protocol  specifies a particular protocol to be used with the 
    //!                    socket IPPROTO_TCP, IPPROTO_UDP or IPPROTO_RAW are 
    //!                    supported.
    //!
    //!  @return  On success, socket handle that is used for consequent socket 
    //!           operations. On error, -1 is returned.
    //!
    //!  @brief  create an endpoint for communication
    //!          The socket function creates a socket that is bound to a specific 
    //!          transport service provider. This function is called by the 
    //!          application layer to obtain a socket handle.
    //
    //*****************************************************************************
    extern INT16 CC3000_EXPORT(socket)(INT32 domain, INT32 type, INT32 protocol);
    
    //*****************************************************************************
    //
    //! closesocket
    //!
    //!  @param  sd    socket handle.
    //!
    //!  @return  On success, zero is returned. On error, -1 is returned.
    //!
    //!  @brief  The socket function closes a created socket.
    //
    //*****************************************************************************
    extern INT32 CC3000_EXPORT(closesocket)(INT32 sd);
    
    //*****************************************************************************
    //
    //! accept
    //!
    //!  @param[in]   sd      socket descriptor (handle)              
    //!  @param[out]  addr    the argument addr is a pointer to a sockaddr structure
    //!                       This structure is filled in with the address of the  
    //!                       peer socket, as known to the communications layer.        
    //!                       determined. The exact format of the address returned             
    //!                       addr is by the socket's address sockaddr. 
    //!                       On this version only AF_INET is supported.
    //!                       This argument returns in network order.
    //!  @param[out] addrlen  the addrlen argument is a value-result argument: 
    //!                       it should initially contain the size of the structure
    //!                       pointed to by addr.
    //!
    //!  @return  For socket in blocking mode:
    //!				      On success, socket handle. on failure negative
    //!			      For socket in non-blocking mode:
    //!				     - On connection establishment, socket handle
    //!				     - On connection pending, SOC_IN_PROGRESS (-2)
    //!			       - On failure, SOC_ERROR	(-1)
    //!
    //!  @brief  accept a connection on a socket:
    //!          This function is used with connection-based socket types 
    //!          (SOCK_STREAM). It extracts the first connection request on the 
    //!          queue of pending connections, creates a new connected socket, and
    //!          returns a new file descriptor referring to that socket.
    //!          The newly created socket is not in the listening state. 
    //!          The original socket sd is unaffected by this call. 
    //!          The argument sd is a socket that has been created with socket(),
    //!          bound to a local address with bind(), and is  listening for 
    //!          connections after a listen(). The argument addr is a pointer 
    //!          to a sockaddr structure. This structure is filled in with the 
    //!          address of the peer socket, as known to the communications layer.
    //!          The exact format of the address returned addr is determined by the 
    //!          socket's address family. The addrlen argument is a value-result
    //!          argument: it should initially contain the size of the structure
    //!          pointed to by addr, on return it will contain the actual 
    //!          length (in bytes) of the address returned.
    //!
    //! @sa     socket ; bind ; listen
    //
    //*****************************************************************************
    extern INT32 CC3000_EXPORT(accept)(INT32 sd, sockaddr *addr, socklen_t *addrlen);
    
    //*****************************************************************************
    //
    //! bind
    //!
    //!  @param[in]   sd      socket descriptor (handle)              
    //!  @param[out]  addr    specifies the destination address. On this version 
    //!                       only AF_INET is supported.
    //!  @param[out] addrlen  contains the size of the structure pointed to by addr.
    //!
    //!  @return  	On success, zero is returned. On error, -1 is returned.
    //!
    //!  @brief  assign a name to a socket
    //!          This function gives the socket the local address addr.
    //!          addr is addrlen bytes long. Traditionally, this is called when a 
    //!          socket is created with socket, it exists in a name space (address 
    //!          family) but has no name assigned.
    //!          It is necessary to assign a local address before a SOCK_STREAM
    //!          socket may receive connections.
    //!
    //! @sa     socket ; accept ; listen
    //
    //*****************************************************************************
    extern INT32 CC3000_EXPORT(bind)(INT32 sd, const sockaddr *addr, INT32 addrlen);
    
    //*****************************************************************************
    //
    //! listen
    //!
    //!  @param[in]   sd      socket descriptor (handle)              
    //!  @param[in]  backlog  specifies the listen queue depth. On this version
    //!                       backlog is not supported.
    //!  @return  	On success, zero is returned. On error, -1 is returned.
    //!
    //!  @brief  listen for connections on a socket
    //!          The willingness to accept incoming connections and a queue
    //!          limit for incoming connections are specified with listen(),
    //!          and then the connections are accepted with accept.
    //!          The listen() call applies only to sockets of type SOCK_STREAM
    //!          The backlog parameter defines the maximum length the queue of
    //!          pending connections may grow to. 
    //!
    //! @sa     socket ; accept ; bind
    //!
    //! @note   On this version, backlog is not supported
    //
    //*****************************************************************************
    extern INT32 CC3000_EXPORT(listen)(INT32 sd, INT32 backlog);
    
    //*****************************************************************************
    //
    //! gethostbyname
    //!
    //!  @param[in]   hostname     host name              
    //!  @param[in]   usNameLen    name length 
    //!  @param[out]  out_ip_addr  This parameter is filled in with host IP address. 
    //!                            In case that host name is not resolved, 
    //!                            out_ip_addr is zero.                  
    //!  @return  	On success, positive is returned. On error, negative is returned
    //!
    //!  @brief  Get host IP by name. Obtain the IP Address of machine on network, 
    //!          by its name.
    //!
    //!  @note  On this version, only blocking mode is supported. Also note that
    //!		     the function requires DNS server to be configured prior to its usage.
    //
    //*****************************************************************************
    #ifndef CC3000_TINY_DRIVER 
    extern INT16 CC3000_EXPORT(gethostbyname)(CHAR * hostname, UINT16 usNameLen, UINT32* out_ip_addr);
    #endif
    
    
    //*****************************************************************************
    //
    //! connect
    //!
    //!  @param[in]   sd       socket descriptor (handle)         
    //!  @param[in]   addr     specifies the destination addr. On this version
    //!                        only AF_INET is supported.
    //!  @param[out]  addrlen  contains the size of the structure pointed to by addr    
    //!  @return  	On success, zero is returned. On error, -1 is returned
    //!
    //!  @brief  initiate a connection on a socket 
    //!          Function connects the socket referred to by the socket descriptor 
    //!          sd, to the address specified by addr. The addrlen argument 
    //!          specifies the size of addr. The format of the address in addr is 
    //!          determined by the address space of the socket. If it is of type 
    //!          SOCK_DGRAM, this call specifies the peer with which the socket is 
    //!          to be associated; this address is that to which datagrams are to be
    //!          sent, and the only address from which datagrams are to be received.  
    //!          If the socket is of type SOCK_STREAM, this call attempts to make a 
    //!          connection to another socket. The other socket is specified  by 
    //!          address, which is an address in the communications space of the
    //!          socket. Note that the function implements only blocking behavior 
    //!          thus the caller will be waiting either for the connection 
    //!          establishment or for the connection establishment failure.
    //!
    //!  @sa socket
    //
    //*****************************************************************************
    extern INT32 CC3000_EXPORT(connect)(INT32 sd, const sockaddr *addr, INT32 addrlen);
    
    //*****************************************************************************
    //
    //! select
    //!
    //!  @param[in]   nfds       the highest-numbered file descriptor in any of the
    //!                           three sets, plus 1.     
    //!  @param[out]   writesds   socket descriptors list for write monitoring
    //!  @param[out]   readsds    socket descriptors list for read monitoring  
    //!  @param[out]   exceptsds  socket descriptors list for exception monitoring
    //!  @param[in]   timeout     is an upper bound on the amount of time elapsed
    //!                           before select() returns. Null means infinity 
    //!                           timeout. The minimum timeout is 5 milliseconds,
    //!                          less than 5 milliseconds will be set
    //!                           automatically to 5 milliseconds.
    //!  @return  	On success, select() returns the number of file descriptors
    //!             contained in the three returned descriptor sets (that is, the
    //!             total number of bits that are set in readfds, writefds,
    //!             exceptfds) which may be zero if the timeout expires before
    //!             anything interesting  happens.
    //!             On error, -1 is returned.
    //!                   *readsds - return the sockets on which Read request will
    //!                              return without delay with valid data.
    //!                   *writesds - return the sockets on which Write request 
    //!                                 will return without delay.
    //!                   *exceptsds - return the sockets which closed recently.
    //!
    //!  @brief  Monitor socket activity  
    //!          Select allow a program to monitor multiple file descriptors,
    //!          waiting until one or more of the file descriptors become 
    //!         "ready" for some class of I/O operation 
    //!
    //!  @Note   If the timeout value set to less than 5ms it will automatically set
    //!          to 5ms to prevent overload of the system
    //!
    //!  @sa socket
    //
    //*****************************************************************************
    extern INT16 CC3000_EXPORT(select)(INT32 nfds, fd_set *readsds, fd_set *writesds,
                      fd_set *exceptsds, struct cc3000_timeval *timeout);
    
    //*****************************************************************************
    //
    //! setsockopt
    //!
    //!  @param[in]   sd          socket handle
    //!  @param[in]   level       defines the protocol level for this option
    //!  @param[in]   optname     defines the option name to Interrogate
    //!  @param[in]   optval      specifies a value for the option
    //!  @param[in]   optlen      specifies the length of the option value
    //!  @return  	On success, zero is returned. On error, -1 is returned
    //!
    //!  @brief  set socket options
    //!          This function manipulate the options associated with a socket.
    //!          Options may exist at multiple protocol levels; they are always
    //!          present at the uppermost socket level.
    //!          When manipulating socket options the level at which the option 
    //!          resides and the name of the option must be specified.  
    //!          To manipulate options at the socket level, level is specified as 
    //!          SOL_SOCKET. To manipulate options at any other level the protocol 
    //!          number of the appropriate protocol controlling the option is 
    //!          supplied. For example, to indicate that an option is to be 
    //!          interpreted by the TCP protocol, level should be set to the 
    //!          protocol number of TCP; 
    //!          The parameters optval and optlen are used to access optval - 
    //!          use for setsockopt(). For getsockopt() they identify a buffer
    //!          in which the value for the requested option(s) are to 
    //!          be returned. For getsockopt(), optlen is a value-result 
    //!          parameter, initially containing the size of the buffer 
    //!          pointed to by option_value, and modified on return to 
    //!          indicate the actual size of the value returned. If no option 
    //!          value is to be supplied or returned, option_value may be NULL.
    //!
    //!  @Note   On this version the following two socket options are enabled:
    //!    			 The only protocol level supported in this version
    //!          is SOL_SOCKET (level).
    //!		       1. SOCKOPT_RECV_TIMEOUT (optname)
    //!			      SOCKOPT_RECV_TIMEOUT configures recv and recvfrom timeout 
    //!           in milliseconds.
    //!		        In that case optval should be pointer to UINT32.
    //!		       2. SOCKOPT_NONBLOCK (optname). sets the socket non-blocking mode on 
    //!           or off.
    //!		        In that case optval should be SOCK_ON or SOCK_OFF (optval).
    //!
    //!  @sa getsockopt
    //
    //*****************************************************************************
    #ifndef CC3000_TINY_DRIVER 
    extern INT16 CC3000_EXPORT(setsockopt)(INT32 sd, INT32 level, INT32 optname, const void *optval,
                          socklen_t optlen);
    #endif
    //*****************************************************************************
    //
    //! getsockopt
    //!
    //!  @param[in]   sd          socket handle
    //!  @param[in]   level       defines the protocol level for this option
    //!  @param[in]   optname     defines the option name to Interrogate
    //!  @param[out]   optval      specifies a value for the option
    //!  @param[out]   optlen      specifies the length of the option value
    //!  @return  	On success, zero is returned. On error, -1 is returned
    //!
    //!  @brief  set socket options
    //!          This function manipulate the options associated with a socket.
    //!          Options may exist at multiple protocol levels; they are always
    //!          present at the uppermost socket level.
    //!          When manipulating socket options the level at which the option 
    //!          resides and the name of the option must be specified.  
    //!          To manipulate options at the socket level, level is specified as 
    //!          SOL_SOCKET. To manipulate options at any other level the protocol 
    //!          number of the appropriate protocol controlling the option is 
    //!          supplied. For example, to indicate that an option is to be 
    //!          interpreted by the TCP protocol, level should be set to the 
    //!          protocol number of TCP; 
    //!          The parameters optval and optlen are used to access optval - 
    //!          use for setsockopt(). For getsockopt() they identify a buffer
    //!          in which the value for the requested option(s) are to 
    //!          be returned. For getsockopt(), optlen is a value-result 
    //!          parameter, initially containing the size of the buffer 
    //!          pointed to by option_value, and modified on return to 
    //!          indicate the actual size of the value returned. If no option 
    //!          value is to be supplied or returned, option_value may be NULL.
    //!
    //!  @Note   On this version the following two socket options are enabled:
    //!    			 The only protocol level supported in this version
    //!          is SOL_SOCKET (level).
    //!		       1. SOCKOPT_RECV_TIMEOUT (optname)
    //!			      SOCKOPT_RECV_TIMEOUT configures recv and recvfrom timeout 
    //!           in milliseconds.
    //!		        In that case optval should be pointer to UINT32.
    //!		       2. SOCKOPT_NONBLOCK (optname). sets the socket non-blocking mode on 
    //!           or off.
    //!		        In that case optval should be SOCK_ON or SOCK_OFF (optval).
    //!
    //!  @sa setsockopt
    //
    //*****************************************************************************
    extern INT16 CC3000_EXPORT(getsockopt)(INT32 sd, INT32 level, INT32 optname, void *optval,
                          socklen_t *optlen);
    
    //*****************************************************************************
    //
    //!  recv
    //!
    //!  @param[in]  sd     socket handle
    //!  @param[out] buf    Points to the buffer where the message should be stored
    //!  @param[in]  len    Specifies the length in bytes of the buffer pointed to 
    //!                     by the buffer argument.
    //!  @param[in] flags   Specifies the type of message reception. 
    //!                     On this version, this parameter is not supported.
    //!
    //!  @return         Return the number of bytes received, or -1 if an error
    //!                  occurred
    //!
    //!  @brief          function receives a message from a connection-mode socket
    //!
    //!  @sa recvfrom
    //!
    //!  @Note On this version, only blocking mode is supported.
    //
    //*****************************************************************************
    extern INT16 CC3000_EXPORT(recv)(INT32 sd, void *buf, INT32 len, INT32 flags);
    
    //*****************************************************************************
    //
    //!  recvfrom
    //!
    //!  @param[in]  sd     socket handle
    //!  @param[out] buf    Points to the buffer where the message should be stored
    //!  @param[in]  len    Specifies the length in bytes of the buffer pointed to 
    //!                     by the buffer argument.
    //!  @param[in] flags   Specifies the type of message reception. 
    //!                     On this version, this parameter is not supported.
    //!  @param[in] from   pointer to an address structure indicating the source
    //!                    address: sockaddr. On this version only AF_INET is
    //!                    supported.
    //!  @param[in] fromlen   source address structure size
    //!
    //!  @return         Return the number of bytes received, or -1 if an error
    //!                  occurred
    //!
    //!  @brief         read data from socket
    //!                 function receives a message from a connection-mode or
    //!                 connectionless-mode socket. Note that raw sockets are not
    //!                 supported.
    //!
    //!  @sa recv
    //!
    //!  @Note On this version, only blocking mode is supported.
    //
    //*****************************************************************************
    extern INT16 CC3000_EXPORT(recvfrom)(INT32 sd, void *buf, INT32 len, INT32 flags, sockaddr *from, 
                        socklen_t *fromlen);
    
    //*****************************************************************************
    //
    //!  send
    //!
    //!  @param sd       socket handle
    //!  @param buf      Points to a buffer containing the message to be sent
    //!  @param len      message size in bytes
    //!  @param flags    On this version, this parameter is not supported
    //!
    //!  @return         Return the number of bytes transmitted, or -1 if an
    //!                  error occurred
    //!
    //!  @brief          Write data to TCP socket
    //!                  This function is used to transmit a message to another 
    //!                  socket.
    //!
    //!  @Note           On this version, only blocking mode is supported.
    //!
    //!  @sa             sendto
    //
    //*****************************************************************************
    
    extern INT16 CC3000_EXPORT(send)(INT32 sd, const void *buf, INT32 len, INT32 flags);
    
    //*****************************************************************************
    //
    //!  sendto
    //!
    //!  @param sd       socket handle
    //!  @param buf      Points to a buffer containing the message to be sent
    //!  @param len      message size in bytes
    //!  @param flags    On this version, this parameter is not supported
    //!  @param to       pointer to an address structure indicating the destination
    //!                  address: sockaddr. On this version only AF_INET is
    //!                  supported.
    //!  @param tolen    destination address structure size
    //!
    //!  @return         Return the number of bytes transmitted, or -1 if an
    //!                  error occurred
    //!
    //!  @brief          Write data to TCP socket
    //!                  This function is used to transmit a message to another 
    //!                  socket.
    //!
    //!  @Note           On this version, only blocking mode is supported.
    //!
    //!  @sa             send
    //
    //*****************************************************************************
    
    extern INT16 CC3000_EXPORT(sendto)(INT32 sd, const void *buf, INT32 len, INT32 flags, 
                      const sockaddr *to, socklen_t tolen);
    
    //*****************************************************************************
    //
    //!  mdnsAdvertiser
    //!
    //!  @param[in] mdnsEnabled         flag to enable/disable the mDNS feature
    //!  @param[in] deviceServiceName   Service name as part of the published
    //!                                 canonical domain name
    //!  @param[in] deviceServiceNameLength   Length of the service name - up to 32 chars
    //!  
    //!
    //!  @return   On success, zero is returned, return SOC_ERROR if socket was not 
    //!            opened successfully, or if an error occurred.
    //!
    //!  @brief    Set CC3000 in mDNS advertiser mode in order to advertise itself.
    //
    //*****************************************************************************
    extern INT16 CC3000_EXPORT(mdnsAdvertiser)(UINT16 mdnsEnabled, CHAR * deviceServiceName, UINT16 deviceServiceNameLength);
    
    
    //*****************************************************************************
    //
    //!  getmssvalue
    //!
    //!  @param[in] sd         socket descriptor
    //!
    //!  @return   On success, returns the MSS value of a TCP connection
    //!
    //!  @brief    Returns the MSS value of a TCP connection according to the socket descriptor
    //
    //*****************************************************************************
    extern UINT16 CC3000_EXPORT(getmssvalue) (INT32 sd);
    
    //*****************************************************************************
    //
    // Close the Doxygen group.
    //! @}
    //
    //*****************************************************************************
    
    
    //*****************************************************************************
    //
    // Mark the end of the C bindings section for C++ compilers.
    //
    //*****************************************************************************
    #ifdef  __cplusplus
    }
    #endif // __cplusplus
    
    #endif // __SOCKET_H__