packet32h.cs

一个抓包工具

			byte [] MyData = new byte[1032];
			int Result;
			int Size1 = 12 - 1 + MyData.GetLength(0);
			int Size2 = 12 - 1 + MyData.GetLength(0);
			PPACKET_OID_DATA mpData;

			mpData.Oid = Oid;
			mpData.Data = Function.AddressOf( MyData );
			mpData.Length = MyData.GetLength(0);

			Result = DeviceIoControl( mAdapter.hFile ,
				pBIOCQUERYOID ,
				ref mpData ,
				Size1 ,
				MyData ,
				Size2 ,
				ref BytesReturned ,
				0);

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

			int index = 4;
			int Size = (int) Function.Get4Bytes( MyData , ref index , 1 );
			mPacketOidData.Oid = Oid;
			mPacketOidData.Length = Size;

			for( i = 0; i < 1024; i ++ )
				mPacketOidData.Data[i] = MyData[ 8 + i ];

			return true;
		}

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

		public string GetOidStr( uint Oid )
		{
			string Tmp = "";

			if( !GetOid( Oid ) ) return "";
			if( mPacketOidData.Data[1] != 0 )
				Tmp = Encoding.ASCII.GetString( mPacketOidData.Data , 0 , mPacketOidData.Length );
			else
				Tmp = Encoding.Unicode.GetString( mPacketOidData.Data , 0 , mPacketOidData.Length );

			return Tmp;
		}

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

		public byte GetOidByte( uint Oid )
		{
			byte Tmp = 0;

			if( !GetOid( Oid ) ) return 0;
			Tmp = mPacketOidData.Data[0];

			return Tmp;
		}

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

		public char GetOidChar( uint Oid )
		{
			char Tmp = (char) 0;

			if( !GetOid( Oid ) ) return (char) 0;
			Tmp = (char) mPacketOidData.Data[0];

			return Tmp;
		}

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

		public int GetOidInt( uint Oid )
		{ return ( ( int ) GetOidUInt( Oid ) ); }

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

		public uint GetOidUInt( uint Oid )
		{
			uint Tmp = 0;

			if( !GetOid( Oid ) ) return 0;
			Tmp = ( ( uint ) mPacketOidData.Data[3] ) << 24;
			Tmp += ( ( uint ) mPacketOidData.Data[2] ) << 16;
			Tmp += ( ( uint ) mPacketOidData.Data[1] ) << 8;
			Tmp += ( uint ) mPacketOidData.Data[0];

			return Tmp;
		}

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

		public long GetOidLong( uint Oid )
		{ return ( ( long ) GetOidULong( Oid ) ); }

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

		public ulong GetOidULong( uint Oid )
		{
			ulong Tmp = 0;

			if( !GetOid( Oid ) ) return 0;

			Tmp = ( ( ulong ) mPacketOidData.Data[7] ) << 56;
			Tmp += ( ( ulong ) mPacketOidData.Data[6] ) << 48;
			Tmp += ( ( ulong ) mPacketOidData.Data[5] ) << 40;
			Tmp += ( ( ulong ) mPacketOidData.Data[4] ) << 32;
			Tmp += ( ( ulong ) mPacketOidData.Data[3] ) << 24;
			Tmp += ( ( ulong ) mPacketOidData.Data[2] ) << 16;
			Tmp += ( ( ulong ) mPacketOidData.Data[1] ) << 8;
			Tmp += ( ulong ) mPacketOidData.Data[0];

			return Tmp;
		}

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

		unsafe public bool SetOid( uint Oid , object NewValue )
		{
			int BytesReturned = 0, i = 0;
			int Result;
			byte [] MyData = new byte[1024];
			int MyDataAddr = Function.AddressOf( MyData );
			int Size1 = MyData.GetLength(0);

			char * charPtr = ( char * ) MyDataAddr;
			byte * bytePtr = ( byte * ) MyDataAddr;
			short * shortPtr = ( short * ) MyDataAddr;
			ushort * ushortPtr = ( ushort * ) MyDataAddr;
			int * intPtr = ( int * ) MyDataAddr;
			uint * uintPtr = ( uint * ) MyDataAddr;
			long * longPtr = ( long * ) MyDataAddr;
			ulong * ulongPtr = ( ulong * ) MyDataAddr;
			uint * Ptr = ( uint *  ) MyDataAddr;

			*Ptr = Oid;
			if( NewValue.GetType().ToString() == "System.Byte" )
			{
				*( Ptr + 1 ) = 1;
				*( bytePtr + 8 ) = (byte) NewValue;
			}
			else if( NewValue.GetType().ToString() == "System.Char" )
			{
				*( Ptr + 1 ) = 1;
				*( charPtr + 8 ) = (char) NewValue;
			}
			else if( NewValue.GetType().ToString() == "System.Int16" )
			{
				*( Ptr + 1 ) = 2;
				*( shortPtr + 4 ) = (short) NewValue;
			}
			else if( NewValue.GetType().ToString() == "System.UInt16" )
			{
				*( Ptr + 1 ) = 2;
				*( ushortPtr + 4 ) = (ushort) NewValue;
			}
			else if( NewValue.GetType().ToString() == "System.Int32" )
			{
				*( Ptr + 1 ) = 4;
				*( intPtr + 2 ) = (int) NewValue;
			}
			else if( NewValue.GetType().ToString() == "System.UInt32" )
			{
				*( Ptr + 1 ) = 4;
				*( uintPtr + 2 ) = (uint) NewValue;
			}
			else if( NewValue.GetType().ToString() == "System.Int64" )
			{
				*( Ptr + 1 ) = 8;
				*( longPtr + 1 ) = (long) NewValue;
			}
			else if( NewValue.GetType().ToString() == "System.UInt64" )
			{
				*( Ptr + 1 ) = 8;
				*( ulongPtr + 1 ) = (ulong) NewValue;
			}
			else if( NewValue.GetType().ToString() == "System.String")
			{
				*( Ptr + 1 ) = (uint) ( (string) NewValue ).Length;
				for( i = 0; i < ( (string) NewValue ).Length; i ++ )
					MyData[ 8 + i ] = (byte) ( (string) NewValue )[i];
			}


			Result = DeviceIoControl( mAdapter.hFile ,
				pBIOCSETOID ,
				MyData ,
				Size1 ,
				MyData ,
				Size1 ,
				ref BytesReturned ,
				0);

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

			return true;
		}

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

		public bool PacketSetMaxLookAheadSize()
		{
			//set the size of the lookahead buffer to the maximum available by the the NIC driver
			uint uintValue2 = GetOidUInt( NtddNDish.OID_GEN_MAXIMUM_LOOKAHEAD );
			SetOid( NtddNDish.OID_GEN_CURRENT_LOOKAHEAD , uintValue2 );
			
			return true;
		}

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

		public int SendDeviceCommand( uint DvcCmd , int Value )
		{
			int BytesReturned = 0;
			int newValue = Value;

			return DeviceIoControl( mAdapter.hFile,
				DvcCmd,
				ref newValue,
				4,
				0,
				0,
				ref BytesReturned,
				0);
		}

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

		unsafe public int SendDeviceCommand( uint DvcCmd , BPF_PROGRAM Value )
		{
			int BytesReturned = 0;
			char * Addr;
			int Size;

			Addr = ( char * ) Value.bf_insns;
			Size = (int) ( Value.bf_len * sizeof( PBPF_INSN ) );

			return DeviceIoControl( mAdapter.hFile,
				DvcCmd,
				Addr,
				Size,
				0,
				0,
				ref BytesReturned,
				0);
		}

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

		public bool PacketSetMinToCopy( int nbytes )
		{
			int Result = 0;

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

			return true;

		}

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

		public bool PacketSetNumWrites( int nwrites )
		{
			int Result = 0;

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

			return true;
		}

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

		public bool PacketSetMode( int mode )
		{
			int Result = 0;

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

			return true;
		}

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

		public bool PacketSetReadTimeout( int timeout)
		{
			int Result = 0;
			int DriverTimeOut = -1;

			mAdapter.ReadTimeOut = timeout;
			Result = SendDeviceCommand( pBIOCSRTIMEOUT, DriverTimeOut );
			if( Result == 0 )
			{
				mPacketErrorCode = Function.GetLastError();
				if( mPacketErrorCode > 0 )
					mPacketErrorMessage = Function.GetSystemErrorMessage( mPacketErrorCode );
				Function.SetLastError( 0 );
				return false;
			}

			return true;
		}

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