summaryrefslogtreecommitdiff
path: root/pith/url.c
diff options
context:
space:
mode:
Diffstat (limited to 'pith/url.c')
-rw-r--r--pith/url.c542
1 files changed, 542 insertions, 0 deletions
diff --git a/pith/url.c b/pith/url.c
new file mode 100644
index 00000000..173cb879
--- /dev/null
+++ b/pith/url.c
@@ -0,0 +1,542 @@
+#if !defined(lint) && !defined(DOS)
+static char rcsid[] = "$Id: url.c 769 2007-10-24 00:15:40Z hubert@u.washington.edu $";
+#endif
+
+/*
+ * ========================================================================
+ * Copyright 2006-2007 University of Washington
+ * Copyright 2013 Eduardo Chappa
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * ========================================================================
+ */
+
+#include "../pith/headers.h"
+#include "../pith/url.h"
+#include "../pith/mailview.h"
+#include "../pith/string.h"
+
+/*
+ * Internal prototypes
+ */
+char *rfc1738_scheme_part(char *);
+int rfc1738uchar(char *);
+int rfc1738xchar(char *);
+
+
+/*
+ * * * * * * * * * RFC 1738 support routines * * * * * * * *
+ */
+
+
+/*
+ * Various helpful definitions
+ */
+#define RFC1738_SAFE "$-_.+" /* "safe" */
+#define RFC1738_EXTRA "!*'()," /* "extra" */
+#define RFC1738_RSVP ";/?:@&=" /* "reserved" */
+#define RFC1738_NEWS "-.+_" /* valid for "news:" URL */
+#define RFC1738_FUDGE "#{}|\\^~[]" /* Unsafe, but popular */
+#define RFC1738_ESC(S) (*(S) == '%' && isxpair((S) + 1))
+
+
+/*
+ * rfc1738_scan -- Scan the given line for possible URLs as defined
+ * in RFC1738
+ */
+char *
+rfc1738_scan(char *line, int *len)
+{
+ char *colon, *start, *end;
+ int n;
+
+ /* process each : in the line */
+ for(; (colon = strindex(line, ':')) != NULL; line = end){
+ end = colon + 1;
+ if(colon == line) /* zero length scheme? */
+ continue;
+
+ /*
+ * Valid URL (ala RFC1738 BNF)? First, first look to the
+ * left to make sure there are valid "scheme" chars...
+ */
+ start = colon - 1;
+ while(1)
+ if(!(isdigit((unsigned char) *start)
+ || isalpha((unsigned char) *start)
+ || strchr("+-.", *start))){
+ start++; /* advance over bogus char */
+ break;
+ }
+ else if(start > line)
+ start--;
+ else
+ break;
+
+ /*
+ * Make sure everyhing up to the colon is a known scheme...
+ */
+ if(start && (n = colon - start) && !isdigit((unsigned char) *start)
+ && (((n == 3
+ && (*start == 'F' || *start == 'f')
+ && !struncmp(start+1, "tp", 2))
+ || (n == 4
+ && (((*start == 'H' || *start == 'h')
+ && !struncmp(start + 1, "ttp", 3))
+ || ((*start == 'N' || *start == 'n')
+ && !struncmp(start + 1, "ews", 3))
+ || ((*start == 'N' || *start == 'n')
+ && !struncmp(start + 1, "ntp", 3))
+ || ((*start == 'W' || *start == 'w')
+ && !struncmp(start + 1, "ais", 3))
+#ifdef ENABLE_LDAP
+ || ((*start == 'L' || *start == 'l')
+ && !struncmp(start + 1, "dap", 3))
+#endif
+ || ((*start == 'I' || *start == 'i')
+ && !struncmp(start + 1, "map", 3))
+ || ((*start == 'F' || *start == 'f')
+ && !struncmp(start + 1, "ile", 3))))
+ || (n == 5
+ && (*start == 'H' || *start == 'h')
+ && !struncmp(start+1, "ttps", 4))
+ || (n == 6
+ && (((*start == 'G' || *start == 'g')
+ && !struncmp(start+1, "opher", 5))
+ || ((*start == 'M' || *start == 'm')
+ && !struncmp(start + 1, "ailto", 5))
+ || ((*start == 'T' || *start == 't')
+ && !struncmp(start + 1, "elnet", 5))))
+ || (n == 8
+ && (*start == 'P' || *start == 'p')
+ && !struncmp(start + 1, "rospero", 7))
+ || (n == 11
+ && (*start == 'x' || *start == 'X')
+ && !struncmp(start + 1, "-pine-help", 10))
+ || (n == 13
+ && (*start == 'x' || *start == 'X')
+ && !struncmp(start + 1, "-alpine-help", 12)))
+ || url_external_specific_handler(start, n))){
+ /*
+ * Second, make sure that everything to the right of the
+ * colon is valid for a "schemepart"...
+ */
+
+ if((end = rfc1738_scheme_part(colon + 1)) - colon > 1){
+ int i, j;
+
+ /* make sure something useful follows colon */
+ for(i = 0, j = end - colon; i < j; i++)
+ if(!strchr(RFC1738_RSVP, colon[i]))
+ break;
+
+ if(i != j){
+ *len = end - start;
+
+ /*
+ * Special case handling for comma.
+ * See the problem is comma's valid, but if it's the
+ * last character in the url, it's likely intended
+ * as a delimiter in the text rather part of the URL.
+ * In most cases any way, that's why we have the
+ * exception.
+ */
+ if(*(end - 1) == ','
+ || (*(end - 1) == '.' && (!*end || *end == ' ')))
+ (*len)--;
+
+ if(*len - (colon - start) > 0)
+ return(start);
+ }
+ }
+ }
+ }
+
+ return(NULL);
+}
+
+
+/*
+ * rfc1738_scheme_part - make sure what's to the right of the
+ * colon is valid
+ *
+ * NOTE: we have a problem matching closing parens when users
+ * bracket the url in parens. So, lets try terminating our
+ * match on any closing paren that doesn't have a coresponding
+ * open-paren.
+ */
+char *
+rfc1738_scheme_part(char *s)
+{
+ int n, paren = 0, bracket = 0;
+
+ while(1)
+ switch(*s){
+ default :
+ if((n = rfc1738xchar(s)) != 0){
+ s += n;
+ break;
+ }
+
+ case '\0' :
+ return(s);
+
+ case '[' :
+ bracket++;
+ s++;
+ break;
+
+ case ']' :
+ if(bracket--){
+ s++;
+ break;
+ }
+
+ return(s);
+
+ case '(' :
+ paren++;
+ s++;
+ break;
+
+ case ')' :
+ if(paren--){
+ s++;
+ break;
+ }
+
+ return(s);
+ }
+}
+
+
+
+/*
+ * rfc1738_str - convert rfc1738 escaped octets in place
+ */
+char *
+rfc1738_str(char *s)
+{
+ register char *p = s, *q = s;
+
+ while(1)
+ switch(*q = *p++){
+ case '%' :
+ if(isxpair(p)){
+ *q = X2C(p);
+ p += 2;
+ }
+
+ default :
+ q++;
+ break;
+
+ case '\0':
+ return(s);
+ }
+}
+
+
+/*
+ * rfc1738uchar - returns TRUE if the given char fits RFC 1738 "uchar" BNF
+ */
+int
+rfc1738uchar(char *s)
+{
+ return((RFC1738_ESC(s)) /* "escape" */
+ ? 2
+ : (isalnum((unsigned char) *s) /* alphanumeric */
+ || strchr(RFC1738_SAFE, *s) /* other special stuff */
+ || strchr(RFC1738_EXTRA, *s)));
+}
+
+
+/*
+ * rfc1738xchar - returns TRUE if the given char fits RFC 1738 "xchar" BNF
+ */
+int
+rfc1738xchar(char *s)
+{
+ int n;
+
+ return((n = rfc1738uchar(s))
+ ? n
+ : (strchr(RFC1738_RSVP, *s) != NULL
+ || strchr(RFC1738_FUDGE, *s)));
+}
+
+
+/*
+ * rfc1738_num - return long value of a string of digits, possibly escaped
+ */
+unsigned long
+rfc1738_num(char **s)
+{
+ register char *p = *s;
+ unsigned long n = 0L;
+
+ for(; *p; p++)
+ if(*p == '%' && isxpair(p+1)){
+ int c = X2C(p+1);
+ if(isdigit((unsigned char) c)){
+ n = (c - '0') + (n * 10);
+ p += 2;
+ }
+ else
+ break;
+ }
+ else if(isdigit((unsigned char) *p))
+ n = (*p - '0') + (n * 10);
+ else
+ break;
+
+ *s = p;
+ return(n);
+}
+
+
+int
+rfc1738_group(char *s)
+{
+ return(isalnum((unsigned char) *s)
+ || RFC1738_ESC(s)
+ || strchr(RFC1738_NEWS, *s));
+}
+
+
+/*
+ * Encode (hexify) a mailto url.
+ *
+ * Args s -- src url
+ *
+ * Returns An allocated string which is suitably encoded.
+ * Result should be freed by caller.
+ *
+ * Since we don't know here which characters are reserved characters (? and &)
+ * for use in delimiting the pieces of the url and which are just those
+ * characters contained in the data that should be encoded, we always encode
+ * them. That's because we know we don't use those as reserved characters.
+ * If you do use those as reserved characters you have to encode each part
+ * separately.
+ */
+char *
+rfc1738_encode_mailto(char *s)
+{
+ char *d, *ret = NULL;
+
+ if(s){
+ /* Worst case, encode every character */
+ ret = d = (char *)fs_get((3*strlen(s) + 1) * sizeof(char));
+ while(*s){
+ if(isalnum((unsigned char)*s)
+ || strchr(RFC1738_SAFE, *s)
+ || strchr(RFC1738_EXTRA, *s))
+ *d++ = *s++;
+ else{
+ *d++ = '%';
+ C2XPAIR(*s, d);
+ s++;
+ }
+ }
+
+ *d = '\0';
+ }
+
+ return(ret);
+}
+
+
+/*
+ * * * * * * * * * RFC 1808 support routines * * * * * * * *
+ */
+
+
+int
+rfc1808_tokens(char *url, char **scheme, char **net_loc, char **path,
+ char **parms, char **query, char **frag)
+{
+ char *p, *q, *start, *tmp = cpystr(url);
+
+ start = tmp;
+ if((p = strchr(start, '#')) != NULL){ /* fragment spec? */
+ *p++ = '\0';
+ if(*p)
+ *frag = cpystr(p);
+ }
+
+ if((p = strchr(start, ':')) && p != start){ /* scheme part? */
+ for(q = start; q < p; q++)
+ if(!(isdigit((unsigned char) *q)
+ || isalpha((unsigned char) *q)
+ || strchr("+-.", *q)))
+ break;
+
+ if(p == q){
+ *p++ = '\0';
+ *scheme = cpystr(start);
+ start = p;
+ }
+ }
+
+ if(*start == '/' && *(start+1) == '/'){ /* net_loc */
+ if((p = strchr(start+2, '/')) != NULL)
+ *p++ = '\0';
+
+ *net_loc = cpystr(start+2);
+ if(p)
+ start = p;
+ else *start = '\0'; /* End of parse */
+ }
+
+ if((p = strchr(start, '?')) != NULL){
+ *p++ = '\0';
+ *query = cpystr(p);
+ }
+
+ if((p = strchr(start, ';')) != NULL){
+ *p++ = '\0';
+ *parms = cpystr(p);
+ }
+
+ if(*start)
+ *path = cpystr(start);
+
+ fs_give((void **) &tmp);
+
+ return(1);
+}
+
+
+
+/*
+ * web_host_scan -- Scan the given line for possible web host names
+ *
+ * NOTE: scan below is limited to DNS names ala RFC1034
+ */
+char *
+web_host_scan(char *line, int *len)
+{
+ char *end, last = '\0';
+
+ for(; *line; last = *line++)
+ if((*line == 'w' || *line == 'W')
+ && (!last || !(isalnum((unsigned char) last)
+ || last == '.' || last == '-' || last == '/'))
+ && (((*(line + 1) == 'w' || *(line + 1) == 'W') /* "www." */
+ && (*(line + 2) == 'w' || *(line + 2) == 'W'))
+ || ((*(line + 1) == 'e' || *(line + 1) == 'E') /* "web." */
+ && (*(line + 2) == 'b' || *(line + 2) == 'B')))
+ && (*(line + 3) == '.')){
+ end = rfc1738_scheme_part(line + 3);
+ if((*len = end - line) > ((*(line+3) == '.') ? 4 : 3)){
+ /* Dread comma exception, see note in rfc1738_scan */
+ if(strchr(",:", *(line + (*len) - 1))
+ || (*(line + (*len) - 1) == '.'
+ && (!*(line + (*len)) || *(line + (*len)) == ' ')))
+ (*len)--;
+
+ return(line);
+ }
+ else
+ line += 3;
+ }
+
+ return(NULL);
+}
+
+
+/*
+ * mail_addr_scan -- Scan the given line for possible RFC822 addr-spec's
+ *
+ * NOTE: Well, OK, not strictly addr-specs since there's alot of junk
+ * we're tying to sift thru and we'd like to minimize false-pos
+ * matches.
+ */
+char *
+mail_addr_scan(char *line, int *len)
+{
+ char *amp, *start, *end;
+/*
+ * This list is not the whole standards-based list, this is just a list
+ * of likely email address characters. We don't want to include everything
+ * because punctuation in the text might get mixed in with the address.
+ */
+#define NONALPHANUMOK ".-_+%/="
+
+ /* process each : in the line */
+ for(; (amp = strindex(line, '@')) != NULL; line = end){
+ end = amp + 1;
+ /* zero length addr? */
+ if(amp == line || !(isalnum((unsigned char) *(start = amp - 1))
+ || strchr(NONALPHANUMOK, *start)))
+ continue;
+
+ /*
+ * Valid address (ala RFC822 BNF)? First, first look to the
+ * left to make sure there are valid "scheme" chars...
+ */
+ while(1)
+ /* NOTE: we're not doing quoted-strings */
+ if(!(isalnum((unsigned char) *start) || strchr(NONALPHANUMOK, *start))){
+ /* advance over bogus char, and erase leading punctuation */
+ for(start++; *start && strchr(NONALPHANUMOK, *start); start++)
+ ;
+
+ break;
+ }
+ else if(start > line)
+ start--;
+ else
+ break;
+
+ /*
+ * Make sure everyhing up to the colon is a known scheme...
+ */
+ if(start && (amp - start) > 0){
+ /*
+ * Second, make sure that everything to the right of
+ * amp is valid for a "domain"...
+ */
+ if(*(end = amp + 1) == '['){ /* domain literal */
+ int dots = 3;
+
+ for(++end; *end ; end++)
+ if(*end == ']'){
+ if(!dots){
+ *len = end - start + 1;
+ return(start);
+ }
+ else
+ break; /* bogus */
+ }
+ else if(*end == '.'){
+ if(--dots < 0)
+ break; /* bogus */
+ }
+ else if(!isdigit((unsigned char) *end))
+ break; /* bogus */
+ }
+ else if(isalnum((unsigned char) *end)){ /* domain name? */
+ for(++end; ; end++)
+ if(!(*end && (isalnum((unsigned char) *end)
+ || *end == '-'
+ || *end == '.'
+ || *end == '_'))){
+ /* can't end with dash, dot or underscore */
+ while(!isalnum((unsigned char) *(end - 1)))
+ end--;
+
+ *len = end - start;
+ return(start);
+ }
+ }
+ }
+ }
+
+ return(NULL);
+}
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2024-11-05 19:20:41 +0000