urldecode Namespace Reference

Classes
struct	decoder_state_s

Typedefs
typedef struct urldecode::decoder_state_s	decoder_state

Enumerations
enum	states { ST_SYM , ST_PERCENT , ST_PERCENT_AND_SYM }

Functions
static int	hexdigit (char c)
int	is_unreserved (char c)
ssize_t	urldecode (decoder_state *state, char *data, size_t size)
	Decodes URL-encoded data.
std::pair< std::string, int >	urldecode (decoder_state *state, const std::string &data, size_t size)

Typedef Documentation

decoder_state

typedef struct urldecode::decoder_state_s urldecode::decoder_state

Enumeration Type Documentation

states

enum urldecode::states

Enumerator
ST_SYM
ST_PERCENT
ST_PERCENT_AND_SYM

Definition at line 39 of file urldecode.h.

{ ST_SYM, ST_PERCENT, ST_PERCENT_AND_SYM };

Function Documentation

hexdigit()

int urldecode::hexdigit ( char c )

static

Definition at line 28 of file urldecode.h.

{
    if (c >= '0' && c <= '9')
        return c - '0';
    if (c >= 'A' && c <= 'F')
        return 10 + c - 'A';
    if (c >= 'a' && c <= 'f')
        return 10 + c - 'a';
    return -1;
}

is_unreserved()

int urldecode::is_unreserved

(

char

c

)

Definition at line 47 of file urldecode.h.

{
    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
           (c >= '0' && c <= '9') || index("-_.~!*'();:@&=+$,/?%#[]", c);
}

urldecode() [1/2]

ssize_t urldecode::urldecode	(	decoder_state *	state,
		char *	data,
		size_t	size )

Decodes URL-encoded data.

Because encoded data is always bigger conversion is done in-place.

Returns

Number of decoded bytes written to data. Negative integer if data is not valid URL-encoded sequence.

Definition at line 59 of file urldecode.h.

{
    size_t inpos = 0, outpos = 0;
    int d1, d2;
    while (inpos < size)
    {
        char in = data[inpos++];
        switch (in)
        {
        case '%':
            switch (state->state)
            {
            case ST_SYM:
                state->state = ST_PERCENT;
                break;
            default:
                return -1;
            }
            break;
        case '+':
            switch (state->state)
            {
            case ST_SYM:
                data[outpos++] = ' ';
                break;
            default:
                return -1;
            }
            break;
        default:
            switch (state->state)
            {
            case ST_PERCENT_AND_SYM:
                d1 = hexdigit(state->sym), d2 = hexdigit(in);
                if (d1 >= 0 && d2 >= 0)
                {
                    data[outpos++] = (d1 << 4) | d2;
                }
                else
                {
                    return -1;
                }
                state->state = ST_SYM;
                break;
            case ST_PERCENT:
                state->sym = in;
                state->state = ST_PERCENT_AND_SYM;
                break;
            case ST_SYM:
                if (is_unreserved(in))
                {
                    data[outpos++] = in;
                }
                else
                {
                    return -1;
                }
                break;
            }
        }
    }
    return outpos;
}

urldecode() [2/2]

std::pair< std::string, int > urldecode::urldecode	(	decoder_state *	state,
		const std::string &	data,
		size_t	size )

Definition at line 124 of file urldecode.h.

{
    size_t inpos = 0; 
    int outpos = 0;
    int d1, d2;
    std::stringstream output;
    while (inpos < size)
    {
        char in = data[inpos++];
        switch (in)
        {
        case '%':
            switch (state->state)
            {
            case ST_SYM:
                state->state = ST_PERCENT;
                break;
            default:
                outpos=-1;
            }
            break;
        case '+':
            switch (state->state)
            {
            case ST_SYM:
                //data[outpos++] = ' ';
                output << ' ';
                break;
            default:
                outpos=-1;
            }
            break;
        default:
            switch (state->state)
            {
            case ST_PERCENT_AND_SYM:
                d1 = hexdigit(state->sym), d2 = hexdigit(in);
                if (d1 >= 0 && d2 >= 0)
                {
                    //data[outpos++] = (d1 << 4) | d2;
                    char temp = (d1 << 4) | d2;
                    output << temp;
                }
                else
                {
                    outpos=-1;
                }
                state->state = ST_SYM;
                break;
            case ST_PERCENT:
                state->sym = in;
                state->state = ST_PERCENT_AND_SYM;
                break;
            case ST_SYM:
                if (is_unreserved(in))
                {
                    //data[outpos++] = in;
                    output << in;
                }
                else
                {
                    outpos=-1;
                }
                break;
            }
        }
    }
    return std::make_pair(output.str(),outpos);
}