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