/*              Parse HyperText Document Address                HTParse.c
   **           ================================
 */

#include "HTParse.h"
#define TRACE 0

#define FREE(x) if (x) {free(x); x = NULL;}

struct struct_parts {
    char           *access;
    char           *host;
    char           *absolute;
    char           *relative;
/*      char * search;          no - treated as part of path */
    char           *anchor;
};

/*      Strings of any length
   **      ---------------------
 */
PUBLIC int      strcasecomp
ARGS2(CONST char *, a, CONST char *, b)
{
    CONST char     *p = a;
    CONST char     *q = b;

    for (p = a, q = b; *p && *q; p++, q++) {
        int             diff = TOLOWER(*p) - TOLOWER(*q);
        if (diff)
            return diff;
    }
    if (*p)
        return 1;               /* p was longer than q */
    if (*q)
        return -1;              /* p was shorter than q */
    return 0;                   /* Exact match */
}

/*      With count limit
   **      ----------------
 */
PUBLIC int      strncasecomp
ARGS3(CONST char *, a, CONST char *, b, int, n)
{
    CONST char     *p = a;
    CONST char     *q = b;

    for (p = a, q = b;; p++, q++) {
        int             diff;
        if (p == (a + n))
            return 0;           /* Match up to n characters */
        if (!(*p && *q))
            return (*p - *q);
        diff = TOLOWER(*p) - TOLOWER(*q);
        if (diff)
            return diff;
    }
    /* NOTREACHED */
}

/*      Allocate a new copy of a string, and returns it
 */
PUBLIC char    *HTSACopy
ARGS2(char **, dest, CONST char *, src)
{
    FREE(*dest);
    if (src) {
        *dest = (char *) malloc(strlen(src) + 1);
        if (*dest == NULL)
            outofmem(__FILE__, "HTSACopy");
        strcpy(*dest, src);
    }
    return *dest;
}
/*      String Allocate and Concatenate
 */
PUBLIC char    *HTSACat
ARGS2(char **, dest, CONST char *, src)
{
    if (src && *src) {
        if (*dest) {
            int             length = strlen(*dest);
            *dest = (char *) realloc(*dest, length + strlen(src) + 1);
            if (*dest == NULL)
                outofmem(__FILE__, "HTSACat");
            strcpy(*dest + length, src);
        } else {
            *dest = (char *) malloc(strlen(src) + 1);
            if (*dest == NULL)
                outofmem(__FILE__, "HTSACat");
            strcpy(*dest, src);
        }
    }
    return *dest;
}



/*      Strip white space off a string.                         HTStrip()
   **   -------------------------------
   **
   ** On exit,
   **   Return value points to first non-white character, or to 0 if none.
   **   All trailing white space is OVERWRITTEN with zero.
 */
PUBLIC char    *HTStrip
ARGS1(char *, s)
{
#define SPACE(c) ((c == ' ') || (c == '\t') || (c == '\n'))
    char           *p = s;
    for (p = s; *p; p++);       /* Find end of string */
    for (p--; p >= s; p--) {
        if (SPACE(*p))
            *p = '\0';          /* Zap trailing blanks */
        else
            break;
    }
    while (SPACE(*s))
        s++;                    /* Strip leading blanks */
    return s;
}

/*      Scan a filename for its consituents.                    scan()
   **   ------------------------------------
   **
   ** On entry,
   **   name    points to a document name which may be incomplete.
   ** On exit,
   **      absolute or relative may be nonzero (but not both).
   **   host, anchor and access may be nonzero if they were specified.
   **   Any which are nonzero point to zero terminated strings.
 */
PRIVATE void    scan
ARGS2(char *, name, struct struct_parts *, parts)
{
    char           *after_access;
    char           *p;
    /* int length = strlen (name); */

    parts->access = NULL;
    parts->host = NULL;
    parts->absolute = NULL;
    parts->relative = NULL;
    parts->anchor = NULL;

    /* 
     **  Scan left-to-right for a scheme (access).
     */
    after_access = name;
    for (p = name; *p; p++) {
        if (*p == ':') {
            *p = '\0';
            parts->access = name;       /* Access name has been specified */
            after_access = (p + 1);
            break;
        }
        if (*p == '/' || *p == '#' || *p == ';' || *p == '?')
            break;
    }

#ifdef NOTDEFINED
    for (p = (name + length - 1); p >= name; p--) {
#endif                          /* NOTDEFINED */
        /* 
         **  Scan left-to-right for a fragment (anchor).
         */
        for (p = after_access; *p; p++) {
            if (*p == '#') {
                parts->anchor = (p + 1);
                *p = '\0';      /* terminate the rest */
            }
        }

        /* 
         **  Scan left-to-right for a host or absolute path.
         */
        p = after_access;
        if (*p == '/') {
            if (p[1] == '/') {
                parts->host = (p + 2);  /* host has been specified */
                *p = '\0';      /* Terminate access */
                p = strchr(parts->host, '/');   /* look for end of host name if any */
                if (p != NULL) {
                    *p = '\0';  /* Terminate host */
                    parts->absolute = (p + 1);  /* Root has been found */
                }
            } else {
                parts->absolute = (p + 1);      /* Root found but no host */
            }
        } else {
            parts->relative = (*after_access) ? after_access : NULL;    /* NULL for
                                                                         * "" */
        }

        /* 
         **  Check schemes that commonly have unescaped hashes.
         */
        if (parts->access && parts->anchor) {
            if ((!parts->host && strcasecomp(parts->access, "lynxcgi")) ||
                !strcasecomp(parts->access, "nntp") ||
                !strcasecomp(parts->access, "snews") ||
                !strcasecomp(parts->access, "news") ||
                !strcasecomp(parts->access, "data")) {
                /* 
                 *  Access specified but no host and not a lynxcgi URL, so the
                 *  anchor may not really be one, e.g., news:j462#36487@foo.bar,
                 *  or it's an nntp or snews URL, or news URL with a host.
                 *  Restore the '#' in the address.
                 */
                *(parts->anchor - 1) = '#';
                parts->anchor = NULL;
            }
        }
#ifdef NOT_DEFINED              /* search is just treated as part of path */
        {
            char           *p = (relative ? relative : absolute);
            if (p != NULL) {
                char           *q = strchr(p, '?');     /* Any search string? */
                if (q != NULL) {
                    *q = '\0';  /* If so, chop that off. */
                    parts->search = (q + 1);
                }
            }
        }
#endif                          /* NOT_DEFINED */
    }                           /* scan */


/*      Parse a Name relative to another name.                  HTParse()
   **   --------------------------------------
   **
   **   This returns those parts of a name which are given (and requested)
   **   substituting bits from the related name where necessary.
   **
   ** On entry,
   **   aName           A filename given
   **      relatedName     A name relative to which aName is to be parsed
   **      wanted          A mask for the bits which are wanted.
   **
   ** On exit,
   **   returns         A pointer to a malloc'd string which MUST BE FREED
 */
    PUBLIC char    *HTParse ARGS3(CONST char *, aName,
                                  CONST char *, relatedName, int, wanted) {
        char           *result = NULL;
        char           *return_value = NULL;
        int             len;
        char           *name = NULL;
        char           *rel = NULL;
        char           *p;
        char           *access;
        struct struct_parts given, related;

        if (TRACE)
            fprintf(stderr,
                    "HTParse: aName:%s   relatedName:%s\n", aName, relatedName);

        /* 
         **  Allocate the output string.
         */
        len = strlen(aName) + strlen(relatedName) + 10;
        result = (char *) malloc(len);  /* Lots of space: more than enough */
        if (result == NULL)
            outofmem(__FILE__, "HTParse");
        result[0] = '\0';       /* Clear string */

        /* 
         **  Make working copies of the input strings to cut up.
         */
        StrAllocCopy(name, aName);
        StrAllocCopy(rel, relatedName);

        /* 
         **  Cut up the strings into URL fields.
         */
        scan(name, &given);
        scan(rel, &related);

        /* 
         **  Handle the scheme (access) field.
         */
        if (given.access && given.host && !given.relative && !given.absolute) {
            if (!strcmp(given.access, "http") ||
                !strcmp(given.access, "https") || !strcmp(given.access, "ftp"))
                /* 
                 **  Assume root.
                 */
                given.absolute = "";
        }
        access = given.access ? given.access : related.access;
        if (wanted & PARSE_ACCESS) {
            if (access) {
                strcat(result, access);
                if (wanted & PARSE_PUNCTUATION)
                    strcat(result, ":");
            }
        }

        /* 
         **  If different schemes, inherit nothing.
         **
         **  We'll try complying with RFC 1808 and
         **  the Fielding draft, and inherit nothing
         **  if both schemes are given, rather than
         **  only when they differ, except for
         **  file URLs - FM
         **
         **  After trying it for a while, it's still
         **  premature, IHMO, to go along with it, so
         **  this is back to inheriting for identical
         **  schemes whether or not they are "file".
         **  If you want to try it again yourself,
         **  uncomment the strncasecomp() below. - FM
         */
        if ((given.access && related.access) && (       /* strcasecomp(given.access, 
                                                         * "file") || */
                                                    strcmp(given.access,
                                                           related.access))) {
            related.host = NULL;
            related.absolute = NULL;
            related.relative = NULL;
            related.anchor = NULL;
        }

        /* 
         **  Handle the host field.
         */
        if (wanted & PARSE_HOST)
            if (given.host || related.host) {
                char           *tail = result + strlen(result);
                if (wanted & PARSE_PUNCTUATION)
                    strcat(result, "//");
                strcat(result, given.host ? given.host : related.host);
#define CLEAN_URLS
#ifdef CLEAN_URLS
                /* 
                 **  Ignore default port numbers, and trailing dots on FQDNs,
                 **  which will only cause identical addresses to look different.
                 */
                {
                    char           *p, *h;
                    p = strchr(tail, ':');
                    if (p != NULL && !isdigit((unsigned char) p[1]))
                        /* 
                         **  Colon not followed by a port number.
                         */
                        *p = '\0';
                    if (p != NULL && p != '\0' && access != NULL) {
                        /* 
                         **  Port specified.
                         */
                        if ((!strcmp(access, "http") && !strcmp(p, ":80")) ||
                            (!strcmp(access, "gopher") && !strcmp(p, ":70")) ||
                            (!strcmp(access, "ftp") && !strcmp(p, ":21")) ||
                            (!strcmp(access, "wais") && !strcmp(p, ":210")) ||
                            (!strcmp(access, "nntp") && !strcmp(p, ":119")) ||
                            (!strcmp(access, "news") && !strcmp(p, ":119")) ||
                            (!strcmp(access, "snews") && !strcmp(p, ":563")) ||
                            (!strcmp(access, "finger") && !strcmp(p, ":79")) ||
                            (!strcmp(access, "cso") && !strcmp(p, ":105")))
                            *p = '\0';  /* It is the default: ignore it */
                    }
                    if (p == NULL) {
                        int             len = strlen(tail);

                        if (len > 0) {
                            h = tail + len - 1; /* last char of hostname */
                            if (*h == '.')
                                *h = '\0';      /* chop final . */
                        }
                    } else {
                        h = p;
                        h--;    /* End of hostname */
                        if (*h == '.') {
                            /* 
                             **  Slide p over h.
                             */
                            while (*p != '\0')
                                *h++ = *p++;
                            *h = '\0';  /* terminate */
                        }
                    }
                }
#endif                          /* CLEAN_URLS */
            }

        /* 
         **  If different hosts, inherit no path.
         */
        if (given.host && related.host)
            if (strcmp(given.host, related.host) != 0) {
                related.absolute = NULL;
                related.relative = NULL;
                related.anchor = NULL;
            }

        /* 
         **  Handle the path.
         */
        if (wanted & PARSE_PATH) {
            if (access && !given.absolute && given.relative) {
                if (!strcasecomp(access, "nntp") ||
                    !strcasecomp(access, "snews") ||
                    (!strcasecomp(access, "news") &&
                     !strncasecomp(result, "news://", 7))) {
                    /* 
                     *  Treat all given nntp or snews paths,
                     *  or given paths for news URLs with a host,
                     *  as absolute.
                     */
                    given.absolute = given.relative;
                    given.relative = NULL;
                }
            }
            if (given.absolute) {       /* All is given */
                if (wanted & PARSE_PUNCTUATION)
                    strcat(result, "/");
                strcat(result, given.absolute);
                if (TRACE)
                    fprintf(stderr, "1\n");
            } else if (related.absolute) {      /* Adopt path not name */
                strcat(result, "/");
                strcat(result, related.absolute);
                if (given.relative) {
                    p = strchr(result, '?');    /* Search part? */
                    if (p == NULL)
                        p = (result + strlen(result) - 1);
                    for (; *p != '/'; p--);     /* last / */
                    p[1] = '\0';        /* Remove filename */
                    strcat(result, given.relative);     /* Add given one */
                    HTSimplify(result);
                }
                if (TRACE)
                    fprintf(stderr, "2\n");
            } else if (given.relative) {
                strcat(result, given.relative); /* what we've got */
                if (TRACE)
                    fprintf(stderr, "3\n");
            } else if (related.relative) {
                strcat(result, related.relative);
                if (TRACE)
                    fprintf(stderr, "4\n");
            } else {            /* No inheritance */
                if (strncasecomp(aName, "lynxcgi:", 8) &&
                    strncasecomp(aName, "lynxexec:", 9) &&
                    strncasecomp(aName, "lynxprog:", 9)) {
                    strcat(result, "/");
                }
                if (!strcmp(result, "news:/"))
                    result[5] = '*';
                if (TRACE)
                    fprintf(stderr, "5\n");
            }
        }

        /* 
         **  Handle the fragment (anchor).
         */
        if (wanted & PARSE_ANCHOR)
            if ((given.anchor && *given.anchor) || (!given.anchor && related.anchor)) {
                if (wanted & PARSE_PUNCTUATION)
                    strcat(result, "#");
                strcat(result, (given.anchor) ? given.anchor : related.anchor);
            }
        if (TRACE)
            fprintf(stderr, "HTParse: result:%s\n", result);
        FREE(rel);
        FREE(name);

        StrAllocCopy(return_value, result);
        FREE(result);

        return return_value;    /* exactly the right length */
    }

/*      Simplify a filename.                            HTSimplify()
   **   --------------------
   **
   **  A unix-style file is allowed to contain the seqeunce xxx/../ which may
   **  be replaced by "" , and the seqeunce "/./" which may be replaced by "/".
   **  Simplification helps us recognize duplicate filenames.
   **
   **   Thus,   /etc/junk/../fred       becomes /etc/fred
   **           /etc/junk/./fred        becomes /etc/junk/fred
   **
   **      but we should NOT change
   **           http://fred.xxx.edu/../..
   **
   **   or      ../../albert.html
 */
    PUBLIC void HTSimplify ARGS1(char *, filename) {
        char           *p;
        char           *q, *q1;

        if (filename == NULL)
            return;

        if ((filename[0] && filename[1]) && strchr(filename, '/') != NULL) {
            for (p = (filename + 2); *p; p++) {
                if (*p == '/') {
                    if ((p[1] == '.') && (p[2] == '.') &&
                        (p[3] == '/' || p[3] == '\0')) {
                        /* 
                         **  Handle "/../" or "/..".
                         */
                        for (q = (p - 1); (q >= filename) && (*q != '/'); q--)
                            /* 
                             **  Back up to previous slash or beginning of string.
                             */
                            ;
                        if ((q[0] == '/') && strncmp(q, "/../", 4) &&
                            !((q - 1) > filename && q[-1] == '/')) {
                            /* 
                             **  Not at beginning of string or in a
                             **  host field, so remove the "/xxx/..".
                             */
                            q1 = (p + 3);
                            p = q;
                            while (*q1 != '\0')
                                *p++ = *q1++;
                            *p = '\0';  /* terminate */
#ifdef NOTDEFINED
                            /* 
                             **  Make sure filename has at least one slash.
                             */
                            if (*filename == '\0') {
                                *filename = '/';
                                *(filename + 1) = '\0';
                            }
#endif                          /* NOTDEFINED */
                            /* 
                             **  Start again with previous slash.
                             */
                            p = (q - 1);
                        }
                    } else if (p[1] == '.' && p[2] == '/') {
                        /* 
                         **  Handle "./" by removing the characters.
                         */
                        q = p;
                        q1 = (p + 2);
                        while (*q1 != '\0')
                            *q++ = *q1++;
                        *q = '\0';      /* terminate */
                        p--;
                    } else if (p[1] == '.' && p[2] == '\0') {
                        /* 
                         **  Handle terminal "." by removing the character.
                         */
                        p[1] = '\0';
                    }
                }
            }
        }
    }

/*      Make Relative Name.                                     HTRelative()
   **   -------------------
   **
   ** This function creates and returns a string which gives an expression of
   ** one address as related to another. Where there is no relation, an absolute
   ** address is retured.
   **
   **  On entry,
   **   Both names must be absolute, fully qualified names of nodes
   **   (no anchor bits)
   **
   **  On exit,
   **   The return result points to a newly allocated name which, if
   **   parsed by HTParse relative to relatedName, will yield aName.
   **   The caller is responsible for freeing the resulting name later.
   **
 */
    PUBLIC char    *HTRelative ARGS2(CONST char *, aName, CONST char *, relatedName) {
        char           *result = NULL;
        CONST char     *p = aName;
        CONST char     *q = relatedName;
        CONST char     *after_access = NULL;
        CONST char     *path = NULL;
        CONST char     *last_slash = NULL;
        int             slashes = 0;

        for (; *p; p++, q++) {  /* Find extent of match */
            if (*p != *q)
                break;
            if (*p == ':')
                after_access = p + 1;
            if (*p == '/') {
                last_slash = p;
                slashes++;
                if (slashes == 3)
                    path = p;
            }
        }

        /* q, p point to the first non-matching character or zero */

        if (!after_access) {    /* Different access */
            StrAllocCopy(result, aName);
        } else if (slashes < 3) {       /* Different nodes */
            StrAllocCopy(result, after_access);
        } else if (slashes == 3) {      /* Same node, different path */
            StrAllocCopy(result, path);
        } else {                /* Some path in common */
            int             levels = 0;
            for (; *q && (*q != '#'); q++)
                if (*q == '/')
                    levels++;
            result = (char *) malloc(3 * levels + strlen(last_slash) + 1);
            if (result == NULL)
                outofmem(__FILE__, "HTRelative");
            result[0] = '\0';
            for (; levels; levels--)
                strcat(result, "../");
            strcat(result, last_slash + 1);
        }
        if (TRACE)
            fprintf(stderr, "HT: `%s' expressed relative to\n    `%s' is\n   `%s'.",
                    aName, relatedName, result);
        return result;
    }