/******************************Module*Header*******************************\
* Module Name: getinfo.cpp
*
* Author:  David Stewart [dstewart]
*
* Copyright (c) 1998 Microsoft Corporation.  All rights reserved.
\**************************************************************************/

#include <TCHAR.H>
#include <objbase.h>
#include <mmsystem.h> //for mci commands
#include <urlmon.h>
#include <hlguids.h>  //for IID_IBindStatusCallback
#include "getinfo.h"
#include "netres.h"
#include "wininet.h"
#include "condlg.h"
#include "..\main\mmfw.h"
#include "..\cdopt\cdopt.h"
#include "mapi.h"
#include <stdio.h>

extern HINSTANCE g_dllInst;

#define MODE_OK 0
#define MODE_MULTIPLE 1
#define MODE_NOT_FOUND 2

#define FRAMES_PER_SECOND           75
#define FRAMES_PER_MINUTE           (60*FRAMES_PER_SECOND)
#define MAX_UPLOAD_URL_LENGTH       1500

#ifdef UNICODE
#define URLFUNCTION "URLOpenStreamW"
#define CANONFUNCTION "InternetCanonicalizeUrlW"
#else
#define URLFUNCTION "URLOpenStreamA"
#define CANONFUNCTION "InternetCanonicalizeUrlA"
#endif

HWND    g_hwndParent = NULL;
extern HINSTANCE g_hURLMon;
LPCDOPT g_pNetOpt = NULL;
LPCDDATA g_pNetData = NULL;
BOOL g_fCancelDownload = FALSE;     //ANY ACCESS MUST BE SURROUNDED by Enter/Leave g_Critical
IBinding* g_pBind = NULL;           //ANY ACCESS MUST BE SURROUNDED by Enter/Leave g_Critical
long g_lNumDownloadingThreads = 0;  //MUST USE InterlockedIncrement/Decrement
BOOL g_fDownloadDone = FALSE;
BOOL g_fDBWriteFailure = FALSE;
extern CRITICAL_SECTION g_Critical;
extern CRITICAL_SECTION g_BatchCrit;

DWORD WINAPI SpawnSingleDownload(LPVOID pParam);
DWORD WINAPI SpawnBatchDownload(LPVOID pParam);
DWORD WINAPI DoBatchDownload(LPCDBATCH pBatchList, HWND hwndParent);
BOOL DoDownload(TCHAR* url, TCHAR* szFilename, HWND hwndParent);

CCDNet::CCDNet()
{
    m_dwRef = 0;
}

CCDNet::~CCDNet()
{
}

STDMETHODIMP CCDNet::QueryInterface(REFIID riid, void** ppv)
{
    *ppv = NULL;
    if (IID_IUnknown == riid || IID_ICDNet == riid)
    {  
        *ppv = this;
    }

    if (NULL==*ppv)
    {
        return E_NOINTERFACE;
    }

    AddRef();

    return S_OK;
}

STDMETHODIMP_(ULONG) CCDNet::AddRef(void)
{
    return ++m_dwRef;
}

STDMETHODIMP_(ULONG) CCDNet::Release(void)
{
    if (0!=--m_dwRef)
        return m_dwRef;

    delete this;
    return 0;
}

STDMETHODIMP CCDNet::SetOptionsAndData(void* pOpts, void* pData)
{
    g_pNetOpt = (LPCDOPT)pOpts;
    g_pNetData = (LPCDDATA)pData;

    return S_OK;
}

//this is a start to implementing the "upload via http" case rather than the
//upload via mail case
BOOL UploadToProvider(LPCDPROVIDER pProvider, LPCDTITLE pTitle, HWND hwndParent)
{
    TCHAR szURL[INTERNET_MAX_URL_LENGTH];
    TCHAR szMainURL[INTERNET_MAX_URL_LENGTH];
    TCHAR szFilename[MAX_PATH];

    //get the InternetCanonicalizeURL function
	typedef BOOL (PASCAL *CANPROC)(LPCTSTR, LPTSTR, LPDWORD, DWORD);
    CANPROC canProc = NULL;

    HMODULE hNet = LoadLibrary(TEXT("WININET.DLL"));
    if (hNet!=NULL)
    {
	    canProc = (CANPROC)GetProcAddress(hNet,CANONFUNCTION);
    }
    else
    {
        return FALSE;
    }
    
    if (pProvider && pTitle && canProc)
    {
        //check for provider URL
        if (_tcslen(pProvider->szProviderUpload)>0)
        {
            TCHAR szTempCan[MAX_PATH*2];

            //create the URL to send
            wsprintf(szMainURL,TEXT("%s%s"),pProvider->szProviderUpload,pTitle->szTitleQuery);
            _tcscpy(szURL,szMainURL);

            //add title
            _tcscat(szURL,TEXT("&t="));
            DWORD dwSize = sizeof(szTempCan);
            canProc(pTitle->szTitle,szTempCan,&dwSize,0);
            _tcscat(szURL,szTempCan);

            //add artist
            _tcscat(szURL,TEXT("&a="));
            dwSize = sizeof(szTempCan);
            canProc(pTitle->szArtist,szTempCan,&dwSize,0);
            _tcscat(szURL,szTempCan);
        
            //add tracks
            TCHAR szTrack[MAX_PATH];
            for (DWORD i = 0; i < pTitle->dwNumTracks; i++)
            {
                wsprintf(szTrack,TEXT("&%u="),i+1);

                dwSize = sizeof(szTempCan);
                canProc(pTitle->pTrackTable[i].szName,szTempCan,&dwSize,0);

                if ((_tcslen(szURL) + _tcslen(szTrack) + _tcslen(szTempCan)) > 
                    MAX_UPLOAD_URL_LENGTH-sizeof(TCHAR))
                {
                    //we're coming close to the limit.  Send what we have and start rebuilding
                    if (!g_fCancelDownload)
                    {
                        if (DoDownload(szURL,szFilename, hwndParent))
                        {
                            DeleteFile(szFilename);
                        } //end if "upload" successful
                        else
                        {
                            //bad upload, don't bother sending the rest
                            //probably a timeout
                            return FALSE;
                        }
                    }

                    //reset the URL to just the provider + toc
                    _tcscpy(szURL,szMainURL);
                } //end if length

                _tcscat(szURL,szTrack);
                _tcscat(szURL,szTempCan);
            } //end for track

            //send it
            if (!g_fCancelDownload)
            {
                if (DoDownload(szURL,szFilename, hwndParent))
                {
                    DeleteFile(szFilename);
                } //end if "upload" successful
                else
                {
                    return FALSE;
                }
            }
        } //end if url exists
    } //end if state OK

    if (hNet)
    {
        FreeLibrary(hNet);
    }

    return TRUE;
}

DWORD WINAPI UploadThread(LPVOID pParam)
{
    InterlockedIncrement((LONG*)&g_lNumDownloadingThreads);

    //this will block us against the batch download happening, too
	EnterCriticalSection(&g_BatchCrit);

    LPCDTITLE pTitle = (LPCDTITLE)pParam;
    HWND hwndParent = g_hwndParent;
    
    int nTries = 0;
    int nSuccessful = 0;

    if (pTitle)
    {
        LPCDOPTIONS pOptions = g_pNetOpt->GetCDOpts();             // Get the options, needed for provider list

        if (pOptions && pOptions->pCurrentProvider)             // Make sure we have providers
        {        
            LPCDPROVIDER pProviderList = NULL;
            LPCDPROVIDER pProvider = NULL;
        
            g_pNetOpt->CreateProviderList(&pProviderList);       // Get the sorted provider list
            pProvider = pProviderList;                          // Get the head of the list

            while ((pProvider) && (!g_fCancelDownload))
            {
                nTries++;
                if (UploadToProvider(pProvider,pTitle,hwndParent))
                {
                    nSuccessful++;
                }
                pProvider = pProvider->pNext;
            }

            g_pNetOpt->DestroyProviderList(&pProviderList);
        } //end if providers
    }

    //addref'ed before thread was created
    g_pNetOpt->Release();
    g_pNetData->Release();
    
    long status = UPLOAD_STATUS_NO_PROVIDERS;
    
    if ((nSuccessful != nTries) && (nSuccessful > 0))
    {
        status = UPLOAD_STATUS_SOME_PROVIDERS;
    }

    if ((nSuccessful == nTries) && (nSuccessful > 0))
    {
        status = UPLOAD_STATUS_ALL_PROVIDERS;
    }

    if (g_fCancelDownload)
    {
        status = UPLOAD_STATUS_CANCELED;
    }

	LeaveCriticalSection(&g_BatchCrit);
    InterlockedDecrement((LONG*)&g_lNumDownloadingThreads);

    //post message saying we're done
    PostMessage(hwndParent,WM_NET_DONE,(WPARAM)g_dllInst,status);

    return 0;
}

STDMETHODIMP CCDNet::Upload(LPCDTITLE pTitle, HWND hwndParent)
{
    HRESULT hr = E_FAIL;
    DWORD   dwHow;
    BOOL    fConnected;

    if (g_pNetOpt && g_pNetData && pTitle)                                      // Make sure we are in a valid state
    {
        fConnected = _InternetGetConnectedState(&dwHow,0,TRUE);     // Make sure we are connected to net

        if (fConnected)                                             // Make sure we are in a valid state
        {
            EnterCriticalSection(&g_Critical);
            g_fCancelDownload = FALSE;
            LeaveCriticalSection(&g_Critical);

            DWORD dwThreadID;
            HANDLE hNetThread = NULL;

            g_hwndParent = hwndParent;
            g_pNetOpt->AddRef();
            g_pNetData->AddRef();
            hNetThread = CreateThread(NULL,0,UploadThread,(void*)pTitle,0,&dwThreadID);
            if (hNetThread)
            {
                CloseHandle(hNetThread);
                hr = S_OK;
            }
        } //end if connected
    } //end if options and data ok

    return (hr);
}

STDMETHODIMP_(BOOL) CCDNet::CanUpload()
{
    BOOL retcode = FALSE;

    if (g_pNetOpt && g_pNetData)                                      // Make sure we are in a valid state
    {
        //check all providers to be sure at least one has upload capability
        LPCDOPTIONS pOptions = g_pNetOpt->GetCDOpts();             // Get the options, needed for provider list

        if (pOptions && pOptions->pCurrentProvider)             // Make sure we have providers
        {        
            LPCDPROVIDER pProviderList = NULL;
            LPCDPROVIDER pProvider = NULL;
    
            g_pNetOpt->CreateProviderList(&pProviderList);       // Get the sorted provider list
            pProvider = pProviderList;                          // Get the head of the list

            while (pProvider)
            {
                if (_tcslen(pProvider->szProviderUpload) > 0)
                {
                    retcode = TRUE;
                }
                pProvider = pProvider->pNext;
            } //end while

            g_pNetOpt->DestroyProviderList(&pProviderList);
        } //end if providers
    } //end if set up properly

    return (retcode);
}

STDMETHODIMP CCDNet::Download(DWORD dwDeviceHandle, TCHAR chDrive, DWORD dwMSID, LPCDTITLE pTitle, BOOL fManual, HWND hwndParent)
{
    if (g_pNetOpt==NULL)
    {
        return E_FAIL;
    }

    if (g_pNetData==NULL)
    {
        return E_FAIL;
    }

    if (FAILED(g_pNetData->CheckDatabase(hwndParent)))
    {
        return E_FAIL;
    }

	CGetInfoFromNet netinfo(dwDeviceHandle, 
                            dwMSID, 
                            hwndParent);

    EnterCriticalSection(&g_Critical);
    g_fCancelDownload = FALSE;
    LeaveCriticalSection(&g_Critical);
    
	BOOL fResult = netinfo.DoIt(fManual, pTitle, chDrive);

    return fResult ? S_OK : E_FAIL;
}

STDMETHODIMP_(BOOL) CCDNet::IsDownloading()
{
    BOOL retcode = FALSE;

    if (g_lNumDownloadingThreads > 0)
    {
        retcode = TRUE;
    }

    return (retcode);
}

STDMETHODIMP CCDNet::CancelDownload()
{
    EnterCriticalSection(&g_Critical);
    if (g_pBind)
    {
        g_pBind->Abort();
    }
    g_fCancelDownload = TRUE;
    LeaveCriticalSection(&g_Critical);
    while (IsDownloading())
    {
        Sleep(10);
    }

    return S_OK;
}

struct CBindStatusCallback : IBindStatusCallback
{
///// object state
    ULONG           m_cRef;         // object reference count
	BOOL            m_fAbort;       // set to true if we want this to abort
    HWND            m_hMessage;     // callback window
	IStream*	    m_pStream;	// holds downloaded data

///// construction and destruction
    CBindStatusCallback(IStream* pStream, HWND hwndParent);
    ~CBindStatusCallback();

///// IUnknown methods
    STDMETHODIMP QueryInterface(REFIID riid, LPVOID *ppvObj);
    STDMETHODIMP_(ULONG) AddRef();
    STDMETHODIMP_(ULONG) Release();

///// IBindStatusCallback methods
    STDMETHODIMP OnStartBinding(DWORD dwReserved, IBinding *pib);
    STDMETHODIMP GetPriority(LONG *pnPriority);
    STDMETHODIMP OnLowResource(DWORD reserved);
    STDMETHODIMP OnProgress(ULONG ulProgress, ULONG ulProgressMax,
	ULONG ulStatusCode, LPCWSTR szStatusText);
    STDMETHODIMP OnStopBinding(HRESULT hresult, LPCWSTR szError);
    STDMETHODIMP GetBindInfo(DWORD *grfBINDF, BINDINFO *pbindinfo);
    STDMETHODIMP OnDataAvailable(DWORD grfBSCF, DWORD dwSize,
	FORMATETC *pformatetc, STGMEDIUM *pstgmed);
    STDMETHODIMP OnObjectAvailable(REFIID riid, IUnknown *punk);
};

/////////////////////////////////////////////////////////////////////////////
// CBindStatusCallback Creation & Destruction
//
CBindStatusCallback::CBindStatusCallback(IStream* pStream, HWND hwndParent)
{
    HRESULT hr = S_OK;
    m_cRef = 0;
    m_fAbort = FALSE;
    m_pStream = pStream;
    m_pStream->AddRef();
    m_hMessage = hwndParent;

    PostMessage(m_hMessage,WM_NET_STATUS,(WPARAM)g_dllInst,IDS_STRING_CONNECTING);
}


CBindStatusCallback::~CBindStatusCallback()
{
    EnterCriticalSection(&g_Critical);
    if (g_pBind)
    {
        g_pBind->Release();
        g_pBind = NULL;
    }
    LeaveCriticalSection(&g_Critical);

	if( m_pStream )
	{
		m_pStream->Release();
		m_pStream = NULL;
	}
}

/////////////////////////////////////////////////////////////////////////////
// CBindStatusCallback IUnknown Methods
//

STDMETHODIMP CBindStatusCallback::QueryInterface(REFIID riid, LPVOID *ppvObj)
{
    if (IsEqualIID(riid, IID_IUnknown) ||
	IsEqualIID(riid, IID_IBindStatusCallback))
    {
	    *ppvObj = (IBindStatusCallback *) this;
	    AddRef();
	    return NOERROR;
    }
    else
    {
    	*ppvObj = NULL;
	    return E_NOINTERFACE;
    }
}

STDMETHODIMP_(ULONG) CBindStatusCallback::AddRef()
{
    InterlockedIncrement((LONG*)&m_cRef);
    return m_cRef;
}

STDMETHODIMP_(ULONG) CBindStatusCallback::Release()
{
    ULONG cRef = m_cRef;
    if (InterlockedDecrement((LONG*)&m_cRef) == 0)
    {
    	delete this;
	    return 0;
    }
    else
	return cRef-1;
}


/////////////////////////////////////////////////////////////////////////////
// CBindStatusCallback IBindStatusCallback Methods
//

STDMETHODIMP CBindStatusCallback::OnStartBinding(DWORD dwReserved, IBinding *pib)
{
    EnterCriticalSection(&g_Critical);
    g_pBind = pib;
    g_pBind->AddRef();
    LeaveCriticalSection(&g_Critical);
    return S_OK;
}

STDMETHODIMP CBindStatusCallback::GetPriority(LONG *pnPriority)
{
    return S_OK;
}

STDMETHODIMP CBindStatusCallback::OnLowResource(DWORD reserved)
{
    return S_OK;
}

STDMETHODIMP CBindStatusCallback::OnProgress(ULONG ulProgress, ULONG ulProgressMax,
    ULONG ulStatusCode, LPCWSTR szStatusText)
{
	int nResID = 0;

    switch (ulStatusCode)
    {
        case (BINDSTATUS_FINDINGRESOURCE) : nResID = IDS_STRING_FINDINGRESOURCE; break;
        case (BINDSTATUS_CONNECTING) : nResID = IDS_STRING_CONNECTING; break;
        case (BINDSTATUS_REDIRECTING) : nResID = IDS_STRING_REDIRECTING; break;
        case (BINDSTATUS_BEGINDOWNLOADDATA) : nResID = IDS_STRING_BEGINDOWNLOAD; break;
        case (BINDSTATUS_DOWNLOADINGDATA) : nResID = IDS_STRING_DOWNLOAD; break;
        case (BINDSTATUS_ENDDOWNLOADDATA) : nResID = IDS_STRING_ENDDOWNLOAD; break;
        case (BINDSTATUS_SENDINGREQUEST) : nResID = IDS_STRING_SENDINGREQUEST; break;
    } //end switch
        
    if (nResID > 0)
    {
        PostMessage(m_hMessage,WM_NET_STATUS,(WPARAM)g_dllInst,nResID);
    }

    if (( m_fAbort ) || (g_fCancelDownload))
	{
        EnterCriticalSection(&g_Critical);
        g_fCancelDownload = TRUE;
        g_fDownloadDone = TRUE;
        LeaveCriticalSection(&g_Critical);
		return E_ABORT;
	}
    return S_OK;
}

STDMETHODIMP CBindStatusCallback::OnStopBinding(HRESULT hresult, LPCWSTR szError)
{
    EnterCriticalSection(&g_Critical);
    if (g_pBind)
    {
        g_pBind->Release();
        g_pBind = NULL;
    }
    LeaveCriticalSection(&g_Critical);
    return S_OK;
}


STDMETHODIMP CBindStatusCallback::GetBindInfo(DWORD *pgrfBINDF, BINDINFO *pbindinfo)
{
    *pgrfBINDF = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE;
    pbindinfo->cbSize = sizeof(BINDINFO);
    pbindinfo->szExtraInfo = NULL;
    ZeroMemory(&pbindinfo->stgmedData, sizeof(STGMEDIUM));
    pbindinfo->grfBindInfoF = 0;
    pbindinfo->dwBindVerb = BINDVERB_GET;
    pbindinfo->szCustomVerb = NULL;

    return S_OK;
}

STDMETHODIMP CBindStatusCallback::OnDataAvailable(DWORD grfBSCF, DWORD dwSize,
    FORMATETC *pformatetc, STGMEDIUM *pstgmed)
{
	// fill our stream with the data from the stream passed to us
	if( m_pStream )
	{
		ULARGE_INTEGER cb;

		cb.LowPart = dwSize;
		cb.HighPart = 0;
		if( pstgmed && pstgmed->pstm )
		{
			pstgmed->pstm->CopyTo( m_pStream, cb, NULL, NULL );
		}
	}

    // Notify owner when download is complete
	if( grfBSCF & BSCF_LASTDATANOTIFICATION )
	{
        g_fDownloadDone = TRUE;

		if( m_pStream )
		{
			m_pStream->Release();
			m_pStream = NULL;
		}
	}
    return S_OK;
}

STDMETHODIMP CBindStatusCallback::OnObjectAvailable(REFIID riid, IUnknown *punk)
{
    return E_NOTIMPL;
}

/////////////////////////////////////////////////////////////////////////////
// CGetInfoFromNet

CGetInfoFromNet::CGetInfoFromNet(DWORD cdrom, DWORD dwMSID, HWND hwndParent)
{
	DevHandle = cdrom;
	m_MS = dwMSID;
    g_hwndParent = hwndParent;
}

CGetInfoFromNet::~CGetInfoFromNet()
{
}

BOOL CGetInfoFromNet::DoIt(BOOL fManual, LPCDTITLE pTitle, TCHAR chDrive) 
{
	BOOL fRet = FALSE;

    int nMode = CONNECTION_GETITNOW;
    
    if (!fManual)
    {
        if (g_lNumDownloadingThreads == 0)
        {
            //if no threads are running already,
            //check the connection, possibly prompting the user
            nMode = ConnectionCheck(g_hwndParent,g_pNetOpt, chDrive);
        }
    }

    if (nMode == CONNECTION_DONOTHING)
    {
        return FALSE;
    }

	//if passed-in ID is not > 0, then we don't want to scan current disc
    if ((m_MS > 0) && (pTitle == NULL))
    {
        m_Tracks = readtoc();

	    if (m_Tracks > 0)
	    {
		    BuildQuery();
	    }
    } //if msid is greater than 0

    if (nMode == CONNECTION_BATCH)
    {
        if (m_MS > 0)
        {
            AddToBatch(m_Tracks,m_Query);
        }
        return FALSE;
    }

    //we need to determine now whether we spawn a batching thread or a single-item downloader
    g_fDBWriteFailure = FALSE;
    DWORD dwThreadID;
    HANDLE hNetThread = NULL;

    //addref the global pointers before entering the thread
    g_pNetOpt->AddRef();
    g_pNetData->AddRef();
    
    if (m_MS > 0)
    {
        //need to create a batch item for this thread to use
        LPCDBATCH pBatch = new CDBATCH;
        pBatch->fRemove = FALSE;
        pBatch->fFresh = TRUE;
        pBatch->pNext = NULL;

        if (!pTitle)
        {
            pBatch->dwTitleID = m_MS;
            pBatch->dwNumTracks = m_Tracks;
            pBatch->szTitleQuery = new TCHAR[_tcslen(m_Query)+1];
            _tcscpy(pBatch->szTitleQuery,m_Query);
        }
        else
        {
            pBatch->dwTitleID = pTitle->dwTitleID;
            pBatch->dwNumTracks = pTitle->dwNumTracks;
            if (pTitle->szTitleQuery)
            {
                pBatch->szTitleQuery = new TCHAR[_tcslen(pTitle->szTitleQuery)+1];
                _tcscpy(pBatch->szTitleQuery,pTitle->szTitleQuery);
            }
            else
            {
                pBatch->szTitleQuery = new TCHAR[_tcslen(m_Query)+1];
                _tcscpy(pBatch->szTitleQuery,m_Query);
            }
        }

        hNetThread = CreateThread(NULL,0,SpawnSingleDownload,(void*)pBatch,0,&dwThreadID);
    }
    else
    {
        hNetThread = CreateThread(NULL,0,SpawnBatchDownload,(void*)NULL,0,&dwThreadID);
    }

    if (hNetThread)
    {
        CloseHandle(hNetThread);
        fRet = TRUE;
    }

	return (fRet);
}

int CGetInfoFromNet::readtoc()
{
	DWORD dwRet;
    MCI_SET_PARMS   mciSet;

    ZeroMemory( &mciSet, sizeof(mciSet) );

    mciSet.dwTimeFormat = MCI_FORMAT_MSF;
    mciSendCommand( DevHandle, MCI_SET, MCI_SET_TIME_FORMAT, (DWORD_PTR)(LPVOID)&mciSet );

    MCI_STATUS_PARMS mciStatus;
    long lAddress, lStartPos, lDiskLen;
    int i;

    ZeroMemory( &mciStatus, sizeof(mciStatus) );
    mciStatus.dwItem = MCI_STATUS_NUMBER_OF_TRACKS;

    //
    // NOTE: none of the mciSendCommand calls below bother to check the
    //       return code.  This is asking for trouble... but if the
    //       commands fail we cannot do much about it.
    //
    dwRet = mciSendCommand( DevHandle, MCI_STATUS,
		    MCI_STATUS_ITEM, (DWORD_PTR)(LPVOID)&mciStatus);

	int tracks = -1;
	tracks = (UCHAR)mciStatus.dwReturn;

    mciStatus.dwItem = MCI_STATUS_POSITION;
    for ( i = 0; i < tracks; i++ )
    {

	    mciStatus.dwTrack = i + 1;
	    dwRet = mciSendCommand( DevHandle, MCI_STATUS,
			    MCI_STATUS_ITEM | MCI_TRACK,
			    (DWORD_PTR)(LPVOID)&mciStatus);

	    lAddress = (long)mciStatus.dwReturn;

        //converts "packed" time into pure frames
        lAddress =  (MCI_MSF_MINUTE(lAddress) * FRAMES_PER_MINUTE) +
					(MCI_MSF_SECOND(lAddress) * FRAMES_PER_SECOND) +
					(MCI_MSF_FRAME( lAddress));

		m_toc[i] = lAddress;

		if (i==0)
		{
			lStartPos = lAddress;
		}
    }

    mciStatus.dwItem = MCI_STATUS_LENGTH;
    dwRet = mciSendCommand( DevHandle, MCI_STATUS,
		    MCI_STATUS_ITEM, (DWORD_PTR)(LPVOID)&mciStatus);

    /*
    ** Convert the total disk length into frames
    */
    lAddress  = (long)mciStatus.dwReturn;
    lDiskLen =  (MCI_MSF_MINUTE(lAddress) * FRAMES_PER_MINUTE) +
				(MCI_MSF_SECOND(lAddress) * FRAMES_PER_SECOND) +
				(MCI_MSF_FRAME( lAddress));

    /*
    ** Now, determine the absolute start position of the sentinel
    ** track.  That is, the special track that marks the end of the
    ** disk.
    */
    lAddress = lStartPos + lDiskLen + 1; //dstewart: add one for true time

	m_toc[i] = lAddress;

	return (tracks);
}

void CGetInfoFromNet::BuildQuery()
{
    wsprintf(m_Query,TEXT("cd=%X"),m_Tracks);
	
	//add each frame stattime to query, include end time of disc
	TCHAR tempstr[MAX_PATH];
	for (int i = 0; i < m_Tracks+1; i++)
	{
		wsprintf(tempstr,TEXT("+%X"),m_toc[i]);
		_tcscat(m_Query,tempstr);
	}
}

void CGetInfoFromNet::AddToBatch(int nNumTracks, TCHAR* szQuery)
{
    if ((g_pNetData) && (g_pNetOpt))
    {
        g_pNetData->AddToBatch(m_MS, szQuery, nNumTracks);
        LPCDOPTIONS pOptions = g_pNetOpt->GetCDOpts();
        if (pOptions)
        {
            pOptions->dwBatchedTitles = g_pNetData->GetNumBatched();
            g_pNetOpt->DownLoadCompletion(0,NULL);
        }
    }
}    

void CopyStreamToFile( IStream* pStream, HANDLE hFile )
{
	TCHAR	achBuf[512];
	ULONG	cb = 1;
	DWORD	dwWritten;
	LARGE_INTEGER	dlib;

	dlib.LowPart = 0;
	dlib.HighPart = 0;
	pStream->Seek( dlib, STREAM_SEEK_SET, NULL );
	pStream->Read( achBuf, 512, &cb );
	while( cb )
	{
		if( FALSE == WriteFile( hFile, achBuf, cb, &dwWritten, NULL ))
		{
			break;
		}
		pStream->Read( achBuf, 512, &cb );
	}
}

BOOL DoDownload(TCHAR* url, TCHAR* szFilename, HWND hwndParent)
{
	TCHAR szPath[_MAX_PATH];
	TCHAR    sz[_MAX_PATH];
	BOOL fGotFileName = FALSE;

	// Get a file name
	if(GetTempPath(_MAX_PATH, szPath))
	{
		if(GetTempFileName(szPath, TEXT("cdd"), 0, sz))
		{
		    fGotFileName = TRUE;
	    }
	}

    if (!fGotFileName)
    {
	    return FALSE;
    }

    IStream* pStream = NULL;

    g_fDownloadDone = FALSE;
    if (FAILED(CreateStreamOnHGlobal( NULL, TRUE, &pStream )))
    {
        return FALSE;
    }
    //pStream was addref'ed by createstreamonhgobal

	CBindStatusCallback* pCDC = new CBindStatusCallback(pStream, hwndParent);
	if(!pCDC)
	{
        pStream->Release();
		return FALSE;
	}
	pCDC->AddRef();

    HRESULT hr = E_NOTIMPL;

    if (g_hURLMon == NULL)
    {
        g_hURLMon = LoadLibrary(TEXT("URLMON.DLL"));
    }

    if (g_hURLMon!=NULL)
    {
	    typedef BOOL (PASCAL *URLDOWNLOADPROC)(LPUNKNOWN, LPCTSTR, DWORD, LPBINDSTATUSCALLBACK);
	    URLDOWNLOADPROC URLDownload = (URLDOWNLOADPROC)GetProcAddress(g_hURLMon,URLFUNCTION);

        if (URLDownload!=NULL)
        {
            #ifdef DBG
	        OutputDebugString(url);
            OutputDebugString(TEXT("\n"));
            #endif
            hr = URLDownload(NULL, url, 0, pCDC);
        }
    }

	if(FAILED(hr))
	{
		pCDC->Release();
        pStream->Release();
        return FALSE;
	}

    pCDC->Release();

    if (g_fCancelDownload)
    {
        return FALSE;
    }

	// Create the file for writing
	HANDLE hFileWrite = CreateFile(sz, GENERIC_READ | GENERIC_WRITE, 
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_TEMPORARY, NULL);
	if( hFileWrite != INVALID_HANDLE_VALUE )
	{
		CopyStreamToFile( pStream, hFileWrite );
		CloseHandle( hFileWrite );
	}

    pStream->Release();

    _tcscpy(szFilename,sz);

    return TRUE;
}

//dialog box handler for multiple hits
INT_PTR CALLBACK MultiHitDlgProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
        case WM_INITDIALOG :
        {
            TCHAR* szFilename = (TCHAR*)lParam;
            TCHAR szTemp[MAX_PATH];
            TCHAR szArtist[MAX_PATH];
            TCHAR szTitle[MAX_PATH];
            int i = 1;

            _tcscpy(szTitle,TEXT("."));
            
            while (_tcslen(szTitle)>0)
            {
                wsprintf(szTemp,TEXT("Title%i"),i);
       	        GetPrivateProfileString(TEXT("CD"),szTemp,TEXT(""),szTitle,sizeof(szTitle)/sizeof(TCHAR),szFilename);
                wsprintf(szTemp,TEXT("Artist%i"),i);
    	        GetPrivateProfileString(TEXT("CD"),szTemp,TEXT(""),szArtist,sizeof(szArtist)/sizeof(TCHAR),szFilename);
                i++;

                if (_tcslen(szTitle)>0)
                {
                    wsprintf(szTemp,TEXT("%s (%s)"),szTitle,szArtist);
                    SendDlgItemMessage(hwnd,IDC_LIST_DISCS,LB_ADDSTRING,0,(LPARAM)szTemp);
                }
            }

            SendDlgItemMessage(hwnd,IDC_LIST_DISCS,LB_SETCURSEL,0,0);
        }
        break;

        case WM_COMMAND :
        {
            if (LOWORD(wParam)==IDCANCEL)
            {
                EndDialog(hwnd,-1);
            }

            if (LOWORD(wParam)==IDOK)
            {
                LRESULT nSel = SendDlgItemMessage(hwnd,IDC_LIST_DISCS,LB_GETCURSEL,0,0);
                EndDialog(hwnd,nSel+1);
            }
        }
        break;
    }

    return FALSE;
}

BOOL ResolveMultiples(TCHAR* szFilename, BOOL fCurrent, HWND hwndParent)
{
    //special case ... sometimes, this comes back with <2 hits!!!
    //in this case, go ahead and ask for URL1

    TCHAR sznewurl[INTERNET_MAX_URL_LENGTH];
    GetPrivateProfileString(TEXT("CD"),TEXT("URL2"),TEXT(""),sznewurl,sizeof(sznewurl)/sizeof(TCHAR),szFilename);

    INT_PTR nSelection = 0;

    if (_tcslen(sznewurl)==0)
    {
        nSelection = 1;
    }
    else
    {
        if (fCurrent)
        {
            nSelection = DialogBoxParam(g_dllInst, MAKEINTRESOURCE(IDD_MULTIPLE_HITS),
                       hwndParent, MultiHitDlgProc, (LPARAM)szFilename );
        }
    }

    if (nSelection > 0)
    {
        TCHAR szSelected[MAX_PATH];
        wsprintf(szSelected,TEXT("URL%i"),nSelection);

        GetPrivateProfileString(TEXT("CD"),szSelected,TEXT(""),sznewurl,sizeof(sznewurl)/sizeof(TCHAR),szFilename);

        DeleteFile(szFilename);

        if (DoDownload(sznewurl,szFilename, hwndParent))
        {
            return TRUE;
        }
    }

    return FALSE;
}

//no more cover art in first version
#if 0
void TranslateTempCoverToFinal(TCHAR* szCurrent, TCHAR* szFinal, long discid, TCHAR* extension)
{
    //we want to put the cover art in a "coverart" subdir relative to whereever CD player is
    TCHAR szPath[MAX_PATH];
    GetModuleFileName(NULL,szPath,sizeof(szPath));

    TCHAR* szPathEnd;
    szPathEnd = _tcsrchr(szPath, TEXT('\\'))+sizeof(TCHAR);
    _tcscpy(szPathEnd,TEXT("coverart\\"));

    CreateDirectory(szPath,NULL); //create the coverart subdir

    wsprintf(szFinal,TEXT("%s%08X%s"),szPath,discid,extension);
}
#endif

DWORD GetNextDisc(long lOriginal, LPCDBATCH* ppBatch)
{
    DWORD discid = (DWORD)-1;

    //only do the batch if no discid was passed in originally to thread
    if (lOriginal < 1)
    {
        if (*ppBatch!=NULL)
        {
            *ppBatch = (*ppBatch)->pNext;
            if (*ppBatch != NULL)
            {
                discid = (*ppBatch)->dwTitleID;
            }
        }
    }

    return (discid);
}       

LPCDPROVIDER GetNewProvider(LPCDPROVIDER pList, LPCDPROVIDER pCurrent, LPCDPROVIDER pDefault)
{
    //find the next provider that isn't the current
    if (pCurrent == pDefault)
    {
        //we've just done the current provider, so go to the head of the list next
        pCurrent = pList;
        if (pCurrent == pDefault)
        {
            //if the default was also the head of the list, go to the next and return
            pCurrent = pCurrent->pNext;
        }
        return (pCurrent);
    }

    //get the next entry on the list
    pCurrent = pCurrent->pNext;

    //is the next entry the same as the default entry?  if so, move on one more
    if (pCurrent == pDefault)
    {
        pCurrent = pCurrent->pNext;
    }

    return (pCurrent);
}

//if szProvider is NULL, szURL is filled in with "just the query" ...
//if szProvider is not NULL, it is prepended to the query in szURL
int GetTracksAndQuery(LPCDBATCH pBatch, TCHAR* szURL, TCHAR* szProvider)
{
    if (pBatch == NULL)
    {
        return 0;
    }
    
    int nReturn = pBatch->dwNumTracks;

    if (szProvider != NULL)
    {
        wsprintf(szURL,TEXT("%s%s"),szProvider,pBatch->szTitleQuery);
    }
    else
    {
        _tcscpy(szURL,pBatch->szTitleQuery);
    }

    return nReturn;
}

void WINAPI AddTitleToDatabase(DWORD dwDiscID, DWORD dwTracks, TCHAR *szURL, TCHAR *szTempFile)
{
    LPCDTITLE   pCDTitle = NULL;
    TCHAR       tempstr[CDSTR];
    BOOL        fContinue = TRUE;
    DWORD       dwMenus = 0;

    while (fContinue)
    {
        TCHAR szMenuIndex[10];
        TCHAR szMenuEntry[INTERNET_MAX_URL_LENGTH];
        wsprintf(szMenuIndex,TEXT("MENU%i"),dwMenus+1);

		GetPrivateProfileString( TEXT("CD"), szMenuIndex, TEXT(""),
						         szMenuEntry, sizeof(szMenuEntry)/sizeof(TCHAR), szTempFile );

        if (_tcslen(szMenuEntry)>0)
        {
            dwMenus++;
        }
        else
        {
            fContinue = FALSE;
        }
    }

    if (SUCCEEDED(g_pNetData->CreateTitle(&pCDTitle, dwDiscID, dwTracks, dwMenus)))
    {
        GetPrivateProfileString(TEXT("CD"),TEXT("TITLE"),TEXT(""),tempstr,sizeof(tempstr)/sizeof(TCHAR),szTempFile);
        _tcscpy(pCDTitle->szTitle,tempstr);

        GetPrivateProfileString(TEXT("CD"),TEXT("ARTIST"),TEXT(""),tempstr,sizeof(tempstr)/sizeof(TCHAR),szTempFile);
        _tcscpy(pCDTitle->szArtist,tempstr);

        GetPrivateProfileString(TEXT("CD"),TEXT("LABEL"),TEXT(""),tempstr,sizeof(tempstr)/sizeof(TCHAR),szTempFile);
        _tcscpy(pCDTitle->szLabel,tempstr);

        GetPrivateProfileString(TEXT("CD"),TEXT("COPYRIGHT"),TEXT(""),tempstr,sizeof(tempstr)/sizeof(TCHAR),szTempFile);
        _tcscpy(pCDTitle->szCopyright,tempstr);

        GetPrivateProfileString(TEXT("CD"),TEXT("RELEASEDATE"),TEXT(""),tempstr,sizeof(tempstr)/sizeof(TCHAR),szTempFile);
        _tcscpy(pCDTitle->szDate,tempstr);

        g_pNetData->SetTitleQuery(pCDTitle, szURL); 

        for (int i = 1; i < (int) dwTracks + 1; i++)
        {
	        TCHAR tempstrtrack[10];
	        TCHAR tempstrtitle[CDSTR];
	        wsprintf(tempstrtrack,TEXT("TRACK%i"),i);
	        GetPrivateProfileString(TEXT("CD"),tempstrtrack,TEXT(""),tempstrtitle,sizeof(tempstrtitle)/sizeof(TCHAR),szTempFile);

            if (_tcslen(tempstrtitle) == 0)
            {
                TCHAR strFormat[CDSTR];
                LoadString(g_dllInst,IDS_STRING_DEFAULTTRACK,strFormat,sizeof(strFormat)/sizeof(TCHAR));
                wsprintf(tempstrtitle,strFormat,i);
            }

            _tcscpy(pCDTitle->pTrackTable[i-1].szName,tempstrtitle);
        }

        for (i = 1; i < (int) (dwMenus + 1); i++)
        {
	        TCHAR tempstrmenu[10];
	        TCHAR tempstrmenuvalue[CDSTR+INTERNET_MAX_URL_LENGTH+(3*sizeof(TCHAR))]; //3 = two colons and a terminating null
	        wsprintf(tempstrmenu,TEXT("MENU%i"),i);
	        GetPrivateProfileString(TEXT("CD"),tempstrmenu,TEXT(""),tempstrmenuvalue,sizeof(tempstrmenuvalue)/sizeof(TCHAR),szTempFile);

            //need to split menu into its component parts
            if (_tcslen(tempstrmenuvalue)!=0)
            {
                TCHAR* szNamePart;
                szNamePart = _tcsstr(tempstrmenuvalue,URL_SEPARATOR);

                TCHAR* szURLPart;
                szURLPart = _tcsstr(tempstrmenuvalue,URL_SEPARATOR);
                if (szURLPart!=NULL)
                {
                    //need to move past two colons
                    szURLPart = _tcsinc(szURLPart);
                    szURLPart = _tcsinc(szURLPart);
                }

                if (szNamePart!=NULL)
                {
                    *szNamePart = '\0';
                }

                if (tempstrmenuvalue)
                {
                    if (_tcslen(tempstrmenuvalue) >= sizeof(pCDTitle->pMenuTable[i-1].szMenuText)/sizeof(TCHAR))
                    {
                        tempstrmenuvalue[sizeof(pCDTitle->pMenuTable[i-1].szMenuText)/sizeof(TCHAR) - 1] = TEXT('\0');  // Trunc string to max len
                    }
                    _tcscpy(pCDTitle->pMenuTable[i-1].szMenuText,tempstrmenuvalue);
                }

                if (szURLPart)
                { 
                    g_pNetData->SetMenuQuery(&(pCDTitle->pMenuTable[i-1]), szURLPart); 
                }
            }
        }

        g_pNetData->UnlockTitle(pCDTitle,TRUE);

        //at this point, if the title is not in the database, we have a major problem
        if (!g_pNetData->QueryTitle(dwDiscID))
        {
            g_fDBWriteFailure = TRUE;
        }
        else
        {
            g_fDBWriteFailure = FALSE;
        }
    }
}


BOOL IsCertifiedProvider(LPCDPROVIDER pProvider, TCHAR *szTempFile)
{
    BOOL    fCertified = TRUE;
    TCHAR   szCert[MAX_PATH];
    
    GetPrivateProfileString(TEXT("CD"),TEXT("CERTIFICATE"),TEXT(""),szCert,sizeof(szCert)/sizeof(TCHAR),szTempFile);

    fCertified = g_pNetOpt->VerifyProvider(pProvider,szCert);

    return(fCertified);
}

void UpdatePropertyPage(DWORD dwDiscID, BOOL fDownloading, HWND hwndParent)
{
    if (g_pNetOpt)
    {
        LPCDUNIT pUnit = g_pNetOpt->GetCDOpts()->pCDUnitList;

        while (pUnit!=NULL)
        {
            if (pUnit->dwTitleID == dwDiscID)
            {
                pUnit->fDownLoading = fDownloading;
                PostMessage(hwndParent,WM_NET_DB_UPDATE_DISC,0,(LPARAM)pUnit); //Tell the UI we changed status of disc
                break;
            }
            pUnit = pUnit->pNext;
        }
    }
}

BOOL WINAPI DownloadBatch(LPCDBATCH pBatch, LPCDPROVIDER pProvider, LPDWORD pdwMultiHit, LPBOOL pfTimeout, HWND hwndParent)
{
    BOOL    fSuccess = FALSE;
    DWORD   dwTracks;
    TCHAR   szURL[INTERNET_MAX_URL_LENGTH];
    TCHAR   szTempFile[MAX_PATH];
    DWORD   dwDiscID;

    dwTracks = GetTracksAndQuery(pBatch, szURL, pProvider->szProviderURL);
    dwDiscID = pBatch->dwTitleID;
    *pfTimeout = FALSE;

    UpdatePropertyPage(pBatch->dwTitleID, TRUE, hwndParent); //tell prop page ui that disc is downloading

    if (dwTracks > 0 && dwDiscID != 0)
    {
        if (DoDownload(szURL,szTempFile,hwndParent))
        {
            if (IsCertifiedProvider(pProvider, szTempFile))
            {
	            int nMode = GetPrivateProfileInt(TEXT("CD"),TEXT("MODE"),MODE_NOT_FOUND,szTempFile);

                if (nMode == MODE_NOT_FOUND)
                {
                    DeleteFile(szTempFile);
                }
                else if (nMode == MODE_MULTIPLE)
                {
                    if (pdwMultiHit)
                    {
                        (*pdwMultiHit)++;
                    }

                    if (!ResolveMultiples(szTempFile,TRUE,hwndParent))
                    {
                        DeleteFile(szTempFile);
                    }
                    else
                    {
                        nMode = MODE_OK;
                    }
                }
                
                if (nMode == MODE_OK)
                {
                    GetTracksAndQuery(pBatch,szURL,NULL); //reset szURL to lose the provider
                    AddTitleToDatabase(dwDiscID, dwTracks, szURL, szTempFile);
                    DeleteFile(szTempFile);
                    fSuccess = TRUE;
                } //end if mode ok
            } //end if certified provider
        } //end if download ok
        else
        {
            *pfTimeout = TRUE;
        }
    } //end if valid query
    
    UpdatePropertyPage(pBatch->dwTitleID, FALSE, hwndParent); //tell prop page ui that disc is no longer downloading

    return(fSuccess);
}

DWORD WINAPI SpawnSingleDownload(LPVOID pParam)
{
    InterlockedIncrement((LONG*)&g_lNumDownloadingThreads);

    LPCDBATCH pBatch = (LPCDBATCH)pParam;
    HWND hwndParent = g_hwndParent;
    
    if (pBatch)
    {
        DoBatchDownload(pBatch,hwndParent);

        //if download failed, add to batch if not already in db
        //but only do this if batching is turned on
        LPCDOPTIONS pOptions = g_pNetOpt->GetCDOpts();
        if (pOptions)
        {
            LPCDOPTDATA pOptionData = pOptions->pCDData;
            if (pOptionData)
            {
                if (pOptionData->fBatchEnabled)
                {
                    if (!g_pNetData->QueryTitle(pBatch->dwTitleID))
                    {
                        g_pNetData->AddToBatch(pBatch->dwTitleID, pBatch->szTitleQuery, pBatch->dwNumTracks);
                        pOptions->dwBatchedTitles = g_pNetData->GetNumBatched();
                        PostMessage(hwndParent,WM_NET_DB_UPDATE_BATCH,0,0); //Tell the UI we changed number in batch
                    } //end if not in db
                } //if batching is on
            } //end if option data
        } //end if poptions

        delete [] pBatch->szTitleQuery;
        delete pBatch;
    }

    //addref'ed before thread was created
    g_pNetOpt->Release();
    g_pNetData->Release();
    
    InterlockedDecrement((LONG*)&g_lNumDownloadingThreads);
    return 0;
}

DWORD WINAPI SpawnBatchDownload(LPVOID pParam)
{
    InterlockedIncrement((LONG*)&g_lNumDownloadingThreads);

    LPCDBATCH pBatchList = NULL;
    HWND hwndParent = g_hwndParent;

    if (g_pNetData)
    {
        if (SUCCEEDED(g_pNetData->LoadBatch(NULL,&pBatchList)))
        {
            DoBatchDownload(pBatchList,hwndParent);
            g_pNetData->UnloadBatch(pBatchList);
        }
    }

    //addref'ed before thread was created
    g_pNetOpt->Release();
    g_pNetData->Release();
    
    InterlockedDecrement((LONG*)&g_lNumDownloadingThreads);
    return 0;
}

DWORD WINAPI DoBatchDownload(LPCDBATCH pBatchList, HWND hwndParent)
{
	EnterCriticalSection(&g_BatchCrit);

    BOOL    retcode = FALSE;
    DWORD   dwHow;
    BOOL    fConnected;
    DWORD   dwCurrent = 0;
    DWORD   dwOther = 0;
    DWORD   dwMultiHit = 0;
    DWORD   dwTimedOut = 0;

    fConnected = _InternetGetConnectedState(&dwHow,0,TRUE);     // Make sure we are connected to net

    if (fConnected && g_pNetOpt && g_pNetData)                        // Make sure we are in a valid state
    {
        LPCDOPTIONS pOptions = g_pNetOpt->GetCDOpts();             // Get the options, needed for provider list

        if (pOptions && pOptions->pCurrentProvider)             // Make sure we have providers
        {        
            LPCDPROVIDER pProviderList = NULL;
            LPCDPROVIDER pProvider = NULL;
            
            g_pNetOpt->CreateProviderList(&pProviderList);       // Get the sorted provider list
            pProvider = pProviderList;                          // Get the head of the list

            LPCDBATCH pBatch;
                      
            if (pBatchList)
            {
                while (pProvider && !g_fCancelDownload)                 // loop thru providers, but check current first and only once.
                {
                    BOOL fNotifiedUIProvider = FALSE;
                    pBatch = pBatchList;
                
                    while (pBatch && !g_fCancelDownload && !pProvider->fTimedOut)  // We will loop thru each batched title
                    {
                        BOOL fAttemptDownload = TRUE;                   // Assume we are going to try to download all in batch
                        if (pBatch->fRemove)
                        {
                            fAttemptDownload = FALSE; //we've already tried this disc on one provider and got it
                        }

                        if (fAttemptDownload)
                        {
                            if (!fNotifiedUIProvider)
                            {
                                PostMessage(hwndParent,WM_NET_CHANGEPROVIDER,0,(LPARAM)pProvider); //Tell the UI who the provider is
                                fNotifiedUIProvider = TRUE;
                            }

                            BOOL fTimeout = FALSE;

                            if (DownloadBatch(pBatch, pProvider, &dwMultiHit, &fTimeout, hwndParent))  // attempt to download this batch
                            {
                                pBatch->fRemove = TRUE;                         // This batch download succeeded, mark for termination from batch

                                if (pProvider == pOptions->pCurrentProvider)
                                {
                                    dwCurrent++;
                                }
                                else
                                {
                                    dwOther++;
                                }
                            }
                            else
                            {
                                pProvider->fTimedOut = fTimeout;
                            }

                            //check to see if db write failed
                            if (g_fDBWriteFailure)
                            {
                                //let the UI know
                                PostMessage(hwndParent,WM_NET_DB_FAILURE,0,0);

                                //get out of the batch loop
                                break;
                            }
                        
                            //let ui know that something happened with this disc
                            PostMessage(hwndParent,WM_NET_DONE,(WPARAM)g_dllInst,pBatch->dwTitleID);

                            //increment the meter if we know this is the last time we're
                            //visiting this particular disc ... either it was found, or
                            //we are out of possible places to look
                            if ((pBatch->fRemove) || (pProvider->pNext == NULL))
                            {
                                PostMessage(hwndParent,WM_NET_INCMETER,(WPARAM)g_dllInst,pBatch->dwTitleID);
                            }

                        } //end attempt on disc

                        pBatch = pBatch->pNext;
                    } //end batch
                
                    if (g_fDBWriteFailure)
                    {
                        //get out of the provider loop
                        break;
                    }

                    pProvider = pProvider->pNext; //providers are "in order"
                } //end while cycling providers

            } //end if load batch OK

            //check to see if ALL providers timed out ... possible net problem
            BOOL fAllFailed = TRUE;
            pProvider = pProviderList;
            while (pProvider!=NULL)
            {
                if (!pProvider->fTimedOut)
                {
                    fAllFailed = FALSE;
                    break;
                }
                pProvider = pProvider->pNext;
            }

            if (fAllFailed)
            {
                //let the UI know
                PostMessage(hwndParent,WM_NET_NET_FAILURE,0,0);
            }

            g_pNetOpt->DestroyProviderList(&pProviderList);
        } //end if pointers ok

#ifdef DBG
        // Ok, output some interesting stat's about what happened.
        {
            TCHAR str[255];
            wsprintf(str, TEXT("current = %d, other = %d, multihits = %d\n"), dwCurrent, dwOther, dwMultiHit);
            OutputDebugString(str);
        }
#endif
    } //end if connected to net and pointers ok

    if (!fConnected)
    {
        //may be a net problem
        if ((dwHow & (INTERNET_CONNECTION_MODEM|INTERNET_CONNECTION_LAN)) == 0)
        {
            PostMessage(hwndParent,WM_NET_NET_FAILURE,0,0);
        }
    }

    PostMessage(hwndParent,WM_NET_DONE,(WPARAM)g_dllInst,(LPARAM) 0); //fBadGuy ? -1 : 0);

	LeaveCriticalSection(&g_BatchCrit);

    return (retcode);
}