asyncinet.cpp File Reference

#include "rapps.h"
#include <wininet.h>
#include <atlbase.h>
#include "asyncinet.h"

Include dependency graph for asyncinet.cpp:

Go to the source code of this file.

Functions
BOOL	AsyncInetIsCanceled (pASYNCINET AsyncInet)
BOOL	AsyncInetAcquire (pASYNCINET AsyncInet)
VOID	AsyncInetRelease (pASYNCINET AsyncInet)
int	AsyncInetPerformCallback (pASYNCINET AsyncInet, ASYNC_EVENT Event, WPARAM wParam, LPARAM lParam)
VOID CALLBACK	AsyncInetStatusCallback (HINTERNET hInternet, DWORD_PTR dwContext, DWORD dwInternetStatus, LPVOID lpvStatusInformation, DWORD dwStatusInformationLength)
VOID	AsyncInetReadFileLoop (pASYNCINET AsyncInet)
BOOL	AsyncInetCleanUp (pASYNCINET AsyncInet)
VOID	AsyncInetFree (pASYNCINET AsyncInet)
pASYNCINET	AsyncInetDownload (LPCWSTR lpszAgent, DWORD dwAccessType, LPCWSTR lpszProxy, LPCWSTR lpszProxyBypass, LPCWSTR lpszUrl, BOOL bAllowCache, ASYNCINET_CALLBACK Callback, VOID *Extension)
BOOL	AsyncInetCancel (pASYNCINET AsyncInet)

Function Documentation

AsyncInetAcquire()

BOOL AsyncInetAcquire

(

pASYNCINET

AsyncInet

)

Definition at line 162 of file asyncinet.cpp.

{
    BOOL bResult = FALSE;
    if (AsyncInet)
    {
        EnterCriticalSection(&(AsyncInet->CriticalSection));
        ATLASSERT(AsyncInet->ReferenceCnt > 0);
        if (!AsyncInetIsCanceled(AsyncInet))
        {
            AsyncInet->ReferenceCnt++;
            bResult = TRUE;
        }
        // otherwise (AsyncInet->bCleanUp == TRUE)
        // AsyncInetAcquire will return FALSE.
        // In this case, any thread should no longer use this AsyncInet
 
        LeaveCriticalSection(&(AsyncInet->CriticalSection));
    }
 
    return bResult;
}

Referenced by AsyncInetDownload().

AsyncInetCancel()

BOOL AsyncInetCancel

(

pASYNCINET

AsyncInet

)

Definition at line 126 of file asyncinet.cpp.

{
    if (AsyncInet)
    {
        HINTERNET hInetFile;
        EnterCriticalSection(&(AsyncInet->CriticalSection));
        AsyncInet->bCancelled = TRUE;
        hInetFile = AsyncInet->hInetFile;
        AsyncInet->hInetFile = NULL;
        LeaveCriticalSection(&(AsyncInet->CriticalSection));
 
        if (hInetFile)
        {
            InternetCloseHandle(hInetFile);
            return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by CAppScrnshotPreview::PreviousDisplayCleanup().

AsyncInetCleanUp()

BOOL AsyncInetCleanUp

(

pASYNCINET

AsyncInet

)

Definition at line 388 of file asyncinet.cpp.

{
    if (AsyncInet)
    {
        ATLASSERT(AsyncInet->ReferenceCnt == 0);
        // close the handle, waiting for all pending request cancelled.
 
        if (AsyncInet->bCancelled) // already closed
        {
            AsyncInet->hInetFile = NULL;
        }
        else if (AsyncInet->hInetFile)
        {
            InternetCloseHandle(AsyncInet->hInetFile);
            AsyncInet->hInetFile = NULL;
        }
 
        // only cleanup when handle closed notification received
        switch (WaitForSingleObject(AsyncInet->hEventHandleClose, INFINITE))
        {
        case WAIT_OBJECT_0:
        {
            AsyncInetFree(AsyncInet); // now safe to free the structure
            return TRUE;
        }
        default:
            ATLASSERT(FALSE);
            AsyncInetFree(AsyncInet);
            return FALSE;
        }
    }
    else
    {
        return FALSE;
    }
}

Referenced by AsyncInetRelease().

AsyncInetDownload()

pASYNCINET AsyncInetDownload	(	LPCWSTR	lpszAgent,
		DWORD	dwAccessType,
		LPCWSTR	lpszProxy,
		LPCWSTR	lpszProxyBypass,
		LPCWSTR	lpszUrl,
		BOOL	bAllowCache,
		ASYNCINET_CALLBACK	Callback,
		VOID *	Extension
	)

Definition at line 33 of file asyncinet.cpp.

{
    pASYNCINET AsyncInet = NULL;
    BOOL bSuccess = FALSE;
    DWORD InetOpenUrlFlag = 0;
    INTERNET_STATUS_CALLBACK OldCallbackFunc;
 
    AsyncInet = (pASYNCINET)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ASYNCINET));
    if (!AsyncInet)
    {
        OutputDebugStringA("At File: " __FILE__ " HeapAlloc returned 0\n");
        return 0;
    }
 
    AsyncInet->bCancelled = FALSE;
 
    AsyncInet->hInternet = NULL;
    AsyncInet->hInetFile = NULL;
 
    AsyncInet->Callback = Callback;
    AsyncInet->Extension = Extension;
 
    AsyncInet->hEventHandleCreated = CreateEvent(NULL, FALSE, FALSE, NULL);
 
    InitializeCriticalSection(&(AsyncInet->CriticalSection));
    AsyncInet->ReferenceCnt = 1; // 1 for callee itself
    AsyncInet->hEventHandleClose = CreateEvent(NULL, FALSE, FALSE, NULL);
 
    if (AsyncInet->hEventHandleCreated && AsyncInet->hEventHandleClose)
    {
        AsyncInet->hInternet = InternetOpenW(lpszAgent, dwAccessType, lpszProxy, lpszProxyBypass, INTERNET_FLAG_ASYNC);
 
        if (AsyncInet->hInternet)
        {
            OldCallbackFunc = InternetSetStatusCallbackW(AsyncInet->hInternet, AsyncInetStatusCallback);
            if (OldCallbackFunc != INTERNET_INVALID_STATUS_CALLBACK)
            {
                InetOpenUrlFlag |= INTERNET_FLAG_PASSIVE | INTERNET_FLAG_RESYNCHRONIZE;
                if (!bAllowCache)
                {
                    InetOpenUrlFlag |= INTERNET_FLAG_DONT_CACHE | INTERNET_FLAG_PRAGMA_NOCACHE | INTERNET_FLAG_RELOAD;
                }
 
                AsyncInet->hInetFile = InternetOpenUrlW(AsyncInet->hInternet, lpszUrl, 0, 0, InetOpenUrlFlag, (DWORD_PTR)AsyncInet);
 
                if (AsyncInet->hInetFile)
                {
                    // operate complete synchronously
                    bSuccess = TRUE;
                    AsyncInetReadFileLoop(AsyncInet);
                }
                else
                {
                    if (GetLastError() == ERROR_IO_PENDING)
                    {
                        // everything fine. waiting for handle created
                        switch (WaitForSingleObject(AsyncInet->hEventHandleCreated, INFINITE))
                        {
                        case WAIT_OBJECT_0:
                            if (AsyncInet->hInetFile)
                            {
                                bSuccess = TRUE;
                            }
                        }
                    }
                }
            }
        }
    }
 
    if (!bSuccess)
    {
        AsyncInetFree(AsyncInet);
        AsyncInet = NULL;
    }
 
    if (AsyncInet)
    {
        // add reference count for caller.
        // the caller is responsible for call AsyncInetRelease when no longer using it.
        AsyncInetAcquire(AsyncInet);
    }
    return AsyncInet;
}

Referenced by CAppScrnshotPreview::DisplayImage().

AsyncInetFree()

VOID AsyncInetFree

(

pASYNCINET

AsyncInet

)

Definition at line 425 of file asyncinet.cpp.

{
    if (AsyncInet)
    {
        DeleteCriticalSection(&(AsyncInet->CriticalSection));
 
        if (AsyncInet->hEventHandleCreated)
        {
            CloseHandle(AsyncInet->hEventHandleCreated);
            AsyncInet->hEventHandleCreated = NULL;
        }
        if (AsyncInet->hEventHandleClose)
        {
            CloseHandle(AsyncInet->hEventHandleClose);
            AsyncInet->hEventHandleClose = NULL;
        }
        if (AsyncInet->hInternet)
        {
            InternetCloseHandle(AsyncInet->hInternet);
            AsyncInet->hInternet = NULL;
        }
        if (AsyncInet->hInetFile)
        {
            InternetCloseHandle(AsyncInet->hInetFile);
            AsyncInet->hInetFile = NULL;
        }
        HeapFree(GetProcessHeap(), 0, AsyncInet);
    }
}

Referenced by AsyncInetCleanUp(), and AsyncInetDownload().

AsyncInetIsCanceled()

BOOL AsyncInetIsCanceled

(

pASYNCINET

AsyncInet

)

Definition at line 147 of file asyncinet.cpp.

{
    if (AsyncInet)
    {
        EnterCriticalSection(&(AsyncInet->CriticalSection));
        if (AsyncInet->bCancelled)
        {
            LeaveCriticalSection(&(AsyncInet->CriticalSection));
            return TRUE;
        }
        LeaveCriticalSection(&(AsyncInet->CriticalSection));
    }
    return FALSE;
}

Referenced by AsyncInetAcquire(), AsyncInetReadFileLoop(), and AsyncInetStatusCallback().

AsyncInetPerformCallback()

int AsyncInetPerformCallback	(	pASYNCINET	AsyncInet,
		ASYNC_EVENT	Event,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 207 of file asyncinet.cpp.

{
    if (AsyncInet && AsyncInet->Callback)
    {
        return AsyncInet->Callback(AsyncInet, Event, wParam, lParam, AsyncInet->Extension);
    }
    return 0;
}

Referenced by AsyncInetReadFileLoop(), and AsyncInetStatusCallback().

AsyncInetReadFileLoop()

VOID AsyncInetReadFileLoop

(

pASYNCINET

AsyncInet

)

Definition at line 314 of file asyncinet.cpp.

{
    if ((!AsyncInet) || (!AsyncInet->hInetFile))
    {
        return;
    }
 
    while (1)
    {
        if (AsyncInetIsCanceled(AsyncInet))
        {
            // abort now.
            AsyncInetRelease(AsyncInet);
            break;
        }
 
        BOOL bRet = InternetReadFile(AsyncInet->hInetFile,
            AsyncInet->ReadBuffer,
            _countof(AsyncInet->ReadBuffer),
            &(AsyncInet->BytesRead));
 
        if (bRet)
        {
            if (AsyncInet->BytesRead == 0)
            {
                // everything read. now complete.
                AsyncInetPerformCallback(AsyncInet, ASYNCINET_COMPLETE, 0, 0);
                AsyncInetRelease(AsyncInet);
                break;
            }
            else
            {
                // read completed immediately.
                AsyncInetPerformCallback(AsyncInet, ASYNCINET_DATA, (WPARAM)(AsyncInet->ReadBuffer), (LPARAM)(AsyncInet->BytesRead));
            }
        }
        else
        {
            DWORD dwError;
            if ((dwError = GetLastError()) == ERROR_IO_PENDING)
            {
                // performing asynchronous IO, everything OK.
                break;
            }
            else
            {
                if (dwError == ERROR_INVALID_HANDLE ||
                    dwError == ERROR_INTERNET_OPERATION_CANCELLED ||
                    dwError == ERROR_CANCELLED)
                {
                    if (AsyncInetIsCanceled(AsyncInet))
                    {
                        // not an error. just normally cancelling
                        AsyncInetRelease(AsyncInet);
                        break;
                    }
                }
 
                if (!AsyncInetIsCanceled(AsyncInet)) // can not send both ASYNCINET_ERROR and ASYNCINET_CANCELLED
                {
                    AsyncInetPerformCallback(AsyncInet, ASYNCINET_ERROR, 0, dwError);
                }
                else
                {
                    // TODO: log the error
                }
                AsyncInetRelease(AsyncInet);
                break;
            }
        }
    }
    return;
}

Referenced by AsyncInetDownload(), and AsyncInetStatusCallback().

AsyncInetRelease()

VOID AsyncInetRelease

(

pASYNCINET

AsyncInet

)

Definition at line 184 of file asyncinet.cpp.

{
    BOOL bCleanUp = FALSE;
    if (AsyncInet)
    {
        EnterCriticalSection(&(AsyncInet->CriticalSection));
 
        ATLASSERT(AsyncInet->ReferenceCnt);
        AsyncInet->ReferenceCnt--;
        if (AsyncInet->ReferenceCnt == 0)
        {
            bCleanUp = TRUE;
        }
 
        LeaveCriticalSection(&(AsyncInet->CriticalSection));
 
        if (bCleanUp)
        {
            AsyncInetCleanUp(AsyncInet);
        }
    }
}

Referenced by AsyncInetReadFileLoop(), AsyncInetStatusCallback(), and CAppScrnshotPreview::ProcessWindowMessage().

AsyncInetStatusCallback()

VOID CALLBACK AsyncInetStatusCallback	(	HINTERNET	hInternet,
		DWORD_PTR	dwContext,
		DWORD	dwInternetStatus,
		LPVOID	lpvStatusInformation,
		DWORD	dwStatusInformationLength
	)

Definition at line 220 of file asyncinet.cpp.

{
    pASYNCINET AsyncInet = (pASYNCINET)dwContext;
    switch (dwInternetStatus)
    {
    case INTERNET_STATUS_HANDLE_CREATED:
    {
        // retrieve handle created by InternetOpenUrlW
        AsyncInet->hInetFile = *((LPHINTERNET)lpvStatusInformation);
        SetEvent(AsyncInet->hEventHandleCreated);
        break;
    }
    case INTERNET_STATUS_HANDLE_CLOSING:
    {
        if (AsyncInetIsCanceled(AsyncInet))
        {
            AsyncInetPerformCallback(AsyncInet, ASYNCINET_CANCELLED, 0, 0);
        }
        SetEvent(AsyncInet->hEventHandleClose);
        break;
    }
    case INTERNET_STATUS_REQUEST_COMPLETE:
    {
        INTERNET_ASYNC_RESULT* AsyncResult = (INTERNET_ASYNC_RESULT*)lpvStatusInformation;
 
        if (!AsyncInet->hInetFile)
        {
            if (!AsyncInetIsCanceled(AsyncInet))
            {
                // some error occurs during InternetOpenUrl
                // and INTERNET_STATUS_HANDLE_CREATED is skipped
                SetEvent(AsyncInet->hEventHandleCreated);
                break;
            }
        }
 
        switch (AsyncResult->dwError)
        {
        case ERROR_SUCCESS:
        {
            // there are two possibilities:
            // 1: InternetOpenUrlW (async mode) complete. (this should be only for the first time)
            // 2: InternetReadFile (async mode) complete.
            // so I use bIsOpenUrlComplete field in ASYNCINET to indicate this.
 
            if (!(AsyncInet->bIsOpenUrlComplete)) // InternetOpenUrlW completed
            {
                AsyncInet->bIsOpenUrlComplete = TRUE;
            }
            else // asynchronous InternetReadFile complete
            {
                AsyncInetPerformCallback(AsyncInet, ASYNCINET_DATA, (WPARAM)(AsyncInet->ReadBuffer), (LPARAM)(AsyncInet->BytesRead));
            }
 
            AsyncInetReadFileLoop(AsyncInet);
        }
        break;
        case ERROR_INVALID_HANDLE:
        case ERROR_INTERNET_OPERATION_CANCELLED:
        case ERROR_CANCELLED:
            if (AsyncInetIsCanceled(AsyncInet))
            {
                AsyncInetRelease(AsyncInet);
                break;
            }
 
            // fall down
        default:
            // something went wrong
            if (AsyncInetIsCanceled(AsyncInet))
            {
                // sending both ASYNCINET_ERROR and ASYNCINET_CANCELLED may lead to unpredictable behavior
                // TODO: log the error
                AsyncInetRelease(AsyncInet);
            }
            else
            {
                AsyncInetPerformCallback(AsyncInet, ASYNCINET_ERROR, 0, (LPARAM)(AsyncResult->dwError));
                AsyncInetRelease(AsyncInet);
            }
            break;
        }
        break;
    }
    }
    return;
}

Referenced by AsyncInetDownload().