// 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;
}
void udpsend_thread(void *p)
{
int sd;
struct sockaddr_in server;
struct sockaddr_in to;
int BUFSIZE = 8192;
char buf[BUFSIZE];
struct ip_addr to_ipaddr;
int n, i;
/* create a new socket to send responses to this client */
sd = socket(AF_INET, SOCK_DGRAM, 0);
if (sd < 0) {
xil_printf("%s: error creating socket, return value = %d\r\n", __FUNCTION__, sd);
return ;
}
memset(&server, 0, sizeof server);
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = 9130;
if (lwip_bind(sd, (struct sockaddr *)&server, sizeof server) < 0) {
printf("error binding");
return ;
}
IP4_ADDR(&to_ipaddr, 192, 168, 1, 100);
memset(&to, 0, sizeof to);
to.sin_family = AF_INET;
to.sin_addr.s_addr = to_ipaddr.addr;
to.sin_port = 9123;
memset(buf, 0, sizeof buf);
buf[0] = '0'; buf[1] = '0';
buf[1400] = '1'; buf[1401] = '1';
buf[1500] = '2'; buf[1501] = '2';
buf[2000] = '3'; buf[2001] = '3';
/* send one packet to create ARP entry */
lwip_sendto(sd, buf, 1024, 0, (struct sockaddr *)&to, sizeof to);
/* wait until receive'd arp entry updates ARP cache */
sleep(20);
#if 1
/* now send real packets */
for (i = 0; i < 10; i++) {
n = lwip_sendto(sd, buf, sizeof buf, 0, (struct sockaddr *)&to, sizeof to);
xil_printf("sent bytes = %d\r\n", n);
}
#endif
}
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;
}
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
const struct sockaddr *dest_addr, socklen_t addrlen)
{
struct fdtab_entry *e = fdtab_get(sockfd);
ssize_t ret = 0;
switch(e->type) {
case FDTAB_TYPE_UNIX_SOCKET:
assert(!"NYI");
return -1;
break;
case FDTAB_TYPE_LWIP_SOCKET:
lwip_mutex_lock();
ret = lwip_sendto(e->fd, buf, len, flags, dest_addr, addrlen);
lwip_mutex_unlock();
break;
case FDTAB_TYPE_AVAILABLE:
errno = EBADF;
ret = -1;
break;
default:
errno = ENOTSOCK;
ret = -1;
break;
}
return ret;
}
static void
mc_event_local_callback(int s, unsigned int flags, void *closure)
{
xsMachine *the = closure;
mc_local_event_t ev;
struct sockaddr_in sin;
socklen_t slen = sizeof(sin);
int n;
if (flags & MC_SOCK_READ) {
n = lwip_recvfrom(s, &ev, sizeof(ev), 0, (struct sockaddr *)&sin, &slen);
if (n == sizeof(ev) && ev.callback != NULL)
(*ev.callback)(the, ev.closure);
#if !USE_SEMAPHORE
if (!(ev.flags & MC_CALL_ASYNC))
lwip_sendto(s, &ev, sizeof(ev), 0, (struct sockaddr *)&sin, sizeof(sin));
#endif
}
else {
mc_event_unregister(s);
lwip_close(s);
}
#if USE_SEMAPHORE
if (!(ev.flags & MC_CALL_ASYNC))
mc_task_wake(&ev);
#endif
}
static void
mc_event_thread_call_local(mc_event_thread_callback_f callback, void *closure, uint32_t flags)
{
int s;
struct sockaddr_in sin;
mc_local_event_t ev;
int fl;
if ((s = lwip_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
return;
fl = lwip_fcntl(s, F_GETFL, 0);
lwip_fcntl(s, F_SETFL, fl | O_NONBLOCK);
sin.sin_family = AF_INET;
sin.sin_port = htons(MC_LOCAL_EVENT_PORT);
sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
ev.callback = callback;
ev.closure = closure;
ev.flags = flags;
#if USE_SEMAPHORE
mc_task_init(&ev);
#endif
lwip_sendto(s, &ev, sizeof(ev), 0, (struct sockaddr *)&sin, sizeof(sin));
#if !USE_SEMAPHORE
if (!(flags & MC_CALL_ASYNC))
lwip_recv(s, &ev, sizeof(ev), 0);
#endif
lwip_close(s);
#if USE_SEMAPHORE
if (!(flags & MC_CALL_ASYNC)) {
mc_task_sleep(&ev);
mc_task_fin(&ev);
}
#endif
}
/* Ping using the socket ip */
static err_t
ping_send(int s, ip_addr_t *addr)
{
int err;
struct icmp_echo_hdr *iecho;
struct sockaddr_in to;
size_t ping_size = sizeof(struct icmp_echo_hdr) + PING_DATA_SIZE;
LWIP_ASSERT("ping_size is too big", ping_size <= 0xffff);
iecho = (struct icmp_echo_hdr *)mem_malloc((mem_size_t)ping_size);
if (!iecho) {
return ERR_MEM;
}
ping_prepare_echo(iecho, (u16_t)ping_size);
to.sin_len = sizeof(to);
to.sin_family = AF_INET;
inet_addr_from_ipaddr(&to.sin_addr, addr);
err = lwip_sendto(s, iecho, ping_size, 0, (struct sockaddr*)&to, sizeof(to));
mem_free(iecho);
return (err ? ERR_OK : ERR_VAL);
}
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags)
{
struct fdtab_entry *e = fdtab_get(sockfd);
ssize_t ret = 0;
switch(e->type) {
case FDTAB_TYPE_UNIX_SOCKET:
assert(!"NYI");
return -1;
break;
case FDTAB_TYPE_LWIP_SOCKET:
assert(msg != NULL);
assert(msg->msg_control == NULL);
assert(msg->msg_controllen == 0);
#if 0
// XXX: Copy all buffers into one. Should instead have an lwIP interface for this.
size_t totalsize = 0;
for(int i = 0; i < msg->msg_iovlen; i++) {
totalsize += msg->msg_iov[i].iov_len;
}
char *buf = malloc(totalsize);
size_t pos = 0;
for(int i = 0; i < msg->msg_iovlen; i++) {
memcpy(&buf[pos], msg->msg_iov[i].iov_base, msg->msg_iov[i].iov_len);
pos += msg->msg_iov[i].iov_len;
}
lwip_mutex_lock();
ret = lwip_sendto(e->fd, buf, totalsize, flags, msg->msg_name,
msg->msg_namelen);
lwip_mutex_unlock();
free(buf);
#else
lwip_mutex_lock();
ret = lwip_sendmsg(e->fd, msg, flags);
lwip_mutex_unlock();
#endif
break;
case FDTAB_TYPE_AVAILABLE:
errno = EBADF;
ret = -1;
break;
default:
errno = ENOTSOCK;
ret = -1;
break;
}
return ret;
}
/**
Send UDP data.
@param socket The socket, obtained via udpOpen()
@param data The data to send.
@param length The number of bytes to send.
@param address The IP address to send to - use the IP_ADDRESS macro if necessary.
@param port The port to send on.
@return The number of bytes written.
\b Example
\code
int sock = udpOpen(); // create a new socket
int address = IP_ADDRESS(192, 168, 0, 210); // where to send
int port = 10000; // which port to send on
int written = udpWrite(sock, "some data", strlen("some data"), address, port);
\endcode
*/
int udpWrite(int socket, const char* data, int length, int address, int port)
{
struct sockaddr_in sa = {
.sin_family = AF_INET,
.sin_addr.s_addr = address,
.sin_port = htons(port)
};
return lwip_sendto(socket, data, length, 0, (struct sockaddr*)&sa, sizeof(sa));
}
int LWIP_SOCKETS_Driver::SendTo( SOCK_SOCKET socket, const char* buf, int len, int flags, const SOCK_sockaddr* to, int tolen )
{
NATIVE_PROFILE_PAL_NETWORK();
sockaddr_in addr;
SOCK_SOCKADDR_TO_SOCKADDR(to, addr, &tolen);
return lwip_sendto(socket, buf, len, flags, (sockaddr*)&addr, (u32_t)tolen);
}
ssize_t zts_sendto(int fd, const void *buf, size_t len, int flags,
const struct sockaddr *addr, socklen_t addrlen)
{
if (!addr || !buf || len <= 0) {
return ZTS_ERR_INVALID_ARG;
}
if (addrlen > (int)sizeof(struct sockaddr_storage) || addrlen < (int)sizeof(struct sockaddr_in)) {
return ZTS_ERR_INVALID_ARG;
}
return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_sendto(fd, buf, len, flags, addr, addrlen);
}
static void SC_SendTo(__SYSCALL_PARAM_BLOCK* pspb)
{
pspb->lpRetValue = (LPVOID)lwip_sendto(
(INT)PARAM(0),
(const void*)PARAM(1),
(size_t)PARAM(2),
(INT)PARAM(3),
(const struct sockaddr*)PARAM(4),
(socklen_t)PARAM(5)
);
}
void UdpSendData(int socket, const void *data, uint16_t size, uint16_t port)
{
struct sockaddr_in sDestAddr;
memset((char *)&sDestAddr, 0, sizeof(sDestAddr));
/*Destination*/
sDestAddr.sin_family = AF_INET;
sDestAddr.sin_len = sizeof(sDestAddr);
sDestAddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
sDestAddr.sin_port = htons(port);
// Send some data to show we are alive
lwip_sendto(socket, data, size, 0, (struct sockaddr *)&sDestAddr, sizeof(sDestAddr));
}
// 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;
}
int send(int s, const void *data, int size, unsigned int flags)
{
struct lwip_socket *sock;
err_t err;
sock = get_socket(s);
if (!sock)
return -1;
if (sock->conn->type!=NETCONN_TCP)
{
return lwip_sendto(s, data, size, flags, NULL, 0);
}
err = netconn_write(sock->conn, data, size, NETCONN_COPY | ((flags & MSG_MORE)?NETCONN_MORE:0));
return (err==ERR_OK?size:-1);
}
static void post_int(OsNetworkHandle* aHandle)
{
// Send byte to interrupt socket
int sender = lwip_socket ( AF_INET, SOCK_DGRAM, 0 );
struct sockaddr_in s;
s.sin_family = AF_INET;
s.sin_port = htons( 10000 + HANDLE_TO_SOCKET(aHandle) ); // relate port to fd
s.sin_addr.s_addr = IPADDR_LOOPBACK; // localhost
char buffer[] = { 0xaa };
int bytes = lwip_sendto ( sender, buffer, 1, 0, (struct sockaddr*) &s, sizeof(s) );
if ( bytes != sizeof(buffer) )
exit(-1);
lwip_close(sender);
}
int32_t OsNetworkSendTo(THandle aHandle, const uint8_t* aBuffer, uint32_t aBytes, TIpAddress aAddress, uint16_t aPort )
{
if ( OsNetworkHandle_IsInterrupted(aHandle) )
return -1;
LOGFUNCIN();
struct sockaddr_in s;
s.sin_family = AF_INET;
s.sin_port = htons(aPort);
s.sin_addr.s_addr = aAddress;
int bytes = lwip_sendto ( HANDLE_TO_SOCKET(aHandle), (const void *) aBuffer, (size_t) aBytes, 0, (struct sockaddr*) &s, sizeof(s) );
LOGFUNCOUT();
return bytes;
}
static void
ping_send(int s, ip_addr_t *addr)
{
struct icmp_echo_hdr *iecho;
struct sockaddr_in to;
if (!(iecho = (struct icmp_echo_hdr *)malloc(sizeof(struct icmp_echo_hdr))))
return;
ICMPH_TYPE_SET(iecho,ICMP_ECHO);
iecho->chksum = 0;
iecho->seqno = htons(seq_num);
iecho->chksum = inet_chksum(iecho, sizeof(*iecho));
to.sin_len = sizeof(to);
to.sin_family = AF_INET;
to.sin_addr.s_addr = addr->addr;
lwip_sendto(s,iecho,sizeof(*iecho),0,(struct sockaddr*)&to,sizeof(to));
free(iecho);
seq_num++;
}
static void
ping_send(int s, const ip_addr_t *addr)
{
struct icmp_echo_hdr *iecho;
struct sockaddr_storage to;
if (!(iecho = (struct icmp_echo_hdr *)malloc(sizeof(struct icmp_echo_hdr))))
return;
ICMPH_TYPE_SET(iecho,ICMP_ECHO);
iecho->chksum = 0;
iecho->seqno = htons(seq_num);
iecho->chksum = inet_chksum(iecho, sizeof(*iecho));
#if LWIP_IPV4
if(!IP_IS_V6(addr)) {
struct sockaddr_in *to4 = (struct sockaddr_in*)&to;
to4->sin_len = sizeof(to);
to4->sin_family = AF_INET;
inet_addr_from_ipaddr(&to4->sin_addr, ip_2_ip4(addr));
}
#endif /* LWIP_IPV4 */
#if LWIP_IPV6
if(IP_IS_V6(addr)) {
struct sockaddr_in6 *to6 = (struct sockaddr_in6*)&to;
to6->sin6_len = sizeof(to);
to6->sin6_family = AF_INET6;
inet6_addr_from_ip6addr(&to6->sin6_addr, ip_2_ip6(addr));
}
#endif /* LWIP_IPV6 */
lwip_sendto(s, iecho, sizeof(*iecho), 0, (struct sockaddr*)&to, sizeof(to));
free(iecho);
seq_num++;
}
void udp_setup_thread_entry(void *p)
{
int sock;
int bytes_read;
struct sockaddr_in server_addr , client_addr;
int optval = 1;
fd_set readset;
/* create socket */
if ((sock = lwip_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
{
rt_kprintf("Can not create udp setup socket.\n");
return;
}
lwip_setsockopt(sock,SOL_SOCKET,SO_BROADCAST,&optval ,sizeof(optval));
/* init server socket address */
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SETUP_UDP_PORT);
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
rt_memset(&(server_addr.sin_zero),0, sizeof(server_addr.sin_zero));
if (lwip_bind(sock,(struct sockaddr *)&server_addr,
sizeof(struct sockaddr)) == -1)
{
rt_kprintf("Bind error\n");
return;
}
rt_kprintf("UDPServer Waiting for client on port %d \n",SETUP_UDP_PORT);
while (1)
{
int bytes_ret;
rt_uint32_t addr_len = sizeof(struct sockaddr_in);
FD_ZERO(&readset);
FD_SET(sock, &readset);
if( lwip_select(sock+1, &readset, 0, 0, 0) == 0 )
continue;
rt_mutex_take(&setup_data_buf_mutex,RT_WAITING_FOREVER);
bytes_read = lwip_recvfrom(sock, setup_data_buf, DATA_BUF_SIZE, MSG_DONTWAIT,
(struct sockaddr *)&client_addr, &addr_len);
rt_mutex_release(&setup_data_buf_mutex);
if( bytes_read < 0 )
{
continue;
}
rt_mutex_take(&setup_data_buf_mutex,RT_WAITING_FOREVER);
setup_data_buf[bytes_read] = 0;
bytes_ret = processCMD(setup_data_buf,bytes_read);
rt_mutex_release(&setup_data_buf_mutex);
if( bytes_ret > 0 )
{
// command execute success, send reply in buffer.
client_addr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
rt_mutex_take(&setup_data_buf_mutex,RT_WAITING_FOREVER);
lwip_sendto(sock,setup_data_buf,bytes_ret,0,(struct sockaddr*)&client_addr, sizeof(struct sockaddr));
rt_mutex_release(&setup_data_buf_mutex);
}
}
// Should not reach here!.
}
static void test_sockets_msgapi_cmsg(int domain)
{
int s, ret, enable;
struct sockaddr_storage addr_storage;
socklen_t addr_size;
struct iovec iov;
struct msghdr msg;
struct cmsghdr *cmsg;
struct in_pktinfo *pktinfo;
u8_t rcv_buf[4];
u8_t snd_buf[4] = {0xDE, 0xAD, 0xBE, 0xEF};
u8_t cmsg_buf[CMSG_SPACE(sizeof(struct in_pktinfo))];
test_sockets_init_loopback_addr(domain, &addr_storage, &addr_size);
s = test_sockets_alloc_socket_nonblocking(domain, SOCK_DGRAM);
fail_unless(s >= 0);
ret = lwip_bind(s, (struct sockaddr*)&addr_storage, addr_size);
fail_unless(ret == 0);
/* Update addr with epehermal port */
ret = lwip_getsockname(s, (struct sockaddr*)&addr_storage, &addr_size);
fail_unless(ret == 0);
enable = 1;
ret = lwip_setsockopt(s, IPPROTO_IP, IP_PKTINFO, &enable, sizeof(enable));
fail_unless(ret == 0);
/* Receive full message, including control message */
iov.iov_base = rcv_buf;
iov.iov_len = sizeof(rcv_buf);
msg.msg_control = cmsg_buf;
msg.msg_controllen = sizeof(cmsg_buf);
msg.msg_flags = 0;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_name = NULL;
msg.msg_namelen = 0;
memset(rcv_buf, 0, sizeof(rcv_buf));
ret = lwip_sendto(s, snd_buf, sizeof(snd_buf), 0, (struct sockaddr*)&addr_storage, addr_size);
fail_unless(ret == sizeof(snd_buf));
tcpip_thread_poll_one();
ret = lwip_recvmsg(s, &msg, 0);
fail_unless(ret == sizeof(rcv_buf));
fail_unless(!memcmp(rcv_buf, snd_buf, sizeof(rcv_buf)));
/* Verify message header */
cmsg = CMSG_FIRSTHDR(&msg);
fail_unless(cmsg != NULL);
fail_unless(cmsg->cmsg_len > 0);
fail_unless(cmsg->cmsg_level == IPPROTO_IP);
fail_unless(cmsg->cmsg_type == IP_PKTINFO);
/* Verify message data */
pktinfo = (struct in_pktinfo*)CMSG_DATA(cmsg);
/* We only have loopback interface enabled */
fail_unless(pktinfo->ipi_ifindex == 1);
fail_unless(pktinfo->ipi_addr.s_addr == PP_HTONL(INADDR_LOOPBACK));
/* Verify there are no additional messages */
cmsg = CMSG_NXTHDR(&msg, cmsg);
fail_unless(cmsg == NULL);
/* Send datagram again, testing truncation */
memset(rcv_buf, 0, sizeof(rcv_buf));
ret = lwip_sendto(s, snd_buf, sizeof(snd_buf), 0, (struct sockaddr*)&addr_storage, addr_size);
fail_unless(ret == sizeof(snd_buf));
tcpip_thread_poll_one();
msg.msg_controllen = 1;
msg.msg_flags = 0;
ret = lwip_recvmsg(s, &msg, 0);
fail_unless(ret == sizeof(rcv_buf));
fail_unless(!memcmp(rcv_buf, snd_buf, sizeof(rcv_buf)));
/* Ensure truncation was returned */
fail_unless(msg.msg_flags & MSG_CTRUNC);
/* Ensure no control messages were returned */
fail_unless(msg.msg_controllen == 0);
ret = lwip_close(s);
fail_unless(ret == 0);
}
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");
}
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
const struct sockaddr *dest_addr, socklen_t addrlen)
{
int sock = socket_for_fd(sockfd);
return lwip_sendto(sock, buf, len, flags, dest_addr, addrlen);
}
int sendto(int s, const void *dataptr, size_t size, int flags, const struct sockaddr *to, socklen_t tolen) {
BT_HANDLE hSocket = (BT_HANDLE)s;
return lwip_sendto(hSocket->socket, dataptr, size, flags, to, tolen);
}
/**
* Send an SNTP request via sockets.
* This is a very minimal implementation that does not fully conform
* to the SNTPv4 RFC, especially regarding server load and error procesing.
*/
void
sntp_request(void *arg)
{
int sock;
struct sockaddr_in local;
struct sockaddr_in to;
int tolen;
int size;
int timeout;
struct sntp_msg sntpmsg;
ip_addr_t sntp_server_address;
LWIP_UNUSED_ARG(arg);
/* if we got a valid SNTP server address... */
if (ipaddr_aton(SNTP_SERVER_ADDRESS, &sntp_server_address)) {
/* create new socket */
sock = lwip_socket(AF_INET, SOCK_DGRAM, 0);
if (sock >= 0) {
/* prepare local address */
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
local.sin_port = PP_HTONS(INADDR_ANY);
local.sin_addr.s_addr = PP_HTONL(INADDR_ANY);
/* bind to local address */
if (lwip_bind(sock, (struct sockaddr *)&local, sizeof(local)) == 0) {
/* set recv timeout */
timeout = SNTP_RECV_TIMEOUT;
lwip_setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
/* prepare SNTP request */
sntp_initialize_request(&sntpmsg);
/* prepare SNTP server address */
memset(&to, 0, sizeof(to));
to.sin_family = AF_INET;
to.sin_port = PP_HTONS(SNTP_PORT);
inet_addr_from_ipaddr(&to.sin_addr, &sntp_server_address);
/* send SNTP request to server */
if (lwip_sendto(sock, &sntpmsg, SNTP_MSG_LEN, 0, (struct sockaddr *)&to, sizeof(to)) >= 0) {
/* receive SNTP server response */
tolen = sizeof(to);
size = lwip_recvfrom(sock, &sntpmsg, SNTP_MSG_LEN, 0, (struct sockaddr *)&to, (socklen_t *)&tolen);
/* if the response size is good */
if (size == SNTP_MSG_LEN) {
/* if this is a SNTP response... */
if (((sntpmsg.li_vn_mode & SNTP_MODE_MASK) == SNTP_MODE_SERVER) ||
((sntpmsg.li_vn_mode & SNTP_MODE_MASK) == SNTP_MODE_BROADCAST)) {
/* do time processing */
sntp_process(sntpmsg.receive_timestamp);
} else {
LWIP_DEBUGF( SNTP_DEBUG_WARN, ("sntp_request: not response frame code\n"));
}
}
} else {
LWIP_DEBUGF( SNTP_DEBUG_WARN, ("sntp_request: not sendto==%i\n", errno));
}
}
/* close the socket */
closesocket(sock);
}
}
}
int netstack_send_echo(u8 *ripaddr, u16 size, u16 seqno,
struct netstack_echo_reply *reply)
{
u64 ts;
int s, i, err;
char buf[64];
size_t fromlen, off, len = sizeof(struct icmp_echo_hdr) + size;
ip_addr_t to_addr, from_addr;
struct sockaddr_in sock;
struct ip_hdr *iphdr;
struct icmp_echo_hdr *iecho;
LWIP_ASSERT("ping_size is too big\n", len <= 0xffff);
/* Prepare target address */
IP4_ADDR(&to_addr, ripaddr[0],ripaddr[1],ripaddr[2],ripaddr[3]);
/* Open RAW socket */
if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) {
vmm_printf("%s: failed to open ICMP socket\n", __func__);
return VMM_EFAIL;
}
/* Set socket option */
i = PING_RCV_TIMEO;
lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &i, sizeof(i));
/* Prepare socket address */
sock.sin_len = sizeof(sock);
sock.sin_family = AF_INET;
inet_addr_from_ipaddr(&sock.sin_addr, &to_addr);
/* Prepare ECHO request */
iecho = (struct icmp_echo_hdr *)vmm_zalloc(len);
if (!iecho) {
return VMM_ENOMEM;
}
ICMPH_TYPE_SET(iecho, ICMP_ECHO);
ICMPH_CODE_SET(iecho, 0);
iecho->chksum = 0;
iecho->id = PING_ID;
iecho->seqno = htons(seqno);
for (i = 0; i < size; i++) {
((char*)iecho)[sizeof(struct icmp_echo_hdr) + i] = (char)i;
}
iecho->chksum = inet_chksum(iecho, len);
/* Send ECHO request */
err = lwip_sendto(s, iecho, len, 0,
(struct sockaddr*)&sock, sizeof(sock));
vmm_free(iecho);
if (!err) {
return VMM_EFAIL;
}
/* Get reference timestamp */
ts = vmm_timer_timestamp();
/* Wait for ECHO reply */
err = VMM_EFAIL;
off = lwip_recvfrom(s, buf, sizeof(buf), 0,
(struct sockaddr*)&sock, (socklen_t*)&fromlen);
if (off >= (sizeof(struct ip_hdr) + sizeof(struct icmp_echo_hdr))) {
inet_addr_to_ipaddr(&from_addr, &sock.sin_addr);
iphdr = (struct ip_hdr *)buf;
iecho = (struct icmp_echo_hdr *)(buf + (IPH_HL(iphdr) * 4));
if ((iecho->id == PING_ID) &&
(iecho->seqno == htons(seqno))) {
reply->ripaddr[0] = ip4_addr1(&from_addr);
reply->ripaddr[1] = ip4_addr2(&from_addr);
reply->ripaddr[2] = ip4_addr3(&from_addr);
reply->ripaddr[3] = ip4_addr4(&from_addr);
reply->ttl = IPH_TTL(iphdr);
reply->len = len;
reply->seqno = seqno;
reply->rtt =
udiv64(vmm_timer_timestamp() - ts, 1000);
err = VMM_OK;
}
}
while (off < len) {
off = lwip_recvfrom(s, buf, sizeof(buf), 0,
(struct sockaddr*)&sock, (socklen_t*)&fromlen);
}
/* Close RAW socket */
lwip_close(s);
return err;
}
