NetSock_TxData
Copy bytes from an application memory buffer into a socket to send to a remote socket.
Files
net_sock.h/net_sock.c
net_bsd.h/net_bsd.c
Prototypes
NET_SOCK_RTN_CODE NetSock_TxData (NET_SOCK_ID sock_id,
void *p_data,
CPU_INT16U data_len,
CPU_INT16S flags,
NET_ERR *p_err);
NET_SOCK_RTN_CODE NetSock_TxDataTo(NET_SOCK_ID sock_id,
void *p_data,
CPU_INT16U data_len,
CPU_INT16S flags,
NET_SOCK_ADDR *p_addr_remote,
NET_SOCK_ADDR_LEN addr_len,
NET_ERR *p_err);
ssize_t send (int sock_id,
void *p_data,
_size_t data_len,
int flags);
ssize_t sendto ( int sock_id,
void *p_data,
_size_t data_len,
int flags,
struct sockaddr *p_addr_remote,
socklen_t addr_len);
Arguments
sock_id
This is the socket ID returned by NetSock_Open()/socket() when the socket was created or by NetSock_Accept()/accept() when a connection was accepted.
p_data
Pointer to the application data memory buffer to send.
data_len
Size of the application data memory buffer (in bytes).
flags
Flag to select transmit options; bit-field flags logically OR’d:
NET_SOCK_FLAG_NONE/0
NET_SOCK_FLAG_TX_NO_BLOCK/
No socket flags selected
MSG_DONTWAIT
Send socket data without blocking
In most cases, this flag would be set to NET_SOCK_FLAG_NONE/0.
p_addr_remote
Pointer to a socket address structure (see section Network Sockets Concepts) which contains the remote socket address to send data to.
addr_len
Size of the socket address structure which must be passed the size of the socket address structure [e.g., sizeof(NET_SOCK_ADDR_IPv4)].
p_err
Pointer to variable that will receive the return error code from this function:
NET_SOCK_ERR_NONENET_ERR_FAULT_NULL_PTRNET_SOCK_ERR_NOT_USEDNET_SOCK_ERR_CLOSEDNET_SOCK_ERR_INVALID_SOCKNET_SOCK_ERR_INVALID_FAMILYNET_SOCK_ERR_INVALID_PROTOCOLNET_SOCK_ERR_INVALID_TYPENET_SOCK_ERR_INVALID_STATENET_SOCK_ERR_INVALID_OPNET_SOCK_ERR_INVALID_FLAGNET_SOCK_ERR_INVALID_DATA_SIZENET_SOCK_ERR_INVALID_CONNNET_SOCK_ERR_INVALID_ADDRNET_SOCK_ERR_INVALID_ADDR_LENNET_SOCK_ERR_INVALID_PORT_NBRNET_SOCK_ERR_ADDR_IN_USENET_SOCK_ERR_PORT_NBR_NONE_AVAILNET_SOCK_ERR_CONN_FAILNET_SOCK_ERR_FAULTNET_ERR_TXNET_IF_ERR_INVALID_IFNET_IP_ERR_ADDR_NONE_AVAILNET_IP_ERR_ADDR_CFG_IN_PROGRESSNET_CONN_ERR_NOT_USEDNET_CONN_ERR_INVALID_CONNNET_CONN_ERR_INVALID_FAMILYNET_CONN_ERR_INVALID_TYPENET_CONN_ERR_INVALID_PROTOCOL_IXNET_CONN_ERR_INVALID_ADDR_LENNET_CONN_ERR_ADDR_IN_USENET_INIT_ERR_NOT_COMPLETEDNET_ERR_FAULT_LOCK_ACQUIRE
Returned Value
Positive number of bytes (queued to be) sent, if successful;
NET_SOCK_BSD_RTN_CODE_CONN_CLOSED/0, if the socket is closed;
NET_SOCK_BSD_ERR_TX/-1, otherwise.
Note that a positive return value does not mean that the message was successfully delivered to the remote socket, just that it was sent or queued for sending.
Blocking vs Non-Blocking
The default setting for µC/TCP-IP is blocking. However, this setting can be changed at compile time by setting the NET_SOCK_DFLT_NO_BLOCK_EN to DEF_ENABLED or DEF_DISABLED. (see net_cfg.h file).
DEF_DISABLED sets the blocking mode to blocking. This means that a socket receive function will wait forever, until at least one byte of data is available to return or the socket connection is closed, unless a timeout is specified by NetSock_CfgTimeoutRxQ_Set() [See function NetSock_CfgTimeoutRxQ_Set()].
DEF_ENABLED sets the blocking mode to non-blocking. This means that a socket receive function will not wait but immediately return either any available data, socket connection closed, or an error indicating no available data or other possible socket faults. Your application will have to “poll” the socket on a regular basis to receive data.
The current version of µC/TCP-IP selects blocking or non-blocking at compile time for all sockets. A future version may allow the selection of blocking or non-blocking at the individual socket level. However, each socket receive call can pass the NET_SOCK_FLAG_RX_NO_BLOCK/MSG_DONTWAIT flag to disable blocking on that call.
Required Configuration
None.
Notes / Warnings
TCP sockets typically use NetSock_TxData()/send(), whereas UDP sockets typically use NetSock_TxDataTo()/sendto().
For datagram sockets (i.e., UDP), each receive returns the data from exactly one send but datagram order and delivery is not guaranteed. Also, if the receive memory buffer is not large enough to receive an entire datagram, the datagram’s data is truncated to the size of the memory buffer and the remaining data is discarded.
For datagram sockets (i.e., UDP), all data is sent atomically – i.e., each call to send data must be sent in a single, complete datagram. Since µC/TCP-IP does not currently support IP transmit fragmentation, if a datagram socket attempts to send data greater than a single datagram, then the socket send is aborted and no socket data is sent.
Only some transmit flag options are implemented. If other flag options are requested, an error is returned so that flag options are not silently ignored.