/**

 * uri.c: set of generic URI related routines

 *

 * Reference: RFC 2396

 *

 * See Copyright for the status of this software.

 *

 * daniel@veillard.com

 */

#define IN_LIBXML

#include "XmlEnglibxml.h"

#include <string.h>

//#include "Libxml2_xmlmemory.h"

#include "Libxml2_uri.h"

#include "Libxml2_globals.h"

//#include "Libxml2_xmlerror.h"

/************************************************************************

 *                                                                      *

 *      Macros to differentiate various character type                  *

 *          directly extracted from RFC 2396                            *

 *                                                                      *

 ************************************************************************/

/*

 * alpha    = lowalpha | upalpha

 */

#define IS_ALPHA(x) (IS_LOWALPHA(x) || IS_UPALPHA(x))

/*

 * lowalpha = "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"

 */

#define IS_LOWALPHA(x) (((x) >= 'a') && ((x) <= 'z'))

/*

 * upalpha = "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"

 */

#define IS_UPALPHA(x) (((x) >= 'A') && ((x) <= 'Z'))

/*

 * digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"

 */

#define IS_DIGIT(x) (((x) >= '0') && ((x) <= '9'))

/*

 * alphanum = alpha | digit

 */

#define IS_ALPHANUM(x) (IS_ALPHA(x) || IS_DIGIT(x))

/*

 * hex = digit | "A" | "B" | "C" | "D" | "E" | "F" |

 *               "a" | "b" | "c" | "d" | "e" | "f"

 */

#define IS_HEX(x) ((IS_DIGIT(x)) || (((x) >= 'a') && ((x) <= 'f')) || \

        (((x) >= 'A') && ((x) <= 'F')))

/*

 * mark = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"

 */

#define IS_MARK(x) (((x) == '-') || ((x) == '_') || ((x) == '.') || \

    ((x) == '!') || ((x) == '~') || ((x) == '*') || ((x) == '\'') ||    \

    ((x) == '(') || ((x) == ')'))

/*

 * reserved = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ","

 */

#define IS_RESERVED(x) (((x) == ';') || ((x) == '/') || ((x) == '?') || \

        ((x) == ':') || ((x) == '@') || ((x) == '&') || ((x) == '=') || \

    ((x) == '+') || ((x) == '$') || ((x) == ','))

static int isReserved(char ch)

    {

    return IS_RESERVED(ch);

    }

/*

 * unreserved = alphanum | mark

 */

#define IS_UNRESERVED(x) (IS_ALPHANUM(x) || IS_MARK(x))

static int isUnreserved(char ch)

    {

    return IS_UNRESERVED(ch);

    }

/*

 * escaped = "%" hex hex

 */

#define IS_ESCAPED(p) \

            ((*(p) == '%') && (IS_HEX((p)[1])) && (IS_HEX((p)[2])))

static int isEscaped(const char* pch)

    {

    return IS_ESCAPED(pch);

    }

/*

 * uric_no_slash = unreserved | escaped | ";" | "?" | ":" | "@" |

 *                        "&" | "=" | "+" | "$" | ","

 */

/*

#define IS_URIC_NO_SLASH(p) ((IS_UNRESERVED(*(p))) || (IS_ESCAPED(p)) ||\

            ((*(p) == ';')) || ((*(p) == '?')) || ((*(p) == ':')) ||\

            ((*(p) == '@')) || ((*(p) == '&')) || ((*(p) == '=')) ||\

            ((*(p) == '+')) || ((*(p) == '$')) || ((*(p) == ',')))

*/

#define IS_URIC_NO_SLASH(p) \

            ((IS_UNRESERVED(*(p))) || \

             (IS_ESCAPED(p))       || \

             ((*(p)) != '/' && IS_RESERVED(p)))

static int isUriCNoSlash(const char* pch)

    {

    char ch = *pch;

    return isUnreserved(ch) ||

           isEscaped(pch)     ||

           (ch != '/' && isReserved(ch));

    }

/*

 * pchar = unreserved | escaped | ":" | "@" | "&" | "=" | "+" | "$" | ","

 */

#define IS_PCHAR(p) ((IS_UNRESERVED(*(p))) || (IS_ESCAPED(p)) ||    \

            ((*(p) == ':')) || ((*(p) == '@')) || ((*(p) == '&')) ||\

            ((*(p) == '=')) || ((*(p) == '+')) || ((*(p) == '$')) ||\

            ((*(p) == ',')))

static int isPChar(const char* pch)

    {

    char ch = *pch;

    return isUnreserved(ch) ||

           isEscaped(pch)   ||

           ch == ':' || ch == '@' || ch == '&' ||

           ch == '=' || ch == '+' || ch == '$' ||

           ch == ',';

    }

/*

 * rel_segment   = 1*( unreserved | escaped |

 *                 ";" | "@" | "&" | "=" | "+" | "$" | "," )

 */

#define IS_SEGMENT(p) ((IS_UNRESERVED(*(p))) || (IS_ESCAPED(p)) ||  \

            ((*(p) == ';')) || ((*(p) == '@')) || ((*(p) == '&')) ||  \

            ((*(p) == '=')) || ((*(p) == '+')) || ((*(p) == '$')) ||  \

            ((*(p) == ',')))

static int isSegment(const char* pch)

    {

    char ch = *pch;

    return isUnreserved(ch)  || isEscaped(pch) ||

           ch == ';' || ch == '@' || ch == '&' ||

           ch == '=' || ch == '+' || ch == '$' ||

           ch == ',';

    }

/*

 * scheme = alpha *( alpha | digit | "+" | "-" | "." )

 */

#define IS_SCHEME(x) ((IS_ALPHA(x)) || (IS_DIGIT(x)) ||         \

                  ((x) == '+') || ((x) == '-') || ((x) == '.'))

/* the macros is used only once 

static int isScheme(char x)

    {

    return ((IS_ALPHA(x)) || (IS_DIGIT(x)) ||         

            (x) == '+') || ((x) == '-') || ((x) == '.'))

    }

*/

/*

 * reg_name = 1*( unreserved | escaped | "$" | "," |

 *                ";" | ":" | "@" | "&" | "=" | "+" )

 */

#define IS_REG_NAME(p) ((IS_UNRESERVED(*(p))) || (IS_ESCAPED(p)) || \

       ((*(p) == '$')) || ((*(p) == ',')) || ((*(p) == ';')) ||     \

       ((*(p) == ':')) || ((*(p) == '@')) || ((*(p) == '&')) ||     \

       ((*(p) == '=')) || ((*(p) == '+')))

static int isRegName(const char* pch)

    {

    char ch = *pch;

    return isUnreserved(ch) || isEscaped(pch) ||

           ch == '$' || ch == ',' || ch == ';' ||

           ch == ':' || ch == '@' || ch == '&' ||

           ch == '=' || ch == '+';

    }

/*

 * userinfo = *( unreserved | escaped | ";" | ":" | "&" | "=" |

 *                      "+" | "$" | "," )

 */

#define IS_USERINFO(p) ((IS_UNRESERVED(*(p))) || (IS_ESCAPED(p)) || \

       ((*(p) == ';')) || ((*(p) == ':')) || ((*(p) == '&')) ||     \

       ((*(p) == '=')) || ((*(p) == '+')) || ((*(p) == '$')) ||     \

       ((*(p) == ',')))

static int isUserInfo(const char* pch)

    {

    char ch = *pch;

    return

            isUnreserved(ch) ||

            isEscaped(pch)   ||

            ch == ';' || ch == ':' || ch == '&' ||

            ch == '=' || ch == '+' || ch == '$' ||

            ch == ',';

    }

/*

 * uric = reserved | unreserved | escaped

 */

#define IS_URIC(p) ((IS_UNRESERVED(*(p))) || (IS_ESCAPED(p)) || (IS_RESERVED(*(p))))

static int isUriC(const char* pch)

    {

    char ch = *pch;

    return isUnreserved(ch) || isEscaped(pch) || isReserved(ch);

    }

/*

* unwise = "{" | "}" | "|" | "\" | "^" | "[" | "]" | "`"

*/

#define IS_UNWISE(p)                                                    \

      (((*(p) == '{')) || ((*(p) == '}')) || ((*(p) == '|')) ||         \

       ((*(p) == '\\'))|| ((*(p) == '^')) || ((*(p) == '[')) ||        \

       ((*(p) == ']')) || ((*(p) == '`')))

static int isUnwise(char ch)

    {

    return

       ch == '{'  || ch == '}' || ch == '|' ||

       ch == '\\' || ch == '^' || ch == '[' ||

       ch == ']'  || ch == '`';

    }

/*

 * Skip to next pointer char, handle escaped sequences

 */

#define NEXT(p) ((*p == '%')? p += 3 : p++)

/*

 * Productions from the spec.

 *

 *    authority     = server | reg_name

 *    reg_name      = 1*( unreserved | escaped | "$" | "," |

 *                        ";" | ":" | "@" | "&" | "=" | "+" )

 *

 * path          = [ abs_path | opaque_part ]

 */

/************************************************************************

 *                                                                      *

 *          Generic URI structure functions                             *

 *                                                                      *

 ************************************************************************/

/**

 * xmlCreateURI:

 *

 * Simply creates an empty xmlURI

 *

 * Returns the new structure or NULL in case of error

 *

 * OOM: possible --> returns NULL , sets OOM flag

 */

xmlURIPtr

xmlCreateURI(void) {

    xmlURIPtr ret;

    ret = (xmlURIPtr) xmlMalloc(sizeof(xmlURI));

    if (ret == NULL) {

        xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("xmlCreateURI: out of memory\n"));

        return(NULL);

    }

    memset(ret, 0, sizeof(xmlURI));

    return(ret);

}

/**

 * xmlSaveUri:

 * @uri:  pointer to an xmlURI

 *

 * Save the URI as an escaped string

 *

 * Returns a new string (to be deallocated by caller)

 *

 * OOM:

 */

xmlChar*

xmlSaveUri(xmlURIPtr uri)

{

    xmlChar* ret;// = NULL;

    const char* p;

    int len;

    int max;

    char ch;

    if (!uri)

        return(NULL);

    max = 80;

    ret = (xmlChar*) xmlMallocAtomic((max + 1) * sizeof(xmlChar));

    if (!ret)

        goto OOM;

    len = 0;

    if (uri->scheme != NULL) {

        p = uri->scheme;

        // TODO: OPTIMIZE: roll two blocks into one do { } while loop

        while (*p != 0) {

            if (len >= max) {

                xmlChar* tmp;

                max *= 2;

                tmp = (xmlChar*) xmlRealloc(ret, (max + 1) * sizeof(xmlChar)); // DONE: Fix xmlRealloc

                if (!tmp)

                    goto OOM;

                ret = tmp;

            }

            ret[len++] = *p++;

        }

        if (len >= max) {

            xmlChar* tmp;

            max *= 2;

            tmp = (xmlChar*) xmlRealloc(ret, (max + 1) * sizeof(xmlChar)); // DONE: Fix xmlRealloc

            if (!tmp)

                goto OOM;

            ret = tmp;

        }

        ret[len++] = ':';

    }

    if (uri->opaque != NULL) {

        p = uri->opaque;

        while (*p != 0) {

            if (len + 3 >= max) {

                xmlChar* tmp;

                max *= 2;

                tmp = (xmlChar*) xmlRealloc(ret, (max + 1) * sizeof(xmlChar)); // DONE: Fix xmlRealloc

                if (!tmp)

                    goto OOM;

                ret = tmp;

            }

            if (isReserved(*p) || isUnreserved(*p))

            {

                ret[len++] = *p++;

            }

            else

            {

                int val = *(unsigned char*)p++;

                int hi = val / 0x10;

                int lo = val % 0x10;

                ret[len++] = '%';

                ret[len++] = hi + (hi > 9? 'A'-10 : '0');

                ret[len++] = lo + (lo > 9? 'A'-10 : '0');

            }

        }

    }

    else

    {

        if (uri->server != NULL) {

            if (len + 3 >= max) {

                xmlChar* tmp;

                max *= 2;

                tmp = (xmlChar*) xmlRealloc(ret, (max + 1) * sizeof(xmlChar)); // DONE: Fix xmlRealloc

                if (!tmp)

                    goto OOM;

                ret = tmp;

            }

            ret[len++] = '/';

            ret[len++] = '/';

            if (uri->user != NULL) {

                p = uri->user;

                // TODO: OPTIMIZE: roll two IFs into one loop again

                while (*p != 0) {

                    if (len + 3 >= max) {

                        xmlChar* tmp;

                        max *= 2;

                        tmp = (xmlChar*) xmlRealloc(ret, (max + 1) * sizeof(xmlChar)); // DONE: Fix xmlRealloc

                        if (!tmp)

                            goto OOM;

                        ret = tmp;

                    }

                    ch = *p;

                    if (isUnreserved(ch) ||

                        ch == ';' || ch == ':' ||

                        ch == '&' || ch == '=' ||

                        ch == '+' || ch == '$' ||

                        ch == ',')

                    {

                        ret[len++] = *p++;

                    }

                    else

                    {

                        int val = *(unsigned char *)p++;

                        int hi = val / 0x10, lo = val % 0x10;

                        ret[len++] = '%';

                        ret[len++] = hi + (hi > 9? 'A'-10 : '0');

                        ret[len++] = lo + (lo > 9? 'A'-10 : '0');

                    }

                }

                if (len + 3 >= max) {

                    xmlChar* tmp;

                    max *= 2;

                    tmp = (xmlChar*) xmlRealloc(ret, (max + 1) * sizeof(xmlChar)); // DONE: Fix xmlRealloc

                    if (!tmp)

                        goto OOM;

                    ret = tmp;

                }

                ret[len++] = '@';

            }

            p = uri->server;

            while (*p != 0) {

                if (len >= max) {

                    xmlChar* tmp;

                    max *= 2;

                    tmp = (xmlChar*) xmlRealloc(ret, (max + 1) * sizeof(xmlChar)); // DONE: Fix xmlRealloc

                    if (!tmp)

                        goto OOM;

                    ret = tmp;

                }

                ret[len++] = *p++;

            }

            if (uri->port > 0) {

                if (len + 10 >= max) {

                    xmlChar* tmp;

                    max *= 2;

                    tmp = (xmlChar*) xmlRealloc(ret, (max + 1) * sizeof(xmlChar)); // DONE: Fix xmlRealloc

                    if (!tmp)

                        goto OOM;

                    ret = tmp;

                }

                len += snprintf((char*) &ret[len], max - len, ":%d", uri->port);

            }

        }

        else if (uri->authority != NULL) {

            if (len + 3 >= max) {

                xmlChar* tmp;

                max *= 2;

                tmp = (xmlChar*) xmlRealloc(ret, (max + 1) * sizeof(xmlChar)); // DONE: Fix xmlRealloc

                if (!tmp)

                    goto OOM;

                ret = tmp;

            }

            ret[len++] = '/';

            ret[len++] = '/';

            p = uri->authority;

            while (*p != 0) {

                if (len + 3 >= max) {

                    xmlChar* tmp;

                    max *= 2;

                    tmp = (xmlChar*) xmlRealloc(ret, (max + 1) * sizeof(xmlChar)); // DONE: Fix xmlRealloc

                    if (!tmp)

                        goto OOM;

                    ret = tmp;

                }

                ch = *p;

                if (isUnreserved(ch) ||

                            ch == '$' || ch == ',' || ch == ';' ||

                            ch == ':' || ch == '@' || ch == '&' ||

                            ch == '=' || ch == '+')

                {

                    ret[len++] = *p++;

                }

                else

                {

                    int val = *(unsigned char *)p++;

                    int hi = val / 0x10;

                    int lo = val % 0x10;

                    ret[len++] = '%';

                    ret[len++] = hi + (hi > 9? 'A'-10 : '0');

                    ret[len++] = lo + (lo > 9? 'A'-10 : '0');

                }

            }

    }

    else if (uri->scheme != NULL) {

        if (len + 3 >= max) {

            xmlChar* tmp;

            max *= 2;

            tmp = (xmlChar*) xmlRealloc(ret, (max + 1) * sizeof(xmlChar)); // DONE: Fix xmlRealloc

            if (!tmp)

                goto OOM;

            ret = tmp;

        }

        ret[len++] = '/';

        ret[len++] = '/';

    }

    if (uri->path != NULL) {

        p = uri->path;

        while (*p != 0) {

            if (len + 3 >= max) {

                xmlChar* tmp;

                max *= 2;

                tmp = (xmlChar*) xmlRealloc(ret, (max + 1) * sizeof(xmlChar)); // DONE: Fix xmlRealloc

                if (!tmp)

                    goto OOM;

                ret = tmp;

            }

            ch = *p;

            if (isUnreserved(ch) || ch == '/' ||

                ch == ';' || ch == '@' || ch == '&' ||

                ch == '=' || ch == '+' || ch == '$' ||

                ch == ',')

            {

                ret[len++] = *p++;

            }

            else

            {

                int val = *(unsigned char *)p++;

                int hi = val / 0x10;