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

Last change on this file since 21121 was 21121, checked in by jow, 7 years ago

[package] uhttpd:

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