// 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; }