char *LoadFile(char *name, int *size)
{
char *buf;
buf = ReadFileBuf(name, size);
if (buf != NULL) {
WriteLog("load from file: %s\n", name);
goto next;
}
buf = ReadFromPack(name, size);
if (buf != NULL) {
goto next;
}
EngineError("not find: %s\n", name);
next:
return buf;
}
//===============================================================================================
// FUNCTION: getsUnBuf
// PURPOSE: Unbuffered version of gets
// RETURNS: ZERO on success
// GETS_EOF on EOF
// GETS_ERROR on error
//
static int getsUnBuf(ATF_FILEINFO *pATF, LPSTR pszString, DWORD dwBufSize)
{
WPTRASSERT(pATF);
ASSERT(dwBufSize > 1L); // Must be at least one character and a '\0';
DWORD dwToRead = dwBufSize;
// Zero terminate the buffer at the last element and reduce the length count
// to be sure that we are returning a zero term8inated string.
dwToRead--;
pszString[dwToRead] = '\0';
LPSTR pszThisRead = pszString;
while (dwToRead > 0L)
{
// Do the read.
DWORD dwBytesToRead = min(MAX_READ_SIZE, dwToRead);
DWORD dwBytesRead = 0L;
if (!ReadFileBuf(pATF, pszThisRead, dwBytesToRead, &dwBytesRead, NULL))
return GETS_ERROR;
if (dwBytesRead == 0L)
return GETS_EOF;
// Zero terminate the read block after the last byte read.
// No bounds problem because we predecremented the string size
// up front to allow for a trailing '\0'.
pszThisRead[dwBytesRead] = '\0';
// If the line terminator has not been set, set it now.
if (pATF->cLineTerm == '\0')
pATF->cLineTerm = GetLineTerminator(pszString);
// look for a line terminator.
LPSTR pszTerm = strchr(pszThisRead, pATF->cLineTerm);
if (pszTerm)
{
// Zero out the terminator and step on past it.
*pszTerm++ = '\0';
// Set the count of bytes to back up in the file.
int nCount = (pszThisRead + dwBytesRead) - pszTerm;
// adjust file position if we find a line terminator before the end of the buffer we have just read;
if (nCount < 0)
SetFilePointerBuf(pATF, nCount, NULL, FILE_CURRENT);
break;
}
dwToRead -= dwBytesRead;
pszThisRead += dwBytesRead;
}
// Take out the last character if it is '\r'.
// (present if \r\n pairs terminate lines)
int l = strlen(pszThisRead);
if (l && (pszThisRead[l-1]=='\r'))
{
--l;
pszThisRead[l] = '\0';
}
return (DWORD(l) < dwBufSize-1) ? 0 : GETS_NOEOL;
}
UINT CPClientFileSender::OnThread(int ThreadNum)
{
CRequest req;
CRequest reqSend;
COptionsMap map;
while(!m_Thread.IsStopped())
{
if(m_Thread.WaitEvent() == CThread::WAIT_STATUS_ON_EVENT)
{
while(m_GetFileRequestBuf.Pop(req) && !m_Thread.IsStopped())
{
if(req.m_iCommand == MESSAGE_TYPE_GET_FILE_BY_FILENAME)
{
map.FromString(req.GetDataAsString());
CString strFilename = map.GetOption(KEY_FILE);
CString strOffset = map.GetOption(KEY_OFFSET);
CString strHash = map.GetOption(KEY_HASH);
TRACE(_T("CPClientFileSender::OnThread try to send %s\n"), strFilename);
if(IsSkipedFile(strHash))
{
TRACE(_T("CPClientFileSender::OnThread IsSkipedFile==TRUE\n"));
continue;
}
if (strHash == _T("d41d8cd98f00b204e9800998ecf8427e"))
{
map.SetOption(KEY_OFFSET, 0);
map.SetOption(KEY_SIZE, 0);
map.SetOption(KEY_FILE, _T("d41d8cd98f00b204e9800998ecf8427e"));
map.SetOption(KEY_HASH, _T("d41d8cd98f00b204e9800998ecf8427e"));
CRequest reqTmp;
reqTmp.m_iCommand = MESSAGE_TYPE_FILE;
reqTmp.m_dwStationId = req.m_dwStationId;
reqTmp.SetData(map.ToString());
m_pLink->SendMsg(reqTmp);
continue;
}
LARGE_INTEGER Offset;
Offset.QuadPart = _ttoi64(strOffset);
//StrToInt64Ex(strOffset, STIF_DEFAULT, &Offset.QuadPart);
reqSend.m_dwStationId = req.m_dwStationId;
FILE * hFile = createFileToSend(strHash, strFilename);
if( hFile == NULL )
{
TRACE(_T("CPClientFileSender::OnThread CreateFile failed\n"));
if (strFilename.GetLength())
map.SetOption(KEY_FILE, strFilename);
map.SetOption(KEY_HASH, strHash);
map.SetOption(KEY_OFFSET, Offset.QuadPart);
LPVOID lpMsgBuf;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, GetLastError(), 0, (LPTSTR) &lpMsgBuf, 0, NULL);
map.SetOption(KEY_ERROR, (LPCTSTR)lpMsgBuf);
LocalFree( lpMsgBuf );
reqSend.m_iCommand = MESSAGE_TYPE_FILE_ERROR;
reqSend.SetData(map.ToString());
m_pLink->SendMsg(reqSend);
continue;
}
LARGE_INTEGER iDataLen, FullDataLen;
iDataLen.QuadPart = GetBinFileSizeEx( hFile);
FullDataLen = iDataLen;
if(Offset.QuadPart > -1L && Offset.QuadPart < iDataLen.QuadPart)
{
fpos_t pos = Offset.QuadPart;
fsetpos(hFile, &pos);
iDataLen.QuadPart -= Offset.QuadPart;
} else if(Offset.QuadPart > -1L && Offset.QuadPart >= iDataLen.QuadPart)
{
if (strFilename.GetLength())
map.SetOption(KEY_FILE, strFilename);
else
map.SetOption(KEY_FILE, strHash);
map.SetOption(KEY_HASH, strHash);
map.SetOption(KEY_OFFSET, Offset.QuadPart);
map.SetOption(KEY_ERROR, _T("Bad file offset"));
reqSend.m_iCommand = MESSAGE_TYPE_FILE_ERROR;
reqSend.SetData(map.ToString());
m_pLink->SendMsg(reqSend);
closeFile(hFile, strHash);
continue;
}
reqSend.m_iCommand = MESSAGE_TYPE_FILE;
#define MAX_FILE_DATA_SECTION 16384L
if(iDataLen.QuadPart > MAX_FILE_DATA_SECTION)
{
m_bSending = TRUE;
while(iDataLen.QuadPart > 0 && !m_Thread.IsStopped() &&
!IsSkipedFile(strHash) && m_bSending)
{
DWORD size = (DWORD)min(MAX_FILE_DATA_SECTION, iDataLen.QuadPart);
if (strFilename.GetLength())
map.SetOption(KEY_FILE, strFilename);
else
map.SetOption(KEY_FILE, strHash);
map.SetOption(KEY_HASH, strHash);
map.SetOption(KEY_OFFSET, Offset.QuadPart);
if(ReadFileBuf(hFile, size, map, reqSend))
{
if (m_InteractiveWnd)
{
//TRACE(_T("::PostMessage(HWND_BROADCAST, WM_FILE_INFO, %d, %d)\n"), Offset.LowPart, Offset.HighPart);
//::PostMessage(HWND_BROADCAST, WM_FILE_INFO, 1, 2);
PDataFileSendInfo pFileSendInfo = new DataFileSendInfo;
pFileSendInfo->FileSize = FullDataLen;
pFileSendInfo->SendedBytes = Offset;
pFileSendInfo->FileCount = m_GetFileRequestBuf.GetCount() + 1;
::PostMessage(m_InteractiveWnd->GetSafeHwnd(), WM_FILE_INFO, (WPARAM)pFileSendInfo, NULL);
}
if (m_UseLoPriority)
{
if(!m_pLink->SendMsgLoPriority(reqSend))
break;
}
else
{
if(!m_pLink->SendMsg(reqSend))
break;
}
} else
break;
iDataLen.QuadPart -= size;
Offset.QuadPart += size;
}
m_bSending = FALSE;
} else
{
if (strFilename.GetLength())
map.SetOption(KEY_FILE, strFilename);
else
map.SetOption(KEY_FILE, strHash);
map.SetOption(KEY_HASH, strHash);
map.SetOption(KEY_OFFSET, Offset.QuadPart);
if(ReadFileBuf(hFile, iDataLen.LowPart, map, reqSend))
{
m_pLink->SendMsg(reqSend);
}
}
closeFile(hFile, strHash);
}
else
{
TRACE(_T("CPClientFileSender::OnThread req.m_iCommand != MESSAGE_TYPE_GET_FILE_BY_FILENAME\n"));
}
}
}
}
return 0;
}
