1 #include <u.h>
2 #include <libc.h>
3 #include <bin.h>
4 #include <httpd.h>
5 
6 typedef struct Strings		Strings;
7 
8 struct Strings
9 {
10 	char	*s1;
11 	char	*s2;
12 };
13 
14 static	char*		abspath(HConnect *cc, char *origpath, char *curdir);
15 static	int		getc(HConnect*);
16 static	char*		getword(HConnect*);
17 static	Strings		parseuri(HConnect *c, char*);
18 static	Strings		stripsearch(char*);
19 
20 /*
21  * parse the next request line
22  * returns:
23  *	1 ok
24  *	0 eof
25  *	-1 error
26  */
27 int
28 hparsereq(HConnect *c, int timeout)
29 {
30 	Strings ss;
31 	char *vs, *v, *search, *uri, *origuri, *extra;
32 
33 	if(c->bin != nil){
34 		hfail(c, HInternal);
35 		return -1;
36 	}
37 
38 	/*
39 	 * serve requests until a magic request.
40 	 * later requests have to come quickly.
41 	 * only works for http/1.1 or later.
42 	 */
43 	if(timeout)
44 		alarm(timeout);
45 	if(hgethead(c, 0) < 0)
46 		return -1;
47 	if(timeout)
48 		alarm(0);
49 	c->reqtime = time(nil);
50 	c->req.meth = getword(c);
51 	if(c->req.meth == nil){
52 		hfail(c, HSyntax);
53 		return -1;
54 	}
55 	uri = getword(c);
56 	if(uri == nil || strlen(uri) == 0){
57 		hfail(c, HSyntax);
58 		return -1;
59 	}
60 	v = getword(c);
61 	if(v == nil){
62 		if(strcmp(c->req.meth, "GET") != 0){
63 			hfail(c, HUnimp, c->req.meth);
64 			return -1;
65 		}
66 		c->req.vermaj = 0;
67 		c->req.vermin = 9;
68 	}else{
69 		vs = v;
70 		if(strncmp(vs, "HTTP/", 5) != 0){
71 			hfail(c, HUnkVers, vs);
72 			return -1;
73 		}
74 		vs += 5;
75 		c->req.vermaj = strtoul(vs, &vs, 10);
76 		if(*vs != '.' || c->req.vermaj != 1){
77 			hfail(c, HUnkVers, vs);
78 			return -1;
79 		}
80 		vs++;
81 		c->req.vermin = strtoul(vs, &vs, 10);
82 		if(*vs != '\0'){
83 			hfail(c, HUnkVers, vs);
84 			return -1;
85 		}
86 
87 		extra = getword(c);
88 		if(extra != nil){
89 			hfail(c, HSyntax);
90 			return -1;
91 		}
92 	}
93 
94 	/*
95 	 * the fragment is not supposed to be sent
96 	 * strip it 'cause some clients send it
97 	 */
98 	origuri = uri;
99 	uri = strchr(origuri, '#');
100 	if(uri != nil)
101 		*uri = 0;
102 
103 	/*
104 	 * http/1.1 requires the server to accept absolute
105 	 * or relative uri's.  convert to relative with an absolute path
106 	 */
107 	if(http11(c)){
108 		ss = parseuri(c, origuri);
109 		uri = ss.s1;
110 		c->req.urihost = ss.s2;
111 		if(uri == nil){
112 			hfail(c, HBadReq, uri);
113 			return -1;
114 		}
115 		origuri = uri;
116 	}
117 
118 	/*
119 	 * munge uri for search, protection, and magic
120 	 */
121 	ss = stripsearch(origuri);
122 	origuri = ss.s1;
123 	search = ss.s2;
124 	uri = hurlunesc(c, origuri);
125 	uri = abspath(c, uri, "/");
126 	if(uri == nil || uri[0] == '\0'){
127 		hfail(c, HNotFound, "no object specified");
128 		return -1;
129 	}
130 
131 	c->req.uri = uri;
132 	c->req.search = search;
133 	if(search)
134 		c->req.searchpairs = hparsequery(c, hstrdup(c, search));
135 
136 	return 1;
137 }
138 
139 static Strings
140 parseuri(HConnect *c, char *uri)
141 {
142 	Strings ss;
143 	char *urihost, *p;
144 
145 	urihost = nil;
146 	if(uri[0] != '/'){
147 		if(cistrncmp(uri, "http://", 7) != 0){
148 			ss.s1 = nil;
149 			ss.s2 = nil;
150 			return ss;
151 		}
152 		uri += 5;	/* skip http: */
153 	}
154 
155 	/*
156 	 * anything starting with // is a host name or number
157 	 * hostnames consists of letters, digits, - and .
158 	 * for now, just ignore any port given
159 	 */
160 	if(uri[0] == '/' && uri[1] == '/'){
161 		urihost = uri + 2;
162 		p = strchr(urihost, '/');
163 		if(p == nil)
164 			uri = hstrdup(c, "/");
165 		else{
166 			uri = hstrdup(c, p);
167 			*p = '\0';
168 		}
169 		p = strchr(urihost, ':');
170 		if(p != nil)
171 			*p = '\0';
172 	}
173 
174 	if(uri[0] != '/' || uri[1] == '/'){
175 		ss.s1 = nil;
176 		ss.s2 = nil;
177 		return ss;
178 	}
179 
180 	ss.s1 = uri;
181 	ss.s2 = hlower(urihost);
182 	return ss;
183 }
184 static Strings
185 stripsearch(char *uri)
186 {
187 	Strings ss;
188 	char *search;
189 
190 	search = strchr(uri, '?');
191 	if(search != nil)
192 		*search++ = 0;
193 	ss.s1 = uri;
194 	ss.s2 = search;
195 	return ss;
196 }
197 
198 /*
199  *  to circumscribe the accessible files we have to eliminate ..'s
200  *  and resolve all names from the root.
201  */
202 static char*
203 abspath(HConnect *cc, char *origpath, char *curdir)
204 {
205 	char *p, *sp, *path, *work, *rpath;
206 	int len, n, c;
207 
208 	if(curdir == nil)
209 		curdir = "/";
210 	if(origpath == nil)
211 		origpath = "";
212 	work = hstrdup(cc, origpath);
213 	path = work;
214 
215 	/*
216 	 * remove any really special characters
217 	 */
218 	for(sp = "`;| "; *sp; sp++){
219 		p = strchr(path, *sp);
220 		if(p)
221 			*p = 0;
222 	}
223 
224 	len = strlen(curdir) + strlen(path) + 2 + UTFmax;
225 	if(len < 10)
226 		len = 10;
227 	rpath = halloc(cc, len);
228 	if(*path == '/')
229 		rpath[0] = 0;
230 	else
231 		strcpy(rpath, curdir);
232 	n = strlen(rpath);
233 
234 	while(path){
235 		p = strchr(path, '/');
236 		if(p)
237 			*p++ = 0;
238 		if(strcmp(path, "..") == 0){
239 			while(n > 1){
240 				n--;
241 				c = rpath[n];
242 				rpath[n] = 0;
243 				if(c == '/')
244 					break;
245 			}
246 		}else if(strcmp(path, ".") == 0){
247 			;
248 		}else if(n == 1)
249 			n += snprint(rpath+n, len-n, "%s", path);
250 		else
251 			n += snprint(rpath+n, len-n, "/%s", path);
252 		path = p;
253 	}
254 
255 	if(strncmp(rpath, "/bin/", 5) == 0)
256 		strcpy(rpath, "/");
257 	return rpath;
258 }
259 
260 static char*
261 getword(HConnect *c)
262 {
263 	char *buf;
264 	int ch, n;
265 
266 	while((ch = getc(c)) == ' ' || ch == '\t' || ch == '\r')
267 		;
268 	if(ch == '\n')
269 		return nil;
270 	n = 0;
271 	buf = halloc(c, 1);
272 	for(;;){
273 		switch(ch){
274 		case ' ':
275 		case '\t':
276 		case '\r':
277 		case '\n':
278 			buf[n] = '\0';
279 			return hstrdup(c, buf);
280 		}
281 
282 		if(n < HMaxWord-1){
283 			buf = bingrow(&c->bin, buf, n, n + 1, 0);
284 			if(buf == nil)
285 				return nil;
286 			buf[n++] = ch;
287 		}
288 		ch = getc(c);
289 	}
290 }
291 
292 static int
293 getc(HConnect *c)
294 {
295 	if(c->hpos < c->hstop)
296 		return *c->hpos++;
297 	return '\n';
298 }