BST_IP_ERR_T BST_IP_BsdSocket( BST_FD_T *pfd, BST_ARG_T *Arg, BST_UINT16 usProtocol ) { BST_UINT32 ulTimeout; ulTimeout = BST_IP_RX_TIME_OUT; if( BST_NULL_PTR == pfd ) { return BST_IP_ERR_ARG; } switch( usProtocol ) { case BST_IP_PROTOCOL_UDP: pfd->lFd = lwip_socket( AF_INET, SOCK_DGRAM, 0 ); break; case BST_IP_PROTOCOL_TCP: pfd->lFd = lwip_socket( AF_INET, SOCK_STREAM, 0 ); //TCP对应SOCK_STREAM break; default : pfd->lFd = BST_IP_ERR_MEM; return BST_IP_ERR_ARG; } if( BST_IP_IsBsdFdValid( (*pfd) ) ) { if ( 0 == lwip_setsockopt( pfd->lFd, SOL_SOCKET, SO_RCVTIMEO, &ulTimeout, BST_OS_SIZEOF( ulTimeout ) ) ) { return BST_IP_ERR_OK; } return BST_IP_ERR_VAL; } else { return BST_IP_ERR_MEM; } }
int32_t trcSocketInitializeListener() { if (sock >= 0) return 0; sock = lwip_socket(AF_INET, SOCK_STREAM, 0); if (sock < 0) return -1; address.sin_family = AF_INET; address.sin_port = htons( TRC_TCPIP_PORT ); address.sin_addr.s_addr = INADDR_ANY; if (bind(sock, (struct sockaddr *)&address, sizeof (address)) < 0) { closesocket(sock); sock = -1; return -1; } if (lwip_listen(sock, 5) < 0) { closesocket(sock); sock = -1; return -1; } return 0; }
void echo_application_thread() { int sock, new_sd; struct sockaddr_in address, remote; int size; if ((sock = lwip_socket(AF_INET, SOCK_STREAM, 0)) < 0) return; address.sin_family = AF_INET; address.sin_port = htons(echo_port); address.sin_addr.s_addr = INADDR_ANY; if (lwip_bind(sock, (struct sockaddr *)&address, sizeof (address)) < 0) return; lwip_listen(sock, 0); size = sizeof(remote); while (1) { if ((new_sd = lwip_accept(sock, (struct sockaddr *)&remote, (socklen_t *)&size)) > 0) { sys_thread_new("echos", process_echo_request, (void*)new_sd, THREAD_STACKSIZE, DEFAULT_THREAD_PRIO); } } }
void telnet_init(int vdefd) { int sockfd; struct sockaddr_in serv_addr; vdehist_termread=lwip_read; vdehist_termwrite=lwip_write; vdehist_logincmd=telnet_logincmd; sockfd=lwip_socket(AF_INET, SOCK_STREAM, 0); if (!sockfd) { printlog(LOG_ERR,"telnet socket err: %s",strerror(errno)); } bzero((char *) &serv_addr, sizeof(serv_addr)); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); serv_addr.sin_port = htons(TELNET_TCP_PORT); if (lwip_bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) { printlog(LOG_ERR,"telnet bind err: %s",strerror(errno)); } lwip_listen(sockfd, 5); addpfd(sockfd,telnetaccept); }
static void ping_thread(void *arg) { int s; int timeout = PING_RCV_TIMEO; ip_addr_t ping_target; LWIP_UNUSED_ARG(arg); if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) { return; } lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)); while (1) { ping_target = PING_TARGET; if (ping_send(s, &ping_target) == ERR_OK) { LWIP_DEBUGF( PING_DEBUG, ("ping: send ")); ip_addr_debug_print(PING_DEBUG, &ping_target); LWIP_DEBUGF( PING_DEBUG, ("\n")); ping_time = sys_now(); ping_recv(s); } else { LWIP_DEBUGF( PING_DEBUG, ("ping: send ")); ip_addr_debug_print(PING_DEBUG, &ping_target); LWIP_DEBUGF( PING_DEBUG, (" - error\n")); } sys_msleep(PING_DELAY); } }
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 }
/* * Function: CreateUdpSocket * Description: Create a socket to an UDP port * Return: Handle to the socket */ int CreateUdpSocket(uint16_t port, UdpCbkFunc cbkFunc) { int udpSocket; struct sockaddr_in sLocalAddr; imask_t val; /* Init socket */ udpSocket = lwip_socket(AF_INET, SOCK_DGRAM, 0); Irq_Save(val); for(int i=0;i<MAX_NUM_OF_SOCKETS;i++){ if(sockList[i] == (-1)){ sockList[i] = udpSocket; cbkFuncList[i] = cbkFunc; break; } } Irq_Restore(val); memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr)); /*Source*/ sLocalAddr.sin_family = AF_INET; sLocalAddr.sin_len = sizeof(sLocalAddr); sLocalAddr.sin_addr.s_addr = htonl(INADDR_ANY); sLocalAddr.sin_port = htons(port); if(lwip_bind(udpSocket, (struct sockaddr *)&sLocalAddr, sizeof(sLocalAddr)) < 0) { KillUdpSocket(udpSocket); } return udpSocket; }
int main(int argc, char **argv) { int sock, length; struct sockaddr_in server; int msgsock; int i; // intalization lwip_tcpip_init(); /* DHCP */ //enum { BUF_SIZE = Nic::Packet_allocator::DEFAULT_PACKET_SIZE * 128 }; int BUF_SIZE= 200000; if (lwip_nic_init(0, 0, 0, BUF_SIZE, BUF_SIZE)) { printf("ERROR: We got no IP address!\n"); return 1; } /* Create socket */ sock = lwip_socket(AF_INET, SOCK_STREAM, 0); if (sock < 0) { perror("opening stream socket"); exit(1); } /* Name socket using wildcards */ server.sin_family = AF_INET; server.sin_addr.s_addr = INADDR_ANY; server.sin_port = htons(SRV_PORT); if (lwip_bind(sock, (struct sockaddr *)&server, sizeof(server))) { perror("binding stream socket"); exit(1); } /* Find out assigned port number and print it out */ //length = sizeof(server); //if (getsockname(sock, (struct sockaddr *)&server, &length)) { // perror("getting socket name"); // exit(1); // } // printf("Socket has port #%d\n", ntohs(server.sin_port)); printf("Socket has port #%d\n",3333); /* Start accepting connections */ lwip_listen(sock, 5); do { msgsock = lwip_accept(sock, 0, 0); if (msgsock == -1) perror("accept"); printf("process message on msgsock %d \n ",msgsock); process_client(msgsock); close(msgsock); } while (TRUE); /* * Since this program has an infinite loop, the socket "sock" is * never explicitly closed. However, all sockets will be closed * automatically when a process is killed or terminates normally. */ }
int mc_event_main(xsMachine *the, mc_event_shutdown_callback_t *cb) { struct timeval tv; fd_set rs, ws; int n = -1, i; unsigned int flags; uint64_t timeInterval; struct sockaddr_in sin; int localevent_sock; mc_shutdown_callback = cb; g_status = -1; /* not ready yet */ if ((localevent_sock = lwip_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) return -1; sin.sin_family = AF_INET; sin.sin_port = htons(MC_LOCAL_EVENT_PORT); sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK); lwip_bind(localevent_sock, (struct sockaddr *)&sin, sizeof(sin)); mc_event_register(localevent_sock, MC_SOCK_READ, mc_event_local_callback, the); mc_event_delegation_init(); g_status = 0; /* running */ while (!g_status) { timeInterval = mc_event_process_timeout(the); if (timeInterval != 0) { tv.tv_sec = timeInterval / 1000; tv.tv_usec = (timeInterval % 1000) * 1000; } if (maxfd < 0) { /* @@ what if only timer is running?? */ mc_log_debug("event: no one is waiting!\n"); break; /* no one is waiting for anything! will be blocked forever unless break */ } rs = reads; ws = writes; n = lwip_select(maxfd + 1, &rs, &ws, NULL, timeInterval > 0 ? &tv : NULL); if (mc_event_callback_any.callback != NULL) (*mc_event_callback_any.callback)(mc_event_callback_any.fd, (unsigned int)n, mc_event_callback_any.closure); if (n > 0) { for (i = 0; i <= maxfd; i++) { flags = 0; if (FD_ISSET(i, &rs)) flags |= MC_SOCK_READ; if (FD_ISSET(i, &ws)) flags |= MC_SOCK_WRITE; if (flags) { if (mc_event_callbacks[i].callback == NULL) { mc_log_error("event: %s ready for closed socket(%d)!?\n", flags & MC_SOCK_WRITE ? "write" : "read", i); continue; } (*mc_event_callbacks[i].callback)(i, flags, mc_event_callbacks[i].closure); } } } } mc_event_delegation_fin(); lwip_close(localevent_sock); return g_exit_status; }
static int test_sockets_alloc_socket_nonblocking(int domain, int type) { int s = lwip_socket(domain, type, 0); if (s >= 0) { int ret = lwip_fcntl(s, F_SETFL, O_NONBLOCK); fail_unless(ret == 0); } return s; }
THandle OsNetworkCreate(OsNetworkSocketType aSocketType) { int s; int type; OsNetworkHandle* h; //LOG(__FUNCTION__); switch ( aSocketType ) { case eOsNetworkSocketStream: type = SOCK_STREAM; break; case eOsNetworkSocketDatagram: type = SOCK_DGRAM; break; default: return kHandleNull; } h = OsNetworkHandle_Create(); //LOG(" Created %d\n", HANDLE_TO_SOCKET(h)); if ( h == kHandleNull ) return kHandleNull; s = lwip_socket(AF_INET, type, 0); if ( s < 0 ) { OsNetworkHandle_Destroy(h); return kHandleNull; } if ( type == SOCK_DGRAM ) { char loop = 1; if (lwip_setsockopt(s, IPPROTO_IP, IP_MULTICAST_LOOP, &loop, sizeof(loop)) < 0) { OsNetworkHandle_Destroy(h); return kHandleNull; } } if ( OsNetworkHandle_Initialise(h, s) < 0 ) { OsNetworkHandle_Destroy(h); return kHandleNull; } return (THandle) h; }
int socket(int domain, int type, int protocol) { int fd, res; fd = lwip_socket(domain, type, protocol); if (fd < 0) return -1; res = alloc_fd(FTYPE_SOCKET); printk("socket -> %d\n", res); files[res].socket.fd = fd; return res; }
void MTD_FLASHMEM UDPClient::init(IPAddress remoteAddress, uint16_t remotePort) { m_socket = lwip_socket(AF_INET, SOCK_DGRAM, 0); sockaddr_in localAddress = {0}; localAddress.sin_family = AF_INET; localAddress.sin_len = sizeof(sockaddr_in); localAddress.sin_addr.s_addr = htonl(INADDR_ANY); localAddress.sin_port = htons(getUDPPort()); lwip_bind(m_socket.getSocket(), (sockaddr *)&localAddress, sizeof(sockaddr_in)); m_socket.setRemoteAddress(remoteAddress, remotePort); }
static void socketCreate(uint16 sockNr) { int sockFd; int sockType; struct sockaddr_in sLocalAddr; if (SocketAdminList[sockNr].SocketProtocolIsTcp) { sockType = SOCK_STREAM; } else { sockType = SOCK_DGRAM; } sockFd = lwip_socket(AF_INET, sockType, 0); if (sockFd >= 0) { memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr)); int on = 1; lwip_ioctl(sockFd, FIONBIO, &on); // lwip_setsockopt( sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(int) ); // shuzhou add lwip_setsockopt(sockFd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(int)); // Set socket to no delay /*Source*/ sLocalAddr.sin_family = AF_INET; sLocalAddr.sin_len = sizeof(sLocalAddr); sLocalAddr.sin_addr.s_addr = htonl(INADDR_ANY); // TODO: Use IP from configuration instead sLocalAddr.sin_port = htons(SocketAdminList[sockNr].SocketConnectionRef->SocketLocalPort); if(lwip_bind(sockFd, (struct sockaddr *)&sLocalAddr, sizeof(sLocalAddr)) >= 0) { if (!SocketAdminList[sockNr].SocketProtocolIsTcp) { // Now the UDP socket is ready for receive/transmit SocketAdminList[sockNr].SocketHandle = sockFd; SocketAdminList[sockNr].SocketState = SOCKET_UDP_READY; } else { if ( lwip_listen(sockFd, 20) == 0 ){ // TODO: What number of the backlog? // Now the TCP socket is ready for receive/transmit SocketAdminList[sockNr].SocketHandle = sockFd; SocketAdminList[sockNr].SocketState = SOCKET_TCP_LISTENING; } else { lwip_close(sockFd); } } } else { lwip_close(sockFd); } } else { // Socket creation failed // Do nothing, try again later } }
Socket::Socket() { int on = 1; socket_ = new SocketHandle_t; socket_->fd = lwip_socket(PF_INET, SOCK_STREAM, 0); lwip_setsockopt(socket_->fd, SOL_SOCKET, SO_REUSEADDR, (char*) &on, sizeof(on)); /* Set socket non-blocking */ lwip_ioctl(socket_->fd, FIONBIO, &on); }
int32_t mcs_tcp_init(void (*mcs_tcp_callback)(char *)) { int s; int c; int ret; struct sockaddr_in addr; int count = 0; int rcv_len, rlen; int32_t mcs_ret = MCS_TCP_DISCONNECT; /* Setting the TCP ip */ if (HTTPCLIENT_OK != getInitialTCPIP()) { return MCS_TCP_INIT_ERROR; } /* command buffer */ char cmd_buf [50]= {0}; strcat(cmd_buf, DEVICEID); strcat(cmd_buf, ","); strcat(cmd_buf, DEVICEKEY); strcat(cmd_buf, ",0"); mcs_tcp_connect: os_memset(&addr, 0, sizeof(addr)); addr.sin_len = sizeof(addr); addr.sin_family = AF_INET; addr.sin_port = htons(SOCK_TCP_SRV_PORT); addr.sin_addr.s_addr =inet_addr(TCP_ip); /* create the socket */ s = lwip_socket(AF_INET, SOCK_STREAM, 0); if (s < 0) { mcs_ret = MCS_TCP_SOCKET_INIT_ERROR; printf("tcp client create fail 0\n"); goto idle; } ret = lwip_connect(s, (struct sockaddr *)&addr, sizeof(addr)); if (ret < 0) { lwip_close(s); printf("tcp client connect fail 1\n"); goto mcs_tcp_connect; } /* timer */ void tcpTimerCallback( TimerHandle_t pxTimer ) { ret = lwip_write(s, cmd_buf, sizeof(cmd_buf)); }
void Test_lwIP() { int server; int client; int acceptSock; int nonblock; int recvd; struct sockaddr_in addr, acceptAddr; socklen_t len; // tcp interface variables struct ip_addr IpAddrLB; IP4_ADDR( &IpAddrLB, 127,0,0,1); //Loopback addr.sin_family = AF_INET; addr.sin_port = 8080; addr.sin_addr.s_addr = *(u32_t*)&IpAddrLB; addr.sin_len = sizeof(struct sockaddr_in); server = lwip_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); client = lwip_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); nonblock = 1; if(server == -1 || client == -1) lcd_printf("Sockets were not created!\n"); if(-1 == lwip_ioctl(server, FIONBIO, (void*)&nonblock)) lcd_printf("Error ioctl 1\n"); if(-1 == lwip_ioctl(client, FIONBIO, (void*)&nonblock)) lcd_printf("Error ioctl 2\n"); len = sizeof(addr); if(-1 == lwip_bind( server, (const struct sockaddr*)&addr, len ))lcd_printf("Error bind\n"); if(-1 == lwip_listen( server, 2 )) lcd_printf("Error listen\n"); / / Set up a tcp connection for client: Bind, Connect
//Entry point of ping application. void ping_Entry(void *arg) { int s; int timeout = PING_RCV_TIMEO; __PING_PARAM* pParam = (__PING_PARAM*)arg; ping_pkt_seq = 0; //Reset ping sequence number. ping_succ = 0; if((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) { PrintLine(" ping : Create raw socket failed,quit."); return; } lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)); _hx_printf("\r\n Ping %s with %d bytes packet:\r\n",inet_ntoa(pParam->targetAddr),pParam->size); while (1) { //ping_target = PING_TARGET; //ping gw //IP4_ADDR(&ping_target, 127,0,0,1); //ping loopback. if (ping_send(s, &pParam->targetAddr,pParam->size) == ERR_OK) { //printf(" ping_Entry : Send out packet,addr = %s,size = %d\r\n",inet_ntoa(pParam->targetAddr),pParam->size); ping_time = sys_now(); ping_recv(s); ping_pkt_seq ++; } else { PrintLine(" ping : Send out packet failed."); } //sys_msleep(PING_DELAY); //Try the specified times. pParam->count --; if(0 == pParam->count) { break; } } //Show ping statistics. _hx_printf("\r\n"); _hx_printf(" ping statistics: total send = %d,received = %d,%d loss.\r\n", ping_pkt_seq,ping_succ,(ping_pkt_seq - ping_succ)); //Close socket. lwip_close(s); }
int socket(int domain, int type, int protocol) { if(!BT_isNetworkingReady()) { return -1; } BT_ERROR Error; BT_HANDLE hSocket = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), &Error); if(!hSocket) { return 0; } hSocket->socket = lwip_socket(domain, type, protocol); return (int)hSocket; }
int socket_init_socket(struct mySocket *sock, int type) { sock->_sock_fd = -1; sock->_blocking = 1; sock->_timeout.tv_sec = 1; sock->_timeout.tv_usec = 500; if (sock->_sock_fd != -1) return -1; int fd = lwip_socket(AF_INET, type, 0); if (fd < 0) return -1; sock->_sock_fd = fd; return 0; }
void rx_application_thread() { int sock, new_sd; struct sockaddr_in address, remote; int size; if ((sock = lwip_socket(AF_INET, SOCK_STREAM, 0)) < 0) return; address.sin_family = AF_INET; address.sin_port = htons(rxperf_port); address.sin_addr.s_addr = INADDR_ANY; if (lwip_bind(sock, (struct sockaddr *)&address, sizeof (address)) < 0) { #ifdef OS_IS_FREERTOS vTaskDelete(NULL); #endif return; } lwip_listen(sock, 0); size = sizeof(remote); new_sd = lwip_accept(sock, (struct sockaddr *)&remote, (socklen_t*)&size); while (1) { #if (USE_JUMBO_FRAMES==1) char recv_buf[9700]; /* keep reading data */ if (lwip_read(new_sd, recv_buf, 8000) <= 0) break; #else char recv_buf[1500]; /* keep reading data */ if (lwip_read(new_sd, recv_buf, 1460) <= 0) break; #endif } print("Connection closed. RXPERF exiting.\r\n"); lwip_close(new_sd); #ifdef OS_IS_FREERTOS xil_printf("Rx IPERF Thread is being DELETED\r\n"); vTaskDelete(NULL); #endif }
static void receive_udp(void *pvParameters) { int lSocket; struct sockaddr_in sLocalAddr, sDestAddr; int nbytes; int i; lSocket = lwip_socket(AF_INET, SOCK_DGRAM, 0); if(lSocket != 0) { printf("ERROR \r\n"); } memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr)); 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(8080); /*Source*/ sLocalAddr.sin_family = AF_INET; sLocalAddr.sin_len = sizeof(sLocalAddr); sLocalAddr.sin_addr.s_addr = htonl(INADDR_ANY); //inet_addr("192.168.4.1"); sLocalAddr.sin_port = htons(8080); int err = lwip_bind(lSocket, (struct sockaddr *)&sLocalAddr, sizeof(sLocalAddr)); if(err != 0) { printf("ERROR \r\n"); } while (1) { nbytes=lwip_recv(lSocket, buffer, sizeof(buffer),8); if (nbytes>0) { //lwip_sendto(lSocket, buffer, nbytes, 0, (struct sockaddr *)&sDestAddr, sizeof(sDestAddr)); char * dat = malloc(nbytes); memcpy(dat, buffer, nbytes); dat[nbytes] = 0; my_event_t ev; ev.event_type = EVT_DATA; ev.data = dat; ev.len = nbytes; xQueueSend(mainqueue, &ev, 0); } } lwip_close(lSocket); }
static void ping_thread(void *arg) { int s; LWIP_UNUSED_ARG(arg); if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) { return; } while (1) { printf("sending ping\n"); ping_send(s,&ping_addr); ping_recv(s,&ping_addr); sleep(1); } }
/** Open a new TCP socket. Be sure to close any sockets you open - otherwise, you won't be able to open any new ones. @param address The IP address to connect to - use the IP_ADDRESS macro if needed. @param port The port to connect on. @return A handle to the new socket, or -1 if it failed to connect. \b Example \code int sock = tcpOpen(IP_ADDRESS(192, 168, 0, 210), 11101); if (sock > -1) { // then we got a good connection // ...reading & writing... tcpClose(sock); // make sure to close it if we connected } \endcode */ int tcpOpen(int address, int port) { int sock = lwip_socket(0, SOCK_STREAM, IPPROTO_TCP); if (sock >= 0) { struct sockaddr_in to = { .sin_family = AF_INET, .sin_addr.s_addr = address, .sin_port = htons(port) }; if (lwip_connect(sock, (const struct sockaddr*)&to, sizeof(to)) != 0) { lwip_close(sock); sock = -1; } } return sock; }
void buttonConnectPressed(void* source) { struct sockaddr_in addr; int ret; ((button_t*)source)->hasBeenAcknowledged = 1; setStatus(CONNECTING); if (!isConnected) { memset(&addr, 0, sizeof(addr)); addr.sin_len = sizeof(addr); addr.sin_family = AF_INET; addr.sin_port = PP_HTONS(SOCK_TARGET_PORT); addr.sin_addr.s_addr = inet_addr(SOCK_TARGET_HOST); socket_in = lwip_socket(AF_INET, SOCK_STREAM, 0); if ((ret = lwip_connect(socket_in, (struct sockaddr*)&addr, sizeof(addr))) == 0) { isConnected = 1; executeCommand(IDENT); executeCommand(END_IDENT); setStatus(CONNECTED); } else { isConnected = 0; setStatus(DISCONNECTED); } } else { if ((ret = lwip_close(socket_in)) == 0) { setStatus(DISCONNECTED); isConnected = 0; resetBoards(); setVersion(NULL); } } refreshBoards(); }
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); }
/* ------------------------------------------------------------------------------------------------------ * sockex_nonblocking_connect() * * Description : Handing socket receive data. * * Argument(s) : none. * */ void sockex_testrecv(void *arg) { // int ret; struct sockaddr_in servaddr, cliaddr; // struct timeval tv; unsigned long cliaddr_len; LWIP_UNUSED_ARG(arg); memset(&servaddr, 0, sizeof(servaddr)); /* set up address to connect to */ servaddr.sin_len = sizeof(servaddr); servaddr.sin_family = AF_INET; servaddr.sin_port = PP_HTONS(SOCK_HOSR_PORT); servaddr.sin_addr.s_addr = lwIPLocalIPAddrGet(); /* Set local IP address.*/ listenfd = lwip_socket(AF_INET, SOCK_STREAM, 0); lwip_bind(listenfd, (struct sockaddr *)&servaddr, sizeof(struct sockaddr)); lwip_listen(listenfd, SOCK_HOSR_PORT); RS232printf("Accepting connections ...\n"); cliaddr_len = sizeof(cliaddr); for(;;) { connfd = lwip_accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len); if(connfd <= 0) { OSTimeDly(2); continue; } else { connfd = connfd; RS232printf("cli is ok!"); } // lwip_select(); OSTimeDly(2); } }
static void ping_thread(void *arg) { int s; struct ip_addr dest_addr; if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) { return; } IP4_ADDR(&dest_addr,192,168,2,1); while (1) { printf("sending ping\n"); ping_send(s,&dest_addr); ping_recv(s,&dest_addr); sleep(1); } }
static void ping_host_thread(void *arg) { int s,i=0; int timeout = PING_RCV_TIMEO; ip_addr_t ping_target; char *host = (char *)arg; //LWIP_UNUSED_ARG(arg); if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) { return; } lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)); while (1) { //ping_target = PING_TARGET; if (i>4) break; i++; (ip4_addr_set_u32(&ping_target, ipaddr_addr(host))); if (ping_send(s, &ping_target) == ERR_OK) { //LWIP_DEBUGF( PING_DEBUG, ("ping: send ")); //ip_addr_debug_print(PING_DEBUG, &ping_target); //LWIP_DEBUGF( PING_DEBUG, ("\n")); rt_kprintf("ping: send "); ip_addr_debug_print1(&ping_target); rt_kprintf("\n"); ping_time = sys_now(); ping_recv(s); } else { //LWIP_DEBUGF( PING_DEBUG, ("ping: send ")); //ip_addr_debug_print(PING_DEBUG, &ping_target); //LWIP_DEBUGF( PING_DEBUG, (" - error\n")); rt_kprintf("ping: send "); ip_addr_debug_print1(&ping_target); rt_kprintf(" - error\n"); } sys_msleep(PING_DELAY); } }
/* http server */ int web_application_thread() { int sock, new_sd; struct sockaddr_in address, remote; socklen_t size; /* create a TCP socket */ if ((sock = lwip_socket(AF_INET, SOCK_STREAM, 0)) < 0) return 0; /* bind to port 80 at any interface */ address.sin_family = AF_INET; address.sin_port = htons(http_port); address.sin_addr.s_addr = INADDR_ANY; if (lwip_bind(sock, (struct sockaddr *) &address, sizeof(address)) < 0) return 0; /* listen for incoming connections */ lwip_listen(sock, 5); size = sizeof(remote); while (1) { sys_thread_t new_thread; new_sd = lwip_accept(sock, (struct sockaddr *) &remote, &size); /* spawn a separate handler for each request */ new_thread = sys_thread_new("httpd", (void (*)(void *)) process_http_request, (void *) new_sd, THREAD_STACKSIZE, DEFAULT_THREAD_PRIO); /* close connection if no new threads available */ if (new_thread == 0) { close(new_sd); } } return 0; }