HTTPGetFilesThread.cpp

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "HTTPGetFilesThread.h"
#pragma package(smart_init)

//---------------------------------------------------------------------------

__fastcall Task::Task(PFileList pFileList, HINTERNET hInternet)
{
  m_dwId = pFileList->dwTaskId;
  m_asHost = pFileList->asHost;
  m_pFiles = pFileList->pFiles;
  m_pBuffer = new byte[BUFFER_SIZE];
  m_hConnect = m_hRequest = NULL;
  m_pReadyFiles = new TList;
  m_pCurrentFile = NULL;
  m_dwTimeout = 3000;

  if(hInternet)
	m_hConnect = InternetConnect(hInternet, String(m_asHost).c_str(),
								 INTERNET_DEFAULT_HTTP_PORT,
                                 NULL,NULL,
                                 INTERNET_SERVICE_HTTP,
								 0, m_dwId);
  m_eStatus = (m_hConnect) ? tsReady : tsError;
}

__fastcall Task::~Task()
{
  if(m_hConnect) InternetCloseHandle(m_hConnect);
  if(m_hRequest) InternetCloseHandle(m_hRequest);

  while(m_pFiles->Count)
  {
    PFileDescr pItem = (PFileDescr)m_pFiles->Items[0];
    delete pItem;
    m_pFiles->Delete(0);
  }

  delete m_pFiles;

  if(m_pCurrentFile)
  {
    if(m_pCurrentFile->pData) delete m_pCurrentFile->pData;
    delete m_pCurrentFile;
  }

  while(m_pReadyFiles->Count)
  {
    PReadyFile pItem = (PReadyFile)m_pReadyFiles->Items[0];
    if(pItem->pData) delete pItem->pData;
    delete pItem;
    m_pReadyFiles->Delete(0);
  }

  delete m_pReadyFiles;

  delete [] m_pBuffer;
}

void __fastcall Task::Touch()
{
  if(m_hConnect)
  {
    if(!m_pCurrentFile)
    {                                                 
      m_pCurrentFile = new tagReadyFile;
      m_pCurrentFile->dwTaskId = m_dwId;
      for(int i = 0; i < FILE_DESCR_ID_SIZE; i++)
        m_pCurrentFile->sFileDescr.dwFileId[i] = ((PFileDescr)m_pFiles->Items[0])->dwFileId[i];
      m_pCurrentFile->sFileDescr.asFileName = ((PFileDescr)m_pFiles->Items[0])->asFileName;
      m_pCurrentFile->dwErrorCode = 0;
      m_pCurrentFile->pData = NULL;
      m_dwCurrentFileLength = 0;
    }

    if(m_eStatus == tsReady || m_eStatus == tsFileReady)
    {
      LPCTSTR rgpszAcceptTypes[] = {TEXT("*/*"), NULL};
	  m_hRequest = HttpOpenRequest(m_hConnect,
								   TEXT("GET"),
								   String(((PFileDescr)m_pFiles->Items[0])->asFileName).c_str(),
								   TEXT("HTTP/1.1"), NULL,
								   rgpszAcceptTypes,
                                   INTERNET_FLAG_KEEP_CONNECTION |
                                   INTERNET_FLAG_NO_CACHE_WRITE  |
                                   INTERNET_FLAG_PRAGMA_NOCACHE  |
                                   INTERNET_FLAG_RELOAD,
								   m_dwId);
                                   
      if(m_hRequest && HttpSendRequest(m_hRequest, NULL, 0, NULL, 0))
      {
        m_eStatus = tsReqSent;
        m_dwWaitFor = GetTickCount() + m_dwTimeout;
      }
      else m_eStatus = tsError;
    }
    else if(m_eStatus == tsReqSent)
    {
      DWORD dwIndex = 0;
      DWORD dwBufferSize = BUFFER_SIZE - 1;

      //if(InternetQueryDataAvailable(m_hRequest, &m_dwCurrentFileLength, 0, 0))
      if(HttpQueryInfo(m_hRequest, HTTP_QUERY_FLAG_NUMBER | HTTP_QUERY_CONTENT_LENGTH, m_pBuffer, &dwBufferSize, &dwIndex))
      {
        m_dwCurrentFileLength = *((DWORD*)m_pBuffer);
        m_eStatus = tsFileReading;
        m_dwWaitFor = GetTickCount() + m_dwTimeout;
      }
      else if(GetTickCount() > m_dwWaitFor) m_eStatus = tsError;
    }
    else if(m_eStatus == tsFileReading)
    {
      DWORD dwBytesRead = 0;

      if(InternetReadFile(m_hRequest, m_pBuffer, BUFFER_SIZE - 1, &dwBytesRead))
      {
        if(dwBytesRead)
        {
          m_dwWaitFor = GetTickCount() + m_dwTimeout;
          
          if(!m_pCurrentFile->pData) m_pCurrentFile->pData = new TMemoryStream;

          m_pCurrentFile->pData->Write(m_pBuffer, dwBytesRead);

          if(m_pCurrentFile->pData->Size == m_dwCurrentFileLength)
          {
            m_pCurrentFile->pData->Seek(0, soFromBeginning);
            m_pReadyFiles->Add(m_pCurrentFile);
            m_pCurrentFile = NULL;
            m_dwCurrentFileLength = 0;
            PFileDescr pFileDescr = (PFileDescr)m_pFiles->Items[0];
            delete pFileDescr;
            m_pFiles->Delete(0);

            if(!m_pFiles->Count) m_eStatus = tsComplete;
            else m_eStatus = tsFileReady;
          }
        }
        else if(GetTickCount() > m_dwWaitFor) m_eStatus = tsError;
      }
      else m_eStatus = tsError;
    }

    if(m_eStatus == tsError)
    {
      if(m_pCurrentFile->pData)
      {
        delete m_pCurrentFile->pData;
        m_pCurrentFile->pData = NULL;
      }

      m_pCurrentFile->dwErrorCode = GetLastError();
      m_pReadyFiles->Add(m_pCurrentFile);
      m_pCurrentFile = NULL;
      m_dwCurrentFileLength = 0;
      PFileDescr pFileDescr = (PFileDescr)m_pFiles->Items[0];
      delete pFileDescr;
      m_pFiles->Delete(0);

      if(!m_pFiles->Count) m_eStatus = tsComplete;
      else m_eStatus = tsFileReady;
    }
  }
}

bool __fastcall Task::GetConnected()
{
  return(m_hConnect != NULL);
}

DWORD __fastcall Task::GetId()
{
  return m_dwId;
}

TList* __fastcall Task::GetReadyFiles()
{
  return m_pReadyFiles;
}

PReadyFile __fastcall Task::GetReadyFile()
{
  PReadyFile pReadyFile = NULL;

  if(m_pReadyFiles->Count)
  {
    pReadyFile = (PReadyFile)m_pReadyFiles->Items[0];
    m_pReadyFiles->Delete(0);
  }

  return pReadyFile;
}

bool __fastcall Task::GetComplete()
{
  return (m_eStatus == tsComplete);
}

bool __fastcall Task::GetFileReady()
{
  return (m_pReadyFiles->Count > 0);
}

//---------------------------------------------------------------------------

//   Important: Methods and properties of objects in VCL can only be
//   used in a method called using Synchronize, for example:
//
//      Synchronize(UpdateCaption);
//
//   where UpdateCaption could look like:
//
//      void __fastcall THTTPGetFilesThread::UpdateCaption()
//      {
//        Form1->Caption = "Updated in a thread";
//      }
//---------------------------------------------------------------------------

__fastcall THTTPGetFilesThread::THTTPGetFilesThread(bool CreateSuspended)
  : TThread(CreateSuspended)
{
  m_pTaskList = new TList;
  m_pReadyTasks = new TThreadList;
  m_pNewTaskEvent = new TSimpleEvent(false);
  m_pFileReadyEvent = new TSimpleEvent(false);
  m_pDeleteTaskEvent = new TSimpleEvent(false);
  m_dwNewTaskId = 1;
  m_hInternet = NULL;
  m_pNewTask = NULL;
  m_dwCurrentTaskId = 0xFFFFFFFF;
  m_dwTaskToDelete = 0xFFFFFFFF;
}

//---------------------------------------------------------------------------
void __fastcall THTTPGetFilesThread::Execute()
{
  m_hInternet = InternetOpen(TEXT("Mozilla/4.0 (compatible; MSIE 6.0b; Windows NT 5.0; .NET CLR 1.0.2914)"),
                             INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);

  if(m_hInternet)
  {
    while(!Terminated)
    {
      if(m_pNewTaskEvent->WaitFor(1) == wrSignaled)
      {
        PTask pNewTask = new Task(m_pNewTask, m_hInternet);
        m_pTaskList->Add(pNewTask);
        delete m_pNewTask;
        m_pNewTask = NULL;

        m_pNewTaskEvent->ResetEvent();
      }

      if(m_pDeleteTaskEvent->WaitFor(1) == wrSignaled)
      {
        for(int i = 0; i < m_pTaskList->Count; i++)
        {
          PTask pTask = (PTask)m_pTaskList->Items[i];

          if(m_dwTaskToDelete == pTask->Id)
          {
            m_pTaskList->Delete(i);
            delete pTask;

            break;
          }
        }

        m_pDeleteTaskEvent->ResetEvent();
      }

      int i = 0;
      while(i < m_pTaskList->Count)
      {
        PTask pTask = (PTask)m_pTaskList->Items[i];

        if(pTask && pTask->Connected)
        {
          pTask->Touch();

          if(pTask->FileReady || pTask->Complete)
          {
            PReadyFile pReadyFile = pTask->ReadyFile;

            while(pReadyFile)
            {
              m_pReadyTasks->LockList()->Add(pReadyFile);
              m_pReadyTasks->UnlockList();

              m_pFileReadyEvent->SetEvent();
              pReadyFile = pTask->ReadyFile;
            }
          }

          if(pTask->Complete && !pTask->FileReady)
          {
            delete pTask;
            m_pTaskList->Delete(i);
          }
          else i++;
        }
      }

      Sleep(5);
    }

    InternetCloseHandle(m_hInternet);
  }
}
//---------------------------------------------------------------------------


__fastcall THTTPGetFilesThread::~THTTPGetFilesThread()
{
  delete m_pFileReadyEvent;
  delete m_pNewTaskEvent;
  delete m_pDeleteTaskEvent;

  while(m_pTaskList->Count)
  {
    PTask pItem = (PTask)m_pTaskList->Items[0];
    delete pItem;
    m_pTaskList->Delete(0);
  }

  delete m_pTaskList;

  TList *pList = m_pReadyTasks->LockList();

  while(pList->Count)
  {
    PReadyFile pTask = (PReadyFile)pList->Items[0];
    delete pTask->pData;
    delete pTask;
    pList->Delete(0);
  }

  m_pReadyTasks->UnlockList();
  delete m_pReadyTasks;
}

DWORD __fastcall THTTPGetFilesThread::AddTask(PFileList pFiles)
{
  DWORD dwTaskId = 0xFFFFFFFF;
  DWORD dwWaitFor = GetTickCount() + 1000;

  while(m_pNewTaskEvent->WaitFor(1) == wrSignaled && dwWaitFor < GetTickCount());

  if(m_pNewTaskEvent->WaitFor(1) == wrTimeout)
  {
    dwTaskId = m_dwNewTaskId++;
    if(m_dwNewTaskId == 0xFFFFFFFF) m_dwNewTaskId = 1;
    pFiles->dwTaskId = dwTaskId;
    m_pNewTask = new tagFileList;
    m_pNewTask->pFiles = new TList;

    m_pNewTask->asHost = pFiles->asHost;
    m_pNewTask->dwTaskId = pFiles->dwTaskId;

    for(int i = 0; i < pFiles->pFiles->Count; i++)
    {
      PFileDescr pNewFileDescr = new tagFileDescr;
      PFileDescr pFiledescr = (PFileDescr)pFiles->pFiles->Items[i];
      for(int j = 0; j < FILE_DESCR_ID_SIZE; j++)
        pNewFileDescr->dwFileId[j] = pFiledescr->dwFileId[j];
      pNewFileDescr->asFileName = pFiledescr->asFileName;

      m_pNewTask->pFiles->Add(pNewFileDescr);
    }

    m_pNewTaskEvent->SetEvent();
  }

  return dwTaskId;
}

PReadyFile __fastcall THTTPGetFilesThread::GetReadyFile()
{
  PReadyFile pReadyFile = NULL;
  TList *pList = m_pReadyTasks->LockList();

  if(pList->Count)
  {
    pReadyFile = (PReadyFile)pList->Items[0];
    pList->Delete(0);

    if(!pList->Count) m_pFileReadyEvent->ResetEvent();
  }

  m_pReadyTasks->UnlockList();

  return pReadyFile;
}

bool __fastcall THTTPGetFilesThread::GetFileReady()
{
  return (m_pFileReadyEvent->WaitFor(1) == wrSignaled);
}

bool __fastcall THTTPGetFilesThread::DeleteTask(DWORD dwTaskId)
{
  bool brc = false;
  DWORD dwWaitFor = GetTickCount() + 1000;

  while(m_pDeleteTaskEvent->WaitFor(1) == wrSignaled && dwWaitFor < GetTickCount());

  if(m_pDeleteTaskEvent->WaitFor(1) == wrTimeout)
  {
    m_dwTaskToDelete = dwTaskId;
    m_pDeleteTaskEvent->SetEvent();
  }
  
  return brc;
}

bool __fastcall THTTPGetFilesThread::GetComplete()
{
  return (m_pTaskList->Count == 0);
}