uhttpd: protect tcp receive operations with select, make tcp keep-alive optional...
[openwrt/openwrt.git] / package / uhttpd / src / uhttpd-utils.c
1 /*
2 * uhttpd - Tiny single-threaded httpd - Utility functions
3 *
4 * Copyright (C) 2010 Jo-Philipp Wich <xm@subsignal.org>
5 *
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
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
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.
17 */
18
19 #define _XOPEN_SOURCE 500 /* crypt() */
20 #define _BSD_SOURCE /* strcasecmp(), strncasecmp() */
21
22 #include "uhttpd.h"
23 #include "uhttpd-utils.h"
24
25 #ifdef HAVE_TLS
26 #include "uhttpd-tls.h"
27 #endif
28
29
30 static char *uh_index_files[] = {
31 "index.html",
32 "index.htm",
33 "default.html",
34 "default.htm"
35 };
36
37
38 const char * sa_straddr(void *sa)
39 {
40 static char str[INET6_ADDRSTRLEN];
41 struct sockaddr_in *v4 = (struct sockaddr_in *)sa;
42 struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)sa;
43
44 if( v4->sin_family == AF_INET )
45 return inet_ntop(AF_INET, &(v4->sin_addr), str, sizeof(str));
46 else
47 return inet_ntop(AF_INET6, &(v6->sin6_addr), str, sizeof(str));
48 }
49
50 const char * sa_strport(void *sa)
51 {
52 static char str[6];
53 snprintf(str, sizeof(str), "%i", sa_port(sa));
54 return str;
55 }
56
57 int sa_port(void *sa)
58 {
59 return ntohs(((struct sockaddr_in6 *)sa)->sin6_port);
60 }
61
62 int sa_rfc1918(void *sa)
63 {
64 struct sockaddr_in *v4 = (struct sockaddr_in *)sa;
65 unsigned long a = htonl(v4->sin_addr.s_addr);
66
67 if( v4->sin_family == AF_INET )
68 {
69 return ((a >= 0x0A000000) && (a <= 0x0AFFFFFF)) ||
70 ((a >= 0xAC100000) && (a <= 0xAC1FFFFF)) ||
71 ((a >= 0xC0A80000) && (a <= 0xC0A8FFFF));
72 }
73
74 return 0;
75 }
76
77 /* Simple strstr() like function that takes len arguments for both haystack and needle. */
78 char *strfind(char *haystack, int hslen, const char *needle, int ndlen)
79 {
80 int match = 0;
81 int i, j;
82
83 for( i = 0; i < hslen; i++ )
84 {
85 if( haystack[i] == needle[0] )
86 {
87 match = ((ndlen == 1) || ((i + ndlen) <= hslen));
88
89 for( j = 1; (j < ndlen) && ((i + j) < hslen); j++ )
90 {
91 if( haystack[i+j] != needle[j] )
92 {
93 match = 0;
94 break;
95 }
96 }
97
98 if( match )
99 return &haystack[i];
100 }
101 }
102
103 return NULL;
104 }
105
106 /* interruptable select() */
107 int select_intr(int n, fd_set *r, fd_set *w, fd_set *e, struct timeval *t)
108 {
109 int rv;
110 sigset_t ssn, sso;
111
112 /* unblock SIGCHLD */
113 sigemptyset(&ssn);
114 sigaddset(&ssn, SIGCHLD);
115 sigaddset(&ssn, SIGPIPE);
116 sigprocmask(SIG_UNBLOCK, &ssn, &sso);
117
118 rv = select(n, r, w, e, t);
119
120 /* restore signal mask */
121 sigprocmask(SIG_SETMASK, &sso, NULL);
122
123 return rv;
124 }
125
126
127 int uh_tcp_send(struct client *cl, const char *buf, int len)
128 {
129 fd_set writer;
130 struct timeval timeout;
131
132 FD_ZERO(&writer);
133 FD_SET(cl->socket, &writer);
134
135 timeout.tv_sec = cl->server->conf->network_timeout;
136 timeout.tv_usec = 0;
137
138 if( select(cl->socket + 1, NULL, &writer, NULL, &timeout) > 0 )
139 {
140 #ifdef HAVE_TLS
141 if( cl->tls )
142 return cl->server->conf->tls_send(cl, (void *)buf, len);
143 else
144 #endif
145 return send(cl->socket, buf, len, 0);
146 }
147
148 return -1;
149 }
150
151 int uh_tcp_peek(struct client *cl, char *buf, int len)
152 {
153 int sz = uh_tcp_recv(cl, buf, len);
154
155 /* store received data in peek buffer */
156 if( sz > 0 )
157 {
158 cl->peeklen = sz;
159 memcpy(cl->peekbuf, buf, sz);
160 }
161
162 return sz;
163 }
164
165 int uh_tcp_recv(struct client *cl, char *buf, int len)
166 {
167 int sz = 0;
168 int rsz = 0;
169
170 fd_set reader;
171 struct timeval timeout;
172
173 /* first serve data from peek buffer */
174 if( cl->peeklen > 0 )
175 {
176 sz = min(cl->peeklen, len);
177 len -= sz; cl->peeklen -= sz;
178
179 memcpy(buf, cl->peekbuf, sz);
180 memmove(cl->peekbuf, &cl->peekbuf[sz], cl->peeklen);
181 }
182
183 /* caller wants more */
184 if( len > 0 )
185 {
186 FD_ZERO(&reader);
187 FD_SET(cl->socket, &reader);
188
189 timeout.tv_sec = cl->server->conf->network_timeout;
190 timeout.tv_usec = 0;
191
192 if( select(cl->socket + 1, &reader, NULL, NULL, &timeout) > 0 )
193 {
194 #ifdef HAVE_TLS
195 if( cl->tls )
196 rsz = cl->server->conf->tls_recv(cl, (void *)&buf[sz], len);
197 else
198 #endif
199 rsz = recv(cl->socket, (void *)&buf[sz], len, 0);
200
201 if( (sz == 0) || (rsz > 0) )
202 sz += rsz;
203 }
204 else if( sz == 0 )
205 {
206 sz = -1;
207 }
208 }
209
210 return sz;
211 }
212
213
214 int uh_http_sendhf(struct client *cl, int code, const char *summary, const char *fmt, ...)
215 {
216 va_list ap;
217
218 char buffer[UH_LIMIT_MSGHEAD];
219 int len;
220
221 len = snprintf(buffer, sizeof(buffer),
222 "HTTP/1.1 %03i %s\r\n"
223 "Connection: close\r\n"
224 "Content-Type: text/plain\r\n"
225 "Transfer-Encoding: chunked\r\n\r\n",
226 code, summary
227 );
228
229 ensure_ret(uh_tcp_send(cl, buffer, len));
230
231 va_start(ap, fmt);
232 len = vsnprintf(buffer, sizeof(buffer), fmt, ap);
233 va_end(ap);
234
235 ensure_ret(uh_http_sendc(cl, buffer, len));
236 ensure_ret(uh_http_sendc(cl, NULL, 0));
237
238 return 0;
239 }
240
241
242 int uh_http_sendc(struct client *cl, const char *data, int len)
243 {
244 char chunk[8];
245 int clen;
246
247 if( len == -1 )
248 len = strlen(data);
249
250 if( len > 0 )
251 {
252 clen = snprintf(chunk, sizeof(chunk), "%X\r\n", len);
253 ensure_ret(uh_tcp_send(cl, chunk, clen));
254 ensure_ret(uh_tcp_send(cl, data, len));
255 ensure_ret(uh_tcp_send(cl, "\r\n", 2));
256 }
257 else
258 {
259 ensure_ret(uh_tcp_send(cl, "0\r\n\r\n", 5));
260 }
261
262 return 0;
263 }
264
265 int uh_http_sendf(
266 struct client *cl, struct http_request *req, const char *fmt, ...
267 ) {
268 va_list ap;
269 char buffer[UH_LIMIT_MSGHEAD];
270 int len;
271
272 va_start(ap, fmt);
273 len = vsnprintf(buffer, sizeof(buffer), fmt, ap);
274 va_end(ap);
275
276 if( (req != NULL) && (req->version > 1.0) )
277 ensure_ret(uh_http_sendc(cl, buffer, len));
278 else if( len > 0 )
279 ensure_ret(uh_tcp_send(cl, buffer, len));
280
281 return 0;
282 }
283
284 int uh_http_send(
285 struct client *cl, struct http_request *req, const char *buf, int len
286 ) {
287 if( len < 0 )
288 len = strlen(buf);
289
290 if( (req != NULL) && (req->version > 1.0) )
291 ensure_ret(uh_http_sendc(cl, buf, len));
292 else if( len > 0 )
293 ensure_ret(uh_tcp_send(cl, buf, len));
294
295 return 0;
296 }
297
298
299 int uh_urldecode(char *buf, int blen, const char *src, int slen)
300 {
301 int i;
302 int len = 0;
303
304 #define hex(x) \
305 (((x) <= '9') ? ((x) - '0') : \
306 (((x) <= 'F') ? ((x) - 'A' + 10) : \
307 ((x) - 'a' + 10)))
308
309 for( i = 0; (i <= slen) && (i <= blen); i++ )
310 {
311 if( src[i] == '%' )
312 {
313 if( ((i+2) <= slen) && isxdigit(src[i+1]) && isxdigit(src[i+2]) )
314 {
315 buf[len++] = (char)(16 * hex(src[i+1]) + hex(src[i+2]));
316 i += 2;
317 }
318 else
319 {
320 buf[len++] = '%';
321 }
322 }
323 else
324 {
325 buf[len++] = src[i];
326 }
327 }
328
329 return len;
330 }
331
332 int uh_urlencode(char *buf, int blen, const char *src, int slen)
333 {
334 int i;
335 int len = 0;
336 const char hex[] = "0123456789abcdef";
337
338 for( i = 0; (i <= slen) && (i <= blen); i++ )
339 {
340 if( isalnum(src[i]) || (src[i] == '-') || (src[i] == '_') ||
341 (src[i] == '.') || (src[i] == '~') )
342 {
343 buf[len++] = src[i];
344 }
345 else if( (len+3) <= blen )
346 {
347 buf[len++] = '%';
348 buf[len++] = hex[(src[i] >> 4) & 15];
349 buf[len++] = hex[(src[i] & 15) & 15];
350 }
351 else
352 {
353 break;
354 }
355 }
356
357 return len;
358 }
359
360 int uh_b64decode(char *buf, int blen, const unsigned char *src, int slen)
361 {
362 int i = 0;
363 int len = 0;
364
365 unsigned int cin = 0;
366 unsigned int cout = 0;
367
368
369 for( i = 0; (i <= slen) && (src[i] != 0); i++ )
370 {
371 cin = src[i];
372
373 if( (cin >= '0') && (cin <= '9') )
374 cin = cin - '0' + 52;
375 else if( (cin >= 'A') && (cin <= 'Z') )
376 cin = cin - 'A';
377 else if( (cin >= 'a') && (cin <= 'z') )
378 cin = cin - 'a' + 26;
379 else if( cin == '+' )
380 cin = 62;
381 else if( cin == '/' )
382 cin = 63;
383 else if( cin == '=' )
384 cin = 0;
385 else
386 continue;
387
388 cout = (cout << 6) | cin;
389
390 if( (i % 4) == 3 )
391 {
392 if( (len + 3) < blen )
393 {
394 buf[len++] = (char)(cout >> 16);
395 buf[len++] = (char)(cout >> 8);
396 buf[len++] = (char)(cout);
397 }
398 else
399 {
400 break;
401 }
402 }
403 }
404
405 buf[len++] = 0;
406 return len;
407 }
408
409 static char * canonpath(const char *path, char *path_resolved)
410 {
411 char path_copy[PATH_MAX];
412 char *path_cpy = path_copy;
413 char *path_res = path_resolved;
414
415 struct stat s;
416
417
418 /* relative -> absolute */
419 if( *path != '/' )
420 {
421 getcwd(path_copy, PATH_MAX);
422 strncat(path_copy, "/", PATH_MAX - strlen(path_copy));
423 strncat(path_copy, path, PATH_MAX - strlen(path_copy));
424 }
425 else
426 {
427 strncpy(path_copy, path, PATH_MAX);
428 }
429
430 /* normalize */
431 while( (*path_cpy != '\0') && (path_cpy < (path_copy + PATH_MAX - 2)) )
432 {
433 if( *path_cpy == '/' )
434 {
435 /* skip repeating / */
436 if( path_cpy[1] == '/' )
437 {
438 path_cpy++;
439 continue;
440 }
441
442 /* /./ or /../ */
443 else if( path_cpy[1] == '.' )
444 {
445 /* skip /./ */
446 if( (path_cpy[2] == '/') || (path_cpy[2] == '\0') )
447 {
448 path_cpy += 2;
449 continue;
450 }
451
452 /* collapse /x/../ */
453 else if( (path_cpy[2] == '.') &&
454 ((path_cpy[3] == '/') || (path_cpy[3] == '\0'))
455 ) {
456 while( (path_res > path_resolved) && (*--path_res != '/') )
457 ;
458
459 path_cpy += 3;
460 continue;
461 }
462 }
463 }
464
465 *path_res++ = *path_cpy++;
466 }
467
468 /* remove trailing slash if not root / */
469 if( (path_res > (path_resolved+1)) && (path_res[-1] == '/') )
470 path_res--;
471 else if( path_res == path_resolved )
472 *path_res++ = '/';
473
474 *path_res = '\0';
475
476 /* test access */
477 if( !stat(path_resolved, &s) && (s.st_mode & S_IROTH) )
478 return path_resolved;
479
480 return NULL;
481 }
482
483 struct path_info * uh_path_lookup(struct client *cl, const char *url)
484 {
485 static char path_phys[PATH_MAX];
486 static char path_info[PATH_MAX];
487 static struct path_info p;
488
489 char buffer[UH_LIMIT_MSGHEAD];
490 char *docroot = cl->server->conf->docroot;
491 char *pathptr = NULL;
492
493 int slash = 0;
494 int no_sym = cl->server->conf->no_symlinks;
495 int i = 0;
496 struct stat s;
497
498 /* back out early if url is undefined */
499 if ( url == NULL )
500 return NULL;
501
502 memset(path_phys, 0, sizeof(path_phys));
503 memset(path_info, 0, sizeof(path_info));
504 memset(buffer, 0, sizeof(buffer));
505 memset(&p, 0, sizeof(p));
506
507 /* copy docroot */
508 memcpy(buffer, docroot,
509 min(strlen(docroot), sizeof(buffer) - 1));
510
511 /* separate query string from url */
512 if( (pathptr = strchr(url, '?')) != NULL )
513 {
514 p.query = pathptr[1] ? pathptr + 1 : NULL;
515
516 /* urldecode component w/o query */
517 if( pathptr > url )
518 uh_urldecode(
519 &buffer[strlen(docroot)],
520 sizeof(buffer) - strlen(docroot) - 1,
521 url, (int)(pathptr - url) - 1
522 );
523 }
524
525 /* no query string, decode all of url */
526 else
527 {
528 uh_urldecode(
529 &buffer[strlen(docroot)],
530 sizeof(buffer) - strlen(docroot) - 1,
531 url, strlen(url)
532 );
533 }
534
535 /* create canon path */
536 for( i = strlen(buffer), slash = (buffer[max(0, i-1)] == '/'); i >= 0; i-- )
537 {
538 if( (buffer[i] == 0) || (buffer[i] == '/') )
539 {
540 memset(path_info, 0, sizeof(path_info));
541 memcpy(path_info, buffer, min(i + 1, sizeof(path_info) - 1));
542
543 if( no_sym ? realpath(path_info, path_phys)
544 : canonpath(path_info, path_phys)
545 ) {
546 memset(path_info, 0, sizeof(path_info));
547 memcpy(path_info, &buffer[i],
548 min(strlen(buffer) - i, sizeof(path_info) - 1));
549
550 break;
551 }
552 }
553 }
554
555 /* check whether found path is within docroot */
556 if( strncmp(path_phys, docroot, strlen(docroot)) ||
557 ((path_phys[strlen(docroot)] != 0) &&
558 (path_phys[strlen(docroot)] != '/'))
559 ) {
560 return NULL;
561 }
562
563 /* test current path */
564 if( ! stat(path_phys, &p.stat) )
565 {
566 /* is a regular file */
567 if( p.stat.st_mode & S_IFREG )
568 {
569 p.root = docroot;
570 p.phys = path_phys;
571 p.name = &path_phys[strlen(docroot)];
572 p.info = path_info[0] ? path_info : NULL;
573 }
574
575 /* is a directory */
576 else if( (p.stat.st_mode & S_IFDIR) && !strlen(path_info) )
577 {
578 /* ensure trailing slash */
579 if( path_phys[strlen(path_phys)-1] != '/' )
580 path_phys[strlen(path_phys)] = '/';
581
582 /* try to locate index file */
583 memset(buffer, 0, sizeof(buffer));
584 memcpy(buffer, path_phys, sizeof(buffer));
585 pathptr = &buffer[strlen(buffer)];
586
587 /* if requested url resolves to a directory and a trailing slash
588 is missing in the request url, redirect the client to the same
589 url with trailing slash appended */
590 if( !slash )
591 {
592 uh_http_sendf(cl, NULL,
593 "HTTP/1.1 302 Found\r\n"
594 "Location: %s%s%s\r\n"
595 "Connection: close\r\n\r\n",
596 &path_phys[strlen(docroot)],
597 p.query ? "?" : "",
598 p.query ? p.query : ""
599 );
600
601 p.redirected = 1;
602 }
603 else if( cl->server->conf->index_file )
604 {
605 strncat(buffer, cl->server->conf->index_file, sizeof(buffer));
606
607 if( !stat(buffer, &s) && (s.st_mode & S_IFREG) )
608 {
609 memcpy(path_phys, buffer, sizeof(path_phys));
610 memcpy(&p.stat, &s, sizeof(p.stat));
611 }
612 }
613 else
614 {
615 for( i = 0; i < array_size(uh_index_files); i++ )
616 {
617 strncat(buffer, uh_index_files[i], sizeof(buffer));
618
619 if( !stat(buffer, &s) && (s.st_mode & S_IFREG) )
620 {
621 memcpy(path_phys, buffer, sizeof(path_phys));
622 memcpy(&p.stat, &s, sizeof(p.stat));
623 break;
624 }
625
626 *pathptr = 0;
627 }
628 }
629
630 p.root = docroot;
631 p.phys = path_phys;
632 p.name = &path_phys[strlen(docroot)];
633 }
634 }
635
636 return p.phys ? &p : NULL;
637 }
638
639
640 static struct auth_realm *uh_realms = NULL;
641
642 struct auth_realm * uh_auth_add(char *path, char *user, char *pass)
643 {
644 struct auth_realm *new = NULL;
645 struct passwd *pwd;
646
647 #ifdef HAVE_SHADOW
648 struct spwd *spwd;
649 #endif
650
651 if((new = (struct auth_realm *)malloc(sizeof(struct auth_realm))) != NULL)
652 {
653 memset(new, 0, sizeof(struct auth_realm));
654
655 memcpy(new->path, path,
656 min(strlen(path), sizeof(new->path) - 1));
657
658 memcpy(new->user, user,
659 min(strlen(user), sizeof(new->user) - 1));
660
661 /* given password refers to a passwd entry */
662 if( (strlen(pass) > 3) && !strncmp(pass, "$p$", 3) )
663 {
664 #ifdef HAVE_SHADOW
665 /* try to resolve shadow entry */
666 if( ((spwd = getspnam(&pass[3])) != NULL) && spwd->sp_pwdp )
667 {
668 memcpy(new->pass, spwd->sp_pwdp,
669 min(strlen(spwd->sp_pwdp), sizeof(new->pass) - 1));
670 }
671
672 else
673 #endif
674
675 /* try to resolve passwd entry */
676 if( ((pwd = getpwnam(&pass[3])) != NULL) && pwd->pw_passwd &&
677 (pwd->pw_passwd[0] != '!') && (pwd->pw_passwd[0] != 0)
678 ) {
679 memcpy(new->pass, pwd->pw_passwd,
680 min(strlen(pwd->pw_passwd), sizeof(new->pass) - 1));
681 }
682 }
683
684 /* ordinary pwd */
685 else
686 {
687 memcpy(new->pass, pass,
688 min(strlen(pass), sizeof(new->pass) - 1));
689 }
690
691 if( new->pass[0] )
692 {
693 new->next = uh_realms;
694 uh_realms = new;
695
696 return new;
697 }
698
699 free(new);
700 }
701
702 return NULL;
703 }
704
705 int uh_auth_check(
706 struct client *cl, struct http_request *req, struct path_info *pi
707 ) {
708 int i, plen, rlen, protected;
709 char buffer[UH_LIMIT_MSGHEAD];
710 char *user = NULL;
711 char *pass = NULL;
712
713 struct auth_realm *realm = NULL;
714
715 plen = strlen(pi->name);
716 protected = 0;
717
718 /* check whether at least one realm covers the requested url */
719 for( realm = uh_realms; realm; realm = realm->next )
720 {
721 rlen = strlen(realm->path);
722
723 if( (plen >= rlen) && !strncasecmp(pi->name, realm->path, rlen) )
724 {
725 req->realm = realm;
726 protected = 1;
727 break;
728 }
729 }
730
731 /* requested resource is covered by a realm */
732 if( protected )
733 {
734 /* try to get client auth info */
735 foreach_header(i, req->headers)
736 {
737 if( !strcasecmp(req->headers[i], "Authorization") &&
738 (strlen(req->headers[i+1]) > 6) &&
739 !strncasecmp(req->headers[i+1], "Basic ", 6)
740 ) {
741 memset(buffer, 0, sizeof(buffer));
742 uh_b64decode(buffer, sizeof(buffer) - 1,
743 (unsigned char *) &req->headers[i+1][6],
744 strlen(req->headers[i+1]) - 6);
745
746 if( (pass = strchr(buffer, ':')) != NULL )
747 {
748 user = buffer;
749 *pass++ = 0;
750 }
751
752 break;
753 }
754 }
755
756 /* have client auth */
757 if( user && pass )
758 {
759 /* find matching realm */
760 for( realm = uh_realms; realm; realm = realm->next )
761 {
762 rlen = strlen(realm->path);
763
764 if( (plen >= rlen) &&
765 !strncasecmp(pi->name, realm->path, rlen) &&
766 !strcmp(user, realm->user)
767 ) {
768 req->realm = realm;
769 break;
770 }
771 }
772
773 /* found a realm matching the username */
774 if( realm )
775 {
776 /* is a crypt passwd */
777 if( realm->pass[0] == '$' )
778 pass = crypt(pass, realm->pass);
779
780 /* check user pass */
781 if( !strcmp(pass, realm->pass) )
782 return 1;
783 }
784 }
785
786 /* 401 */
787 uh_http_sendf(cl, NULL,
788 "HTTP/%.1f 401 Authorization Required\r\n"
789 "WWW-Authenticate: Basic realm=\"%s\"\r\n"
790 "Content-Type: text/plain\r\n"
791 "Content-Length: 23\r\n\r\n"
792 "Authorization Required\n",
793 req->version, cl->server->conf->realm
794 );
795
796 return 0;
797 }
798
799 return 1;
800 }
801
802
803 static struct listener *uh_listeners = NULL;
804 static struct client *uh_clients = NULL;
805
806 struct listener * uh_listener_add(int sock, struct config *conf)
807 {
808 struct listener *new = NULL;
809 socklen_t sl;
810
811 if( (new = (struct listener *)malloc(sizeof(struct listener))) != NULL )
812 {
813 memset(new, 0, sizeof(struct listener));
814
815 new->socket = sock;
816 new->conf = conf;
817
818 /* get local endpoint addr */
819 sl = sizeof(struct sockaddr_in6);
820 memset(&(new->addr), 0, sl);
821 getsockname(sock, (struct sockaddr *) &(new->addr), &sl);
822
823 new->next = uh_listeners;
824 uh_listeners = new;
825
826 return new;
827 }
828
829 return NULL;
830 }
831
832 struct listener * uh_listener_lookup(int sock)
833 {
834 struct listener *cur = NULL;
835
836 for( cur = uh_listeners; cur; cur = cur->next )
837 if( cur->socket == sock )
838 return cur;
839
840 return NULL;
841 }
842
843
844 struct client * uh_client_add(int sock, struct listener *serv)
845 {
846 struct client *new = NULL;
847 socklen_t sl;
848
849 if( (new = (struct client *)malloc(sizeof(struct client))) != NULL )
850 {
851 memset(new, 0, sizeof(struct client));
852
853 new->socket = sock;
854 new->server = serv;
855
856 /* get remote endpoint addr */
857 sl = sizeof(struct sockaddr_in6);
858 memset(&(new->peeraddr), 0, sl);
859 getpeername(sock, (struct sockaddr *) &(new->peeraddr), &sl);
860
861 /* get local endpoint addr */
862 sl = sizeof(struct sockaddr_in6);
863 memset(&(new->servaddr), 0, sl);
864 getsockname(sock, (struct sockaddr *) &(new->servaddr), &sl);
865
866 new->next = uh_clients;
867 uh_clients = new;
868 }
869
870 return new;
871 }
872
873 struct client * uh_client_lookup(int sock)
874 {
875 struct client *cur = NULL;
876
877 for( cur = uh_clients; cur; cur = cur->next )
878 if( cur->socket == sock )
879 return cur;
880
881 return NULL;
882 }
883
884 void uh_client_remove(int sock)
885 {
886 struct client *cur = NULL;
887 struct client *prv = NULL;
888
889 for( cur = uh_clients; cur; prv = cur, cur = cur->next )
890 {
891 if( cur->socket == sock )
892 {
893 if( prv )
894 prv->next = cur->next;
895 else
896 uh_clients = cur->next;
897
898 free(cur);
899 break;
900 }
901 }
902 }
903
904
905 #ifdef HAVE_CGI
906 static struct interpreter *uh_interpreters = NULL;
907
908 struct interpreter * uh_interpreter_add(const char *extn, const char *path)
909 {
910 struct interpreter *new = NULL;
911
912 if( (new = (struct interpreter *)
913 malloc(sizeof(struct interpreter))) != NULL )
914 {
915 memset(new, 0, sizeof(struct interpreter));
916
917 memcpy(new->extn, extn, min(strlen(extn), sizeof(new->extn)-1));
918 memcpy(new->path, path, min(strlen(path), sizeof(new->path)-1));
919
920 new->next = uh_interpreters;
921 uh_interpreters = new;
922
923 return new;
924 }
925
926 return NULL;
927 }
928
929 struct interpreter * uh_interpreter_lookup(const char *path)
930 {
931 struct interpreter *cur = NULL;
932 const char *e;
933
934 for( cur = uh_interpreters; cur; cur = cur->next )
935 {
936 e = &path[max(strlen(path) - strlen(cur->extn), 0)];
937
938 if( !strcmp(e, cur->extn) )
939 return cur;
940 }
941
942 return NULL;
943 }
944 #endif