svn.miranda.im is moving to a new home!

git-svn-id: http://miranda-plugins.googlecode.com/svn/trunk@7 e753b5eb-9565-29b2-b5c5-2cc6f99dfbcb

1 files changed, 503 insertions, 0 deletions

diff --git a/miranda-wine/src/modules/netlib/netlib.c b/miranda-wine/src/modules/netlib/netlib.c
new file mode 100644
index 0000000..72a0370
--- /dev/null
+++ b/miranda-wine/src/modules/netlib/netlib.c
@@ -0,0 +1,503 @@
+/*

+

+Miranda IM: the free IM client for Microsoft* Windows*

+

+Copyright 2000-2006 Miranda ICQ/IM project, 

+all portions of this codebase are copyrighted to the people 

+listed in contributors.txt.

+

+This program is free software; you can redistribute it and/or

+modify it under the terms of the GNU General Public License

+as published by the Free Software Foundation; either version 2

+of the License, or (at your option) any later version.

+

+This program is distributed in the hope that it will be useful,

+but WITHOUT ANY WARRANTY; without even the implied warranty of

+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+GNU General Public License for more details.

+

+You should have received a copy of the GNU General Public License

+along with this program; if not, write to the Free Software

+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

+*/

+#include "commonheaders.h"

+#include "netlib.h"

+

+struct NetlibUser **netlibUser=NULL;

+int netlibUserCount=0;

+CRITICAL_SECTION csNetlibUser;

+HANDLE hConnectionHeaderMutex;

+DWORD g_LastConnectionTick; // protected by csNetlibUser

+

+void NetlibFreeUserSettingsStruct(NETLIBUSERSETTINGS *settings)

+{

+	if(settings->szIncomingPorts) mir_free(settings->szIncomingPorts);

+	if(settings->szOutgoingPorts) mir_free(settings->szOutgoingPorts);

+	if(settings->szProxyAuthPassword) mir_free(settings->szProxyAuthPassword);

+	if(settings->szProxyAuthUser) mir_free(settings->szProxyAuthUser);

+	if(settings->szProxyServer) mir_free(settings->szProxyServer);

+}

+

+void NetlibInitializeNestedCS(struct NetlibNestedCriticalSection *nlncs)

+{

+	nlncs->dwOwningThreadId= 0;

+	nlncs->lockCount=0;

+	nlncs->hMutex=CreateMutex(NULL,FALSE,NULL);

+}

+

+void NetlibDeleteNestedCS(struct NetlibNestedCriticalSection *nlncs)

+{

+	CloseHandle(nlncs->hMutex);

+}

+

+int NetlibEnterNestedCS(struct NetlibConnection *nlc,int which)

+{

+	struct NetlibNestedCriticalSection *nlncs;

+	DWORD dwCurrentThreadId=GetCurrentThreadId();

+

+	WaitForSingleObject(hConnectionHeaderMutex,INFINITE);

+	if(nlc==NULL || nlc->handleType!=NLH_CONNECTION) {

+		ReleaseMutex(hConnectionHeaderMutex);

+		SetLastError(ERROR_INVALID_PARAMETER);

+		return 0;

+	}

+	nlncs=which==NLNCS_SEND?&nlc->ncsSend:&nlc->ncsRecv;

+	if(nlncs->lockCount && (nlc->ncsRecv.dwOwningThreadId==dwCurrentThreadId || nlc->ncsSend.dwOwningThreadId==dwCurrentThreadId)) {

+		nlncs->lockCount++;

+		ReleaseMutex(hConnectionHeaderMutex);

+		return 1;

+	}

+	InterlockedIncrement(&nlc->dontCloseNow);

+	ResetEvent(nlc->hOkToCloseEvent);

+	ReleaseMutex(hConnectionHeaderMutex);

+	WaitForSingleObject(nlncs->hMutex,INFINITE);

+	nlncs->dwOwningThreadId=dwCurrentThreadId;

+	nlncs->lockCount=1;

+	if(InterlockedDecrement(&nlc->dontCloseNow)==0)

+		SetEvent(nlc->hOkToCloseEvent);

+	return 1;

+}

+

+void NetlibLeaveNestedCS(struct NetlibNestedCriticalSection *nlncs)

+{

+	if(--nlncs->lockCount==0) {

+		nlncs->dwOwningThreadId=0;

+		ReleaseMutex(nlncs->hMutex);

+	}

+}

+

+static int GetNetlibUserSettingInt(const char *szUserModule,const char *szSetting,int defValue)

+{

+	DBVARIANT dbv;

+	if(DBGetContactSetting(NULL,szUserModule,szSetting,&dbv)

+	   && DBGetContactSetting(NULL,"Netlib",szSetting,&dbv))

+		return defValue;

+	if(dbv.type==DBVT_BYTE) return dbv.bVal;

+	if(dbv.type==DBVT_WORD) return dbv.wVal;

+	return dbv.dVal;

+}

+

+static char *GetNetlibUserSettingString(const char *szUserModule,const char *szSetting,int decode)

+{

+	DBVARIANT dbv;

+	if(DBGetContactSetting(NULL,szUserModule,szSetting,&dbv)

+	   && DBGetContactSetting(NULL,"Netlib",szSetting,&dbv)) {

+		return NULL;

+	}

+	else {

+		char *szRet;

+		if(decode) CallService(MS_DB_CRYPT_DECODESTRING, strlen(dbv.pszVal) + 1, (LPARAM)dbv.pszVal);

+		szRet=mir_strdup(dbv.pszVal);

+		DBFreeVariant(&dbv);

+		if(szRet==NULL) SetLastError(ERROR_OUTOFMEMORY);

+		return szRet;

+	}

+}

+

+static int NetlibRegisterUser(WPARAM wParam,LPARAM lParam)

+{

+	NETLIBUSER *nlu=(NETLIBUSER*)lParam;

+	struct NetlibUser *thisUser;

+	int i;

+

+	if(nlu==NULL || nlu->cbSize!=sizeof(NETLIBUSER) || nlu->szSettingsModule==NULL

+	   || (!(nlu->flags&NUF_NOOPTIONS) && nlu->szDescriptiveName==NULL)

+	   || (nlu->flags&NUF_HTTPGATEWAY && (nlu->pfnHttpGatewayInit==NULL))) {

+		SetLastError(ERROR_INVALID_PARAMETER);

+		return (int)(HANDLE)NULL;

+	}

+

+	EnterCriticalSection(&csNetlibUser);

+	for(i=0;i<netlibUserCount;i++)

+		if(!lstrcmpA(netlibUser[i]->user.szSettingsModule,nlu->szSettingsModule)) {

+			LeaveCriticalSection(&csNetlibUser);

+			SetLastError(ERROR_DUP_NAME);

+			return (int)(HANDLE)NULL;

+		}

+	LeaveCriticalSection(&csNetlibUser);

+

+	thisUser=(struct NetlibUser*)mir_calloc(sizeof(struct NetlibUser));

+	thisUser->handleType=NLH_USER;

+	thisUser->user=*nlu;

+	if((thisUser->user.szSettingsModule=mir_strdup(nlu->szSettingsModule))==NULL

+	   || (nlu->szDescriptiveName && (thisUser->user.szDescriptiveName=mir_strdup(nlu->szDescriptiveName))==NULL)

+	   || (nlu->szHttpGatewayUserAgent && (thisUser->user.szHttpGatewayUserAgent=mir_strdup(nlu->szHttpGatewayUserAgent))==NULL)) {

+		SetLastError(ERROR_OUTOFMEMORY);

+		return (int)(HANDLE)NULL;

+	}

+	if (nlu->szHttpGatewayHello) 

+		thisUser->user.szHttpGatewayHello=mir_strdup(nlu->szHttpGatewayHello);

+	else

+		thisUser->user.szHttpGatewayHello=NULL;

+

+	thisUser->settings.cbSize=sizeof(NETLIBUSERSETTINGS);

+	thisUser->settings.useProxy=GetNetlibUserSettingInt(thisUser->user.szSettingsModule,"NLUseProxy",0);

+	thisUser->settings.proxyType=GetNetlibUserSettingInt(thisUser->user.szSettingsModule,"NLProxyType",PROXYTYPE_SOCKS5);

+	if(thisUser->user.flags&NUF_NOHTTPSOPTION && thisUser->settings.proxyType==PROXYTYPE_HTTPS)

+		thisUser->settings.proxyType=PROXYTYPE_HTTP;

+	if(!(thisUser->user.flags&(NUF_HTTPCONNS|NUF_HTTPGATEWAY)) && thisUser->settings.proxyType==PROXYTYPE_HTTP) {

+		thisUser->settings.useProxy=0;

+		thisUser->settings.proxyType=PROXYTYPE_SOCKS5;

+	}

+	thisUser->settings.szProxyServer=GetNetlibUserSettingString(thisUser->user.szSettingsModule,"NLProxyServer",0);

+	thisUser->settings.wProxyPort=GetNetlibUserSettingInt(thisUser->user.szSettingsModule,"NLProxyPort",1080);

+	thisUser->settings.useProxyAuth=GetNetlibUserSettingInt(thisUser->user.szSettingsModule,"NLUseProxyAuth",0);

+	thisUser->settings.szProxyAuthUser=GetNetlibUserSettingString(thisUser->user.szSettingsModule,"NLProxyAuthUser",0);

+	thisUser->settings.szProxyAuthPassword=GetNetlibUserSettingString(thisUser->user.szSettingsModule,"NLProxyAuthPassword",1);

+	thisUser->settings.useProxyAuthNtlm=GetNetlibUserSettingInt(thisUser->user.szSettingsModule,"NLUseProxyAuthNtlm",0);

+	thisUser->settings.dnsThroughProxy=GetNetlibUserSettingInt(thisUser->user.szSettingsModule,"NLDnsThroughProxy",1);

+	thisUser->settings.specifyIncomingPorts=GetNetlibUserSettingInt(thisUser->user.szSettingsModule,"NLSpecifyIncomingPorts",0);

+	thisUser->settings.szIncomingPorts=GetNetlibUserSettingString(thisUser->user.szSettingsModule,"NLIncomingPorts",0);

+	thisUser->settings.specifyOutgoingPorts=GetNetlibUserSettingInt(thisUser->user.szSettingsModule,"NLSpecifyOutgoingPorts",0);

+	thisUser->settings.szOutgoingPorts=GetNetlibUserSettingString(thisUser->user.szSettingsModule,"NLOutgoingPorts",0);

+

+	EnterCriticalSection(&csNetlibUser);

+	netlibUser=(struct NetlibUser**)mir_realloc(netlibUser,sizeof(struct NetlibUser*)*++netlibUserCount);

+	netlibUser[netlibUserCount-1]=thisUser;

+	LeaveCriticalSection(&csNetlibUser);

+	return (int)thisUser;

+}

+

+static int NetlibGetUserSettings(WPARAM wParam,LPARAM lParam)

+{

+	NETLIBUSERSETTINGS *nlus=(NETLIBUSERSETTINGS*)lParam;

+	struct NetlibUser *nlu=(struct NetlibUser*)wParam;

+

+	if(GetNetlibHandleType(nlu)!=NLH_USER || nlus==NULL || nlus->cbSize!=sizeof(NETLIBUSERSETTINGS)) {

+		SetLastError(ERROR_INVALID_PARAMETER);

+		return 0;

+	}

+	*nlus=nlu->settings;

+	return 1;

+}

+

+static int NetlibSetUserSettings(WPARAM wParam,LPARAM lParam)

+{

+	NETLIBUSERSETTINGS *nlus=(NETLIBUSERSETTINGS*)lParam;

+	struct NetlibUser *nlu=(struct NetlibUser*)wParam;

+

+	if(GetNetlibHandleType(nlu)!=NLH_USER || nlus==NULL || nlus->cbSize!=sizeof(NETLIBUSERSETTINGS)) {

+		SetLastError(ERROR_INVALID_PARAMETER);

+		return 0;

+	}

+	NetlibFreeUserSettingsStruct(&nlu->settings);

+	NetlibSaveUserSettingsStruct(nlu->user.szSettingsModule,nlus);

+	return 1;

+}

+

+int NetlibCloseHandle(WPARAM wParam,LPARAM lParam)

+{

+	switch(GetNetlibHandleType(wParam)) {

+		case NLH_USER:

+		{	struct NetlibUser *nlu=(struct NetlibUser*)wParam;

+			int i;

+			EnterCriticalSection(&csNetlibUser);

+			for(i=0;i<netlibUserCount;i++)

+				if(!lstrcmpA(netlibUser[i]->user.szSettingsModule,nlu->user.szSettingsModule)) {

+					netlibUserCount--;

+					memmove(netlibUser+i,netlibUser+i+1,(netlibUserCount-i)*sizeof(struct NetlibUser*));

+					break;

+				}

+			LeaveCriticalSection(&csNetlibUser);

+			NetlibFreeUserSettingsStruct(&nlu->settings);

+			if(nlu->user.szSettingsModule) mir_free(nlu->user.szSettingsModule);

+			if(nlu->user.szDescriptiveName) mir_free(nlu->user.szDescriptiveName);

+			if(nlu->user.szHttpGatewayHello) mir_free(nlu->user.szHttpGatewayHello);

+			if(nlu->user.szHttpGatewayUserAgent) mir_free(nlu->user.szHttpGatewayUserAgent);

+			if(nlu->szStickyHeaders) mir_free(nlu->szStickyHeaders);

+			break;

+		}

+		case NLH_CONNECTION:

+		{	struct NetlibConnection *nlc=(struct NetlibConnection*)wParam;

+			HANDLE waitHandles[4];

+			DWORD waitResult;

+

+			WaitForSingleObject(hConnectionHeaderMutex,INFINITE);

+			if (nlc->usingHttpGateway)
+			{
+				struct NetlibHTTPProxyPacketQueue *p = nlc->pHttpProxyPacketQueue;
+				while (p != NULL) {
+					struct NetlibHTTPProxyPacketQueue *t = p;
+
+					p = p->next;
+
+					mir_free(t->dataBuffer);
+					mir_free(t);
+				}
+			}
+			else
+			{
+				if(nlc->handleType!=NLH_CONNECTION || nlc->s==INVALID_SOCKET) {
+					ReleaseMutex(hConnectionHeaderMutex);
+					SetLastError(ERROR_INVALID_PARAMETER);	  //already been closed
+					return 0;
+				}
+				closesocket(nlc->s);
+				nlc->s=INVALID_SOCKET;
+			}

+			ReleaseMutex(hConnectionHeaderMutex);

+

+			waitHandles[0]=hConnectionHeaderMutex;

+			waitHandles[1]=nlc->hOkToCloseEvent;

+			waitHandles[2]=nlc->ncsRecv.hMutex;

+			waitHandles[3]=nlc->ncsSend.hMutex;

+			waitResult=WaitForMultipleObjects( SIZEOF(waitHandles),waitHandles,TRUE,INFINITE);

+			if(waitResult<WAIT_OBJECT_0 || waitResult >= WAIT_OBJECT_0 + SIZEOF(waitHandles)) {

+				ReleaseMutex(hConnectionHeaderMutex);

+				SetLastError(ERROR_INVALID_PARAMETER);	  //already been closed

+				return 0;

+			}

+			nlc->handleType=0;

+			if(nlc->nlhpi.szHttpPostUrl) mir_free(nlc->nlhpi.szHttpPostUrl);

+			if(nlc->nlhpi.szHttpGetUrl) mir_free(nlc->nlhpi.szHttpGetUrl);

+			if(nlc->dataBuffer) mir_free(nlc->dataBuffer);

+			if(nlc->hInstSecurityDll) FreeLibrary(nlc->hInstSecurityDll);

+			NetlibDeleteNestedCS(&nlc->ncsRecv);

+			NetlibDeleteNestedCS(&nlc->ncsSend);

+			CloseHandle(nlc->hOkToCloseEvent);

+			DeleteCriticalSection(&nlc->csHttpSequenceNums);

+			ReleaseMutex(hConnectionHeaderMutex);

+			Netlib_Logf(nlc->nlu,"(%p:%u) Connection closed",nlc,nlc->s);

+			break;

+		}

+		case NLH_BOUNDPORT:

+			return NetlibFreeBoundPort((struct NetlibBoundPort*)wParam);

+		case NLH_PACKETRECVER:

+		{	struct NetlibPacketRecver *nlpr=(struct NetlibPacketRecver*)wParam;

+			mir_free(nlpr->packetRecver.buffer);

+			break;

+		}

+		default:

+			SetLastError(ERROR_INVALID_PARAMETER);

+			return 0;

+	}

+	mir_free((void*)wParam);

+	return 1;

+}

+

+static int NetlibGetSocket(WPARAM wParam,LPARAM lParam)

+{

+	SOCKET s;

+	if((void*)wParam==NULL) {

+		s=INVALID_SOCKET;

+		SetLastError(ERROR_INVALID_PARAMETER);

+	}

+	else {

+		WaitForSingleObject(hConnectionHeaderMutex,INFINITE);

+		switch(GetNetlibHandleType(wParam)) {

+			case NLH_CONNECTION:

+				s=(int)((struct NetlibConnection*)wParam)->s;

+				break;

+			case NLH_BOUNDPORT:

+				s=(int)((struct NetlibBoundPort*)wParam)->s;

+				break;

+			default:

+				s=INVALID_SOCKET;

+				SetLastError(ERROR_INVALID_PARAMETER);

+				break;

+		}

+		ReleaseMutex(hConnectionHeaderMutex);

+	}

+	return s;

+}

+

+static char szHexDigits[]="0123456789ABCDEF";

+int NetlibHttpUrlEncode(WPARAM wParam,LPARAM lParam)

+{

+	unsigned char *szOutput,*szInput=(unsigned char*)lParam;

+	unsigned char *pszIn,*pszOut;

+	int outputLen;

+

+	if(szInput==NULL) {

+		SetLastError(ERROR_INVALID_PARAMETER);

+		return (int)(char*)NULL;

+	}

+	for(outputLen=0,pszIn=szInput;*pszIn;pszIn++) {

+		if(isalnum(*pszIn) || *pszIn==' ') outputLen++;

+		else outputLen+=3;

+	}

+	szOutput=(unsigned char*)HeapAlloc(GetProcessHeap(),0,outputLen+1);

+	if(szOutput==NULL) {

+		SetLastError(ERROR_OUTOFMEMORY);

+		return (int)(unsigned char*)NULL;

+	}

+	for(pszOut=szOutput,pszIn=szInput;*pszIn;pszIn++) {

+		if(isalnum(*pszIn)) *pszOut++=*pszIn;

+		else if(*pszIn==' ') *pszOut++='+';

+		else {

+			*pszOut++='%';

+			*pszOut++=szHexDigits[*pszIn>>4];

+			*pszOut++=szHexDigits[*pszIn&0xF];

+		}

+	}

+	*pszOut='\0';

+	return (int)szOutput;

+}

+

+static char base64chars[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

+int NetlibBase64Encode(WPARAM wParam,LPARAM lParam)

+{

+	NETLIBBASE64 *nlb64=(NETLIBBASE64*)lParam;

+	int iIn;

+	char *pszOut;

+	PBYTE pbIn;

+

+	if(nlb64==NULL || nlb64->pszEncoded==NULL || nlb64->pbDecoded==NULL) {

+		SetLastError(ERROR_INVALID_PARAMETER);

+		return 0;

+	}

+	if(nlb64->cchEncoded<Netlib_GetBase64EncodedBufferSize(nlb64->cbDecoded)) {

+		SetLastError(ERROR_BUFFER_OVERFLOW);

+		return 0;

+	}

+	nlb64->cchEncoded=Netlib_GetBase64EncodedBufferSize(nlb64->cbDecoded);

+	for(iIn=0,pbIn=nlb64->pbDecoded,pszOut=nlb64->pszEncoded;iIn<nlb64->cbDecoded;iIn+=3,pbIn+=3,pszOut+=4) {

+		pszOut[0]=base64chars[pbIn[0]>>2];

+		if(nlb64->cbDecoded-iIn==1) {

+			pszOut[1]=base64chars[(pbIn[0]&3)<<4];

+			pszOut[2]='=';

+			pszOut[3]='=';

+			pszOut+=4;

+			break;

+		}

+		pszOut[1]=base64chars[((pbIn[0]&3)<<4)|(pbIn[1]>>4)];

+		if(nlb64->cbDecoded-iIn==2) {

+			pszOut[2]=base64chars[(pbIn[1]&0xF)<<2];

+			pszOut[3]='=';

+			pszOut+=4;

+			break;

+		}

+		pszOut[2]=base64chars[((pbIn[1]&0xF)<<2)|(pbIn[2]>>6)];

+		pszOut[3]=base64chars[pbIn[2]&0x3F];

+	}

+	pszOut[0]='\0';

+	return 1;

+}

+

+static BYTE Base64CharToInt(char c)

+{

+	if(c>='A' && c<='Z') return c-'A';

+	if(c>='a' && c<='z') return c-'a'+26;

+	if(c>='0' && c<='9') return c-'0'+52;

+	if(c=='+') return 62;

+	if(c=='/') return 63;

+	if(c=='=') return 64;

+	return 255;

+}

+

+int NetlibBase64Decode(WPARAM wParam,LPARAM lParam)

+{

+	NETLIBBASE64 *nlb64=(NETLIBBASE64*)lParam;

+	char *pszIn;

+	PBYTE pbOut;

+	BYTE b1,b2,b3,b4;

+	int iIn;

+

+	if(nlb64==NULL || nlb64->pszEncoded==NULL || nlb64->pbDecoded==NULL) {

+		SetLastError(ERROR_INVALID_PARAMETER);

+		return 0;

+	}

+	if(nlb64->cchEncoded&3) {

+		SetLastError(ERROR_INVALID_DATA);

+		return 0;

+	}

+	if(nlb64->cbDecoded<Netlib_GetBase64DecodedBufferSize(nlb64->cchEncoded)) {

+		SetLastError(ERROR_BUFFER_OVERFLOW);

+		return 0;

+	}

+	nlb64->cbDecoded=Netlib_GetBase64DecodedBufferSize(nlb64->cchEncoded);

+	for(iIn=0,pszIn=nlb64->pszEncoded,pbOut=nlb64->pbDecoded;iIn<nlb64->cchEncoded;iIn+=4,pszIn+=4,pbOut+=3) {

+		b1=Base64CharToInt(pszIn[0]);

+		b2=Base64CharToInt(pszIn[1]);

+		b3=Base64CharToInt(pszIn[2]);

+		b4=Base64CharToInt(pszIn[3]);

+		if(b1==255 || b1==64 || b2==255 || b2==64 || b3==255 || b4==255) {

+			SetLastError(ERROR_INVALID_DATA);

+			return 0;

+		}

+		pbOut[0]=(b1<<2)|(b2>>4);

+		if(b3==64) {nlb64->cbDecoded-=2; break;}

+		pbOut[1]=(b2<<4)|(b3>>2);

+		if(b4==64) {nlb64->cbDecoded--; break;}

+		pbOut[2]=b4|(b3<<6);

+	}

+	return 1;

+}

+

+static int NetlibShutdown(WPARAM wParam,LPARAM lParam)

+{

+	int i;

+	

+	NetlibLogShutdown();

+	for(i=netlibUserCount;i>0;i--)

+		NetlibCloseHandle((WPARAM)netlibUser[i-1],0);

+	if(netlibUser) mir_free(netlibUser);

+	CloseHandle(hConnectionHeaderMutex);

+	DeleteCriticalSection(&csNetlibUser);

+	WSACleanup();

+	return 0;

+}

+

+static int NetlibModulesLoaded(WPARAM wParam, LPARAM lParam)

+{

+	HookEvent(ME_SYSTEM_SHUTDOWN,NetlibShutdown); // get shutdown hook _after_ all the other plugins

+	return 0;

+}

+

+int LoadNetlibModule(void)

+{

+	WSADATA wsadata;

+

+	//HookEvent(ME_SYSTEM_SHUTDOWN,NetlibShutdown); // hooked later to be called last after plugins

+	HookEvent(ME_SYSTEM_MODULESLOADED, NetlibModulesLoaded);

+	HookEvent(ME_OPT_INITIALISE,NetlibOptInitialise);

+	WSAStartup(MAKEWORD(1,1), &wsadata);

+	InitializeCriticalSection(&csNetlibUser);

+	hConnectionHeaderMutex=CreateMutex(NULL,FALSE,NULL);

+	g_LastConnectionTick=GetTickCount();

+	NetlibLogInit();

+	CreateServiceFunction(MS_NETLIB_REGISTERUSER,NetlibRegisterUser);

+	CreateServiceFunction(MS_NETLIB_GETUSERSETTINGS,NetlibGetUserSettings);

+	CreateServiceFunction(MS_NETLIB_SETUSERSETTINGS,NetlibSetUserSettings);

+	CreateServiceFunction(MS_NETLIB_CLOSEHANDLE,NetlibCloseHandle);

+	CreateServiceFunction(MS_NETLIB_BINDPORT,NetlibBindPort);

+	CreateServiceFunction(MS_NETLIB_OPENCONNECTION,NetlibOpenConnection);

+	CreateServiceFunction(MS_NETLIB_SETHTTPPROXYINFO,NetlibHttpGatewaySetInfo);

+	CreateServiceFunction(MS_NETLIB_SETSTICKYHEADERS,NetlibHttpSetSticky);

+	CreateServiceFunction(MS_NETLIB_GETSOCKET,NetlibGetSocket);

+	CreateServiceFunction(MS_NETLIB_URLENCODE,NetlibHttpUrlEncode);

+	CreateServiceFunction(MS_NETLIB_BASE64ENCODE,NetlibBase64Encode);

+	CreateServiceFunction(MS_NETLIB_BASE64DECODE,NetlibBase64Decode);

+	CreateServiceFunction(MS_NETLIB_SENDHTTPREQUEST,NetlibHttpSendRequest);

+	CreateServiceFunction(MS_NETLIB_RECVHTTPHEADERS,NetlibHttpRecvHeaders);

+	CreateServiceFunction(MS_NETLIB_FREEHTTPREQUESTSTRUCT,NetlibHttpFreeRequestStruct);

+	CreateServiceFunction(MS_NETLIB_HTTPTRANSACTION,NetlibHttpTransaction);

+	CreateServiceFunction(MS_NETLIB_SEND,NetlibSend);

+	CreateServiceFunction(MS_NETLIB_RECV,NetlibRecv);

+	CreateServiceFunction(MS_NETLIB_SELECT,NetlibSelect);

+	CreateServiceFunction(MS_NETLIB_SELECTEX,NetlibSelectEx);

+	CreateServiceFunction(MS_NETLIB_CREATEPACKETRECVER,NetlibPacketRecverCreate);

+	CreateServiceFunction(MS_NETLIB_GETMOREPACKETS,NetlibPacketRecverGetMore);

+	CreateServiceFunction(MS_NETLIB_SETPOLLINGTIMEOUT,NetlibHttpSetPollingTimeout);	

+	return 0;

+}