//---------------------------------------------------------------------------
static void _FileIterator_BuildFilePathIfNeeded (StringA& strFilePath, const StringA& strDir, const StringA& strName)
{
if (strFilePath.isEmpty())
{
strFilePath.grow(strDir.length() + strName.length() + 2, false);
strFilePath = strDir;
strFilePath.pathAppend(strName);
}
}
StringA ReadLine()
{
StringA str;
while (1)
{
char c;
Read(&c, 1);
if (c == '\r')
{
char c2;
Read(&c2, 1);
if (c2 == '\n')
{
break;
}
else
{
if (str.length() == 512)
throw -1;
str += c;
if (str.length() == 512)
throw -1;
str += c2;
}
}
else
{
if (str.length() == 512)
throw -1;
str += c;
}
}
TRACE("%s\n", str.c_str());
return str;
}
void CallStackWnd::OnRender(UI::Graphics* pGraphics)
{
// HFONT hOldFont = dc.SelectFont((HFONT)GetStockObject(ANSI_FIXED_FONT));
{
LDraw::SolidBrush* brush = new LDraw::SolidBrush(LDraw::Color(255, 255, 255));
pGraphics->FillRectangle(brush, 0, 0, m_computedSize.Width, m_computedSize.Height);
}
for (int i = 0; i < m_callstack.size(); i++)
{
DebugFrame* pDebugFrame = m_callstack[i];
// if (m_pFrame->m_Eip >= line->u.instr.address && m_pFrame->m_Eip < line->u.instr.address+line->u.instr.nbytes)
// {
// }
if (i == 0)
{
DrawYellowArrow(pGraphics, i*16 + 8);
}
if (m_selected == i)
{
if (i != 0)
{
DrawGreenArrow(pGraphics, i*16 + 8);
}
}
pGraphics->DrawString(pDebugFrame->m_str, GetFont(), LDraw::PointF(14, i*16), new LDraw::SolidBrush(LDraw::Color::Black));
}
// dc.SelectFont(hOldFont);
#if 0
if (g_pt)
{
if (m_pFrame->m_ctx && m_pFrame->m_ctx->m_pDebugProcess && !m_pFrame->m_ctx->m_pDebugProcess->m_bRunning)
{
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, m_pFrame->m_dwProcessId);
int n = 0;
// DWORD eip = g_pt->m_context.Eip;
// DWORD ebp = g_pt->m_context.Ebp;
STACK_FRAME frame;
frame.Ebp = (STACK_FRAME*)g_pt->m_context.Ebp;
frame.Ret_Addr = (PBYTE)g_pt->m_context.Eip;
while (frame.Ebp)
{
StringA str = "";
for (int i = 0; i < m_pFrame->m_ctx->m_modules.size(); i++)
{
DebugModule* pModule = m_pFrame->m_ctx->m_modules[i];
if ((ULONG)frame.Ret_Addr >= pModule->base && (ULONG)frame.Ret_Addr < pModule->base + pModule->size)
{
str = pModule->name.c_str();
tysymbolmap::iterator psymi = NULL;
tysymbolmap::iterator symi = pModule->symbols.begin();
while (symi != pModule->symbols.end())
{
if ((*symi).first > (ULONG)frame.Ret_Addr)
{
break;
}
psymi = symi;
symi++;
}
if (psymi != NULL)
{
char s[512];
sprintf(s, "%s + %X", (*psymi).second->m_name.c_str(), frame.Ret_Addr - (*psymi).first);
str += s;
}
break;
}
}
if (str.length()==0)
{
char buf[64];
sprintf(buf, "%X", frame.Ret_Addr);
str = buf;
}
/*
for (i = 0; i < m_pFrame->m_ctx->sourceFiles.size(); i++)
{
SourceFile* sourceFile = m_pFrame->m_ctx->sourceFiles[i];
if (eip >= sourceFile->startAddress &&
eip < sourceFile->endAddress)
{
// sprintf(str, "%s() - %X", sourceFile->sourceFileName, eip);
// break;
}
}
*/
dc.TextOut(10, n*16, str.c_str());
// if (frame.Ebp == NULL)
// break;
DWORD nRead;
ReadProcessMemory(hProcess, frame.Ebp, &frame, 8, &nRead);
if (nRead == 0)
break;
//frame eip = oldeip;
n++;
}
//while (n < 20);
CloseHandle(hProcess);
}
}
#endif
}
void CGnutellaSocket::OnReceive(int nErrorCode)
{
TRACE("OnRead\n");
/*
if (nErrorCode)
{
ASSERT(0);
return;
}
*/
if (m_state == 0 || m_state == 1)
{
/*
time_t timer1;
time(&timer1);
double diff = difftime(timer1, m_timer0);
m_timer0 = timer1;
ATLTRACE("", diff);
*/
ULONG n;
ioctlsocket(m_socket, FIONREAD, &n);
char buf[256+1];
while (n)
{
int len = 256;
if (len > n)
len = n;
int nread = Receive(buf, len);
//if (nread == SOCKET_ERROR)
if (nread < len)
{
m_state = -1;
Close();
return;
}
n -= nread;
buf[nread] = 0;
m_strHandshake += buf;
}
/*
std::string line;
while (1)
{
line = ReadLine();
m_strHandshake += line + "\r\n";
if (line.length() == 0)
break;
}
*/
if (m_strHandshake.length() > 4096)
{
// Handshake overflow
ASSERT(0);
m_state = -1;
Close();
return;//break;
}
if (m_state == 0)
{
if (m_strHandshake.length() >= 12)
{
if (strncmp(m_strHandshake.c_str(), "GNUTELLA/0.6", 12))
{
// Not a gnutella peer (disconnect)
m_state = -1;
Close();
return;//break;
}
m_state = 1; // Now we know it's a gnutella peer (keep receiving handshake)
}
}
if (m_state == 1)
{
if (strstr(m_strHandshake.c_str(), "\r\n\r\n"))
{
m_state = 2; // Have read entire handshake string
}
}
if (m_state == 2)
{
int m_code = ParseHandshake();
m_pComm->ProcessHeaders(this);
if (m_code == 200) // OK
{
m_state = 3;
char* str =
"GNUTELLA/0.6 200 OK\r\n"
"\r\n";
// char* str = "GNUTELLA OK\n\n";
int nWritten = Send(str, strlen(str));
if (nWritten != strlen(str))
{
ASSERT(0);
}
// PostMessage(m_pComm->m_hWnd, WM_USER+102, (LPARAM)(IConnection*)this, m_code);
// m_pComm->m_client->OnConnection(this);
// Ping
{
GnutellaHeader ping;
CoCreateGuid(&ping.Guid); // ???
ping.PayloadType = GnutellaPing;
ping.TTL = 7;
ping.Hops = 0;
ping.PayloadLength = 0;
int wrote = Send((const char*)&ping, sizeof(ping));
}
}
else
{
Close();
/*
char* str =
"GNUTELLA/0.6 503 FAIL\r\n"
"\r\n";
int nWritten = Send(str, strlen(str));
if (nWritten != strlen(str))
{
ASSERT(0);
}
*/
}
}
}
else if (m_state == 3)
{
int nread = Receive(m_packetbuf+m_nbufbytes, 32768-m_nbufbytes);
if (nread == -1)
{
m_state = -1;
Close();
return;
}
int nbufbytes = m_nbufbytes + nread;
// Process all complete packets
bool bContinue;
int offset = 0;
int bytesleft;
do
{
bytesleft = nbufbytes - offset;
if (bytesleft < sizeof(GnutellaHeader))
{
// Incomplete packet
bContinue = false;
}
else
{
GnutellaHeader* hdr = (GnutellaHeader*)(m_packetbuf+offset);
if((hdr->PayloadType == 0x00 && hdr->PayloadLength < 32768) ||
(hdr->PayloadType == 0x01 && hdr->PayloadLength >= 14 && hdr->PayloadLength < 32768) ||
(hdr->PayloadType == 0x02 && hdr->PayloadLength > 0 && hdr->PayloadLength < 32768) ||
(hdr->PayloadType == 0x30 && hdr->PayloadLength > 2 && hdr->PayloadLength < 32768) ||
(hdr->PayloadType == 0x31 && hdr->PayloadLength < 32768) ||
(hdr->PayloadType == 0x32 && hdr->PayloadLength < 32768) ||
(hdr->PayloadType == 0x40 && hdr->PayloadLength >= 26 && hdr->PayloadLength < 32768) ||
(hdr->PayloadType == 0x80 && hdr->PayloadLength > 2 && hdr->PayloadLength <= 230) ||
(hdr->PayloadType == 0x81 && hdr->PayloadLength > 26 && hdr->PayloadLength <= 32768))
{
DWORD packetlen = sizeof(GnutellaHeader) + hdr->PayloadLength;
if (bytesleft < packetlen)
{
// Incomplete packet
bContinue = false;
}
else
{
ProcessPacket(hdr);
offset += packetlen;
bContinue = true;
}
}
else
{
bContinue = false;
m_state = -1;
Close();
return;
}
}
}
while (bContinue);
// Move the leftover bytes to the beginning of the buffer
if (bytesleft)
{
memmove(m_packetbuf, m_packetbuf+offset, bytesleft);
}
m_nbufbytes = bytesleft;
}
}
int CGnutellaSocket::ParseHandshake()
{
const char* p = m_strHandshake.c_str();
const char* pend = p+m_strHandshake.length();
if (!strncmp(p, "GNUTELLA/0.6", 12))
{
p += 12;
p++;
long code = strtol(p, (char**)&p, 10);
p++;
StringA codemsg;
while (p < pend)
{
if (p[0] == '\r' && p[1] == '\n')
{
break;
}
codemsg += *p;
p++;
}
if (*p++ != '\r') ASSERT(0);
if (*p++ != '\n') ASSERT(0);
// HttpHeaders headers;
m_headers.AddHeaders(p);
/*
while (p < pend)
{
std::string header;
while (p < pend)
{
if (p[0] == '\r' && p[1] == '\n')
{
break;
}
header += *p;
p++;
}
if (*p++ != '\r') ASSERT(0);
if (*p++ != '\n') ASSERT(0);
m_headers.push_back(header);
}
ASSERT(*p == 0);
*/
return code;
}
else
{
ASSERT(0);
return 0;
}
}
void MailAccount::GetNewMail(ITable* pTable)
{
int port = 110;
POP3Client* pSocket = new POP3Client;
pSocket->Create();
pSocket->Connect(m_server.c_str(), port);
StringA greeting = pSocket->ReadLine();
if (strncmp(greeting.c_str(), "+OK", 3))
throw -1;
{
char msg[512];
sprintf(msg, "USER %s\r\n", m_username.c_str());
pSocket->Write(msg, strlen(msg));
StringA response = pSocket->ReadLine();
if (strncmp(response.c_str(), "+OK", 3))
throw -1;
}
{
char msg[512];
sprintf(msg, "PASS %s\r\n", m_password.c_str());
pSocket->Write(msg, strlen(msg));
StringA response = pSocket->ReadLine();
if (strncmp(response.c_str(), "+OK", 3))
throw -1;
}
CArray<int, int> message_numbers;
{
char* msg = "LIST\r\n";
pSocket->Write(msg, strlen(msg));
StringA response = pSocket->ReadLine();
if (strncmp(response.c_str(), "+OK", 3))
throw -1;
while (1)
{
StringA line = pSocket->ReadLine();
if (!strcmp(line.c_str(), "."))
{
break;
}
int message_number;
int message_size;
sscanf(line.c_str(), "%d %d", &message_number, &message_size);
message_numbers.Add(message_number);
TRACE("%s\n", line.c_str());
}
// FILE* fp_text = fopen("C:\\mail_text", "a+b");
// FILE* fp_index = fopen("C:\\mail_index", "a+b");
for (int i = 0; i < message_numbers.size(); i++)
{
IRecord* pMessage = pTable->NewRecord();
pMessage->GetField((int)0)->SetValue((long)0);//m_ID;
pMessage->GetField(5)->SetValue((long)0);
pMessage->GetField(6)->SetValue(time(NULL));
pMessage->GetField(7)->SetValue(m_ID);
{
char msg[256];
sprintf(msg, "RETR %d\r\n", message_numbers[i]);
TRACE(msg);
pSocket->Write(msg, strlen(msg));
StringA response = pSocket->ReadLine();
if (strncmp(response.c_str(), "+OK", 3))
throw -1;
}
// Read the message
StringA lines;
while (1)
{
StringA line = pSocket->ReadLine();
if (!strcmp(line.c_str(), ".")) // Multiline message ends with '.\r\n'
{
break;
}
lines += line;
lines += "\r\n";
}
const char *p = lines.c_str();
while (*p)
{
if (p[0] == '\r' && p[1] == '\n') // End of headers
break;
// field name
StringA fieldName;
while (*p)
{
if (isspace(*p) || *p == ':')
break;
fieldName += *p;
p++;
}
while (isspace(*p)) p++;
if (*p++ != ':') throw -1;
while (isspace(*p)) p++;
// field body
StringA fieldBody;
while (*p)
{
if (p[0] == '\r' && p[1] == '\n')
{
if (p[2] == '\t' || p[2] == ' ') // continuation on next line
{
p += 3;
}
else
{
p += 2;
break; // End of this field
}
}
else
{
fieldBody += *p;
p++;
}
}
if (!stricmp(fieldName.c_str(), "Subject"))
{
pMessage->GetField(1)->SetData(fieldBody.c_str(), fieldBody.length());
}
else if (!stricmp(fieldName.c_str(), "From"))
{
pMessage->GetField(2)->SetData(fieldBody.c_str(), fieldBody.length());
}
}
pMessage->GetField(3)->SetData(lines.c_str(), p - lines.c_str());
if (p[0] != '\r' || p[1] != '\n')
throw -1;
p += 2;
pMessage->GetField(4)->SetData(p, lines.length() - (p - lines.c_str()));
pMessage->Write();
// The message isn't actually deleted from the server until we issue a QUIT command
{
char msg[256];
sprintf(msg, "DELE %d\r\n", message_numbers[i]);
TRACE(msg);
pSocket->Write(msg, strlen(msg));
StringA response = pSocket->ReadLine();
if (strncmp(response.c_str(), "+OK", 3))
throw -1;
}
}
/*
fclose(fp_index);
fclose(fp_text);
*/
}
{
char* msg = "QUIT\r\n";
pSocket->Write(msg, strlen(msg));
StringA response = pSocket->ReadLine();
if (strncmp(response.c_str(), "+OK", 3))
throw -1;
}
}
