unsigned int do_dump(void) { int i1; unsigned char *pByte_Val, byte_val; char ascii_result[18]; old_dump_beg = dump_beg; DebugPrint("\r\n %08X - ",dump_beg & 0xfffffff0); strcpy(ascii_result,"................"); for (i1=0;i1<(dump_beg & 0x000f);i1++) DebugSend(" "); while (dump_beg <= dump_end) { pByte_Val = (unsigned char *)dump_beg++; byte_val = *pByte_Val; DebugPrint("%02X ",byte_val); if (!iscntrl(byte_val&0x7f)) ascii_result[i1] = byte_val; i1++; if (!(dump_beg & 0x000f)) { DebugSend(" "); DebugSend(ascii_result); i1 = 0; strcpy(ascii_result,"................"); if (dump_beg==0) break; if (dump_beg <= dump_end) { DebugPrint("\r\n %08X - ",dump_beg & 0xfffffff0); } } } return (dump_beg); }
void DebugPrint(const char *format, ...) { char debug_result[82]; va_list argptr; va_start(argptr, format); vsprintf(debug_result, format, argptr); va_end(argptr); DebugSend(debug_result); }
bool CUpDownClient::SendPeerCacheFileRequest() { if (GetDownloadState() == DS_ONQUEUE){ ASSERT( m_ePeerCacheDownState == PCDS_NONE ); ASSERT( m_pPCDownSocket == NULL ); } else if (GetDownloadState() == DS_DOWNLOADING){ ASSERT( m_ePeerCacheDownState == PCDS_NONE ); ASSERT( m_pPCDownSocket == NULL ); } else{ ASSERT(0); } if (!SupportPeerCache() || socket == NULL){ ASSERT(0); return false; } m_uPeerCacheDownloadPushId = GetRandomUInt32(); CSafeMemFile data(128); data.WriteUInt8(PCPCK_VERSION); data.WriteUInt8(PCOP_REQ); data.WriteUInt8(5); CTag tagCacheIP(PCTAG_CACHEIP, theApp.m_pPeerCache->GetCacheIP()); tagCacheIP.WriteNewEd2kTag(&data); CTag tagPushId(PCTAG_PUSHID, m_uPeerCacheDownloadPushId); tagPushId.WriteNewEd2kTag(&data); CTag tagFileId(PCTAG_FILEID, (uchar*)reqfile->GetFileHash()); tagFileId.WriteNewEd2kTag(&data); CTag tagPublicIP(PCTAG_PUBLICIP, theApp.GetPublicIP()); tagPublicIP.WriteNewEd2kTag(&data); CTag tagCachePort(PCTAG_CACHEPORT, theApp.m_pPeerCache->GetCachePort()); tagCachePort.WriteNewEd2kTag(&data); if (thePrefs.GetDebugClientTCPLevel() > 0){ DebugSend("OP__PeerCacheQuery", this, reqfile->GetFileHash()); Debug(_T(" CacheIP=%s PushId=%u PublicIP=%s FileId=%s\n"), ipstr(tagCacheIP.GetInt()), tagPushId.GetInt(), ipstr(tagPublicIP.GetInt()), md4str(tagFileId.GetHash())); } Packet* pEd2kPacket = new Packet(&data, OP_EMULEPROT, OP_PEERCACHE_QUERY); theStats.AddUpDataOverheadFileRequest(pEd2kPacket->size); socket->SendPacket(pEd2kPacket); SetDownloadState(DS_DOWNLOADING); m_dwLastBlockReceived = ::GetTickCount(); SetPeerCacheDownState(PCDS_WAIT_CLIENT_REPLY); return true; }
bool CListenSocket::SendPortTestReply(char result, bool disconnect) { POSITION pos2; for(POSITION pos1 = socket_list.GetHeadPosition(); ( pos2 = pos1 ) != NULL; ) { socket_list.GetNext(pos1); CClientReqSocket* cur_sock = socket_list.GetAt(pos2); if (cur_sock->m_bPortTestCon) { if (thePrefs.GetDebugClientTCPLevel() > 0) DebugSend("OP__PortTest", cur_sock->client); Packet* replypacket = new Packet(OP_PORTTEST, 1); replypacket->pBuffer[0]=result; theStats.AddUpDataOverheadOther(replypacket->size); cur_sock->SendPacket(replypacket); if (disconnect) cur_sock->m_bPortTestCon = false; return true; } } return false; }
void CClientList::Process() { /////////////////////////////////////////////////////////////////////////// // Cleanup banned client list // const uint32 cur_tick = ::GetTickCount(); if (m_dwLastBannCleanUp + BAN_CLEANUP_TIME < cur_tick) { m_dwLastBannCleanUp = cur_tick; POSITION pos = m_bannedList.GetStartPosition(); uint32 nKey; uint32 dwBantime; while (pos != NULL) { m_bannedList.GetNextAssoc( pos, nKey, dwBantime ); if (dwBantime + CLIENTBANTIME < cur_tick ) RemoveBannedClient(nKey); } } /////////////////////////////////////////////////////////////////////////// // Cleanup tracked client list // if (m_dwLastTrackedCleanUp + TRACKED_CLEANUP_TIME < cur_tick) { m_dwLastTrackedCleanUp = cur_tick; if (thePrefs.GetLogBannedClients()) AddDebugLogLine(false, _T("Cleaning up TrackedClientList, %i clients on List..."), m_trackedClientsList.GetCount()); POSITION pos = m_trackedClientsList.GetStartPosition(); uint32 nKey; CDeletedClient* pResult; while (pos != NULL) { m_trackedClientsList.GetNextAssoc( pos, nKey, pResult ); if (pResult->m_dwInserted + KEEPTRACK_TIME < cur_tick ){ m_trackedClientsList.RemoveKey(nKey); delete pResult; } } if (thePrefs.GetLogBannedClients()) AddDebugLogLine(false, _T("...done, %i clients left on list"), m_trackedClientsList.GetCount()); } /////////////////////////////////////////////////////////////////////////// // Process Kad client list // //We need to try to connect to the clients in m_KadList //If connected, remove them from the list and send a message back to Kad so we can send a ACK. //If we don't connect, we need to remove the client.. //The sockets timeout should delete this object. //MORPH START - Removed by Stulle, Optimize Process Kad client list [WiZaRd] /* POSITION pos1, pos2; */ //MORPH END - Removed by Stulle, Optimize Process Kad client list [WiZaRd] // buddy is just a flag that is used to make sure we are still connected or connecting to a buddy. buddyState buddy = Disconnected; //MORPH START - Changed by Stulle, Optimize Process Kad client list [WiZaRd] /* for (pos1 = m_KadList.GetHeadPosition(); (pos2 = pos1) != NULL; ) { m_KadList.GetNext(pos1); CUpDownClient* cur_client = m_KadList.GetAt(pos2); */ for (POSITION pos = m_KadList.GetHeadPosition(); pos != NULL; ) { POSITION posLast = pos; CUpDownClient* cur_client = m_KadList.GetNext(pos); //MORPH END - Changed by Stulle, Optimize Process Kad client list [WiZaRd] if( !Kademlia::CKademlia::IsRunning() ) { //Clear out this list if we stop running Kad. //Setting the Kad state to KS_NONE causes it to be removed in the switch below. cur_client->SetKadState(KS_NONE); } switch(cur_client->GetKadState()) { case KS_QUEUED_FWCHECK: case KS_QUEUED_FWCHECK_UDP: //Another client asked us to try to connect to them to check their firewalled status. cur_client->TryToConnect(true, true); break; case KS_CONNECTING_FWCHECK: //Ignore this state as we are just waiting for results. break; case KS_FWCHECK_UDP: case KS_CONNECTING_FWCHECK_UDP: // we want a UDP firewallcheck from this client and are just waiting to get connected to send the request break; case KS_CONNECTED_FWCHECK: //We successfully connected to the client. //We now send a ack to let them know. if (cur_client->GetKadVersion() >= KADEMLIA_VERSION7_49a){ // the result is now sent per TCP instead of UDP, because this will fail if our intern UDP port is unreachable. // But we want the TCP testresult regardless if UDP is firewalled, the new UDP state and test takes care of the rest ASSERT( cur_client->socket != NULL && cur_client->socket->IsConnected() ); if (thePrefs.GetDebugClientTCPLevel() > 0) DebugSend("OP_KAD_FWTCPCHECK_ACK", cur_client); Packet* pPacket = new Packet(OP_KAD_FWTCPCHECK_ACK, 0, OP_EMULEPROT); if (!cur_client->SafeConnectAndSendPacket(pPacket)) cur_client = NULL; } else { if (thePrefs.GetDebugClientKadUDPLevel() > 0) DebugSend("KADEMLIA_FIREWALLED_ACK_RES", cur_client->GetIP(), cur_client->GetKadPort()); Kademlia::CKademlia::GetUDPListener()->SendNullPacket(KADEMLIA_FIREWALLED_ACK_RES, ntohl(cur_client->GetIP()), cur_client->GetKadPort(), 0, NULL); } //We are done with this client. Set Kad status to KS_NONE and it will be removed in the next cycle. if (cur_client != NULL) cur_client->SetKadState(KS_NONE); break; case KS_INCOMING_BUDDY: //A firewalled client wants us to be his buddy. //If we already have a buddy, we set Kad state to KS_NONE and it's removed in the next cycle. //If not, this client will change to KS_CONNECTED_BUDDY when it connects. if( m_nBuddyStatus == Connected ) cur_client->SetKadState(KS_NONE); break; case KS_QUEUED_BUDDY: //We are firewalled and want to request this client to be a buddy. //But first we check to make sure we are not already trying another client. //If we are not already trying. We try to connect to this client. //If we are already connected to a buddy, we set this client to KS_NONE and it's removed next cycle. //If we are trying to connect to a buddy, we just ignore as the one we are trying may fail and we can then try this one. if( m_nBuddyStatus == Disconnected ) { buddy = Connecting; m_nBuddyStatus = Connecting; cur_client->SetKadState(KS_CONNECTING_BUDDY); cur_client->TryToConnect(true, true); theApp.emuledlg->serverwnd->UpdateMyInfo(); } else if( m_nBuddyStatus == Connected ) cur_client->SetKadState(KS_NONE); break; case KS_CONNECTING_BUDDY: //We are trying to connect to this client. //Although it should NOT happen, we make sure we are not already connected to a buddy. //If we are we set to KS_NONE and it's removed next cycle. //But if we are not already connected, make sure we set the flag to connecting so we know //things are working correctly. if( m_nBuddyStatus == Connected ) cur_client->SetKadState(KS_NONE); else { ASSERT( m_nBuddyStatus == Connecting ); buddy = Connecting; } break; case KS_CONNECTED_BUDDY: //A potential connected buddy client wanting to me in the Kad network //We set our flag to connected to make sure things are still working correctly. buddy = Connected; //If m_nBuddyStatus is not connected already, we set this client as our buddy! if( m_nBuddyStatus != Connected ) { m_pBuddy = cur_client; m_nBuddyStatus = Connected; theApp.emuledlg->serverwnd->UpdateMyInfo(); } if( m_pBuddy == cur_client && theApp.IsFirewalled() && cur_client->SendBuddyPingPong() ) { if (thePrefs.GetDebugClientTCPLevel() > 0) DebugSend("OP__BuddyPing", cur_client); Packet* buddyPing = new Packet(OP_BUDDYPING, 0, OP_EMULEPROT); theStats.AddUpDataOverheadOther(buddyPing->size); VERIFY( cur_client->SendPacket(buddyPing, true, true) ); cur_client->SetLastBuddyPingPongTime(); } break; default: //MORPH START - Changed by Stulle, Optimize Process Kad client list [WiZaRd] /* RemoveFromKadList(cur_client); */ //removed function overhead if(cur_client == m_pBuddy) { //MORPH START - Added by Stulle, Fix for setting buddy state on removing buddy [WiZaRd] buddy = Disconnected; m_nBuddyStatus = Disconnected; //MORPH END - Added by Stulle, Fix for setting buddy state on removing buddy [WiZaRd] m_pBuddy = NULL; theApp.emuledlg->serverwnd->UpdateMyInfo(); } m_KadList.RemoveAt(posLast); //MORPH END - Changed by Stulle, Optimize Process Kad client list [WiZaRd] } } //We either never had a buddy, or lost our buddy.. if( buddy == Disconnected ) { if( m_nBuddyStatus != Disconnected || m_pBuddy ) { if( Kademlia::CKademlia::IsRunning() && theApp.IsFirewalled() && Kademlia::CUDPFirewallTester::IsFirewalledUDP(true)) { //We are a lowID client and we just lost our buddy. //Go ahead and instantly try to find a new buddy. Kademlia::CKademlia::GetPrefs()->SetFindBuddy(); } m_pBuddy = NULL; m_nBuddyStatus = Disconnected; theApp.emuledlg->serverwnd->UpdateMyInfo(); } } if ( Kademlia::CKademlia::IsConnected() ) { //we only need a buddy if direct callback is not available if( Kademlia::CKademlia::IsFirewalled() && Kademlia::CUDPFirewallTester::IsFirewalledUDP(true)) { //TODO 0.49b: Kad buddies won'T work with RequireCrypt, so it is disabled for now but should (and will) //be fixed in later version // Update: Buddy connections itself support obfuscation properly since 0.49a (this makes it work fine if our buddy uses require crypt) // ,however callback requests don't support it yet so we wouldn't be able to answer callback requests with RequireCrypt, protocolchange intended for the next version if( m_nBuddyStatus == Disconnected && Kademlia::CKademlia::GetPrefs()->GetFindBuddy() && !thePrefs.IsClientCryptLayerRequired()) { DEBUG_ONLY( DebugLog(_T("Starting Buddysearch")) ); //We are a firewalled client with no buddy. We have also waited a set time //to try to avoid a false firewalled status.. So lets look for a buddy.. if( !Kademlia::CSearchManager::PrepareLookup(Kademlia::CSearch::FINDBUDDY, true, Kademlia::CUInt128(true).Xor(Kademlia::CKademlia::GetPrefs()->GetKadID())) ) { //This search ID was already going. Most likely reason is that //we found and lost our buddy very quickly and the last search hadn't //had time to be removed yet. Go ahead and set this to happen again //next time around. Kademlia::CKademlia::GetPrefs()->SetFindBuddy(); } } } else { if( m_pBuddy ) { //Lets make sure that if we have a buddy, they are firewalled! //If they are also not firewalled, then someone must have fixed their firewall or stopped saturating their line.. //We just set the state of this buddy to KS_NONE and things will be cleared up with the next cycle. if( !m_pBuddy->HasLowID() ) m_pBuddy->SetKadState(KS_NONE); } } } else { if( m_pBuddy ) { //We are not connected anymore. Just set this buddy to KS_NONE and things will be cleared out on next cycle. m_pBuddy->SetKadState(KS_NONE); } } /////////////////////////////////////////////////////////////////////////// // Cleanup client list // CleanUpClientList(); /////////////////////////////////////////////////////////////////////////// // Process Direct Callbacks for Timeouts // ProcessConnectingClientsList(); }
/** * Add a client to the waiting queue for uploads. * * @param client address of the client that should be added to the waiting queue * * @param bIgnoreTimelimit don't check time limit to possibly ban the client. */ void CUploadQueue::AddClientToQueue(CUpDownClient* client, bool bIgnoreTimelimit) { //This is to keep users from abusing the limits we put on lowID callbacks. //1)Check if we are connected to any network and that we are a lowID. //(Although this check shouldn't matter as they wouldn't have found us.. // But, maybe I'm missing something, so it's best to check as a precaution.) //2)Check if the user is connected to Kad. We do allow all Kad Callbacks. //3)Check if the user is in our download list or a friend.. //We give these users a special pass as they are helping us.. //4)Are we connected to a server? If we are, is the user on the same server? //TCP lowID callbacks are also allowed.. //5)If the queue is very short, allow anyone in as we want to make sure //our upload is always used. if (theApp.IsConnected() && theApp.IsFirewalled() && !client->GetKadPort() && client->GetDownloadState() == DS_NONE && !client->IsFriend() && theApp.serverconnect && !theApp.serverconnect->IsLocalServer(client->GetServerIP(),client->GetServerPort()) && GetWaitingUserCount() > 50) return; client->AddAskedCount(); client->SetLastUpRequest(); if (!bIgnoreTimelimit) client->AddRequestCount(client->GetUploadFileID()); if (client->IsBanned()) return; uint16 cSameIP = 0; // check for double POSITION pos1, pos2; for (pos1 = waitinglist.GetHeadPosition();( pos2 = pos1 ) != NULL;) { waitinglist.GetNext(pos1); CUpDownClient* cur_client= waitinglist.GetAt(pos2); if (cur_client == client) { if (client->m_bAddNextConnect && AcceptNewClient(client->m_bAddNextConnect)) { //Special care is given to lowID clients that missed their upload slot //due to the saving bandwidth on callbacks. if(thePrefs.GetLogUlDlEvents()) AddDebugLogLine(true, _T("Adding ****lowid when reconnecting. Client: %s"), client->DbgGetClientInfo()); client->m_bAddNextConnect = false; RemoveFromWaitingQueue(client, true); // statistic values // TODO: Maybe we should change this to count each request for a file only once and ignore reasks CKnownFile* reqfile = theApp.sharedfiles->GetFileByID((uchar*)client->GetUploadFileID()); if (reqfile) reqfile->statistic.AddRequest(); AddUpNextClient(_T("Adding ****lowid when reconnecting."), client); return; } client->SendRankingInfo(); theApp.emuledlg->transferwnd->queuelistctrl.RefreshClient(client); return; } else if ( client->Compare(cur_client) ) { theApp.clientlist->AddTrackClient(client); // in any case keep track of this client // another client with same ip:port or hash // this happens only in rare cases, because same userhash / ip:ports are assigned to the right client on connecting in most cases if (cur_client->credits != NULL && cur_client->credits->GetCurrentIdentState(cur_client->GetIP()) == IS_IDENTIFIED) { //cur_client has a valid secure hash, don't remove him if (thePrefs.GetVerbose()) AddDebugLogLine(false, GetResString(IDS_SAMEUSERHASH), client->GetUserName(), cur_client->GetUserName(), client->GetUserName()); return; } if (client->credits != NULL && client->credits->GetCurrentIdentState(client->GetIP()) == IS_IDENTIFIED) { //client has a valid secure hash, add him remove other one if (thePrefs.GetVerbose()) AddDebugLogLine(false, GetResString(IDS_SAMEUSERHASH), client->GetUserName(), cur_client->GetUserName(), cur_client->GetUserName()); RemoveFromWaitingQueue(pos2,true); if (!cur_client->socket) { if(cur_client->Disconnected(_T("AddClientToQueue - same userhash 1"))) delete cur_client; } } else { // remove both since we do not know who the bad one is if (thePrefs.GetVerbose()) AddDebugLogLine(false, GetResString(IDS_SAMEUSERHASH), client->GetUserName() ,cur_client->GetUserName(), _T("Both")); RemoveFromWaitingQueue(pos2,true); if (!cur_client->socket) { if(cur_client->Disconnected(_T("AddClientToQueue - same userhash 2"))) delete cur_client; } return; } } else if (client->GetIP() == cur_client->GetIP()) { // same IP, different port, different userhash cSameIP++; } } if (cSameIP >= 3) { // do not accept more than 3 clients from the same IP if (thePrefs.GetVerbose()) DEBUG_ONLY( AddDebugLogLine(false,_T("%s's (%s) request to enter the queue was rejected, because of too many clients with the same IP"), client->GetUserName(), ipstr(client->GetConnectIP())) ); return; } else if (theApp.clientlist->GetClientsFromIP(client->GetIP()) >= 3) { if (thePrefs.GetVerbose()) DEBUG_ONLY( AddDebugLogLine(false,_T("%s's (%s) request to enter the queue was rejected, because of too many clients with the same IP (found in TrackedClientsList)"), client->GetUserName(), ipstr(client->GetConnectIP())) ); return; } // done // statistic values // TODO: Maybe we should change this to count each request for a file only once and ignore reasks CKnownFile* reqfile = theApp.sharedfiles->GetFileByID((uchar*)client->GetUploadFileID()); if (reqfile) reqfile->statistic.AddRequest(); // emule collection will bypass the queue if (reqfile != NULL && CCollection::HasCollectionExtention(reqfile->GetFileName()) && reqfile->GetFileSize() < (uint64)MAXPRIORITYCOLL_SIZE && !client->IsDownloading() && client->socket != NULL && client->socket->IsConnected()) { client->SetCollectionUploadSlot(true); RemoveFromWaitingQueue(client, true); AddUpNextClient(_T("Collection Priority Slot"), client); return; } else client->SetCollectionUploadSlot(false); // cap the list // the queue limit in prefs is only a soft limit. Hard limit is 25% higher, to let in powershare clients and other // high ranking clients after soft limit has been reached uint32 softQueueLimit = thePrefs.GetQueueSize(); uint32 hardQueueLimit = thePrefs.GetQueueSize() + max(thePrefs.GetQueueSize()/4, 200); // if soft queue limit has been reached, only let in high ranking clients if ((uint32)waitinglist.GetCount() >= hardQueueLimit || (uint32)waitinglist.GetCount() >= softQueueLimit && // soft queue limit is reached (client->IsFriend() && client->GetFriendSlot()) == false && // client is not a friend with friend slot client->GetCombinedFilePrioAndCredit() < GetAverageCombinedFilePrioAndCredit()) { // and client has lower credits/wants lower prio file than average client in queue // then block client from getting on queue return; } if (client->IsDownloading()) { // he's already downloading and wants probably only another file if (thePrefs.GetDebugClientTCPLevel() > 0) DebugSend("OP__AcceptUploadReq", client); Packet* packet = new Packet(OP_ACCEPTUPLOADREQ,0); theStats.AddUpDataOverheadFileRequest(packet->size); client->SendPacket(packet, true); return; } if (waitinglist.IsEmpty() && ForceNewClient(true)) { AddUpNextClient(_T("Direct add with empty queue."), client); } else { waitinglist.AddTail(client); client->SetUploadState(US_ONUPLOADQUEUE); theApp.emuledlg->transferwnd->queuelistctrl.AddClient(client,true); theApp.emuledlg->transferwnd->ShowQueueCount(waitinglist.GetCount()); client->SendRankingInfo(); } }
bool CUploadQueue::AddUpNextClient(LPCTSTR pszReason, CUpDownClient* directadd){ CUpDownClient* newclient = NULL; // select next client or use given client if (!directadd) { newclient = FindBestClientInQueue(); if(newclient) { RemoveFromWaitingQueue(newclient, true); theApp.emuledlg->transferwnd->ShowQueueCount(waitinglist.GetCount()); } } else newclient = directadd; if(newclient == NULL) return false; if (!thePrefs.TransferFullChunks()) UpdateMaxClientScore(); // refresh score caching, now that the highest score is removed if (IsDownloading(newclient)) return false; if(pszReason && thePrefs.GetLogUlDlEvents()) AddDebugLogLine(false, _T("Adding client to upload list: %s Client: %s"), pszReason, newclient->DbgGetClientInfo()); if (newclient->HasCollectionUploadSlot() && directadd == NULL){ ASSERT( false ); newclient->SetCollectionUploadSlot(false); } // tell the client that we are now ready to upload if (!newclient->socket || !newclient->socket->IsConnected()) { newclient->SetUploadState(US_CONNECTING); if (!newclient->TryToConnect(true)) return false; } else { if (thePrefs.GetDebugClientTCPLevel() > 0) DebugSend("OP__AcceptUploadReq", newclient); Packet* packet = new Packet(OP_ACCEPTUPLOADREQ,0); theStats.AddUpDataOverheadFileRequest(packet->size); newclient->SendPacket(packet, true); newclient->SetUploadState(US_UPLOADING); } newclient->SetUpStartTime(); newclient->ResetSessionUp(); InsertInUploadingList(newclient); m_nLastStartUpload = ::GetTickCount(); // statistic CKnownFile* reqfile = theApp.sharedfiles->GetFileByID((uchar*)newclient->GetUploadFileID()); if (reqfile) reqfile->statistic.AddAccepted(); theApp.emuledlg->transferwnd->uploadlistctrl.AddClient(newclient); return true; }
void debug_parse(char *cmd_line) { int params, result; unsigned int temp1,temp2,temp3,temp4; unsigned short tempword; unsigned char tempbyte; while (*cmd_line == ' ') cmd_line++; switch (toupper(*cmd_line++)) { case '?': DebugPrint("\r\n Compile Date: %s, Time: %s",__DATE__,__TIME__); break; case 'A': // assemble break; case 'B': break; case 'C': // compare break; case 'D': // dump params = sscanf(cmd_line,"%X %X",&temp2,&temp3); switch (params) { case 0: case EOF: dump_end = dump_beg + 127; do_dump(); break; case 1: dump_beg = temp2; dump_end = dump_beg + 127; do_dump(); break; case 2: if (temp3<temp2) temp3=temp2; dump_beg = temp2; dump_end = temp3; do_dump(); break; } break; case 'E': // read unsigned int if (sscanf(cmd_line,"%X",&temp1)==1) debug_port = (unsigned char*)(temp1&0xFFFFFFFC); temp2 = *(unsigned int*)debug_port; DebugPrint("\r\n %08X -> %08X",(int)debug_port,temp2); // debug_port += sizeof(int); break; case 'F': // fill params = sscanf(cmd_line,"%X %X %X",&temp2,&temp3,&temp4); switch (params) { case 3: dump_end = temp3; for (old_dump_beg=temp2;old_dump_beg<=dump_end;old_dump_beg++) { // pokeb(dump_seg,old_dump_beg,temp4); } break; default: { DebugSend(" ?? \r\n"); } break; } break; case 'G': // go DebugInit(); break; case 'H': // hex break; case 'I': // read byte break; case 'J': // read word break; case 'K': break; case 'L': // load break; case 'M': // write unsigned int if (sscanf(cmd_line,"%X %X",&temp1,&temp2)==2) { debug_port = (unsigned char*)(temp1&0xFFFFFFFC); DebugPrint("\r\n %08X <- %08X",(int)debug_port,temp2); *(unsigned int*)debug_port = temp2; debug_port += sizeof(int); } else { DebugSend(" ?? \r\n"); } break; case 'N': // name break; case 'O': // output byte if (sscanf(cmd_line,"%X %X",&temp1,&temp2)==2) { debug_port = (unsigned char*)temp1; tempbyte = temp2; DebugPrint("\r\n %08X <- %02X",(int)debug_port,tempbyte); *debug_port = tempbyte; debug_port += sizeof(tempbyte); } else { DebugSend(" ?? \r\n"); } break; case 'P': // proceed if (sscanf(cmd_line,"%d",&temp1)==1) { gain_Ap = temp1; } DebugPrint("\r\n gain_Ap = %5.1f",gain_Ap); break; case 'Q': // quit if (sscanf(cmd_line,"%d",&temp1)==1) { gain_Ai = temp1; } DebugPrint("\r\n gain_Ai = %5.1f",gain_Ai); break; case 'R': // register if (sscanf(cmd_line,"%d",&temp1)==1) { gain_Ad = temp1; } DebugPrint("\r\n gain_Ad = %5.1f",gain_Ad); break; case 'S': // search if (sscanf(cmd_line,"%X",&temp2)==1) { } break; case 'T': // Test if (sscanf(cmd_line,"%X",&temp1)==1) { switch (temp1){ case 0: #ifdef _MPU6050_H_ result = MPU6050_Setup(); if (result==STATUS_OK) { DebugPrint("\r\n MPU6050 Init Success!"); } else { DebugPrint("\r\n MPU6050 Init Fail. Error = %i", result); } #endif break; case 1: break; case 2: break; case 3: break; case 4: break; case 5: break; case 6: break; case 7: break; case 8: break; case 9: break; } } else { bTest = !bTest; if (bTest) { DebugPrint("\r\n Test ON!"); ResetTimer(DEBUG_TIMER); StartTimer(DEBUG_TIMER,50); } else { DebugPrint("\r\n Test OFF!"); } } break; case 'U': if (sscanf(cmd_line,"%d %d",&temp1,&temp2)==2) { DebugPrint("\r\n L298_set_speed(%d,%d)", temp1, temp2); L298_set_speed(temp1,temp2); } else if (sscanf(cmd_line,"%X",&temp1)==1) { switch (temp1){ case 0: break; case 1: break; case 2: break; case 3: break; case 4: break; case 5: //U5 break; case 6: //U6 break; case 7: //U7 break; case 8: break; case 9: break; } } else { } break; case 'W': // write word if (sscanf(cmd_line,"%X %X",&temp1,&temp2)==2) { debug_port = (unsigned char*)(temp1&0xFFFFFFFE); tempword = temp2; DebugPrint("\r\n %08X <- %04X",(int)debug_port,tempword); *(unsigned short*)debug_port = tempword; debug_port += sizeof(tempword); } else { DebugSend(" ?? \r\n"); } break; case 'X': if (sscanf(cmd_line,"%X",&temp1)==1) { switch (temp1){ case 0: break; case 1: break; case 2: break; case 3: break; case 4: break; case 5: break; case 6: break; case 7: break; case 8: break; case 9: break; } } else { } break; case 'Y': temp4 = sscanf(cmd_line,"%X %X",&temp1,&temp2); if (temp4>=1) { switch (temp1){ case 0: break; case 1: break; case 2: break; case 3: break; case 4: break; case 5: break; case 6: break; case 7: break; case 8: break; case 9: break; } } else { } break; case 'Z': debug_main_Z(cmd_line); break; default: ; } }
void CUpDownClient::ProcessHttpBlockPacket(const BYTE* pucData, UINT uSize) { if (reqfile == NULL) throw CString(_T("Failed to process HTTP data block - No 'reqfile' attached")); if (reqfile->IsStopped() || (reqfile->GetStatus() != PS_READY && reqfile->GetStatus() != PS_EMPTY)) throw CString(_T("Failed to process HTTP data block - File not ready for receiving data")); if (m_nUrlStartPos == -1) throw CString(_T("Failed to process HTTP data block - Unexpected file data")); uint32 nStartPos = m_nUrlStartPos; uint32 nEndPos = m_nUrlStartPos + uSize; m_nUrlStartPos += uSize; // if (thePrefs.GetDebugClientTCPLevel() > 0) // Debug(" Start=%u End=%u Size=%u %s\n", nStartPos, nEndPos, size, DbgGetFileInfo(reqfile->GetFileHash())); if (!(GetDownloadState() == DS_DOWNLOADING || GetDownloadState() == DS_NONEEDEDPARTS)) throw CString(_T("Failed to process HTTP data block - Invalid download state")); m_dwLastBlockReceived = ::GetTickCount(); if (nEndPos == nStartPos || uSize != nEndPos - nStartPos) throw CString(_T("Failed to process HTTP data block - Invalid block start/end offsets")); thePrefs.Add2SessionTransferData(GetClientSoft(), (GetClientSoft()==SO_URL) ? (UINT)-2 : (UINT)-1, false, false, uSize); m_nDownDataRateMS += uSize; if (credits) credits->AddDownloaded(uSize, GetIP()); nEndPos--; for (POSITION pos = m_PendingBlocks_list.GetHeadPosition(); pos != NULL; ) { POSITION posLast = pos; Pending_Block_Struct *cur_block = m_PendingBlocks_list.GetNext(pos); if (cur_block->block->StartOffset <= nStartPos && nStartPos <= cur_block->block->EndOffset) { if (thePrefs.GetDebugClientTCPLevel() > 0){ // NOTE: 'Left' is only accurate in case we have one(!) request block! void* p = m_pPCDownSocket ? (void*)m_pPCDownSocket : (void*)socket; Debug(_T("%08x Start=%u End=%u Size=%u Left=%u %s\n"), p, nStartPos, nEndPos, uSize, cur_block->block->EndOffset - (nStartPos + uSize) + 1, DbgGetFileInfo(reqfile->GetFileHash())); } m_nLastBlockOffset = nStartPos; uint32 lenWritten = reqfile->WriteToBuffer(uSize, pucData, nStartPos, nEndPos, cur_block->block, this); if (lenWritten > 0) { m_nTransferredDown += uSize; SetTransferredDownMini(); if (nEndPos >= cur_block->block->EndOffset) { reqfile->RemoveBlockFromList(cur_block->block->StartOffset, cur_block->block->EndOffset); delete cur_block->block; delete cur_block; m_PendingBlocks_list.RemoveAt(posLast); if (m_PendingBlocks_list.IsEmpty()) { if (thePrefs.GetDebugClientTCPLevel() > 0) DebugSend("More block requests", this); m_nUrlStartPos = (UINT)-1; SendHttpBlockRequests(); } } // else // TRACE("%hs - %d bytes missing\n", __FUNCTION__, cur_block->block->EndOffset - nEndPos); } return; } } TRACE("%s - Dropping packet\n", __FUNCTION__); }
bool CUpDownClient::ProcessPeerCacheQuery(const uchar* packet, UINT size) { const bool bDebug = (thePrefs.GetDebugClientTCPLevel() > 0); if (bDebug) DebugRecv("OP_PeerCacheQuery", this); if (socket == NULL){ ASSERT(0); return false; } CSafeMemFile dataRecv(packet, size); uint8 uPCVersion = dataRecv.ReadUInt8(); if (uPCVersion != PCPCK_VERSION){ if (bDebug) Debug(_T(" ***Invalid packet version: 0x%02x\n"), uPCVersion); ASSERT(0); return false; } uint8 uPCOpcode = dataRecv.ReadUInt8(); if (uPCOpcode != PCOP_REQ){ if (bDebug) Debug(_T(" ***Invalid packet opcode: 0x%02x\n"), uPCOpcode); ASSERT(0); return false; } uint32 uCacheIP = 0; uint16 uCachePort = 0; uint32 uPushId = 0; uchar aucFileHash[16]; uint32 uRemoteIP = 0; md4clr(aucFileHash); CString strInfo; UINT uTags = dataRecv.ReadUInt8(); while (uTags--) { CTag tag(&dataRecv, GetUnicodeSupport()!=utf8strNone); if (tag.GetNameID() == PCTAG_CACHEIP && tag.IsInt()) { uCacheIP = tag.GetInt(); if (bDebug) strInfo.AppendFormat(_T(" CacheIP=%s"), ipstr(uCacheIP)); } else if (tag.GetNameID() == PCTAG_CACHEPORT && tag.IsInt()) { uCachePort = (uint16)tag.GetInt(); if (bDebug) strInfo.AppendFormat(_T(" CachePort=%u"), uCachePort); } else if (tag.GetNameID() == PCTAG_PUSHID && tag.IsInt()) { uPushId = tag.GetInt(); if (bDebug) strInfo.AppendFormat(_T(" PushId=%u"), uPushId); } else if (tag.GetNameID() == PCTAG_FILEID && tag.IsHash() && tag.GetHash() != NULL) { md4cpy(aucFileHash, tag.GetHash()); if (bDebug) strInfo.AppendFormat(_T(" FileId=%s"), md4str(aucFileHash)); } else if (tag.GetNameID() == PCTAG_PUBLICIP && tag.IsInt()) { uRemoteIP = tag.GetInt(); if (bDebug) strInfo.AppendFormat(_T(" PublicIP=%s"), ipstr(uRemoteIP)); } else { if (bDebug) strInfo.AppendFormat(_T(" ***UnkTag: %s"), tag.GetFullInfo()); ASSERT(0); } } if (bDebug) { if (dataRecv.GetPosition() < dataRecv.GetLength()) strInfo.AppendFormat(_T(" ***AddData: %u bytes"), (UINT)(dataRecv.GetLength() - dataRecv.GetPosition())); Debug(_T("%s\n"), strInfo); } if (uCacheIP == 0 || uCachePort == 0 || uPushId == 0 || isnulmd4(aucFileHash)){ if (thePrefs.GetVerbose()) AddDebugLogLine(false, _T("Invalid PeerCacheQuery; %s"), DbgGetClientInfo()); return false; } CKnownFile* pUploadFile = theApp.sharedfiles->GetFileByID(aucFileHash); if (pUploadFile == NULL){ if (thePrefs.GetVerbose()) AddDebugLogLine(false, _T("PeerCacheQuery reqfile does not match ed2k reqfile; %s"), DbgGetClientInfo()); return false; } if (m_pPCUpSocket != NULL) { SetPeerCacheUpState(PCUS_NONE); m_pPCUpSocket->Safe_Delete(); ASSERT( m_pPCUpSocket == NULL ); } m_pPCUpSocket = new CPeerCacheUpSocket(this); m_pPCUpSocket->SetTimeOut(GetPeerCacheSocketUploadTimeout()); m_pPCUpSocket->Create(); SOCKADDR_IN sockAddr = {0}; sockAddr.sin_family = AF_INET; sockAddr.sin_port = htons(uCachePort); sockAddr.sin_addr.S_un.S_addr = uCacheIP; //Try to always tell the socket to WaitForOnConnect before you call Connect. m_pPCUpSocket->WaitForOnConnect(); m_pPCUpSocket->Connect((SOCKADDR*)&sockAddr, sizeof sockAddr); CStringA strPCRequest; strPCRequest.AppendFormat("GIVE %u\r\n", uPushId); if (thePrefs.GetDebugClientTCPLevel() > 0){ DebugSend("PeerCache-GIVE", this, pUploadFile->GetFileHash()); Debug(_T(" %hs\n"), strPCRequest); } CRawPacket* pHttpPacket = new CRawPacket(strPCRequest); theStats.AddUpDataOverheadFileRequest(pHttpPacket->size); m_pPCUpSocket->SendPacket(pHttpPacket); m_pPCUpSocket->SetHttpState(HttpStateRecvExpected); m_bPeerCacheUpHit = false; SetPeerCacheUpState(PCUS_WAIT_CACHE_REPLY); //theApp.uploadBandwidthThrottler->AddToStandardList(0, m_pPCUpSocket); CSafeMemFile dataSend(128); dataSend.WriteUInt8(PCPCK_VERSION); dataSend.WriteUInt8(PCOP_RES); dataSend.WriteUInt8(3); CTag tagPushId(PCTAG_PUSHID, uPushId); tagPushId.WriteNewEd2kTag(&dataSend); CTag tagPublicIP(PCTAG_PUBLICIP, theApp.GetPublicIP()); tagPublicIP.WriteNewEd2kTag(&dataSend); CTag tagFileId(PCTAG_FILEID, (BYTE*)aucFileHash); tagFileId.WriteNewEd2kTag(&dataSend); if (thePrefs.GetDebugClientTCPLevel() > 0){ DebugSend("OP__PeerCacheAnswer", this, aucFileHash); Debug(_T(" PushId=%u PublicIP=%s FileId=%s\n"), tagPushId.GetInt(), ipstr(tagPublicIP.GetInt()), md4str(tagFileId.GetHash())); } Packet* pEd2kPacket = new Packet(&dataSend, OP_EMULEPROT, OP_PEERCACHE_ANSWER); theStats.AddUpDataOverheadFileRequest(pEd2kPacket->size); socket->SendPacket(pEd2kPacket); return true; }
bool CUpDownClient::SendHttpBlockRequests() { USES_CONVERSION; ASSERT( GetDownloadState() == DS_DOWNLOADING ); ASSERT( m_ePeerCacheDownState == PCDS_WAIT_CLIENT_REPLY || m_ePeerCacheDownState == PCDS_DOWNLOADING ); m_bPeerCacheDownHit = false; m_dwLastBlockReceived = ::GetTickCount(); if (reqfile == NULL) throw CString(_T("Failed to send block requests - No 'reqfile' attached")); CreateBlockRequests(1); if (m_PendingBlocks_list.IsEmpty()){ if (m_pPCDownSocket != NULL){ m_pPCDownSocket->Safe_Delete(); ASSERT( m_pPCDownSocket == NULL ); SetPeerCacheDownState(PCDS_NONE); } SetDownloadState(DS_NONEEDEDPARTS); SwapToAnotherFile(_T("A4AF for NNP file. CUpDownClient::SendHttpBlockRequests()"), true, false, false, NULL, true, true); return false; } // PeerCache does not support persistant HTTP connections if (m_pPCDownSocket != NULL) { m_pPCDownSocket->Safe_Delete(); ASSERT( m_pPCDownSocket == NULL ); SetPeerCacheDownState(PCDS_NONE); return SendPeerCacheFileRequest(); } ASSERT( m_pPCDownSocket == NULL ); m_pPCDownSocket = new CPeerCacheDownSocket(this); m_pPCDownSocket->SetTimeOut(GetPeerCacheSocketDownloadTimeout()); if (!m_pPCDownSocket->Create()){ m_pPCDownSocket->Safe_Delete(); ASSERT( m_pPCDownSocket == NULL ); return false; } ASSERT( !m_pPCDownSocket->IsConnected() ); SOCKADDR_IN sockAddr = {0}; sockAddr.sin_family = AF_INET; sockAddr.sin_port = htons( theApp.m_pPeerCache->GetCachePort() ); sockAddr.sin_addr.S_un.S_addr = theApp.m_pPeerCache->GetCacheIP(); //Try to always tell the socket to WaitForOnConnect before you call Connect. m_pPCDownSocket->WaitForOnConnect(); m_pPCDownSocket->Connect((SOCKADDR*)&sockAddr, sizeof sockAddr); POSITION pos = m_PendingBlocks_list.GetHeadPosition(); Pending_Block_Struct* pending = m_PendingBlocks_list.GetNext(pos); ASSERT( pending->block->StartOffset <= pending->block->EndOffset ); m_uReqStart = pending->block->StartOffset; m_uReqEnd = pending->block->EndOffset; m_nUrlStartPos = (uint64)-1; CStringA strPCRequest; strPCRequest.AppendFormat("GET http://%s/.ed2khash=%s HTTP/1.0\r\n", ipstrA(m_uPeerCacheRemoteIP), md4strA(reqfile->GetFileHash())); strPCRequest.AppendFormat("X-ED2K-PushId: %u\r\n", m_uPeerCacheDownloadPushId); strPCRequest.AppendFormat("Range: bytes=%I64u-%I64u\r\n", m_uReqStart, m_uReqEnd); strPCRequest.AppendFormat("User-Agent: eMule/%s\r\n", T2CA(theApp.m_strCurVersionLong)); strPCRequest.AppendFormat("X-Network: eDonkey,Kademlia\r\n"); strPCRequest.AppendFormat("\r\n"); if (thePrefs.GetDebugClientTCPLevel() > 0){ DebugSend("PeerCache-GET", this, reqfile->GetFileHash()); Debug(_T(" %hs\n"), strPCRequest); } CRawPacket* pHttpPacket = new CRawPacket(strPCRequest); theStats.AddUpDataOverheadFileRequest(pHttpPacket->size); m_pPCDownSocket->SendPacket(pHttpPacket); m_pPCDownSocket->SetHttpState(HttpStateRecvExpected); SetPeerCacheDownState(PCDS_WAIT_CACHE_REPLY); return true; }
bool CUpDownClient::ProcessPeerCacheDownHttpResponse(const CStringAArray& astrHeaders) { ASSERT( GetDownloadState() == DS_DOWNLOADING ); ASSERT( m_ePeerCacheDownState == PCDS_WAIT_CACHE_REPLY ); if (reqfile == NULL) throw CString(_T("Failed to process HTTP response - No 'reqfile' attached")); if (GetDownloadState() != DS_DOWNLOADING) throw CString(_T("Failed to process HTTP response - Invalid client download state")); if (astrHeaders.GetCount() == 0) throw CString(_T("Unexpected HTTP response - No headers available")); const CStringA& rstrHdr = astrHeaders.GetAt(0); UINT uHttpMajVer, uHttpMinVer, uHttpStatusCode; if (sscanf(rstrHdr, "HTTP/%u.%u %u", &uHttpMajVer, &uHttpMinVer, &uHttpStatusCode) != 3){ CString strError; strError.Format(_T("Unexpected HTTP response: \"%hs\""), rstrHdr); throw strError; } if (uHttpMajVer != 1 || (uHttpMinVer != 0 && uHttpMinVer != 1)){ CString strError; strError.Format(_T("Unexpected HTTP version: \"%hs\""), rstrHdr); throw strError; } bool bExpectData = uHttpStatusCode == HTTP_STATUS_OK || uHttpStatusCode == HTTP_STATUS_PARTIAL_CONTENT; if (!bExpectData){ CString strError; strError.Format(_T("Unexpected HTTP status code \"%u\""), uHttpStatusCode); throw strError; } uint64 uContentLength = 0; bool bCacheHit = false; bool bValidContentRange = false; for (int i = 1; i < astrHeaders.GetCount(); i++) { const CStringA& rstrHdr = astrHeaders.GetAt(i); if (bExpectData && strnicmp(rstrHdr, "Content-Length:", 15) == 0) { uContentLength = _atoi64((LPCSTR)rstrHdr + 15); if (uContentLength > m_uReqEnd - m_uReqStart + 1){ CString strError; strError.Format(_T("Unexpected HTTP header field \"%hs\""), rstrHdr); throw strError; } } else if (bExpectData && strnicmp(rstrHdr, "Content-Range:", 14) == 0) { uint64 ui64Start = 0, ui64End = 0, ui64Len = 0; if (sscanf((LPCSTR)rstrHdr + 14," bytes %I64u - %I64u / %I64u", &ui64Start, &ui64End, &ui64Len) != 3){ CString strError; strError.Format(_T("Unexpected HTTP header field \"%hs\""), rstrHdr); throw strError; } if (ui64Start > ui64End || ui64Len != reqfile->GetFileSize() || ui64Start < m_uReqStart || ui64Start > m_uReqEnd || ui64End < m_uReqStart || ui64End > m_uReqEnd){ CString strError; strError.Format(_T("Unexpected HTTP header field \"%hs\""), rstrHdr); throw strError; } bValidContentRange = true; m_nUrlStartPos = ui64Start; } else if (strnicmp(rstrHdr, "Server:", 7) == 0) { if (m_strClientSoftware.IsEmpty()) m_strClientSoftware = rstrHdr.Mid(7).Trim(); } else if (bExpectData && strnicmp(rstrHdr, "X-Cache: MISS", 13) == 0) { bCacheHit = false; } else if (bExpectData && strnicmp(rstrHdr, "X-Cache: HIT", 12) == 0) { bCacheHit = true; } } // we either get a 'Content-Range' or (for very small files) just a 'Content-Length' for the entire file if (!bValidContentRange && uContentLength == reqfile->GetFileSize()) { bValidContentRange = true; m_nUrlStartPos = 0; } if (!bValidContentRange){ if (thePrefs.GetDebugClientTCPLevel() <= 0) DebugHttpHeaders(astrHeaders); CString strError; strError.Format(_T("Unexpected HTTP response - No valid HTTP content range found")); throw strError; } if (m_pPCDownSocket) { CSafeMemFile dataAck(128); dataAck.WriteUInt8( bCacheHit ? 1 : 0 ); if (thePrefs.GetDebugClientTCPLevel() > 0){ DebugSend("OP__PeerCacheAck", this, reqfile->GetFileHash()); Debug(_T(" %s\n"), bCacheHit ? _T("CacheHit") : _T("CacheMiss")); } Packet* pEd2kPacket = new Packet(&dataAck, OP_EMULEPROT, OP_PEERCACHE_ACK); theStats.AddUpDataOverheadFileRequest(pEd2kPacket->size); socket->SendPacket(pEd2kPacket); } // SetDownloadState(DS_DOWNLOADING); //PC-TODO: Where does this flag need to be cleared again? // When client is allowed to send more block requests? // Also, we have to support both type of downloads within in the same connection. SetPeerCacheDownState(PCDS_DOWNLOADING); m_bPeerCacheDownHit = bCacheHit; return true; }
bool CClientUDPSocket::ProcessPacket(const BYTE* packet, uint16 size, uint8 opcode, uint32 ip, uint16 port) { switch(opcode) { case OP_REASKCALLBACKUDP: { if (thePrefs.GetDebugClientUDPLevel() > 0) DebugRecv("OP_ReaskCallbackUDP", NULL, NULL, ip); theStats.AddDownDataOverheadOther(size); CUpDownClient* buddy = theApp.clientlist->GetBuddy(); if( buddy ) { if( size < 17 || buddy->socket == NULL ) break; if (!md4cmp(packet, buddy->GetBuddyID())) { PokeUInt32(const_cast<BYTE*>(packet)+10, ip); PokeUInt16(const_cast<BYTE*>(packet)+14, port); Packet* response = new Packet(OP_EMULEPROT); response->opcode = OP_REASKCALLBACKTCP; response->pBuffer = new char[size]; memcpy(response->pBuffer, packet+10, size-10); response->size = size-10; if (thePrefs.GetDebugClientTCPLevel() > 0) DebugSend("OP__ReaskCallbackTCP", buddy); theStats.AddUpDataOverheadFileRequest(response->size); buddy->socket->SendPacket(response); } } break; } case OP_REASKFILEPING: { theStats.AddDownDataOverheadFileRequest(size); CSafeMemFile data_in(packet, size); uchar reqfilehash[16]; data_in.ReadHash16(reqfilehash); CKnownFile* reqfile = theApp.sharedfiles->GetFileByID(reqfilehash); if (!reqfile) { if (thePrefs.GetDebugClientUDPLevel() > 0) { DebugRecv("OP_ReaskFilePing", NULL, reqfilehash, ip); DebugSend("OP__FileNotFound", NULL); } Packet* response = new Packet(OP_FILENOTFOUND,0,OP_EMULEPROT); theStats.AddUpDataOverheadFileRequest(response->size); SendPacket(response, ip, port); break; } CUpDownClient* sender = theApp.uploadqueue->GetWaitingClientByIP_UDP(ip, port); if (sender) { if (thePrefs.GetDebugClientUDPLevel() > 0) DebugRecv("OP_ReaskFilePing", sender, reqfilehash); //Make sure we are still thinking about the same file if (md4cmp(reqfilehash, sender->GetUploadFileID()) == 0) { sender->AddAskedCount(); sender->SetLastUpRequest(); //I messed up when I first added extended info to UDP //I should have originally used the entire ProcessExtenedInfo the first time. //So now I am forced to check UDPVersion to see if we are sending all the extended info. //For now on, we should not have to change anything here if we change //anything to the extended info data as this will be taken care of in ProcessExtendedInfo() //Update extended info. if (sender->GetUDPVersion() > 3) { sender->ProcessExtendedInfo(&data_in, reqfile); } //Update our complete source counts. else if (sender->GetUDPVersion() > 2) { uint16 nCompleteCountLast= sender->GetUpCompleteSourcesCount(); uint16 nCompleteCountNew = data_in.ReadUInt16(); sender->SetUpCompleteSourcesCount(nCompleteCountNew); if (nCompleteCountLast != nCompleteCountNew) { reqfile->UpdatePartsInfo(); } } CSafeMemFile data_out(128); if(sender->GetUDPVersion() > 3) { if (reqfile->IsPartFile()) ((CPartFile*)reqfile)->WritePartStatus(&data_out); else data_out.WriteUInt16(0); } data_out.WriteUInt16(theApp.uploadqueue->GetWaitingPosition(sender)); if (thePrefs.GetDebugClientUDPLevel() > 0) DebugSend("OP__ReaskAck", sender); Packet* response = new Packet(&data_out, OP_EMULEPROT); response->opcode = OP_REASKACK; theStats.AddUpDataOverheadFileRequest(response->size); theApp.clientudp->SendPacket(response, ip, port); } else { DebugLogError(_T("Client UDP socket; ReaskFilePing; reqfile does not match")); TRACE(_T("reqfile: %s\n"), DbgGetFileInfo(reqfile->GetFileHash())); TRACE(_T("sender->GetRequestFile(): %s\n"), sender->GetRequestFile() ? DbgGetFileInfo(sender->GetRequestFile()->GetFileHash()) : _T("(null)")); } } else { if (thePrefs.GetDebugClientUDPLevel() > 0) DebugRecv("OP_ReaskFilePing", NULL, reqfilehash, ip); if (((uint32)theApp.uploadqueue->GetWaitingUserCount() + 50) > thePrefs.GetQueueSize()) { if (thePrefs.GetDebugClientUDPLevel() > 0) DebugSend("OP__QueueFull", NULL); Packet* response = new Packet(OP_QUEUEFULL,0,OP_EMULEPROT); theStats.AddUpDataOverheadFileRequest(response->size); SendPacket(response, ip, port); } } break; } case OP_QUEUEFULL: { theStats.AddDownDataOverheadFileRequest(size); CUpDownClient* sender = theApp.downloadqueue->GetDownloadClientByIP_UDP(ip, port); if (thePrefs.GetDebugClientUDPLevel() > 0) DebugRecv("OP_QueueFull", sender, NULL, ip); if (sender){ sender->SetRemoteQueueFull(true); sender->UDPReaskACK(0); } break; } case OP_REASKACK: { theStats.AddDownDataOverheadFileRequest(size); CUpDownClient* sender = theApp.downloadqueue->GetDownloadClientByIP_UDP(ip, port); if (thePrefs.GetDebugClientUDPLevel() > 0) DebugRecv("OP_ReaskAck", sender, NULL, ip); if (sender){ CSafeMemFile data_in(packet, size); if ( sender->GetUDPVersion() > 3 ) { sender->ProcessFileStatus(true, &data_in, sender->GetRequestFile()); } uint16 nRank = data_in.ReadUInt16(); sender->SetRemoteQueueFull(false); sender->UDPReaskACK(nRank); sender->AddAskedCountDown(); } break; } case OP_FILENOTFOUND: { theStats.AddDownDataOverheadFileRequest(size); CUpDownClient* sender = theApp.downloadqueue->GetDownloadClientByIP_UDP(ip, port); if (thePrefs.GetDebugClientUDPLevel() > 0) DebugRecv("OP_FileNotFound", sender, NULL, ip); if (sender){ sender->UDPReaskFNF(); // may delete 'sender'! sender = NULL; } break; } case OP_PORTTEST: { if (thePrefs.GetDebugClientUDPLevel() > 0) DebugRecv("OP_PortTest", NULL, NULL, ip); theStats.AddDownDataOverheadOther(size); if (size == 1){ if (packet[0] == 0x12){ bool ret = theApp.listensocket->SendPortTestReply('1', true); AddDebugLogLine(true, _T("UDP Portcheck packet arrived - ACK sent back (status=%i)"), ret); } } break; } default: theStats.AddDownDataOverheadOther(size); if (thePrefs.GetDebugClientUDPLevel() > 0) { CUpDownClient* sender = theApp.downloadqueue->GetDownloadClientByIP_UDP(ip, port); Debug(_T("Unknown client UDP packet: host=%s:%u (%s) opcode=0x%02x size=%u\n"), ipstr(ip), port, sender ? sender->DbgGetClientInfo() : _T(""), opcode, size); } return false; } return true; }
void debug_parse(char *cmd_line) { int params; unsigned int temp1,temp2,temp3,temp4; unsigned short tempword; unsigned char tempbyte; while (*cmd_line == ' ') cmd_line++; switch (toupper(*cmd_line++)) { case '?': DebugPrint("\r\n Compile Date: %s, Time: %s",__DATE__,__TIME__); break; case 'A': // assemble break; case 'B': break; case 'C': // compare break; case 'D': // dump params = sscanf(cmd_line,"%X %X",&temp2,&temp3); switch (params) { case 0: case EOF: dump_end = dump_beg + 127; do_dump(); break; case 1: dump_beg = temp2; dump_end = dump_beg + 127; do_dump(); break; case 2: if (temp3<temp2) temp3=temp2; dump_beg = temp2; dump_end = temp3; do_dump(); break; } break; case 'E': // read unsigned int if (sscanf(cmd_line,"%X",&temp1)==1) debug_port = (unsigned char*)(temp1&0xFFFFFFFC); temp2 = *(unsigned int*)debug_port; DebugPrint("\r\n %08X -> %08X",(int)debug_port,temp2); // debug_port += sizeof(int); break; case 'F': // fill params = sscanf(cmd_line,"%X %X %X",&temp2,&temp3,&temp4); switch (params) { case 3: dump_end = temp3; for (old_dump_beg=temp2;old_dump_beg<=dump_end;old_dump_beg++) { // pokeb(dump_seg,old_dump_beg,temp4); } break; default: { DebugSend(" ?? \r\n"); } break; } break; case 'G': // go DebugInit(); break; case 'H': // hex break; case 'I': // read byte if (sscanf(cmd_line,"%X",&temp1)==1) { debug_port = (unsigned char*)temp1; tempbyte = *(unsigned char*)debug_port; DebugPrint("\r\n %08X -> %02X",(int)debug_port,tempbyte); debug_port += sizeof(tempbyte); } break; case 'J': // read word if (sscanf(cmd_line,"%X",&temp1)==1) { debug_port = (unsigned char*)(temp1&0xFFFFFFFE); } tempword = *(unsigned short*)debug_port; DebugPrint("\r\n %08X -> %04X",(int)debug_port,tempword); break; case 'K': break; case 'L': // load break; case 'M': // write unsigned int if (sscanf(cmd_line,"%X %X",&temp1,&temp2)==2) { debug_port = (unsigned char*)(temp1&0xFFFFFFFC); DebugPrint("\r\n %08X <- %08X",(int)debug_port,temp2); *(unsigned int*)debug_port = temp2; debug_port += sizeof(int); } else { DebugSend(" ?? \r\n"); } break; case 'N': // name break; case 'O': // output byte if (sscanf(cmd_line,"%X %X",&temp1,&temp2)==2) { debug_port = (unsigned char*)temp1; tempbyte = temp2; DebugPrint("\r\n %08X <- %02X",(int)debug_port,tempbyte); *debug_port = tempbyte; debug_port += sizeof(tempbyte); } else { DebugSend(" ?? \r\n"); } break; case 'P': // proceed if (sscanf(cmd_line,"%X",&temp1)==1) { switch (temp1){ case 0: break; case 1: break; case 2: break; case 3: break; case 4: break; case 5: break; case 6: break; case 7: break; case 8: break; case 9: break; } } else { } break; case 'Q': // quit DebugSend("\r\nYou can't quit now!"); break; case 'R': // register break; case 'S': // search if (sscanf(cmd_line,"%X",&temp2)==1) { } break; case 'T': // Test if (sscanf(cmd_line,"%X",&temp1)==1) { switch (temp1){ case 0: break; case 1: break; case 2: break; case 3: break; case 4: break; case 5: break; case 6: break; case 7: break; case 8: break; case 9: break; } } else { bTest = !bTest; if (bTest) { ResetTimer(BLINK_TIMER); StartTimer(BLINK_TIMER, 500); DebugSend("\r\n LED Blink Started."); } else { DebugSend("\r\n LED Blink Stopped."); } } break; case 'U': if (sscanf(cmd_line,"%X",&temp1)==1) { switch (temp1){ case 0: break; case 1: break; case 2: break; case 3: break; case 4: break; case 5: //U5 break; case 6: //U6 break; case 7: //U7 break; case 8: break; case 9: break; } } else { } break; case 'W': // write word if (sscanf(cmd_line,"%X %X",&temp1,&temp2)==2) { debug_port = (unsigned char*)(temp1&0xFFFFFFFE); tempword = temp2; DebugPrint("\r\n %08X <- %04X",(int)debug_port,tempword); *(unsigned short*)debug_port = tempword; debug_port += sizeof(tempword); } else { DebugSend(" ?? \r\n"); } break; case 'X': if (sscanf(cmd_line,"%X",&temp1)==1) { switch (temp1){ case 0: break; case 1: break; case 2: break; case 3: break; case 4: break; case 5: break; case 6: break; case 7: break; case 8: break; case 9: break; } } else { } break; case 'Y': temp4 = sscanf(cmd_line,"%X %X",&temp1,&temp2); if (temp4>=1) { switch (temp1){ case 0: break; case 1: break; case 2: break; case 3: break; case 4: break; case 5: break; case 6: break; case 7: break; case 8: break; case 9: break; } } else { } break; case 'Z': if (sscanf(cmd_line,"%i %i",&temp1,&temp2)==2) { } else if (sscanf(cmd_line,"%X",&temp1)==1) { switch (temp1){ case 0: break; case 1: break; case 2: break; case 3: break; case 4: break; case 5: break; case 6: break; case 7: break; case 8: break; case 9: break; } } else { } break; default: ; } }