Web alhem.net

Cgi::Base64 Class Reference

#include <Base64.h>

Collaboration diagram for Cgi::Base64:

List of all members.

Public Member Functions
	Base64 (char= '=')
	~Base64 ()
void	encode_file (const char *s, const char *outfn)
void	encode64 (const char *in, size_t len, std::vector< std::string > &out)
void	encode_from_file (const char *, std::vector< std::string > &)
std::string	encode_buffer (const std::string &)
void	decode_file (char *s, char *outfn)
void	decode_to_file (std::vector< std::string > &body, char *outfn)
void	decode_stdout (char *fn, FILE *out=stdout)
void	decode_to_stdout (const std::string &, FILE *=stdout)
void	decode_to_stdout (std::vector< std::string > &, FILE *=stdout)
void	decode_to_buffer (const std::string &, char *, size_t max)
size_t	decode_length (const std::string &)
Private Member Functions
void	setupbase64 ()
char	setupdecode (char c)
unsigned char	reverse (char c)
void	encode (const char *in, char *out)
int	decode (char c)
void	decode_string (char *s, unsigned char *output, int &l)
Private Attributes
char	m_eqchar

---

Detailed Description

Definition at line 33 of file Base64.h.

---

Constructor & Destructor Documentation

Cgi::Base64::Base64

(

char

= '='

)

Definition at line 39 of file Base64.cpp.

References setupbase64().

                      : m_eqchar(eq)
{
        setupbase64();
}

Cgi::Base64::~Base64

(

)

Definition at line 45 of file Base64.cpp.

{
}

---

Member Function Documentation

void Cgi::Base64::encode_file	(	const char *	s,
		const char *	outfn
	)

Definition at line 138 of file Base64.cpp.

References encode(), and m_eqchar.

{
        FILE *fil;
        FILE *fil2;
        int iptr = 0;
        int ptr = 0;
        size_t dv = 0;
        unsigned char c;
        char tmp[4];
        char slask[200];

        slask[76] = 0;  
        
        if ((fil = fopen(s, "rb")) != NULL)
        {
                fil2 = fopen(outfn, "wt");
                fread(&c,1,1,fil);
                while (!feof(fil))
                {
                        tmp[iptr++] = c;
                        if (iptr == 3)
                        {
                                encode(tmp, slask + ptr);
                                ptr += 4;
                                if (ptr == 76)
                                {
                                        fprintf(fil2,"%s\n",slask);
                                        ptr = 0;
                                }
                                iptr = 0;
                                dv++;
                        }
                        fread(&c,1,1,fil);
                }
                fclose(fil);

                if (iptr)
                {
                        int i = iptr;
                        while (iptr < 3)
                                tmp[iptr++] = 0;
                        encode(tmp, slask + ptr);
                        switch (i)
                        {
                        case 1:
                                slask[ptr + 2] = m_eqchar;
                        case 2:
                                slask[ptr + 3] = m_eqchar;
                        }
                        ptr += 4;
                        if (ptr == 76)
                        {
                                fprintf(fil2,"%s\n",slask);
                                ptr = 0;
                        }
                }
                if (ptr)
                {
                        slask[ptr] = 0;
                        fprintf(fil2,"%s\n",slask);
                        ptr = 0;
                }
                fclose(fil2);
        }
}

void Cgi::Base64::encode64	(	const char *	in,
		size_t	len,
		std::vector< std::string > &	out
	)

Definition at line 205 of file Base64.cpp.

References encode(), and m_eqchar.

{
        size_t dv = len / 3;
        size_t ptr = 0;
        size_t i;
        char tmp[100];

        tmp[76] = 0;
        for (i = 0; i < dv; i++)
        {
                encode(in + i * 3,tmp + ptr);
                ptr += 4;
                tmp[ptr] = 0;
                if (ptr == 76)
                {
                        out.push_back( tmp );
                        ptr = 0;
                }
        }
        if (len % 3)
        {
                char slask[3];

                memset(slask,0,3);
                memmove(slask,in + i * 3,len % 3);

                encode(slask,tmp + ptr);
                switch (len % 3)
                {
                case 1:
                        tmp[ptr + 2] = m_eqchar;
                case 2:
                        tmp[ptr + 3] = m_eqchar;
                }
                ptr += 4;
                tmp[ptr] = 0;
                if (ptr == 76)
                {
                        out.push_back( tmp );
                        ptr = 0;
                }
        }
        if (ptr)
        {
                tmp[ptr] = 0;
                out.push_back( tmp );
                ptr = 0;
        }
}

void Cgi::Base64::encode_from_file	(	const char *	,
		std::vector< std::string > &
	)

Definition at line 311 of file Base64.cpp.

References encode(), and m_eqchar.

{
        FILE *fil;
        int iptr = 0;
        int ptr = 0;
        size_t dv = 0;
        unsigned char c;
        char tmp[4];
        char slask[200];

        slask[76] = 0;  
        
        if ((fil = fopen(fn, "rb")) != NULL)
        {
                fread(&c,1,1,fil);
                while (!feof(fil))
                {
                        tmp[iptr++] = c;
                        if (iptr == 3)
                        {
                                encode(tmp, slask + ptr);
                                ptr += 4;
                                if (ptr == 76)
                                {
                                        out.push_back( slask );
                                        ptr = 0;
                                }
                                iptr = 0;
                                dv++;
                        }
                        fread(&c,1,1,fil);
                }
                fclose(fil);

                if (iptr)
                {
                        int i = iptr;
                        while (iptr < 3)
                                tmp[iptr++] = 0;
                        encode(tmp, slask + ptr);
                        switch (i)
                        {
                        case 1:
                                slask[ptr + 2] = m_eqchar;
                        case 2:
                                slask[ptr + 3] = m_eqchar;
                        }
                        ptr += 4;
                        if (ptr == 76)
                        {
                                out.push_back( slask );
                                ptr = 0;
                        }
                }
                if (ptr)
                {
                        slask[ptr] = 0;
                        out.push_back( slask );
                        ptr = 0;
                }
        }
}

std::string Cgi::Base64::encode_buffer

(

const std::string &

)

Definition at line 256 of file Base64.cpp.

References encode(), and m_eqchar.

{
        const char *in = buf.c_str();
        size_t len = buf.size();
        std::string out;
        size_t dv = len / 3;
        size_t ptr = 0;
        size_t i;
        char tmp[100];

        tmp[76] = 0;
        for (i = 0; i < dv; i++)
        {
                encode(in + i * 3,tmp + ptr);
                ptr += 4;
                tmp[ptr] = 0;
                if (ptr == 76)
                {
                        out += tmp;
                        ptr = 0;
                }
        }
        if (len % 3)
        {
                char slask[3];

                memset(slask,0,3);
                memmove(slask,in + i * 3,len % 3);

                encode(slask,tmp + ptr);
                switch (len % 3)
                {
                case 1:
                        tmp[ptr + 2] = m_eqchar;
                case 2:
                        tmp[ptr + 3] = m_eqchar;
                }
                ptr += 4;
                tmp[ptr] = 0;
                if (ptr == 76)
                {
                        out += tmp;
                        ptr = 0;
                }
        }
        if (ptr)
        {
                tmp[ptr] = 0;
                out += tmp;
                ptr = 0;
        }
        return out;
}

void Cgi::Base64::decode_file	(	char *	s,
		char *	outfn
	)

Definition at line 375 of file Base64.cpp.

References decode_string().

{
        FILE *fil;
        FILE *fil2;
        char slask[200];
        unsigned char output[200];

        if ((fil = fopen(s, "rt")) != NULL)
        {
                fil2 = fopen(outfn, "wb");
                fgets(slask, 200, fil);
                while (!feof(fil))
                {
                        while (strlen(slask) && (slask[strlen(slask) - 1] == 13 || slask[strlen(slask) - 1] == 10))
                        {
                                slask[strlen(slask) - 1] = 0;
                        }
                        for (int i = 0; i < (int)strlen(slask); i += 4)
                        {
                                int l;
                                decode_string(slask + i, output, l);
                                fwrite(output, 1, l, fil2);
                        }
                        //
                        fgets(slask, 200, fil);
                }
                fclose(fil);
                fclose(fil2);
        }
}

void Cgi::Base64::decode_to_file	(	std::vector< std::string > &	body,
		char *	outfn
	)

Definition at line 407 of file Base64.cpp.

References decode_string().

{
        FILE *fil;
        unsigned char out[4];

        if ((fil = fopen(outfn,"wb")) != NULL)
        {
                for (std::vector<std::string>::iterator it = body.begin(); it != body.end(); it++)
                {
                        for (size_t i = 0; i < (*it).size(); i += 4)
                        {
                                int l;
                                decode_string( (char *)(*it).c_str() + i, out, l);
                                fwrite(out, 1, l, fil);
                        }
                }
                fclose(fil);
        }
}

void Cgi::Base64::decode_stdout	(	char *	fn,
		FILE *	out = stdout
	)

Definition at line 428 of file Base64.cpp.

References decode_string().

{
        FILE *fil;
        char slask[200];
        unsigned char output[200];

        if ((fil = fopen(s, "rt")) != NULL)
        {
                fgets(slask, 200, fil);
                while (!feof(fil))
                {
                        while (strlen(slask) && (slask[strlen(slask) - 1] == 13 || slask[strlen(slask) - 1] == 10))
                        {
                                slask[strlen(slask) - 1] = 0;
                        }
                        for (int i = 0; i < (int)strlen(slask); i += 4)
                        {
                                int l;
                                decode_string(slask + i, output, l);
                                fwrite(output, 1, l, fil2);
                        }
                        //
                        fgets(slask, 200, fil);
                }
                fclose(fil);
        }
}

void Cgi::Base64::decode_to_stdout	(	const std::string &	,
		FILE *	= stdout
	)

Definition at line 457 of file Base64.cpp.

References decode_string().

{
        size_t p = 0;
        char slask[20000];
        unsigned char output[200];

        while (p < str.size())
        {
                size_t i = 0;
                while (str[p] != 13 && str[p] != 10 && p < str.size())
                {
                        slask[i++] = str[p++];
                }
                slask[i] = 0;
                while (str[p] == 13 || str[p] == 10)
                        p++;
                for (i = 0; i < strlen(slask); i += 4)
                {
                        int l;
                        decode_string(slask + i, output, l);
                        fwrite(output, 1, l, fil2);
                }
        }
}

void Cgi::Base64::decode_to_stdout	(	std::vector< std::string > &	,
		FILE *	= stdout
	)

Definition at line 483 of file Base64.cpp.

References decode_string().

{
        unsigned char out[4];

        for (std::vector<std::string>::iterator it = body.begin(); it != body.end(); it++)
        {
                for (size_t i = 0; i < (*it).size(); i += 4)
                {
                        int l;
                        decode_string( (char *)(*it).c_str() + i, out, l);
                        fwrite(out, 1, l, fil);
                }
        }
}

void Cgi::Base64::decode_to_buffer	(	const std::string &	,
		char *	,
		size_t	max
	)

Definition at line 528 of file Base64.cpp.

References decode_string().

Referenced by Cgi::Web::ValidateAuth().

{
        size_t p = 0;
        size_t o = 0;
        char slask[20000];
        unsigned char output[200];

        while (p < str.size())
        {
                size_t i = 0;
                while (str[p] != 13 && str[p] != 10 && p < str.size())
                {
                        slask[i++] = str[p++];
                }
                slask[i] = 0;
                while (str[p] == 13 || str[p] == 10)
                        p++;
                for (i = 0; i < strlen(slask); i += 4)
                {
                        int l;
                        decode_string(slask + i, output, l);
                        if (o + l <= max)
                        {
                                memcpy(ut + o, output, l);
                                if (o + l < max)
                                        memset(ut + o + l, 0, 1);
                        }
                        o += l;
                }
        }
}

size_t Cgi::Base64::decode_length

(

const std::string &

)

Definition at line 499 of file Base64.cpp.

References decode_string().

{
        size_t p = 0;
        size_t len = 0;
        char slask[20000];
        unsigned char output[200];

        while (p < str.size())
        {
                size_t i = 0;
                while (str[p] != 13 && str[p] != 10 && p < str.size())
                {
                        slask[i++] = str[p++];
                }
                slask[i] = 0;
                while (str[p] == 13 || str[p] == 10)
                        p++;
                for (i = 0; i < strlen(slask); i += 4)
                {
                        int l;
                        decode_string(slask + i, output, l);
//                      fwrite(output, 1, l, fil2);
                        len += l;
                }
        }
        return len;
}

void Cgi::Base64::setupbase64

(

)

[private]

Definition at line 50 of file Base64.cpp.

References base64vec, and setupdecode().

Referenced by Base64().

{
        for (char c = 0; c <= 'z'; c++)
        {
                base64vec[ (int)c] = setupdecode(c); // 0..63
        }
}

char Cgi::Base64::setupdecode

(

char

c

)

[private]

Definition at line 59 of file Base64.cpp.

Referenced by setupbase64().

{
        if (c >= 'a')
                return (char)((c + 26) - 'a');  // 26..51
        if (c >= 'A')
                return (char)(c - 'A');         // 0..25
        if (c >= '0')
                return (char)((c + 52) - '0');  // 52..61
        if (c == '+')
                return 62;              // 62
        if (c == '/')
                return 63;              // 63
        return 0;
}

unsigned char Cgi::Base64::reverse

(

char

c

)

[private]

Definition at line 75 of file Base64.cpp.

References g_achEncodeTable.

Referenced by encode().

{
        return g_achEncodeTable[(int)c];
}

void Cgi::Base64::encode	(	const char *	in,
		char *	out
	)			[private]

Definition at line 81 of file Base64.cpp.

References reverse().

Referenced by encode64(), encode_buffer(), encode_file(), and encode_from_file().

{
        int i1 = (in[0] >> 2) & 63;
        int i2 = ( ((in[0] & 3) << 4) + ((in[1] >> 4) & 15) ) & 63;
        int i3 = ( ((in[1] & 15) << 2) + ((in[2] >> 6) & 3) ) & 63;
        int i4 = in[2] & 63;

        out[0] = reverse( (char)i1);
        out[1] = reverse( (char)i2);
        out[2] = reverse( (char)i3);
        out[3] = reverse( (char)i4);
}

int Cgi::Base64::decode

(

char

c

)

[private]

Definition at line 95 of file Base64.cpp.

References base64vec.

Referenced by decode_string().

{
        return base64vec[(int)c];
}

void Cgi::Base64::decode_string	(	char *	s,
		unsigned char *	output,
		int &	l
	)			[private]

Definition at line 101 of file Base64.cpp.

References decode(), and m_eqchar.

Referenced by decode_file(), decode_length(), decode_stdout(), decode_to_buffer(), decode_to_file(), and decode_to_stdout().

{
        union {
                unsigned long l;
                char s[4];
        } u;

        if (s[2] == m_eqchar)
        {
                l = 1;
                u.l = decode(s[0]) << 18 | decode(s[1]) << 12;

                output[0] = u.s[2];
                output[1] = 0;
                output[2] = 0;
                return;
        }
        else
        if (s[3] == m_eqchar)
        {
                l = 2;
                u.l = decode(s[0]) << 18 | decode(s[1]) << 12 | decode(s[2]) << 6;

                output[0] = u.s[2];
                output[1] = u.s[1];
                output[2] = 0;
                return;
        }
        l = 3;
        u.l = decode(s[0]) << 18 | decode(s[1]) << 12 | decode(s[2]) << 6 | decode(s[3]);

        output[0] = u.s[2];
        output[1] = u.s[1];
        output[2] = u.s[0];
}

---

Member Data Documentation

char Cgi::Base64::m_eqchar [private]

Definition at line 80 of file Base64.h.

Referenced by decode_string(), encode64(), encode_buffer(), encode_file(), and encode_from_file().

---

The documentation for this class was generated from the following files:

• Base64.h
• Base64.cpp

---

Page, code, and content Copyright (C) 2004 by Anders Hedström