listensocket.cpp

非常出名开源客户端下载的程序emule

					break;
				}
				case OP_CANCELTRANSFER:{
					theApp.downloadqueue->AddDownDataOverheadFileRequest(size);
					theApp.uploadqueue->RemoveFromUploadQueue(client);
					theApp.emuledlg->AddDebugLogLine(false, "%s: Upload session ended due cancled transfer.", client->GetUserName());
					client->SetUploadFileID(NULL);
					break;
				}
				case OP_HASHSETREQUEST:{
					theApp.downloadqueue->AddDownDataOverheadFileRequest(size);
					if (size != 16)
						throw GetResString(IDS_ERR_WRONGHPACKAGESIZE);
					client->SendHashsetPacket(packet);
					break;
				}
				case OP_HASHSETANSWER:{
					theApp.downloadqueue->AddDownDataOverheadFileRequest(size);
                   if (client->GetDownloadState() != DS_REQHASHSET)
                        throw CString("unwanted hashset");
					client->ProcessHashSet(packet,size);
					break;
				}
				case OP_SENDINGPART:{
//					theApp.downloadqueue->AddDownDataOverheadOther(0, 24);
					client->ProcessBlockPacket(packet,size);
					break;
				}
				case OP_OUTOFPARTREQS:{
					theApp.downloadqueue->AddDownDataOverheadFileRequest(size);
					if (client->GetDownloadState() == DS_DOWNLOADING)
						client->SetDownloadState(DS_ONQUEUE);
					break;
				}
				case OP_SETREQFILEID:{
					theApp.downloadqueue->AddDownDataOverheadFileRequest(size);
				// DbT:FileRequest
				if (size == 16){
					if (!client->GetWaitStartTime())
						client->SetWaitStartTime();

					CKnownFile* reqfile = theApp.sharedfiles->GetFileByID((uchar*)packet);

					if (!reqfile){
						// send file request no such file packet (0x48)
						Packet* replypacket = new Packet(OP_FILEREQANSNOFIL, 16);
						memcpy(replypacket->pBuffer, packet, 16);
						theApp.uploadqueue->AddUpDataOverheadFileRequest(replypacket->size);
						SendPacket(replypacket, true);
						break;
					}

					// if we are downloading this file, this could be a new source
					if (reqfile->IsPartFile())
						if( theApp.glob_prefs->GetMaxSourcePerFile() > ((CPartFile*)reqfile)->GetSourceCount() )
							theApp.downloadqueue->CheckAndAddKnownSource((CPartFile*)reqfile,client);
				            
					// check to see if this is a new file they are asking for
					if(memcmp(client->GetUploadFileID(), packet, 16) != 0)
						client->SetCommentDirty();

//					CKnownFile* clientreqfile = theApp.sharedfiles->GetFileByID(client->GetUploadFileID());
//					if( clientreqfile )
//						clientreqfile->SubQueuedCount();
//					reqfile->AddQueuedCount();

					//send filestatus
					client->SetUploadFileID((uchar*)packet);
//					memcpy(client->reqfileid,packet,16);
					CMemFile* data = new CMemFile();
					data->Write(reqfile->GetFileHash(),16);
					if (reqfile->IsPartFile())
						((CPartFile*)reqfile)->WritePartStatus(data);
					else {
						uint32 null = 0;
						data->Write(&null,3);
					}
					Packet* packet = new Packet(data);
					packet->opcode = OP_FILESTATUS;
					delete data;
					theApp.uploadqueue->AddUpDataOverheadFileRequest(packet->size);
					SendPacket(packet,true);
					break;
				}
				throw GetResString(IDS_ERR_WRONGPACKAGESIZE);
				break;
				// DbT:End
				}
				case OP_MESSAGE:{
					theApp.downloadqueue->AddDownDataOverheadOther(size);
					uint16 length;
					memcpy(&length,packet,2);
					if (length+2 != size)
						throw CString("invalid message packet");
					char* message = new char[length+1];
					memcpy(message,packet+2,length);
					message[length] = 0;
					theApp.emuledlg->chatwnd.chatselector.ProcessMessage(client,message);
					delete[] message;
					break;
				}
				case OP_ASKSHAREDFILES:	{	// client wants to know what we have in share, let's see if we allow him to know that
					theApp.downloadqueue->AddDownDataOverheadOther(size);
					CPtrList list;
					if (theApp.glob_prefs->CanSeeShares() == 0 ||					// everybody
						(theApp.glob_prefs->CanSeeShares() == 1 && client->IsFriend() ) )	// friend
					{
						CCKey bufKey;
						CKnownFile* cur_file;
						for (POSITION pos = theApp.sharedfiles->m_Files_map.GetStartPosition();pos != 0;){
							theApp.sharedfiles->m_Files_map.GetNextAssoc(pos,bufKey,cur_file);
							list.AddTail((void*&)cur_file);
						}
						theApp.emuledlg->AddLogLine(true,GetResString(IDS_REQ_SHAREDFILES),client->GetUserName(),client->GetUserID(),GetResString(IDS_ACCEPTED) );
					} else theApp.emuledlg->AddLogLine(true,GetResString(IDS_REQ_SHAREDFILES),client->GetUserName(),client->GetUserID(),GetResString(IDS_DENIED) );

					// now create the memfile for the packet
					uint32 iTotalCount = list.GetCount();
					CSafeMemFile tempfile(80);
					tempfile.Write(&iTotalCount, 4);
					while (list.GetCount())
					{
						theApp.sharedfiles->CreateOfferedFilePacket((CKnownFile*)list.GetHead(), &tempfile);
						list.RemoveHead();
					}
					// create a packet and send it
					Packet* replypacket = new Packet(&tempfile);
					replypacket->opcode = OP_ASKSHAREDFILESANSWER;
					theApp.uploadqueue->AddUpDataOverheadOther(replypacket->size);
					SendPacket(replypacket, true, true);
					break;
				}
				case OP_ASKSHAREDFILESANSWER:{
					theApp.downloadqueue->AddDownDataOverheadOther(size);
					client->ProcessSharedFileList(packet,size);
					break;
				}
                case OP_ASKSHAREDDIRS:{
                    theApp.downloadqueue->AddDownDataOverheadOther(size);
                    ASSERT( size == 0 );
                    if (theApp.glob_prefs->CanSeeShares()==0 || (theApp.glob_prefs->CanSeeShares()==1 && client->IsFriend())){
                        theApp.emuledlg->AddLogLine(true,"User %s (%u) requested your shareddirectories-list -> %s",client->GetUserName(),client->GetUserID(),GetResString(IDS_ACCEPTED) );
 
                        CSafeMemFile tempfile(80);
                        uint32 uDirs = theApp.glob_prefs->shareddir_list.GetCount() + theApp.glob_prefs->GetCatCount();
                        tempfile.Write(&uDirs, 4);
						
						CString strDir;
						uint16 cnt;
                        POSITION pos = theApp.glob_prefs->shareddir_list.GetHeadPosition();
                        while (pos){
                            strDir = theApp.glob_prefs->shareddir_list.GetNext(pos);
                            PathRemoveBackslash(strDir.GetBuffer());
                            strDir.ReleaseBuffer();
                            uint16 cnt = strDir.GetLength();
                            tempfile.Write(&cnt, 2);
                            tempfile.Write((LPCTSTR)strDir, cnt);
                        }
						// and the incoming folders
                       	for (int ix=0;ix<theApp.glob_prefs->GetCatCount();ix++) {
							strDir=CString(theApp.glob_prefs->GetCategory(ix)->incomingpath);
							cnt = strDir.GetLength();
							tempfile.Write(&cnt, 2);
							tempfile.Write((LPCTSTR)strDir, cnt);
						} 
                        Packet* replypacket = new Packet(&tempfile);
                        replypacket->opcode = OP_ASKSHAREDDIRSANS;
                        theApp.uploadqueue->AddUpDataOverheadOther(replypacket->size);
                        SendPacket(replypacket, true, true);
					}
					else{
                        theApp.emuledlg->AddLogLine(true,"User %s (%u) requested your shareddirectories-list -> %s",client->GetUserName(),client->GetUserID(),GetResString(IDS_DENIED) );
                        Packet* replypacket = new Packet(OP_ASKSHAREDDENIEDANS, 0);
						theApp.uploadqueue->AddUpDataOverheadOther(replypacket->size);
                        SendPacket(replypacket, true, true);
                    }
                    break;
                }
                case OP_ASKSHAREDFILESDIR:{
                    theApp.downloadqueue->AddDownDataOverheadOther(size);
                    CSafeMemFile data((uchar*)packet, size, 0);
                    uint16 cnt;
                    data.Read(&cnt, 2);
                    CString strReqDir;
                    data.Read(strReqDir.GetBuffer(cnt), cnt);
                   strReqDir.ReleaseBuffer(cnt);
                    PathRemoveBackslash(strReqDir.GetBuffer());
                    strReqDir.ReleaseBuffer();
 
                    if (theApp.glob_prefs->CanSeeShares()==0 || (theApp.glob_prefs->CanSeeShares()==1 && client->IsFriend())){
                        theApp.emuledlg->AddLogLine(true,"User %s (%u) requested your sharedfiles-list for directory %s -> %s",client->GetUserName(),client->GetUserID(),strReqDir,GetResString(IDS_ACCEPTED) );
                        ASSERT( data.GetPosition() == data.GetLength() );
 
                        CTypedPtrList<CPtrList, CKnownFile*> list;
                        for (POSITION pos = theApp.sharedfiles->m_Files_map.GetStartPosition();pos != 0;){
                            CCKey bufKey;
                            CKnownFile* cur_file;
                            theApp.sharedfiles->m_Files_map.GetNextAssoc(pos, bufKey, cur_file);
                            CString strSharedFile(cur_file->GetPath());
                            PathRemoveFileSpec(strSharedFile.GetBuffer());
                            strSharedFile.ReleaseBuffer();
                            if (strReqDir.CompareNoCase(strSharedFile) == 0)
                                list.AddTail(cur_file);
                        }
 
                        if (list.GetCount()){
                            CSafeMemFile tempfile(80);
                            uint16 cnt = strReqDir.GetLength();
                            tempfile.Write(&cnt, 2);
                            tempfile.Write((LPCTSTR)strReqDir, cnt);
                            uint32 uFiles = list.GetCount();
                            tempfile.Write(&uFiles, 4);
                            while (list.GetCount()){
                                theApp.sharedfiles->CreateOfferedFilePacket(list.GetHead(), &tempfile);
                                list.RemoveHead();
                            }
 
                            Packet* replypacket = new Packet(&tempfile);
                            replypacket->opcode = OP_ASKSHAREDFILESDIRANS;
                            theApp.uploadqueue->AddUpDataOverheadOther(replypacket->size);
                            SendPacket(replypacket, true, true);
                        }
                    }
                    else{
                        theApp.emuledlg->AddLogLine(true,"User %s (%u) requested your sharedfiles-list for directory %s -> %s",client->GetUserName(),client->GetUserID(),strReqDir,GetResString(IDS_DENIED) );
                        Packet* replypacket = new Packet(OP_ASKSHAREDDENIEDANS, 0);
                        theApp.uploadqueue->AddUpDataOverheadOther(replypacket->size);
                        SendPacket(replypacket, true, true);
                    }
                    break;
                }
                case OP_ASKSHAREDDIRSANS:{
                    theApp.downloadqueue->AddDownDataOverheadOther(size);
                    if (client->GetFileListRequested() == 1){
                        CSafeMemFile data((uchar*)packet, size, 0);
                        uint32 uDirs;
                        data.Read(&uDirs, 4);
                        for (UINT i = 0; i < uDirs; i++){
                            uint16 cnt;
                            data.Read(&cnt, 2);
                            CString strDir;
                            data.Read(strDir.GetBuffer(cnt), cnt);
                            strDir.ReleaseBuffer(cnt);
                            theApp.emuledlg->AddLogLine(true,"User %s (%u) shares directory %s",client->GetUserName(),client->GetUserID(),strDir);

                            CSafeMemFile tempfile(80);
                            cnt = strDir.GetLength();
                            tempfile.Write(&cnt, 2);
                            tempfile.Write((LPCTSTR)strDir, cnt);
                            Packet* replypacket = new Packet(&tempfile);
                            replypacket->opcode = OP_ASKSHAREDFILESDIR;
                            theApp.uploadqueue->AddUpDataOverheadOther(replypacket->size);
                            SendPacket(replypacket, true, true);
                        }
                        ASSERT( data.GetPosition() == data.GetLength() );
                        client->SetFileListRequested(uDirs);
                    }
                    break;
                }
                case OP_ASKSHAREDFILESDIRANS:{
                    theApp.downloadqueue->AddDownDataOverheadOther(size);
                    if (client->GetFileListRequested() > 0){
                        CSafeMemFile data((uchar*)packet, size, 0);
                        uint16 cnt;
                        data.Read(&cnt, 2);
                        CString strDir;
                        data.Read(strDir.GetBuffer(cnt), cnt);
                        strDir.ReleaseBuffer(cnt);
                        theApp.emuledlg->AddLogLine(true,"User %s (%u) sent sharedfiles-list for directory %s",client->GetUserName(),client->GetUserID(),strDir);
                        client->ProcessSharedFileList(packet + data.GetPosition(), size - data.GetPosition());
                    }
                    break;
                }
                case OP_ASKSHAREDDENIEDANS:{
                    theApp.downloadqueue->AddDownDataOverheadOther(size);
                    ASSERT( size == 0 );
                    theApp.emuledlg->AddLogLine(true,"User %s (%u) denied access to shareddirectories/files-list",client->GetUserName(),client->GetUserID());
                    break;
                }

				default:
					theApp.downloadqueue->AddDownDataOverheadOther(size);
					theApp.emuledlg->AddDebugLogLine(false,"unknown opcode: %i %x",opcode,opcode);
				  
			}
		}
		catch(CFileException* error){
			OUTPUT_DEBUG_TRACE();
			error->Delete();	//mf
			throw GetResString(IDS_ERR_INVALIDPACKAGE);
		}
	}
	catch(CString error){
		OUTPUT_DEBUG_TRACE();
		if (client){
			client->SetDownloadState(DS_ERROR);	
			//TODO write this into a debugfile
			theApp.emuledlg->AddDebugLogLine(false,GetResString(IDS_ERR_CLIENTERROR)
			,client->GetUserName(),client->GetFullIP(),error.GetBuffer());
		}
		else
			theApp.emuledlg->AddDebugLogLine(false,GetResString(IDS_ERR_BADCLIENTACTION),error.GetBuffer());
			
		Disconnect();
		return false;
	}
	return true;
}

bool CClientReqSocket::ProcessExtPacket(char* packet, uint32 size, uint8 opcode){
	try{
		if (!client)
			throw GetResString(IDS_ERR_UNKNOWNCLIENTACTION);
		switch(opcode){
			case OP_EMULEINFO:{
				theApp.downloadqueue->AddDownDataOverheadOther(size);
				client->ProcessMuleInfoPacket(packet,size);
				client->SendMuleInfoPacket(true);
				break;
			}
			case OP_EMULEINFOANSWER:{
				theApp.downloadqueue->AddDownDataOverheadOther(size);
				client->ProcessMuleInfoPacket(packet,size);
				break;
			}
			case OP_COMPRESSEDPART:{
//				theApp.downloadqueue->AddDownDataOverheadOther(24);
				client->ProcessBlockPacket(packet,size,true);
				break;
			}