attsock.c

mtk wap和mms代码。。适应mtk 25。26平台

	*namelen = remoteAddr.addr_len;

	return result;
}

int plx_getsockopt(SOCKET s, int level, int optname, char *optval, int *optlen)
{
	int i = Sock_GetIndexByHandle(s);
	
	//sockaddr_struct localAddr;		/* socket address structure */
	kal_int32	result = 0;
    //kal_int8	error = 0;
	//kal_uint8 	val = 0;
	
	if (i < 0)
	{
		MsgOut("[gWinSock] - fail to call getsockopt(), with unknown socket, socket=%d\r\n",s);
		SockSetError(ENOTSOCK);
		return SOCKET_ERROR;
	}

	if (optval == NULL || optlen == NULL)
	{
		MsgOut("[gWinSock] - fail to call getsockopt(), with invalid param, socket=%d\r\n",s);
		SockSetError(EINVALIDPARA);
		return SOCKET_ERROR;
	}

	switch (level) 
	{
	case SOL_SOCKET:		
		switch (optname) 
		{
		case SO_ACCEPTCONN:
			break;
		case SO_BROADCAST:
			break;
		case SO_DEBUG:
			break;
		case SO_REUSEADDR:
			break;
		case SO_DONTROUTE:
			break;
		default:
			break;
		}
		break;	/* SOL_SOCKET */
	case IPPROTO_TCP:
		switch (optname) 
		{
		case SO_SNDBUF:
			break;
		case SO_RCVBUF:
			break;
		default:
			break;
		}
		break;
	default:
		break;
	}

	MsgOut("[gWinSock] - getsockopt() not supported %d!\r\n", result);
	SockSetError(EOPNOTSUPP);
	return SOCKET_ERROR;	
}

int plx_setsockopt(SOCKET s, int level, int optname, char* optval, int optlen)
{
	MsgOut("[gWinSock] - setsockopt() not supported %d!\r\n", 0);
	SockSetError(EOPNOTSUPP);
	return SOCKET_ERROR;
}

int WSAAsyncSelect(SOCKET s, void *hWnd, unsigned int uMsg, long lEvent)
{
	int i = Sock_GetIndexByHandle(s);
	//long event = 0;
	WINSOCK		*pWinSock = NULL;
	
	kal_int32	result = 0;
	//kal_int8	error = 0;
	kal_uint8	value = 1;

	if (i < 0)
	{
		MsgOut("[gWinSock] - call WSAAsyncSelect(), with unknown socket=%d\r\n", s);
		SockSetError(ENOTSOCK);
		return SOCKET_ERROR;
	}

	pWinSock = &gWinSock[i];

	result = soc_setsockopt(pWinSock->kSocket, SOC_NBIO, &value, sizeof(value));
	if(result < 0)
	{
		result = error_convert(result);
		SockSetError(result);
		return SOCKET_ERROR;
	}
	
	value = SOC_READ | SOC_WRITE | SOC_ACCEPT | SOC_CLOSE | SOC_CONNECT;
	result = soc_setsockopt(pWinSock->kSocket, SOC_ASYNC, &value, sizeof(value));
	if(result < 0)
	{
		result = error_convert(result);
		SockSetError(result);
		return SOCKET_ERROR;
	}	

	gWinSock[i].hWnd	= hWnd;
	gWinSock[i].uMsg	= uMsg;
	gWinSock[i].uEvent	= lEvent;
	
	return 0;
}

unsigned short plx_ntohs(unsigned short netshort)
{
	unsigned short n = (unsigned short)netshort;
	unsigned char *p = (unsigned char *)&n;
	unsigned short temp = 0;
	
	temp = (unsigned short)((p[0] << 8) | p[1]);
	
	return temp;
}

unsigned short plx_htons(unsigned short hostshort)
{
	unsigned short r = 0;
	
	*(unsigned char *)(&r) = (unsigned char )((hostshort >> 8) & 0xff);
	*((unsigned char *)(&r) + 1) = (unsigned char )(hostshort & 0xff);
	return r;
}

unsigned long plx_htonl(unsigned long hostlong)
{
	unsigned int r = 0;
	
	*(unsigned char *)(&r) = (unsigned char )((hostlong >> 24) & 0xff);
	*((unsigned char *)(&r) + 1) = (unsigned char )((hostlong >> 16) & 0xff);
	*((unsigned char *)(&r) + 2) = (unsigned char )((hostlong >> 8) & 0xff);
	*((unsigned char *)(&r) + 3) = (unsigned char )(hostlong & 0xff);

	return r;
}

unsigned long plx_ntohl(unsigned long netlong)
{
	unsigned char * p = (unsigned char *)&netlong;
	unsigned int temp = 0;
	
	temp = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
	
	return temp;
}

#define NTOA_ADDR_LEN	20
char *inet_ntoa(struct in_addr in)
{
	/* 初始化用于inet_ntoa的专用数据区域 */
	static char ntoaBuffer[NTOA_ADDR_LEN];	/* DNS-IP reverse buffer */
	
	memset(ntoaBuffer, 0, NTOA_ADDR_LEN);	
	sprintf(ntoaBuffer, "%d.%d.%d.%d", in.S_un.S_un_b.s_b1,
		in.S_un.S_un_b.s_b2, in.S_un.S_un_b.s_b3, in.S_un.S_un_b.s_b4);
	
	return ntoaBuffer;
}

unsigned long inet_addr(const char *cp)
{
	long     i, ret = 0;
	unsigned char  addr[4];
	unsigned int result = 0;
	int valid = 1;
	
	if (cp == NULL)
	{
		return INADDR_NONE;
	}
	
    // 非默认地址
	for (i = 0; i < 4; i++)
	{
        ret = ParseIPaddr( (char** )&cp );
		if (ret != -1)
		{
			addr[i] = (unsigned char )ret;
		}

		if (ret == -1 || (*cp != '.' && *cp != 0))
		{
			valid = 0;
			break;
		}
		// 跳过 “.” 
		cp ++;
	}
	if ( ret == -1 || valid == 0 )
	{
		return INADDR_NONE;
	}
	
	result = *(unsigned int* )addr;	
	return result;
}

extern BOOL PlxPostMessage(HWND hWnd,  UINT Msg,  WPARAM wParam, LPARAM lParam);

/* 底层socket接收到事件时, 通过此函数通知应用程序 */
static void pollex_socket_notify(void* inMsg)
{	
	int		i		= 0;	
    long	lError	= 0;
    kal_uint8	event_type	= 0;   /* soc_event_enum */
    kal_int8	socket_id	= 0;    /* socket ID */	

#if 0    
	kal_uint8	ref_count	= 0;
	kal_uint16	msg_len		= 0;		
	kal_bool	result		= 0;
	kal_int8	error_cause	= 0;  /* used only when EVENT is close/connect */
	kal_int32	detail_cause= 0; /* refer to cm_cause_enum if error_cause is SOC_BEARER_FAIL */
#endif
        
    app_soc_notify_ind_struct *soc_notify = (app_soc_notify_ind_struct *) inMsg;

#ifdef SOCKET_MSGOUT
    MsgOut("[gWinSock] socket notify(addr=%x) sockID[%d] event[%d] result[%d] ref_count[%d] msg_len[%d] err[%d] detail[%d]\r\n", soc_notify, 
        soc_notify->socket_id,
        soc_notify->event_type,
        soc_notify->result,
        soc_notify->ref_count,
        soc_notify->msg_len,
        soc_notify->error_cause,
        soc_notify->detail_cause);
#endif

    if (soc_notify == NULL)
    {
        return;
    }

	event_type = soc_notify->event_type;
	socket_id = soc_notify->socket_id;

	lError = error_convert(soc_notify->error_cause);	/* 错误原因 */

    i = Sock_GetIndexByKSocket(socket_id);
	
	if (i < 0 && socket_id != gSmsSocket )
	{
        MsgOut ("receive msg from sockID[%d]", socket_id);
		return;
	}

	switch (event_type)
	{
	case SOC_WRITE:
#ifdef SOCKET_MSGOUT
        MsgOut("[gWinSock] + notify: FD_WRITE(kSocket=%d, socket = %d) \r\n", soc_notify->socket_id, i + 1);
#endif
		Sock_PostMessage(i, FD_WRITE, lError);
		break;
		
	case SOC_READ:
#ifdef SOCKET_MSGOUT
        MsgOut("[gWinSock] + notify: FD_READ(kSocket=%d, socket = %d) \r\n", soc_notify->socket_id, i + 1);
#endif
        if (socket_id == gSmsSocket)
        {
            SmsPush_Recv(socket_id);
        }
        else
            Sock_PostMessage(i, FD_READ, lError);
		break;
		
	case SOC_ACCEPT:
		if (socket_id == gSmsSocket)
		{
			SmsPush_Recv(socket_id);
		}
		else
		{
			Sock_PostMessage(i, FD_ACCEPT, lError);
		}
		break;

	case SOC_CONNECT:
#ifdef SOCKET_MSGOUT
        MsgOut("[gWinSock] + notify: FD_CONNECT(kSocket=%d, socket = %d) \r\n", soc_notify->socket_id, i + 1);
#endif
		Sock_PostMessage(i, FD_CONNECT, lError);
		break;
		
	case SOC_CLOSE:
#ifdef SOCKET_MSGOUT
        MsgOut("[gWinSock] + notify: FD_CLOSE(kSocket=%d, socket = %d) \r\n", soc_notify->socket_id, i + 1);
#endif
        if ( gWinSock[i].Unused[0] == SOC_CLOSE )
            break;
//		if ( soc_notify->error_cause == SOC_BEARER_FAIL )
//			DIALMGR_Networkdown ();
        gWinSock[i].Unused[0] = SOC_CLOSE;
		Sock_PostMessage(i, FD_CLOSE, lError);
		break;
		
	default:		
		break;
    }
}


/**************************************************************************
 *
 *	INTERNAL FUNCTION
 *
 **************************************************************************/

/* set error code to globle variable */
static void SockSetError(long iErr)
{
	sock_error_no = iErr;
}

/* get error code from globle variable */
static long SockGetError(void)
{
	return sock_error_no;
}

/* get socket slot index by socket ID */
static int Sock_GetIndexByHandle(SOCKET s)
{
	int i = 0;
	for (i = 0; i < SOCKET_NUM_MAX; i++)
	{
		if (gWinSock[i].bUsed && gWinSock[i].hSocket == s)
			break;
	}

	if (i == SOCKET_NUM_MAX)
	{
		return -1;
	}
	
	return i;
}

/* translate MTK error code to Pollex attsock defined error code */
static long error_convert(long error)
{
	long result = 0;

	switch (error)
	{
	case SOC_SUCCESS:
		break;
	case SOC_ERROR:
		result = SOCKET_ERROR;
		break;
	case SOC_WOULDBLOCK:		
		result = EWOULDBLOCK;
		break;
	case SOC_LIMIT_RESOURCE:		
		result = ELOWSYSRESOURCE;
		break;
	case SOC_INVALID_SOCKET:		
		result = INVALID_SOCKET;
		break;
	case SOC_NAMETOOLONG:	
		result = EINVALIDPARA;
		break;
	case SOC_ALREADY:
		result = EINPROGRESS;
		break;
	case SOC_OPNOTSUPP:
		result = EOPNOTSUPP;
		break;
	case SOC_CONNABORTED:
		result = ECONNABORTED;
		break;
	case SOC_INVAL:
		result = EINVAL;
		break;
	case SOC_PIPE:
		break;
	case SOC_NOTCONN:
		result = ENOTCONN;
		break;
	case SOC_MSGSIZE:
		result = EMSGSIZE;
		break;
	case SOC_BEARER_FAIL:
		result = ENETDOWN;
		break;
	case SOC_CONNRESET:
		result = ERESET;
		break;
	default:
		result = EUNKNOWERROR;
		break;
	}

	return result;
}

/* 把用户传入的地址格式转换成MTK的地址格式 */
static int sockaddr_tokal(struct sockaddr *sockaddr, sockaddr_struct *kaladdr)
{
	struct sockaddr_in *addr = (struct sockaddr_in *)sockaddr;

	if (sockaddr == NULL || kaladdr == NULL)
	{
		return -1;
	}

	memset(kaladdr, 0, sizeof(sockaddr_struct));
	kaladdr->port = ntohs(addr->sin_port);		/* 主机字节序 */
	kaladdr->addr_len = sizeof(addr->sin_addr);
	memcpy(kaladdr->addr, &addr->sin_addr, kaladdr->addr_len);/* 网络字节序 */

	return 0;
}

/* analyse IP address */
static long ParseIPaddr(char** p)
{
	char * ptr;
	long val = 0;
	long bits = 0;
	
    ptr = *p;
    while (*ptr >= '0' && *ptr <= '9')
    {
		bits ++;
		val = val * 10 + (*ptr - '0');
		ptr ++;
	}
	
	if (!(bits >= 1 && bits <= 3 && val >= 0 && val <= 255))
	{
		return -1;
	}
	
	*p = ptr;
	return val;
}

/* get MTK socket slot index by MTK socket ID */
static int Sock_GetIndexByKSocket(kal_int8 s)
{
	int i = 0;

	for (i = 0; i < SOCKET_NUM_MAX; i++)
	{
		if (gWinSock[i].bUsed && gWinSock[i].kSocket == s)
			break;
	}
	
	if (i == SOCKET_NUM_MAX)
	{
		return -1;
	}
	
	return i;
}

/* Post Pollex socket messages */
static int Sock_PostMessage(int i, long lEvent, long lError)
{
	if (gWinSock[i].uEvent & lEvent)
	{
		PlxPostMessage(gWinSock[i].hWnd, gWinSock[i].uMsg, 
			gWinSock[i].hSocket, MAKELONG(lEvent, lError));
	}

	return 0;
}

typedef struct tagDNSInquery
{
	struct tagDNSInquery *next;
	void			*hWnd;			/* user window handle */
	unsigned long   uMsg;			/* user window message */
	unsigned int	hAsync;			/* user id */
	kal_int16		lookup_id;		/* low layer id */
	char			*hostname;
	char			*hostent;		/* user inquiry data buffer */
	long			hostentlen;		/* user data buffer size */
}DNS_INQUERY;

/**************************************************************************\
*
*	GLOBLE VARIABLE DEFINITION
*
\**************************************************************************/