//==========================================================================
// PRODUCT: RusRoute - MaaSoftware routing firewall software driver
// (C) Copyright Moiseenko A.A., MaaSoftware, 2003-2008. All Rights Reserved.
// http://www.maasoftware.ru       http://www.maasoftware.com
// http://www.rusroute.ru          http://www.rusroute.com
// support@maasoftware.ru
//==========================================================================
// FILE:       Common.h
//
// AUTHOR:     Andrey A. Moiseenko
//
// OVERVIEW    Common classes.
// ~~~~~~~~
// DATE:       26.10.2003
//==========================================================================

#include "perm.h"
#include "temp.h"

//---------------------------------------------------------------------------
SimpleString::SimpleString ( const SimpleString & That )
:    m_Str ( NULL ),
     m_Size ( 0 )
{
     *this = That;
}
SimpleString::SimpleString ( const MY_TCHAR * str )
{
     int len = 0;
     while ( str [ len ] ) len++;
     len++;
     m_Size = 0;
     m_Str = new MY_TCHAR [ len ];
     if   ( m_Str )
     {
          Memcpy ( m_Str, str, m_Size = len * sizeof ( MY_TCHAR ) );
     }
}
SimpleString::operator const MY_TCHAR * () const
{
     return ( const MY_TCHAR * ) m_Str;
}
SimpleString & SimpleString::operator = ( const SimpleString & That )
{
     delete [] m_Str;
     m_Size = 0;
     m_Str = new MY_TCHAR [ That.m_Size ];
     if   ( m_Str )
     {
          Memcpy ( m_Str, That.m_Str, m_Size = That.m_Size );
     }
     return *this;
}
const MY_TCHAR * SimpleString::operator = ( const MY_TCHAR * str )
{
     delete [] m_Str;
     m_Str = NULL;
     m_Size = 0;
     if   ( str )
     {
          int len = 0;
          while ( str [ len ] ) len++;
          len++;
          m_Str = new MY_TCHAR [ len ];
          if   ( m_Str )
          {
               Memcpy ( m_Str, str, m_Size = len * sizeof ( MY_TCHAR ) );
          }
     }
     return m_Str;
}
unsigned long SimpleString::Hash () const
{
     return m_Str ? CMaaStandardHashFunction ( m_Str, m_Size ) : 0;
}
BOOL SimpleString::operator == ( const MY_TCHAR * str ) const
{
     if   ( !m_Str || !str )
     {
          INT3;
          return m_Str == NULL && str == NULL;
     }
     for  ( int i = 0; m_Str [ i ] != 0 || str [ i ] != 0; i++ )
     {
          if   ( m_Str [ i ] != str [ i ] )
          {
               return FALSE;
          }
     }
     return TRUE;
}
#ifdef _WINNT
SimpleString::SimpleString ( NDIS_STRING str )
{
     m_Str = NULL;
     m_Size = 0;

     int len = str.Length / 2;
     //if   (len > str.MaximumLength / 2)
     //{
     //     len = str.MaximumLength / 2;
     //}
     m_Str = new MY_TCHAR [ len + 1 ];
     if   ( m_Str )
     {
          m_Str [ len ] = 0;
          for  ( int i = 0; i < len; i++ ) m_Str [ i ] = str.Buffer [ i ];
          m_Size = ( len + 1 ) * sizeof ( MY_TCHAR );
     }
}
SimpleString::SimpleString ( const char * str )
{
     m_Str = NULL;
     m_Size = 0;

     if   ( !str )
     {
          return;
     }
     int len = Strlen ( str ) + 1;
     m_Str = new MY_TCHAR [ len ];
     if   ( m_Str )
     {
          for  ( int i = 0; i < len; i++ ) m_Str [ i ] = str [ i ];
          m_Size = len * sizeof ( MY_TCHAR );
     }
}
const char * SimpleString::const_char_ptr () const
{
     static char txt [ 256 ];
     txt [ 0 ] = txt [ sizeof ( txt ) - 1 ] = 0;
     for  ( int i = 0; i < m_Size && i / 2 < sizeof ( txt ) - 1; i += 2 )
     {
          txt [ i / 2 ] = ( char ) m_Str [ i / 2 ];
     }
     return txt;
}
#else
const char * SimpleString::const_char_ptr () const
{
     return m_Str;
}
#endif
//---------------------------------------------------------------------------

//------------------------------------------------------------------------------
void CDrvEthFrame::GetInfo ( CDrvPacket & Packet )
{
     Packet.m_FrameType = DRV_FRAME_ETH;
     Packet.m_HeaderLen = EthernetHeaderLength; //=14
     if   ( Packet.m_Length >= Packet.m_HeaderLen )
     {
          Packet.m_Status   &= DRV_RECEIVE;
          Packet.m_Protocol = ntohs ( ( ( CDrvEthHdr * ) Packet.m_pHeader ) -> TypeCode );

          if   ( ( ( CDrvEthHdr * ) Packet.m_pHeader ) -> SourceAddr.IsBroadcast () )
          {
               Packet.m_Status |= DRV_PACKET_SOURCE_BROADCAST;
          }
          if   ( ( ( CDrvEthHdr * ) Packet.m_pHeader ) -> DestinAddr.IsBroadcast () )
          {
               Packet.m_Status |= DRV_PACKET_DESTIN_BROADCAST;
          }
          if   (Packet.m_Length < 0 || Packet.m_Length > 1514)
          {
               Packet.m_Length = Packet.m_Length < 0 ? 0 : 1514;
               Packet.m_ErrorCode = eBadLengthOfPacket;
               Packet.m_Status |= DRV_PACKET_ERROR;
          }
     }
     else
     {
          Packet.m_ErrorCode = eTooSmallPacket;
          Packet.m_Status |= DRV_PACKET_ERROR;
     }
}
//---------------------------------------------------------------------------
int CDrvEthFrame::GetProtocol ( void * Header )
{
     return ntohs ( ( ( CDrvEthHdr * ) Header ) -> TypeCode );
}
//---------------------------------------------------------------------------
void CDrvEthFrame::GetDestinMac ( const void * Hdr, void * Mac )
{
     * ( CDrvMac6 * ) Mac = (( CDrvEthHdr * ) Hdr ) -> DestinAddr;
}
//---------------------------------------------------------------------------
void CDrvEthFrame::GetSourceMac ( const void * Hdr, void * Mac )
{
     * ( CDrvMac6 * ) Mac = (( CDrvEthHdr * ) Hdr ) -> SourceAddr;
}
//---------------------------------------------------------------------------
void CDrvEthFrame::SetDestinMac ( void * Hdr, const void * Mac )
{
     (( CDrvEthHdr * ) Hdr ) -> DestinAddr = * ( CDrvMac6 * ) Mac;
}
//---------------------------------------------------------------------------
void CDrvEthFrame::SetSourceMac ( void * Hdr, const void * Mac )
{
     (( CDrvEthHdr * ) Hdr ) -> SourceAddr = * ( CDrvMac6 * ) Mac;
}
//------------------------------------------------------------------------------
int CDrvEthFrame::BuildHeader ( void * Hdr, int Protocol )
{
     ( ( CDrvEthHdr * ) Hdr ) -> TypeCode = htons ( Protocol );
     return EthernetHeaderLength;
}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
void CDrvFddiFrame::GetInfo ( CDrvPacket & Packet )
{
     Packet.m_FrameType = DRV_FRAME_FDDI;
     Packet.m_HeaderLen = FddiHeaderLength;
     if   ( Packet.m_Length >= Packet.m_HeaderLen )
     {
          Packet.m_Status   &= DRV_RECEIVE;
          Packet.m_Protocol = ntohs ( ( ( CDrvFddiHdr * ) Packet.m_pHeader ) -> TypeCode );

          if   ( ( ( CDrvFddiHdr * ) Packet.m_pHeader ) -> SourceAddr.IsBroadcast () )
          {
               Packet.m_Status |= DRV_PACKET_SOURCE_BROADCAST;
          }
          if   ( ( ( CDrvFddiHdr * ) Packet.m_pHeader ) -> DestinAddr.IsBroadcast () )
          {
               Packet.m_Status |= DRV_PACKET_DESTIN_BROADCAST;
          }
     }
     else
     {
          Packet.m_ErrorCode = eTooSmallPacket;
          Packet.m_Status |= DRV_PACKET_ERROR;
     }
}
//---------------------------------------------------------------------------
int CDrvFddiFrame::GetProtocol ( void * Header )
{
     return ntohs ( (( CDrvFddiHdr * ) Header ) -> TypeCode );
}
//---------------------------------------------------------------------------
void CDrvFddiFrame::GetDestinMac ( const void * Hdr, void * Mac )
{
     * ( CDrvMac6 * ) Mac = (( CDrvFddiHdr * ) Hdr ) -> DestinAddr;
}
//---------------------------------------------------------------------------
void CDrvFddiFrame::GetSourceMac ( const void * Hdr, void * Mac )
{
     * ( CDrvMac6 * ) Mac = (( CDrvFddiHdr * ) Hdr ) -> SourceAddr;
}
//---------------------------------------------------------------------------
void CDrvFddiFrame::SetDestinMac ( void * Hdr, const void * Mac )
{
     (( CDrvFddiHdr * ) Hdr ) -> DestinAddr = * ( CDrvMac6 * ) Mac;
}
//---------------------------------------------------------------------------
void CDrvFddiFrame::SetSourceMac ( void * Hdr, const void * Mac )
{
     (( CDrvFddiHdr * ) Hdr ) -> SourceAddr = * ( CDrvMac6 * ) Mac;
}
//------------------------------------------------------------------------------
int CDrvFddiFrame::BuildHeader ( void * Hdr, int Protocol )
{
     CDrvFddiHdr & h = * ( CDrvFddiHdr * ) Hdr;
     h.TypeCode = htons ( Protocol );
     h.FC = 0;                         // subst right FC
     Memzero ( h.xz, sizeof ( h.xz ) );  // subst right xz
     return FddiHeaderLength;
}
//struct CDrvFddiHdr
//{
//     char  FC;
//     CDrvMac6 DestinAddr, SourceAddr;
//     char  xz [ 6 ];
//     short TypeCode; // 0800 = DOD IP - Department of Defense IP
//
//} GCC_PACKED;
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
void CDrvTokenRingFrame::GetInfo ( CDrvPacket & Packet )
{
     Packet.m_FrameType = DRV_FRAME_TOKEN_RING;
     Packet.m_HeaderLen = TokenRingHeaderLength;

     if   ( Packet.m_Length >= Packet.m_HeaderLen )
     {
          Packet.m_Status   &= DRV_RECEIVE;
          Packet.m_Protocol = ntohs ( ( ( CDrvTokenRingHdr * ) Packet.m_pHeader ) -> TypeCode );

          if   ( ( ( CDrvTokenRingHdr * ) Packet.m_pHeader ) -> SourceAddr.IsBroadcast () )
          {
               Packet.m_Status |= DRV_PACKET_SOURCE_BROADCAST;
          }
          if   ( ( ( CDrvTokenRingHdr * ) Packet.m_pHeader ) -> DestinAddr.IsBroadcast () )
          {
               Packet.m_Status |= DRV_PACKET_DESTIN_BROADCAST;
          }
     }
     else
     {
          Packet.m_ErrorCode = eTooSmallPacket;
          Packet.m_Status |= DRV_PACKET_ERROR;
     }
}
//---------------------------------------------------------------------------
int CDrvTokenRingFrame::GetProtocol ( void * Header )
{
     return ntohs ( (( CDrvTokenRingHdr * ) Header ) -> TypeCode );
}
//---------------------------------------------------------------------------
void CDrvTokenRingFrame::GetDestinMac ( const void * Hdr, void * Mac )
{
     * ( CDrvMac6 * ) Mac = (( CDrvTokenRingHdr * ) Hdr ) -> DestinAddr;
}
//---------------------------------------------------------------------------
void CDrvTokenRingFrame::GetSourceMac ( const void * Hdr, void * Mac )
{
     * ( CDrvMac6 * ) Mac = (( CDrvTokenRingHdr * ) Hdr ) -> SourceAddr;
}
//---------------------------------------------------------------------------
void CDrvTokenRingFrame::SetDestinMac ( void * Hdr, const void * Mac )
{
     (( CDrvTokenRingHdr * ) Hdr ) -> DestinAddr = * ( CDrvMac6 * ) Mac;
}
//---------------------------------------------------------------------------
void CDrvTokenRingFrame::SetSourceMac ( void * Hdr, const void * Mac )
{
     (( CDrvTokenRingHdr * ) Hdr ) -> SourceAddr = * ( CDrvMac6 * ) Mac;
}
//------------------------------------------------------------------------------
int CDrvTokenRingFrame::BuildHeader ( void * Hdr, int Protocol )
{
     CDrvTokenRingHdr & h = * ( CDrvTokenRingHdr * ) Hdr;
     h.TypeCode = htons ( Protocol );
     h.AC = 0;                         // subst right AC
     h.FC = 0;                         // subst right FC
     Memzero ( h.xz, sizeof ( h.xz ) );  // subst right xz
     return TokenRingHeaderLength;
}
//struct CDrvTokenRingHdr
//{
//     char  AC;
//     char  FC;
//     CDrvMac6 DestinAddr, SourceAddr;
//     char  xz [ 6 ];
//     short TypeCode; // 0800 = DOD IP - Department of Defense IP
//
//} GCC_PACKED;
//------------------------------------------------------------------------------


/*
//---------------------------------------------------------------------------
void Impossible ()
{
     _asm
     {
          mov  eax, -1
          mov  eax, [ eax ] // Making exeption
     }
}
//---------------------------------------------------------------------------
*/


//------------------------------------------------------------------------------
void CDrvPacket::Init ( CDrvFrame & Frame )
{
     //m_FrameType = FrameType;
     //m_Status   &= DRV_RECEIVE;
     m_ErrorCode = eNoErrors;

     m_pHeader   = GetPtr ( m_pPacket );
     m_Length    = GetLength ( m_pPacket );

     m_Frame = & Frame;
     Frame.GetInfo ( * this );
}
//------------------------------------------------------------------------------