luatos-soc-air101/include/net/wm_socket2.0.3.h

/**
 * @file    wm_socket2.0.3.h
 *
 * @brief   socket203 Module
 *
 * @author  dave
 *
 * @copyright (c) 2014 Winner Microelectronics Co., Ltd.
 */
#ifndef WM_SOCKET2_0_3_H
#define WM_SOCKET2_0_3_H

#include "wm_type_def.h"
#include "wm_netif.h"

//socket state defination
#define NETCONN_STATE_NONE         0
#define NETCONN_STATE_WAITING      1
#define NETCONN_STATE_CONNECTED    2
#define NETCONN_STATE_CLOSED       3

//socket event defination
#define NET_EVENT_TCP_JOINED            0
#define NET_EVENT_TCP_DISCONNECT        1
#define NET_EVENT_TCP_CONNECTED         2
#define NET_EVENT_TCP_CONNECT_FAILED    3
#define NET_EVENT_UDP_START             4
#define NET_EVENT_UDP_START_FAILED      5

#define TLS_MAX_SOCKET_NUM       4
#define TLS_MAX_NETCONN_NUM      20

/** Main packet buffer struct */
struct pbuf {
  /** next pbuf in singly linked pbuf chain */
  struct pbuf *next;

  /** pointer to the actual data in the buffer */
  void *payload;

  /**
   * total length of this buffer and all next buffers in chain
   * belonging to the same packet.
   *
   * For non-queue packet chains this is the invariant:
   * p->tot_len == p->len + (p->next? p->next->tot_len: 0)
   */
  u16_t tot_len;

  /** length of this buffer */
  u16_t len;

  /** pbuf_type as u8_t instead of enum to save space */
  u8_t /*pbuf_type*/ type;

  /** misc flags */
  u8_t flags;

  /**
   * the reference count always equals the number of pointers
   * that refer to this pbuf. This can be pointers from an application,
   * the stack itself, or pbuf->next pointers from a chain.
   */
  u16_t ref;
};

/**
* @brief This Function prototype for tcp error callback functions. Called when 
*                    receives a RST or is unexpectedly closed for any other reason.
*                   The corresponding socket is already freed when this callback is called!
*
* @param[in] skt_num    Is the socket number that returned by tls_socket_create function.
*
* @param[in]  err           Error code to indicate why the socket has been closed
*                        ERR_ABRT: aborted through returning ERR_ABRT from within others
*                                                      callback functions
*                        ERR_RST: the connection was reset by the remote host
*/
typedef void  (*socket_err_fn)(u8 skt_num, err_t err);

/**
* @brief This Function prototype for socket receive callback functions. Called when data has
*                    been received.
*
* @param[in] skt_num   Is the socket number that returned by tls_socket_create function.
*
* @param[in] p         The received data (or NULL when the connection has been closed!)
*
* @param[in] err       An error code if there has been an error receiving, always be ERR_OK 
*                                    when cs mode is udp.
*
* @retval 			The return value is only valid for tcp receive, for upd it means nothing.
*                   ERR_OK: Return this value after handling the received data.
*                   ERR_ABRT:  Only return ERR_ABRT if you want to abort the socket from within the
*                                      callback function!
*/
typedef err_t  (*socket_recv_fn)(u8 skt_num, struct pbuf *p, err_t err);

/** 
* @brief This Function prototype for socket srce ip callback functions. Called when data has
*                    been received.
*
* @param[in] skt_num   Is the socket number that returned by tls_socket_create function.
*
* @param[in] datalen           The received data length
*
* @param[in] ipsrc         source ip addr
*
* @param[in] port          source port
*
* @param[in] err           An error code if there has been an error receiving, always be ERR_OK 
*                                    when cs mode is udp.
*
* @retval			The return value is only valid for UDP receive, for udp it means nothing.
*                   ERR_OK: Return this value after handling the received data.
*                   ERR_ABRT:  Only return ERR_ABRT if you want to abort the socket from within the
*                                      callback function!
*/
typedef err_t  (*socket_recv_ip_rpt_fn)(u8 skt_num, u16 datalen, u8 *ipsrc, u16 port, err_t err);

/**
* @brief This Function prototype for tcp connected callback functions. Called when 
*                   connected to the remote side.
*
* @param[in] skt_num   Is the socket number that returned by tls_socket_create function.
*
* @param[in] err       An unused error code, always ERR_OK currently.
*
* @retval  ERR_OK: Return this value after handling your logic.
* @retval  ERR_ABRT:  Only return ERR_ABRT if you want to abort the socket from within the
*                                      callback function!
*/
typedef err_t (*socket_connected_fn)(u8 skt_num,  err_t err);

/**
* @brief This Function prototype for tcp poll callback functions. Called periodically.
*
* @param[in] skt_num   Is the socket number that returned by tls_socket_create function.
*
* @retval  ERR_OK:     Try to do something periodically.
* @retval  ERR_ABRT:  Only return ERR_ABRT if you want to abort the socket from within the
*                                      callback function!
*/
typedef err_t (*socket_poll_fn)(u8 skt_num);

/**
* @brief This Function prototype for tcp accept callback functions. Called when a new
*                   connection can be accepted on a listening tcp.
*
* @param[in] skt_num   Is the socket number that returned by tls_socket_create function.
*
* @param[in] err       An error code if there has been an error accepting.
*
* @retval  ERR_OK:      Return this value after handling your logic.
* @retval  ERR_ABRT:  Only return ERR_ABRT if you want to abort the socket from within the
*                                      callback function!
*/
typedef err_t (*socket_accept_fn)(u8 skt_num, err_t err);

/**
* @brief This Function prototype for socket state changed callback functions. Called when socket
*                   the sockte's state changed.
*
* @param[in] skt_num   Is the socket number that returned by tls_socket_create function.
*
* @param[in] event     Is the event number, see socket event defination.
*
* @param[in] state     Is the socket state, see socket state defination.
*/
typedef void(*socket_state_changed_fn)(u8 skt_num, u8 event, u8 state);

/** Definitions for error constants. */
typedef enum {
/** No error, everything OK. */
  ERR_OK         = 0,
/** Out of memory error.     */
  ERR_MEM        = -1,
/** Buffer error.            */
  ERR_BUF        = -2,
/** Timeout.                 */
  ERR_TIMEOUT    = -3,
/** Routing problem.         */
  ERR_RTE        = -4,
/** Operation in progress    */
  ERR_INPROGRESS = -5,
/** Illegal value.           */
  ERR_VAL        = -6,
/** Operation would block.   */
  ERR_WOULDBLOCK = -7,
/** Address in use.          */
  ERR_USE        = -8,
/** Already connecting.      */
  ERR_ALREADY    = -9,
/** Conn already established.*/
  ERR_ISCONN     = -10,
/** Not connected.           */
  ERR_CONN       = -11,
/** Low-level netif error    */
  ERR_IF         = -12,

/** Connection aborted.      */
  ERR_ABRT       = -13,
/** Connection reset.        */
  ERR_RST        = -14,
/** Connection closed.       */
  ERR_CLSD       = -15,
/** Illegal argument.        */
  ERR_ARG        = -16
} err_enum_t;

enum tls_socket_protocol{
    SOCKET_PROTO_TCP,      /* TCP Protocol    */
    SOCKET_PROTO_UDP,     /* UDP Protocol   */
};

enum tls_socket_cs_mode{
    SOCKET_CS_MODE_CLIENT,    /* Client mode    */
    SOCKET_CS_MODE_SERVER,    /* Server mode   */
};

struct tls_socket_desc {
    enum tls_socket_cs_mode cs_mode;              /* Server mode  or Client mode, Only for tcp protocol is valid */
    enum tls_socket_protocol protocol;                /* TCP Protocol or UDP Protocol  */
    ip_addr_t  ip_addr;                                              /* Remote ip address, for tcp client mode is remote server's ip address; for tcp server mode can be any address. */
	                                                                    /*          for udp is remote server's ip address */
    u16 port;                                                       /* port, for tcp client mode is remote server's port; for tcp server mode is local listen port . 
	                                                                              for udp is remote server's port */
    u16 localport;                                               /* local port, for udp and tcp client is local listen port, for tcp server means nothing, tcp server always listen at port */
    char host_name[32];                                     /* remote host name, not support for now  */
    u8  host_len;                                                 /* the length of host name   */
    u32 timeout;                                                  /* poll timeout, not implemented for now   */
    socket_err_fn errf;                                          /* a pointer to socket_err_fn   */
    socket_recv_fn recvf;                                      /* a pointer to socket_recv_fn  */
    socket_connected_fn connf;                             /* a pointer to socket_connected_fn  */
    socket_poll_fn pollf;                                        /* a pointer to socket_poll_fn  */
    socket_accept_fn acceptf;                               /* a pointer to socket_accept_fn   */
    socket_state_changed_fn state_changed;       /* a pointer to socket_state_changed_fn   */
    socket_recv_ip_rpt_fn recvwithipf;           /*recv skt info report*/
};

/**
* @brief This function is called by your application code to create a socket.
*
* @param[in] skd      Is a pointer to an tls_socket_desc.
*
* @retval	 ERR_OK    If create socket successfully.
*              negative number   If an error was detected.
*/
int tls_socket_create(struct tls_socket_desc * skd);

/**
* @brief This function is called by your application code to send data by the socket.
*
* @param[in] skt_num      Is the socket number that returned by tls_socket_create function.
*
* @param[in] pdata          Is a pointer to the data which need to be send by the socket.
*
* @param[in] len              The data's length.
*
* @retval	 ERR_OK    If send data successfully.
*              negative number   If an error was detected.
*/
int tls_socket_send(u8 skt_num, void *pdata, u16 len);

/**
* @brief This function is called by your application code to close the socket, and the related resources would be released.
*
* @param[in] skt_num      Is the socket number that returned by tls_socket_create function.
*
* @retval	 ERR_OK    If close socket successfully.
*              negative number   If an error was detected.
*/
int tls_socket_close(u8 skt_num);

struct tls_skt_status_ext_t {
    u8 socket;
    u8 status;
    enum tls_socket_protocol protocol;
    u8 host_ipaddr[4];
    u16 remote_port;
    u16 local_port;
};

struct tls_skt_status_t {
    u32 socket_cnt;
    struct tls_skt_status_ext_t skts_ext[1];
};
/**
* @brief This function is called by your application code to get the socket status of specified socket num.
*
* @param[in] skt_num      Is the socket number that returned by tls_socket_create function.
*
* @param[in] buf          Is a pointer to the data contains the socket status, if the socket is server, also contains it's client's status.
*
* @param[in] len          The buf's length. At least, the len should be bigger than sizeof(struct tls_skt_status_t).
*
* @retval	 	ERR_OK    If send data successfully.
*              negative number   If an error was detected.
*/
int tls_socket_get_status(u8 skt_num, u8 *buf, u32 bufsize);

/**
* @brief This function is called by your application code to send data by udp socket.
*
* @param[in] localport         This function will search all created sockets, if there is a socket whose localport equals this value and it's protocol is udp,
*                                          then send the data by this socket, otherwise, nothing to send.
*
* @param[in] ip_addr          Is the remote ip address.
*
* @param[in] port               Is the remote port which upd send to.
*
* @param[in] pdata             Is a pointer to the data which need to be send by the socket.
*
* @param[in] len              The data's length.
* @retval	 	ERR_OK    If send data successfully.
*              negative number   If an error was detected.
*/
int tls_socket_udp_sendto(u16 localport, u8  *ip_addr, u16 port, void *pdata, u16 len);

/**
 * @ingroup pbuf
 * Enumeration of pbuf layers
 */
typedef enum {
  /** Includes spare room for transport layer header, e.g. UDP header.
   * Use this if you intend to pass the pbuf to functions like udp_send().
   */
  PBUF_TRANSPORT,
  /** Includes spare room for IP header.
   * Use this if you intend to pass the pbuf to functions like raw_send().
   */
  PBUF_IP,
  /** Includes spare room for link layer header (ethernet header).
   * Use this if you intend to pass the pbuf to functions like ethernet_output().
   * @see PBUF_LINK_HLEN
   */
  PBUF_LINK,
  /** Includes spare room for additional encapsulation header before ethernet
   * headers (e.g. 802.11).
   * Use this if you intend to pass the pbuf to functions like netif->linkoutput().
   * @see PBUF_LINK_ENCAPSULATION_HLEN
   */
  PBUF_RAW_TX,
  /** Use this for input packets in a netif driver when calling netif->input()
   * in the most common case - ethernet-layer netif driver. */
  PBUF_RAW
} pbuf_layer;

/**
 * @ingroup pbuf
 * Enumeration of pbuf types
 */
typedef enum {
  /** pbuf data is stored in RAM, used for TX mostly, struct pbuf and its payload
      are allocated in one piece of contiguous memory (so the first payload byte
      can be calculated from struct pbuf).
      pbuf_alloc() allocates PBUF_RAM pbufs as unchained pbufs (although that might
      change in future versions).
      This should be used for all OUTGOING packets (TX).*/
  PBUF_RAM,
  /** pbuf data is stored in ROM, i.e. struct pbuf and its payload are located in
      totally different memory areas. Since it points to ROM, payload does not
      have to be copied when queued for transmission. */
  PBUF_ROM,
  /** pbuf comes from the pbuf pool. Much like PBUF_ROM but payload might change
      so it has to be duplicated when queued before transmitting, depending on
      who has a 'ref' to it. */
  PBUF_REF,
  /** pbuf payload refers to RAM. This one comes from a pool and should be used
      for RX. Payload can be chained (scatter-gather RX) but like PBUF_RAM, struct
      pbuf and its payload are allocated in one piece of contiguous memory (so
      the first payload byte can be calculated from struct pbuf).
      Don't use this for TX, if the pool becomes empty e.g. because of TCP queuing,
      you are unable to receive TCP acks! */
  PBUF_POOL
} pbuf_type;

/**
* @brief This Function allocates a pbuf of the given type (possibly a chain for PBUF_POOL type).
*
*                   The actual memory allocated for the pbuf is determined by the
*                   layer at which the pbuf is allocated and the requested size
*                   (from the size parameter).
*
* @param[in] l                   layer flag to define header size
* @param[in] length           size of the pbuf's payload
* @param[in] type             this parameter decides how and where the pbuf
*
* @retval  The allocated pbuf. If multiple pbufs where allocated, this
*                     is the first pbuf of a pbuf chain.
*/
struct pbuf *pbuf_alloc(pbuf_layer l, u16_t length, pbuf_type type);

/**
* @brief This Function for release the buffer that you receive within the socket_recv_fn callback function.
*                   Attention please: If you return ERR_OK in the socket_recv_fn callback function, you must call this
*                                            function to release the buffer by yourself. Otherwise, the buffer do not need be 
*                                            released by your code.
*
* @param[in] p       The buffer you received in the socket_recv_fn callback function.
*
* @retval  The number of de-allocated pbufs
*/
u8 pbuf_free(struct pbuf *p);

/**
* @brief This Function for copy (part of) the contents of a packet buffer to an application supplied buffer.
*
* @param[in] p     the pbuf from which to copy data.
*
* @param[in] dataptr   the application supplied buffer
*
* @param[in] len      length of data to copy (dataptr must be big enough). No more 
*                                than buf->tot_len will be copied, irrespective of len
*
* @param[in] offset   offset into the packet buffer from where to begin copying len bytes
*
* @retval  The number of bytes copied, or 0 on failure
*/
u16_t pbuf_copy_partial(const struct pbuf *p, void *dataptr, u16_t len, u16_t offset);
#endif