请教高手：哪里有对附件进行编码的Base64源码？急啊！！！！！！

Question

如题

Answer 1

                    Table 1: The Base64 Alphabet     Value Encoding  Value Encoding  Value Encoding  Value Encoding
         0 A            17 R            34 i            51 z
         1 B            18 S            35 j            52 0
         2 C            19 T            36 k            53 1
         3 D            20 U            37 l            54 2
         4 E            21 V            38 m            55 3
         5 F            22 W            39 n            56 4
         6 G            23 X            40 o            57 5
         7 H            24 Y            41 p            58 6
         8 I            25 Z            42 q            59 7
         9 J            26 a            43 r            60 8
        10 K            27 b            44 s            61 9
        11 L            28 c            45 t            62 +
        12 M            29 d            46 u            63 /
        13 N            30 e            47 v
        14 O            31 f            48 w         (pad) =
        15 P            32 g            49 x
        16 Q            33 h            50 y按照这张表。自己写一个吧。
我以前只写过C#的。参考：rfc2045

Answer 2

// Codecs.cpp,v 4.3 2002/10/20 03:02:07 kitty Exp#include "ace/OS.h"
#include "ace/Codecs.h"
#include "ace/Log_Msg.h"const ACE_Byte ACE_Base64::alphabet_[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";const ACE_Byte ACE_Base64::pad_ = '=';int ACE_Base64::init_ = 0;int ACE_Base64::max_columns_ = 72;ACE_Byte ACE_Base64::decoder_[256];ACE_Byte ACE_Base64::member_[256];ACE_Byte*
ACE_Base64::encode (const ACE_Byte* input,
                    const size_t input_len,
                    size_t* output_len)
{
  if (!ACE_Base64::init_)
    ACE_Base64::init();  if (!input)
    return 0;  ACE_Byte* result = 0;  size_t length = ((input_len + 2) / 3) * 4;
  size_t num_lines = length / ACE_Base64::max_columns_ + 1;
  length += num_lines + 1;
  ACE_NEW_RETURN (result, ACE_Byte[length], 0);  int char_count = 0;
  int bits = 0;
  size_t pos = 0;
  int cols = 0;  for (size_t i = 0; i < input_len; ++i)
    {
      if (input[i] > 255) {
        delete[] result;
        return 0;
      }      bits += input[i];
      char_count++;      if (char_count == 3)
        {
          result[pos++] = ACE_Base64::alphabet_[bits >> 18];
          result[pos++] = ACE_Base64::alphabet_[(bits >> 12) & 0x3f];
          result[pos++] = ACE_Base64::alphabet_[(bits >> 6) & 0x3f];
          result[pos++] = ACE_Base64::alphabet_[bits & 0x3f];
          cols += 4;
          if (cols == ACE_Base64::max_columns_) {
            result[pos++] = '\n';
            cols = 0;
          }
          bits = 0;
          char_count = 0;
        }
      else
        {
          bits <<= 8;
        }
    }  if (char_count != 0)
    {
      bits <<= (16 - (8 * char_count));
      result[pos++] = ACE_Base64::alphabet_[bits >> 18];
      result[pos++] = ACE_Base64::alphabet_[(bits >> 12) & 0x3f];
      if (char_count == 1)
        {
          result[pos++] = pad_;
          result[pos++] = pad_;
        }
      else
        {
          result[pos++] = ACE_Base64::alphabet_[(bits >> 6) & 0x3f];
          result[pos++] = pad_;
        }
      if (cols > 0)
        result[pos++] = '\n';
    }
  result[pos] = 0;
  *output_len = pos;
  return result;
}size_t
ACE_Base64::length (const ACE_Byte* input)
{
  if (!ACE_Base64::init_)
    ACE_Base64::init();  ACE_Byte* ptr = ACE_const_cast (ACE_Byte*, input);
  while (*ptr != 0 &&
         (member_[*(ptr)] == 1 || *ptr == pad_
          || ACE_OS_String::ace_isspace (*ptr)))
    ptr++;
  size_t len = ptr - input;
  len = ((len + 3) / 4) * 3 + 1 ;
  return len;
}ACE_Byte*
ACE_Base64::decode (const ACE_Byte* input, size_t* output_len)
{
  if (!ACE_Base64::init_)
    ACE_Base64::init();  if (!input)
    return 0;  size_t result_len = ACE_Base64::length (input);
  ACE_Byte* result = 0;
  ACE_NEW_RETURN (result, ACE_Byte[result_len], 0);  ACE_Byte* ptr = ACE_const_cast (ACE_Byte*, input);
  while (*ptr != 0 &&
         (member_[*(ptr)] == 1 || *ptr == pad_
          || ACE_OS_String::ace_isspace (*ptr)))
    ptr++;
  size_t input_len = ptr - input;  int char_count = 0;
  int bits = 0;
  size_t pos = 0;  size_t i = 0;
  for (; i < input_len; ++i)
    {
      if (input[i] == pad_)
        break;
      if (input[i] > 255 || !ACE_Base64::member_[input[i]])
        continue;
      bits += decoder_[input[i]];
      char_count++;      if (char_count == 4)
        {
          result[pos++] = bits >> 16;
          result[pos++] = (bits >> 8) & 0xff;
          result[pos++] = bits & 0xff;
          bits = 0;
          char_count = 0;
        }
      else
        {
          bits <<= 6;
        }
    }  int errors = 0;
  if ( i == input_len)
    {
      if (char_count)
        {
          ACE_DEBUG ((LM_ERROR,
                      ACE_TEXT ("Decoding incomplete: atleast %d bits truncated\n"),
                      (4 - char_count) * 6));
          errors++;
        }
    }
  else
    {
      switch (char_count)
        {
        case 1:
          ACE_DEBUG ((LM_ERROR,
                      ACE_TEXT ("Decoding incomplete: atleast 2 bits missing\n")));
          errors++;
          break;
        case 2:
          result[pos++] = bits >> 10;
          break;
        case 3:
          result[pos++] = bits >> 16;
          result[pos++] = (bits >> 8) & 0xff;
          break;
        }
    }  if (errors)
    {
      delete[] result;
      return 0;
    }
  result[pos] = 0;
  *output_len = pos;
  return result;
}void
ACE_Base64::init ()
{
  if (!ACE_Base64::init_)
    {
      for (ACE_Byte i = 0; i < sizeof (ACE_Base64::alphabet_); ++i)
        {
          ACE_Base64::decoder_[ACE_Base64::alphabet_[i]] = i;
          ACE_Base64::member_[ACE_Base64::alphabet_[i]] = 1;
        }
      ACE_Base64::init_ = 1;
    }
  return;
}

Answer 3

typedef unsigned char ACE_Byte;
其他的自己看吧！

Answer 4

#include "stdafx.h"
#include "Base64Coder.h"//////////////// Macros / Locals /////////////////////////////////////static char Base64Digits[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
BOOL CBase64Coder::m_Init = FALSE;
char CBase64Coder::m_DecodeTable[256];#ifndef PAGESIZE
#define PAGESIZE 4096
#endif#ifndef ROUNDTOPAGE
#define ROUNDTOPAGE(a) (((a/4096)+1)*4096)
#endif////////////////// Implementation ////////////////////////////////////CBase64Coder::CBase64Coder() : m_pDBuffer(NULL), m_pEBuffer(NULL),
                           m_nDBufLen(0), m_nEBufLen(0)
{
}CBase64Coder::~CBase64Coder()
{
if (m_pDBuffer != NULL)
  {
delete [] m_pDBuffer;
    m_pDBuffer = NULL;
  } if (m_pEBuffer != NULL)
  {
delete [] m_pEBuffer;
    m_pEBuffer = NULL;
  }
}LPSTR CBase64Coder::DecodedMessage() const 
{ 
return (LPSTR) m_pDBuffer;
}LPSTR CBase64Coder::EncodedMessage() const
{ 
return (LPSTR) m_pEBuffer;
}LONG CBase64Coder::DecodedMessageSize() const 
{ 
return m_nDDataLen;
}LONG CBase64Coder::EncodedMessageSize() const
{ 
return m_nEDataLen;
}void CBase64Coder::AllocEncode(DWORD nSize)
{
if (m_nEBufLen < nSize)
{
if (m_pEBuffer != NULL)
delete [] m_pEBuffer; m_nEBufLen = ROUNDTOPAGE(nSize);
m_pEBuffer = new BYTE[m_nEBufLen];
} ::ZeroMemory(m_pEBuffer, m_nEBufLen);
m_nEDataLen = 0;
}void CBase64Coder::AllocDecode(DWORD nSize)
{
if (m_nDBufLen < nSize)
{
if (m_pDBuffer != NULL)
delete [] m_pDBuffer; m_nDBufLen = ROUNDTOPAGE(nSize);
m_pDBuffer = new BYTE[m_nDBufLen];
} ::ZeroMemory(m_pDBuffer, m_nDBufLen);
m_nDDataLen = 0;
}void CBase64Coder::SetEncodeBuffer(const PBYTE pBuffer, DWORD nBufLen)
{
DWORD i = 0; AllocEncode(nBufLen);
while(i < nBufLen)
{
if (!_IsBadMimeChar(pBuffer[i]))
{
m_pEBuffer[m_nEDataLen] = pBuffer[i];
m_nEDataLen++;
}
i++;
}
}void CBase64Coder::SetDecodeBuffer(const PBYTE pBuffer, DWORD nBufLen)
{
AllocDecode(nBufLen);
::CopyMemory(m_pDBuffer, pBuffer, nBufLen);
m_nDDataLen = nBufLen;
}void CBase64Coder::Encode(const PBYTE pBuffer, DWORD nBufLen)
{
SetDecodeBuffer(pBuffer, nBufLen);
AllocEncode(nBufLen * 2); TempBucket Raw;
DWORD nIndex = 0;
while ((nIndex + 3) <= nBufLen)
{
Raw.Clear();
::CopyMemory(&Raw, m_pDBuffer + nIndex, 3);
Raw.nSize = 3;
_EncodeToBuffer(Raw, m_pEBuffer + m_nEDataLen);
nIndex += 3;
m_nEDataLen += 4;
} if (nBufLen > nIndex)
{
Raw.Clear();
Raw.nSize = (BYTE) (nBufLen - nIndex);
::CopyMemory(&Raw, m_pDBuffer + nIndex, nBufLen - nIndex);
_EncodeToBuffer(Raw, m_pEBuffer + m_nEDataLen);
m_nEDataLen += 4;
}
}void CBase64Coder::Encode(LPCSTR szMessage)
{
if (szMessage != NULL)
Encode((const PBYTE)szMessage, strlen(szMessage));
}void CBase64Coder::Decode(const PBYTE pBuffer, DWORD dwBufLen)
{
if (!CBase64Coder::m_Init)
_Init(); SetEncodeBuffer(pBuffer, dwBufLen);
AllocDecode(dwBufLen); TempBucket Raw;
DWORD nIndex = 0;
while((nIndex + 4) <= m_nEDataLen)
{
Raw.Clear();
Raw.nData[0] = CBase64Coder::m_DecodeTable[m_pEBuffer[nIndex]];
Raw.nData[1] = CBase64Coder::m_DecodeTable[m_pEBuffer[nIndex + 1]];
Raw.nData[2] = CBase64Coder::m_DecodeTable[m_pEBuffer[nIndex + 2]];
Raw.nData[3] = CBase64Coder::m_DecodeTable[m_pEBuffer[nIndex + 3]]; if (Raw.nData[2] == 255)
Raw.nData[2] = 0;
if (Raw.nData[3] == 255)
Raw.nData[3] = 0;

Raw.nSize = 4;
_DecodeToBuffer(Raw, m_pDBuffer + m_nDDataLen);
nIndex += 4;
m_nDDataLen += 3;
}

   // If nIndex < m_nEDataLen, then we got a decode message without padding.
   // We may want to throw some kind of warning here, but we are still required
   // to handle the decoding as if it was properly padded.
if (nIndex < m_nEDataLen)
{
Raw.Clear();
for (DWORD i=nIndex; i<m_nEDataLen; i++)
{
Raw.nData[i - nIndex] = CBase64Coder::m_DecodeTable[m_pEBuffer[i]];
Raw.nSize++;
if(Raw.nData[i - nIndex] == 255)
Raw.nData[i - nIndex] = 0;
} _DecodeToBuffer(Raw, m_pDBuffer + m_nDDataLen);
m_nDDataLen += (m_nEDataLen - nIndex);
}
}void CBase64Coder::Decode(LPCSTR szMessage)
{
if (szMessage != NULL)
Decode((const PBYTE)szMessage, strlen(szMessage));
}DWORD CBase64Coder::_DecodeToBuffer(const TempBucket &Decode, PBYTE pBuffer)
{
TempBucket Data;
DWORD nCount = 0; _DecodeRaw(Data, Decode); for (int i=0; i<3; i++)
{
pBuffer[i] = Data.nData[i];
if(pBuffer[i] != 255)
nCount++;
} return nCount;
}
void CBase64Coder::_EncodeToBuffer(const TempBucket &Decode, PBYTE pBuffer)
{
TempBucket Data; _EncodeRaw(Data, Decode); for (int i=0; i<4; i++)
pBuffer[i] = Base64Digits[Data.nData[i]]; switch (Decode.nSize)
{
  case 1:
  pBuffer[2] = '=';
  case 2:
  pBuffer[3] = '=';
}
}void CBase64Coder::_DecodeRaw(TempBucket &Data, const TempBucket &Decode)
{
BYTE nTemp; Data.nData[0] = Decode.nData[0];
Data.nData[0] <<= 2; nTemp = Decode.nData[1];
nTemp >>= 4;
nTemp &= 0x03;
Data.nData[0] |= nTemp; Data.nData[1] = Decode.nData[1];
Data.nData[1] <<= 4; nTemp = Decode.nData[2];
nTemp >>= 2;
nTemp &= 0x0F;
Data.nData[1] |= nTemp; Data.nData[2] = Decode.nData[2];
Data.nData[2] <<= 6;
nTemp = Decode.nData[3];
nTemp &= 0x3F;
Data.nData[2] |= nTemp;
}void CBase64Coder::_EncodeRaw(TempBucket &Data, const TempBucket &Decode)
{
BYTE nTemp; Data.nData[0] = Decode.nData[0];
Data.nData[0] >>= 2;

Data.nData[1] = Decode.nData[0];
Data.nData[1] <<= 4;
nTemp = Decode.nData[1];
nTemp >>= 4;
Data.nData[1] |= nTemp;
Data.nData[1] &= 0x3F; Data.nData[2] = Decode.nData[1];
Data.nData[2] <<= 2; nTemp = Decode.nData[2];
nTemp >>= 6; Data.nData[2] |= nTemp;
Data.nData[2] &= 0x3F; Data.nData[3] = Decode.nData[2];
Data.nData[3] &= 0x3F;
}BOOL CBase64Coder::_IsBadMimeChar(BYTE nData)
{
switch(nData)
{
case '\r': case '\n': case '\t': case ' ' :
case '\b': case '\a': case '\f': case '\v':
return TRUE;
default:
return FALSE;
}
}void CBase64Coder::_Init()
{  
  // Initialize Decoding table.
int i;
for (i=0; i<256; i++)
CBase64Coder::m_DecodeTable[i] = -2; for (i=0; i<64; i++)
{
CBase64Coder::m_DecodeTable[Base64Digits[i]] = (char) i;
CBase64Coder::m_DecodeTable[Base64Digits[i]|0x80] = (char) i;
} CBase64Coder::m_DecodeTable['='] = -1;
CBase64Coder::m_DecodeTable['='|0x80] = -1;
CBase64Coder::m_Init = TRUE;
}