#ifndef uri_H
#define uri_H
//#define _XOPEN_SOURCE 500 //for strdup
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
//uri_reserved = gen-delims / sub-delims
#define pe_gen_delims ":/?#[]@"
#define pe_sub_delims "!$&'()*+,;="
//char *pe_reserved[]=pe_gen_delims "" pe_sub_delims;
#define pe_ALPHA "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define pe_DIGIT "0123456789"
#define pe_HPUT "-._~"
//char *pe_unreserved[]=pe_ALPHA "" pe_DIGIT "" pe_HPUT;
unsigned char rfc3086_percent_encoding[256];
#define isxdigit(a) ((a >= 'a' && a <= 'f') || (a >= '0' && a <= '9') || (a >= 'A' && a <= 'F'))
#define toupper(a) ((a >= 'a' && a <= 'z')?a-' ':a)
char *uri_reserved={
pe_gen_delims
pe_sub_delims
pe_ALPHA
pe_DIGIT
pe_HPUT
};
int uriescapelength(unsigned char *in,int len) {
int rlen=0;//be sure to add one to this return value if you plan on putting a null byte at the end.
int i;
for(i=0;i<len;i++) {
rlen+=strchr(uri_reserved,in[i])?1:3;
}
return rlen;
}
// make sure your out char * has enough space! use uriescapelength for it.
void uriescape(unsigned char *in,unsigned char *out,int len) {
int i;
int j;
for(i=0,j=0;i<len;i++) {
if(strchr(uri_reserved,in[i])) {
out[j]=in[i];
j++;
} else {
out[j]='%';
j++;
out[j]="0123456789ABCDEF"[((in[i] >> 4) % 16)];
j++;
out[j]="0123456789ABCDEF"[(in[i] % 16)];
j++;
}
}
}
int uriunescape(char *in,char *out) {
char *o=out;
char *t;
char a,b;
char *s=in;
while((t=strchr(s,'%'))) {
if(t-s) {//if there are actually bytes to copy.
memmove(o,s,t-s);
o+=(t-s);
s+=(t-s);
}
if(isxdigit(t[1]) && isxdigit(t[2])) {
s+=3;//skip the %XX
a=toupper(t[1]);
b=toupper(t[2]);
*o=((a-'0'<10 ? a-'0' : a-'A'+10) << 4) + (b-'0'<10 ? b-'0' : b-'A'+10);
o++;
} else {
s++;//skip just the %. the next character might be a % //TODO: look up what the "right" thing to do here is.
*o='%';
o++;
}
}
//copy the last part.
memmove(o,s,strlen(s));
o[strlen(s)]=0;
return o+strlen(s)-out;
}
struct uri {//warning. it is technically undefined behavior to set one half of a union then use the other half.
union {
char *A[8];
struct {
union { char *s;char *scheme; };
union { char *u;char *username; };
union { char *k;char *password; };
union { char *d;char *domain; };
union { char *P;char *port; };
union { char *p;char *path; };
union { char *q;char *query_string; };
union { char *f;char *fragment_id; };
};
};
};
//returns 0 on success, returns a byte with bits set for non-matching pieces.
unsigned int uricmp(struct uri *a,struct uri *b) {
int i;
int ret=0;
for(i=0;i<8;i++) {
if(a->A[i] && !b->A[i]) ret |=(1<<(i+8));//we have a's but not b's
if(!a->A[i] && b->A[i]) ret |=(1<<(i+16));
//for testing if(!a->A[i] && !b->A[i]) ret |=(1<<(i+24));//no problem here. both empty.
if(a->A[i] && b->A[i]) {
if(strcmp(a->A[i],b->A[i])) {
ret|=(1<<i);
}
}
}
return ret;
}
char *linefromuri(struct uri *u) {
char *line=malloc(2048);//fuck if I know
strcpy(line,"");
if(u->scheme) {
strcat(line,u->scheme);
}
if(u->scheme && u->domain) {
strcat(line,"://");
}
if(u->scheme && !u->domain) {
strcat(line,":");
}
if(u->username && u->domain) {
strcat(line,u->username);
}
if(u->password && u->username && u->domain) {//we /should/ only have a password if there's a username AND domain
strcat(line,":");
strcat(line,u->password);
}
if(u->username && u->domain) {
strcat(line,"@");
}
if(u->domain) {
strcat(line,u->domain);
}
if(u->port && u->domain) { //port only makes sense if there's a domain
strcat(line,":");
strcat(line,u->port);
}
if(u->path && u->scheme && !u->domain) {
strcat(line,u->path);
}
if(u->path && u->scheme && u->domain) {
if(*u->path != '/') {
strcat(line,"/");
}
strcat(line,u->path);
//path must start with / if we have domain.
}
if(u->query_string) {
strcat(line,"?");
strcat(line,u->query_string);
}
if(u->fragment_id) {
strcat(line,"#");
strcat(line,u->fragment_id);
}
return line;
}
/*
schemes are case sensitive but cononicals are lower case.
domain is case insensitive. return it lowercased?
port is optional and in decimal
path
scheme://username:password@domain:port/path?query_string#fragment_id
mailto:username@domain
optional stuff:
scheme, username, password, port, path, query_string, fragment_id
*/
//should it be a dick about what characters are allowed?
//should it just try to ignore weird shit?
//return 0 on fail //not sure what this means.
//return 1 on success
int urifromline(struct uri *u,char *line) {
//these first two are easy. the rest... not so much.
char *t;
// memset(u,0,sizeof(struct uri)); //this function shouldn't do this.
if((u->fragment_id=strchr(line,'#'))) {
*u->fragment_id=0;
u->fragment_id++;
}
if((u->query_string=strchr(line,'?'))) {
*u->query_string=0;
u->query_string++;
}
//now we have scheme, user, pass, domain, port, and path. maybe.
//what character can we split on now? : is a terrible choice.
// how about /? first / is either a separator between scheme
//could find the first non-scheme character.
//so we might have... scheme://user:pass@host:port/path
//or... user:pass@host:port/path ?
//we need to do this based on /s
// we're either going to find the scheme and authority separator
// or we're going to find the start of a path.
//there: scheme:/path, scheme://host (empty path), or scheme:path/morepath
//or... should we do paths without
//scheme must start with a-z
/* if(*line == '/' && *(line+1) != '/') { //we have a relative path. /like:this.maybe
u->path=line;
return;//we're done. nothing else to do.
}
if(*line == '.') { //we have a relative path like: ./derp or ../merp
u->path=line;
return;//we're done here. nothing else to do.
}*/
//let's see if this starts with a scheme
if(strchr(line,':') && ((*line >= 'a' && *line <= 'z') || (*line >= 'A' && *line <= 'Z'))) {
for(u->scheme=strchr(line,':')-1;u->scheme > line;u->scheme--) {
if((*u->scheme >= 'a' && *u->scheme <= 'z') ||
(*u->scheme >= 'A' && *u->scheme <= 'Z') ||
(*u->scheme >= '0' && *u->scheme <= '9') ||
*u->scheme == '+' || *u->scheme == '-' || *u->scheme == '.') {
//this is still a scheme.
} else {
break;
}
}
if(u->scheme == line) {//we got through the for loop alright. line starts with a scheme.
line=strchr(line,':');
*line=0;
line++;
for(t=u->scheme;*t;t++) {
if(*t >= 'A' && *t <= 'Z') *t+=' ';
}
}
}
//copy-pasted from above the scheme strip attempt.
if(*line == '/' && *(line+1) != '/') { //we have a relative path. /like:this.maybe
u->path=line;
return 1;//we're done. nothing else to do.
}
if(*line == '.') { //we have a relative path like: ./derp or ../merp
u->path=line;
return 1;//we're done here. nothing else to do.
}
if(*line == '/' && line[1] == '/') {//we have an authority section.
//let's left-shift this shit over until the third /
for(t=line+1;*(t+1) && *(t+1) != '/';t++) {
*t=*(t+1);
}
*t=0;
u->path=t+1;//if there was a /, path points at it and the stuff after.
//if there wasn't a /, it points at a null byte. so "empty"
u->username=line+1;
} else {
//we're an authority section without a // I guess.
//or we're a path
if(u->scheme) u->path=line;
else u->username=line;//if we have a scheme we're not a //-less authority
}
if(u->username) {//this contains all of the authority.
if((u->domain=strchr(u->username,'@'))) {//we have user@host at least.
*u->domain=0;
u->domain++;
} else {//this isn't really a username. it is the domain.
u->domain=u->username;
u->username=0;
}
}
//if we still have u->username we try to split to user and password
if(u->username) {
if((u->password=strchr(u->username,':'))) {
*u->password=0;
u->password++;
}
}
if(u->domain) {
if((u->port=strchr(u->domain,']')) && *u->domain == '[') {//this is an IPv6 host
*u->port=0;
u->port++;
u->domain++;//we need to skip the leading [
if(*u->port == ':') {
*u->port=0;
u->port++;//if it ends up being empty, whatever. that's a URI like: http://host:/path
}
} else { //we're safe to split port off at :
if((u->port=strchr(u->domain,':'))) {
*u->port=0;
u->port++;
} //there isn't a port. leave it unset.
}
}
//I dunno.<
