packet32.cs

一个抓包工具

				if( mStopCapture == true ) break;

				if( mCaptureLimits.LimitToPackets )
				{
					if( mCaptureStatus.Total.Count >= mCaptureLimits.PacketSize )
						break;
				}
			
				if( mCaptureLimits.LimitToKiloBytes )
				{
					if( mCaptureStatus.Kilobytes >= mCaptureLimits.KilobyteSize )
						break;
				}
			
				if( mCaptureLimits.LimitToSeconds )
				{
					if( mCaptureStatus.Seconds >= mCaptureLimits.SecondSize )
						break;
				}


			}while( true );

			mCaptureStopped = true;

			PacketUsageItem.StopTime = Function.GetTickCount();
			CalculateBandUsage();

			P32h.PacketFreePacket();
			P32h.PacketCloseAdapter();

		}

		public bool SaveToFile( string FileName )
		{
			StreamWriter SWriter = new StreamWriter( FileName );
			Stream WStream;
			byte [] WriteArray = new byte[16];
			int i = 0;
			byte [] HeaderData = new byte[24];
			PacketParser.PACKET_ITEM PItem;

			if( P32h.CapturedPacketArray == null ) return false;
			if( P32h.CapturedPacketArray.Count == 0 ) return false;

			WStream = SWriter.BaseStream;

			// To make enable our output file to be read by etheral
			HeaderData[0] = 0xD4; HeaderData[1] = 0xC3; HeaderData[2] = 0xB2; HeaderData[3] = 0xA1;
			HeaderData[4] = 0x02; HeaderData[5] = 0x00; HeaderData[6] = 0x04; HeaderData[7] = 0x00;
			HeaderData[8] = 0x00; HeaderData[9] = 0x00; HeaderData[10] = 0x00; HeaderData[11] = 0x00;
			HeaderData[12] = 0x00; HeaderData[13] = 0x00; HeaderData[14] = 0x00; HeaderData[15] = 0x00;
			HeaderData[16] = 0xFF; HeaderData[17] = 0xFF; HeaderData[18] = 0x00; HeaderData[19] = 0x00;
			HeaderData[20] = 0x01; HeaderData[21] = 0x00; HeaderData[22] = 0x00; HeaderData[23] = 0x00;
			 
			WStream.Write( HeaderData, 0 , 24 );

			for( i = 0; i < PParser.PacketCollection.Count; i ++ )
			{
				PItem = ( PacketParser.PACKET_ITEM ) PParser.PacketCollection[i];
				WStream.Write( PItem.FrameData , 0 , 16 );
				WStream.Write( PItem.Data , 0 , PItem.Data.GetLength(0) );
			}

			SWriter.Close();

			return true;
		}


		public bool SaveSelectedPacket( string FileName , int index )
		{
			StreamWriter SWriter = new StreamWriter( FileName );
			Stream WStream;
			byte [] WriteArray = new byte[16];
			byte [] HeaderData = new byte[24];
			PacketParser.PACKET_ITEM PItem;

			if( P32h.CapturedPacketArray == null ) return false;
			if( P32h.CapturedPacketArray.Count == 0 ) return false;

			WStream = SWriter.BaseStream;

			// To make enable our output file to be read by etheral
			HeaderData[0] = 0xD4; HeaderData[1] = 0xC3; HeaderData[2] = 0xB2; HeaderData[3] = 0xA1;
			HeaderData[4] = 0x02; HeaderData[5] = 0x00; HeaderData[6] = 0x04; HeaderData[7] = 0x00;
			HeaderData[8] = 0x00; HeaderData[9] = 0x00; HeaderData[10] = 0x00; HeaderData[11] = 0x00;
			HeaderData[12] = 0x00; HeaderData[13] = 0x00; HeaderData[14] = 0x00; HeaderData[15] = 0x00;
			HeaderData[16] = 0xFF; HeaderData[17] = 0xFF; HeaderData[18] = 0x00; HeaderData[19] = 0x00;
			HeaderData[20] = 0x01; HeaderData[21] = 0x00; HeaderData[22] = 0x00; HeaderData[23] = 0x00;
			 
			WStream.Write( HeaderData, 0 , 24 );
			PItem = ( PacketParser.PACKET_ITEM ) PParser.PacketCollection[index];
			WStream.Write( PItem.FrameData , 0 , 16 );
			WStream.Write( PItem.Data , 0 , PItem.Data.GetLength(0) );

			SWriter.Close();

			return true;
		}


		public bool SaveSelectedPacket( string FileName , int [] indexArray )
		{
			StreamWriter SWriter = new StreamWriter( FileName );
			Stream WStream;
			byte [] WriteArray = new byte[16];
			byte [] HeaderData = new byte[24];
			PacketParser.PACKET_ITEM PItem;
			int i = 0;

			if( P32h.CapturedPacketArray == null ) return false;
			if( P32h.CapturedPacketArray.Count == 0 ) return false;

			WStream = SWriter.BaseStream;

			// To make enable our output file to be read by etheral
			HeaderData[0] = 0xD4; HeaderData[1] = 0xC3; HeaderData[2] = 0xB2; HeaderData[3] = 0xA1;
			HeaderData[4] = 0x02; HeaderData[5] = 0x00; HeaderData[6] = 0x04; HeaderData[7] = 0x00;
			HeaderData[8] = 0x00; HeaderData[9] = 0x00; HeaderData[10] = 0x00; HeaderData[11] = 0x00;
			HeaderData[12] = 0x00; HeaderData[13] = 0x00; HeaderData[14] = 0x00; HeaderData[15] = 0x00;
			HeaderData[16] = 0xFF; HeaderData[17] = 0xFF; HeaderData[18] = 0x00; HeaderData[19] = 0x00;
			HeaderData[20] = 0x01; HeaderData[21] = 0x00; HeaderData[22] = 0x00; HeaderData[23] = 0x00;
			 
			WStream.Write( HeaderData, 0 , 24 );
			for( i = 0; i < indexArray.Length; i ++ )
			{
				PItem = ( PacketParser.PACKET_ITEM ) PParser.PacketCollection[ indexArray[i] ];
				WStream.Write( PItem.FrameData , 0 , 16 );
				WStream.Write( PItem.Data , 0 , PItem.Data.GetLength(0) );
			}

			SWriter.Close();

			return true;
		}

		public bool LoadFromFile( string FileName )
		{
			StreamReader SReader = new StreamReader( FileName );
			Stream RStream;
			byte [] ReadArray;
			byte [] HeaderData = new byte[24];

			PacketOnOff = false;

			P32h.CapturedPacketArray.Clear();
			ReceivedPackets.Clear();

			RStream = SReader.BaseStream;
			ReadArray = new byte[(int) RStream.Length - 24 ];
			RStream.Read( HeaderData , 0 , 24 );
			RStream.Read( ReadArray , 0 , (int) RStream.Length - 24 );
			SReader.Close();
			P32h.CapturedPacketArray.Add( ReadArray );
			PParser.PacketBufferData = ReadArray;

			return true;

		}


		public bool ReadSettings()
		{
			RegistryKey RKey;
			RegistryKey PacanalKey;
			object o;


			RKey = Registry.CurrentUser.OpenSubKey("MSAV");
			if( RKey == null )
			{
				SaveSettings();
				return false;
			}

			PacanalKey = RKey.OpenSubKey("Pacanal", true );
			if( PacanalKey == null )
			{
				RKey.Close();
				SaveSettings();
				return false;
			}

			RKey.Close();

			o = PacanalKey.GetValue("CaptureLimit", 1 );
			try { mCaptureOptions.LimitPackets = ( (int) o ) == 0 ? false : true; }
			catch 
			{ 
				mCaptureOptions.LimitPackets = false;
				PacanalKey.SetValue("CaptureLimit" , 0 );
			}

			o = PacanalKey.GetValue("EachPacketSize", 68 );
			try { mCaptureOptions.PacketSize = (int) o; }
			catch 
			{ 
				mCaptureOptions.PacketSize = 68;
				PacanalKey.SetValue("EachPacketSize" , 68 );
			}

			o = PacanalKey.GetValue("PromiscuousMode", 1 );
			try { mCaptureOptions.PromiscuousMode = ( (int) o ) == 0 ? false : true; }
			catch 
			{ 
				mCaptureOptions.PromiscuousMode = true;
				PacanalKey.SetValue("PromiscuousMode" , 1 );
			}

			o = PacanalKey.GetValue("Filter", "" );
			try { mCaptureOptions.Filter = (string) o; }
			catch 
			{ 
				mCaptureOptions.Filter = "";
				PacanalKey.SetValue("Filter" , "" );
			}

			o = PacanalKey.GetValue("UpdateListInRealTime", 0 );
			try { mDisplayOptions.UpdateListInRealTime = ( (int) o ) == 0 ? false : true; }
			catch 
			{ 
				mDisplayOptions.UpdateListInRealTime = false;
				PacanalKey.SetValue("UpdateListInRealTime" , 0 );
			}

			o = PacanalKey.GetValue("AutomaticScrollInLiveCapture", 0 );
			try { mDisplayOptions.AutomaticScrollInLiveCapture = ( (int) o ) == 0 ? false : true; }
			catch 
			{ 
				mDisplayOptions.AutomaticScrollInLiveCapture = false;
				PacanalKey.SetValue("AutomaticScrollInLiveCapture" , 0 );
			}

			o = PacanalKey.GetValue("LimitToPackets", 0 );
			try { mCaptureLimits.LimitToPackets = ( (int) o ) == 0 ? false : true; }
			catch 
			{ 
				mCaptureLimits.LimitToPackets = false;
				PacanalKey.SetValue("LimitToPackets" , 0 );
			}

			o = PacanalKey.GetValue("PacketSize", 1 );
			try { mCaptureLimits.PacketSize = (int) o; }
			catch 
			{ 
				mCaptureLimits.PacketSize = 1;
				PacanalKey.SetValue("PacketSize" , 1 );
			}

			o = PacanalKey.GetValue("LimitToKiloBytes", 0 );
			try { mCaptureLimits.LimitToKiloBytes = ( (int) o ) == 0 ? false : true; }
			catch 
			{ 
				mCaptureLimits.LimitToKiloBytes = false;
				PacanalKey.SetValue("LimitToKiloBytes" , 0 );
			}

			o = PacanalKey.GetValue("KilobyteSize", 1 );
			try { mCaptureLimits.KilobyteSize = (int) o; }
			catch 
			{ 
				mCaptureLimits.KilobyteSize = 1;
				PacanalKey.SetValue("KilobyteSize" , 1 );
			}

			o = PacanalKey.GetValue("LimitToSeconds", 0 );
			try { mCaptureLimits.LimitToSeconds = ( (int) o ) == 0 ? false : true; }
			catch 
			{ 
				mCaptureLimits.LimitToSeconds = false;
				PacanalKey.SetValue("LimitToSeconds" , 0 );
			}

			o = PacanalKey.GetValue("SecondSize", 1 );
			try { mCaptureLimits.SecondSize = (int) o; }
			catch 
			{ 
				mCaptureLimits.SecondSize = 1;
				PacanalKey.SetValue("SecondSize" , 1 );
			}

			o = PacanalKey.GetValue("EnableMAC", 0 );
			try { mNameResolution.EnableMAC = ( (int) o ) == 0 ? false : true; }
			catch 
			{ 
				mNameResolution.EnableMAC = false;
				PacanalKey.SetValue("EnableMAC" , 0 );
			}

			o = PacanalKey.GetValue("EnableNetwork", 0 );
			try { mNameResolution.EnableNetwork = ( (int) o ) == 0 ? false : true; }
			catch 
			{ 
				mNameResolution.EnableNetwork = false;
				PacanalKey.SetValue("EnableNetwork" , 0 );
			}

			o = PacanalKey.GetValue("EnableTransport", 0 );
			try { mNameResolution.EnableTransport = ( (int) o ) == 0 ? false : true; }
			catch 
			{ 
				mNameResolution.EnableTransport = false;
				PacanalKey.SetValue("EnableTransport" , 0 );
			}

			o = PacanalKey.GetValue("EnableManufacturer", 0 );
			try { mNameResolution.EnableManufacturer = ( (int) o ) == 0 ? false : true; }
			catch 
			{ 
				mNameResolution.EnableManufacturer = false;
				PacanalKey.SetValue("EnableManufacturer" , 0 );
			}

			o = PacanalKey.GetValue("AdapterBufferSize", 512000 );
			try { mCaptureOptions.AdapterBufferSize = (int) o; }
			catch 
			{ 
				mCaptureOptions.AdapterBufferSize = 512000;
				PacanalKey.SetValue("AdapterBufferSize" , 512000 );
			}

			o = PacanalKey.GetValue("BufferSize", 256000 );
			try { mCaptureOptions.BufferSize = (int) o; }
			catch 
			{ 
				mCaptureOptions.BufferSize = 256000;
				PacanalKey.SetValue("BufferSize" , 256000 );
			}

			o = PacanalKey.GetValue("MinBytesToCopy", 4096);
			try { mCaptureOptions.MinBytesToCopy = (int) o; }
			catch 
			{ 
				mCaptureOptions.MinBytesToCopy = 4096;
				PacanalKey.SetValue("MinBytesToCopy" , 4096 );
			}

			o = PacanalKey.GetValue("NumWrites", 1 );
			try { mCaptureOptions.NumWrites = (int) o; }
			catch 
			{ 
				mCaptureOptions.NumWrites = 1;
				PacanalKey.SetValue("NumWrites" , 1 );
			}

			o = PacanalKey.GetValue("ReadTimeOut", 1000 );
			try { mCaptureOptions.ReadTimeOut = (int) o; }
			catch 
			{ 
				mCaptureOptions.ReadTimeOut = 1000;
				PacanalKey.SetValue("ReadTimeOut" , 1000 );
			}

			o = PacanalKey.GetValue("CaptureMode", Packet32h.PACKET_MODE_CAPT );
			try { mCaptureOptions.CaptureMode = (int) o; }
			catch 
			{ 
				mCaptureOptions.CaptureMode = (int) Packet32h.PACKET_MODE_CAPT;
				PacanalKey.SetValue("CaptureMode" , Packet32h.PACKET_MODE_CAPT );
			}

			if( ( mCaptureOptions.CaptureMode != (int) Packet32h.PACKET_MODE_CAPT ) &&
				( mCaptureOptions.CaptureMode != (int) Packet32h.PACKET_MODE_DUMP ) &&
				( mCaptureOptions.CaptureMode != (int) Packet32h.PACKET_MODE_STAT ) &&
				( mCaptureOptions.CaptureMode != (int) Packet32h.PACKET_MODE_STAT_DUMP ) )
			{
				mCaptureOptions.CaptureMode = (int) Packet32h.PACKET_MODE_CAPT;
				PacanalKey.SetValue("CaptureMode" , Packet32h.PACKET_MODE_CAPT );
			}

			o = PacanalKey.GetValue("HardwareFilter", Packet32h.NDIS_PACKET_TYPE_PROMISCUOUS );
			try { mCaptureOptions.HardwareFilter = (int) o; }
			catch 
			{ 
				mCaptureOptions.HardwareFilter = Packet32h.NDIS_PACKET_TYPE_PROMISCUOUS;
				PacanalKey.SetValue("HardwareFilter" , Packet32h.NDIS_PACKET_TYPE_PROMISCUOUS );
			}

			PacanalKey.Close();
			return true;

		}


		public bool SaveSettings()
		{
			RegistryKey RKey = null;
			RegistryKey PacanalKey = null;


			try
			{
				RKey = Registry.CurrentUser.CreateSubKey("MSAV");
			}
			catch( Exception Ex )
			{
				MessageBox.Show( Function.ReturnErrorMessage( Ex ) );
			}

			if( RKey == null )
				return false;

			PacanalKey = RKey.CreateSubKey("Pacanal");
			if( PacanalKey == null )
			{
				RKey.Close();
				return false;
			}

			PacanalKey.CreateSubKey( "CaptureLimit" );
			PacanalKey.SetValue("CaptureLimit", mCaptureOptions.LimitPackets ? 1 : 0 );

			PacanalKey.CreateSubKey( "EachPacketSize" );
			PacanalKey.SetValue("EachPacketSize", mCaptureOptions.PacketSize );

			PacanalKey.CreateSubKey( "PromiscuousMode" );
			PacanalKey.SetValue("PromiscuousMode", mCaptureOptions.PromiscuousMode ? 1 : 0 );

			PacanalKey.CreateSubKey( "Filter" );
			PacanalKey.SetValue("Filter", mCaptureOptions.Filter );

			PacanalKey.CreateSubKey( "UpdateListInRealTime" );
			PacanalKey.SetValue("UpdateListInRealTime", mDisplayOptions.UpdateListInRealTime ? 1 : 0 );

			PacanalKey.CreateSubKey( "AutomaticScrollInLiveCapture" );
			PacanalKey.SetValue("AutomaticScrollInLiveCapture", mDisplayOptions.AutomaticScrollInLiveCapture ? 1 : 0 );

			PacanalKey.CreateSubKey( "LimitToPackets" );
			PacanalKey.SetValue("LimitToPackets", mCaptureLimits.LimitToPackets ? 1 : 0 );

			PacanalKey.CreateSubKey( "PacketSize" );
			PacanalKey.SetValue("PacketSize", mCaptureLimits.PacketSize );

			PacanalKey.CreateSubKey( "LimitToKiloBytes" );
			PacanalKey.SetValue("LimitToKiloBytes", mCaptureLimits.LimitToKiloBytes ? 1 : 0 );

			PacanalKey.CreateSubKey( "KilobyteSize" );
			PacanalKey.SetValue("KilobyteSize", mCaptureLimits.KilobyteSize );

			PacanalKey.CreateSubKey( "LimitToSeconds" );
			PacanalKey.SetValue("LimitToSeconds", mCaptureLimits.LimitToSeconds ? 1 : 0 );

			PacanalKey.CreateSubKey( "SecondSize" );
			PacanalKey.SetValue("SecondSize", mCaptureLimits.SecondSize );

			PacanalKey.CreateSubKey( "EnableMAC" );
			PacanalKey.SetValue("EnableMAC", mNameResolution.EnableMAC ? 1 : 0 );

			PacanalKey.CreateSubKey( "EnableNetwork" );
			PacanalKey.SetValue("EnableNetwork", mNameResolution.EnableNetwork ? 1 : 0 );

			PacanalKey.CreateSubKey( "EnableTransport" );
			PacanalKey.SetValue("EnableTransport", mNameResolution.EnableTransport ? 1 : 0 );

			PacanalKey.CreateSubKey( "EnableManufacturer" );
			PacanalKey.SetValue("EnableManufacturer", mNameResolution.EnableManufacturer ? 1 : 0 );

			PacanalKey.CreateSubKey( "AdapterBufferSize" );
			PacanalKey.SetValue("AdapterBufferSize", mCaptureOptions.AdapterBufferSize );

			PacanalKey.CreateSubKey( "BufferSize" );
			PacanalKey.SetValue("BufferSize", mCaptureOptions.BufferSize );

			PacanalKey.CreateSubKey( "MinBytesToCopy" );
			PacanalKey.SetValue("MinBytesToCopy", mCaptureOptions.MinBytesToCopy );

			PacanalKey.CreateSubKey( "NumWrites" );
			PacanalKey.SetValue("NumWrites", mCaptureOptions.NumWrites );

			PacanalKey.CreateSubKey( "ReadTimeOut" );
			PacanalKey.SetValue("ReadTimeOut", mCaptureOptions.ReadTimeOut );

			PacanalKey.CreateSubKey( "CaptureMode" );
			PacanalKey.SetValue("CaptureMode", mCaptureOptions.CaptureMode );

			PacanalKey.CreateSubKey( "HardwareFilter" );
			PacanalKey.SetValue("HardwareFilter", mCaptureOptions.HardwareFilter );
			
			PacanalKey.Close();

			return true;

		}

	}
}