source: trunk/package/uhttpd/src/uhttpd-utils.c @ 24952

Last change on this file since 24952 was 24952, checked in by jow, 6 years ago

[package] uhttpd: protect tcp receive operations with select, make tcp keep-alive optional (#8272)

File size: 18.7 KB
Line 
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
30static char *uh_index_files[] = {
31        "index.html",
32        "index.htm",
33        "default.html",
34        "default.htm"
35};
36
37
38const 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
50const 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
57int sa_port(void *sa)
58{
59        return ntohs(((struct sockaddr_in6 *)sa)->sin6_port);
60}
61
62int 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. */
78char *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() */
107int 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
127int 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
151int 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
165int 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
214int 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
242int 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
265int 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
284int 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
299int 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
332int 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
360int 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
409static 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
483struct 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
640static struct auth_realm *uh_realms = NULL;
641
642struct 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
705int 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
803static struct listener *uh_listeners = NULL;
804static struct client *uh_clients = NULL;
805
806struct 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
832struct 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
844struct 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
873struct 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
884void 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
906static struct interpreter *uh_interpreters = NULL;
907
908struct 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
929struct 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
Note: See TracBrowser for help on using the repository browser.