void net_poll_status_procedure()
{
if(net_link_status==NETDEV_LINKED)
{
if(dhcp_new_ip_flag==0)//dhcp 无效
{
net_ip_flag=0;//ip无效
if(net_socket_status!=SOCKET_CLOSED)
{
net_socket_close();//关闭net app 重新开始
}
}
else
{
if(dhcp_new_ip_flag!=net_ip_flag)//ip需要更新
{
net_socket_param_refresh();//更新ip等资源
net_ip_flag=dhcp_new_ip_flag;//net ip
if(net_socket_status!=SOCKET_CLOSED)
{
net_socket_close();//关闭net app 重新开始
}
}
}
/***********************/
if(net_socket_status==SOCKET_UDP)//-------------------
{
//todo
}
if(net_socket_status==SOCKET_INIT)//tcp init
{
net_socket_connect();
}
if(net_socket_status==SOCKET_CLOSED || net_socket_status==SOCKET_CLOSE_WAIT)//如果netsocket 是关闭的或者半关闭重新初始化连接
{
if(dhcp_new_ip_flag==net_ip_flag && net_ip_flag!=0 )//如果ip有效
{
net_socket_init();
net_socket_open();//打开当前net socket
}
}
if(net_ip_comflict)
{
net_ip_comflict=FALSE;//使IP冲突无效
net_ip_flag=0;//使ip无效
hal_net_device_software_reset();//如果ip冲突 就重启设备
}
}
else//断开link 就关闭net socket
{
if(net_socket_status!=SOCKET_CLOSED)//-----------------
{
net_ip_comflict=FALSE;//使IP冲突无效
net_ip_flag=0;//使ip无效
net_socket_close();//关闭当前net socket
}
}
}
void en_socket_close(int fd, int fd1) {
if (fd != -1) {
net_socket_close(fd);
}
if (fd1 != -1) {
net_socket_close(fd1);
}
}
void loax_server_delete(loax_server_t** _self)
{
assert(_self);
loax_server_t* self = *_self;
if(self)
{
LOGD("debug");
net_socket_close(&self->socket_event);
net_socket_close(&self->socket_render);
free(self);
*_self = NULL;
g_server = NULL;
}
}
void net_ep_close_i(net_ep_t ep, net_ep_event_t ev) {
assert(ep);
assert(ev == net_ep_event_close_by_user
|| ev == net_ep_event_close_by_peer
|| ev == net_ep_event_close_by_error
|| ev == net_ep_event_close_by_shutdown);
if (ep->m_fd < 0) return;
#ifdef _MSC_VER
//if (ep->m_type = net_ep_socket) {
net_socket_close(&ep->m_fd, ep->m_mgr->m_em);
//}
//else {
// CPE_ERROR(
// ep->m_mgr->m_em, "net_ep_close: close fail, errno=%d (%s)",
// cpe_sock_errno(), cpe_sock_errstr(cpe_sock_errno()));
//}
#else
if (close(ep->m_fd) != 0) {
CPE_ERROR(
ep->m_mgr->m_em, "net_ep_close: close fail, errno=%d (%s)",
cpe_sock_errno(), cpe_sock_errstr(cpe_sock_errno()));
}
#endif
if (net_ep_calc_ev_events(ep)) {
ev_io_stop(ep->m_mgr->m_ev_loop, &ep->m_watcher);
}
ep->m_fd = -1;
if (ep->m_process_fun) ep->m_process_fun(ep, ep->m_process_ctx, ev);
}
static void net_socket_int_event_callback(uint8 new_event)
{
app_write_string("\r\n执行net socket中断事件回调函数!");
if(new_event&SEND_OK)
{
app_write_string("\r\n执行net socket send ok!");
}
if(new_event&DIS_CONN)
{
app_write_string("\r\nnet tcb disconnect!");
if(net_socket_status!=SOCKET_CLOSED)
{
net_socket_close();//关闭net app 重新开始
}
}
if(new_event&CONNECTED)
{
app_write_string("\r\nnet tcb connected!");
}
if(new_event&TIME_OUT)
{
app_write_string("\r\nnet 建立连接或者数据发送超时!");
/*
if(net_socket_status!=SOCKET_CLOSED)
{
net_socket_close();//关闭net app 重新开始
}
*/
}
}
void en_socket_stream_create (EIF_INTEGER *a_fd, EIF_INTEGER *a_fd1) {
SOCKET fd, fd1;
EIF_NET_INITIALIZE;
fd = check_socket_bounds(socket(AF_INET, SOCK_STREAM, 0));
if (fd == INVALID_SOCKET) {
*a_fd = -1;
eif_net_check ((int)fd);
return;
} else {
/* Set socket attribute so it is not passed to any child process */
SetHandleInformation((HANDLE)fd, HANDLE_FLAG_INHERIT, FALSE);
*a_fd = (EIF_INTEGER) fd;
}
if (en_ipv6_available()) {
fd1 = check_socket_bounds(socket(AF_INET6, SOCK_STREAM, 0));
if (fd1 == INVALID_SOCKET) {
*a_fd = -1;
*a_fd1 = -1;
net_socket_close((int)fd);
eif_net_check ((int)fd1);
return;
} else {
/* Set socket attribute so it is not passed to any child process */
SetHandleInformation((HANDLE)fd1, HANDLE_FLAG_INHERIT, FALSE);
*a_fd1 = (EIF_INTEGER) fd1;
}
} else {
*a_fd1 = -1;
}
}
void
handle_write(struct net_service* service, int ret, int err, struct write_session* wsession, size_t bytes)
{
struct net_session* session;
unsigned short index;
unsigned int events;
ffid_vtype fd;
if(!wsession)
{
return;
}
fd = wsession->id;
if(fd == 0)
{
release_write_session(wsession);
return;
}
index = ffid_index(service->socket_ids, fd);
net_lock(&service->session_lock[index]);
session = service->sessions[index];
wsession->op = OP_NET_NONE;
if(ret && bytes >= 0)
{
send_buff_consume(wsession->sbuff, bytes);
}
if(!session || session->id != fd)
{
if(ret && wsession->send_rest && post_rest_write(service, wsession) > 0)
{
net_unlock(&service->session_lock[index]);
return;
}
release_write_session(wsession);
net_unlock(&service->session_lock[index]);
return;
}
ret = post_write(service, session);
events = 0;
if(ret < 0)
{
events |= Eve_Error;
print_error();
}
if (!events || push_queue(service, session, events) > 0)
{
net_unlock(&service->session_lock[index]);
return;
}
net_unlock(&service->session_lock[index]);
net_socket_close(service, fd, 0);
}
loax_server_t* loax_server_new(loax_server_cmd_fn cmd_fn)
{
assert(cmd_fn);
LOGD("debug");
loax_server_t* self = (loax_server_t*) malloc(sizeof(loax_server_t));
if(self == NULL)
{
LOGE("malloc failed");
return NULL;
}
self->w = 0;
self->h = 0;
// JNI callback(s)
self->cmd_fn = cmd_fn;
self->socket_render = net_socket_connect("localhost", "6120", NET_SOCKET_TCP_NODELAY);
if(self->socket_render == NULL)
{
goto fail_render;
}
int retry = 0;
while(1)
{
self->socket_event = net_socket_connect("localhost", "6121", NET_SOCKET_TCP_BUFFERED);
if(self->socket_event)
{
break;
}
else if(retry == 3)
{
LOGE("aborted after retry=%i", retry);
goto fail_event;
}
// event socket can fail if server connects too fast
++retry;
LOGW("retry=%i", retry);
usleep(50000*retry);
}
// success
g_server = self; // TODO
return self;
// failure
fail_event:
net_socket_close(&self->socket_render);
fail_render:
free(self);
return NULL;
}
void en_socket_stream_listen (EIF_INTEGER *a_fd, EIF_INTEGER *a_fd1, EIF_POINTER sockaddr, EIF_INTEGER count) {
int fd, fd1;
SOCKETADDRESS *addr;
int ipv6_supported;
int res;
EIF_NET_INITIALIZE;
addr = (SOCKETADDRESS*) sockaddr;
ipv6_supported = en_ipv6_available();
fd = *a_fd;
if (addr->him.sa_family == AF_INET || NET_IN6ADDR_ISANY(&addr->him6) || NET_IN6ADDR_ISLOOPBACK(&addr->him6)) {
/* listen on v4 */
if ((res=listen(fd, count)) == -1) {
eif_net_check(res);
}
} else {
net_socket_close(fd);
*a_fd = -1;
}
if (ipv6_supported) {
fd1 = *a_fd1;
if ((addr->him.sa_family == AF_INET6) || (addr->him4.sin_addr.s_addr == INADDR_ANY) || (addr->him4.sin_addr.s_addr == htonl (INADDR_LOOPBACK))) {
/* listen on v6 */
if ((res=listen(fd1, count)) == -1) {
eif_net_check(res);
}
} else {
net_socket_close(fd1);
*a_fd1 = -1;
}
}
}
int main(int argc, char** argv)
{
struct net_service* ns;
pthread_t ts[2];
struct net_event events[64];
struct buff_pool* pool;
int i;
int ret;
void* status;
unsigned int e;
struct net_config cfg;
int count;
param_type parm;
char bf[1024];
srand((unsigned)time(NULL));
pool = buff_pool_create(1024, 64);
if(!pool)
{
printf("buff_pool_create faild\n");
exit(-1);
}
ns = net_create(1024 );
if(!ns)
{
printf("open net_service faild\n");
exit(-1);
}
for(i = 0; i < (int)(sizeof(ts)/sizeof(ts[0])); ++i)
{
pthread_create(ts + i, 0, thread_run, ns);
}
count = 0;
while(1)
{
ret = net_queue(ns, events, sizeof(events)/sizeof(events[0]));
if(ret < 0)
{
break;
}
if(ret == 0)
{
net_service_sleep(10);
++count;
if(!net_connect(ns, "127.0.0.1", 9522))
{
// printf("connect error\n");
fflush(stdout);
}
if(count % 100 == 0)
{
printf("-------------------------------- %d %d %d\n", net_socket_size(ns), msg_send_count, msg_recv_count);
fflush(stdout);
}
continue;
}
for(i = 0; i < ret; ++i)
{
e = events[i].events;
if(e & Eve_Error)
{
printf("socket error %d %d\n", events[i].nd, e);
fflush(stdout);
net_socket_close(ns, events[i].nd, 0);
continue;
}
if(e & Eve_Connect)
{
cfg.enByte = enByte16;
cfg.read_buff_cnt = 8;
cfg.write_buff_cnt = 8;
cfg.pool = pool;
if(net_socket_cfg(ns, events[i].nd, &cfg) < 0)
{
net_socket_close(ns, events[i].nd, 0);
}
else
{
// add a connect
parm = 1;
net_socket_ctl(ns, events[i].nd , &parm);
sprintf(bf, " s %d do some read write op %d %d\n", net_socket_size(ns), rand(), rand());
if(net_socket_write(ns, events[i].nd, bf, strlen(bf) + 1) > 0)
{
++msg_send_count;
}
}
}
if(e & Eve_Read)
{
parm = net_socket_ctl(ns, events[i].nd, 0);
if((rand() % 20480) < ((int)parm / 256) )
{
net_socket_close(ns, events[i].nd, 1);
}
else
{
++parm;
net_socket_ctl(ns, events[i].nd, &parm);
handle_client_read(ns, events[i].nd);
}
}
}
}
for(i = 0; i < (int)(sizeof(ts)/sizeof(ts[0])); ++i)
{
pthread_join(ts[i], &status);
}
net_close(ns);
buff_pool_release(pool);
return 0;
}
NET_API net_socket
net_connect(struct net_service* service, const char* ip, unsigned short port)
{
int connect_socket;
struct sockaddr_in connect_addr;
struct epoll_event ev;
struct net_session* session;
int ret;
ffid_vtype id;
connect_socket = create_socket();
if(connect_socket < 0)
{
return 0;
}
ctl_socket_async(connect_socket);
session = create_net_session();
if(!session)
{
net_close_fd(connect_socket);
return 0;
}
session->fd = connect_socket;
session->connect_flag = 1;
id = add_net_session(service, session);
if(!id)
{
release_net_session(session);
net_close_fd(connect_socket);
return 0;
}
memset(&connect_addr, 0, sizeof(connect_addr));
connect_addr.sin_family = AF_INET;
connect_addr.sin_addr.s_addr = inet_addr(ip);
connect_addr.sin_port = htons(port);
ret = connect(connect_socket, (struct sockaddr*)&connect_addr, sizeof(connect_addr));
if(ret < 0)
{
ret = net_get_error();
if(ret != EINPROGRESS)
{
net_socket_close_print_error();
net_socket_close(service, id, 0);
return 0;
}
}
memset(&ev, 0, sizeof(ev));
ev.events = EPOLLIN | EPOLLOUT | EPOLLET;
ev.data.u64 = session->id;
if((ret = epoll_ctl(service->net_service_fd, EPOLL_CTL_ADD, connect_socket, &ev)))
{
ret = net_get_error();
net_socket_close_print_error();
net_socket_close(service, id, 0);
return 0;
}
return id;
}
NET_API net_socket
net_listen(struct net_service* service, unsigned short port, unsigned short listen_cnt)
{
int listen_socket;
int opt;
struct sockaddr_in listen_addr;
struct epoll_event ev;
struct net_session* session;
int ret;
ffid_vtype id;
listen_socket = create_socket();
if(listen_socket < 0)
{
// printf("listen error step 0 %d\n", ret);
// perror("info:");
return 0;
}
opt = 1;
// listen socket reuse
setsockopt(listen_socket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
ctl_socket_async(listen_socket);
listen_addr.sin_family = AF_INET;
listen_addr.sin_port = htons(port);
listen_addr.sin_addr.s_addr = htonl(INADDR_ANY);
if((ret = bind(listen_socket, (struct sockaddr*)&listen_addr, sizeof(listen_addr))))
{
ret = net_get_error();
// printf("listen error step 1 %d\n", ret);
// perror("info:");
net_close_fd(listen_socket);
return 0;
}
if((ret = listen(listen_socket, listen_cnt)))
{
ret = net_get_error();
// printf("listen error step 2 %d\n", ret);
// perror("info:");
net_close_fd(listen_socket);
return 0;
}
session = create_net_session();
if(!session)
{
// printf("listen error step 3\n");
net_close_fd(listen_socket);
return 0;
}
session->fd = listen_socket;
session->lsession = create_listen_session(service, port, listen_cnt);
if(!session->lsession)
{
// printf("listen error step 4 \n");
release_net_session(session);
net_close_fd(listen_socket);
return 0;
}
id = add_net_session(service, session);
if(!id)
{
// printf("listen error step 5 \n");
release_net_session(session);
net_close_fd(listen_socket);
return 0;
}
memset(&ev, 0, sizeof(ev));
ev.events = EPOLLIN | EPOLLOUT | EPOLLET;
ev.data.u64 = session->id;
if((ret = epoll_ctl(service->net_service_fd, EPOLL_CTL_ADD, listen_socket, &ev)))
{
ret = net_get_error();
// printf("listen error step 6 %d\n", ret);
// perror("info:");
net_socket_close_print_error();
net_socket_close(service, id, 0);
return 0;
}
return id;
}
NET_API net_socket
net_connect(struct net_service* service, const char* ip, unsigned short port)
{
NET_SOCKET s;
struct sockaddr_in connect_addr;
struct net_session* session;
struct connect_session* csession;
ffid_vtype id;
FUN_CONNECTEX connectExFun;
int err;
s = create_socket();
if(NET_INVALID_SOCKET == s)
{
return 0;
}
memset(&connect_addr, 0, sizeof(connect_addr));
connect_addr.sin_family = AF_INET;
connect_addr.sin_addr.S_un.S_addr = INADDR_ANY;
connect_addr.sin_port = 0;
if(bind(s, (struct sockaddr*)&connect_addr, sizeof(connect_addr)))
{
net_close_fd(s);
return 0;
}
connectExFun = 0;
connectExFun = get_connect_ex_fun(s);
if(!connectExFun)
{
net_close_fd(s);
return 0;
}
CreateIoCompletionPort((HANDLE)s, service->net_service_fd, (ULONG_PTR)s, sizeof(NET_SOCKET));
csession = (struct connect_session*)malloc(sizeof(struct connect_session));
if(!csession)
{
net_close_fd(s);
return 0;
}
memset(csession, 0, sizeof(struct connect_session));
csession->s = s;
session = create_net_session();
if(!session)
{
net_close_fd(s);
release_connect_session(csession);
return 0;
}
id = add_net_session(service, session);
if(!id)
{
net_close_fd(s);
release_net_session(session);
release_connect_session(csession);
return 0;
}
memset(&connect_addr, 0, sizeof(connect_addr));
connect_addr.sin_family = AF_INET;
connect_addr.sin_addr.S_un.S_addr = inet_addr(ip);
connect_addr.sin_port = htons(port);
csession->id = id;
csession->op = OP_NET_CONNECT;
session->connect_flag = 1;
session->fd = s;
session->data = 0;
if(!connectExFun(s, (struct sockaddr*)&connect_addr, (int)sizeof(connect_addr),
0, 0, (LPDWORD)&csession->send_bytes, (LPOVERLAPPED)&csession->overlapped))
{
err = net_get_error();
if(err != ERROR_IO_PENDING)
{
release_connect_session(csession);
net_socket_close(service, id, 0);
return 0;
}
}
return id;
}
NET_API net_socket
net_listen(struct net_service* service, unsigned short port, unsigned short listen_cnt)
{
ffid_vtype id;
NET_SOCKET listen_socket;
struct net_session* session;
struct sockaddr_in listen_addr;
struct accept_session* asession;
int i, ret;
listen_socket = create_socket();
if(NET_INVALID_SOCKET == listen_socket)
{
return 0;
}
CreateIoCompletionPort((HANDLE)listen_socket, service->net_service_fd, (ULONG_PTR)listen_socket, sizeof(NET_SOCKET));
listen_addr.sin_family = AF_INET;
listen_addr.sin_port = htons(port);
listen_addr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
if((ret = bind(listen_socket, (struct sockaddr*)&listen_addr, sizeof(listen_addr))))
{
ret = net_get_error();
net_close_fd(listen_socket);
return 0;
}
if(listen(listen_socket, listen_cnt))
{
net_close_fd(listen_socket);
return 0;
}
session = create_net_session();
if(!session)
{
net_close_fd(listen_socket);
return 0;
}
session->fd = listen_socket;
session->lsession = create_listen_session(service, port, listen_cnt);
if(!session->lsession)
{
release_net_session(session);
net_close_fd(listen_socket);
return 0;
}
id = add_net_session(service, session);
if(!id)
{
release_net_session(session);
net_close_fd(listen_socket);
return 0;
}
for(i = 0; i < listen_cnt; ++i)
{
asession = create_accept_session();
if(asession)
{
if(!post_listen(service, session, asession))
{
asession->index = i;
continue;
}
release_accept_session(asession);
}
net_socket_close(service, id, 0);
return 0;
}
return id;
}
void en_socket_stream_connect (EIF_INTEGER *a_fd, EIF_INTEGER *a_fd1, EIF_INTEGER *a_local_port, EIF_POINTER sockaddr, EIF_INTEGER timeout, EIF_BOOLEAN is_blocking) {
SOCKETADDRESS* him;
int family;
SOCKET fd, fd1 = INVALID_SOCKET;
int ipv6_supported;
int connect_res;
EIF_NET_INITIALIZE;
ipv6_supported = en_ipv6_available();
fd = (SOCKET) *a_fd;
if (ipv6_supported) {
fd1 = *a_fd1;
}
him = (SOCKETADDRESS*) sockaddr;
family = him->him.sa_family;
if (family == AF_INET6) {
if (!ipv6_supported) {
eraise ("Protocol family not supported", EN_PROG);
return;
} else {
if (fd1 == -1) {
eraise ("Destination unreachable", EN_PROG);
return;
}
/* close the v4 socket, and set fd to be the v6 socket */
*a_fd = (EIF_INTEGER) fd1;
*a_fd1 = -1;
net_socket_close(fd);
fd = fd1;
}
} else {
if (fd1 != -1) {
/* close the v6 socket */
*a_fd1 = -1;
net_socket_close(fd1);
}
if (fd == INVALID_SOCKET) {
eraise ("Destination unreachable", EN_PROG);
return;
}
}
if (timeout <= 0) {
connect_res = connect(fd, (struct sockaddr *) him, SOCKETADDRESS_LEN(him));
if (connect_res == SOCKET_ERROR) {
connect_res = WSAGetLastError();
if ((connect_res == WSAEWOULDBLOCK) || (connect_res == WSAEINPROGRESS)) {
connect_res = 0;
errno = 0;
}
}
} else {
u_long optval;
int optlen = sizeof(int);
/* make socket non-blocking */
if (is_blocking) {
optval = 1;
ioctlsocket( fd, FIONBIO, &optval );
}
/* initiate the connect */
connect_res = connect(fd, (struct sockaddr *) him, SOCKETADDRESS_LEN(him));
if (connect_res == SOCKET_ERROR) {
if (WSAGetLastError() == WSAEWOULDBLOCK) {
fd_set wr, ex;
struct timeval t;
FD_ZERO(&wr);
FD_ZERO(&ex);
FD_SET(fd, &wr);
FD_SET(fd, &ex);
t.tv_sec = timeout / 1000;
t.tv_usec = (timeout % 1000) * 1000;
/* Wait for timout, connection established or
* connection failed. */
connect_res = select((int) fd+1, 0, &wr, &ex, &t);
/* Timeout before connection is established/failed so
* we throw exception and shutdown input/output to prevent
* socket from being used.
* The socket should be closed immediately by the caller. */
if (connect_res == 0) {
shutdown( fd, SD_BOTH );
if (is_blocking) {
/* make socket blocking again - just in case */
optval = 0;
ioctlsocket( fd, FIONBIO, &optval );
}
eraise("connect timed out", EN_PROG);
return;
}
/* We must now determine if the connection has been established
* or if it has failed. The logic here is designed to work around
* bug on Windows NT whereby using getsockopt to obtain the
* last error (SO_ERROR) indicates there is no error. The workaround
* on NT is to allow winsock to be scheduled and this is done by
* yielding and retrying. As yielding is problematic in heavy
* load conditions we attempt up to 3 times to get the error reason. */
if (!FD_ISSET(fd, &ex)) {
connect_res = 0;
} else {
int retry;
for (retry=0; retry<3; retry++) {
net_get_sock_opt(fd, SOL_SOCKET, SO_ERROR, (char*)&connect_res, &optlen);
if (connect_res) {
break;
}
Sleep(0);
}
if (connect_res == 0) {
eraise("Unable to establish connection", EN_PROG);
return;
}
}
}
}
if (is_blocking) {
/* make socket blocking again */
optval = 0;
ioctlsocket(fd, FIONBIO, &optval);
}
}
if (connect_res) {
if (connect_res == WSAEADDRNOTAVAIL) {
eraise("Address is invalid on local machine, or port is not valid on remote machine", EN_PROG);
} else {
eraise("Unable to establish connection", EN_PROG);
}
return;
}
*a_fd = (EIF_INTEGER) fd;
/* we need to initialize the local port field if bind was called
* previously to the connect (by the client) then localport field
* will already be initialized. */
if (*a_local_port == 0) {
/* Now that we're a connected socket, let's extract the port number
* that the system chose for us and store it in the Socket object. */
u_short port;
int len = SOCKETADDRESS_LEN(him);
if (getsockname(fd, (struct sockaddr *)him, &len) == -1) {
if (WSAGetLastError() == WSAENOTSOCK) {
eraise("Socket closed", EN_PROG);
} else {
eraise("getsockname failed", EN_PROG);
}
return;
}
port = ntohs (GET_PORT(him));
*a_local_port = port;
}
}
