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 } }
int close(int fd) { int ret; struct fdtab_entry *e = fdtab_get(fd); if (e->type == FDTAB_TYPE_AVAILABLE) { return -1; } if (e->type == FDTAB_TYPE_LWIP_SOCKET) { if(e->inherited) { // Perform shallow close on lwip so that it will not terminate // the TCP session printf("close: Inherited socket, not closing completely\n"); ret = 0; } else { ret = lwip_close(e->fd); if(ret < 0) { POSIXCOMPAT_DEBUG("[%d]error in lwip_close\n", disp_get_domain_id()); return -1; } } fdtab_free(fd); } else { ret = vfsfd_close(fd); } return ret; }
int http_session_close(struct http_session* session) { lwip_close(session->socket); rt_free(session); return 0; }
int uart_close(uart_socket_t *u) { if(!u){ uart_printf("uart_close(): u is NULL!\r\n"); return -1; } /* Close uart socket */ if(lwip_close(u->fd) == -1){ uart_printf("%s(): close uart failed!", __func__); } /* Delete uart_action task */ u->fd = -1; RtlUpSema(&u->action_sema); RtlMsleepOS(20); /* Free uart related semaphore */ RtlFreeSema(&u->action_sema); RtlFreeSema(&u->tx_sema); RtlFreeSema(&u->dma_tx_sema); /* Free serial */ serial_free(&u->sobj); RtlMfree((u8 *)u, sizeof(uart_socket_t)); return 0; }
/* * 关闭 socket */ static int socket_close(void *ctx, file_t *file) { privinfo_t *priv = ctx; reg_t reg; if (priv == NULL) { seterrno(EINVAL); return -1; } reg = interrupt_disable(); atomic_dec(dev_ref(file)); device_remove(file->ctx); file->ctx = NULL; lwip_close(priv->sock_fd); kfree(priv); interrupt_resume(reg); return 0; }
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 }
void MTD_FLASHMEM Socket::close() { if (m_socket > 0) { lwip_shutdown(m_socket, SHUT_RDWR); lwip_close(m_socket); m_socket = 0; } m_connected = false; }
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; }
BST_IP_ERR_T BST_IP_BsdClose( BST_FD_T fd, BST_ARG_T Arg ) { if( !BST_IP_IsBsdFdValid(fd) ) { BST_RLS_LOG("BST_IP_BsdClose fd is invalid"); return BST_IP_ERR_MEM; } return (BST_IP_ERR_T)lwip_close( fd.lFd ); }
void MTD_FLASHMEM Socket::close() { if (m_socket > 0) { lwip_close(m_socket); m_socket = 0; } m_connected = false; }
int socket_close(struct mySocket *sock) { if (sock->_sock_fd < 0) return -1; lwip_close(sock->_sock_fd); sock->_sock_fd = -1; return 0; }
int shoutcast_session_close(struct shoutcast_session* session) { lwip_close(session->socket); if (session->station_name != RT_NULL) rt_free(session->station_name); rt_free(session); return 0; }
void SoAd_SocketClose(uint16 sockNr) { uint16 i; switch (SocketAdminList[sockNr].SocketState) { case SOCKET_UDP_READY: case SOCKET_TCP_LISTENING: lwip_close(SocketAdminList[sockNr].SocketHandle); SocketAdminList[sockNr].SocketHandle = -1; SocketAdminList[sockNr].SocketState = SOCKET_INIT; break; case SOCKET_TCP_READY: lwip_close(SocketAdminList[sockNr].ConnectionHandle); SocketAdminList[sockNr].ConnectionHandle = -1; SocketAdminList[sockNr].RemoteIpAddress = inet_addr(SoAd_Config.SocketConnection[sockNr].SocketRemoteIpAddress); SocketAdminList[sockNr].RemotePort = htons(SoAd_Config.SocketConnection[sockNr].SocketRemotePort); SocketAdminList[sockNr].SocketState = SOCKET_TCP_LISTENING; for (i = 0; i < SOAD_SOCKET_COUNT; i++) { if (i == sockNr) continue; if (SocketAdminList[sockNr].SocketHandle == SocketAdminList[i].SocketHandle) { if (SocketAdminList[i].SocketState == SOCKET_TCP_LISTENING) { SocketAdminList[sockNr].SocketState = SOCKET_DUPLICATE; break; } } } break; default: /* This should never happen! */ DET_REPORTERROR(MODULE_ID_SOAD, 0, SOAD_SOCKET_CLOSE_ID, SOAD_E_SHALL_NOT_HAPPEN); break; } }
/* * Function: KillUdpSocket * Description: Kill a socket to an UDP port * Param: Handle to the socket */ void KillUdpSocket(int socket) { imask_t val; Irq_Save(val); for(int i=0;i<MAX_NUM_OF_SOCKETS;i++){ if(sockList[i] == socket){ sockList[i] = (-1); } } Irq_Restore(val); lwip_close(socket); }
void tcp_senddata(const char* url, int port, int length) { struct hostent *host; int sock, err, result, timeout, index; struct sockaddr_in server_addr; rt_uint8_t *buffer_ptr; /* 通过函数入口参数url获得host地址(如果是域名,会做域名解析) */ host = gethostbyname(url); /* 创建一个socket,类型是SOCKET_STREAM,TCP类型 */ if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) { /* 创建socket失败 */ rt_kprintf("Socket error\n"); return; } /* 神奇内存 */ buffer_ptr = rt_malloc(length); /* 构造发生数据 */ for (index = 0; index < length; index ++) buffer_ptr[index] = index & 0xff; timeout = 100; /* 设置发送超时时间100ms */ lwip_setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)); /* 初始化预连接的服务端地址 */ server_addr.sin_family = AF_INET; server_addr.sin_port = htons(port); server_addr.sin_addr = *((struct in_addr *)host->h_addr); rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero)); /* 连接到服务端 */ err = connect(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)); rt_kprintf("TCP thread connect error code: %d\n", err); while(1) { /* 发送数据到sock连接 */ result = send(sock, buffer_ptr, length, MSG_DONTWAIT); if(result == -1) //数据发送错误处理 { rt_kprintf("TCP thread send error: %d\n", result); lwip_close(sock); //关闭连接,重新创建连接 rt_thread_delay(10); if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) rt_kprintf("TCP Socket error:%d\n",sock); err = connect(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)); rt_kprintf("TCP thread connect error code: %d\n", err); } } }
static void clntudp_destroy(CLIENT *cl) { register struct cu_data *cu = (struct cu_data *) cl->cl_private; if (cu->cu_closeit) { lwip_close(cu->cu_sock); } XDR_DESTROY(&(cu->cu_outxdrs)); rt_free(cu); rt_free(cl); }
void udp_transpond_demo(void* parameter) { int sock; //int n, off; struct sockaddr_in server_addr; struct sockaddr_in remote_addr; socklen_t addr_len = sizeof(remote_addr); rt_uint8_t run_flag = 1; if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1){ rt_kprintf("Socket error\n"); goto __exit; } memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_port = htons(6000); server_addr.sin_addr.s_addr = htonl(INADDR_ANY); if (bind(sock, (void *)&server_addr, sizeof(server_addr)) == -1) { rt_kprintf("Bind error\n"); lwip_close(sock); run_flag = 0; } rt_kprintf("udp_recv_demo start.\n"); while (run_flag) { //基站发包流速控制在1.8ms,丢包率在0.1% recvfrom(sock, &data, sizeof(data), 0, (void *)&remote_addr, &addr_len); rf_send((void *)&data.id, (void *)&data.data, data.data_len); //如果需要检查ACK,则打开接收 if (data.rcv_len > 0 && rf_recv((void *)&data.data, data.rcv_len) == 0) sendto(sock, data.data, data.rcv_len, 0, (void *)&remote_addr, addr_len); } lwip_close(sock); __exit: rt_kprintf("udp_recv_demo end.\n"); }
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 telnetdata(int fn,int fd,int vdefd) { struct vdehiststat *vdehst=status[fn]; if (vdehist_term_to_mgmt(vdehst) != 0) { int termfd=vdehist_gettermfd(vdehst); int mgmtfd=vdehist_getmgmtfd(vdehst); delpfd(pfdsearch(termfd)); lwip_close(termfd); if (mgmtfd >= 0) { delpfd(mgmtfd); close(mgmtfd); } vdehist_free(vdehst); } }
//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); }
int32_t OsNetworkClose(THandle aHandle) { LOGFUNCIN(); int err = lwip_close ( HANDLE_TO_SOCKET(aHandle) ); if ( err ) { LOG("THINGS\n"); LOGFUNCOUT(); return -1; } LOGFUNCOUT(); OsNetworkHandle_Destroy(aHandle); 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); }
int accept(int s, struct sockaddr *addr, socklen_t *addrlen) { BT_HANDLE hSocket = (BT_HANDLE)s; int new_socket = lwip_accept(hSocket->socket, addr, addrlen); if(new_socket) { BT_ERROR Error; BT_HANDLE h = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), &Error); if(!h) { lwip_close(new_socket); return 0; } h->socket = new_socket; return (int)h; } return 0; }
int close(int fd) { int ret; struct fdtab_entry *e = fdtab_get(fd); if (e->type == FDTAB_TYPE_AVAILABLE) { return -1; } // Might need to remove from epoll list if(e->epoll_fd != -1) { ret = epoll_ctl(e->epoll_fd, EPOLL_CTL_DEL, fd, NULL); assert(ret == 0); } switch(e->type) { case FDTAB_TYPE_LWIP_SOCKET: if (e->inherited) { // Perform shallow close on lwip so that it will not terminate // the TCP session printf("close: Inherited socket, not closing completely\n"); ret = 0; } else { ret = lwip_close(e->fd); if(ret < 0) { POSIXCOMPAT_DEBUG("[%d]error in lwip_close\n", disp_get_domain_id()); return -1; } } fdtab_free(fd); break; case FDTAB_TYPE_PTM: ret = ptm_close(fd); break; case FDTAB_TYPE_PTS: ret = pts_close(fd); break; default: ret = vfsfd_close(fd); } return ret; }
/** 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); }
void rau_app_tcp_connect_server(void) { struct hostent *host; struct sockaddr_in server_addr; int ncount=0; host = gethostbyname(SERVER_URL); while(1) { if(ncount>=5) { hlog("尝试联接5次失败\n"); return; } if ((RauSock = socket(AF_INET, SOCK_STREAM, 0)) == -1) { hlog("RauSocket create error\n"); return; } server_addr.sin_family = AF_INET; server_addr.sin_port = htons(SERVER_PORT); server_addr.sin_addr = *((struct in_addr *)host->h_addr); rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero)); if (connect(RauSock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1) { hlog("Connect fail!\n"); lwip_close(RauSock); rt_thread_delay(100); ncount++; continue; } else { hlog("联接成功开始登陆请求\n"); rau_app_client_login(RauSock); break; } } }