base64.h File Reference

(986a3bf)

#include <string>
#include "localconsts.h"

Go to the source code of this file.

Functions
unsigned char *	php3_base64_encode (const unsigned char *, int, int *)
unsigned char *	php3_base64_decode (const unsigned char *, int, int *)
std::string	encodeBase64String (std::string value)
std::string	decodeBase64String (std::string value)

Function Documentation

decodeBase64String()

std::string decodeBase64String

(

std::string

value

)

Definition at line 203 of file base64.cpp.

{
    int sz = 0;
    const unsigned char *const str = reinterpret_cast<unsigned char*>(
        const_cast<char*>(value.c_str()));
    unsigned char *const buf = php3_base64_decode(
        str, CAST_S32(value.size()), &sz);
 
    if (buf != nullptr)
        value = std::string(reinterpret_cast<char*>(buf), sz);
    else
        value.clear();
    free(buf);
    return value;
}

References CAST_S32, and php3_base64_decode().

Referenced by SetupItemTextField::cancel(), SetupItemTextField::createControls(), SetupItemTextField::externalUpdated(), Dirs::initScreenshotDir(), and SetupItemTextField::rereadValue().

encodeBase64String()

std::string encodeBase64String

(

std::string

value

)

Definition at line 188 of file base64.cpp.

{
    int sz = 0;
    const unsigned char *const str = reinterpret_cast<unsigned char*>(
        const_cast<char*>(value.c_str()));
    unsigned char *const buf = php3_base64_encode(
        str, CAST_S32(value.size()), &sz);
    if (buf == nullptr)
        return std::string();
 
    value = std::string(reinterpret_cast<char*>(buf), sz);
    free(buf);
    return value;
}

References CAST_S32, and php3_base64_encode().

Referenced by Dirs::initScreenshotDir(), and SetupItemTextField::save().

php3_base64_decode()

unsigned char* php3_base64_decode	(	const unsigned char *	string,
		int	length,
		int *	ret_length
	)

Definition at line 100 of file base64.cpp.

{
    const unsigned char *current = string;
    int ch;
    int i = 0;
    int j = 0;
    int k;
 
    unsigned char *result = static_cast<unsigned char *>(
        calloc(length + 1, 1));
 
    if (result == nullptr)
        return nullptr;
 
    /* run through the whole string, converting as we go */
    while ((ch = *current++) != '\0')
    {
        if (ch == base64_pad)
            break;
 
        /* When Base64 gets POSTed, all pluses are interpreted as spaces.
           This line changes them back.  It's not exactly the Base64 spec,
           but it is completely compatible with it (the spec says that
           spaces are invalid).  This will also save many people considerable
           headache.  - Turadg Aleahmad <[email protected]>
           */
 
        if (ch == ' ') ch = '+';
 
        const char *const chp = strchr(base64_table, ch);
        if (chp == nullptr)
            continue;
        ch = CAST_S32(chp - base64_table);
 
        switch (i % 4)
        {
            case 0:
                result[j] = CAST_U8(ch << 2U);
                break;
            case 1:
                result[j++] |= CAST_U8(ch >> 4U);
                result[j] = CAST_U8((ch & 0x0f) << 4U);
                break;
            case 2:
                result[j++] |= CAST_U8(ch >>2U);
                result[j] = CAST_U8((ch & 0x03) << 6U);
                break;
            case 3:
                result[j++] |= CAST_U8(ch);
                break;
            default:
                break;
        }
        i++;
    }
 
    k = j;
    /* mop things up if we ended on a boundary */
    if (ch == base64_pad)
    {
        switch (i % 4)
        {
            case 0:
            case 1:
                free(result);
                return nullptr;
            case 2:
                k++;
                // copy from 3. is it should be here?
                result[k++] = 0;
                break;
            case 3:
                result[k++] = 0;
                break;
            default:
                break;
        }
    }
    if (ret_length != nullptr)
    {
        *ret_length = j;
    }
    result[k] = '\0';
    return result;
}

References base64_pad, base64_table, CAST_S32, and CAST_U8.

Referenced by decodeBase64String(), and MapReader::readBase64Layer().

php3_base64_encode()

unsigned char* php3_base64_encode	(	const unsigned char *	string,
		int	length,
		int *	ret_length
	)

Definition at line 46 of file base64.cpp.

{
    if (string == nullptr)
        return nullptr;
    const unsigned char *current = string;
    int i = 0;
    unsigned char *const result = static_cast<unsigned char *>(
        calloc(CAST_SIZE((length + 3 - length % 3) * 4 / 3 + 1)
        * sizeof(unsigned char), 1));
    if (result == nullptr)
        return nullptr;
 
    while (length > 2)
    { /* keep going until we have less than 24 bits */
        result[i++] = base64_table[current[0] >> 2];
        result[i++] = base64_table[((current[0] & 0x03)
                      << 4) + (current[1] >> 4)];
        result[i++] = base64_table[((current[1] & 0x0f)
                      << 2) + (current[2] >> 6)];
        result[i++] = base64_table[current[2] & 0x3f];
 
        current += 3;
        length -= 3; /* we just handle 3 octets of data */
    }
 
    /* now deal with the tail end of things */
    if (length != 0)
    {
        result[i++] = base64_table[current[0] >> 2];
        if (length > 1)
        {
            result[i++] = base64_table[((current[0] & 0x03) << 4)
                          + (current[1] >> 4)];
            result[i++] = base64_table[(current[1] & 0x0f) << 2];
            result[i++] = base64_pad;
        }
        else
        {
            result[i++] = base64_table[(current[0] & 0x03) << 4];
            result[i++] = base64_pad;
            result[i++] = base64_pad;
        }
    }
    if (ret_length != nullptr)
    {
        *ret_length = i;
    }
    result[i] = '\0';
    return result;
}

References base64_pad, base64_table, and CAST_SIZE.

Referenced by encodeBase64String().