public CServerHello(MemoryStream buffer)
{
DonkeyHeader header;
BinaryWriter writer=new BinaryWriter(buffer);
header=new DonkeyHeader((byte)Protocol.ServerCommand.LoginRequest,writer);
writer.Write(CKernel.Preferences.GetByteArray("UserHash"));
writer.Write(CKernel.Preferences.GetUInt("ID"));
writer.Write(CKernel.Preferences.GetUShort("TCPPort"));
uint nParameters=5;
writer.Write(nParameters);
// user
new ParameterWriter((byte)Protocol.ClientParameter.Name,CKernel.Preferences.GetString("UserName"),writer);
// version
new ParameterWriter((byte)Protocol.ClientParameter.Version,Protocol.EDONKEYVERSION,writer);
// port
new ParameterWriter((byte)Protocol.ClientParameter.Port,(uint)CKernel.Preferences.GetUShort("TCPPort"),writer);
// compression
new ParameterWriter((byte)Protocol.ClientParameter.Compression,5,writer); //1 (supports compression) + 5 (supports alternative server ports)
// emule version
new ParameterWriter((byte)Protocol.ClientParameter.EmuleVersion,Protocol.EMULE_VERSION_COMPLEX,writer);
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CMuleHello(MemoryStream buffer,bool isResponse)
{
BinaryWriter writer=new BinaryWriter(buffer);
DonkeyHeader header;
if (isResponse)
header=new DonkeyHeader((byte)Protocol.ClientCommandExt.eMuleInfoAnswer,writer,Protocol.ProtocolType.eMule);
else
header=new DonkeyHeader((byte)Protocol.ClientCommandExt.eMuleInfo,writer,Protocol.ProtocolType.eMule);
writer.Write(Protocol.EMULE_VERSION);
writer.Write(Protocol.EMULE_PROTOCOL_VERSION);
uint nParameters=8;
writer.Write(nParameters);
// compression
new ParameterWriter(Protocol.ET_COMPRESSION,Protocol.EMULE_VERSION_COMPRESION,writer);
// udp port
new ParameterWriter(Protocol.ET_UDPPORT,(uint)CKernel.Preferences.GetUShort("UDPPort"),writer);
// version udp
new ParameterWriter(Protocol.ET_UDPVER,(uint)Protocol.EMULE_VERSION_UDP,writer);
// version source exchange
new ParameterWriter(Protocol.ET_SOURCEEXCHANGE,(uint)Protocol.EMULE_VERSION_SOURCEEXCHANGE,writer);
// version comments
new ParameterWriter(Protocol.ET_COMMENTS,(uint)Protocol.EMULE_VERSION_COMMENTS,writer);
// version extended requests
new ParameterWriter(Protocol.ET_EXTENDEDREQUEST,(uint)Protocol.EMULE_VERSION_EXTENDEDREQUEST,writer);
// client compatible
new ParameterWriter(Protocol.ET_COMPATIBLECLIENT,(byte)Protocol.Client.eLePhant,writer);
// version lphant
new ParameterWriter(Protocol.ET_ELEPHANTVERSION,Protocol.ELEPHANT_VERSION,writer);
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CServerAskSources(byte[] FileHash,MemoryStream buffer)
{
DonkeyHeader header;
BinaryWriter writer=new BinaryWriter(buffer);
writer.Seek(0,SeekOrigin.End);
header=new DonkeyHeader((byte)Protocol.ServerCommand.GetSources/*,writer*/);
header.Packetlength=17;
header.Serialize(writer);
writer.Write(FileHash);
// header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
// writer.Seek(0,SeekOrigin.Begin);
// header.Serialize(writer);
}
public CServerRequestCallback(uint ID,MemoryStream buffer)
{
DonkeyHeader header;
BinaryWriter writer=new BinaryWriter(buffer);
header=new DonkeyHeader((byte)Protocol.ServerCommand.CallBackRequest,writer);
writer.Write(ID);
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CFileInfo(byte[] in_FileHash,string ClientFileName,MemoryStream buffer)
{
BinaryWriter writer=new BinaryWriter(buffer);
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ClientCommand.FileRequestAnswer,writer);
writer.Write(in_FileHash,0,16);
writer.Write((ushort)ClientFileName.ToCharArray().Length);
writer.Write(ClientFileName.ToCharArray());
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CFileStatus(byte[] in_FileHash,byte[] in_Partes,MemoryStream buffer)
{
BinaryWriter writer=new BinaryWriter(buffer);
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ClientCommand.FileState,writer);
writer.Write(in_FileHash,0,16);
WriteFileStatus(writer,in_Partes);
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CSharedFiles(MemoryStream buffer,CFilesList fileList)
{
BinaryWriter writer=new BinaryWriter(buffer);
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ClientCommand.AskSharedFilesAnswer,writer);
writer.Write((uint)fileList.Count);
lock(fileList)
{
foreach (CElement Elemento in fileList.Values)
{
writer.Write(Elemento.File.FileHash);
writer.Write((uint)0);
writer.Write((ushort)0);
writer.Write(Elemento.File.FileType);
// file name
new ParameterWriter((byte)Protocol.FileTag.Name,Elemento.File.FileName,writer);
// file size
new ParameterWriter((byte)Protocol.FileTag.Size,Elemento.File.FileSize,writer);
}
}
header.Packetlength = (uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CCrumbSetResponse(MemoryStream buffer,CFile File)
{
BinaryWriter writer=new BinaryWriter(buffer);
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ClientCommand.HashSetAnswer,writer);
writer.Write(File.FileHash);
writer.Write((byte)1);
foreach (byte[] PartialHash in File.HashSet)
{
writer.Write(PartialHash);
}
writer.Write((byte)1);
foreach (byte[] CrumbHash in File.CrumbsHashSet)
{
writer.Write(CrumbHash);
}
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CSendBlock(MemoryStream data,uint start,uint end,byte[] FileHash,ref ArrayList UploadDataPackets)
{
MemoryStream buffer;
uint size;
BinaryReader reader=new BinaryReader(data);
BinaryWriter writer;
//byte[] aux_buffer;
while (start!=end)
{
buffer=new MemoryStream();
writer=new BinaryWriter(buffer);
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ClientCommand.SendingPart,writer);
writer.Write(FileHash);
if (end-start>10240) size=10240;
else size=end-start;
writer.Write(start);
writer.Write(start+size);
//aux_buffer=reader.ReadBytes((int)size);
//writer.Write(aux_buffer);
writer.Write(reader.ReadBytes((int)size));
start+=size;
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
UploadDataPackets.Add(buffer);
writer=null;
buffer=null;
}
reader.Close();
data.Close();
data=null;
reader=null;
}
//private byte opcode;
public CSendHello(bool response,MemoryStream buffer,CServer server, bool sendCompatOptions, bool allowPartner)
{
DonkeyHeader header;
BinaryWriter writer=new BinaryWriter(buffer);
if (response)
header=new DonkeyHeader((byte)Protocol.ClientCommand.HelloAnswer,writer);
else
{
header=new DonkeyHeader((byte)Protocol.ClientCommand.Hello,writer);
writer.Write((byte)CKernel.Preferences.GetByteArray("UserHash").Length);
}
writer.Write(CKernel.Preferences.GetByteArray("UserHash"));
writer.Write(CKernel.Preferences.GetUInt("ID"));
writer.Write(CKernel.Preferences.GetUShort("TCPPort"));
uint nParametros=5;
if (sendCompatOptions) nParametros++;
writer.Write(nParametros);
// username
new ParameterWriter((byte)Protocol.ClientParameter.Name,CKernel.Preferences.GetString("UserName"),writer);
// version
new ParameterWriter((byte)Protocol.ClientParameter.Version,Protocol.EDONKEYVERSION,writer);
//ParameterNumericNumeric port=new ParameterWriter((byte)Protocol.ClientParameter.Port,(uint)CKernel.Preferences.GetUShort("TCPPort"),writer);
// emule version
new ParameterWriter((byte)Protocol.ClientParameter.EmuleVersion,Protocol.EMULE_VERSION_COMPLEX,writer);
// upd port
new ParameterWriter((byte)Protocol.ClientParameter.EmuleUDPPort,(uint)CKernel.Preferences.GetUShort("UDPPort"),writer);
// emule flags
new ParameterWriter((byte)Protocol.ClientParameter.Emule_MiscOptions1,
// ( << 4*7) |
(Protocol.EMULE_VERSION_UDP << 4*6) |
(Protocol.EMULE_VERSION_COMPRESION << 4*5) |
(0 /*secureID */ << 4*4) |
(Protocol.EMULE_VERSION_SOURCEEXCHANGE << 4*3) |
(Protocol.EMULE_VERSION_EXTENDEDREQUEST << 4*2) |
(Protocol.EMULE_VERSION_COMMENTS << 4*1) |
// ( << 1*3) |
((((Types.Constants.AllowViewShared)CKernel.Preferences.GetEnum("AllowViewShared",Types.Constants.AllowViewShared.Nobody)==Types.Constants.AllowViewShared.Nobody) ? (uint)1 : (uint)0 )<< 1*2) |
(0 /*uMultiPacket*/ << 1*1) |
(0 /*uSupportPreview*/ << 1*0)
,writer);
uint compatValue=1;
if (sendCompatOptions)
{
if (allowPartner) compatValue=3;
//CLog.Log(Types.Constants.Log.Verbose,"Sent partner flag "+compatValue.ToString());
new ParameterWriter((byte)Protocol.ClientParameter.EmuleCompatOptions,compatValue,writer);
}
if (server==null)
{
writer.Write((uint)0);
writer.Write((ushort)0);
}
else
{
writer.Write(server.IP);
writer.Write(server.MainPort);
}
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CRequestSourceExchange(MemoryStream buffer,byte[] FileHash)
{
BinaryWriter writer = new BinaryWriter(buffer);
DonkeyHeader header = new DonkeyHeader((byte)Protocol.ClientCommandExt.SourcesRequest,Protocol.ProtocolType.eMule);
header.Packetlength=17;
header.Serialize(writer);
writer.Write(FileHash);
// header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
// writer.Seek(0,SeekOrigin.Begin);
// header.Serialize(writer);
}
public CNoFile(MemoryStream buffer,byte[] FileHash)
{
BinaryWriter writer=new BinaryWriter(buffer);
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ClientCommand.FileRequestAnswerNoFile,writer);
writer.Write(FileHash);
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CMuleQR(MemoryStream buffer,ushort QR)
{
BinaryWriter writer=new BinaryWriter(buffer);
DonkeyHeader header;
header=new DonkeyHeader((byte)Protocol.ClientCommandExt.QueueRanking,writer,Protocol.ProtocolType.eMule);
writer.Write(QR);
byte[] empty=new byte[10];
writer.Write(empty);
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CCompressedPacket(ref MemoryStream packet)
{
byte[] compressedBuffer=null;
BinaryReader reader=new BinaryReader(packet);
MemoryStream compressedPacket=new MemoryStream();
packet.Seek(0,SeekOrigin.Begin);
BinaryWriter writer=new BinaryWriter(compressedPacket);
writer.Write(reader.ReadBytes(5));
byte opcode=reader.ReadByte();
writer.Write(opcode);
byte[] uncompressedBuffer=reader.ReadBytes((int)packet.Length-6);
int compressedsize=CCompressedBlockSend.ComprimirBuffer(uncompressedBuffer,ref compressedBuffer);
if (compressedsize+6>=packet.Length)
return;
writer.Write(compressedBuffer);
compressedPacket.Seek(0,SeekOrigin.Begin);
DonkeyHeader header=new DonkeyHeader(opcode,writer,Protocol.ProtocolType.Packet);
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
packet.Close();
packet=compressedPacket;
}
public CSourceExchangeResponse(MemoryStream buffer,byte[] FileHash,uint RequesterID,ushort RequesterPort, int version)
{
//Hashtable IPList=new Hashtable();
ArrayList clientsList=new ArrayList();
BinaryWriter writer=new BinaryWriter(buffer);
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ClientCommandExt.SourcesResult,writer,Protocol.ProtocolType.eMule);
CElement Element=(CElement)CKernel.FilesList[FileHash];
nSources=0;
writer.Write(FileHash);
writer.Write(nSources);
uint myID=CKernel.Preferences.GetUInt("ID");
if ((Element!=null)&&(Element.SourcesList!=null))
{
lock(Element.SourcesList.SyncRoot())
{
foreach (CClient Client in Element.SourcesList)
{
if ((Client.DownloadState != Protocol.DownloadState.None)&&
(Client.UserID>Protocol.LowIDLimit)&&
(Client.UserHash!=null)&&
(Client.UserID!=RequesterID)&&
(Client.UserID!=myID))
{
//IPList[((ulong)Client.UserID << 16) + Client.Port]=((ulong)Client.ServerIP<<16) + Client.ServerPort;
clientsList.Add(Client);
nSources++;
}
if (nSources>=200) break;
}
}
if (nSources<200)
{
int i=0;
CClient QueueClient;
while (i<CKernel.Queue.Count)
{
QueueClient=(CClient)CKernel.Queue[i];
if ((QueueClient.UploadElement==Element)&&
(QueueClient.UserID > Protocol.LowIDLimit)&&
(QueueClient.DownloadState==Protocol.DownloadState.OnQueue)&&
(QueueClient.UserHash!=null)&&
(QueueClient.UserID!=RequesterID)&&
(QueueClient.UserID!=myID))
{
//IPList[((ulong)QueueClient.UserID<<16)+QueueClient.Port]=((ulong)QueueClient.ServerIP<<16)+QueueClient.ServerPort;
if (!clientsList.Contains(QueueClient)) clientsList.Add(QueueClient);
nSources++;
}
if (nSources>=200) break;
i++;
}
}
}
/* //do not send oursef
IPList.Remove(((ulong)CKernel.Preferences.GetUInt("ID")<<16)+CKernel.Preferences.GetUShort("TCPPort"));
//do not send himself
IPList.Remove(((ulong)RequesterID<<16)+RequesterPort);
foreach (ulong ipPort in IPList.Keys)
{
uint IP=(uint)(ipPort>>16);
ushort Port=(ushort)(ipPort&0x00000000FFFF);
//ushort Port=(ushort)(ipPort-((ulong)IP<<16));
ulong ipServerPort=(ulong)IPList[ipPort];
uint ServerIP=(uint)(ipServerPort>>16);
ushort ServerPort=(ushort)(ipServerPort&0x00000000FFFF);
writer.Write(IP);
writer.Write(Port);
writer.Write(ServerIP);
writer.Write(ServerPort);
}
*/
foreach (CClient client in clientsList)
{
writer.Write(client.UserID);
writer.Write(client.Port);
writer.Write(client.ServerIP);
writer.Write(client.ServerPort);
if (version>1)
writer.Write(client.UserHash);
}
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
writer.Seek(16,SeekOrigin.Current);
writer.Write((ushort)clientsList.Count);
}
public CCrumbSetRequest(byte[] Hash,MemoryStream buffer)
{
BinaryWriter writer=new BinaryWriter(buffer);
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ClientCommand.CrumbSetRequest,writer);
writer.Write(Hash,0,16);
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CStartDownload(MemoryStream buffer, byte[] in_FileHash)
{
BinaryWriter writer=new BinaryWriter(buffer);
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ClientCommand.StartUploadRequest,writer);
if (in_FileHash!=null) writer.Write(in_FileHash,0,16);
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CFileBlockRequest(MemoryStream buffer,byte[] FileHash,ref CFileBlock block1,ref CFileBlock block2,ref CFileBlock block3)
{
BinaryWriter writer=new BinaryWriter(buffer);
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ClientCommand.RequestParts,writer);
writer.Write(FileHash);
writer.Write(block1.start);
writer.Write(block2.start);
writer.Write(block3.start);
writer.Write(block1.end+1);
writer.Write(block2.end+1);
writer.Write(block3.end+1);
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CStartUpload(MemoryStream buffer)
{
BinaryWriter writer=new BinaryWriter(buffer);
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ClientCommand.AcceptUploadRequest,writer);
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CFileRequest(byte[] Hash,byte[] Partes,MemoryStream buffer)
{
uint startpos=(uint)buffer.Position;
BinaryWriter writer=new BinaryWriter(buffer);
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ClientCommand.FileRequest,writer);
writer.Write(Hash,0,16);
WriteFileStatus(Partes,writer);
header.Packetlength=(uint)buffer.Position-startpos-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CCancelTransfer(MemoryStream buffer)
{
BinaryWriter writer=new BinaryWriter(buffer);
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ClientCommand.CancelTransfer,writer);
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
//constructor to publish one file
public CServerPublishFiles(MemoryStream buffer,CElement element)
{
DonkeyHeader header;
BinaryWriter writer=new BinaryWriter(buffer);
header=new DonkeyHeader((byte)Protocol.ServerCommand.OfferFiles,writer);
writer.Write(1);
m_AddFileToPacket(writer,element);
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
writer.Write(1);
CLog.Log(Types.Constants.Log.Info,"FIL_PUBLISHED",1);
}
public CClientMessage(MemoryStream buffer,string message)
{
BinaryWriter writer=new BinaryWriter(buffer);
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ClientCommand.Message,writer,Protocol.ProtocolType.eDonkey);
if (message.Length>128) Message=message.Substring(0,128);
byte[] byteStringValue=Encoding.Default.GetBytes(message);
writer.Write((ushort)byteStringValue.Length);
writer.Write(byteStringValue);
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CServerQueryMoreResults(MemoryStream buffer)
{
DonkeyHeader header;
BinaryWriter writer=new BinaryWriter(buffer);
header=new DonkeyHeader((byte)Protocol.ServerCommand.QueryMoreResults,writer);
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CComment(MemoryStream buffer,byte rating,string comment)
{
BinaryWriter writer=new BinaryWriter(buffer);
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ClientCommandExt.FileDescription,writer,Protocol.ProtocolType.eMule);
writer.Write(rating);
if (comment.Length>128) comment=comment.Substring(0,128);
byte[] byteStringValue=Encoding.Default.GetBytes(comment);
writer.Write((uint)byteStringValue.Length);
writer.Write(byteStringValue);
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
public CServerRequestSearch(MemoryStream buffer,string searchString,bool matchAnyWords,string type,uint maxSize,uint minSize,uint avaibility, string exclude, bool esUDP)
{
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ServerCommand.SearchRequest);
BinaryWriter writer=new BinaryWriter(buffer);
if (esUDP)
{
writer.Write((byte)Protocol.Header.eDonkey);
//writer.Write((byte)Protocol.ServerCommandsUDP.GlobalSearchRequest);
writer.Write((byte)Protocol.ServerCommandUDP.GlobalSearchRequest2);
}
else
header.Serialize(writer);
if (type=="Any") type="";
//header
int parametercount=0; //must be written parametercount-1 parmeter headers
if (exclude.Length>0)
writer.Write(notParameter);
if ( searchString.Length>0)
{
parametercount++;
if (parametercount>1)
writer.Write(andParameter);
}
if (type.Length>0)
{
parametercount++;
if (parametercount>1)
writer.Write(andParameter);
}
if (minSize>0)
{
parametercount++;
if (parametercount>1)
writer.Write(andParameter);
}
if (maxSize>0)
{
parametercount++;
if (parametercount>1)
writer.Write(andParameter);
}
if (avaibility>0)
{
parametercount++;
if (parametercount>1)
writer.Write(andParameter);
}
// if (extension.GetLength()>0)
// {
// parametercount++;
// if (parametercount>1)
// writer.Write(andParameter);
// }
//body
if (searchString.Length>0) //search a string
{
//writer.Write(notParameter);
string[] list=searchString.Split(" ".ToCharArray());
byte[] searchbyte;
if ((matchAnyWords)&&(list.Length>1))
{
for (int i=0;i<list.Length;i++)
{
if (i!=list.Length-1) writer.Write(orParameter);
writer.Write(stringParameter); //write the parameter type
searchbyte=Encoding.Default.GetBytes(list[i]);
writer.Write((ushort)searchbyte.Length);
writer.Write(searchbyte);
}
}
else
{
writer.Write(stringParameter); //write the parameter type
searchbyte=Encoding.Default.GetBytes(searchString);
writer.Write((ushort)searchbyte.Length);
writer.Write(searchbyte);
}
}
if (type.Length>0)
{
writer.Write(typeParameter); //write the parameter type
byte[] searchbyte=Encoding.Default.GetBytes(type);
writer.Write((ushort)searchbyte.Length);
writer.Write(searchbyte);
writer.Write(typeNemonic2);
writer.Write(typeNemonic1);
}
if (minSize>0)
{
writer.Write(numericParameter); //write the parameter type
writer.Write(minSize); //write the parameter
writer.Write(minNemonic); //nemonic for this kind of parameter
}
if (maxSize>0)
{
writer.Write(numericParameter); //write the parameter type
writer.Write(maxSize); //write the parameter
writer.Write(maxNemonic); //nemonic for this kind of parameter
}
if (avaibility>0)
{
writer.Write(numericParameter); //write the parameter type
writer.Write(avaibility); //write the parameter
writer.Write(avaibilityNemonic); //nemonic for this kind of parameter
}
// if (extension.GetLength()>0)
// {
// data.Write(&stringParameter,1); //write the parameter type
// nSize=extension.GetLength();
// data.Write(&nSize,2); //write the length
// formatC=extension.GetBuffer();
// data.Write(formatC,nSize); //write parameter
// data.Write(&extensionNemonic,3); //nemonic for this kind of parameter (only 3 bytes!!)
// }
if (exclude.Length>0)
{
writer.Write(stringParameter); //write the parameter type
byte[] searchbyte2=Encoding.Default.GetBytes(exclude);
writer.Write((ushort)searchbyte2.Length);
writer.Write(searchbyte2);
}
if (!esUDP)
{
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
}
}
public CCompressedBlockSend(byte[] data,uint start,uint end,byte[] FileHash,ref ArrayList UploadDataPackets)
{
// byte[] buffercomp=new byte[final-inicio+300];
// Deflater descompresor=new Deflater();
// descompresor.SetInput(datos);
// descompresor.Flush();
// int compressedsize=descompresor.Deflate(buffercomp,0,(int)(final-inicio)+300);
// descompresor.Finish();
byte[] buffercomp=null;
int compressedsize=ComprimirBuffer(data,ref buffercomp);
if (compressedsize>=end-start)
{
buffercomp=null;
MemoryStream strmdatos=new MemoryStream(data);
CSendBlock EnvioBloque=new CSendBlock(strmdatos,start,end,FileHash,ref UploadDataPackets);
return;
}
Debug.Write("Compressed comp:"+compressedsize.ToString()+" win: "+Convert.ToString(end-start-compressedsize)+"\n");
MemoryStream datosComp=new MemoryStream(buffercomp);
end=start+(uint)compressedsize;
MemoryStream buffer;
uint size;
BinaryReader reader=new BinaryReader(datosComp);
BinaryWriter writer;
byte[] aux_buffer;
while (start!=end)
{
buffer=new MemoryStream();
writer=new BinaryWriter(buffer);
DonkeyHeader header=new DonkeyHeader((byte)Protocol.ClientCommandExt.CompressedPart,writer,Protocol.ProtocolType.eMule);
writer.Write(FileHash);
if (end-start>10240) size=10240;
else size=end-start;
writer.Write(start);
writer.Write(compressedsize);
aux_buffer=reader.ReadBytes((int)size);
writer.Write(aux_buffer);
start+=size;
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
UploadDataPackets.Add(buffer);
writer=null;
buffer=null;
}
reader.Close();
datosComp.Close();
datosComp=null;
reader=null;
}
//constructor to publish a list of files
public CServerPublishFiles(MemoryStream buffer,CFilesList FilesList,uint startIndex)
{
DonkeyHeader header;
LastFilePublished=startIndex;
BinaryWriter writer=new BinaryWriter(buffer);
header=new DonkeyHeader((byte)Protocol.ServerCommand.OfferFiles,writer);
writer.Write((uint)FilesList.Count);
uint nfiles=0;
int fileIndex=0;
foreach (CElement element in FilesList.Values)
{
fileIndex++;
if (fileIndex<startIndex) continue;
if (m_AddFileToPacket(writer,element)) nfiles++;
LastFilePublished++;
if (nfiles>=200) break; //TODO: check server soft limits
}
header.Packetlength=(uint)writer.BaseStream.Length-header.Packetlength+1;
writer.Seek(0,SeekOrigin.Begin);
header.Serialize(writer);
writer.Write(nfiles);
CLog.Log(Types.Constants.Log.Info,"FIL_PUBLISHED",nfiles);
}
private bool m_ProcessReceptionStream()
{
if (m_HeaderPending)
{
if (m_ReceptionStream.Length-m_StreamPosition>=6)
{
m_ReceptionStream.Seek(m_StreamPosition,SeekOrigin.Begin);
m_DonkeyHeader=new DonkeyHeader(m_ReceptionStream);
if ((m_DonkeyHeader.Packetlength>200000)||((m_DonkeyHeader.eDonkeyID!=Protocol.ProtocolType.eDonkey)
&&(m_DonkeyHeader.eDonkeyID!=Protocol.ProtocolType.eMule)
&&(m_DonkeyHeader.eDonkeyID!=Protocol.ProtocolType.Packet)))
{
OnConnectionFail((byte)Protocol.ConnectionReason.InvalidHeader);
return false;
}
m_HeaderPending=false;
m_ReceptionStream.Seek(0,SeekOrigin.End);
}
}
if ((!m_HeaderPending)&&
((m_ReceptionStream.Length-m_StreamPosition)>=m_DonkeyHeader.Packetlength+5))
{
m_ReceptionStream.Seek(m_StreamPosition+6,SeekOrigin.Begin);
byte[] paquete=new byte[m_DonkeyHeader.Packetlength-1];
m_ReceptionStream.Read(paquete,0,(int)m_DonkeyHeader.Packetlength-1);
m_HeaderPending=true;
if (m_DonkeyHeader.eDonkeyID==Protocol.ProtocolType.eDonkey)
ProcessDonkeyPacket(ref paquete);
else if (m_DonkeyHeader.eDonkeyID==Protocol.ProtocolType.eMule) ProcessMulePacket(ref paquete);
else if (m_DonkeyHeader.eDonkeyID==Protocol.ProtocolType.Packet)
{
CReceivedCompressedBlock.Uncompress(ref paquete);
ProcessMulePacket(ref paquete);
}
m_DonkeyHeader=null;
if (m_ReceptionStream.Position==m_ReceptionStream.Length)
{
//m_ReceptionStream=new MemoryStream(buffSize);
m_ReceptionStream.SetLength(0);
m_StreamPosition=0;
}
else
{
if (m_ReceptionStream.Length>10240)
{
byte[] tmpbuffer=new byte[m_ReceptionStream.Length-m_ReceptionStream.Position];
m_ReceptionStream.Read(tmpbuffer,0,tmpbuffer.Length);
// m_ReceptionStream.Close();
// MemoryStream nuevoStream=new MemoryStream();
// nuevoStream.Write(tmpbuffer,0,tmpbuffer.Length);
// m_ReceptionStream=nuevoStream;
m_ReceptionStream.SetLength(0);
m_ReceptionStream.Write(tmpbuffer,0,tmpbuffer.Length);
m_StreamPosition=0;
return true;
}
else
{
m_StreamPosition=m_ReceptionStream.Position;
//m_ReceptionStream.Seek(0,SeekOrigin.End);
return true;
}
}
}
if (m_ReceptionStream.Position!=m_ReceptionStream.Length)
{
m_ReceptionStream.Seek(0,SeekOrigin.End);
}
return false;
}