// buffer can stay in RAM of Flash
// ret -1 = error, ret 0 = disconnected
int32_t MTD_FLASHMEM Socket::write(void const *buffer, uint32_t length) {
static uint32_t const MAXCHUNKSIZE = 128;
if (!checkConnection())
return -1;
int32_t bytesSent = 0;
// send in chunks of up to MAXCHUNKSIZE bytes
uint8_t rambuf[min(length, MAXCHUNKSIZE)];
uint8_t const *src = (uint8_t const *)buffer;
while (bytesSent < length) {
uint32_t bytesToSend = min(MAXCHUNKSIZE, length - bytesSent);
f_memcpy(rambuf, src, bytesToSend);
int32_t chunkBytesSent =
m_remoteAddress.sin_len == 0
? lwip_send(m_socket, rambuf, bytesToSend, MSG_DONTWAIT)
: lwip_sendto(m_socket, rambuf, bytesToSend, 0, (sockaddr *)&m_remoteAddress, sizeof(m_remoteAddress));
int32_t lasterr = getLastError();
if (lasterr == EAGAIN || lasterr == EWOULDBLOCK) {
chunkBytesSent = 0;
} else if (chunkBytesSent <= 0 || lasterr != 0) {
// error
bytesSent = -1;
break;
}
bytesSent += chunkBytesSent;
src += chunkBytesSent;
}
if (length > 0)
m_connected = (bytesSent > 0);
return bytesSent;
}
//--------------------------------------------------------------
int ntpbserverEndReply(void)
{
int rcvSize, sndSize, recv_size, sent_size, ntpbpktSize, packetSize;
// Waiting io semaphore
WaitSema(ntpbserver_io_sema);
// Build up ntpb packet
memcpy(&ntpb_buf[0], ntpb_hdrmagic, ntpb_MagicSize); //copying NTPB Magic
*((u16 *)&ntpb_buf[ntpb_MagicSize]) = 0;
*((u16 *)&ntpb_buf[ntpb_MagicSize+2]) = 0xffff;
packetSize = ntpb_hdrSize;
// Send ntpb packet to client
sent_size = 0;
// fragmented packet handling
while (sent_size < packetSize) {
sndSize = lwip_send(client_socket, &ntpb_buf[sent_size], packetSize - sent_size, 0);
if (sndSize < 0)
return -1;
sent_size += sndSize;
}
// receive the response packet from client
rcvSize = recv_noblock(client_socket, &ntpb_buf[0], sizeof(ntpb_buf));
if (rcvSize <= 0)
return -1;
ntpbpktSize = *((u16 *)&ntpb_buf[ntpb_MagicSize]);
packetSize = ntpbpktSize + ntpb_hdrSize;
recv_size = rcvSize;
// fragmented packet handling
while (recv_size < packetSize) {
rcvSize = recv_noblock(client_socket, &ntpb_buf[recv_size], sizeof(ntpb_buf) - recv_size);
if (rcvSize <= 0)
return -1;
recv_size += rcvSize;
}
// parses packet
if (!check_ntpb_header(ntpb_buf))
return -2;
// check client reply
if (*((u16 *)&ntpb_buf[ntpb_hdrSize]) != 1)
return -2;
// Posting semaphore for server Thread so it's able to wait for requests again
SignalSema(ntpbserver_cmd_sema);
// posting io semaphore
SignalSema(ntpbserver_io_sema);
return 0;
}
ssize_t zts_send(int fd, const void *buf, size_t len, int flags)
{
if (!buf || len <= 0) {
return ZTS_ERR_INVALID_ARG;
}
return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_send(fd, buf, len, flags);
}
uint16 SoAd_SendIpMessage(uint16 sockNr, uint32 msgLen, uint8* buff)
{
uint16 bytesSent;
if (SocketAdminList[sockNr].SocketProtocolIsTcp) {
printf("lwip_send: %c,%c,%d,%d,%d,%d\r\n", buff[0],buff[1], buff[2], buff[3], buff[4], buff[5]);
printf("lwip_send: %d,%d,%d,%d,%d,%d\r\n", buff[6],buff[7], buff[8], buff[9], buff[10], buff[11]);
printf("lwip_send: %d,%d,%d,%d,%d,%d\r\n", buff[12],buff[13], buff[14], buff[15], buff[16], buff[17]);
printf("lwip_send: %d,%d,%d,%d,%d,%d\r\n", buff[18],buff[19], buff[20], buff[21], buff[22], buff[23]);
printf("lwip_send: %d,%d,%d,%d,%d,%d,%d\r\n", buff[24],buff[25], buff[26], buff[27], buff[28], buff[29], buff[30]);
// printf("lwip_send: %d,%d\r\n", buff[6],buff[7]);
bytesSent = lwip_send(SocketAdminList[sockNr].ConnectionHandle, buff, msgLen, 0);
} else {
struct sockaddr_in toAddr;
socklen_t toAddrLen = sizeof(toAddr);
toAddr.sin_family = AF_INET;
toAddr.sin_len = sizeof(toAddr);
toAddr.sin_addr.s_addr = SocketAdminList[sockNr].RemoteIpAddress;
toAddr.sin_port = SocketAdminList[sockNr].RemotePort;
bytesSent = lwip_sendto(SocketAdminList[sockNr].SocketHandle, buff, msgLen, 0, (struct sockaddr *)&toAddr, toAddrLen);
}
return bytesSent;
}
static void SC_Send(__SYSCALL_PARAM_BLOCK* pspb)
{
pspb->lpRetValue = (LPVOID)lwip_send(
(INT)PARAM(0),
(const void*)PARAM(1),
(size_t)PARAM(2),
(INT)PARAM(3)
);
}
int32_t OsNetworkSend(THandle aHandle, const uint8_t* aBuffer, uint32_t aBytes)
{
if ( OsNetworkHandle_IsInterrupted(aHandle) )
return -1;
LOGFUNCIN();
int bytes = lwip_send ( HANDLE_TO_SOCKET(aHandle), (const void *) aBuffer, (size_t) aBytes, 0);
LOGFUNCOUT();
return bytes;
}
// buffer can stay in RAM of Flash
// ret -1 = error, ret 0 = disconnected
int32_t MTD_FLASHMEM Socket::write(void const* buffer, uint32_t length)
{
static uint32_t const MAXCHUNKSIZE = 128;
int32_t bytesSent = 0;
if (isStoredInFlash(buffer))
{
// copy from Flash, send in chunks of up to MAXCHUNKSIZE bytes
uint8_t rambuf[min(length, MAXCHUNKSIZE)];
uint8_t const* src = (uint8_t const*)buffer;
while (bytesSent < length)
{
uint32_t bytesToSend = min(MAXCHUNKSIZE, length - bytesSent);
f_memcpy(rambuf, src, bytesToSend);
uint32_t chunkBytesSent = m_remoteAddress.sin_len == 0? lwip_send(m_socket, rambuf, bytesToSend, 0) :
lwip_sendto(m_socket, rambuf, bytesToSend, 0, (sockaddr*)&m_remoteAddress, sizeof(m_remoteAddress));
if (chunkBytesSent == 0)
{
// error
bytesSent = 0;
break;
}
bytesSent += chunkBytesSent;
src += chunkBytesSent;
}
}
else
{
// just send as is
bytesSent = m_remoteAddress.sin_len == 0? lwip_send(m_socket, buffer, length, 0) :
lwip_sendto(m_socket, buffer, length, 0, (sockaddr*)&m_remoteAddress, sizeof(m_remoteAddress));
}
if (length > 0)
m_connected = (bytesSent > 0);
return bytesSent;
}
/*
* 写 socket
*/
static ssize_t socket_write(void *ctx, file_t *file, const void *buf, size_t len)
{
privinfo_t *priv = ctx;
if (priv == NULL) {
seterrno(EINVAL);
return -1;
}
if (atomic_read(&priv->select.flags) & VFS_FILE_ERROR) {
seterrno(EIO);
return -1;
}
return lwip_send(priv->sock_fd, buf, len, 0);
}
int sendto(int s, const void *data, int size, unsigned int flags,
struct sockaddr *to, socklen_t tolen)
{
struct lwip_socket *sock;
struct ip_addr remote_addr;
int err;
sock = get_socket(s);
if (!sock)
return -1;
if (sock->conn->type==NETCONN_TCP)
{
return lwip_send(s, data, size, flags);
}
return (err==ERR_OK?size:-1);
}
int socket_printf(int sock, const char* fmt, ...)
{
va_list args;
rt_uint32_t length;
rt_uint8_t *buf_ptr;
#define BUF_SZ 1024
buf_ptr = (rt_uint8_t*) rt_malloc (1024);
va_start(args, fmt);
length = vsnprintf((char*)(buf_ptr), BUF_SZ, fmt, args);
va_end(args);
lwip_send(sock, buf_ptr, length, 0);
rt_free(buf_ptr);
return length;
}
static int sendCallback(WOLFSSL* ssl, char *buf, int sz, void *ctx)
{
int fd = *(int*)ctx;
int result;
(void)ssl;
fd_set wfds;
FD_ZERO(&wfds);
FD_SET(fd, &wfds);
if (lwip_select(FD_SETSIZE, NULL, &wfds, NULL, NULL) < 0)
{
return -1;
}
else
{
result = lwip_send(fd, buf, sz, 0);
}
return result;
}
/*-----------------------------------------------------------------------------------*/
int
lwip_sendto(int s, void *data, int size, unsigned int flags,
struct sockaddr *to, socklen_t tolen)
{
struct lwip_socket *sock;
struct ip_addr remote_addr, addr;
u16_t remote_port, port;
int ret,connected;
sock = get_socket(s);
if (!sock) {
return -1;
}
/* get the peer if currently connected */
connected = (netconn_peer(sock->conn, &addr, &port) == ERR_OK);
remote_addr.addr = ((struct sockaddr_in *)to)->sin_addr.s_addr;
remote_port = ((struct sockaddr_in *)to)->sin_port;
#if SOCKETS_DEBUG
DEBUGF(SOCKETS_DEBUG, ("lwip_sendto(%d, data=%p, size=%d, flags=0x%x to=", s, data, size, flags));
ip_addr_debug_print(&remote_addr);
DEBUGF(SOCKETS_DEBUG, (" port=%u\n", ntohs(remote_port)));
#endif
netconn_connect(sock->conn, &remote_addr, ntohs(remote_port));
ret = lwip_send(s, data, size, flags);
/* reset the remote address and port number
of the connection */
if (connected)
netconn_connect(sock->conn, &addr, port);
else
netconn_disconnect(sock->conn);
return ret;
}
int sendall(int sockfd, unsigned char *send_buf, int len, int flags){
int bytes_sent = 0;
int n;
/* loop as long as there are data to send */
while(bytes_sent < len){
if((n = lwip_send(sockfd, send_buf + bytes_sent,
len - bytes_sent, flags)) < 0){
fprintf(stderr, "%s: lwip_send error\n", __FUNCTION__);
return ERROR;
}
/* Client closed connection */
if(n == 0)
return 0;
/* increment bytes_sent by n */
bytes_sent += n;
}
return bytes_sent;
}
void tcp_setup_thread_entry(void *p)
{
int listenfd;
struct sockaddr_in saddr;
fd_set readset;
listenfd = lwip_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if( listenfd == -1 )
{
rt_kprintf("TCP setup can not create socket!\n");
return;
}
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = htonl(INADDR_ANY);
saddr.sin_port = htons(SETUP_TCP_PORT);
if( lwip_bind(listenfd, (struct sockaddr *)&saddr, sizeof(saddr)) == -1 )
{
lwip_close(listenfd);
rt_kprintf("TCP setup thread socket bind failed!\n");
return;
}
/* Put socket into listening mode */
if (lwip_listen(listenfd,2) == -1)
{
lwip_close(listenfd);
rt_kprintf("Listen failed.\n");
return;
}
/* Wait for data or a new connection */
while(1)
{
/* Determine what sockets need to be in readset */
FD_ZERO(&readset);
FD_SET(listenfd, &readset);
// wait forever.
if( lwip_select(listenfd+1, &readset, 0, 0, 0) == 0 )
continue;
if (FD_ISSET(listenfd, &readset))
{
int ret,optval = 1;
struct sockaddr_in addrin;
u32_t sockaddrLen = sizeof(addrin);
int socket = lwip_accept(listenfd,(struct sockaddr*)&addrin,&sockaddrLen);
if( socket < 0 ) // accept failed.
{
rt_kprintf("TCP setup accept failed.\n");
continue;
}
rt_kprintf("TCP setup accept connection.\n");
// set socket keep alive.
lwip_setsockopt(socket,SOL_SOCKET,SO_KEEPALIVE,&optval ,sizeof(optval));
// begin to recv & send.
while(1)
{
int dataLen,bytesRet;
ret = blocking_lwip_recv(socket,setup_data_buf,P2X_HEADER_LEN,500);
if( ret == 0 )
continue;
if( ret != P2X_HEADER_LEN )
break;
dataLen = P2X_GET_LENGTH(setup_data_buf);
if( dataLen > 0 )
{
int gotDataLen = blocking_lwip_recv(socket,setup_data_buf+P2X_HEADER_LEN,dataLen,500);
if( gotDataLen != dataLen )
break;
}
bytesRet = processCMD(setup_data_buf,P2X_HEADER_LEN+dataLen);
if( lwip_send(socket,setup_data_buf,bytesRet,0) < 0 )
break;
}
rt_kprintf("TCP setup disconnected.\n");
lwip_close(socket);
}
}// while(1) listen.
}
static void
serve_thread(uint32_t a) {
struct st_args *args = (struct st_args *)a;
union Nsipc *req = args->req;
int r;
switch (args->reqno) {
case NSREQ_ACCEPT:
{
struct Nsret_accept ret;
r = lwip_accept(req->accept.req_s, &ret.ret_addr,
&ret.ret_addrlen);
memmove(req, &ret, sizeof ret);
break;
}
case NSREQ_BIND:
r = lwip_bind(req->bind.req_s, &req->bind.req_name,
req->bind.req_namelen);
break;
case NSREQ_SHUTDOWN:
r = lwip_shutdown(req->shutdown.req_s, req->shutdown.req_how);
break;
case NSREQ_CLOSE:
r = lwip_close(req->close.req_s);
break;
case NSREQ_CONNECT:
r = lwip_connect(req->connect.req_s, &req->connect.req_name,
req->connect.req_namelen);
break;
case NSREQ_LISTEN:
r = lwip_listen(req->listen.req_s, req->listen.req_backlog);
break;
case NSREQ_RECV:
// Note that we read the request fields before we
// overwrite it with the response data.
r = lwip_recv(req->recv.req_s, req->recvRet.ret_buf,
req->recv.req_len, req->recv.req_flags);
break;
case NSREQ_SEND:
r = lwip_send(req->send.req_s, &req->send.req_buf,
req->send.req_size, req->send.req_flags);
break;
case NSREQ_SOCKET:
r = lwip_socket(req->socket.req_domain, req->socket.req_type,
req->socket.req_protocol);
break;
case NSREQ_INPUT:
jif_input(&nif, (void *)&req->pkt);
r = 0;
break;
default:
cprintf("Invalid request code %d from %08x\n", args->whom, args->req);
r = -E_INVAL;
break;
}
if (r == -1) {
char buf[100];
snprintf(buf, sizeof buf, "ns req type %d", args->reqno);
perror(buf);
}
if (args->reqno != NSREQ_INPUT)
ipc_send(args->whom, r, 0, 0);
put_buffer(args->req);
sys_page_unmap(0, (void*) args->req);
free(args);
}
ssize_t send(int sockfd, const void *buf, size_t len, int flags)
{
struct fdtab_entry *e = fdtab_get(sockfd);
switch(e->type) {
case FDTAB_TYPE_UNIX_SOCKET:
{
struct _unix_socket *us = e->handle;
// XXX: Don't support flags
assert(flags == 0);
thread_mutex_lock(&us->mutex);
if(us->passive
|| us->u.active.mode != _UNIX_SOCKET_MODE_CONNECTED) {
errno = ENOTCONN;
thread_mutex_unlock(&us->mutex);
return -1;
}
if(us->send_buf != NULL) {
if(us->nonblocking) {
errno = EAGAIN;
thread_mutex_unlock(&us->mutex);
return -1;
} else {
assert(!"NYI");
}
}
// Bleh. Gotta copy here. I can't just wait until the
// message is fully sent, as that might block
// indefinitely.
us->send_buf = malloc(len);
memcpy(us->send_buf, buf, len);
struct event_closure ec = {
.handler = unixsock_sent,
.arg = us,
};
errval_t err = us->u.active.binding->tx_vtbl.
send(us->u.active.binding, ec, us->send_buf, len);
if(err_is_fail(err)) {
USER_PANIC_ERR(err, "unixsock->send");
thread_mutex_unlock(&us->mutex);
return -1;
}
// Wait until all data sent if blocking
if(!us->nonblocking) {
struct waitset ws;
waitset_init(&ws);
err = us->u.active.binding->change_waitset
(us->u.active.binding, &ws);
if(err_is_fail(err)) {
USER_PANIC_ERR(err, "change_waitset");
}
while(us->send_buf != NULL) {
err = event_dispatch(&ws);
if(err_is_fail(err)) {
USER_PANIC_ERR(err, "waitset_destroy");
}
}
// XXX: Assume it was on the default waitset
err = us->u.active.binding->change_waitset
(us->u.active.binding, get_default_waitset());
if(err_is_fail(err)) {
USER_PANIC_ERR(err, "change_waitset");
}
err = waitset_destroy(&ws);
if(err_is_fail(err)) {
USER_PANIC_ERR(err, "waitset_destroy");
}
}
// XXX: We send all or nothing
thread_mutex_unlock(&us->mutex);
return len;
}
case FDTAB_TYPE_LWIP_SOCKET:
lwip_mutex_lock();
ssize_t ret = lwip_send(e->fd, buf, len, flags);
lwip_mutex_unlock();
return ret;
case FDTAB_TYPE_AVAILABLE:
errno = EBADF;
return -1;
default:
errno = ENOTSOCK;
return -1;
}
}
void usart_rx_thread_entry(void *p)
{
unsigned short max_interval,max_datalen;
unsigned int current_mode;
getFrameSplit(&max_interval,&max_datalen);
current_mode = getWorkingMode();
while( rt_sem_take(&rx_sem,RT_WAITING_FOREVER) == RT_EOK )
{
register rt_base_t temp;
FEED_THE_DOG();
// if rj45 not connected, we should route data between 232 and 485.
if( getLinkStatus() == 0 )
{
// we split rx_buf to 2 parts in order to save space.
int len1,len2;
// Clear the semaphore.
temp = rt_hw_interrupt_disable();
rx_sem.value = 0;
rt_hw_interrupt_enable(temp);
do
{
usart_led_flash();
// recv usart1
rt_sem_take(&tx2_sem,RT_WAITING_FOREVER);
len1 = rt_device_read(dev_uart1,0,rx_buf,RX_BUF_SIZE/2);
if( len1 )
dev_uart2->write(dev_uart2, 0, rx_buf, len1);
else
rt_sem_release(&tx2_sem);
// recv usart2
rt_sem_take(&tx1_sem,RT_WAITING_FOREVER);
len2 = rt_device_read(dev_uart2,0,rx_buf+RX_BUF_SIZE/2,RX_BUF_SIZE/2);
if( len2 )
dev_uart1->write(dev_uart1, 0, rx_buf+RX_BUF_SIZE/2, len2);
else
rt_sem_release(&tx1_sem);
}while( (len1 != 0) && (len2 != 0) );
continue;
}
else
{
// Clear the semaphore.
temp = rt_hw_interrupt_disable();
rx_sem.value = 0;
rt_hw_interrupt_enable(temp);
while( 1 )
{
int len;
usart_led_flash();
// read data.
len = rt_device_read(dev_uart1,0,rx_buf+rx_buf_offset,RX_BUF_SIZE-rx_buf_offset);
if( len == 0 )
{
len = rt_device_read(dev_uart2,0,rx_buf+rx_buf_offset,RX_BUF_SIZE-rx_buf_offset);
}
usart_bytes_recv += len;
// If buffer is empty and we received data, start the timer.
if( rx_buf_offset == 0 )
{
if( len == 0 )
{
break;
}
else
{
// if interval less than 10ms, we send data immediately.
if( max_interval >= 10 )
rt_timer_start(&max_interval_timer);
}
}
// move offset pointer.
rx_buf_offset += len;
// check if we should send data out.
if( rx_buf_offset < max_datalen &&
max_interval_timer.parent.flag & RT_TIMER_FLAG_ACTIVATED )
{
break;
}
// Send data out.
if((current_mode == TCP_SERVER)||
(current_mode == TCP_CLIENT)||
(current_mode == TCP_AUTO))
{
int i;
// send data.
for( i = 0 ; i < SOCKET_LIST_SIZE ; i++ )
{
// we should not use RT_WAITING_FOREVER here.
if( rt_mutex_take(&(socket_list[i].mu_sock),10) != RT_EOK )
continue;
// slot not used.
if( socket_list[i].used )
{
// shall not blocking.
if( lwip_send(socket_list[i].socket,rx_buf,rx_buf_offset,0) < 0 )
{
// connection lost.
lwip_close(socket_list[i].socket);
socket_list[i].used = 0;
rt_kprintf("Connection lost.\n");
}
}
rt_mutex_release(&(socket_list[i].mu_sock));
}
}
else if( (current_mode == UDP)||
(current_mode == UDP_MULTICAST) )
{
if( rt_mutex_take(&(socket_list[0].mu_sock),10) == RT_EOK )
{
if( socket_list[0].used )
{
lwip_sendto(socket_list[0].socket,rx_buf,rx_buf_offset,0,
(struct sockaddr*)&(socket_list[0].cliaddr), sizeof(struct sockaddr));
}
rt_mutex_release(&(socket_list[0].mu_sock));
}
}
else
{
rt_kprintf("fatal error! rx thread exits.\n");
return;
}
rx_buf_offset = 0;
}
}
}
rt_kprintf("Error taking semaphore, usart rx exit!\n");
}
static void echo_run()
{
int lSocket;
struct sockaddr_in sLocalAddr;
lSocket = lwip_socket(AF_INET, SOCK_STREAM, 0);
if (lSocket < 0) {
puts("lSocket < 0");
return;
}
memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr));
sLocalAddr.sin_family = AF_INET;
sLocalAddr.sin_len = sizeof(sLocalAddr);
sLocalAddr.sin_addr.s_addr = 0L; //htonl(IP_ADDR_ANY);
sLocalAddr.sin_port = 23;
if (lwip_bind(lSocket, (struct sockaddr *)&sLocalAddr, sizeof(sLocalAddr)) < 0) {
lwip_close(lSocket);
puts("bind failed");
return;
}
if ( lwip_listen(lSocket, 20) != 0 ) {
lwip_close(lSocket);
puts("listen failed");
return;
}
while (1) {
int clientfd;
struct sockaddr_in client_addr;
int addrlen=sizeof(client_addr);
char buffer[1024];
int nbytes;
clientfd = lwip_accept(lSocket, (struct sockaddr*)&client_addr, (socklen_t *)&addrlen);
if (clientfd > 0) {
puts("Accepted Echo Connection");
/*
int flags = fcntl(clientfd, F_GETFL, 0);
printf("flags = %d\n", flags);
fcntl(clientfd, F_SETFL, flags | O_NONBLOCK);
flags = fcntl(clientfd, F_GETFL, 0);
if ((flags & O_NONBLOCK) == O_NONBLOCK) {
printf("it's nonblocking");
}
else {
printf("it's blocking.");
}
*/
struct timeval tv;
tv.tv_sec = 500;
tv.tv_usec = 500;
setsockopt(clientfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv,sizeof(struct timeval));
do {
nbytes = lwip_recv(clientfd, buffer, sizeof(buffer),0);
if (nbytes > 0)
lwip_send(clientfd, buffer, nbytes, 0);
else
lwip_send(clientfd, "#", 1, 0);
} while (nbytes != 0);
puts("Closing connection.");
lwip_close(clientfd);
}
}
lwip_close(lSocket);
puts("Socked closed.");
}
int Socket::Send(const void* msg, int msgLen)
{
return lwip_send(socket_->fd, msg, msgLen, 0);
}
int lwip_write(int s, const void *mem, int len) {
return lwip_send(s, mem, len, 0);
}
void vBasicSocketsCommandInterpreterTask( void *pvParameters )
{
long lSocket, lClientFd, lBytes, lAddrLen = sizeof( struct sockaddr_in ), lInputIndex;
struct sockaddr_in sLocalAddr;
struct sockaddr_in client_addr;
const char *pcWelcomeMessage = "FreeRTOS command server - connection accepted.\r\nType Help to view a list of registered commands.\r\n\r\n>";
char cInChar;
static char cInputString[ cmdMAX_INPUT_SIZE ], cOutputString[ cmdMAX_OUTPUT_SIZE ];
portBASE_TYPE xReturned;
extern void vRegisterSampleCLICommands( void );
( void ) pvParameters;
/* Register the standard CLI commands. */
vRegisterSampleCLICommands();
lSocket = lwip_socket(AF_INET, SOCK_STREAM, 0);
if( lSocket >= 0 )
{
memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr));
sLocalAddr.sin_family = AF_INET;
sLocalAddr.sin_len = sizeof(sLocalAddr);
sLocalAddr.sin_addr.s_addr = htonl(INADDR_ANY);
sLocalAddr.sin_port = ntohs( ( ( unsigned short ) 23 ) );
if( lwip_bind( lSocket, ( struct sockaddr *) &sLocalAddr, sizeof( sLocalAddr ) ) < 0 )
{
lwip_close( lSocket );
vTaskDelete( NULL );
}
if( lwip_listen( lSocket, 20 ) != 0 )
{
lwip_close( lSocket );
vTaskDelete( NULL );
}
for( ;; )
{
lClientFd = lwip_accept(lSocket, ( struct sockaddr * ) &client_addr, ( u32_t * ) &lAddrLen );
if( lClientFd > 0L )
{
lwip_send( lClientFd, pcWelcomeMessage, strlen( ( const char * ) pcWelcomeMessage ), 0 );
lInputIndex = 0;
memset( cInputString, 0x00, cmdMAX_INPUT_SIZE );
do
{
lBytes = lwip_recv( lClientFd, &cInChar, sizeof( cInChar ), 0 );
if( lBytes > 0L )
{
if( cInChar == '\n' )
{
/* The input string has been terminated. Was the
input a quit command? */
if( strcmp( "quit", ( const char * ) cInputString ) == 0 )
{
/* Set lBytes to 0 to close the connection. */
lBytes = 0L;
}
else
{
/* The input string was not a quit command.
Pass the string to the command interpreter. */
do
{
/* Get the next output string from the command interpreter. */
xReturned = FreeRTOS_CLIProcessCommand( cInputString, cOutputString, cmdMAX_INPUT_SIZE );
lwip_send( lClientFd, cOutputString, strlen( ( const char * ) cOutputString ), 0 );
} while( xReturned != pdFALSE );
/* All the strings generated by the input
command have been sent. Clear the input
string ready to receive the next command. */
lInputIndex = 0;
memset( cInputString, 0x00, cmdMAX_INPUT_SIZE );
lwip_send( lClientFd, "\r\n>", strlen( "\r\n>" ), 0 );
}
}
else
{
if( cInChar == '\r' )
{
/* Ignore the character. */
}
else if( cInChar == '\b' )
{
/* Backspace was pressed. Erase the last
character in the string - if any. */
if( lInputIndex > 0 )
{
lInputIndex--;
cInputString[ lInputIndex ] = '\0';
}
}
else
{
/* A character was entered. Add it to the string
entered so far. When a \n is entered the complete
string will be passed to the command interpreter. */
if( lInputIndex < cmdMAX_INPUT_SIZE )
{
cInputString[ lInputIndex ] = cInChar;
lInputIndex++;
}
}
}
}
} while( lBytes > 0L );
lwip_close( lClientFd );
}
}
}
/* Will only get here if a listening socket could not be created. */
vTaskDelete( NULL );
}
ssize_t send(int sockfd, const void *buf, size_t len, int flags)
{
int sock = socket_for_fd(sockfd);
return lwip_send(sock, buf, len, flags);
}
int
lwip_write(int s, void *data, int size)
{
return lwip_send(s, data, size, 0);
}
/**
Send data.
Make sure you're already successfully connected before trying to write.
@param socket The socket to send on, as returned by tcpOpen()
@param data The data to send.
@param length The number of bytes to send.
@return The number of bytes written.
\b Example
\code
int sock = tcpOpen(IP_ADDRESS(192, 168, 0, 210), 10000);
char mydata = "some of my data";
if (sock > -1) {
int written = tcpWrite(sock, mydata, strlen(mydata));
tcpClose(sock);
}
\endcode
*/
int tcpWrite(int socket, const char* data, int length)
{
return lwip_send(socket, data, length, 0);
}
int send(int s, const void *dataptr, size_t size, int flags) {
BT_HANDLE hSocket = (BT_HANDLE)s;
return lwip_send(hSocket->socket, dataptr, size, flags);
}
static BT_s32 socket_write(BT_HANDLE hSocket, BT_u32 ulFlags, BT_u32 ulSize, const void *pBuffer) {
return lwip_send(hSocket->socket, pBuffer, ulSize, ulFlags);
//return BT_ERR_GENERIC;
}
//--------------------------------------------------------------
int ntpbserverSendData(u16 cmd, u8 *buf, int size)
{
int rcvSize, sndSize, recv_size, sent_size, ntpbpktSize, packetSize;
// Waiting io semaphore
WaitSema(ntpbserver_io_sema);
// Build up ntpb packet
memcpy(&ntpb_buf[0], ntpb_hdrmagic, ntpb_MagicSize); //copying NTPB Magic
*((u16 *)&ntpb_buf[ntpb_MagicSize]) = size;
*((u16 *)&ntpb_buf[ntpb_MagicSize+2]) = cmd;
// copy data buf to ntpb packet
if (buf)
memcpy(&ntpb_buf[ntpb_hdrSize], buf, size);
ntpbpktSize = size;
packetSize = ntpbpktSize + ntpb_hdrSize;
// Send ntpb packet to client
sent_size = 0;
// fragmented packet handling
while (sent_size < packetSize) {
sndSize = lwip_send(client_socket, &ntpb_buf[sent_size], packetSize - sent_size, 0);
if (sndSize < 0)
return -1;
sent_size += sndSize;
}
// receive the response packet from client
rcvSize = recv_noblock(client_socket, &ntpb_buf[0], sizeof(ntpb_buf));
if (rcvSize <= 0)
return -1;
ntpbpktSize = *((u16 *)&ntpb_buf[ntpb_MagicSize]);
packetSize = ntpbpktSize + ntpb_hdrSize;
recv_size = rcvSize;
// fragmented packet handling
while (recv_size < packetSize) {
rcvSize = recv_noblock(client_socket, &ntpb_buf[recv_size], sizeof(ntpb_buf) - recv_size);
if (rcvSize <= 0)
return -1;
recv_size += rcvSize;
}
// parses packet
if (!check_ntpb_header(ntpb_buf))
return -2;
// check client reply
if (*((u16 *)&ntpb_buf[ntpb_hdrSize]) != 1)
return -2;
// posting io semaphore
SignalSema(ntpbserver_io_sema);
return 0;
}
int LWIP_SOCKETS_Driver::Send(SOCK_SOCKET socket, const char* buf, int len, int flags)
{
NATIVE_PROFILE_PAL_NETWORK();
return lwip_send(socket, (const void*)buf, len, flags);
}
//--------------------------------------------------------------
int handleClient(int client_socket) // retrieving a packet sent by the Client
{
int rcvSize, sndSize, packetSize, ntpbpktSize, recv_size, sent_size;
u8 *pbuf;
#ifdef _NETLOG
netlog_send("%s: Client Connection OK\n", MODNAME);
#endif
pbuf = (u8 *)&ntpb_buf[0];
while (1) {
// receive the request packet
rcvSize = recv_noblock(client_socket, &ntpb_buf[0], sizeof(ntpb_buf));
if (rcvSize <= 0)
return -1;
// Get packet Size
ntpbpktSize = *((u16 *)&pbuf[6]);
packetSize = ntpbpktSize + ntpb_hdrSize;
recv_size = rcvSize;
// fragmented packet handling
while (recv_size < packetSize) {
rcvSize = recv_noblock(client_socket, &ntpb_buf[recv_size], sizeof(ntpb_buf) - recv_size);
if (rcvSize <= 0)
return -1;
recv_size += rcvSize;
}
// parses packet
if (check_ntpb_header(pbuf)) {
// Get Remote Command, data size, and cmd datas
remote_cmd = *((u16 *)&pbuf[8]);
cmdsize = ntpbpktSize;
if (cmdsize)
memcpy(cmdbuf, &pbuf[ntpb_hdrSize], cmdsize);
#ifdef _NETLOG
netlog_send("%s: server received command 0x%04x size=%d\n", MODNAME, remote_cmd, cmdsize);
#endif
// prepare a response
*((u16 *)&pbuf[6]) = 0;
packetSize = ntpb_hdrSize + 2;
*((u16 *)&pbuf[ntpb_hdrSize]) = 1;
// Send response
sent_size = 0;
// fragmented packet handling
while (sent_size < packetSize) {
sndSize = lwip_send(client_socket, &ntpb_buf[sent_size], packetSize - sent_size, 0);
if (sndSize < 0)
return -1;
sent_size += sndSize;
}
// Wait server CMD semaphore before to continue to wait for client requests
WaitSema(ntpbserver_cmd_sema);
}
}
return 0;
}
int safe_send( int s, const char * ostr) {
int retval = 0;
retval = lwip_send(s, ostr, strlen(ostr), 0);
return retval;
}
