myfunctions.cs

一个抓包工具

		{
			return DecodeBitField( (ushort) Value , Mask , ValueText );
		}

		public static string DecodeBitField( short Value , int Mask , string [] ValueText )
		{
			return DecodeBitField( (ushort) Value , (uint) Mask , ValueText );
		}

		public static string DecodeBitField( ushort Value , int Mask , string [] ValueText )
		{
			return DecodeBitField( Value , (uint) Mask , ValueText );
		}


		public static string DecodeBitField( uint Value , uint Mask , string [] ValueText )
		{
			byte [] MyArray;
			int GroupLength = 0;
			uint b = 0, mb = 0, tb = 0;
			string ReturnStr = "";
			int iii = 0;
			uint k = 0;
			byte [] BitArray;
			int ShiftCount = 0;

			GroupLength = 8;
			b = Value;
			mb = Mask;
			b &= mb;
			k = (uint) mb;
			while( ( k & 0x1 ) == 0 )
			{
				ShiftCount ++;
				k >>= 1;
			}
			BitArray = GetBytes( mb );
			MyArray = new byte[ GroupLength * 4 ];
			for( iii = 0; iii < MyArray.GetLength(0); iii ++ )
				MyArray[ iii  ] = 46;

			iii = 0;
			tb = mb;
			for( iii = 0; iii < 32; iii ++ )
			{
				if( BitArray[iii] == 1 )
				{
					tb = (uint) ( 1 << iii );
					if( ( tb & b ) > 0 ) 
						MyArray[ iii ] = (byte) 49;
						//MyArray[ MyArray.GetLength(0) - iii ] = (byte) 49;
					else
						MyArray[ iii ] = (byte) 48;
						//MyArray[ MyArray.GetLength(0) - iii ] = (byte) 48;
				}
			}

			k = 0;
			ReturnStr = "";
			for( iii = 0; iii < MyArray.GetLength(0); iii ++ )
			{
				if( k == 3 )
				{
					ReturnStr += (char) MyArray[ iii ] + " ";
					k = 0;
				}
				else
				{
					ReturnStr += (char) MyArray[ iii ];
					k ++;
				}
			}

			ReturnStr += "= " + b.ToString() + " ( " + ValueText[ b >> ShiftCount ] + " )";

			return ReturnStr;

		}

		public static string DecodeBitField( int Value , uint Mask , string [] ValueText )
		{
			return DecodeBitField( (uint) Value , Mask , ValueText );
		}

		public static string DecodeBitField( int Value , int Mask , string [] ValueText )
		{
			return DecodeBitField( (uint) Value , (uint) Mask , ValueText );
		}

		public static string DecodeBitField( uint Value , int Mask , string [] ValueText )
		{
			return DecodeBitField( Value , (uint) Mask , ValueText );
		}

		public static string DecodeBitField( ulong Value , ulong Mask , string [] ValueText )
		{
			byte [] MyArray;
			int GroupLength = 0;
			ulong b = 0, mb = 0, tb = 0;
			string ReturnStr = "";
			int iii = 0;
			ulong k = 0;
			byte [] BitArray;
			int ShiftCount = 0;

			GroupLength = 16;
			b = Value;
			mb = Mask;
			b &= mb;
			k = (ulong) mb;
			while( ( k & 0x1 ) == 0 )
			{
				ShiftCount ++;
				k >>= 1;
			}
			BitArray = GetBytes( mb );
			MyArray = new byte[ GroupLength * 4 ];
			for( iii = 0; iii < MyArray.GetLength(0); iii ++ )
				MyArray[ iii  ] = 46;

			iii = 0;
			tb = mb;
			for( iii = 0; iii < 64; iii ++ )
			{
				if( BitArray[iii] == 1 )
				{
					tb = (ulong) ( 1 << iii );
					if( ( tb & b ) > 0 ) 
						MyArray[ iii ] = (byte) 49;
						//MyArray[ MyArray.GetLength(0) - iii ] = (byte) 49;
					else
						MyArray[ iii ] = (byte) 48;
						//MyArray[ MyArray.GetLength(0) - iii ] = (byte) 48;
				}
			}

			k = 0;
			ReturnStr = "";
			for( iii = 0; iii < MyArray.GetLength(0); iii ++ )
			{
				if( k == 3 )
				{
					ReturnStr += (char) MyArray[ iii ] + " ";
					k = 0;
				}
				else
				{
					ReturnStr += (char) MyArray[ iii ];
					k ++;
				}
			}

			ReturnStr += "= " + b.ToString() + " ( " + ValueText[ b >> ShiftCount ] + " )";

			return ReturnStr;

		}

		public static string DecodeBitField( long Value , ulong Mask , string [] ValueText )
		{
			return DecodeBitField( (ulong) Value , Mask , ValueText );
		}

		public static string DecodeBitField( long Value , long Mask , string [] ValueText )
		{
			return DecodeBitField( (ulong) Value , (ulong) Mask , ValueText );
		}

		public static string DecodeBitField( ulong Value , long Mask , string [] ValueText )
		{
			return DecodeBitField( Value , (ulong) Mask , ValueText );
		}

		public static short Swap( short s )
		{
			short b1 = 0, b2 = 0;
			short rs;

			b1 = (short) ( ( s >> 8 ) & 0x00ff );
			b2 = (short) ( ( s & 0x00ff ) << 8 );
			rs = (short) ( b1 + b2 );

			return rs;
		}

		public static ushort Swap( ushort us )
		{
			ushort b1 = 0, b2 = 0;
			ushort rus;

			b1 = (ushort) ( ( us >> 8 ) & 0x00ff );
			b2 = (ushort) ( ( us & 0x00ff ) << 8 );
			rus = (ushort) ( b1 + b2 );

			return rus;
		}

		public static int Swap( int i )
		{
			int b1 = 0, b2 = 0, b3 = 0, b4 = 0;
			int ri;

			b1 = ( i >> 24 ) & 0x000000ff;
			b2 = ( ( i >> 16 ) & 0x000000ff ) << 8;
			b3 = ( ( i >> 8 ) & 0x000000ff ) << 16;
			b4 = ( i & 0x000000ff ) << 24;

			ri = b1 + b2 + b3 + b4;

			return ri;
		}

		public static uint Swap( uint ui )
		{
			uint b1 = 0, b2 = 0, b3 = 0, b4 = 0;
			uint rui;

			b1 = ( ui >> 24 ) & 0x000000ff;
			b2 = ( ( ui >> 16 ) & 0x000000ff ) << 8;
			b3 = ( ( ui >> 8 ) & 0x000000ff ) << 16;
			b4 = ( ui & 0x000000ff ) << 24;

			rui = b1 + b2 + b3 + b4;

			return rui;
		}

		public static long Swap( long l )
		{
			long b1 = 0, b2 = 0, b3 = 0, b4 = 0;
			long b5 = 0, b6 = 0, b7 = 0, b8 = 0;
			long rl;

			b1 = ( ( l >> 56 ) & 0x00000000000000ff );
			b2 = ( ( l >> 48 ) & 0x00000000000000ff ) << 8;
			b3 = ( ( l >> 40 ) & 0x00000000000000ff ) << 16;
			b4 = ( ( l  >> 32 ) & 0x00000000000000ff ) << 24;
			b5 = ( ( l >> 24 ) & 0x00000000000000ff ) << 32;
			b6 = ( ( l >> 16 ) & 0x00000000000000ff ) << 40;
			b7 = ( ( l >> 8 ) & 0x00000000000000ff ) << 48;
			b8 = ( l & 0x00000000000000ff ) << 56;

			rl = b1 + b2 + b3 + b4 + b5 + b6 + b7 + b8;

			return rl;
		}

		public static ulong Swap( ulong ul )
		{
			ulong b1 = 0, b2 = 0, b3 = 0, b4 = 0;
			ulong b5 = 0, b6 = 0, b7 = 0, b8 = 0;
			ulong url;

			b1 = ( ( ul >> 56 ) & 0x00000000000000ff );
			b2 = ( ( ul >> 48 ) & 0x00000000000000ff ) << 8;
			b3 = ( ( ul >> 40 ) & 0x00000000000000ff ) << 16;
			b4 = ( ( ul  >> 32 ) & 0x00000000000000ff ) << 24;
			b5 = ( ( ul >> 24 ) & 0x00000000000000ff ) << 32;
			b6 = ( ( ul >> 16 ) & 0x00000000000000ff ) << 40;
			b7 = ( ( ul >> 8 ) & 0x00000000000000ff ) << 48;
			b8 = ( ul & 0x00000000000000ff ) << 56;

			url = b1 + b2 + b3 + b4 + b5 + b6 + b7 + b8;

			return url;
		}

		public static byte [] GetBytes( byte val )
		{
			byte [] retbyte = new byte[8];
			int i = 0;
			int tmp = ( (int) val ) & 0xff;

			for( i = 0; i < 8; i ++ )
			{
				if( ( ( tmp >> i ) & 0x1 ) > 0 ) retbyte[7-i] = 1;
				else retbyte[7-i] = 0;
			}

			return retbyte;
		}

		public static byte [] GetBytes( short val )
		{
			byte [] retbyte = new byte[16];
			int i = 0;
			int tmp = ( (int) val ) & 0xffff;

			for( i = 0; i < 16; i ++ )
			{
				if( ( ( tmp >> i ) & 0x1 ) > 0 ) retbyte[15-i] = 1;
				else retbyte[15-i] = 0;
			}

			return retbyte;
		}

		public static byte [] GetBytes( ushort val )
		{
			return GetBytes( (short) val );
		}

		public static byte [] GetBytes( int val )
		{
			byte [] retbyte = new byte[32];
			int i = 0;
			int tmp = (int) ( val & 0xffffffff );

			for( i = 0; i < 32; i ++ )
			{
				if( ( ( tmp >> i ) & 0x1 ) > 0 ) retbyte[31-i] = 1;
				else retbyte[31-i] = 0;
			}

			return retbyte;
		}

		public static byte [] GetBytes( uint val )
		{
			return GetBytes( (int) val );
		}

		public static byte [] GetBytes( long val )
		{
			byte [] retbyte = new byte[64];
			int i = 0;
			long tmp = (long) ( ( (ulong) val ) & 0xffffffffffffffff );

			for( i = 0; i < 32; i ++ )
			{
				if( ( ( tmp >> i ) & 0x1 ) > 0 ) retbyte[63-i] = 1;
				else retbyte[63-i] = 0;
			}

			return retbyte;
		}


		public static byte [] GetBytes( ulong val )
		{
			return GetBytes( (long) val );
		}


		public static string GetMACAddress( byte [] PacketData , ref int Index )
		{
			string Tmp = "";
			int i = 0;

			for( i = 0; i < 5; i ++ )
			{
				Tmp += PacketData[ Index ++ ].ToString("x02") + ":";
			}

			Tmp += PacketData[ Index ++ ].ToString("x02");

			return Tmp;
		}


		public static void HighlightText( RichTextBox Rtx , TreeNode MNode  )
		{
			int i = 0;
			int StartX = 0, EndX = 0;
			int StartY = 0, EndY = 0;
			int [] intArray;

			Rtx.SelectionStart = 0;
			Rtx.SelectionLength = Rtx.Text.Length;
			Rtx.SelectionColor = System.Drawing.Color.Black;

			try
			{
				intArray = ( int [] ) MNode.Tag;
				if( intArray == null ) return;
			}
			catch
			{
				return;
			}


			for( i = 2; i < intArray.Length; i += 4 )
			{
				StartX = intArray[ i ];
				EndX = intArray[ i + 1 ];
				StartY = intArray[ i + 2 ];
				EndY = intArray[ i + 3 ];

				Rtx.SelectionStart = StartX;
				Rtx.SelectionLength = EndX;
				Rtx.SelectionColor = System.Drawing.Color.Blue;

				Rtx.SelectionStart = StartY;
				Rtx.SelectionLength = EndY;
				Rtx.SelectionColor = System.Drawing.Color.Red;
			}

		}


		public static void AddNodeToTheList( TreeNode mNode , ref ArrayList aList )
		{
			TreeNode PNode;
			int i = 0;

			for( i = 0; i < mNode.Nodes.Count; i ++ )
			{
				PNode = mNode.Nodes[ i ];
				aList.Add( PNode );
				if( PNode.Nodes.Count > 0 )
					AddNodeToTheList( PNode , ref aList );
			}

		}

		public static void ReverseHighlightText( RichTextBox Rtx , TreeView Tnc , System.Drawing.Point Pt  )
		{
			int i = 0;
			TreeNode PNode = null;
			int CharIndex = 0;
			int [] intArray;
			int ModeX = 0, ModeY = 0;
			ArrayList aList = new ArrayList();

			CharIndex = Rtx.GetCharIndexFromPosition( Pt );

			if( CharIndex < 167 ) return;

			ModeX = CharIndex / 78;
			ModeY = CharIndex - ( ModeX * 78 );
			ModeY -= 11;
			if( ModeY > 48 )
			{
				ModeY -= 48;
				CharIndex = ModeX * 78 + 11 + ModeY * 3 - 1;
			}

			for( i = 1; i < Tnc.Nodes.Count; i ++ )
			{
				PNode = Tnc.Nodes[ i ];
				aList.Add( PNode );
				if( PNode.Nodes.Count > 0 )
					AddNodeToTheList( PNode , ref aList );
			}

			for( i = 0; i < aList.Count; i ++ )
			{
				PNode = ( TreeNode ) aList[ i ];

				try
				{
					intArray = ( int [] ) PNode.Tag;
					
					if( ( CharIndex >= intArray[2] ) && ( CharIndex <= ( intArray[ intArray.Length - 4 ] + intArray[intArray.Length - 3 ] ) ) && ( PNode.Nodes.Count == 0 ) )
					{
						Tnc.SelectedNode = PNode;
						HighlightText( Rtx , PNode );
						return;
					}
				}
				catch( Exception Ex )
				{	MessageBox.Show( ReturnErrorMessage( Ex ) );
					return; }
			}

		}


		public static int [] FindHighlightPos( int SPos , int SLen )
		{
			int FieldX = 0, FieldY = 0;
			int i = 0;
			int Val = 0;
			int StartX = 0, EndX = 0;
			int StartY = 0, EndY = 0;
			int ModeX = 0, ModeY = 0;
			int ModeXX = 0, ModeYY = 0;
			int CurrentIndex = 0;
			ArrayList aList = new ArrayList();
			int [] ReturnArray;


			FieldX = SPos;
			FieldY = SLen;

			aList.Add( SPos );
			aList.Add( SLen );

			ModeX = FieldX / 16;
			ModeY = FieldX  - ( ModeX * 16 );
			
			StartX = 166 + 78 * ModeX + ModeY * 3;
			StartY = 216 + 78 * ModeX + ModeY;

			CurrentIndex = ModeX;

			Val = ModeY + FieldY;

			if( Val <= 16 )
			{
				EndX = FieldY * 3;
				EndY = FieldY;

				aList.Add( StartX );
				aList.Add( EndX );
				aList.Add( StartY );
				aList.Add( EndY );

			}
			else
			{
				Val = 16 - ModeY;
				FieldY -= Val;
				EndX = Val * 3;
				EndY = Val;

				aList.Add( StartX );
				aList.Add( EndX );
				aList.Add( StartY );
				aList.Add( EndY );

				CurrentIndex ++;

				ModeXX = FieldY / 16;
				ModeYY = FieldY - ( ModeXX * 16 );
				
				for