packetfactory.cs

P2P (peer to peer) file sharing program in C#. Supports Gnutella, Gnutella2, eDonkey, and OpenNap. w

			return (eachNH*ConnectionManager.ultrapeers.Count);
		}

		int SizeCHs()
		{
			int eachCH = 1+1+2+10;
			this.chCount = GUID.rand.Next(15, 35);
			if(HostCache.recentHubs.Count < this.chCount)
				this.chCount = HostCache.recentHubs.Count;
			return (eachCH*this.chCount);
		}
	}

	public class OQHT : OMessage
	{
		public bool reset;
		public byte deflate;
		public byte fragNum;
		public byte fragCount;

		//indexindata and lenofdata make things more ugly, but much faster (less buffer copies)
		public int indexindata;
		public int lenofdata;
		public byte[] data;

		public override bool FillSendBuff(Sck sck, ref int buffIndex)
		{
			if(reset)
			{
				byte[] pckt = new byte[1+1+3+6];
				Setllen(pckt, 0, 1);
				Setnlen(pckt, 0, 3);
				SetRest(pckt, 0, false);
				Endian.VarBytesFromInt(pckt, 1, 6, 1);
				pckt[2] = (byte)'Q';
				pckt[3] = (byte)'H';
				pckt[4] = (byte)'T';
				pckt[5] = 0x00;
				Array.Copy(Endian.GetBytes(QueryRouteTable.ourQHT.Length, !Stats.Updated.le), 0, pckt, 6, 4);
				pckt[10] = 0x01;
				return StandardFill(sck, ref buffIndex, pckt);
			}
			else
			{
				int payLen = 5+lenofdata;
				int llen = Endian.NumBytesFromInt(payLen);
				if(!CanFit(sck, ref buffIndex, 1+llen+3+payLen))
					return false;
				Setllen(sck.sendBuff, buffIndex, llen);
				Setnlen(sck.sendBuff, buffIndex, 3);
				SetRest(sck.sendBuff, buffIndex, false);
				buffIndex++;
				Endian.VarBytesFromInt(sck.sendBuff, buffIndex, payLen, llen);
				buffIndex += llen;
				sck.sendBuff[buffIndex] = (byte)'Q';
				sck.sendBuff[buffIndex+1] = (byte)'H';
				sck.sendBuff[buffIndex+2] = (byte)'T';
				buffIndex += 3;
				sck.sendBuff[buffIndex] = 0x01;
				sck.sendBuff[buffIndex+1] = fragNum;
				sck.sendBuff[buffIndex+2] = fragCount;
				sck.sendBuff[buffIndex+3] = deflate;
				sck.sendBuff[buffIndex+4] = 0x01;
				buffIndex += 5;
				Array.Copy(data, indexindata, sck.sendBuff, buffIndex, lenofdata);
				buffIndex += lenofdata;
				return true;
			}
		}
	}

	public class OQKR : OMessage, IUdpMessage
	{
		public static byte[] pckt = new byte[0];
		public static byte[] localIP = null;

		public void SetupUdpPacket(OutgoingPacket op)
		{
			byte[] udpPckt;
			lock(pckt)
			{
				if(pckt.Length == 0)
				{
					pckt = new byte[1+1+3 + 1+1+3+6];
					Setllen(pckt, 0, 1);
					Setnlen(pckt, 0, 3);
					SetRest(pckt, 0, true);
					Endian.VarBytesFromInt(pckt, 1, 11, 1);
					pckt[2] = (byte)'Q';
					pckt[3] = (byte)'K';
					pckt[4] = (byte)'R';
					Setllen(pckt, 5, 1);
					Setnlen(pckt, 5, 3);
					SetRest(pckt, 5, false);
					Endian.VarBytesFromInt(pckt, 6, 6, 1);
					pckt[7] = (byte)'R';
					pckt[8] = (byte)'N';
					pckt[9] = (byte)'A';
				}
				udpPckt = new byte[pckt.Length+8];
				Array.Copy(pckt, 0, udpPckt, 8, pckt.Length);
			}
			//key for either us or proxy hub
			if(Stats.Updated.udpIncoming)
			{
				if(OQKR.localIP == null)
					OQKR.localIP = Endian.BigEndianIP(Stats.settings.ipAddress);
				Array.Copy(OQKR.localIP, 0, udpPckt, 18, 4);
				Array.Copy(Endian.GetBytes((ushort)Stats.settings.port, !Stats.Updated.le), 0, udpPckt, 22, 2);
			}
			else
			{
				if(ConnectionManager.ultrapeers.Count == 0)
					op.cancel = true;
				else
				{
					int sockNum = ((ConnectionManager.G2Host)ConnectionManager.ultrapeers.GetKey(GUID.rand.Next(0, ConnectionManager.ultrapeers.Count))).sockNum;
					if(Sck.scks[sockNum].remoteIPA == null)
						op.cancel = true;
					else
					{
						Array.Copy(Endian.GetBytes(Sck.scks[sockNum].remoteIPA), 0, udpPckt, 18, 4);
						Array.Copy(Endian.GetBytes((ushort)Sck.scks[sockNum].port, !Stats.Updated.le), 0, udpPckt, 22, 2);
					}
				}
			}
			op.deflate = false;
			op.pcktData = udpPckt;
			op.acks = null;
			op.parts = new BitArray(UDPSR.GetPartCount(udpPckt.Length-8), false);
			op.len = udpPckt.Length-8;
		}

		public override bool FillSendBuff(Sck sck, ref int buffIndex)
		{
			System.Diagnostics.Debug.WriteLine("G2 OQKR: this shouldn't have been called");
			return true;
		}
	}

	public class OQKA : OMessage, IUdpMessage
	{
		public bool qk = false;
		public int queryKey = -1;
		public IPAddress sna = null;
		public IPAddress qna = null;
		public static byte[] header = new byte[0];

		public override bool FillSendBuff(Sck sck, ref int buffIndex)
		{
			lock(header)
			{
				FillHeader();
				int size = SizeRest();
				if(CanFit(sck, ref buffIndex, header.Length+size))
				{
					Array.Copy(header, 0, sck.sendBuff, buffIndex, header.Length);
					buffIndex += header.Length;
					FillRest(sck.sendBuff, ref buffIndex);
					return true;
				}
				else
					return false;
			}
		}

		public void SetupUdpPacket(OutgoingPacket op)
		{
			lock(header)
			{
				FillHeader();
				int size = SizeRest();
				byte[] payload = new byte[8+header.Length+size];
				int buffIndex = 8+header.Length;
				FillRest(payload, ref buffIndex);
				Array.Copy(header, 0, payload, 8, header.Length);
				op.deflate = false;
				op.pcktData = payload;
				op.acks = null;
				op.parts = new BitArray(UDPSR.GetPartCount(payload.Length-8), false);
				op.len = payload.Length-8;
			}
		}

		void FillHeader()
		{
			if(header.Length == 0)
			{
				header = new byte[1+1+3];
				Setllen(header, 0, 1);
				Setnlen(header, 0, 3);
				SetRest(header, 0, true);
				//skip length for now
				header[2] = (byte)'Q';
				header[3] = (byte)'K';
				header[4] = (byte)'A';
			}
		}

		int SizeRest()
		{
			int size = (1+1+3+4);	//sna
			if(qna != null)
				size += (1+1+3+4);	//qna
			if(this.qk)
				size += (1+1+2+4);	//query key
			Endian.VarBytesFromInt(header, 1, size, 1);
			return size;
		}

		void FillRest(byte[] payload, ref int buffIndex)
		{
			//query key
			if(this.qk)
			{
				Setllen(payload, buffIndex, 1);
				Setnlen(payload, buffIndex, 2);
				SetRest(payload, buffIndex, false);
				buffIndex++;
				Endian.VarBytesFromInt(payload, buffIndex, 4, 1);
				buffIndex++;
				payload[buffIndex] = (byte)'Q';
				buffIndex++;
				payload[buffIndex] = (byte)'K';
				buffIndex++;
				Array.Copy(Endian.GetBytes(queryKey, !Stats.Updated.le), 0, payload, buffIndex, 4);
				buffIndex += 4;
			}
			//sna
			Setllen(payload, buffIndex, 1);
			Setnlen(payload, buffIndex, 3);
			SetRest(payload, buffIndex, false);
			buffIndex++;
			Endian.VarBytesFromInt(payload, buffIndex, 4, 1);
			buffIndex++;
			payload[buffIndex] = (byte)'S';
			buffIndex++;
			payload[buffIndex] = (byte)'N';
			buffIndex++;
			payload[buffIndex] = (byte)'A';
			buffIndex++;
			Array.Copy(Endian.GetBytes(sna), 0, payload, buffIndex, 4);
			buffIndex += 4;
			//qna
			if(qna != null)
			{
				Setllen(payload, buffIndex, 1);
				Setnlen(payload, buffIndex, 3);
				SetRest(payload, buffIndex, false);
				buffIndex++;
				Endian.VarBytesFromInt(payload, buffIndex, 4, 1);
				buffIndex++;
				payload[buffIndex] = (byte)'Q';
				buffIndex++;
				payload[buffIndex] = (byte)'N';
				buffIndex++;
				payload[buffIndex] = (byte)'A';
				buffIndex++;
				Array.Copy(Endian.GetBytes(qna), 0, payload, buffIndex, 4);
				buffIndex += 4;
			}
		}
	}

	public class OQ2 : OMessage, IUdpMessage
	{
		public byte[] pckt = null;
		//descriptive name
		public string query = "";
		//associated guid
		public byte[] guid = null;
		//should this be sent directly over a tcp connection to a hub
		public bool tcpQuery = false;
		//do we need a proxy hub because we're udp-firewalled
		public IPAddress ipaProxyHub = null;
		public int proxyPort;
		//hub info for reference
		public HubInfo hi;
		//any urn?
		public byte[] urn = null;
		//interest packet combinations: 0=none, 1=URL&DN
		public int interest = 0;

		public void SetupUdpPacket(OutgoingPacket op)
		{
			CreatePacket(8);
			op.deflate = false;
			op.pcktData = pckt;
			op.acks = null;
			op.parts = new BitArray(UDPSR.GetPartCount(pckt.Length-8), false);
			op.len = pckt.Length-8;
		}

		public override bool FillSendBuff(Sck sck, ref int buffIndex)
		{
			CreatePacket(0);
			return OMessage.StandardFill(sck, ref buffIndex, pckt, true);
		}

		void CreatePacket(int i)
		{
			if(pckt == null)
			{
				//the 1 is for the null control byte to end the series of children... and the 16 is the guid payload
				int total = SizeUDP() + SizeURN() + SizeDN() + SizeI() + 1 + 16;
				int numBytesLen = Endian.NumBytesFromInt(total);
				this.pckt = new byte[i+1+numBytesLen+2+total];
				Setllen(pckt, i, numBytesLen);
				Setnlen(pckt, i, 2);
				SetRest(pckt, i, true);
				i++;
				Endian.VarBytesFromInt(pckt, i, total, numBytesLen);
				i += numBytesLen;
				pckt[i] = (byte)'Q';
				i++;
				pckt[i] = (byte)'2';
				i++;
				//udp
				if(!tcpQuery)
				{
					Setllen(pckt, i, 1);
					Setnlen(pckt, i, 3);
					SetRest(pckt, i, false);
					i++;
					Endian.VarBytesFromInt(pckt, i, 10, 1);
					i++;
					pckt[i] = (byte)'U';
					i++;
					pckt[i] = (byte)'D';
					i++;
					pckt[i] = (byte)'P';
					i++;
					if(this.ipaProxyHub == null)
					{
						Array.Copy(Endian.GetBytes(Stats.Updated.myIPA), 0, pckt, i, 4);
						i += 4;
						Array.Copy(Endian.GetBytes((ushort)Stats.settings.port, !Stats.Updated.le), 0, pckt, i, 2);
						i += 2;
					}
					else
					{
						Array.Copy(Endian.GetBytes(this.ipaProxyHub), 0, pckt, i, 4);
						i += 4;
						Array.Copy(Endian.GetBytes((ushort)proxyPort, !Stats.Updated.le), 0, pckt, i, 2);
						i += 2;
					}
					Array.Copy(Endian.GetBytes(hi.mhi.queryKey, !Stats.Updated.le), 0, pckt, i, 4);
					i += 4;
				}
				//urn
				if(this.urn != null)
				{
					Setllen(pckt, i, 1);
					Setnlen(pckt, i, 3);
					SetRest(pckt, i, false);
					i++;
					Endian.VarBytesFromInt(pckt, i, this.urn.Length, 1);
					i++;
					pckt[i] = (byte)'U';
					i++;
					pckt[i] = (byte)'R';
					i++;
					pckt[i] = (byte)'N';
					i++;
					Array.Copy(this.urn, 0, pckt, i, this.urn.Length);
					i += this.urn.Length;
				}
				//dn
				if(this.query.Length > 0)
				{
					Setllen(pckt, i, 1);
					Setnlen(pckt, i, 2);
					SetRest(pckt, i, false);
					i++;
					Endian.VarBytesFromInt(pckt, i, this.query.Length, 1);
					i++;
					pckt[i] = (byte)'D';
					i++;
					pckt[i] = (byte)'N';
					i++;
					Array.Copy(Encoding.ASCII.GetBytes(this.query), 0, pckt, i, this.query.Length);
					i += this.query.Length;
				}
				//i
				if(this.interest == 1)
				{
					Setllen(pckt, i, 1);
					Setnlen(pckt, i, 1);
					SetRest(pckt, i, false);
					i++;
					Endian.VarBytesFromInt(pckt, i, 7, 1);
					i++;
					pckt[i] = (byte)'I';
					i++;
					pckt[i] = (byte)'U';
					i++;
					pckt[i] = (byte)'R';
					i++;
					pckt[i] = (byte)'L';
					i++;
					pckt[i] = (byte)'\0';
					i++;
					pckt[i] = (byte)'D';
					i++;
					pckt[i] = (byte)'N';
					i++;
					pckt[i] = (byte)'\0';
					i++;
				}
				//the rest
				pckt[i] = 0x00;
				i++;
				Array.Copy(this.guid, 0, pckt, i, 16);
				i += 16;
			}
		}

		int SizeUDP()
		{
			if(this.tcpQuery)
				return 0;
			else
				return (1+1+3+10);
		}

		int SizeURN()
		{
			if(this.urn == null)
				return 0;
			else
				return (1+1+3+this.urn.Length);
		}

		int SizeDN()
		{
			if(this.query.Length == 0)
				return 0;
			else
				return (1+1+2+this.query.Length);
		}

		int SizeI()
		{
			if(this.interest == 0)
				return 0;
			else if(this.interest == 1)
				return (1+1+1+7);
			else
				return 0;
		}
	}

	public class OQA : OMessage, IUdpMessage
	{
		public bool tcp;	//tcp or not
		public byte[] sGUID;//search guid
		public int gOffset;	//offset in search guid
		int dCount = 0;		//amount of Done hubs
		int sCount1 = 0;	//amount of local cluster Search hubs
		int sCount2 = 0;	//amount of cached Search hubs
		int numBytesLen;
		int total;

		public override bool FillSendBuff(Sck sck, ref int buffIndex)
		{
			lock(HostCache.recentHubs)
			{
				total = SizeTimestamp()+SizeDs()+SizeSs()+1+16;
				numBytesLen = Endian.NumBytesFromInt(total);
				if(!OMessage.CanFit(sck, ref buffIndex, 1+numBytesLen+2+total))
					return false;

				FillBuff(sck.sendBuff, ref buffIndex);
				return true;
			}
		}

		public void SetupUdpPacket(OutgoingPacket op)
		{
			lock(HostCache.recentHubs)
			{
				total = SizeTimestamp()+SizeDs()+SizeSs()+1+16;
				numBytesLen = Endian.NumBytesFromInt(total);
				byte[] pckt = new byte[8+1+numBytesLen+2+total];
				int buffIndex = 8;
				FillBuff(pckt, ref buffIndex);
				op.deflate = false;
				op.pcktData = pckt;
				op.acks = null;
				op.parts = new BitArray(UDPSR.GetPartCount(pckt.Length-8), false);
				op.len = pckt.Length-8;
			}
		}

		void FillBuff(byte[] bytarr, ref int buffIndex)
		{
			Setllen(bytarr, buffIndex, numBytesLen);
			Setnlen(bytarr, buffIndex, 2);
			SetRest(bytarr, buffIndex, true);
			buffIndex++;
			Endian.VarBytesFromInt(bytarr, buffIndex, total, numBytesLen);
			buffIndex += numBytesLen;
			bytarr[buffIndex] = (byte)'Q';
			buffIndex++;
			bytarr[buffIndex] = (byte)'A';
			buffIndex++;

			//timestamp
			Setllen(bytarr, buffIndex, 1);
			Setnlen(bytarr, buffIndex, 2);
			SetRest(bytarr, buffIndex, false);
			buffIndex++;
			Endian.VarBytesFromInt(bytarr, buffIndex, 4, 1);
			buffIndex++;
			bytarr[buffIndex] = (byte)'T';
			buffIndex++;
			bytarr[buffIndex] = (byte)'S';
			buffIndex++;
			Array.Copy(Endian.GetBytes(Stats.Updated.timestamp, !Stats.Updated.le), 0, bytarr, buffIndex, 4);
			buffIndex += 4;

			//done hubs
			for(int x = 0; x <= ConnectionManager.ultrapeers.Count; x++)
			{
				Setllen(bytarr, buffIndex, 1);
				Setnlen(bytarr, buffIndex, 1);
				SetRest(bytarr, buffIndex, false);
				buffIndex++;
				Endian.VarBytesFromInt(bytarr, buffIndex, 8, 1);
				buffIndex++;
				bytarr[buffIndex] = (byte)'D';
				buffIndex++;
				if(x < ConnectionManager.ultrapeers.Count)
				{
					int tmpSckNum = ((ConnectionManager.G2Host)ConnectionManager.ultrapeers.GetKey(x)).sockNum;
					Array.Copy(Endian.GetBytes(Sck.scks[tmpSckNum].remoteIPA), 0, bytarr, buffIndex, 4);
					buffIndex += 4;
					Array.Copy(Endian.GetBytes((ushort)Sck.scks[tmpSckNum].port, !Stats.Updated.le), 0, bytarr, buffIndex, 2);
					buffIndex += 2;
					Array.Copy(Endian.GetBytes(Sck.scks[tmpSckNum].leaves, !Stats.Updated.le), 0, bytarr, buffIndex, 2);
					buffIndex += 2;
				}
				else
				{
					Array.Copy(Endian.GetBytes(Stats.Updated.myIPA), 0, bytarr, buffIndex, 4);
					buffIndex += 4;
					Array.Copy(Endian.GetBytes((ushort)Stats.settings.port, !Stats.Updated.le), 0, bytarr, buffIndex, 2);
					buffIndex += 2;
					Array.Copy(Endian.GetBytes((ushort)ConnectionManager.leaves.Count, !Stats.Updated.le), 0, bytarr, buffIndex, 2);
					buffIndex += 2;
				}
			}

			//search hubs
			foreach(ConnectionManager.G2Host g2h in ConnectionManager.ultrapeers.Keys)
				if(Sck.scks[g2h.sockNum].neighbors.Count > 0)
					foreach(IPEndPoint ipep in Sck.scks[g2h.sockNum].neighbors)
					{
						Setllen(bytarr, buffIndex, 1);
						Setnlen(bytarr, buffIndex, 1);
						SetRest(bytarr, buffIndex, false);