attsock.c

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

/***************************************************************************
 *
 *                      Pollex Mobile Platform
 *
 * Copyright (c) 2004 by Pollex Mobile Software Co., Ltd. 
 *                       All Rights Reserved 
 *
 * Module   : attsock.c
 *
 * Purpose  : implement the function of Windows Socket
 *            
 **************************************************************************/
#ifdef MMI_ON_WIN32

#ifndef _WINSOCKAPI_
#define _WINSOCKAPI_
#endif
#ifndef IPPROTO_TCP
#define IPPROTO_TCP 6
#endif
#ifndef PF_INET
#define PF_INET (0) /* currently only support Internet */
#endif

#endif

#include "kal_non_specific_general_types.h"
#include "stack_config.h"
#include "soc_api.h"		/* for mtk socket api */
#include "app2soc_struct.h" /* interface with Applications */

#include "EventsGprot.h"	/* SetProtocolEventHandler */
#include "stack_common.h"
#include "stack_msgs.h"
#include  "protocolevents.h"

#include "plxclib.h"
#include "plxosal.h"
#include "attsock.h"

//#define SOCKET_MSGOUT
//#define ATTSOCK_WIN32
//#define SOCKET_SND_MSG
//#define SOCKET_HARD_ERR

#if 0
#ifdef SOCKET_MSGOUT
	#define MsgOut	
#else	
	#define MsgOut(x, y)
#endif
#endif


/**************************************************************************
 *
 *	constant definition
 *
 **************************************************************************/

#define IN_ADDR_LEN				4

#define SOCKET_VERSION			0x0110
#define SOCKET_DESCRIPTION		"Pollex Socket Version 1.1"
#define UDP_MAXMSGSIZE			1024*10

/**************************************************************************
 *
 *	data structure and type definition
 *
 **************************************************************************/

typedef struct tagWinSock
{	
	SOCKET			hSocket;		/* socket handle		*/	
	kal_int8		kSocket;		/* low layer socket handle */
	kal_int8		bUsed;
	kal_int8		Unused[2];		/* pad byte				*/
	void			*hWnd;			/* user window handle	*/
	unsigned long	uMsg;			/* user window message	*/
	unsigned long	uEvent;			/* user event			*/
	struct sockaddr_in laddr;		/* local address		*/
} WINSOCK;

#define SOCKET_NUM_MAX		10

static int	gSockNumber = 0;
static WINSOCK	gWinSock[SOCKET_NUM_MAX];
static long sock_error_no = 0;
static kal_int8	gSmsSocket = 0;
static kal_int8 gSmsInit = 0;

static void SockSetError(long iErr);
static long SockGetError(void);

static int Sock_GetIndexByHandle(SOCKET s);
static int Sock_GetIndexByKSocket(kal_int8 s);

static long error_convert(long error);
static long ParseIPaddr(char** p);
static int sockaddr_tokal(struct sockaddr *sockaddr, sockaddr_struct *kaladdr);

extern void SetProtocolEventHandler(PsFuncPtr funcPtr, U16 eventID);
static void pollex_socket_notify(void* inMsg);
static void get_hostname_ind(void* inMsg);

static int Sock_PostMessage(int i, long lEvent, long lError);

void ClearAllSocketEventHandler (void);
void ClearSocketEventHandler(U16 notifID);
U16 SetSocketEventHandler (PsFuncPtr funcPtr, U16 eventID);

/**************************************************************************
 *
 *	winsock api implementation
 *
 **************************************************************************/

//#ifdef PWAP_RONI_

#define WAP_PUSH_PORT	2948
#define PUSH_DATA_SIZE	1024

extern int Get_Dialer_id(void);

int SmsPush_Init(void)
{
	kal_int32	AccountID = 0,  result = 0;
    kal_uint8  value = 0;
	sockaddr_struct	addr;
    AccountID = Get_Dialer_id();
		
    if (gSmsInit)
    {
        return 0;
    }

//	gSmsSocket = soc_create(PF_INET, SOCK_SMS, 0, MOD_WAP, AccountID); 
    gSmsSocket = soc_create(PF_INET, SOCK_SMS, 0, MOD_MMI, 0); 
	if(gSmsSocket < 0)
	{
		return -1;
	}
	
	SetSocketEventHandler(pollex_socket_notify, MSG_ID_APP_SOC_NOTIFY_IND);

	memset(&addr, 0, sizeof(sockaddr_struct));
	addr.addr_len = 0;
	addr.port = WAP_PUSH_PORT;

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

    value = KAL_TRUE;
    soc_setsockopt(gSmsSocket, SOC_SILENT_LISTEN, &value, sizeof(value));

    if(soc_bind(gSmsSocket, &addr) < 0)
    {
        soc_close(gSmsSocket);
		gSmsSocket = -1;
        return -1;
    }

#if 0
    {
        unsigned char buf[1024];
		extern void WAP_DataOut(const unsigned char *pData, unsigned short Length,
				 const unsigned char *pName);

        value = soc_recv(gSmsSocket,  //socket id 
            buf, // buffer to receive 
            sizeof(buf),// buffer length 
            0);

		if (value > 0)
		{
			WAP_DataOut((const unsigned char *)buf, (unsigned short )value,
				 (const unsigned char *)"WAPProt Push Init");
		}
    }
#endif
    
    gSmsInit = 1;
	return 0;
}      

#ifndef ONLY_WHTTP
unsigned long WSMS_CallBack( unsigned long wsg, unsigned long  Param1, unsigned long  Param2);
#endif

void SmsPush_Recv(kal_int8 hSmsPush)
{
	kal_uint8	*data = NULL;
	kal_int32	result = 0, length = PUSH_DATA_SIZE;
	kal_int8	error = 0;

    data = malloc(PUSH_DATA_SIZE);

    if (data == NULL)
    {
        return;
    }

	memset(data, 0, PUSH_DATA_SIZE);
	result = soc_recv(hSmsPush, data, length, 0);

	if (result > 0)
	{
#ifndef ONLY_WHTTP
		WSMS_CallBack(0, (unsigned long  )data, (unsigned long  )result);
#endif
	}	

    free(data);
}

//#endif /* PWAP_RONI_ */

/* Microsoft Windows Extension function prototypes */
int WSAStartup(unsigned short wVersionRequired, LPWSADATA lpWSAData)
{
	ClearAllSocketEventHandler();

    SmsPush_Init();
    
	if (wVersionRequired > SOCKET_VERSION)
	{
		MsgOut("[gWinSock] - WSAStartup() failed with unsupportet version %d.\r\n", 0);
		return EOPNOTSUPP;
	}
	
	if( lpWSAData != NULL )
	{
		/* 将当前版本号以及SOCKET信息返回用于用户协商 */
		lpWSAData->wVersion = SOCKET_VERSION;
		lpWSAData->wHighVersion = SOCKET_VERSION;
		memcpy(lpWSAData->szDescription, SOCKET_DESCRIPTION, strlen(SOCKET_DESCRIPTION)+1);
		/* 不提供配置信息 */
		lpWSAData->szSystemStatus[0] = 0;
		lpWSAData->iMaxSockets = SOCKET_NUM_MAX;
		lpWSAData->iMaxUdpDg = UDP_MAXMSGSIZE;
		/* 保留销售商结构 */
		lpWSAData->lpVendorInfo = NULL;
	}	

#ifdef ATTSOCK_WIN32
    soc_init_win32();	/* 初始化MTK socket 库 */
#endif
	
//	SetProtocolEventHandler(pollex_socket_notify, MSG_ID_APP_SOC_NOTIFY_IND);
//	SetProtocolEventHandler(get_hostname_ind, MSG_ID_APP_SOC_GET_HOST_BY_NAME_IND);

	MsgOut("[gWinSock] + WSAStartup() successed %d.\r\n", 0);
	return 0;
}

int WSACleanup(void)
{
	MsgOut("[gWinSock] + WSACleanup() successed %d.\r\n", 0);
	return 0;
}

void WSASetLastError(long ierror)
{
	MsgOut("[gWinSock] + WSASetLasterror=%d\r\n", ierror);
	SockSetError(ierror);
}

long WSAGetLastError(void)
{
	long iErr = SockGetError();
	
	MsgOut("[gWinSock] + SockGetError=%d\r\n", (int)iErr);
	
	return iErr;
}

SOCKET plx_socket(int af, int type, int protocol)
{
	int i = 0;
	int account = 0;
	WINSOCK *pWinSock = NULL;

	account = Get_Dialer_id();
	
	if (account < 0)
	{
		return INVALID_SOCKET;
	}
	
	/* look up a free socket slot in winsock array */
	/*
	for (i = 0; i < SOCKET_NUM_MAX; i++)
	{
		if (!gWinSock[i].bUsed)
			break;
	}
	*/
	if (++gSockNumber >= SOCKET_NUM_MAX)
		gSockNumber = 0; 
		
	pWinSock = &gWinSock[gSockNumber];
	while (pWinSock->bUsed && i < SOCKET_NUM_MAX)
	{
		if (++gSockNumber >= SOCKET_NUM_MAX)
		{
			gSockNumber = 0;
		}
		
		pWinSock = &gWinSock[gSockNumber];
		i++;
	}	

	if (i == SOCKET_NUM_MAX)
	{
		MsgOut("[gWinSock] - create %s socket failed.\r\n", 
				(type == SOCK_STREAM ? "STREAM" : "DGRAM"));
		SockSetError(ESOCKTABLEFULL);
		return INVALID_SOCKET;
	}

	memset(pWinSock, 0, sizeof(WINSOCK));

	pWinSock->bUsed	= 1;
#ifndef ATTSOCK_WIN32
    af = PF_INET;
    type -= 1;
#endif

#ifdef SOCKET_MSGOUT
    MsgOut("[gWinSock] + socket call soc_create(af=%d, type = %d, protocol = %d, account = %d)", af, type, protocol, account);
#endif
    
	pWinSock->kSocket = soc_create((kal_int8)af, (kal_int8)type, (kal_int8)protocol, MOD_MMI, account);
	
	if (pWinSock->kSocket < 0)
	{
        /*
        kal_int8 kerr = 0;
        kal_int32 detail = 0;

        soc_get_last_error()
        */
		pWinSock->bUsed	= 0;
#ifdef SOCKET_MSGOUT
        MsgOut("[gWinSock] + socket call soc_create(kSocket=%d)\r\n", pWinSock->kSocket);
#endif
		return INVALID_SOCKET;
	}
	
	SetSocketEventHandler(pollex_socket_notify, MSG_ID_APP_SOC_NOTIFY_IND);
#ifdef SOCKET_MSGOUT
    MsgOut("[gWinSock] + socket call succeed kSocket = %d, socket = %d\r\n", pWinSock->hSocket, gSockNumber + 1);
#endif

	pWinSock->hSocket = gSockNumber + 1;
	return pWinSock->hSocket;
}

int plx_shutdown(SOCKET s, int how)
{
	int i = Sock_GetIndexByHandle(s);
	WINSOCK		*pWinSock = NULL;
		
	kal_int32	result = 0;
	kal_int8	error = 0;
	
	if (i < 0)
	{
		MsgOut("[gWinSock] - fail to shutdown a unknown socket, socket=%d\r\n", s);
		SockSetError(ENOTSOCK);
		return SOCKET_ERROR;
	}

	result = soc_shutdown(pWinSock->kSocket, (kal_uint8)how);
	if (result < 0)
	{
#ifdef SOCKET_HARD_ERR
		kal_int8	ret = 0;
		ret = soc_get_last_error(pWinSock->kSocket, &error, &result);
#endif

#ifdef SOCKET_MSGOUT
		MsgOut("[gWinSock] - fail to call soc_shutdown(), with error %d, socket=%d\r\n", s, error);
		MsgOut("[gWinSock] - fail soc_shutdown(), result = %d\r\n", result);
#endif
		//SockSetError(error);
        SockSetError(result);
		result = SOCKET_ERROR;
	}

	return result;
}

int plx_closesocket(SOCKET s)
{
	int i = Sock_GetIndexByHandle(s);
	if (i < 0)
	{
		MsgOut("[gWinSock] - fail to close a unknown socket, socket=%d\r\n", s);
		SockSetError(ENOTSOCK);
		return SOCKET_ERROR;
	}

	MsgOut("[gWinSock] + close socket OK, socket=%d, kSocket=%d\r\n", s, gWinSock[i].kSocket);
	soc_close(gWinSock[i].kSocket);	
	memset(&gWinSock[i], 0, sizeof(gWinSock[i]));
	
	return 0;
}

SOCKET plx_accept(SOCKET s, struct sockaddr *addr, int *addrlen)
{
	SOCKADDR_IN *remote = (SOCKADDR_IN*)addr;
	int	i = Sock_GetIndexByHandle(s);
	WINSOCK		*pWinSock = NULL;

	sockaddr_struct remoteAddr;		/* socket address structure */
	//kal_int32	result = 0;
	//kal_int8	error = 0;

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

	if (addr == NULL || addrlen == NULL || *addrlen < sizeof(SOCKADDR_IN))
	{
		MsgOut("[gWinSock] - call accept(), with invalid param=%d\r\n", s);
		SockSetError(EINVALIDPARA);
		return INVALID_SOCKET;
	}

	pWinSock = &gWinSock[i];	/* 侦听控制块 */

	/* look up a free socket slot in winsock array */
	for (i = 0; i < SOCKET_NUM_MAX; i++)
	{
		if (!gWinSock[i].bUsed)
			break;
	}
	
	if (i == SOCKET_NUM_MAX)
	{
		MsgOut("[gWinSock] - accept %d socket failed.\r\n", s);
		SockSetError(ESOCKTABLEFULL);
		return INVALID_SOCKET;
	}
	
	memset(&gWinSock[i], 0, sizeof(WINSOCK));
	gWinSock[i].bUsed	= 1;
	gWinSock[i].hSocket = i + 1;
	gWinSock[i].kSocket = soc_accept(pWinSock->kSocket, &remoteAddr);
		
	if (gWinSock[i].kSocket < 0)
	{
		MsgOut("[gWinSock] - accept() err %d!\r\n", gWinSock[i].kSocket);
		memset( &(gWinSock[i]), 0, sizeof(WINSOCK) );
		SockSetError(EOPNOTSUPP);
		return INVALID_SOCKET;
	}

    gWinSock[i].uEvent = pWinSock->uEvent;
    gWinSock[i].hWnd = pWinSock->hWnd;			/* user window handle	*/
	gWinSock[i].uMsg = pWinSock->uMsg;			/* user window message	*/

	remote->sin_family = AF_INET;
	remote->sin_port = htons(remoteAddr.port);
	memcpy(&remote->sin_addr.S_un.S_addr, remoteAddr.addr, remoteAddr.addr_len);
	*addrlen = remoteAddr.addr_len;

		
	return gWinSock[i].hSocket;
}


int plx_bind(SOCKET s, const struct sockaddr *addr, int addrlen)
{		
	int i = Sock_GetIndexByHandle(s);
	WINSOCK		*pWinSock = NULL;

	sockaddr_struct localAddr;		/* socket address structure */
	kal_int32	result = 0;
	kal_int8	error = 0;
	
	if (i < 0)
	{