source: branches/backfire/package/uhttpd/src/uhttpd-utils.c @ 20884

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

[backfire] merge r20883

File size: 16.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
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                                {
425                                        while( (path_res > path_resolved) && (*--path_res != '/') )
426                                                ;
427
428                                        path_cpy += 3;
429                                        continue;
430                                }
431                        }
432                }
433
434                *path_res++ = *path_cpy++;
435        }
436
437        /* remove trailing slash if not root / */
438        if( (path_res > (path_resolved+1)) && (path_res[-1] == '/') )
439                path_res--;
440        else if( path_res == path_resolved )
441                *path_res++ = '/';
442
443        *path_res = '\0';
444
445        /* test access */
446        if( !stat(path_resolved, &s) && (s.st_mode & S_IROTH) )
447                return path_resolved;
448
449        return NULL;
450}
451
452struct path_info * uh_path_lookup(struct client *cl, const char *url)
453{
454        static char path_phys[PATH_MAX];
455        static char path_info[PATH_MAX];
456        static struct path_info p;
457
458        char buffer[UH_LIMIT_MSGHEAD];
459        char *docroot = cl->server->conf->docroot;
460        char *pathptr = NULL;
461
462        int no_sym = cl->server->conf->no_symlinks;
463        int i = 0;
464        struct stat s;
465
466
467        memset(path_phys, 0, sizeof(path_phys));
468        memset(path_info, 0, sizeof(path_info));
469        memset(buffer, 0, sizeof(buffer));
470        memset(&p, 0, sizeof(p));
471
472        /* copy docroot */
473        memcpy(buffer, docroot,
474                min(strlen(docroot), sizeof(buffer) - 1));
475
476        /* separate query string from url */
477        if( (pathptr = strchr(url, '?')) != NULL )
478        {
479                p.query = pathptr[1] ? pathptr + 1 : NULL;
480
481                /* urldecode component w/o query */
482                if( pathptr > url )
483                        uh_urldecode(
484                                &buffer[strlen(docroot)],
485                                sizeof(buffer) - strlen(docroot) - 1,
486                                url, (int)(pathptr - url) - 1
487                        );
488        }
489
490        /* no query string, decode all of url */
491        else
492        {
493                uh_urldecode(
494                        &buffer[strlen(docroot)],
495                        sizeof(buffer) - strlen(docroot) - 1,
496                        url, strlen(url)
497                );
498        }
499
500        /* create canon path */
501        for( i = strlen(buffer); i >= 0; i-- )
502        {
503                if( (buffer[i] == 0) || (buffer[i] == '/') )
504                {
505                        memset(path_info, 0, sizeof(path_info));
506                        memcpy(path_info, buffer, min(i + 1, sizeof(path_info) - 1));
507
508                        if( no_sym ? realpath(path_info, path_phys)
509                                   : canonpath(path_info, path_phys)
510                        ) {
511                                memset(path_info, 0, sizeof(path_info));
512                                memcpy(path_info, &buffer[i],
513                                        min(strlen(buffer) - i, sizeof(path_info) - 1));
514
515                                break;
516                        }
517                }
518        }
519
520        /* check whether found path is within docroot */
521        if( strncmp(path_phys, docroot, strlen(docroot)) ||
522            ((path_phys[strlen(docroot)] != 0) &&
523                 (path_phys[strlen(docroot)] != '/'))
524        ) {
525                return NULL;
526        }
527
528        /* test current path */
529        if( ! stat(path_phys, &p.stat) )
530        {
531                /* is a regular file */
532                if( p.stat.st_mode & S_IFREG )
533                {
534                        p.root = docroot;
535                        p.phys = path_phys;
536                        p.name = &path_phys[strlen(docroot)];
537                        p.info = path_info[0] ? path_info : NULL;
538                }
539
540                /* is a directory */
541                else if( (p.stat.st_mode & S_IFDIR) && !strlen(path_info) )
542                {
543                        /* ensure trailing slash */
544                        if( path_phys[strlen(path_phys)-1] != '/' )
545                                path_phys[strlen(path_phys)] = '/';
546
547                        /* try to locate index file */
548                        memset(buffer, 0, sizeof(buffer));
549                        memcpy(buffer, path_phys, sizeof(buffer));
550                        pathptr = &buffer[strlen(buffer)];
551
552                        for( i = 0; i < array_size(uh_index_files); i++ )
553                        {
554                                strncat(buffer, uh_index_files[i], sizeof(buffer));
555
556                                if( !stat(buffer, &s) && (s.st_mode & S_IFREG) )
557                                {
558                                        memcpy(path_phys, buffer, sizeof(path_phys));
559                                        memcpy(&p.stat, &s, sizeof(p.stat));
560                                        break;
561                                }
562
563                                *pathptr = 0;
564                        }
565
566                        p.root = docroot;
567                        p.phys = path_phys;
568                        p.name = &path_phys[strlen(docroot)];
569                }
570        }
571
572        return p.phys ? &p : NULL;
573}
574
575
576static char uh_realms[UH_LIMIT_AUTHREALMS * sizeof(struct auth_realm)] = { 0 };
577static int uh_realm_count = 0;
578
579struct auth_realm * uh_auth_add(char *path, char *user, char *pass)
580{
581        struct auth_realm *new = NULL;
582        struct passwd *pwd;
583        struct spwd *spwd;
584
585        if( uh_realm_count < UH_LIMIT_AUTHREALMS )
586        {
587                new = (struct auth_realm *)
588                        &uh_realms[uh_realm_count * sizeof(struct auth_realm)];
589
590                memset(new, 0, sizeof(struct auth_realm));
591
592                memcpy(new->path, path,
593                        min(strlen(path), sizeof(new->path) - 1));
594
595                memcpy(new->user, user,
596                        min(strlen(user), sizeof(new->user) - 1));
597
598                /* given password refers to a passwd entry */
599                if( (strlen(pass) > 3) && !strncmp(pass, "$p$", 3) )
600                {
601                        /* try to resolve shadow entry */
602                        if( ((spwd = getspnam(&pass[3])) != NULL) && spwd->sp_pwdp )
603                        {
604                                memcpy(new->pass, spwd->sp_pwdp,
605                                        min(strlen(spwd->sp_pwdp), sizeof(new->pass) - 1));
606                        }
607
608                        /* try to resolve passwd entry */
609                        else if( ((pwd = getpwnam(&pass[3])) != NULL) && pwd->pw_passwd &&
610                                (pwd->pw_passwd[0] != '!') && (pwd->pw_passwd[0] != 0)
611                        ) {
612                                memcpy(new->pass, pwd->pw_passwd,
613                                        min(strlen(pwd->pw_passwd), sizeof(new->pass) - 1));
614                        }                       
615                }
616
617                /* ordinary pwd */
618                else
619                {
620                        memcpy(new->pass, pass,
621                                min(strlen(pass), sizeof(new->pass) - 1));
622                }
623
624                uh_realm_count++;
625        }
626
627        return new;
628}
629
630int uh_auth_check(
631        struct client *cl, struct http_request *req, struct path_info *pi
632) {
633        int i, plen, rlen, protected;
634        char buffer[UH_LIMIT_MSGHEAD];
635        char *user = NULL;
636        char *pass = NULL;
637
638        struct auth_realm *realm = NULL;
639
640        plen = strlen(pi->name);
641        protected = 0;
642
643        /* check whether at least one realm covers the requested url */
644        for( i = 0; i < uh_realm_count; i++ )
645        {
646                realm = (struct auth_realm *)
647                        &uh_realms[i * sizeof(struct auth_realm)];
648
649                rlen = strlen(realm->path);
650
651                if( (plen >= rlen) && !strncasecmp(pi->name, realm->path, rlen) )
652                {
653                        req->realm = realm;
654                        protected = 1;
655                        break;
656                }
657        }
658
659        /* requested resource is covered by a realm */
660        if( protected )
661        {
662                /* try to get client auth info */
663                foreach_header(i, req->headers)
664                {
665                        if( !strcasecmp(req->headers[i], "Authorization") &&
666                                (strlen(req->headers[i+1]) > 6) &&
667                                !strncasecmp(req->headers[i+1], "Basic ", 6)
668                        ) {
669                                memset(buffer, 0, sizeof(buffer));
670                                uh_b64decode(buffer, sizeof(buffer) - 1,
671                                        (unsigned char *) &req->headers[i+1][6],
672                                        strlen(req->headers[i+1]) - 6);
673
674                                if( (pass = strchr(buffer, ':')) != NULL )
675                                {
676                                        user = buffer;
677                                        *pass++ = 0;
678                                }
679
680                                break;
681                        }
682                }
683
684                /* have client auth */
685                if( user && pass )
686                {
687                        /* find matching realm */
688                        for( i = 0, realm = NULL; i < uh_realm_count; i++ )
689                        {
690                                realm = (struct auth_realm *)
691                                        &uh_realms[i * sizeof(struct auth_realm)];
692
693                                rlen = strlen(realm->path);
694
695                                if( (plen >= rlen) &&
696                                    !strncasecmp(pi->name, realm->path, rlen) &&
697                                    !strcmp(user, realm->user)
698                                ) {
699                                        req->realm = realm;
700                                        break;
701                                }
702
703                                realm = NULL;
704                        }
705
706                        /* found a realm matching the username */
707                        if( realm )
708                        {
709                                /* is a crypt passwd */
710                                if( realm->pass[0] == '$' )
711                                        pass = crypt(pass, realm->pass);
712
713                                /* check user pass */
714                                if( !strcmp(pass, realm->pass) )
715                                        return 1;
716                        }
717                }
718
719                /* 401 */
720                uh_http_sendf(cl, NULL,
721                        "HTTP/%.1f 401 Authorization Required\r\n"
722                        "WWW-Authenticate: Basic realm=\"%s\"\r\n"
723                        "Content-Type: text/plain\r\n"
724                        "Content-Length: 23\r\n\r\n"
725                        "Authorization Required\n",
726                                req->version, cl->server->conf->realm
727                );
728
729                return 0;
730        }
731
732        return 1;
733}
734
735
736static char uh_listeners[UH_LIMIT_LISTENERS * sizeof(struct listener)] = { 0 };
737static char uh_clients[UH_LIMIT_CLIENTS * sizeof(struct client)] = { 0 };
738
739static int uh_listener_count = 0;
740static int uh_client_count = 0;
741
742
743struct listener * uh_listener_add(int sock, struct config *conf)
744{
745        struct listener *new = NULL;
746        socklen_t sl;
747
748        if( uh_listener_count < UH_LIMIT_LISTENERS )
749        {
750                new = (struct listener *)
751                        &uh_listeners[uh_listener_count * sizeof(struct listener)];
752
753                new->socket = sock;
754                new->conf   = conf;
755
756                /* get local endpoint addr */
757                sl = sizeof(struct sockaddr_in6);
758                memset(&(new->addr), 0, sl);
759                getsockname(sock, (struct sockaddr *) &(new->addr), &sl);
760
761                uh_listener_count++;
762        }
763
764        return new;
765}
766
767struct listener * uh_listener_lookup(int sock)
768{
769        struct listener *cur = NULL;
770        int i;
771
772        for( i = 0; i < uh_listener_count; i++ )
773        {
774                cur = (struct listener *) &uh_listeners[i * sizeof(struct listener)];
775
776                if( cur->socket == sock )
777                        return cur;
778        }
779
780        return NULL;
781}
782
783
784struct client * uh_client_add(int sock, struct listener *serv)
785{
786        struct client *new = NULL;
787        socklen_t sl;
788
789        if( uh_client_count < UH_LIMIT_CLIENTS )
790        {
791                new = (struct client *)
792                        &uh_clients[uh_client_count * sizeof(struct client)];
793
794                new->socket = sock;
795                new->server = serv;
796
797                /* get remote endpoint addr */
798                sl = sizeof(struct sockaddr_in6);
799                memset(&(new->peeraddr), 0, sl);
800                getpeername(sock, (struct sockaddr *) &(new->peeraddr), &sl);
801
802                /* get local endpoint addr */
803                sl = sizeof(struct sockaddr_in6);
804                memset(&(new->servaddr), 0, sl);
805                getsockname(sock, (struct sockaddr *) &(new->servaddr), &sl);
806
807                uh_client_count++;
808        }
809
810        return new;
811}
812
813struct client * uh_client_lookup(int sock)
814{
815        struct client *cur = NULL;
816        int i;
817
818        for( i = 0; i < uh_client_count; i++ )
819        {
820                cur = (struct client *) &uh_clients[i * sizeof(struct client)];
821
822                if( cur->socket == sock )
823                        return cur;
824        }
825
826        return NULL;
827}
828
829void uh_client_remove(int sock)
830{
831        struct client *del = uh_client_lookup(sock);
832
833        if( del )
834        {
835                memmove(del, del + 1,
836                        sizeof(uh_clients) - (int)((char *)del - uh_clients) - sizeof(struct client));
837
838                uh_client_count--;
839        }
840}
841
842
Note: See TracBrowser for help on using the repository browser.