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); } } }
/* * 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; }
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); }
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 bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) { int sock = socket_for_fd(sockfd); int ret = lwip_bind(sock, addr, addrlen); if (ret == 0) mark_connected(sockfd, 1); return ret; }
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; }
/** Bind to a port to listen for incoming data. Before you can receive UDP data, you need to bind to a port. If you're only going to be writing, you don't need to bother binding. @param socket The socket obtained from udpOpen() @param port An integer specifying the port to bind to. @return True on success, false on failure. \b Example \code int sock = udpOpen(); // create a new socket if (udpBind(sock, 10000) == true) { // then bind to port 10000 // we're successfully bound, and ready to read } \endcode */ bool udpBind(int socket, int port) { struct sockaddr_in sa = { .sin_family = AF_INET, .sin_addr.s_addr = INADDR_ANY, .sin_port = htons(port) }; return lwip_bind(socket, (const struct sockaddr *)&sa, sizeof(sa)) == 0; }
int LWIP_SOCKETS_Driver::Bind(SOCK_SOCKET socket, const SOCK_sockaddr* address, int addressLen) { NATIVE_PROFILE_PAL_NETWORK(); sockaddr_in addr; SOCK_SOCKADDR_TO_SOCKADDR(address, addr, &addressLen); return lwip_bind(socket, (sockaddr*)&addr, addressLen); }
int zts_bind(int fd, const struct sockaddr *addr, socklen_t addrlen) { if (!addr) { 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_bind(fd, addr, addrlen); }
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); }
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 }
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 } }
BST_IP_ERR_T BST_IP_BsdBind( BST_FD_T fd, BST_UINT16 usPort ) { struct sockaddr_in stLocalAddr; if( !BST_IP_IsBsdFdValid(fd) ) { return BST_IP_ERR_MEM; } stLocalAddr.sin_len = BST_OS_SIZEOF(stLocalAddr); stLocalAddr.sin_family = AF_INET; stLocalAddr.sin_port = PP_HTONS( usPort ); stLocalAddr.sin_addr.s_addr = BST_IP_ADDRESS_ANY; return (BST_IP_ERR_T)lwip_bind( fd.lFd, ( struct sockaddr *)&stLocalAddr, BST_OS_SIZEOF(stLocalAddr) ); }
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); }
/* ------------------------------------------------------------------------------------------------------ * 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); } }
int32_t OsNetworkBind(THandle aHandle, TIpAddress aAddress, uint32_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; // this is already stored in network order int err = lwip_bind ( HANDLE_TO_SOCKET(aHandle), (struct sockaddr*) &s, sizeof(s) ); if ( err == EADDRINUSE ) return -2; LOGFUNCOUT(); return err; }
/* 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; }
/* http server */ int web_application_thread() { int sock, new_sd; struct sockaddr_in address, remote; int size; /* create a TCP socket */ if ((sock = lwip_socket(AF_INET, SOCK_STREAM, 0)) < 0) { #ifdef OS_IS_FREERTOS vTaskDelete(NULL); #endif return -1; } /* 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) { #ifdef OS_IS_FREERTOS vTaskDelete(NULL); #endif return -1; } /* listen for incoming connections */ lwip_listen(sock, 0); size = sizeof(remote); while (1) { new_sd = lwip_accept(sock, (struct sockaddr *)&remote, (socklen_t *)&size); /* spawn a separate handler for each request */ process_http_request((void*)new_sd); //sys_thread_new("httpd", (void(*)(void*))process_http_request, (void*)new_sd, // THREAD_STACKSIZE, // DEFAULT_THREAD_PRIO); } return 0; }
static int OsNetworkHandle_Initialise(OsNetworkHandle* aHandle, int aSocket) { LOGFUNC(); aHandle->iSocket = aSocket; #if INT_ENABLED int ih = lwip_socket(AF_INET, SOCK_DGRAM, 0); if ( ih < 0 ) { LOG("%s failed with %d\n", __FUNCTION__, errno); return -1; } struct sockaddr_in s; s.sin_family = AF_INET; s.sin_port = htons( 10000 + (short) aSocket ); // relate port to fd s.sin_addr.s_addr = IPADDR_LOOPBACK; // localhost int err = lwip_bind ( ih, (struct sockaddr*) &s, sizeof(s) ); if ( err < 0 ) { lwip_close(ih); return -1; } aHandle->iIntSocket = ih; #endif LOG("Created OsNetworkHandle %d:%d\n", aHandle->iSocket, aHandle->iIntSocket); return 0; }
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
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) { struct fdtab_entry *e = fdtab_get(sockfd); switch(e->type) { case FDTAB_TYPE_UNIX_SOCKET: assert(addrlen >= sizeof(struct sockaddr_un)); assert(addr->sa_family == AF_UNIX); struct _unix_socket *us = e->handle; memcpy(&us->sockaddr, addr, sizeof(struct sockaddr_un)); POSIXCOMPAT_DEBUG("bind(%d, %p (%s), %u)\n", sockfd, addr, us->sockaddr.sun_path, addrlen); // XXX: Should fail if file already exists // Create socket file errval_t err = vfs_create(us->sockaddr.sun_path, &us->vfs_handle); if(err_is_fail(err)) { DEBUG_ERR(err, "vfs_create"); return -1; } break; case FDTAB_TYPE_LWIP_SOCKET: lwip_mutex_lock(); int ret = lwip_bind(e->fd, addr, addrlen); lwip_mutex_unlock(); return ret; default: return -1; } return 0; }
int Socket::BindToAddr(const std::string& addr, const std::string& port) { struct sockaddr_in my_addr; memset(&my_addr, 0, sizeof(struct sockaddr_in)); my_addr.sin_family = AF_INET; my_addr.sin_addr.s_addr = INADDR_ANY; my_addr.sin_port = htons(atoi(port.c_str())); if (addr != "ANY" && inet_addr(addr.c_str()) != INADDR_NONE) { my_addr.sin_addr.s_addr = inet_addr(addr.c_str()); } log(LOG_NOTICE) << "binding to " << addr << " -> " << inet_ntoa(my_addr.sin_addr) << " port " << port; if (lwip_bind(socket_->fd, (struct sockaddr *) &my_addr, sizeof(my_addr)) < 0) { log(LOG_EMERG) << "Error on bind!"; return -1; } return 0; }
//-------------------------------------------------------------- void serverThread(void *args) // Server thread: Handle Client & packets { int tcp_socket; struct sockaddr_in peer; int peerlen, r, err; conn_retry: peer.sin_family = AF_INET; peer.sin_port = htons(SERVER_TCP_PORT); peer.sin_addr.s_addr = htonl(INADDR_ANY); #ifdef _NETLOG netlog_send("%s: server init starting...\n", MODNAME); #endif // create the socket tcp_socket = lwip_socket(AF_INET, SOCK_STREAM, 0); if (tcp_socket < 0) { err = -1; goto error; } #ifdef _NETLOG netlog_send("%s: server socket created.\n", MODNAME); #endif r = lwip_bind(tcp_socket,(struct sockaddr *)&peer,sizeof(peer)); if (r < 0) { err = -2; goto error; } #ifdef _NETLOG netlog_send("%s: bind OK.\n", MODNAME); #endif r = lwip_listen(tcp_socket, 3); if (r < 0) { err = -3; goto error; } #ifdef _NETLOG netlog_send("%s: server ready!\n", MODNAME); #endif while(1) { peerlen = sizeof(peer); r = lwip_accept(tcp_socket,(struct sockaddr *)&peer, &peerlen); if (r < 0) { err = -4; goto error; } client_socket = r; r = handleClient(client_socket); if (r < 0) { lwip_close(client_socket); #ifdef _NETLOG netlog_send("%s: Client Connection closed - error %d\n", MODNAME, r); #endif } } error: lwip_close(client_socket); #ifdef _NETLOG netlog_send("%s: Client Connection closed - error %d\n", MODNAME, err); #endif goto conn_retry; }
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); }
int OTAClass::beginLocal(uint16_t port, bool reboot_when_success) { int ret = -1; // variables for image processing flash_t flash; uint32_t img2_addr, img2_len, img3_addr, img3_len; uint32_t img_upper_bound; uint32_t checksum = 0; uint32_t signature1, signature2; // variables for network processing int server_socket = -1; int client_socket = -1; struct sockaddr_in localHost; struct sockaddr_in client_addr; int socket_error, socket_timeout; socklen_t optlen; // variables for OTA unsigned char *buf = NULL; int read_bytes = 0, processed_len; uint32_t file_info[3]; uint32_t ota_len; uint32_t ota_blk_size = 0; int i, n; do { sync_ota_addr(); get_image_info(&img2_addr, &img2_len, &img3_addr, &img3_len); img_upper_bound = img2_addr + 0x10 + img2_len; // image2 base + header + len if (img3_len > 0) { img_upper_bound += 0x10 + img3_len; // image 3 header + len } if ((ota_addr & 0xfff != 0) || (ota_addr == ~0x0) || (ota_addr < img_upper_bound)) { OTA_PRINTF("Invalid OTA address: %08X\r\n", ota_addr); break; } buf = (unsigned char *) malloc (BUFSIZE); if (buf == NULL) { OTA_PRINTF("Fail to allocate memory\r\n"); break; } server_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (server_socket < 0) { OTA_PRINTF("Fail to create socket\r\n"); break; } memset(&localHost, 0, sizeof(localHost)); localHost.sin_family = AF_INET; localHost.sin_port = htons(port); localHost.sin_addr.s_addr = INADDR_ANY; if (lwip_bind(server_socket, (struct sockaddr *)&localHost, sizeof(localHost)) < 0) { OTA_PRINTF("Bind fail\r\n"); break; } if (lwip_listen(server_socket , 1) < 0) { OTA_PRINTF("Listen fail\r\n"); break; } OTA_PRINTF("Wait for client\r\n"); n = (int) sizeof( client_addr ); memset(&client_addr, 0, sizeof(client_addr)); client_socket = lwip_accept(server_socket, (struct sockaddr *) &client_addr, (socklen_t *)&n); OTA_PRINTF("Client connected. IP:%s port:%d\r\n\r\n", inet_ntoa(client_addr.sin_addr.s_addr), ntohs(client_addr.sin_port)); socket_timeout = DEFAULT_IMAGE_DOWNLOAD_TIMEOUT; lwip_setsockopt(client_socket, SOL_SOCKET, SO_RCVTIMEO, &socket_timeout, sizeof(socket_timeout)); OTA_PRINTF("Read OTA info...\r\n"); read_bytes = read(client_socket, file_info, sizeof(file_info)); if (read_bytes < 0) { OTA_PRINTF("Fail to read OTA info\r\n"); break; } if (file_info[2] == 0) { OTA_PRINTF("OTA image len is 0\r\n"); break; } ota_len = file_info[2]; ota_blk_size = ((ota_len - 1) / 4096) + 1; for (i = 0; i < ota_blk_size; i++) { flash_erase_sector(&flash, ota_addr + i * 4096); } OTA_PRINTF("Start download\r\n"); // Now download OTA image processed_len = 0; while( processed_len < ota_len ) { memset(buf, 0, BUFSIZE); read_bytes = read(client_socket, buf, BUFSIZE); if (read_bytes < 0) { optlen = sizeof(socket_error); getsockopt(client_socket, SOL_SOCKET, SO_ERROR, &socket_error, &optlen); if (socket_error == EAGAIN) { // socket timeout } break; } if (flash_stream_write(&flash, ota_addr + processed_len, read_bytes, buf) < 0) { OTA_PRINTF("Write sector fail\r\n"); break; } processed_len += read_bytes; } if (processed_len != ota_len) { OTA_PRINTF("Download fail\r\n"); break; } // Read OTA image from flash and calculate checksum checksum = processed_len = 0; while ( processed_len < ota_len ) { n = (processed_len + BUFSIZE < ota_len) ? BUFSIZE : (ota_len - processed_len); flash_stream_read(&flash, ota_addr + processed_len, n, buf); for (i=0; i<n; i++) checksum += (buf[i] & 0xFF); processed_len += n; } if (checksum != file_info[0]) { OTA_PRINTF("Bad checksum:%d expected:%d\r\n", checksum, file_info[0]); break; } // Put signature for OTA image flash_write_word(&flash, ota_addr + 8, 0x35393138); flash_write_word(&flash, ota_addr + 12, 0x31313738); flash_read_word(&flash, ota_addr + 8, &signature1); flash_read_word(&flash, ota_addr + 12, &signature2); if (signature1 != 0x35393138 || signature2 != 0x31313738) { OTA_PRINTF("Put signature fail\r\n"); break; } // Mark image 2 as old image flash_write_word(&flash, img2_addr + 8, 0x35393130); ret = 0; OTA_PRINTF("OTA success\r\n"); } while (0); if (buf != NULL) { free(buf); } if (server_socket >= 0) { close(server_socket); } if (client_socket >= 0) { close(client_socket); } if (ret < 0) { OTA_PRINTF("OTA fail\r\n"); } else { if (reboot_when_success) { sys_reset(); } } return ret; }
/** * 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); } } }
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 ); }
/************************************************************** * void chargen_thread(void *arg) * * chargen task. This server will wait for connections on well * known TCP port number: 19. For every connection, the server will * write as much data as possible to the tcp port. **************************************************************/ static void chargen_thread(void *arg) { int listenfd; struct sockaddr_in chargen_saddr; fd_set readset; fd_set writeset; int i, maxfdp1; struct charcb *p_charcb; /* First acquire our socket for listening for connections */ listenfd = lwip_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); LWIP_ASSERT("chargen_thread(): Socket create failed.", listenfd >= 0); memset(&chargen_saddr, 0, sizeof(chargen_saddr)); chargen_saddr.sin_family = AF_INET; chargen_saddr.sin_addr.s_addr = htonl(INADDR_ANY); chargen_saddr.sin_port = htons(19); // Chargen server port if (lwip_bind(listenfd, (struct sockaddr *) &chargen_saddr, sizeof(chargen_saddr)) == -1) LWIP_ASSERT("chargen_thread(): Socket bind failed.", 0); /* Put socket into listening mode */ if (lwip_listen(listenfd, MAX_SERV) == -1) LWIP_ASSERT("chargen_thread(): Listen failed.", 0); /* Wait forever for network input: This could be connections or data */ for (;;) { maxfdp1 = listenfd+1; /* Determine what sockets need to be in readset */ FD_ZERO(&readset); FD_ZERO(&writeset); FD_SET(listenfd, &readset); for (p_charcb = charcb_list; p_charcb; p_charcb = p_charcb->next) { if (maxfdp1 < p_charcb->socket + 1) maxfdp1 = p_charcb->socket + 1; FD_SET(p_charcb->socket, &readset); FD_SET(p_charcb->socket, &writeset); } /* Wait for data or a new connection */ i = lwip_select(maxfdp1, &readset, &writeset, 0, 0); if (i == 0) continue; /* At least one descriptor is ready */ if (FD_ISSET(listenfd, &readset)) { /* We have a new connection request!!! */ /* Lets create a new control block */ p_charcb = (struct charcb *)rt_calloc(1, sizeof(struct charcb)); if (p_charcb) { p_charcb->socket = lwip_accept(listenfd, (struct sockaddr *) &p_charcb->cliaddr, &p_charcb->clilen); if (p_charcb->socket < 0) rt_free(p_charcb); else { /* Keep this tecb in our list */ p_charcb->next = charcb_list; charcb_list = p_charcb; p_charcb->nextchar = 0x21; } } else { /* No memory to accept connection. Just accept and then close */ int sock; struct sockaddr cliaddr; socklen_t clilen; sock = lwip_accept(listenfd, &cliaddr, &clilen); if (sock >= 0) lwip_close(sock); } } /* Go through list of connected clients and process data */ for (p_charcb = charcb_list; p_charcb; p_charcb = p_charcb->next) { if (FD_ISSET(p_charcb->socket, &readset)) { /* This socket is ready for reading. This could be because someone typed * some characters or it could be because the socket is now closed. Try reading * some data to see. */ if (do_read(p_charcb) < 0) break; } if (FD_ISSET(p_charcb->socket, &writeset)) { char line[80]; char setchar = p_charcb->nextchar; for( i = 0; i < 59; i++) { line[i] = setchar; if (++setchar == 0x7f) setchar = 0x21; } line[i] = 0; strcat(line, "\n\r"); if (lwip_write(p_charcb->socket, line, strlen(line)) < 0) { close_chargen(p_charcb); break; } if (++p_charcb->nextchar == 0x7f) p_charcb->nextchar = 0x21; } } } }
/* ------------------------------------------------------------------------------------------------------ * sockex_selects() * * Description : socket selects test. * * Argument(s) : none. * */ void sockex_selects(void *arg) { int sock_fd, new_fd; struct sockaddr_in server_addr; struct sockaddr_in client_addr; socklen_t sin_size; int yes; INT8U buf[BUF_SIZE]; int ret; int i; fd_set fdsr; /* Create file descriptor.*/ int maxsock; struct timeval tv; conn_amount = 0; LWIP_UNUSED_ARG(arg); sock_fd = lwip_socket(AF_INET, SOCK_STREAM, 0); yes = 1; ret = lwip_setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)); if(ret == -1) { return; } memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_len = sizeof(server_addr); server_addr.sin_port = PP_HTONS(SOCK_HOSR_PORT); server_addr.sin_addr.s_addr = lwIPLocalIPAddrGet(); /* IP_ADDR_ANY is '0.0.0.0'.*/ lwip_bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)); lwip_listen(sock_fd, BACKLOG + 1); /* MAX TCP client is BACKLOG.*/ sin_size = sizeof(client_addr); maxsock = sock_fd; while(1) { FD_ZERO(&fdsr); /* Initialize file descriptor set.*/ FD_SET(sock_fd, &fdsr); tv.tv_sec = 10; /* Timeout setting.*/ tv.tv_usec = 0; for (i = 0; i < BACKLOG; i++) /* Add active connection to fd set.*/ { if (fd_A[i] != 0) { FD_SET(fd_A[i], &fdsr); } } ret = lwip_select(maxsock + 1, &fdsr, NULL, NULL, &tv); if(ret < 0) { break; } else if(ret == 0) { continue; } for (i = 0; i < conn_amount; i++) /* Check every fd in the set.*/ { if (FD_ISSET(fd_A[i], &fdsr)) { int opt = 100; /* set recv timeout (100 ms) */ lwip_setsockopt(fd_A[i], SOL_SOCKET, SO_RCVTIMEO, &opt, sizeof(int)); ret = lwip_read(fd_A[i], buf, 8); if (ret <= 0) { // lwip_close(fd_A[i]); // FD_CLR(fd_A[i], &fdsr); // fd_A[i] = 0; } else /* receive data.*/ { if((buf[0] == 'C')&&(buf[1] == 'o')) { // address_t addr; // INT8U mac[8] = {0x00, 0x12, 0x4B, 0x00, 0x01, 0xC0, 0xB7, 0xE0}; // addr.mode = LONG_ADDR; // utilReverseBuf(mac, 8); // memcpy(addr.long_addr, mac, 8); // mac_tx_handle(&addr, &buf[7], 1, MAC_DATA); } if (ret < BUF_SIZE) memset(&buf[ret], '\0', 1); } } } if(FD_ISSET(sock_fd, &fdsr)) /* Check whether a new connection comes.*/ { new_fd = lwip_accept(sock_fd, (struct sockaddr *)&client_addr, &sin_size); if(new_fd <= 0) { continue; } // lwip_send(new_fd, "con", 4, 0); if(conn_amount < BACKLOG) /* Add to fd queue.*/ { fd_A[conn_amount++] = new_fd; if(new_fd > maxsock) maxsock = new_fd; } else { // conn_amount = 0; lwip_close(fd_A[conn_amount-1]); fd_A[conn_amount-1] = new_fd; if(new_fd > maxsock) maxsock = new_fd; // lwip_send(new_fd, "bye", 4, 0); // lwip_close(new_fd); /* Close larger than 5 socket.*/ } } // for (i = 0; i < BACKLOG; i++) /* Close other connections.*/ // { // if (fd_A[i] != 0) { // lwip_close(fd_A[i]); // } // } } }