packet32h.cs

一个抓包工具

		//****************************************************************

		public bool PacketSetBpf()
		{
			int Result = 0;

			Result = SendDeviceCommand( pBIOCSETF, mBpfProgram );
			if( Result == 0 )
			{
				mPacketErrorCode = Function.GetLastError();
				if( mPacketErrorCode > 0 )
					mPacketErrorMessage = Function.GetSystemErrorMessage( mPacketErrorCode );
				Function.SetLastError( 0 );
				return false;
			}

			return true;
		}

		//****************************************************************
		//
		//****************************************************************

		public bool PacketGetStats()
		{
			int Res = 0;
			int BytesReturned = 0;
			// We use a support structure to avoid kernel-level inconsistencies with old or malicious applications
			BPF_STAT tmpstat; // = ( PBPF_STAT * ) Function.AddressOf( new byte[ sizeof( PBPF_STAT ) ] );	

			tmpstat.bs_capt = 0;
			tmpstat.bs_drop = 0;
			tmpstat.bs_recv = 0;
			tmpstat.ps_ifdrop = 0;

			Res = DeviceIoControl( mAdapter.hFile,
				pBIOCGSTATS,
				0,
				0,
				ref tmpstat,
				16, //sizeof( PBPF_STAT ),
				ref BytesReturned,
				0);

			if( Res == 0 )
			{
				mPacketErrorCode = Function.GetLastError();
				if( mPacketErrorCode > 0 )
					mPacketErrorMessage = Function.GetSystemErrorMessage( mPacketErrorCode );
				Function.SetLastError( 0 );
				return false;
			}

			// Copy only the first two values retrieved from the driver
			mBpfStat.bs_recv = tmpstat.bs_recv;
			mBpfStat.bs_drop = tmpstat.bs_drop;

			return true;
		}

		//****************************************************************
		//
		//****************************************************************

		public bool PacketGetStatsEx()
		{
			int Res = 0;
			int BytesReturned = 0;
			// We use a support structure to avoid kernel-level inconsistencies with old or malicious applications
			//PBPF_STAT * tmpstat = ( PBPF_STAT * ) Function.AddressOf( new byte[ sizeof( PBPF_STAT ) ] );
			BPF_STAT tmpstat; // = ( PBPF_STAT * ) Function.AddressOf( new byte[ sizeof( PBPF_STAT ) ] );	

			tmpstat.bs_capt = 0;
			tmpstat.bs_drop = 0;
			tmpstat.bs_recv = 0;
			tmpstat.ps_ifdrop = 0;

			Res = DeviceIoControl( mAdapter.hFile,
				pBIOCGSTATS,
				0,
				0,
				ref tmpstat,
				16, //sizeof( PBPF_STAT ),
				ref BytesReturned,
				0);
			if( Res == 0 )
			{
				mPacketErrorCode = Function.GetLastError();
				if( mPacketErrorCode > 0 )
					mPacketErrorMessage = Function.GetSystemErrorMessage( mPacketErrorCode );
				Function.SetLastError( 0 );
				return false;
			}

			mBpfStat.bs_recv = tmpstat.bs_recv;
			mBpfStat.bs_drop = tmpstat.bs_drop;
			mBpfStat.ps_ifdrop = tmpstat.ps_ifdrop;
			mBpfStat.bs_capt = tmpstat.bs_capt;

			return true;
		}

		//****************************************************************
		//
		//****************************************************************

		public bool PacketSetBuff( int dim )
		{
			int Result = 0;

			Result = SendDeviceCommand( pBIOCSETBUFFERSIZE, dim );
			if( Result == 0 )
			{
				mPacketErrorCode = Function.GetLastError();
				if( mPacketErrorCode > 0 )
					mPacketErrorMessage = Function.GetSystemErrorMessage( mPacketErrorCode );
				Function.SetLastError( 0 );
				return false;
			}

			return true;
		}

		//****************************************************************
		//
		//****************************************************************

		public bool PacketGetNetType()
		{
			//get the link-layer type
			mNetType.LinkType = ( uint ) GetMediaInUse();
			//get the link-layer speed
			mNetType.LinkSpeed = ( uint ) GetLinkSpeed();

			return true;
		}

		//****************************************************************
		//
		//****************************************************************

		public bool PacketSendPacket()
		{
			int BytesTransfered = 0;
			int Result = 0;
    
			Result = WriteFile( mAdapter.hFile,
				mPacket.Buffer,
				(int) mPacket.Length,
				ref BytesTransfered,
				0);
			if( Result == 0 )
			{
				mPacketErrorCode = Function.GetLastError();
				if( mPacketErrorCode > 0 )
					mPacketErrorMessage = Function.GetSystemErrorMessage( mPacketErrorCode );
				Function.SetLastError( 0 );
				return false;
			}

			return true;
		}

		//****************************************************************
		//
		//****************************************************************

		unsafe public int PacketSendPackets( bool Sync )
		{
			int Result = 0;
			int BytesTransfered = 0, TotBytesTransfered = 0;
			TIMEVAL BufStartTime;
			long StartTicks = 0, CurTicks = 0, TargetTicks = 0, TimeFreq = 0;
			long Val1 = 0, Val2 = 0, Val3 = 0;


			// Obtain starting timestamp of the buffer
			BufStartTime.tv_sec = ( ( TIMEVAL * )( mPacket.Buffer ) )->tv_sec;
			BufStartTime.tv_usec = ( ( TIMEVAL * )( mPacket.Buffer ) )->tv_usec;

			// Retrieve the reference time counters
			QueryPerformanceCounter( ref StartTicks );
			QueryPerformanceFrequency( ref TimeFreq );

			CurTicks = StartTicks;

			do
			{
				// Send the data to the driver
				if( Sync )
					Result = DeviceIoControl( mAdapter.hFile,
						pBIOCSENDPACKETSSYNC,
						mPacket.Buffer + TotBytesTransfered,
						mPacket.Length - TotBytesTransfered,
						0,
						0,
						ref BytesTransfered,
						0);
				else
					Result = DeviceIoControl( mAdapter.hFile,
						pBIOCSENDPACKETSNOSYNC,
						mPacket.Buffer + TotBytesTransfered,
						mPacket.Length - TotBytesTransfered,
						0,
						0,
						ref BytesTransfered,
						0);


				TotBytesTransfered += BytesTransfered;

				// calculate the time interval to wait before sending the next packet
				Val1 = ( ( ( TIMEVAL * )( mPacket.Buffer + TotBytesTransfered ) )->tv_sec - BufStartTime.tv_sec) * 1000000;
				Val2 = ( ( ( TIMEVAL * )( mPacket.Buffer + TotBytesTransfered ) )->tv_usec - BufStartTime.tv_usec );
				Val3 = TimeFreq / 1000000;
				TargetTicks = StartTicks + Val1 + Val2 * Val3;

				// Exit from the loop on termination or error
				if( TotBytesTransfered >= mPacketBufferSize || Result == 0 )
					break;
		
				// Wait until the time interval has elapsed
			while( CurTicks <= TargetTicks )
				QueryPerformanceCounter( ref CurTicks );

			}while( true );

			return TotBytesTransfered;
		}

		//****************************************************************
		//
		//****************************************************************

		public bool PacketReceivePacket( bool Sync )
		{
			int Result = 0;
			byte [] ReadBytes;
			//int i = 0;

			Result = SetEvent( mAdapter.ReadEvent );

			if( mAdapter.ReadTimeOut != -1 )
			{
				if( mAdapter.ReadTimeOut == 0 )
					Result = WaitForSingleObject( mAdapter.ReadEvent, INFINITE );
				else
					Result = WaitForSingleObject( mAdapter.ReadEvent, mAdapter.ReadTimeOut );

			}

			if( Result != mAdapter.ReadEvent )
			{
				mPacketErrorCode = Function.GetLastError();
				if( mPacketErrorCode > 0 )
					mPacketErrorMessage = Function.GetSystemErrorMessage( mPacketErrorCode );
				Function.SetLastError( 0 );

			}
			

			Result = ReadFile(  mAdapter.hFile, 
								mPacket.Buffer, 
								mPacket.Length, 
								ref mPacket.ulBytesReceived,
								0);

			mPacketErrorCode = Function.GetLastError();
			if( mPacketErrorCode > 0 )
				mPacketErrorMessage = Function.GetSystemErrorMessage( mPacketErrorCode );
			Function.SetLastError( 0 );

			if( mPacket.ulBytesReceived > 0 )
			{
				ReadBytes = new byte[ (int) mPacket.ulBytesReceived ];
				Marshal.Copy( ( IntPtr ) mPacket.Buffer , ReadBytes , 0 , (int) mPacket.ulBytesReceived );
				mCapturedPacketArray.Add ( ReadBytes );
			}

			if( Result == 0 ) return false;


			return true;
		}

		//****************************************************************
		//
		//****************************************************************

		public bool PacketSetHwFilter( uint Filter )
		{
			SetOid( NtddNDish.OID_GEN_CURRENT_PACKET_FILTER, Filter );

			return true;
		}

		//****************************************************************
		//
		//****************************************************************

		public bool PacketGetNetInfoEx( string AdapterName, ref int NEntries )
		{
			RegistryKey SystemKey;
			RegistryKey InterfaceKey;
			RegistryKey ParametersKey;
			RegistryKey TcpIpKey;
			RegistryKey UnderTcpKey;
			char [] StrArr = new char[1024+1];//WCHAR	String[1024+1];
			int DHCPEnabled = 0;
			int ZeroBroadcast = 0;
			string StrAdapterName = AdapterName;

			StrAdapterName = StrAdapterName.Replace("Device" , "" );
			StrAdapterName = StrAdapterName.Replace("\\" , "" );
			StrAdapterName = StrAdapterName.Replace("NPF_" , "" );

			UnderTcpKey = Registry.LocalMachine.OpenSubKey("SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces");
			if( UnderTcpKey != null )
			{
				TcpIpKey = UnderTcpKey.OpenSubKey( StrAdapterName );
				if( TcpIpKey == null )
				{
					UnderTcpKey.Close();
					goto fail;
				}
			}
			else
			{
				// Query the registry key with the interface's adresses
				SystemKey = Registry.LocalMachine.OpenSubKey("SYSTEM\\CurrentControlSet\\Services");
				if( SystemKey == null )
					goto fail;

				InterfaceKey = SystemKey.OpenSubKey( StrAdapterName );
				if( InterfaceKey == null )
				{
					SystemKey.Close();
					goto fail;
				}

				SystemKey.Close();
				ParametersKey = InterfaceKey.OpenSubKey("Parameters");
				if( ParametersKey == null )
				{
					InterfaceKey.Close();
					goto fail;
				}
	
				InterfaceKey.Close();
				TcpIpKey = ParametersKey.OpenSubKey("TcpIp");
				if( TcpIpKey == null )
				{
					ParametersKey.Close();
					goto fail;
				}
				ParametersKey.Close();
			}

			object oUseZeroBroadcast = TcpIpKey.GetValue("UseZeroBroadcast");
			if( oUseZeroBroadcast == null )
				ZeroBroadcast = 0;
			else
				ZeroBroadcast = (int) oUseZeroBroadcast;
	
			object oEnableDHCP = TcpIpKey.GetValue("EnableDHCP");
			if( oEnableDHCP == null )
				DHCPEnabled = 0;
			else
				DHCPEnabled = (int) oEnableDHCP;