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         /* first serve data from peek buffer */
 171         if( cl->peeklen > 0 )
 172         {
 173                 sz = min(cl->peeklen, len);
 174                 len -= sz; cl->peeklen -= sz;
 175
 176                 memcpy(buf, cl->peekbuf, sz);
 177                 memmove(cl->peekbuf, &cl->peekbuf[sz], cl->peeklen);
 178         }
 179
 180         /* caller wants more */
 181         if( len > 0 )
 182         {
 183 #ifdef HAVE_TLS
 184                 if( cl->tls )
 185                         rsz = cl->server->conf->tls_recv(cl, (void *)&buf[sz], len);
 186                 else
 187 #endif
 188                         rsz = recv(cl->socket, (void *)&buf[sz], len, 0);
 189
 190                 if( (sz == 0) || (rsz > 0) )
 191                         sz += rsz;
 192         }
 193
 194         return sz;
 195 }
 196
 197
 198 int uh_http_sendhf(struct client *cl, int code, const char *summary, const char *fmt, ...)
 199 {
 200         va_list ap;
 201
 202         char buffer[UH_LIMIT_MSGHEAD];
 203         int len;
 204
 205         len = snprintf(buffer, sizeof(buffer),
 206                 "HTTP/1.1 %03i %s\r\n"
 207                 "Connection: close\r\n"
 208                 "Content-Type: text/plain\r\n"
 209                 "Transfer-Encoding: chunked\r\n\r\n",
 210                         code, summary
 211         );
 212
 213         ensure_ret(uh_tcp_send(cl, buffer, len));
 214
 215         va_start(ap, fmt);
 216         len = vsnprintf(buffer, sizeof(buffer), fmt, ap);
 217         va_end(ap);
 218
 219         ensure_ret(uh_http_sendc(cl, buffer, len));
 220         ensure_ret(uh_http_sendc(cl, NULL, 0));
 221
 222         return 0;
 223 }
 224
 225
 226 int uh_http_sendc(struct client *cl, const char *data, int len)
 227 {
 228         char chunk[8];
 229         int clen;
 230
 231         if( len == -1 )
 232                 len = strlen(data);
 233
 234         if( len > 0 )
 235         {
 236                 clen = snprintf(chunk, sizeof(chunk), "%X\r\n", len);
 237                 ensure_ret(uh_tcp_send(cl, chunk, clen));
 238                 ensure_ret(uh_tcp_send(cl, data, len));
 239                 ensure_ret(uh_tcp_send(cl, "\r\n", 2));
 240         }
 241         else
 242         {
 243                 ensure_ret(uh_tcp_send(cl, "0\r\n\r\n", 5));
 244         }
 245
 246         return 0;
 247 }
 248
 249 int uh_http_sendf(
 250         struct client *cl, struct http_request *req, const char *fmt, ...
 251 ) {
 252         va_list ap;
 253         char buffer[UH_LIMIT_MSGHEAD];
 254         int len;
 255
 256         va_start(ap, fmt);
 257         len = vsnprintf(buffer, sizeof(buffer), fmt, ap);
 258         va_end(ap);
 259
 260         if( (req != NULL) && (req->version > 1.0) )
 261                 ensure_ret(uh_http_sendc(cl, buffer, len));
 262         else if( len > 0 )
 263                 ensure_ret(uh_tcp_send(cl, buffer, len));
 264
 265         return 0;
 266 }
 267
 268 int uh_http_send(
 269         struct client *cl, struct http_request *req, const char *buf, int len
 270 ) {
 271         if( len < 0 )
 272                 len = strlen(buf);
 273
 274         if( (req != NULL) && (req->version > 1.0) )
 275                 ensure_ret(uh_http_sendc(cl, buf, len));
 276         else if( len > 0 )
 277                 ensure_ret(uh_tcp_send(cl, buf, len));
 278
 279         return 0;
 280 }
 281
 282
 283 int uh_urldecode(char *buf, int blen, const char *src, int slen)
 284 {
 285         int i;
 286         int len = 0;
 287
 288 #define hex(x) \
 289         (((x) <= '9') ? ((x) - '0') : \
 290                 (((x) <= 'F') ? ((x) - 'A' + 10) : \
 291                         ((x) - 'a' + 10)))
 292
 293         for( i = 0; (i <= slen) && (i <= blen); i++ )
 294         {
 295                 if( src[i] == '%' )
 296                 {
 297                         if( ((i+2) <= slen) && isxdigit(src[i+1]) && isxdigit(src[i+2]) )
 298                         {
 299                                 buf[len++] = (char)(16 * hex(src[i+1]) + hex(src[i+2]));
 300                                 i += 2;
 301                         }
 302                         else
 303                         {
 304                                 buf[len++] = '%';
 305                         }
 306                 }
 307                 else
 308                 {
 309                         buf[len++] = src[i];
 310                 }
 311         }
 312
 313         return len;
 314 }
 315
 316 int uh_urlencode(char *buf, int blen, const char *src, int slen)
 317 {
 318         int i;
 319         int len = 0;
 320         const char hex[] = "0123456789abcdef";
 321
 322         for( i = 0; (i <= slen) && (i <= blen); i++ )
 323         {
 324                 if( isalnum(src[i]) || (src[i] == '-') || (src[i] == '_') ||
 325                     (src[i] == '.') || (src[i] == '~') )
 326                 {
 327                         buf[len++] = src[i];
 328                 }
 329                 else if( (len+3) <= blen )
 330                 {
 331                         buf[len++] = '%';
 332                         buf[len++] = hex[(src[i] >> 4) & 15];
 333                         buf[len++] = hex[(src[i] & 15) & 15];
 334                 }
 335                 else
 336                 {
 337                         break;
 338                 }
 339         }
 340
 341         return len;
 342 }
 343
 344 int uh_b64decode(char *buf, int blen, const unsigned char *src, int slen)
 345 {
 346         int i = 0;
 347         int len = 0;
 348
 349         unsigned int cin  = 0;
 350         unsigned int cout = 0;
 351
 352
 353         for( i = 0; (i <= slen) && (src[i] != 0); i++ )
 354         {
 355                 cin = src[i];
 356
 357                 if( (cin >= '0') && (cin <= '9') )
 358                         cin = cin - '0' + 52;
 359                 else if( (cin >= 'A') && (cin <= 'Z') )
 360                         cin = cin - 'A';
 361                 else if( (cin >= 'a') && (cin <= 'z') )
 362                         cin = cin - 'a' + 26;
 363                 else if( cin == '+' )
 364                         cin = 62;
 365                 else if( cin == '/' )
 366                         cin = 63;
 367                 else if( cin == '=' )
 368                         cin = 0;
 369                 else
 370                         continue;
 371
 372                 cout = (cout << 6) | cin;
 373
 374                 if( (i % 4) == 3 )
 375                 {
 376                         if( (len + 3) < blen )
 377                         {
 378                                 buf[len++] = (char)(cout >> 16);
 379                                 buf[len++] = (char)(cout >> 8);
 380                                 buf[len++] = (char)(cout);
 381                         }
 382                         else
 383                         {
 384                                 break;
 385                         }
 386                 }
 387         }
 388
 389         buf[len++] = 0;
 390         return len;
 391 }
 392
 393 static char * canonpath(const char *path, char *path_resolved)
 394 {
 395         char path_copy[PATH_MAX];
 396         char *path_cpy = path_copy;
 397         char *path_res = path_resolved;
 398
 399         struct stat s;
 400
 401
 402         /* relative -> absolute */
 403         if( *path != '/' )
 404         {
 405                 getcwd(path_copy, PATH_MAX);
 406                 strncat(path_copy, "/", PATH_MAX - strlen(path_copy));
 407                 strncat(path_copy, path, PATH_MAX - strlen(path_copy));
 408         }
 409         else
 410         {
 411                 strncpy(path_copy, path, PATH_MAX);
 412         }
 413
 414         /* normalize */
 415         while( (*path_cpy != '\0') && (path_cpy < (path_copy + PATH_MAX - 2)) )
 416         {
 417                 if( *path_cpy == '/' )
 418                 {
 419                         /* skip repeating / */
 420                         if( path_cpy[1] == '/' )
 421                         {
 422                                 path_cpy++;
 423                                 continue;
 424                         }
 425
 426                         /* /./ or /../ */
 427                         else if( path_cpy[1] == '.' )
 428                         {
 429                                 /* skip /./ */
 430                                 if( (path_cpy[2] == '/') || (path_cpy[2] == '\0') )
 431                                 {
 432                                         path_cpy += 2;
 433                                         continue;
 434                                 }
 435
 436                                 /* collapse /x/../ */
 437                                 else if( (path_cpy[2] == '.') &&
 438                                          ((path_cpy[3] == '/') || (path_cpy[3] == '\0'))
 439                                 ) {
 440                                         while( (path_res > path_resolved) && (*--path_res != '/') )
 441                                                 ;
 442
 443                                         path_cpy += 3;
 444                                         continue;
 445                                 }
 446                         }
 447                 }
 448
 449                 *path_res++ = *path_cpy++;
 450         }
 451
 452         /* remove trailing slash if not root / */
 453         if( (path_res > (path_resolved+1)) && (path_res[-1] == '/') )
 454                 path_res--;
 455         else if( path_res == path_resolved )
 456                 *path_res++ = '/';
 457
 458         *path_res = '\0';
 459
 460         /* test access */
 461         if( !stat(path_resolved, &s) && (s.st_mode & S_IROTH) )
 462                 return path_resolved;
 463
 464         return NULL;
 465 }
 466
 467 struct path_info * uh_path_lookup(struct client *cl, const char *url)
 468 {
 469         static char path_phys[PATH_MAX];
 470         static char path_info[PATH_MAX];
 471         static struct path_info p;
 472
 473         char buffer[UH_LIMIT_MSGHEAD];
 474         char *docroot = cl->server->conf->docroot;
 475         char *pathptr = NULL;
 476
 477         int no_sym = cl->server->conf->no_symlinks;
 478         int i = 0;
 479         struct stat s;
 480
 481         /* back out early if url is undefined */
 482         if ( url == NULL )
 483                 return NULL;
 484
 485         memset(path_phys, 0, sizeof(path_phys));
 486         memset(path_info, 0, sizeof(path_info));
 487         memset(buffer, 0, sizeof(buffer));
 488         memset(&p, 0, sizeof(p));
 489
 490         /* copy docroot */
 491         memcpy(buffer, docroot,
 492                 min(strlen(docroot), sizeof(buffer) - 1));
 493
 494         /* separate query string from url */
 495         if( (pathptr = strchr(url, '?')) != NULL )
 496         {
 497                 p.query = pathptr[1] ? pathptr + 1 : NULL;
 498
 499                 /* urldecode component w/o query */
 500                 if( pathptr > url )
 501                         uh_urldecode(
 502                                 &buffer[strlen(docroot)],
 503                                 sizeof(buffer) - strlen(docroot) - 1,
 504                                 url, (int)(pathptr - url) - 1
 505                         );
 506         }
 507
 508         /* no query string, decode all of url */
 509         else
 510         {
 511                 uh_urldecode(
 512                         &buffer[strlen(docroot)],
 513                         sizeof(buffer) - strlen(docroot) - 1,
 514                         url, strlen(url)
 515                 );
 516         }
 517
 518         /* create canon path */
 519         for( i = strlen(buffer); i >= 0; i-- )
 520         {
 521                 if( (buffer[i] == 0) || (buffer[i] == '/') )
 522                 {
 523                         memset(path_info, 0, sizeof(path_info));
 524                         memcpy(path_info, buffer, min(i + 1, sizeof(path_info) - 1));
 525
 526                         if( no_sym ? realpath(path_info, path_phys)
 527                                    : canonpath(path_info, path_phys)
 528                         ) {
 529                                 memset(path_info, 0, sizeof(path_info));
 530                                 memcpy(path_info, &buffer[i],
 531                                         min(strlen(buffer) - i, sizeof(path_info) - 1));
 532
 533                                 break;
 534                         }
 535                 }
 536         }
 537
 538         /* check whether found path is within docroot */
 539         if( strncmp(path_phys, docroot, strlen(docroot)) ||
 540             ((path_phys[strlen(docroot)] != 0) &&
 541                  (path_phys[strlen(docroot)] != '/'))
 542         ) {
 543                 return NULL;
 544         }
 545
 546         /* test current path */
 547         if( ! stat(path_phys, &p.stat) )
 548         {
 549                 /* is a regular file */
 550                 if( p.stat.st_mode & S_IFREG )
 551                 {
 552                         p.root = docroot;
 553                         p.phys = path_phys;
 554                         p.name = &path_phys[strlen(docroot)];
 555                         p.info = path_info[0] ? path_info : NULL;
 556                 }
 557
 558                 /* is a directory */
 559                 else if( (p.stat.st_mode & S_IFDIR) && !strlen(path_info) )
 560                 {
 561                         /* ensure trailing slash */
 562                         if( path_phys[strlen(path_phys)-1] != '/' )
 563                                 path_phys[strlen(path_phys)] = '/';
 564
 565                         /* try to locate index file */
 566                         memset(buffer, 0, sizeof(buffer));
 567                         memcpy(buffer, path_phys, sizeof(buffer));
 568                         pathptr = &buffer[strlen(buffer)];
 569
 570                         if( cl->server->conf->index_file )
 571                         {
 572                                 strncat(buffer, cl->server->conf->index_file, sizeof(buffer));
 573
 574                                 if( !stat(buffer, &s) && (s.st_mode & S_IFREG) )
 575                                 {
 576                                         memcpy(path_phys, buffer, sizeof(path_phys));
 577                                         memcpy(&p.stat, &s, sizeof(p.stat));
 578                                 }
 579                         }
 580                         else
 581                         {
 582                                 for( i = 0; i < array_size(uh_index_files); i++ )
 583                                 {
 584                                         strncat(buffer, uh_index_files[i], sizeof(buffer));
 585
 586                                         if( !stat(buffer, &s) && (s.st_mode & S_IFREG) )
 587                                         {
 588                                                 memcpy(path_phys, buffer, sizeof(path_phys));
 589                                                 memcpy(&p.stat, &s, sizeof(p.stat));
 590                                                 break;
 591                                         }
 592
 593                                         *pathptr = 0;
 594                                 }
 595                         }
 596
 597                         p.root = docroot;
 598                         p.phys = path_phys;
 599                         p.name = &path_phys[strlen(docroot)];
 600                 }
 601         }
 602
 603         return p.phys ? &p : NULL;
 604 }
 605
 606
 607 static struct auth_realm *uh_realms = NULL;
 608
 609 struct auth_realm * uh_auth_add(char *path, char *user, char *pass)
 610 {
 611         struct auth_realm *new = NULL;
 612         struct passwd *pwd;
 613
 614 #ifdef HAVE_SHADOW
 615         struct spwd *spwd;
 616 #endif
 617
 618         if((new = (struct auth_realm *)malloc(sizeof(struct auth_realm))) != NULL)
 619         {
 620                 memset(new, 0, sizeof(struct auth_realm));
 621
 622                 memcpy(new->path, path,
 623                         min(strlen(path), sizeof(new->path) - 1));
 624
 625                 memcpy(new->user, user,
 626                         min(strlen(user), sizeof(new->user) - 1));
 627
 628                 /* given password refers to a passwd entry */
 629                 if( (strlen(pass) > 3) && !strncmp(pass, "$p$", 3) )
 630                 {
 631 #ifdef HAVE_SHADOW
 632                         /* try to resolve shadow entry */
 633                         if( ((spwd = getspnam(&pass[3])) != NULL) && spwd->sp_pwdp )
 634                         {
 635                                 memcpy(new->pass, spwd->sp_pwdp,
 636                                         min(strlen(spwd->sp_pwdp), sizeof(new->pass) - 1));
 637                         }
 638
 639                         else
 640 #endif
 641
 642                         /* try to resolve passwd entry */
 643                         if( ((pwd = getpwnam(&pass[3])) != NULL) && pwd->pw_passwd &&
 644                                 (pwd->pw_passwd[0] != '!') && (pwd->pw_passwd[0] != 0)
 645                         ) {
 646                                 memcpy(new->pass, pwd->pw_passwd,
 647                                         min(strlen(pwd->pw_passwd), sizeof(new->pass) - 1));
 648                         }
 649                 }
 650
 651                 /* ordinary pwd */
 652                 else
 653                 {
 654                         memcpy(new->pass, pass,
 655                                 min(strlen(pass), sizeof(new->pass) - 1));
 656                 }
 657
 658                 if( new->pass[0] )
 659                 {
 660                         new->next = uh_realms;
 661                         uh_realms = new;
 662
 663                         return new;
 664                 }
 665
 666                 free(new);
 667         }
 668
 669         return NULL;
 670 }
 671
 672 int uh_auth_check(
 673         struct client *cl, struct http_request *req, struct path_info *pi
 674 ) {
 675         int i, plen, rlen, protected;
 676         char buffer[UH_LIMIT_MSGHEAD];
 677         char *user = NULL;
 678         char *pass = NULL;
 679
 680         struct auth_realm *realm = NULL;
 681
 682         plen = strlen(pi->name);
 683         protected = 0;
 684
 685         /* check whether at least one realm covers the requested url */
 686         for( realm = uh_realms; realm; realm = realm->next )
 687         {
 688                 rlen = strlen(realm->path);
 689
 690                 if( (plen >= rlen) && !strncasecmp(pi->name, realm->path, rlen) )
 691                 {
 692                         req->realm = realm;
 693                         protected = 1;
 694                         break;
 695                 }
 696         }
 697
 698         /* requested resource is covered by a realm */
 699         if( protected )
 700         {
 701                 /* try to get client auth info */
 702                 foreach_header(i, req->headers)
 703                 {
 704                         if( !strcasecmp(req->headers[i], "Authorization") &&
 705                                 (strlen(req->headers[i+1]) > 6) &&
 706                                 !strncasecmp(req->headers[i+1], "Basic ", 6)
 707                         ) {
 708                                 memset(buffer, 0, sizeof(buffer));
 709                                 uh_b64decode(buffer, sizeof(buffer) - 1,
 710                                         (unsigned char *) &req->headers[i+1][6],
 711                                         strlen(req->headers[i+1]) - 6);
 712
 713                                 if( (pass = strchr(buffer, ':')) != NULL )
 714                                 {
 715                                         user = buffer;
 716                                         *pass++ = 0;
 717                                 }
 718
 719                                 break;
 720                         }
 721                 }
 722
 723                 /* have client auth */
 724                 if( user && pass )
 725                 {
 726                         /* find matching realm */
 727                         for( realm = uh_realms; realm; realm = realm->next )
 728                         {
 729                                 rlen = strlen(realm->path);
 730
 731                                 if( (plen >= rlen) &&
 732                                     !strncasecmp(pi->name, realm->path, rlen) &&
 733                                     !strcmp(user, realm->user)
 734                                 ) {
 735                                         req->realm = realm;
 736                                         break;
 737                                 }
 738                         }
 739
 740                         /* found a realm matching the username */
 741                         if( realm )
 742                         {
 743                                 /* is a crypt passwd */
 744                                 if( realm->pass[0] == '$' )
 745                                         pass = crypt(pass, realm->pass);
 746
 747                                 /* check user pass */
 748                                 if( !strcmp(pass, realm->pass) )
 749                                         return 1;
 750                         }
 751                 }
 752
 753                 /* 401 */
 754                 uh_http_sendf(cl, NULL,
 755                         "HTTP/%.1f 401 Authorization Required\r\n"
 756                         "WWW-Authenticate: Basic realm=\"%s\"\r\n"
 757                         "Content-Type: text/plain\r\n"
 758                         "Content-Length: 23\r\n\r\n"
 759                         "Authorization Required\n",
 760                                 req->version, cl->server->conf->realm
 761                 );
 762
 763                 return 0;
 764         }
 765
 766         return 1;
 767 }
 768
 769
 770 static struct listener *uh_listeners = NULL;
 771 static struct client *uh_clients = NULL;
 772
 773 struct listener * uh_listener_add(int sock, struct config *conf)
 774 {
 775         struct listener *new = NULL;
 776         socklen_t sl;
 777
 778         if( (new = (struct listener *)malloc(sizeof(struct listener))) != NULL )
 779         {
 780                 memset(new, 0, sizeof(struct listener));
 781
 782                 new->socket = sock;
 783                 new->conf   = conf;
 784
 785                 /* get local endpoint addr */
 786                 sl = sizeof(struct sockaddr_in6);
 787                 memset(&(new->addr), 0, sl);
 788                 getsockname(sock, (struct sockaddr *) &(new->addr), &sl);
 789
 790                 new->next = uh_listeners;
 791                 uh_listeners = new;
 792
 793                 return new;
 794         }
 795
 796         return NULL;
 797 }
 798
 799 struct listener * uh_listener_lookup(int sock)
 800 {
 801         struct listener *cur = NULL;
 802
 803         for( cur = uh_listeners; cur; cur = cur->next )
 804                 if( cur->socket == sock )
 805                         return cur;
 806
 807         return NULL;
 808 }
 809
 810
 811 struct client * uh_client_add(int sock, struct listener *serv)
 812 {
 813         struct client *new = NULL;
 814         socklen_t sl;
 815
 816         if( (new = (struct client *)malloc(sizeof(struct client))) != NULL )
 817         {
 818                 memset(new, 0, sizeof(struct client));
 819
 820                 new->socket = sock;
 821                 new->server = serv;
 822
 823                 /* get remote endpoint addr */
 824                 sl = sizeof(struct sockaddr_in6);
 825                 memset(&(new->peeraddr), 0, sl);
 826                 getpeername(sock, (struct sockaddr *) &(new->peeraddr), &sl);
 827
 828                 /* get local endpoint addr */
 829                 sl = sizeof(struct sockaddr_in6);
 830                 memset(&(new->servaddr), 0, sl);
 831                 getsockname(sock, (struct sockaddr *) &(new->servaddr), &sl);
 832
 833                 new->next = uh_clients;
 834                 uh_clients = new;
 835         }
 836
 837         return new;
 838 }
 839
 840 struct client * uh_client_lookup(int sock)
 841 {
 842         struct client *cur = NULL;
 843
 844         for( cur = uh_clients; cur; cur = cur->next )
 845                 if( cur->socket == sock )
 846                         return cur;
 847
 848         return NULL;
 849 }
 850
 851 void uh_client_remove(int sock)
 852 {
 853         struct client *cur = NULL;
 854         struct client *prv = NULL;
 855
 856         for( cur = uh_clients; cur; prv = cur, cur = cur->next )
 857         {
 858                 if( cur->socket == sock )
 859                 {
 860                         if( prv )
 861                                 prv->next = cur->next;
 862                         else
 863                                 uh_clients = cur->next;
 864
 865                         free(cur);
 866                         break;
 867                 }
 868         }
 869 }
 870
 871
 872 #ifdef HAVE_CGI
 873 static struct interpreter *uh_interpreters = NULL;
 874
 875 struct interpreter * uh_interpreter_add(const char *extn, const char *path)
 876 {
 877         struct interpreter *new = NULL;
 878
 879         if( (new = (struct interpreter *)
 880                         malloc(sizeof(struct interpreter))) != NULL )
 881         {
 882                 memset(new, 0, sizeof(struct interpreter));
 883
 884                 memcpy(new->extn, extn, min(strlen(extn), sizeof(new->extn)-1));
 885                 memcpy(new->path, path, min(strlen(path), sizeof(new->path)-1));
 886
 887                 new->next = uh_interpreters;
 888                 uh_interpreters = new;
 889
 890                 return new;
 891         }
 892
 893         return NULL;
 894 }
 895
 896 struct interpreter * uh_interpreter_lookup(const char *path)
 897 {
 898         struct interpreter *cur = NULL;
 899         const char *e;
 900
 901         for( cur = uh_interpreters; cur; cur = cur->next )
 902         {
 903                 e = &path[max(strlen(path) - strlen(cur->extn), 0)];
 904
 905                 if( !strcmp(e, cur->extn) )
 906                         return cur;
 907         }
 908
 909         return NULL;
 910 }
 911 #endif