#include
#include
#include
#include
#include "msinc.h"
#include "mssoc.h"
#include "mslog.h"
#include "mssim.h"
#define sm_set_core_flag()
#define sm_set_app_flag()
/* --------------------------------------------------------------------------
* 模块内部变量声明。
* ----------------------------------------------------------------------- */
typedef struct _soc_session_t {
int used;
int handle;
SOCKET socket;
enum {TCP_CONNECTING, TCP_CONNECTED, TCP_WAIT_CLOSE} tcp_state;
enum {UDP_CONNECTING, UDP_CONNECTED, UDP_WAIT_CLOSE} udp_state;
enum {BLOCK_WRITE, CAN_WRITE} write_pipe;
enum {BLOCK_READ, CAN_READ} read_pipe;
//void (*hook)(int handler, int state);
ms_sockaddr addr;
ms_get_host_cb_t get_host_cb;
ms_soc_cb_t soc_cb;
} soc_session_t;
#define MS_SOC_MAX_NUM (3)
/**
* 并发TCP会话队列。
*/
static soc_session_t sessions[MS_SOC_MAX_NUM];
/*
* 队列定时器初始化标志。
*/
static int init_timer = 0;
/*
* 定时器的ID号。
*/
static int itemer_id = -1;
/*
* 系统忙标志。
*/
static int busy = 0;
/* --------------------------------------------------------------------------
* 模块内部函数声明。
* ----------------------------------------------------------------------- */
/**
* TCP队列处理定时器函数。
*/
static void proc_sessions(int tid, int p);
/**
* UDP队列处理定时器函数。
*/
static void proc_sessions_udp(int tid, int p);
/**
* 处理会话。
*/
static void proc_session(soc_session_t* session);
/**
* 处理会话。
*/
static void proc_session_udp(soc_session_t* session);
/**
* tcp模块的初始化函数。
*/
static int soc_mod_init_func(void);
/**
* tcp模块的清理函数。
*/
static int soc_mod_fina_func(void);
static int soc_mod_init_func(void)
{
WSADATA ws;
int ret = -1;
ret = WSAStartup(MAKEWORD(1, 1), &ws);
if (ret != 0)
return -1;
else
{
itemer_id = -1;
init_timer = 0;
}
return 0;
}
static int soc_mod_fina_func(void)
{
WSACleanup();
if (init_timer && itemer_id >= 0)
{
ms_delete_timer((uint16)itemer_id);
itemer_id = -1;
init_timer = 0;
}
return 0;
}
void proc_session(soc_session_t* session) {
int v;
fd_set fdrds, fdwrs;
struct timeval timeout = {0, 0};
if (!init_timer)
return;
switch(session->tcp_state)
{
case TCP_CONNECTING:
FD_ZERO(&fdwrs);
FD_SET(session->socket, &fdwrs);
if ((v = select(1, NULL, &fdwrs, NULL, &timeout)) == SOCKET_ERROR)
{
if (session->soc_cb)
{
sm_set_app_flag();
session->soc_cb(session->handle, MS_SOCEVT_CONNECT_FAILED);
sm_set_core_flag();
}
return;
}
if (v > 0 && FD_ISSET(session->socket, &fdwrs))
{
session->tcp_state = TCP_CONNECTED;
session->read_pipe = CAN_READ;
session->write_pipe = CAN_WRITE;
if (session->soc_cb)
{
sm_set_app_flag();
session->soc_cb(session->handle, MS_SOCEVT_CONNECT);
sm_set_core_flag();
}
}
break;
case TCP_CONNECTED:
if (session->write_pipe == BLOCK_WRITE)
{
FD_ZERO(&fdwrs);
FD_SET(session->socket, &fdwrs);
if ((v = select(1, NULL, &fdwrs, NULL, &timeout)) == SOCKET_ERROR)
{
if (session->soc_cb)
{
sm_set_app_flag();
session->soc_cb(session->handle, MS_SOCEVT_CONNECT_FAILED);
sm_set_core_flag();
}
return;
}
if (v > 0 && FD_ISSET(session->socket, &fdwrs))
{
session->write_pipe = CAN_WRITE;
if (session->soc_cb)
{
sm_set_app_flag();
session->soc_cb(session->handle, MS_SOCEVT_WRITE);
sm_set_core_flag();
}
}
}
FD_ZERO(&fdrds);
FD_SET(session->socket, &fdrds);
if ((v = select(1, &fdrds, NULL, NULL, &timeout)) == SOCKET_ERROR)
{
if (session->soc_cb)
{
sm_set_app_flag();
session->soc_cb(session->handle, MS_SOCEVT_CONNECT_FAILED);
sm_set_core_flag();
}
return;
}
if ((v > 0) && FD_ISSET(session->socket, &fdrds))
{
session->read_pipe = CAN_READ;
if (session->soc_cb)
{
sm_set_app_flag();
session->soc_cb(session->handle, MS_SOCEVT_READ);
sm_set_core_flag();
}
}
break;
case TCP_WAIT_CLOSE:
if (session->soc_cb)
{
sm_set_app_flag();
session->soc_cb(session->handle, MS_SOCEVT_CLOSE);
sm_set_core_flag();
}
session->used = FALSE;
session->soc_cb = NULL;
break;
}
}
////////////////////////////////////////////////////////////////////////////////
void proc_session_udp(soc_session_t* session) {
int v;
fd_set fdrds, fdwrs;
struct timeval timeout = {0, 0};
if (!init_timer)
return;
switch(session->udp_state)
{
case UDP_CONNECTING:
//FD_ZERO(&fdwrs);
//FD_SET(session->socket, &fdwrs);
/*
if ((v = select(1, NULL, &fdwrs, NULL, &timeout)) == SOCKET_ERROR)
{
if (session->soc_cb)
{
sm_set_app_flag();
session->soc_cb(session->handle, MS_SOCEVT_CONNECT_FAILED);
sm_set_core_flag();
}
return;
}
if (v > 0 && FD_ISSET(session->socket, &fdwrs))
{
*/
session->udp_state = UDP_CONNECTED;
session->read_pipe = CAN_READ;
session->write_pipe = CAN_WRITE;
/*
if (session->soc_cb)
{
sm_set_app_flag();
session->soc_cb(session->handle, MS_SOCEVT_CONNECT);
sm_set_core_flag();
}
}
*/
break;
case UDP_CONNECTED:
if (session->write_pipe == BLOCK_WRITE)
{
FD_ZERO(&fdwrs);
FD_SET(session->socket, &fdwrs);
if ((v = select(1, NULL, &fdwrs, NULL, &timeout)) == SOCKET_ERROR)
{
if (session->soc_cb)
{
sm_set_app_flag();
session->soc_cb(session->handle, MS_SOCEVT_CONNECT_FAILED);
sm_set_core_flag();
}
return;
}
if (v > 0 && FD_ISSET(session->socket, &fdwrs))
{
session->write_pipe = CAN_WRITE;
if (session->soc_cb)
{
sm_set_app_flag();
session->soc_cb(session->handle, MS_SOCEVT_WRITE);
sm_set_core_flag();
}
}
}
/*
if (session->read_pipe == BLOCK_READ)
{
FD_ZERO(&fdwrs);
FD_SET(session->socket, &fdwrs);
if ((v = select(1, NULL, &fdwrs, NULL, &timeout)) == SOCKET_ERROR)
{
if (session->soc_cb)
{
sm_set_app_flag();
session->soc_cb(session->handle, MS_SOCEVT_CONNECT_FAILED);
sm_set_core_flag();
}
return;
}
if (v > 0 && FD_ISSET(session->socket, &fdwrs))
{
session->write_pipe = CAN_READ;
if (session->soc_cb)
{
sm_set_app_flag();
session->soc_cb(session->handle, MS_SOCEVT_READ);
sm_set_core_flag();
}
}
}
*/
FD_ZERO(&fdrds);
FD_SET(session->socket, &fdrds);
if ((v = select(1, &fdrds, NULL, NULL, &timeout)) == SOCKET_ERROR)
{
if (session->soc_cb)
{
sm_set_app_flag();
session->soc_cb(session->handle, MS_SOCEVT_CONNECT_FAILED);
sm_set_core_flag();
}
return;
}
if ((v > 0) && FD_ISSET(session->socket, &fdrds))
{
session->read_pipe = CAN_READ;
if (session->soc_cb)
{
sm_set_app_flag();
session->soc_cb(session->handle, MS_SOCEVT_READ);
sm_set_core_flag();
}
}
break;
case UDP_WAIT_CLOSE:
if (session->soc_cb)
{
sm_set_app_flag();
session->soc_cb(session->handle, MS_SOCEVT_CLOSE);
sm_set_core_flag();
}
session->used = FALSE;
session->soc_cb = NULL;
break;
}
}
////////////////////////////////////////////////////////////////////////////////
void proc_sessions(int tid, int p) {
int i;
if (busy)
return ;
busy = TRUE;
for (i = 0; i < MS_SOC_MAX_NUM; i++) {
if (sessions[i].used) {
proc_session(sessions + i);
}
}
busy = FALSE;
}
//这里运行udp
void proc_sessions_udp(int tid, int p) {
int i;
if (busy)
return ;
busy = TRUE;
for (i = 0; i < MS_SOC_MAX_NUM; i++) {
if (sessions[i].used) {
proc_session_udp(sessions + i);
}
}
busy = FALSE;
}
/************************************************************************************/
//mssoc.h
int bearer_mode;
int bearer_status;
ms_bearer_cb_t bearer_cb;
int ms_soc_init()
{
soc_mod_init_func();
if (bearer_status)
return -1;
if (!init_timer)
{
memset(&sessions, 0, sizeof(sessions));
ms_quick_timer(200, 0, proc_sessions, 1);
init_timer = TRUE;
}
return 0;
}
/////////////////////////////////////////////////
int ms_soc_init_udp()
{
soc_mod_init_func();
if (bearer_status)
return -1;
if (!init_timer)
{
memset(&sessions, 0, sizeof(sessions));
ms_quick_timer(200, 0, proc_sessions_udp, 1);
init_timer = TRUE;
}
return 0;
}
int ms_soc_finalize()
{
if (bearer_status)
ms_bearer_close();
soc_mod_fina_func();
return 0;
}
static void bearer_timer_cb(int tid, int p)
{
if (bearer_cb)
{
if (!p)
{
bearer_status = 1;
bearer_cb(MS_BEARER_OK);
}
else
{
bearer_status = 0;
//bearer_cb(MS_BEARER_FAILED);
}
}
}
int ms_bearer_open(int mode, void * cb)
{
if (!bearer_status)
{
ms_quick_timer(2000, 0, bearer_timer_cb, 0);
bearer_mode = mode;
bearer_cb = cb;
return MS_SOC_WAIT;
}
return MS_SOC_OK;
}
int ms_bearer_close()
{
if (bearer_status)
{
ms_quick_timer(2000, 1, bearer_timer_cb, 0);
return MS_SOC_WAIT;
}
return MS_SOC_OK;
}
void * _vm_soc_session_malloc()
{
int i;
soc_session_t* session = NULL;
for (i = 0; i < MS_SOC_MAX_NUM; i++)
{
if (!sessions[i].used) {
session = sessions + i;
session->handle = i;
break;
}
}
return session;
}
void _ms_soc_session_free(int handle)
{
if (handle >= 0 && handle <= MS_SOC_MAX_NUM)
{
sessions[handle].tcp_state = TCP_WAIT_CLOSE;
sessions[handle].used = FALSE;
sessions[handle].soc_cb = NULL;
}
}
void * _ms_soc_session_get(int handle)
{
return sessions+handle;
}
int ms_soc_create(int type, void * cb)
{
soc_session_t* session;
session = _vm_soc_session_malloc();
if (session)
{
unsigned long ul = 1;
unsigned long p = 0;
session->tcp_state = TCP_CONNECTING;
session->used = TRUE;
session->soc_cb = cb;
if ((session->socket = socket(PF_INET, type+1, 0)) == INVALID_SOCKET)
{
_ms_soc_session_free(session->handle);
return MS_SOC_ERROR;
}
if(ioctlsocket(session->socket, FIONBIO, (unsigned long*)&ul) == SOCKET_ERROR)
{
_ms_soc_session_free(session->handle);
return MS_SOC_ERROR;
}
if (ioctlsocket(session->socket, FIONREAD, &p) != 0)
{
_ms_soc_session_free(session->handle);
return MS_SOC_ERROR;
}
return session->handle;
}
return MS_SOC_USEOUT;
}
//////////////////////////////////////////////////////
int ms_soc_create_udp(int type, void * cb)
{
soc_session_t* session;
session = _vm_soc_session_malloc();
if (session)
{
unsigned long ul = 1;
unsigned long p = 0;
session->udp_state = UDP_CONNECTED;
session->used = TRUE;
session->soc_cb = cb;
session->read_pipe = CAN_READ;
session->write_pipe = CAN_WRITE;
if ((session->socket = socket(PF_INET, type, 0)) == INVALID_SOCKET)
{
_ms_soc_session_free(session->handle);
return MS_SOC_ERROR;
}
if(ioctlsocket(session->socket, FIONBIO, (unsigned long*)&ul) == SOCKET_ERROR)//控制套接口的模式
{
_ms_soc_session_free(session->handle);
return MS_SOC_ERROR;
}
if (ioctlsocket(session->socket, FIONREAD, &p) != 0)
{
_ms_soc_session_free(session->handle);
return MS_SOC_ERROR;
}
return session->handle;
}
return MS_SOC_USEOUT;
}
int ms_soc_close(int s)
{
int handle = s;
if ((handle >= 0) && (handle < MS_SOC_MAX_NUM))
{
if (sessions[handle].handle == handle)
{
closesocket(sessions[handle].socket);
_ms_soc_session_free(handle);
return MS_SOC_OK;
}
}
return MS_SOC_INVALID;
}
int ms_soc_bind(int s, ms_sockaddr * addr)
{
int handle,err;
// int len;
soc_session_t* session;
struct sockaddr_in udp_bind;//标准的套接字结构体sockaddr_in
ms_sockaddr *addr_udp=NULL;
addr_udp=addr;
handle=s;
session = _ms_soc_session_get(s);//return sessions+handle;返回的应该是socket的值
if (session)
{
udp_bind.sin_family = AF_INET;
udp_bind.sin_port = htons((unsigned short)addr->port);
udp_bind.sin_addr.s_addr = *(long*)addr->addr;
}
if ((handle >= 0) && (handle < MS_SOC_MAX_NUM))
{
if (sessions[handle].handle == handle)
{
err=bind(s,(struct sockaddr *)&addr,sizeof(addr));
if(err==SOCKET_ERROR)
return MS_SOC_ERROR;
else
return MS_SOC_OK;
}
}
return 0;
}
int ms_soc_connect(int s, const ms_sockaddr * addr)
{
int idx = -1;
soc_session_t* session;
struct sockaddr_in remote;
unsigned long p = 0;
int TimeOut = 5000;
unsigned long ul = 1;
struct timeval timeout;
fd_set r;
int ret;
session = _ms_soc_session_get(s);
if (session)
{
remote.sin_family = AF_INET;
remote.sin_port = htons((unsigned short)addr->port);
remote.sin_addr.s_addr = *(long*)addr->addr;
if (connect(session->socket, (struct sockaddr*)&remote, sizeof(remote)) == SOCKET_ERROR)
{
if (WSAGetLastError() == WSAEWOULDBLOCK)
{
int error_code, err_len=sizeof(error_code);
FD_ZERO(&r);
FD_SET(session->socket, &r);
timeout.tv_sec = 10; //Connection timeout
timeout.tv_usec = 0;
ret = select(session->socket+1, 0, &r, 0, &timeout);
if ( ret <= 0 )
{
ret = closesocket(session->socket);
_ms_soc_session_free(s);
return MS_SOC_ERROR;
}
if (FD_ISSET(session->socket, &r))
{
getsockopt(session->socket, SOL_SOCKET, SO_ERROR, (char *)&error_code, &err_len);
if (error_code != 0)
{
ret = closesocket(session->socket);
_ms_soc_session_free(s);
return MS_SOC_ERROR;
}
}
else
{
ret = closesocket(session->socket);
_ms_soc_session_free(s);
return MS_SOC_ERROR;
}
}
else
{
_ms_soc_session_free(idx);
return MS_SOC_ERROR;
}
return MS_SOC_WAIT;
}
if(ioctlsocket(session->socket, FIONBIO, (unsigned long*)&p) == SOCKET_ERROR)
{
closesocket(session->socket);
return MS_SOC_ERROR;
}
}
return MS_SOC_INVALID;
}
int ms_soc_recvfrom(int s,void *buf,int len,ms_sockaddr *addr)
{
int handle = s;
int nread;
int serverlen;
struct timeval timeout = {0, 0};
soc_session_t* session;
struct sockaddr_in remote_udp;//标准的套接字结构体sockaddr_in
ms_sockaddr *addr_udp=NULL;
addr_udp=addr;//接收下看看
serverlen=sizeof(remote_udp);
session = _ms_soc_session_get(s);//return sessions+handle;返回的应该是socket的值
if (session)
{
remote_udp.sin_family = AF_INET;
remote_udp.sin_port = htons((unsigned short)addr->port);
remote_udp.sin_addr.s_addr = *(long*)addr->addr;//是否正确？？？
//sockSend.sin_addr.S_un.S_addr=inet_addr("211.143.108.24");//服务器地址??传递是否正确
}
handle=s;//接收句柄
//nread = recvfrom(sessions[handle].socket, (char*)buf, len, 0,(struct sockaddr*)&remote_udp,&serverlen);在下边执行
////////////////////////////////////////////////////////////////////////////////////////////////////////
if ((handle >= 0) && (handle < MS_SOC_MAX_NUM) &&
sessions[handle].used && (sessions[handle].handle == handle))
{
if (sessions[handle].udp_state == UDP_WAIT_CLOSE)
return -1;
if (sessions[handle].read_pipe == CAN_READ
&& sessions[handle].udp_state == UDP_CONNECTED)
{
/***************************************/
int v;
fd_set fdwrs;
struct timeval timeout = {0, 0};
FD_ZERO(&fdwrs);
FD_SET(sessions[handle].socket, &fdwrs);
if ((v = select(1, &fdwrs, NULL, NULL, &timeout)) == SOCKET_ERROR)
{
return MS_SOC_ERROR;
}
if (v > 0 && FD_ISSET(sessions[handle].socket, &fdwrs))
{
nread = recvfrom(sessions[handle].socket, (char*)buf, len, 0,(struct sockaddr*)&remote_udp,&serverlen);
}
else
{
return MS_SOC_WAIT;
}
/***************************************/
/*
* nread == 0 表示TCP链路已经被对等层关闭。
* SOCKET_ERROR 并且调用WSAGetLastError()返回WSAEWOULDBLOCK写通道当前被阻塞，其他为失败。
* nread > 0表示已经写入了一定的字节数。
*/
if (nread == 0)
{
//收到Server的FIN包，可以选择主动断开连接或继续发送数据；
//ms_soc_close(s);
//nread = -1;
}
else if (nread == SOCKET_ERROR)
{
switch(WSAGetLastError())
{
case WSAEWOULDBLOCK:
sessions[handle].read_pipe = BLOCK_READ;
nread = MS_SOC_WAIT;
break;
default:
nread = -1;
break;
}
}
return nread;
}
else
return MS_SOC_WAIT;
}
else
return MS_SOC_INVALID;
////////////////////////////////////////////////////////////////////////////////////////////////////////
}
int ms_soc_recv(int s, void * buf, int len)
{
int handle = s;
int nread;
if ((handle >= 0) && (handle < MS_SOC_MAX_NUM) &&
sessions[handle].used && (sessions[handle].handle == handle))
{
if (sessions[handle].tcp_state == TCP_WAIT_CLOSE)
return -1;
if (sessions[handle].read_pipe == CAN_READ
&& sessions[handle].tcp_state == TCP_CONNECTED)
{
/***************************************/
int v;
fd_set fdwrs;
struct timeval timeout = {0, 0};
FD_ZERO(&fdwrs);
FD_SET(sessions[handle].socket, &fdwrs);
if ((v = select(1, &fdwrs, NULL, NULL, &timeout)) == SOCKET_ERROR)
{
return MS_SOC_ERROR;
}
if (v > 0 && FD_ISSET(sessions[handle].socket, &fdwrs))
{
nread = recv(sessions[handle].socket, (char*)buf, len, 0);
}
else
{
return MS_SOC_WAIT;
}
/***************************************/
/*
* nread == 0 表示TCP链路已经被对等层关闭。
* SOCKET_ERROR 并且调用WSAGetLastError()返回WSAEWOULDBLOCK写通道当前被阻塞，其他为失败。
* nread > 0表示已经写入了一定的字节数。
*/
if (nread == 0)
{
//收到Server的FIN包，可以选择主动断开连接或继续发送数据；
//ms_soc_close(s);
//nread = -1;
}
else if (nread == SOCKET_ERROR)
{
switch(WSAGetLastError())
{
case WSAEWOULDBLOCK:
sessions[handle].read_pipe = BLOCK_READ;
nread = MS_SOC_WAIT;
break;
default:
nread = -1;
break;
}
}
return nread;
}
else
return MS_SOC_WAIT;
}
else
return MS_SOC_INVALID;
}
int ms_soc_sendto(int s,const void *buf,int len,ms_sockaddr *addr)
{
int handle;
int nwrite;
struct timeval timeout = {0, 0};
soc_session_t* session;
struct sockaddr_in remote_udp;//标准的套接字结构体sockaddr_in
ms_sockaddr *addr_udp=NULL;
addr_udp=addr;//接收下看看
session = _ms_soc_session_get(s);//return sessions+handle;返回的应该是socket的值
if (session)
{
remote_udp.sin_family = AF_INET;
remote_udp.sin_port = htons((unsigned short)addr->port);
remote_udp.sin_addr.s_addr = *(long*)addr->addr;//是否正确？？？
//sockSend.sin_addr.S_un.S_addr=inet_addr("211.143.108.24");//服务器地址??传递是否正确
}
handle=s;//接收句柄
//nwrite = sendto(sessions[handle].socket, (char*)buf, len, 0,(struct sockaddr*)&remote_udp,sizeof(remote_udp));复制到下边执行
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
if ((handle >= 0) && (handle < MS_SOC_MAX_NUM) &&
sessions[handle].used && (sessions[handle].handle == handle))
{
if (sessions[handle].udp_state == UDP_WAIT_CLOSE)
return -1;
if (sessions[handle].write_pipe == CAN_WRITE
&& sessions[handle].udp_state == UDP_CONNECTED)
{
int v;
fd_set fdwrs;
struct timeval timeout = {0, 0};
FD_ZERO(&fdwrs);
FD_SET(sessions[handle].socket, &fdwrs);
if ((v = select(1, NULL, &fdwrs, NULL, &timeout)) == SOCKET_ERROR)
{
return MS_SOC_ERROR;
}
if (v > 0 && FD_ISSET(sessions[handle].socket, &fdwrs))
{
nwrite = sendto(sessions[handle].socket, (char*)buf, len, 0,(struct sockaddr*)&remote_udp,sizeof(remote_udp));
}
else
{
return MS_SOC_WAIT;
}
if (nwrite == SOCKET_ERROR)
{
switch(WSAGetLastError())
{
case WSAEWOULDBLOCK:
sessions[handle].write_pipe = BLOCK_WRITE;
nwrite = MS_SOC_WAIT;
break;
default:
nwrite = -1;
break;
}
}
return nwrite;
}
else
return MS_SOC_WAIT;
}
else
return MS_SOC_INVALID;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
int ms_soc_send(int s, const void * buf, int len)
{
int handle = s;
int nwrite;
if ((handle >= 0) && (handle < MS_SOC_MAX_NUM) &&
sessions[handle].used && (sessions[handle].handle == handle))
{
if (sessions[handle].tcp_state == TCP_WAIT_CLOSE)
return -1;
if (sessions[handle].write_pipe == CAN_WRITE
&& sessions[handle].tcp_state == TCP_CONNECTED)
{
int v;
fd_set fdwrs;
struct timeval timeout = {0, 0};
FD_ZERO(&fdwrs);
FD_SET(sessions[handle].socket, &fdwrs);
if ((v = select(1, NULL, &fdwrs, NULL, &timeout)) == SOCKET_ERROR)
{
return MS_SOC_ERROR;
}
if (v > 0 && FD_ISSET(sessions[handle].socket, &fdwrs))
{
nwrite = send(sessions[handle].socket, (char*)buf, len, 0);
}
else
{
return MS_SOC_WAIT;
}
if (nwrite == SOCKET_ERROR)
{
switch(WSAGetLastError())
{
case WSAEWOULDBLOCK:
sessions[handle].write_pipe = BLOCK_WRITE;
nwrite = MS_SOC_WAIT;
break;
default:
nwrite = -1;
break;
}
}
return nwrite;
}
else
return MS_SOC_WAIT;
}
else
return MS_SOC_INVALID;
}
int ms_inet_addr(char * ipchar, uint8 * ip)
{
uint32 ipp = inet_addr(ipchar);
if (ip)
memcpy(ip, &ipp, 4);
return ipp;
}
void get_host_timer_cb(int tid, int p)
{
soc_session_t* session = NULL;
session = (soc_session_t*)_ms_soc_session_get(p);
if (session)
{
if (session->get_host_cb)
session->get_host_cb(p, *(long*)session->addr.addr);
}
}
int ms_soc_gethostbyname(int s, const char * host, void * cb)
{
int ip;
HOSTENT* hent;
static char g_host[128];
soc_session_t* session = NULL;
session = (soc_session_t*)_ms_soc_session_get(s);
if (session)
{
if ((hent = gethostbyname(host)) != 0)
{
ip = *(long*)hent->h_addr;
if (strcmp(g_host, host) == 0)
{
return ip;
}
else
{
memcpy(session->addr.addr, &ip, sizeof(long));
session->get_host_cb = cb;
ms_quick_timer(200, s, get_host_timer_cb, 0);
strcpy(g_host, host);
return MS_SOC_WAIT;
}
}
return MS_SOC_ERROR;
}
return MS_SOC_INVALID;
}
