//-----------------------------------------------------------------------------
//
//
//  File: b64octet.cpp 
//
//  Description:  Implementation of Base64 encoding stream designed for use
//      with UTF7 encoding.
//
//  Author: Mike Swafford (MikeSwa)
//
//  History:
//      10/21/98 - MikeSwa Created 
//
//  Copyright (C) 1998 Microsoft Corporation
//
//-----------------------------------------------------------------------------

#include "precomp.h"

//Alphabet for BASE64 encoding as defined in RFC1421 and RFC1521
CHAR g_rgchBase64[64] = 
{
    'A','B','C','D','E','F','G','H','I','J','K','L','M',
    'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
    'a','b','c','d','e','f','g','h','i','j','k','l','m',
    'n','o','p','q','r','s','t','u','v','w','x','y','z',
    '0','1','2','3','4','5','6','7','8','9','+','/'
};

const DWORD BASE64_OCTET_STATE_0_BITS   = 0;
const DWORD BASE64_OCTET_STATE_2_BITS   = 1;
const DWORD BASE64_OCTET_STATE_4_BITS   = 2;
const DWORD BASE64_NUM_STATES           = 3;

//---[ CBase64OctetStream::CBase64OctetStream ]--------------------------------
//
//
//  Description: 
//      Default contructor for CBase64OctetStream
//  Parameters:
//      -
//  Returns:
//      -
//  History:
//      10/21/98 - MikeSwa Created 
//
//-----------------------------------------------------------------------------
CBase64OctetStream::CBase64OctetStream()
{
    m_dwSignature = BASE64_OCTET_SIG;
    m_dwCurrentState = BASE64_OCTET_STATE_0_BITS;
    m_bCurrentLeftOver = 0;
}

//---[ CBase64OctetStream::NextState ]------------------------------------------
//
//
//  Description: 
//      Moves the internal state machine to the next state
//  Parameters:
//      -
//  Returns:
//      -
//  History:
//      10/21/98 - MikeSwa Created 
//
//-----------------------------------------------------------------------------
void CBase64OctetStream::NextState()
{
    m_dwCurrentState++;
    if (BASE64_NUM_STATES == m_dwCurrentState)
    {
        m_dwCurrentState = BASE64_OCTET_STATE_0_BITS;
        m_bCurrentLeftOver = 0;
    }
}

//---[ CBase64OctetStream::ResetState ]----------------------------------------
//
//
//  Description: 
//      Resets the internal state machine
//  Parameters:
//      -
//  Returns:
//      -
//  History:
//      10/21/98 - MikeSwa Created 
//
//-----------------------------------------------------------------------------
void CBase64OctetStream::ResetState()
{
    m_dwCurrentState = BASE64_OCTET_STATE_0_BITS;
    m_bCurrentLeftOver = 0;
}

//---[ CBase64OctetStream::fProcessWideChar ]----------------------------------
//
//
//  Description: 
//      Processes a single wide character and stores the results in its 
//      buffer.  It will also ensure that there is always enough room to 
//      safely calll TerminateStream.
//  Parameters:
//      IN      wch     UNICODE character to process
//  Returns:
//      TRUE    if there is enough room in the buffer to convert this char
//      FALSE   if there is not enough room to conver this char safely
//  History:
//      10/21/98 - MikeSwa Created 
//
//-----------------------------------------------------------------------------
BOOL CBase64OctetStream::fProcessWideChar(WCHAR wch)
{
    BYTE   bHigh = HIBYTE(wch);
    BYTE   bLow  = LOBYTE(wch);
    //At most... a single WCHAR will generate 3 base64 characters evenly or 2
    //base64 characters plus a remainder which can be expanded to 
    //3 more characters (with trailing "==")
    if (m_CharBuffer.cSpaceLeft() < 5)
        return FALSE;

    //We know we have enough room to safely convert this character.... we 
    //will _VERIFY all PushChar's.

    //Loop through bytes in WCHAR
    _VERIFY(fProcessSingleByte(bHigh));
    _VERIFY(fProcessSingleByte(bLow));
    return TRUE;
}

//---[ CBase64OctetStream::fProcessSingleByte ]--------------------------------
//
//
//  Description: 
//      Does the actual work of converting a single byte to the appropriate 
//      base64 char(s).  Also keeps track of state.
//  Parameters:
//      IN b   BYTE to convert
//  Returns:
//      TRUE if there is enough room for the conversion
//      FALSE otherwise
//  History:
//      10/21/98 - MikeSwa Created 
//
//-----------------------------------------------------------------------------
BOOL CBase64OctetStream::fProcessSingleByte(BYTE b)
{
    const BYTE BASE64_MASK = 0x3F; //can only use 6 bits in Base64

    BOOL fRet = TRUE;
    if (m_CharBuffer.fIsFull())
        return FALSE;

    switch (m_dwCurrentState)
    {
        case BASE64_OCTET_STATE_0_BITS:
            //There were no bits left from previous state
            m_bCurrentLeftOver = b & 0x03; //there will now be 2 bits left over
            m_bCurrentLeftOver <<= 4; //shift to MSB in six bits
            _VERIFY(m_CharBuffer.fPushChar(g_rgchBase64[BASE64_MASK & (b >> 2)]));
            NextState();
            break;
        case BASE64_OCTET_STATE_2_BITS:
            //There were 2 bits left from previous state.. 
            m_bCurrentLeftOver += (0x0F & (b >> 4));
            _VERIFY(m_CharBuffer.fPushChar(g_rgchBase64[BASE64_MASK & m_bCurrentLeftOver]));

            //we will leave 4 low bits over
            m_bCurrentLeftOver = 0x0F & b;
            m_bCurrentLeftOver <<= 2; //shift to MSB is six bit grouping
            NextState();
            break;
        case BASE64_OCTET_STATE_4_BITS:
            //There were 4 bits left over
            if (m_CharBuffer.cSpaceLeft() < 2)
            {
                //There is not enough room for both characters we would push...
                //so don't process byte at all. 
                //Do not move to the next state... do not collection $200.
                fRet = FALSE;
            }
            else
            {
                m_bCurrentLeftOver += (0x03 & (b >> 6));
                _VERIFY(m_CharBuffer.fPushChar(g_rgchBase64[BASE64_MASK & m_bCurrentLeftOver]));
                m_bCurrentLeftOver = 0;
                _VERIFY(m_CharBuffer.fPushChar(g_rgchBase64[BASE64_MASK & b]));
                NextState();
            }
            break;
        default:
            _ASSERT(0 && "Invalid State");
    }
    return fRet;
}

//---[ CBase64OctetStream::cTerminateStream ]----------------------------------
//
//
//  Description: 
//      Used to signal the termination of the current stream.  Resets the 
//      state as performs any padding necessary
//  Parameters:
//      IN  fUTF7Encoded    TRUE if the stream is UTF7 encoded (does not 
//                          require '=' padding).
//  Returns:
//      TRUE if there is anything left in the buffer.
//      FALSE if there are no characters left to convert
//  History:
//      10/21/98 - MikeSwa Created 
//
//-----------------------------------------------------------------------------
BOOL CBase64OctetStream::fTerminateStream(BOOL fUTF7Encoded)
{
    if (BASE64_OCTET_STATE_0_BITS != m_dwCurrentState)
    {
        //There should always be space left to do this
        _VERIFY(m_CharBuffer.fPushChar(g_rgchBase64[m_bCurrentLeftOver]));
        if (!fUTF7Encoded)
        {
            switch(m_dwCurrentState)
            {
                case BASE64_OCTET_STATE_2_BITS:
                    //There are 2 bits in this byte we did not use... which 
                    //means that there are 2 more base64 chars to fill 24 bits
                    //+ => Used bits
                    //- => Unused (but parsed) bits
                    //? => Unseed bits to fill out to 24 bits
                    //++++ ++-- ???? ???? ???? ????
                    _VERIFY(m_CharBuffer.fPushChar('='));
                    _VERIFY(m_CharBuffer.fPushChar('='));
                    break;
                case BASE64_OCTET_STATE_4_BITS:
                    //In these chase there is only 1 extra base64 char needed
                    //++++ ++++ ++++ ---- ???? ????
                    _VERIFY(m_CharBuffer.fPushChar('='));
                    break;
            }
        }
    }
    ResetState();
    return (!m_CharBuffer.fIsEmpty());
}

//---[ CBase64OctetStream::fNextValidChar ]------------------------------------
//
//
//  Description: 
//      Iterates over buffered converted characters
//  Parameters:
//      OUT pch     Next buffer char
//  Returns:
//      TRUE    If there is a character to get
//      FALSE   If there were no characters to get
//  History:
//      10/21/98 - MikeSwa Created 
//
//-----------------------------------------------------------------------------
BOOL CBase64OctetStream::fNextValidChar(CHAR *pch)
{
    _ASSERT(pch);
    return m_CharBuffer.fPopChar(pch);
}