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;
}
static void net_socket_accept(void *opaque)
{
NetSocketState *s = opaque;
struct sockaddr_in saddr;
socklen_t len;
int fd;
for(;;) {
len = sizeof(saddr);
fd = qemu_accept(s->listen_fd, (struct sockaddr *)&saddr, &len);
if (fd < 0 && errno != EINTR) {
return;
} else if (fd >= 0) {
qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
break;
}
}
s->fd = fd;
s->nc.link_down = false;
net_socket_connect(s);
snprintf(s->nc.info_str, sizeof(s->nc.info_str),
"socket: connection from %s:%d",
inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
}
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
}
}
}
static NetSocketState *net_socket_fd_init_stream(VLANState *vlan,
const char *model,
const char *name,
int fd, int is_connected)
{
VLANClientState *nc;
NetSocketState *s;
nc = qemu_new_net_client(&net_socket_info, vlan, NULL, model, name);
snprintf(nc->info_str, sizeof(nc->info_str), "socket: fd=%d", fd);
s = DO_UPCAST(NetSocketState, nc, nc);
s->fd = fd;
if (is_connected) {
net_socket_connect(s);
} else {
qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
}
return s;
}
/*说明: 创建一个task任务，用于socket请求*/
static void task_net_connect_fun(void * arg)
{
int ret = -1;
net_sckt_param_t sckt_param = {0};
net_options_t *msg = (net_options_t *)arg;
int socketid;
BE_ASYNC_S* async = (BE_ASYNC_S*)calloc(1,sizeof(BE_ASYNC_S));
async->param_count = 1;
async->params = (be_jse_symbol_t**) calloc(1,sizeof(be_jse_symbol_t*) * async->param_count);
memset(&sckt_param,0,sizeof(net_sckt_param_t));
ret = parse_net_option_addr(msg->addr,&sckt_param);
if (ret < 0){
async->func = (be_jse_symbol_t *)msg->onerror_cb;
async->params[0] = new_str_symbol("paramter error");
}
socketid = net_socket_connect(&sckt_param);
if (socketid > 0){
async->func = (be_jse_symbol_t *)msg->onconn_cb;
async->params[0] = new_int_symbol(socketid);
be_debug(JS_NET_TAG,"NET.connect ok ,socketid = %d",socketid);
}else{
async->func = (be_jse_symbol_t *)msg->onerror_cb;
async->params[0] = new_str_symbol("connect error");
be_debug(JS_NET_TAG,"NET.connect error");
}
be_debug(JS_NET_TAG,"task: host=%s,port=%d,type=%d",sckt_param.host_ip,sckt_param.port,sckt_param.proto);
ret = be_osal_schedule_call(be_jse_async_event_cb, async);
if (ret >=0){
INC_SYMBL_REF(async->func);//because be_jse_async_event_cb will auto unlock async->func
}else{
free(async);
free(async->params);
}
if (socketid > 0){
char *buffer = calloc(1,NET_SOCKET_RECV_BUFF_LEN);
int bytes_received = 0;
while(1){
be_debug(JS_NET_TAG,"ready to recv...socketid=%d",socketid);
bytes_received = recv(socketid, buffer, NET_SOCKET_RECV_BUFF_LEN, 0);
if (bytes_received > 0){ //recv成功
be_debug(JS_NET_TAG,"recv...bytes_received=%d",bytes_received);
BE_ASYNC_S* async = (BE_ASYNC_S*)calloc(1,sizeof(BE_ASYNC_S));
async->param_count = 2;
async->params = (be_jse_symbol_t**) calloc(1,sizeof(be_jse_symbol_t*) * async->param_count);
async->func = (be_jse_symbol_t *)msg->ondata_cb;
async->params[0] = new_int_symbol(socketid);
async->params[1] = new_str_symbol(buffer);
ret = be_osal_schedule_call(be_jse_async_event_cb, async);
if(ret >= 0){
INC_SYMBL_REF(async->func); //be_jse_async_event_cb会自动释放func，而这里是while循环
}else{
free(async);
free(async->params);
}
memset(buffer,0,NET_SOCKET_RECV_BUFF_LEN);
}else if (bytes_received < 0){//recv失败
if (errno == EINTR) continue;
be_warn(JS_NET_TAG,"recv...error=%d",bytes_received);
break;
}else{
be_warn(JS_NET_TAG,"server closed=%d",bytes_received);
break;
}
}
/*callback when close or error*/
BE_ASYNC_S* async = (BE_ASYNC_S*)calloc(1,sizeof(BE_ASYNC_S));
async->param_count = 1;
async->params = (be_jse_symbol_t**) calloc(1,sizeof(be_jse_symbol_t*) * async->param_count);
if (bytes_received != 0){
async->func = (be_jse_symbol_t *)msg->onerror_cb;
async->params[0] = new_str_symbol("recv error");
}else{
async->func = (be_jse_symbol_t *)msg->onclose_cb;
async->params[0] = new_int_symbol(socketid);
}
ret = be_osal_schedule_call(be_jse_async_event_cb, async);
if(ret >= 0){
INC_SYMBL_REF(async->func);
}else{
free(async);
free(async->params);
}
}
done:
/*onxxx_cb callback is optional,need check if vaild*/
if (msg->onclose_cb) symbol_unlock((be_jse_symbol_t *)msg->onclose_cb);
if (msg->ondata_cb) symbol_unlock((be_jse_symbol_t *)msg->ondata_cb);
if (msg->onerror_cb) symbol_unlock((be_jse_symbol_t *)msg->onerror_cb);
if (msg->onconn_cb) symbol_unlock((be_jse_symbol_t *)msg->onconn_cb);
free(msg->addr);
free(msg);
be_debug(JS_NET_TAG,"aos get task exit name=%s",be_osal_task_name());
be_osal_exit_task(0);
}
