/*=============================================================================
                           xmlrpc_wininet_transport
===============================================================================
   WinInet-based client transport for Xmlrpc-c.  Copyright information at
   the bottom of this file.
   
   Changelog (changes by Steven A. Bone - sbone@pobox.com unless otherwise noted):
   05.01.01 - Significant refactoring of the transport layer due to internal
              changes of the xmlrpc-c transports.  Modeled after the CURL
              based transport changes by Bryan Henderson.              
   05.02.03 - Fixed Authorization header - thanks yamer.
   05.03.20 - Supports xmlrpc_xportparms, xmlrpc_wininet_xportparms added
              *potential breaking change* - now by default we fail on invalid
			  SSL certs, use the xmlrpc_wininet_xportparms option to enable old
			  behavior.
   
=============================================================================*/

#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <stddef.h>

#include "xmlrpc_config.h"

#include "bool.h"
#include "mallocvar.h"
#include "linklist.h"
#include "casprintf.h"

#include "xmlrpc-c/base.h"
#include "xmlrpc-c/base_int.h"
#include "xmlrpc-c/client.h"
#include "xmlrpc-c/client_int.h"
#include "pthreadx.h"

#if defined (WIN32)
#	include <wininet.h>
#endif /*WIN32*/

#if defined (WIN32) && defined(_DEBUG)
#		include <crtdbg.h>
#		define new DEBUG_NEW
#		define malloc(size) _malloc_dbg( size, _NORMAL_BLOCK, __FILE__, __LINE__)
#		undef THIS_FILE
		static char THIS_FILE[] = __FILE__;
#endif /*WIN32 && _DEBUG*/


static HINTERNET hSyncInternetSession = NULL;

/* Declare WinInet status callback. */
void CALLBACK statusCallback (HINTERNET hInternet,
                          unsigned long dwContext,
                          unsigned long dwInternetStatus,
                          void * lpvStatusInformation,
                          unsigned long dwStatusInformationLength);


struct xmlrpc_client_transport {
    pthread_mutex_t listLock;
    struct list_head rpcList;
        /* List of all RPCs that exist for this transport.  An RPC exists
           from the time the user requests it until the time the user 
           acknowledges it is done.
        */
    int allowInvalidSSLCerts;
        /* Flag to specify if we ignore invalid SSL Certificates.  If this
		   is set to zero, calling a XMLRPC server with an invalid SSL
		   certificate will fail.  This is the default behavior of the other
		   transports, but invalid certificates were allowed in pre 1.2 
		   wininet xmlrpc-c transports.
        */
};

typedef struct {
    unsigned long http_status;
	HINTERNET hHttpRequest;
	HINTERNET hURL;
	INTERNET_PORT nPort;
	char szHostName[255];	
	char szUrlPath[255];
	BOOL bUseSSL;
	char *headerList;
	BYTE *pSendData;
	xmlrpc_mem_block *pResponseData;
} winInetTransaction;

typedef struct {
    struct list_head link;  /* link in transport's list of RPCs */
    winInetTransaction * winInetTransactionP;
        /* The object which does the HTTP transaction, with no knowledge
           of XML-RPC or Xmlrpc-c.
        */
    xmlrpc_mem_block * responseXmlP;
    xmlrpc_bool threadExists;
    pthread_t thread;
    xmlrpc_transport_asynch_complete complete;
        /* Routine to call to complete the RPC after it is complete HTTP-wise.
           NULL if none.
        */
    struct xmlrpc_call_info * callInfoP;
        /* User's identifier for this RPC */
	struct xmlrpc_client_transport * clientTransportP;
} rpc;

static void
createWinInetHeaderList( xmlrpc_env *         const envP,
						 const xmlrpc_server_info * const serverP,
						 char ** const headerListP) {

    char *szHeaderList = NULL;
	char *szContentType = "Content-Type: text/xml\r\n";

    /* Send an authorization header if we need one. */
    if (serverP->_http_basic_auth) {
        /* Make the header with content type and authorization   */
        /* NOTE: A newline is required between each added header */
		szHeaderList = malloc(strlen(szContentType) + 17 + strlen(serverP->_http_basic_auth) + 1 );
        
        if (szHeaderList == NULL)
            xmlrpc_env_set_fault_formatted(
                envP, XMLRPC_INTERNAL_ERROR,
                "Couldn't allocate memory for authorization header");
        else {
            memcpy(szHeaderList,szContentType, strlen(szContentType));
			memcpy(szHeaderList + strlen(szContentType),"\r\nAuthorization: ", 17);
			memcpy(szHeaderList + strlen(szContentType) + 17, serverP->_http_basic_auth,
                   strlen(serverP->_http_basic_auth) + 1);
        }
    }
	else
	{
		/* Just the content type header is needed */
		szHeaderList = malloc(strlen(szContentType) + 1);
        
        if (szHeaderList == NULL)
            xmlrpc_env_set_fault_formatted(
                envP, XMLRPC_INTERNAL_ERROR, "Couldn't allocate memory for standard header");
        else 
            memcpy(szHeaderList,szContentType, strlen(szContentType)+1);
	}

    *headerListP = szHeaderList;
}

static void
createWinInetTransaction(xmlrpc_env *         const envP,
                      const xmlrpc_server_info * const serverP,
                      xmlrpc_mem_block *   const callXmlP,
                      xmlrpc_mem_block *   const responseXmlP,
                      winInetTransaction **   const winInetTransactionPP) {

    winInetTransaction * winInetTransactionP;

    MALLOCVAR(winInetTransactionP);
    if (winInetTransactionP == NULL)
        xmlrpc_env_set_fault_formatted(
            envP, XMLRPC_INTERNAL_ERROR,
            "No memory to create WinInet transaction.");
    else {
		char szExtraInfo[255];
		char szScheme[100];
		URL_COMPONENTS uc;

		/* Init to defaults */
		winInetTransactionP->http_status = 0;
		winInetTransactionP->hHttpRequest = NULL;
		winInetTransactionP->hURL = NULL;
		winInetTransactionP->headerList=NULL;
		winInetTransactionP->pSendData=NULL;
		winInetTransactionP->pResponseData=responseXmlP;

		/* Parse the URL and store results into the  winInetTransaction struct */
		memset (&uc, 0, sizeof (uc));
		uc.dwStructSize = sizeof (uc);
		uc.lpszScheme = szScheme;
		uc.dwSchemeLength = 100;
		uc.lpszHostName = winInetTransactionP->szHostName;
		uc.dwHostNameLength = 255;
		uc.lpszUrlPath = winInetTransactionP->szUrlPath;
		uc.dwUrlPathLength = 255;
		uc.lpszExtraInfo = szExtraInfo;
		uc.dwExtraInfoLength = 255;
		if (InternetCrackUrl (serverP->_server_url, strlen (serverP->_server_url), ICU_ESCAPE, &uc) == FALSE)
		{
			xmlrpc_env_set_fault_formatted( envP, XMLRPC_INTERNAL_ERROR,
											"Unable to parse the server URL.");
		}
		else
		{
			winInetTransactionP->nPort = (uc.nPort) ? uc.nPort : INTERNET_DEFAULT_HTTP_PORT;
			if (_strnicmp (uc.lpszScheme, "https", 5) == 0)
				winInetTransactionP->bUseSSL=TRUE;
			else
				winInetTransactionP->bUseSSL=FALSE;
			createWinInetHeaderList(envP, serverP, &winInetTransactionP->headerList);

			XMLRPC_MEMBLOCK_APPEND(char, envP, callXmlP, "\0", 1);
			if (!envP->fault_occurred) {
				winInetTransactionP->pSendData = XMLRPC_MEMBLOCK_CONTENTS(char, callXmlP);
			}
		}
			
		
		if (envP->fault_occurred)
            free(winInetTransactionP);
    }
    *winInetTransactionPP = winInetTransactionP;
}



static void
destroyWinInetTransaction(winInetTransaction * const winInetTransactionP) {

	XMLRPC_ASSERT_PTR_OK(winInetTransactionP);

	if (winInetTransactionP->hHttpRequest)
		InternetCloseHandle (winInetTransactionP->hHttpRequest);

	if (winInetTransactionP->hURL)
		InternetCloseHandle (winInetTransactionP->hURL);

	if (winInetTransactionP->headerList)
		free(winInetTransactionP->headerList);

	free(winInetTransactionP);
}

static void get_wininet_response (	xmlrpc_env *      const envP,
									winInetTransaction * const winInetTransactionP)
{
	INTERNET_BUFFERS inetBuffer;
	LPTSTR pMsg = NULL;
	PVOID pMsgMem = NULL;
	unsigned long dwFlags;
	unsigned long dwErr = 0; 
	unsigned long nExpected = 0;
	unsigned long dwLen = sizeof (unsigned long);
	void * body = NULL;
	BOOL bOK = FALSE;

	inetBuffer.dwStructSize = sizeof (INTERNET_BUFFERS);
	inetBuffer.Next = NULL;
	inetBuffer.lpcszHeader = NULL;
	inetBuffer.dwHeadersTotal = inetBuffer.dwHeadersLength = 0;
	inetBuffer.dwOffsetHigh = inetBuffer.dwOffsetLow = 0;
	inetBuffer.dwBufferLength = 0;

	bOK = HttpQueryInfo (winInetTransactionP->hHttpRequest, 
		HTTP_QUERY_CONTENT_LENGTH|HTTP_QUERY_FLAG_NUMBER, 
		&inetBuffer.dwBufferTotal, &dwLen, NULL);
	if (!bOK)
	{
		dwErr = GetLastError ();
		FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | 
			FORMAT_MESSAGE_FROM_SYSTEM, 
			NULL,
			dwErr,
			MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
			(LPTSTR) &pMsgMem,
			1024,NULL);

		pMsg = (pMsgMem) ? (LPTSTR)(pMsgMem) : "Sync HttpQueryInfo failed.";
		XMLRPC_FAIL (envP, XMLRPC_NETWORK_ERROR, pMsg);
	}

    if (inetBuffer.dwBufferTotal == 0)
		XMLRPC_FAIL (envP, XMLRPC_NETWORK_ERROR, "WinInet returned no data");

	body = inetBuffer.lpvBuffer = calloc (inetBuffer.dwBufferTotal, sizeof (TCHAR));
	dwFlags = IRF_SYNC;
	inetBuffer.dwBufferLength = nExpected = inetBuffer.dwBufferTotal;
	InternetQueryDataAvailable (winInetTransactionP->hHttpRequest, &inetBuffer.dwBufferLength, 0, 0);

	/* Read Response from InternetFile */
	do
	{
		if (inetBuffer.dwBufferLength != 0)
			bOK = InternetReadFileEx (winInetTransactionP->hHttpRequest, &inetBuffer, dwFlags, 1);

		if (!bOK)
			dwErr = GetLastError ();

		if (dwErr)
		{
			if (dwErr == WSAEWOULDBLOCK || dwErr == ERROR_IO_PENDING) 
			{
				/* Non-block socket operation wait 10 msecs */
				SleepEx (10, TRUE);
				/* Reset dwErr to zero for next pass */
				dwErr = 0;
			}
			else
			{
				FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | 
					FORMAT_MESSAGE_FROM_SYSTEM, 
					NULL,
					dwErr,
					MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
					(LPTSTR) &pMsgMem,
					1024,NULL);
				pMsg = (pMsgMem) ? (LPTSTR)(pMsgMem) : "ASync InternetReadFileEx failed.";
				XMLRPC_FAIL (envP, XMLRPC_NETWORK_ERROR, pMsg);
			}
		}
		
		if (inetBuffer.dwBufferLength)
		{
			TCHAR * bufptr = inetBuffer.lpvBuffer;
			bufptr += inetBuffer.dwBufferLength;
			inetBuffer.lpvBuffer = bufptr;
			nExpected -= inetBuffer.dwBufferLength;
			/* Adjust inetBuffer.dwBufferLength when it is greater than the */
			/* expected end of file */
 			if (inetBuffer.dwBufferLength > nExpected)
				inetBuffer.dwBufferLength = nExpected; 

		}
		else
			inetBuffer.dwBufferLength = nExpected;
		dwErr = 0;
	} while  (nExpected != 0);


    /* Add to the response buffer. */ 
	xmlrpc_mem_block_append(envP, winInetTransactionP->pResponseData, body, inetBuffer.dwBufferTotal);
     XMLRPC_FAIL_IF_FAULT (envP);

 cleanup:
	/* Since the XMLRPC_FAIL calls goto cleanup, we must handle */
	/* the free'ing of the memory here. */
	if (pMsgMem != NULL)
	{
		LocalFree( pMsgMem );
	}

	if (body)
		free (body);
}


static void
performWinInetTransaction(xmlrpc_env *      const envP,
                       winInetTransaction * const winInetTransactionP,
					   struct xmlrpc_client_transport * const clientTransportP) {
	LPTSTR pMsg = NULL;
	LPVOID pMsgMem = NULL;

	unsigned long lastErr;
	unsigned long reqFlags = INTERNET_FLAG_NO_UI;
	char * acceptTypes[] = {"text/xml", NULL};
	unsigned long queryLen = sizeof (unsigned long);
	
	winInetTransactionP->hURL = InternetConnect (hSyncInternetSession, 
					winInetTransactionP->szHostName, winInetTransactionP->nPort, 
					NULL, NULL, INTERNET_SERVICE_HTTP, 0, 1);

	/* Start our request running. */
	if (winInetTransactionP->bUseSSL == TRUE)
		reqFlags |= INTERNET_FLAG_SECURE |INTERNET_FLAG_IGNORE_CERT_CN_INVALID;

	winInetTransactionP->hHttpRequest = HttpOpenRequest (winInetTransactionP->hURL, "POST",
		winInetTransactionP->szUrlPath, "HTTP/1.1", NULL, (const char **)&acceptTypes,
		reqFlags, 1);

	XMLRPC_FAIL_IF_NULL(winInetTransactionP->hHttpRequest,envP, XMLRPC_INTERNAL_ERROR,
						"Unable to open the requested URL.");

	if ( HttpAddRequestHeaders (winInetTransactionP->hHttpRequest, winInetTransactionP->headerList, 
		strlen (winInetTransactionP->headerList), HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE ) ==FALSE)
	{
		XMLRPC_FAIL (envP, XMLRPC_INTERNAL_ERROR, "Could not set Content-Type.");
	}

#ifdef DEBUG
	/* Provide the user with transport status information */
	InternetSetStatusCallback (winInetTransactionP->hHttpRequest, statusCallback);
#endif

Again:
	/* Send the requested XML remote procedure command */ 
	if (HttpSendRequest (winInetTransactionP->hHttpRequest, NULL, 0, 
		winInetTransactionP->pSendData, 
		strlen(winInetTransactionP->pSendData))==FALSE)
	{
		lastErr = GetLastError ();

		FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
			FORMAT_MESSAGE_ALLOCATE_BUFFER |
			FORMAT_MESSAGE_IGNORE_INSERTS, 
			NULL,
			lastErr,
			MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
			(LPTSTR) &pMsgMem,
			0, NULL);


		if (pMsgMem == NULL)
		{
			switch (lastErr)
			{
			case ERROR_INTERNET_CANNOT_CONNECT:
				pMsg = "Sync HttpSendRequest failed: Connection refused.";
				break;
			case ERROR_INTERNET_CLIENT_AUTH_CERT_NEEDED:
				pMsg = "Sync HttpSendRequest failed: Client authorization certificate needed.";
				break;

			/* The following conditions are recommendations that microsoft */
			/* provides in their knowledge base. */

			/* HOWTO: Handle Invalid Certificate Authority Error with WinInet (Q182888) */
			case ERROR_INTERNET_INVALID_CA:
				if (clientTransportP->allowInvalidSSLCerts){
					OutputDebugString ("Sync HttpSendRequest failed: "
						"The function is unfamiliar with the certificate "
						"authority that generated the server's certificate. ");
					reqFlags = SECURITY_FLAG_IGNORE_UNKNOWN_CA;

					InternetSetOption (winInetTransactionP->hHttpRequest, INTERNET_OPTION_SECURITY_FLAGS,
										&reqFlags, sizeof (reqFlags));

					goto Again;
				}
				else{
					pMsg = "Invalid or unknown/untrusted SSL Certificate Authority.";
				}
				break;

			/* HOWTO: Make SSL Requests Using WinInet (Q168151) */
			case ERROR_INTERNET_SEC_CERT_CN_INVALID:
				if (clientTransportP->allowInvalidSSLCerts){
					OutputDebugString ("Sync HttpSendRequest failed: "
						"The SSL certificate common name (host name field) is incorrect\r\n "
						"for example, if you entered www.server.com and the common name "
						"on the certificate says www.different.com. ");
					
					reqFlags = INTERNET_FLAG_IGNORE_CERT_CN_INVALID;

					InternetSetOption (winInetTransactionP->hHttpRequest, INTERNET_OPTION_SECURITY_FLAGS,
										&reqFlags, sizeof (reqFlags));

					goto Again;
				}
				else{
					pMsg = "The SSL certificate common name (host name field) is incorrect.";
				}
				break;

			case ERROR_INTERNET_SEC_CERT_DATE_INVALID:
				if (clientTransportP->allowInvalidSSLCerts){
					OutputDebugString ("Sync HttpSendRequest failed: "
						"The SSL certificate date that was received from the server is "
						"bad. The certificate is expired. ");

					reqFlags = INTERNET_FLAG_IGNORE_CERT_DATE_INVALID;

					InternetSetOption (winInetTransactionP->hHttpRequest, INTERNET_OPTION_SECURITY_FLAGS,
										&reqFlags, sizeof (reqFlags));

					goto Again;
				}
				else{
					pMsg = "The SSL certificate date that was received from the server is invalid.";
				}
				break;

			default:
				pMsg = (LPTSTR)pMsgMem = LocalAlloc (LPTR, MAX_PATH);
				sprintf (pMsg, "Sync HttpSendRequest failed: GetLastError (%d)", lastErr);
				break;

			}
		}
		else
		{
			pMsg = (LPTSTR)(pMsgMem); 

		}
		XMLRPC_FAIL (envP, XMLRPC_NETWORK_ERROR, pMsg);

	}

	if( HttpQueryInfo (winInetTransactionP->hHttpRequest, 
		HTTP_QUERY_FLAG_NUMBER|HTTP_QUERY_STATUS_CODE,
		&winInetTransactionP->http_status, &queryLen, NULL) == FALSE)
	{
		lastErr = GetLastError ();
		FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | 
			FORMAT_MESSAGE_FROM_SYSTEM, 
			NULL,
			lastErr,
			MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
			(LPTSTR) &pMsgMem,
			1024,NULL);

		pMsg = (pMsgMem) ? (LPTSTR)(pMsgMem) : "Sync HttpQueryInfo failed.";
		XMLRPC_FAIL (envP, XMLRPC_NETWORK_ERROR, pMsg);

	}

    /* Make sure we got a "200 OK" message from the remote server. */
	if(winInetTransactionP->http_status!=200)
	{
		unsigned long msgLen = 1024;
		char errMsg [1024];
		*errMsg = 0;
		HttpQueryInfo (winInetTransactionP->hHttpRequest, HTTP_QUERY_STATUS_TEXT, errMsg, &msgLen, NULL);

		/* Set our fault. We break this into multiple lines because it */
		/* will generally contain line breaks to begin with. */
		xmlrpc_env_set_fault_formatted (envP, XMLRPC_NETWORK_ERROR,
					   "HTTP error #%d occurred\n %s", winInetTransactionP->http_status, errMsg);
		goto cleanup;
		
	 }
    /* Read the response. */	
    get_wininet_response (envP, winInetTransactionP);
    XMLRPC_FAIL_IF_FAULT (envP);

 cleanup:
	/* Since the XMLRPC_FAIL calls goto cleanup, we must handle */
	/* the free'ing of the memory here. */
	if (pMsgMem != NULL)
	{
		LocalFree( pMsgMem );
	}

}

static unsigned __stdcall 
doAsyncRpc(void * arg) {
    rpc * const rpcP = arg;
    xmlrpc_env env;
    xmlrpc_env_init(&env);
    performWinInetTransaction(&env, rpcP->winInetTransactionP, rpcP->clientTransportP );
    rpcP->complete(rpcP->callInfoP, rpcP->responseXmlP, env);
    xmlrpc_env_clean(&env);
    return 0;
}


static void
createRpcThread(xmlrpc_env *              const envP,
                rpc *                     const rpcP,
                pthread_t *               const threadP) {

    int rc;

    rc = pthread_create(threadP, NULL, doAsyncRpc, rpcP);
    switch (rc) {
    case 0: 
        break;
    case EAGAIN:
        xmlrpc_env_set_fault_formatted(
            envP, XMLRPC_INTERNAL_ERROR, 
            "pthread_create() failed:  System Resources exceeded.");
        break;
    case EINVAL:
        xmlrpc_env_set_fault_formatted(
            envP, XMLRPC_INTERNAL_ERROR, 
            "pthread_create() failed:  Param Error for attr.");
        break;
    case ENOMEM:
        xmlrpc_env_set_fault_formatted(
            envP, XMLRPC_INTERNAL_ERROR, 
            "pthread_create() failed:  No memory for new thread.");
        break;
    default:
        xmlrpc_env_set_fault_formatted(
            envP, XMLRPC_INTERNAL_ERROR, 
            "pthread_create() failed: Unrecognized error code %d.", rc);
        break;
    }
}

static void
rpcCreate(xmlrpc_env *             const envP,
          struct xmlrpc_client_transport * const clientTransportP,
          const xmlrpc_server_info * const serverP,
          xmlrpc_mem_block *       const callXmlP,
          xmlrpc_mem_block *       const responseXmlP,
          xmlrpc_transport_asynch_complete      complete, 
          struct xmlrpc_call_info *       const callInfoP,
          rpc **                   const rpcPP) {

    rpc * rpcP;

    MALLOCVAR(rpcP);
    if (rpcP == NULL)
        xmlrpc_env_set_fault_formatted(
            envP, XMLRPC_INTERNAL_ERROR,
            "Couldn't allocate memory for rpc object");
    else {
        rpcP->callInfoP = callInfoP;
        rpcP->complete  = complete;
        rpcP->responseXmlP = responseXmlP;
        rpcP->threadExists = FALSE;

        createWinInetTransaction(envP, serverP,
                              callXmlP, responseXmlP, 
                              &rpcP->winInetTransactionP);
        if (!envP->fault_occurred) {
            if (complete) {
                createRpcThread(envP, rpcP, &rpcP->thread);
                if (!envP->fault_occurred)
                    rpcP->threadExists = TRUE;
            }
            if (!envP->fault_occurred) {
                list_init_header(&rpcP->link, rpcP);
                pthread_mutex_lock(&clientTransportP->listLock);
                list_add_head(&clientTransportP->rpcList, &rpcP->link);
                pthread_mutex_unlock(&clientTransportP->listLock);
            }
            if (envP->fault_occurred)
                    destroyWinInetTransaction(rpcP->winInetTransactionP);
        }
        if (envP->fault_occurred)
            free(rpcP);
    }
    *rpcPP = rpcP;
}

static void 
rpcDestroy(rpc * const rpcP) {

    XMLRPC_ASSERT_PTR_OK(rpcP);
    XMLRPC_ASSERT(!rpcP->threadExists);

    destroyWinInetTransaction(rpcP->winInetTransactionP);

    list_remove(&rpcP->link);

    free(rpcP);
}

static void * 
finishRpc(struct list_head * const headerP, 
          void *             const context ATTR_UNUSED) {
    
    rpc * const rpcP = headerP->itemP;

    if (rpcP->threadExists) {
        void *status;
        int result;

        result = pthread_join(rpcP->thread, &status);
        
        rpcP->threadExists = FALSE;
    }

    XMLRPC_MEMBLOCK_FREE(char, rpcP->responseXmlP);

    rpcDestroy(rpcP);

    return NULL;
}


/* Used for debugging purposes to track the status of
** your request. */
void CALLBACK statusCallback (HINTERNET hInternet,
                         unsigned long dwContext,
                         unsigned long dwInternetStatus,
                         void * lpvStatusInformation,
                         unsigned long dwStatusInformationLength)
{
	switch (dwInternetStatus)
	{
	case INTERNET_STATUS_RESOLVING_NAME:
		OutputDebugString("INTERNET_STATUS_RESOLVING_NAME\r\n");
		break;

	case INTERNET_STATUS_NAME_RESOLVED:
		OutputDebugString("INTERNET_STATUS_NAME_RESOLVED\r\n");
		break;

	case INTERNET_STATUS_HANDLE_CREATED:
		OutputDebugString("INTERNET_STATUS_HANDLE_CREATED\r\n");
		break;

	case INTERNET_STATUS_CONNECTING_TO_SERVER:
		OutputDebugString("INTERNET_STATUS_CONNECTING_TO_SERVER\r\n");
		break;

	case INTERNET_STATUS_REQUEST_SENT:
		OutputDebugString("INTERNET_STATUS_REQUEST_SENT\r\n");
		break;

	case INTERNET_STATUS_SENDING_REQUEST:
		OutputDebugString("INTERNET_STATUS_SENDING_REQUEST\r\n");
		break;

	case INTERNET_STATUS_CONNECTED_TO_SERVER:
		OutputDebugString("INTERNET_STATUS_CONNECTED_TO_SERVER\r\n");
		break;

	case INTERNET_STATUS_RECEIVING_RESPONSE:
		OutputDebugString("INTERNET_STATUS_RECEIVING_RESPONSE\r\n");
		break;

	case INTERNET_STATUS_RESPONSE_RECEIVED:
		OutputDebugString("INTERNET_STATUS_RESPONSE_RECEIVED\r\n");
		break;

	case INTERNET_STATUS_CLOSING_CONNECTION:
		OutputDebugString("INTERNET_STATUS_CLOSING_CONNECTION\r\n");
		break;

	case INTERNET_STATUS_CONNECTION_CLOSED:
		OutputDebugString("INTERNET_STATUS_CONNECTION_CLOSED\r\n");
		break;

	case INTERNET_STATUS_HANDLE_CLOSING:
		OutputDebugString("INTERNET_STATUS_HANDLE_CLOSING\r\n");
		break;

	case INTERNET_STATUS_CTL_RESPONSE_RECEIVED:
		OutputDebugString("INTERNET_STATUS_CTL_RESPONSE_RECEIVED\r\n");
		break;

	case INTERNET_STATUS_REDIRECT:
		OutputDebugString("INTERNET_STATUS_REDIRECT\r\n");
		break;

	case INTERNET_STATUS_REQUEST_COMPLETE:
		/* This indicates the data is ready. */
		OutputDebugString("INTERNET_STATUS_REQUEST_COMPLETE\r\n");
		break;

	default:
		OutputDebugString("statusCallback, default case!\r\n");
		break;
     }
}

static void 
create(xmlrpc_env *              const envP,
       int                       const flags ATTR_UNUSED,
       const char *              const appname ATTR_UNUSED,
       const char *              const appversion ATTR_UNUSED,
	   const struct xmlrpc_xportparms * const transportparmsP,
       size_t                    const parm_size,
       struct xmlrpc_client_transport ** const handlePP) {
/*----------------------------------------------------------------------------
   This does the 'create' operation for a WinInet client transport.
-----------------------------------------------------------------------------*/
    struct xmlrpc_client_transport * transportP;

	struct xmlrpc_wininet_xportparms * const wininetXportParmsP = 
		(struct xmlrpc_wininet_xportparms *) transportparmsP;

    MALLOCVAR(transportP);
    if (transportP == NULL)
        xmlrpc_env_set_fault_formatted(
            envP, XMLRPC_INTERNAL_ERROR, 
            "Unable to allocate transport descriptor.");
    else {
        pthread_mutex_init(&transportP->listLock, NULL);
        
        list_make_empty(&transportP->rpcList);

		if (hSyncInternetSession == NULL)
			hSyncInternetSession = InternetOpen ("xmlrpc-c wininet transport",
				INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);

		if (!wininetXportParmsP || parm_size < XMLRPC_WXPSIZE(allowInvalidSSLCerts))
		    transportP->allowInvalidSSLCerts = 0;
		else
            transportP->allowInvalidSSLCerts = wininetXportParmsP->allowInvalidSSLCerts;

        *handlePP = transportP;
    }
}


static void 
destroy(struct xmlrpc_client_transport * const clientTransportP) {
/*----------------------------------------------------------------------------
   This does the 'destroy' operation for a WinInet client transport.
-----------------------------------------------------------------------------*/
	XMLRPC_ASSERT(clientTransportP != NULL);

    XMLRPC_ASSERT(list_is_empty(&clientTransportP->rpcList));

	if (hSyncInternetSession)
		InternetCloseHandle(hSyncInternetSession);
	hSyncInternetSession = NULL;

	pthread_mutex_destroy(&clientTransportP->listLock);

	free(clientTransportP);
}


static void 
sendRequest(xmlrpc_env *             const envP, 
            struct xmlrpc_client_transport * const clientTransportP,
            const xmlrpc_server_info * const serverP,
            xmlrpc_mem_block *       const callXmlP,
            xmlrpc_transport_asynch_complete      complete,
            struct xmlrpc_call_info *       const callInfoP) {
/*----------------------------------------------------------------------------
   Initiate an XML-RPC rpc asynchronously.  Don't wait for it to go to
   the server.

   Unless we return failure, we arrange to have complete() called when
   the rpc completes.

   This does the 'send_request' operation for a WinInet client transport.
-----------------------------------------------------------------------------*/
    rpc * rpcP;
    xmlrpc_mem_block * responseXmlP;

    responseXmlP = XMLRPC_MEMBLOCK_NEW(char, envP, 0);
    if (!envP->fault_occurred) {
        rpcCreate(envP, clientTransportP, serverP, callXmlP, responseXmlP,
                  complete, callInfoP,
                  &rpcP);

        if (envP->fault_occurred)
            XMLRPC_MEMBLOCK_FREE(char, responseXmlP);
    }
    /* The user's eventual finish_asynch call will destroy this RPC
       and response buffer
    */
}

static void 
finishAsynch(struct xmlrpc_client_transport * const clientTransportP,
             xmlrpc_timeoutType         const timeoutType ATTR_UNUSED,
             xmlrpc_timeout                const timeout ATTR_UNUSED) {
/*----------------------------------------------------------------------------
   Wait for the threads of all outstanding RPCs to exit and destroy those
   RPCs.

   This does the 'finish_asynch' operation for a WinInet client transport.
-----------------------------------------------------------------------------*/
    /* We ignore any timeout request.  Some day, we should figure out how
       to set an alarm and interrupt running threads.
    */

    pthread_mutex_lock(&clientTransportP->listLock);

    list_foreach(&clientTransportP->rpcList, finishRpc, NULL);

    pthread_mutex_unlock(&clientTransportP->listLock);
}


static void
call(xmlrpc_env *             const envP,
     struct xmlrpc_client_transport * const clientTransportP,
     const xmlrpc_server_info * const serverP,
     xmlrpc_mem_block *       const callXmlP,
     xmlrpc_mem_block **      const responsePP) {

	 
    xmlrpc_mem_block * responseXmlP;
    rpc * rpcP;

    XMLRPC_ASSERT_ENV_OK(envP);
    XMLRPC_ASSERT_PTR_OK(serverP);
    XMLRPC_ASSERT_PTR_OK(callXmlP);
    XMLRPC_ASSERT_PTR_OK(responsePP);

    responseXmlP = XMLRPC_MEMBLOCK_NEW(char, envP, 0);
    if (!envP->fault_occurred) {
        rpcCreate(envP, clientTransportP, serverP, callXmlP, responseXmlP,
                  NULL, NULL, &rpcP);
        if (!envP->fault_occurred) {
            performWinInetTransaction(envP, rpcP->winInetTransactionP, clientTransportP);
            
            *responsePP = responseXmlP;
            
            rpcDestroy(rpcP);
        }
        if (envP->fault_occurred)
            XMLRPC_MEMBLOCK_FREE(char, responseXmlP);
    }
}


struct xmlrpc_client_transport_ops xmlrpc_wininet_transport_ops = {
    NULL,
    NULL,
    &create,
    &destroy,
    &sendRequest,
    &call,
    &finishAsynch,
};

/* Copyright (C) 2001 by First Peer, Inc. All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
** 1. Redistributions of source code must retain the above copyright
**    notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
**    notice, this list of conditions and the following disclaimer in the
**    documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
**    derived from this software without specific prior written permission. 
**  
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
** ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
** OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
** SUCH DAMAGE. */
