gopher/url.c
Kelvin Sherlock 340846cd57 re org code
2012-04-15 21:48:58 -04:00

437 lines
9.6 KiB
C

#pragma optimize 79
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "url.h"
enum {
kScheme,
kUser,
kPassword,
kHost,
kPort,
kPath,
kParams,
kQuery,
kFragment
};
extern void parse_scheme(const char *cp, unsigned size, URLComponents *c);
/*
* scheme://username:password@domain:port/path;parms?query_string#fragment_id
*
*
*/
int URLComponentGetC(const char *url, URLComponents *components, int type, char *dest)
{
URLRange *rangePtr;
URLRange r;
if (!url || !components) return -1;
if (type < URLComponentScheme || type > URLComponentPathAndQuery) return -1;
rangePtr = &components->scheme;
r = rangePtr[type];
if (!dest) return r.length;
else
{
if (r.length)
{
memcpy(dest, url + r.location, r.length);
}
dest[r.length] = 0;
return r.length;
}
}
// pstring.
int URLComponentGet(const char *url, URLComponents *components, int type, char *dest)
{
URLRange *rangePtr;
URLRange r;
if (!url || !components) return -1;
if (type < URLComponentScheme || type > URLComponentPathAndQuery) return -1;
rangePtr = &components->scheme;
r = rangePtr[type];
if (!dest) return r.length;
else if (r.length > 255) return -1;
else
{
dest[0] = r.length;
if (r.length)
{
memcpy(dest + 1, url + r.location, r.length);
}
return r.length;
}
}
int ParseURL(const char *url, int length, struct URLComponents *components)
{
char c;
int state;
int hasScheme;
int hasAt;
int i, l;
URLRange range = { 0, 0 };
URLRange *rangePtr;
if (!components || !url) return 0;
rangePtr = &components->scheme;
memset(components, 0, sizeof(URLComponents));
state = kScheme;
// 1 check for a scheme.
// [A-Za-z0-9.+-]+ ':'
hasScheme = 0;
hasAt = 0;
range.location = 0;
for(i = 0; i < length; ++i)
{
c = url[i];
if (c == ':')
{
hasScheme = 1;
break;
}
if (c >= 'a' && c <= 'z') continue;
if (c >= 'A' && c <= 'Z') continue;
if (c >= '0' && c <= '9') continue;
//if (isalnum(c)) continue;
if (c == '.') continue;
if (c == '+') continue;
if (c == '-') continue;
break;
}
if (hasScheme)
{
if (i == 0) return 0;
range.length = i;
components->scheme = range;
parseScheme(url, i, components);
++i; // skip the ':'
}
else
{
state = kPath;
i = 0;
}
// 2. check for //
// //user:password@domain:port/
// otherwise, it's a path
if (strncmp(url + i, "//", 2) == 0)
{
state = kUser;
i += 2;
}
else
{
state = kPath;
}
//range = (URLRange){ i, 0 };
range.location = i; range.length = 0;
for( ; i < length; ++i)
{
c = url[i];
if ((c < 32) || (c & 0x80))
{
// goto invalid_char;
return 0;
}
switch(c)
{
// illegal chars.
// % # not allowed but allowed.
case ' ':
case '"':
case '<':
case '>':
case '[':
case '\\':
case ']':
case '^':
case '`':
case '{':
case '|':
case '}':
case 0x7f:
// goto invalid_char;
return 0;
break;
case ':':
// username -> password
// domain -> port
// password -> error
// port -> error
// all others, no transition.
switch(state)
{
case kUser:
case kHost:
l = i - range.location;
if (l > 0)
{
range.length = l;
rangePtr[state] = range;
}
//range = (URLRange){ i + 1 , 0 };
range.location = i + 1; range.length = 0;
state++;
break;
case kPassword:
case kPort:
return 0;
}
break;
case '@':
// username -> domain
// password -> domain
// all others no transition.
// path -> error?
switch(state)
{
case kUser:
case kPassword:
hasAt = 1;
l = i - range.location;
if (l > 0)
{
range.length = l;
rangePtr[state] = range;
}
//range = (URLRange){ i + 1 , 0 };
range.location = i + 1; range.length = 0;
state = kHost;
break;
}
break;
case '/':
// domain -> path
// port -> path
// (must be switched to domain:port)
// username -> path
// password -> path
// all others, no transition.
// '/' is part of the filename.
switch (state)
{
case kUser:
hasAt = 1; // close enough
state = kHost; // username was actually the domain.
// pass through.
case kPassword: // need to switch to domain:port later.
case kHost:
case kPort:
l = i - range.location;
if (l > 0)
{
range.length = l;
rangePtr[state] = range;
}
//range = (URLRange){ i, 0 }; // '/' is part of path.
range.location = i; range.length = 0;
state = kPath;
break;
}
break;
case ';':
// path -> param
// all others, no transition.
if (state == kPath)
{
l = i - range.location;
if (l > 0)
{
range.length = l;
rangePtr[state] = range;
}
//range = (URLRange){ i + 1 , 0 };
range.location = i + 1; range.length = 0;
state = kParams;
}
break;
case '?':
// path -> query
// param -> query
// all others, no transition.
if (state == kPath || state == kParams)
{
l = i - range.location;
if (l > 0)
{
range.length = l;
rangePtr[state] = range;
}
//range = (URLRange){ i + 1 , 0 };
range.location = i + 1; range.length = 0;
state = kQuery;
}
break;
case '#':
// fragment -> no transition
// everything else transitions to a fragment.
// can immediately end parsing since we know the length...
l = i - range.location;
if (l > 0)
{
range.length = l;
rangePtr[state] = range;
}
state = kFragment;
range.location = i + 1; range.length = 0;
i = length; // break from loop.
break;
}
}
// finish up the last portion.
if (state)
{
l = i - range.location;
if (l > 0)
{
range.length = l;
rangePtr[state] = range;
}
}
if (!hasAt)
{
// user:name was actually domain:port
components->host = components->user;
components->port = components->password;
components->user.location = 0;
components->user.length = 0;
components->password.location = 0;
components->password.length = 0;
}
// port number conversion.
if (components->port.location)
{
const char *tmp = url + components->port.location;
int p = 0;
l = components->port.length;
for (i = 0; i < l; ++i)
{
c = tmp[i];
if ((c < '0') || (c > '9'))
{
p = 0;
break;
}
// convert to number.
c &= 0x0f;
// p *= 10;
// 10x = 2x + 8x = (x << 1) + (x << 3)
if (p)
{
int p2;
p2 = p << 1;
p = p2 << 2;
p = p + p2;
}
p += c;
}
components->portNumber = p;
}
#if 0
// path and query.
// path;params?query
range = components->path;
if (range.length)
{
if (components->params.length)
range.length += components->params.length + 1;
if (components->query.length)
range.length += components->query.length + 1;
components->pathAndQuery = range;
}
#endif
return 1;
}