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