2 * uhttpd - Tiny non-forking httpd - Utility functions
4 * Copyright (C) 2010 Jo-Philipp Wich <xm@subsignal.org>
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
19 #define _XOPEN_SOURCE 500 /* crypt() */
20 #define _BSD_SOURCE /* strcasecmp(), strncasecmp() */
23 #include "uhttpd-utils.h"
26 #include "uhttpd-tls.h"
30 static char *uh_index_files[] = {
38 const char * sa_straddr(void *sa)
40 static char str[INET6_ADDRSTRLEN];
41 struct sockaddr_in *v4 = (struct sockaddr_in *)sa;
42 struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)sa;
44 if( v4->sin_family == AF_INET )
45 return inet_ntop(AF_INET, &(v4->sin_addr), str, sizeof(str));
47 return inet_ntop(AF_INET6, &(v6->sin6_addr), str, sizeof(str));
50 const char * sa_strport(void *sa)
53 snprintf(str, sizeof(str), "%i", sa_port(sa));
59 return ntohs(((struct sockaddr_in6 *)sa)->sin6_port);
62 /* Simple strstr() like function that takes len arguments for both haystack and needle. */
63 char *strfind(char *haystack, int hslen, const char *needle, int ndlen)
68 for( i = 0; i < hslen; i++ )
70 if( haystack[i] == needle[0] )
72 match = ((ndlen == 1) || ((i + ndlen) <= hslen));
74 for( j = 1; (j < ndlen) && ((i + j) < hslen); j++ )
76 if( haystack[i+j] != needle[j] )
92 int uh_tcp_send(struct client *cl, const char *buf, int len)
95 struct timeval timeout;
98 FD_SET(cl->socket, &writer);
101 timeout.tv_usec = 500000;
103 if( select(cl->socket + 1, NULL, &writer, NULL, &timeout) > 0 )
107 return SSL_write(cl->tls, buf, len);
110 return send(cl->socket, buf, len, 0);
116 int uh_tcp_peek(struct client *cl, char *buf, int len)
118 int sz = uh_tcp_recv(cl, buf, len);
120 /* store received data in peek buffer */
124 memcpy(cl->peekbuf, buf, sz);
130 int uh_tcp_recv(struct client *cl, char *buf, int len)
135 /* first serve data from peek buffer */
136 if( cl->peeklen > 0 )
138 sz = min(cl->peeklen, len);
139 len -= sz; cl->peeklen -= sz;
141 memcpy(buf, cl->peekbuf, sz);
142 memmove(cl->peekbuf, &cl->peekbuf[sz], cl->peeklen);
145 /* caller wants more */
150 rsz = SSL_read(cl->tls, (void *)&buf[sz], len);
153 rsz = recv(cl->socket, (void *)&buf[sz], len, 0);
155 if( (sz == 0) || (rsz > 0) )
163 do { if( x < 0 ) return -1; } while(0)
165 int uh_http_sendhf(struct client *cl, int code, const char *summary, const char *fmt, ...)
169 char buffer[UH_LIMIT_MSGHEAD];
172 len = snprintf(buffer, sizeof(buffer),
173 "HTTP/1.1 %03i %s\r\n"
174 "Content-Type: text/plain\r\n"
175 "Transfer-Encoding: chunked\r\n\r\n",
179 ensure(uh_tcp_send(cl, buffer, len));
182 len = vsnprintf(buffer, sizeof(buffer), fmt, ap);
185 ensure(uh_http_sendc(cl, buffer, len));
186 ensure(uh_http_sendc(cl, NULL, 0));
192 int uh_http_sendc(struct client *cl, const char *data, int len)
202 clen = snprintf(chunk, sizeof(chunk), "%X\r\n", len);
203 ensure(uh_tcp_send(cl, chunk, clen));
204 ensure(uh_tcp_send(cl, data, len));
205 ensure(uh_tcp_send(cl, "\r\n", 2));
209 ensure(uh_tcp_send(cl, "0\r\n\r\n", 5));
216 struct client *cl, struct http_request *req, const char *fmt, ...
219 char buffer[UH_LIMIT_MSGHEAD];
223 len = vsnprintf(buffer, sizeof(buffer), fmt, ap);
226 if( (req != NULL) && (req->version > 1.0) )
227 ensure(uh_http_sendc(cl, buffer, len));
229 ensure(uh_tcp_send(cl, buffer, len));
235 struct client *cl, struct http_request *req, const char *buf, int len
240 if( (req != NULL) && (req->version > 1.0) )
241 ensure(uh_http_sendc(cl, buf, len));
243 ensure(uh_tcp_send(cl, buf, len));
249 int uh_urldecode(char *buf, int blen, const char *src, int slen)
255 (((x) <= '9') ? ((x) - '0') : \
256 (((x) <= 'F') ? ((x) - 'A' + 10) : \
259 for( i = 0; (i <= slen) && (i <= blen); i++ )
263 if( ((i+2) <= slen) && isxdigit(src[i+1]) && isxdigit(src[i+2]) )
265 buf[len++] = (char)(16 * hex(src[i+1]) + hex(src[i+2]));
282 int uh_urlencode(char *buf, int blen, const char *src, int slen)
286 const char hex[] = "0123456789abcdef";
288 for( i = 0; (i <= slen) && (i <= blen); i++ )
290 if( isalnum(src[i]) || (src[i] == '-') || (src[i] == '_') ||
291 (src[i] == '.') || (src[i] == '~') )
295 else if( (len+3) <= blen )
298 buf[len++] = hex[(src[i] >> 4) & 15];
299 buf[len++] = hex[(src[i] & 15) & 15];
310 int uh_b64decode(char *buf, int blen, const unsigned char *src, int slen)
315 unsigned int cin = 0;
316 unsigned int cout = 0;
319 for( i = 0; (i <= slen) && (src[i] != 0); i++ )
323 if( (cin >= '0') && (cin <= '9') )
324 cin = cin - '0' + 52;
325 else if( (cin >= 'A') && (cin <= 'Z') )
327 else if( (cin >= 'a') && (cin <= 'z') )
328 cin = cin - 'a' + 26;
329 else if( cin == '+' )
331 else if( cin == '/' )
333 else if( cin == '=' )
338 cout = (cout << 6) | cin;
342 if( (len + 3) < blen )
344 buf[len++] = (char)(cout >> 16);
345 buf[len++] = (char)(cout >> 8);
346 buf[len++] = (char)(cout);
360 struct path_info * uh_path_lookup(struct client *cl, const char *url)
362 static char path_phys[PATH_MAX];
363 static char path_info[PATH_MAX];
364 static struct path_info p;
366 char buffer[UH_LIMIT_MSGHEAD];
367 char *docroot = cl->server->conf->docroot;
368 char *pathptr = NULL;
374 memset(path_phys, 0, sizeof(path_phys));
375 memset(path_info, 0, sizeof(path_info));
376 memset(buffer, 0, sizeof(buffer));
377 memset(&p, 0, sizeof(p));
380 memcpy(buffer, docroot,
381 min(strlen(docroot), sizeof(buffer) - 1));
383 /* separate query string from url */
384 if( (pathptr = strchr(url, '?')) != NULL )
386 p.query = pathptr[1] ? pathptr + 1 : NULL;
388 /* urldecode component w/o query */
391 &buffer[strlen(docroot)],
392 sizeof(buffer) - strlen(docroot) - 1,
393 url, (int)(pathptr - url) - 1
397 /* no query string, decode all of url */
401 &buffer[strlen(docroot)],
402 sizeof(buffer) - strlen(docroot) - 1,
407 /* create canon path */
408 for( i = strlen(buffer); i >= 0; i-- )
410 if( (buffer[i] == 0) || (buffer[i] == '/') )
412 memset(path_info, 0, sizeof(path_info));
413 memcpy(path_info, buffer, min(i + 1, sizeof(path_info) - 1));
415 if( realpath(path_info, path_phys) )
417 memset(path_info, 0, sizeof(path_info));
418 memcpy(path_info, &buffer[i],
419 min(strlen(buffer) - i, sizeof(path_info) - 1));
426 /* check whether found path is within docroot */
427 if( strncmp(path_phys, docroot, strlen(docroot)) ||
428 ((path_phys[strlen(docroot)] != 0) &&
429 (path_phys[strlen(docroot)] != '/'))
434 /* test current path */
435 if( ! stat(path_phys, &p.stat) )
437 /* is a regular file */
438 if( p.stat.st_mode & S_IFREG )
442 p.name = &path_phys[strlen(docroot)];
443 p.info = path_info[0] ? path_info : NULL;
447 else if( (p.stat.st_mode & S_IFDIR) && !strlen(path_info) )
449 /* ensure trailing slash */
450 if( path_phys[strlen(path_phys)-1] != '/' )
451 path_phys[strlen(path_phys)] = '/';
453 /* try to locate index file */
454 memset(buffer, 0, sizeof(buffer));
455 memcpy(buffer, path_phys, sizeof(buffer));
456 pathptr = &buffer[strlen(buffer)];
458 for( i = 0; i < array_size(uh_index_files); i++ )
460 strncat(buffer, uh_index_files[i], sizeof(buffer));
462 if( !stat(buffer, &s) && (s.st_mode & S_IFREG) )
464 memcpy(path_phys, buffer, sizeof(path_phys));
465 memcpy(&p.stat, &s, sizeof(p.stat));
474 p.name = &path_phys[strlen(docroot)];
478 return p.phys ? &p : NULL;
482 static char uh_realms[UH_LIMIT_AUTHREALMS * sizeof(struct auth_realm)] = { 0 };
483 static int uh_realm_count = 0;
485 struct auth_realm * uh_auth_add(
486 char *path, char *realm, char *user, char *pass
488 struct auth_realm *new = NULL;
492 if( uh_realm_count < UH_LIMIT_AUTHREALMS )
494 new = (struct auth_realm *)
495 &uh_realms[uh_realm_count * sizeof(struct auth_realm)];
497 memset(new, 0, sizeof(struct auth_realm));
499 memcpy(new->realm, realm,
500 min(strlen(realm), sizeof(new->realm) - 1));
502 memcpy(new->path, path,
503 min(strlen(path), sizeof(new->path) - 1));
505 memcpy(new->user, user,
506 min(strlen(user), sizeof(new->user) - 1));
508 /* given password refers to a passwd entry */
509 if( (strlen(pass) > 3) && !strncmp(pass, "$p$", 3) )
511 /* try to resolve shadow entry */
512 if( ((spwd = getspnam(&pass[3])) != NULL) && spwd->sp_pwdp )
514 memcpy(new->pass, spwd->sp_pwdp,
515 min(strlen(spwd->sp_pwdp), sizeof(new->pass) - 1));
518 /* try to resolve passwd entry */
519 else if( ((pwd = getpwnam(&pass[3])) != NULL) && pwd->pw_passwd &&
520 (pwd->pw_passwd[0] != '!') && (pwd->pw_passwd[0] != 0)
522 memcpy(new->pass, pwd->pw_passwd,
523 min(strlen(pwd->pw_passwd), sizeof(new->pass) - 1));
530 memcpy(new->pass, pass,
531 min(strlen(pass), sizeof(new->pass) - 1));
541 struct client *cl, struct http_request *req, struct path_info *pi
543 int i, plen, rlen, protected;
544 char buffer[UH_LIMIT_MSGHEAD];
548 struct auth_realm *realm = NULL;
550 plen = strlen(pi->name);
553 /* check whether at least one realm covers the requested url */
554 for( i = 0; i < uh_realm_count; i++ )
556 realm = (struct auth_realm *)
557 &uh_realms[i * sizeof(struct auth_realm)];
559 rlen = strlen(realm->path);
561 if( (plen >= rlen) && !strncasecmp(pi->name, realm->path, rlen) )
569 /* requested resource is covered by a realm */
572 /* try to get client auth info */
573 foreach_header(i, req->headers)
575 if( !strcasecmp(req->headers[i], "Authorization") &&
576 (strlen(req->headers[i+1]) > 6) &&
577 !strncasecmp(req->headers[i+1], "Basic ", 6)
579 memset(buffer, 0, sizeof(buffer));
580 uh_b64decode(buffer, sizeof(buffer) - 1,
581 (unsigned char *) &req->headers[i+1][6],
582 strlen(req->headers[i+1]) - 6);
584 if( (pass = strchr(buffer, ':')) != NULL )
594 /* have client auth */
597 /* find matching realm */
598 for( i = 0, realm = NULL; i < uh_realm_count; i++ )
600 realm = (struct auth_realm *)
601 &uh_realms[i * sizeof(struct auth_realm)];
603 rlen = strlen(realm->path);
605 if( (plen >= rlen) &&
606 !strncasecmp(pi->name, realm->path, rlen) &&
607 !strcmp(user, realm->user)
616 /* found a realm matching the username */
619 /* is a crypt passwd */
620 if( realm->pass[0] == '$' )
621 pass = crypt(pass, realm->pass);
623 /* check user pass */
624 if( !strcmp(pass, realm->pass) )
630 uh_http_sendf(cl, NULL,
631 "HTTP/%.1f 401 Authorization Required\r\n"
632 "WWW-Authenticate: Basic realm=\"%s\"\r\n"
633 "Content-Type: text/plain\r\n"
634 "Content-Length: 23\r\n\r\n"
635 "Authorization Required\n",
636 req->version, realm ? realm->realm : ""
646 static char uh_listeners[UH_LIMIT_LISTENERS * sizeof(struct listener)] = { 0 };
647 static char uh_clients[UH_LIMIT_CLIENTS * sizeof(struct client)] = { 0 };
649 static int uh_listener_count = 0;
650 static int uh_client_count = 0;
653 struct listener * uh_listener_add(int sock, struct config *conf)
655 struct listener *new = NULL;
658 if( uh_listener_count < UH_LIMIT_LISTENERS )
660 new = (struct listener *)
661 &uh_listeners[uh_listener_count * sizeof(struct listener)];
666 /* get local endpoint addr */
667 sl = sizeof(struct sockaddr_in6);
668 memset(&(new->addr), 0, sl);
669 getsockname(sock, (struct sockaddr *) &(new->addr), &sl);
677 struct listener * uh_listener_lookup(int sock)
679 struct listener *cur = NULL;
682 for( i = 0; i < uh_listener_count; i++ )
684 cur = (struct listener *) &uh_listeners[i * sizeof(struct listener)];
686 if( cur->socket == sock )
694 struct client * uh_client_add(int sock, struct listener *serv)
696 struct client *new = NULL;
699 if( uh_client_count < UH_LIMIT_CLIENTS )
701 new = (struct client *)
702 &uh_clients[uh_client_count * sizeof(struct client)];
707 /* get remote endpoint addr */
708 sl = sizeof(struct sockaddr_in6);
709 memset(&(new->peeraddr), 0, sl);
710 getpeername(sock, (struct sockaddr *) &(new->peeraddr), &sl);
712 /* get local endpoint addr */
713 sl = sizeof(struct sockaddr_in6);
714 memset(&(new->servaddr), 0, sl);
715 getsockname(sock, (struct sockaddr *) &(new->servaddr), &sl);
723 struct client * uh_client_lookup(int sock)
725 struct client *cur = NULL;
728 for( i = 0; i < uh_client_count; i++ )
730 cur = (struct client *) &uh_clients[i * sizeof(struct client)];
732 if( cur->socket == sock )
739 void uh_client_remove(int sock)
741 struct client *del = uh_client_lookup(sock);
745 memmove(del, del + 1,
746 sizeof(uh_clients) - (int)((char *)del - uh_clients) - sizeof(struct client));