开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Web服务器 > 查看源码
httpd.c
资源名称：httpd.tar.gz　[点击查看]
上传用户：lampled
上传日期：2007-01-07
资源大小：94k
文件大小：28k
源码类别：

Web服务器

开发平台：

Unix_Linux

httpd.c：源码内容
  1. /* Copyright (C) 1995, 1996 by Sven Berkvens (sven@stack.nl) */
  3. #include "config.h"
  5. #include <sys/types.h>
  6. #ifdef HAVE_SYS_TIME_H
  7. #include <sys/time.h>
  8. #endif /* HAVE_SYS_TIME_H */
  9. #ifdef HAVE_SYS_RESOURCE_H
  10. #include <sys/resource.h>
  11. #endif /* HAVE_SYS_RESOURCE_H */
  12. #ifdef HAVE_SYS_MMAN_H
  13. #include <sys/mman.h>
  14. #endif /* HAVE_SYS_MMAN_H */
  15. #include <sys/socket.h>
  16. #ifdef HAVE_SYS_WAIT_H
  17. #include <sys/wait.h>
  18. #endif /* HAVE_SYS_WAIT_H */
  19. #include <sys/signal.h>
  20. #include <sys/stat.h>
  21. #ifdef HAVE_SYS_SELECT_H
  22. #include <sys/select.h>
  23. #endif /* HAVE_SYS_SELECT_H */
  24. #ifdef HAVE_SYS_PARAM_H
  25. #include <sys/param.h>
  26. #endif /* HAVE_SYS_PARAM_H */
  27. #ifdef HAVE_SYS_SYSLIMITS_H
  28. #include <sys/syslimits.h>
  29. #endif /* HAVE_SYS_SYSLIMITS_H */
  31. #include <netinet/in.h>
  33. #include <arpa/inet.h>
  35. #include <fcntl.h>
  36. #include <string.h>
  37. #include <stdio.h>
  38. #include <errno.h>
  39. #include <netdb.h>
  40. #ifdef HAVE_TIME_H
  41. #ifdef SYS_TIME_WITH_TIME
  42. #include <time.h>
  43. #endif /* SYS_TIME_WITH_TIME */
  44. #endif /* HAVE_TIME_H */
  45. #include <stdlib.h>
  46. #ifndef NONEWSTYLE
  47. #include <stdarg.h>
  48. #else /* Not not NONEWSTYLE */
  49. #include <varargs.h>
  50. #endif /* NONEWSTYLE */
  51. #include <signal.h>
  52. #include <pwd.h>
  53. #include <grp.h>
  54. #include <unistd.h>
  55. #ifdef HAVE_ERR_H
  56. #include <err.h>
  57. #else /* Not HAVE_ERR_H */
  58. #include "err.h"
  59. #endif /* HAVE_ERR_H */
  60. #include <ctype.h>
  61. #ifdef HAVE_ALLOCA_H
  62. #include <alloca.h>
  63. #endif /* HAVE_ALLOCA_H */
  64. #ifdef HAVE_VFORK_H
  65. #include <vfork.h>
  66. #endif /* HAVE_VFORK_H */
  67. #ifdef HAVE_MEMORY_H
  68. #include <memory.h>
  69. #endif /* HAVE_MEMORY_H */
  71. #include "httpd.h"
  72. #include "methods.h"
  73. #include "local.h"
  74. #include "procname.h"
  75. #include "ssi.h"
  76. #include "extra.h"
  77. #include "cgi.h"
  78. #include "xscrypt.h"
  79. #include "path.h"
  80. #include "convert.h"
  81. #include "setenv.h"
  82. #include "getopt.h"
  83. #include "string.h"
  85. #ifdef __linux__
  86. extern char *tempnam(const char *, const char *);
  87. #endif /* __linux__ */
  89. /* This is for HP/UX */
  90. #ifdef HPUX
  91. #ifndef NOFORWARDS
  92. extern int setpriority PROTO((int, int, int));
  93. #endif /* NOFORWARDS */
  94. #endif /* HPUX */
  96. /* Global variables */
  98. int port, headers, localmode, netbufind, netbufsiz, readlinemode,
  99. headonly, postonly;
  100. static int sd, reqs, number, mainhttpd = 1;
  101. gid_t group_id, origegid;
  102. uid_t user_id, origeuid;
  103. char netbuf[MYBUFSIZ], remotehost[MAXHOSTNAMELEN], orig[MYBUFSIZ],
  104. currenttime[80], dateformat[MYBUFSIZ], real_path[XS_PATH_MAX],
  105. thishostname[MAXHOSTNAMELEN], version[16], error_path[XS_PATH_MAX],
  106. access_path[XS_PATH_MAX], refer_path[XS_PATH_MAX], rootdir[XS_PATH_MAX],
  107. total[XS_PATH_MAX], name[XS_PATH_MAX];
  108. static char browser[MYBUFSIZ], referer[MYBUFSIZ], outputbuffer[SENDBUFSIZE],
  109. thisdomain[MAXHOSTNAMELEN], message503[MYBUFSIZ],
  110. *startparams;
  111. FILE *access_log = NULL, *refer_log = NULL;
  112. time_t modtime;
  113. static struct in_addr thisaddress;
  115. /* Static arrays */
  117. static char six2pr[64] =
  118. {
  119. 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
  120. 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
  121. 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
  122. 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
  123. '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
  124. };
  126. /* Prototypes */
  128. #ifndef NOFORWARDS
  129. static VOID filedescrs PROTO((void));
  130. static VOID detach PROTO((void));
  131. static VOID child_handler PROTO((int));
  132. static VOID term_handler PROTO((int));
  133. static VOID open_logs PROTO((int));
  134. static VOID core_handler PROTO((int));
  135. static VOID set_signals PROTO((void));
  137. static int hexdigit PROTO((int));
  138. static int decode PROTO((char *));
  140. static VOID uudecode PROTO((char *));
  142. static VOID process_request PROTO((void));
  144. static VOID setup_environment PROTO((void));
  145. static VOID standalone_main PROTO((void));
  146. #endif /* NOFORWARDS */
  148. extern VOID
  149. stdheaders DECL3(int, lastmod, int, texthtml, int, endline)
  150. {
  151. setcurrenttime();
  152. printf("Date: %srnServer: %srn", currenttime, SERVER_IDENT);
  153. if (lastmod)
  154. printf("Last-modified: %srnExpires: %srn",
  155. currenttime, currenttime);
  156. if (texthtml)
  157. printf("Content-type: text/htmlrn");
  158. if (endline)
  159. printf("rn");
  160. }
  162. static VOID
  163. filedescrs DECL0
  164. {
  165. close(0); if (open(BITBUCKETNAME, O_RDONLY, 0) != 0)
  166. err(1, "Cannot open fd 0 (%s)", BITBUCKETNAME);
  167. if (dup2(0, 1) != 1)
  168. err(1, "Cannot dup2() fd 1");
  169. }
  171. static VOID
  172. detach DECL0
  173. {
  174. pid_t x;
  176. if (chdir("/"))
  177. err(1, "chdir(`/')");
  178. if ((x = fork()) > 0)
  179. exit(0);
  180. else if (x == -1)
  181. err(1, "fork()");
  182. #ifdef HAVE_SETSID
  183. if (setsid() == -1)
  184. err(1, "setsid() failed");
  185. #else /* Not HAVE_SETSID */
  186. if (setpgrp(getpid(), 0)) == -1)
  187. err(1, "setpgrp() failed");
  188. #endif /* HAVE_SETSID */
  189. }
  191. extern VOID
  192. setcurrenttime DECL0
  193. {
  194. time_t thetime;
  196. time(&thetime);
  197. strftime(currenttime, sizeof(currenttime),
  198. "%a, %d %b %Y %T GMT", gmtime(&thetime));
  199. }
  201. static VOID
  202. child_handler DECL1(int, sig)
  203. {
  204. #ifdef NeXT
  205. union wait status;
  206. #else /* Not NeXT */
  207. int status;
  208. #endif /* NeXT */
  210. while (wait3(&status, WNOHANG, NULL) > 0)
  211. /* NOTHING */;
  212. set_signals();
  213. }
  215. static VOID
  216. term_handler DECL1(int, sig)
  217. {
  218. if (mainhttpd)
  219. {
  220. setcurrenttime();
  221. fprintf(stderr, "[%s] Received signal %d, shutting down...n",
  222. currenttime, sig);
  223. fflush(stderr);
  224. mainhttpd = 0;
  225. killpg(0, SIGTERM);
  226. }
  227. exit(0);
  228. }
  230. static VOID
  231. open_logs DECL1(int, sig)
  232. {
  233. FILE *pidlog;
  234. char buffer[XS_PATH_MAX];
  235. uid_t savedeuid;
  236. gid_t savedegid;
  237. int tempfile;
  239. set_signals();
  240. savedeuid = savedegid = -1;
  241. if (!origeuid)
  242. {
  243. savedeuid = geteuid(); seteuid(origeuid);
  244. savedegid = getegid(); setegid(origegid);
  245. }
  246. if (mainhttpd)
  247. {
  248. sprintf(buffer, calcpath(PID_PATH));
  249. remove(buffer);
  250. if ((pidlog = fopen(buffer, "w")))
  251. {
  252. fprintf(pidlog, "%ldn", (long)getpid());
  253. fprintf(pidlog, "%sn", startparams);
  254. fclose(pidlog);
  255. }
  256. signal(SIGHUP, SIG_IGN); killpg(0, SIGHUP);
  257. }
  259. if (access_log)
  260. fclose(access_log);
  261. if (!(access_log = fopen(access_path, "a")))
  262. err(1, "fopen(`%s' [append])", access_path);
  263. #ifndef SETVBUF_REVERSED
  264. setvbuf(access_log, NULL, _IOLBF, 0);
  265. #else /* Not not SETVBUF_REVERSED */
  266. setvbuf(access_log, _IOLBF, NULL, 0);
  267. #endif /* SETVBUF_REVERSED */
  269. fflush(stderr);
  270. close(2);
  271. if ((tempfile = open(error_path, O_CREAT | O_APPEND | O_WRONLY,
  272. S_IWUSR | S_IRUSR | S_IROTH | S_IRGRP)) < 0)
  273. err(1, "open(`%s' [append])", error_path);
  274. if (tempfile != 2)
  275. {
  276. if (dup2(tempfile, 2) == -1)
  277. err(1, "dup2() failed");
  278. close(tempfile);
  279. }
  281. if (refer_log)
  282. fclose(refer_log);
  283. if (!(refer_log = fopen(refer_path, "a")))
  284. err(1, "fopen(`%s' [append])", refer_path);
  285. #ifndef SETVBUF_REVERSED
  286. setvbuf(refer_log, NULL, _IOLBF, 0);
  287. #else /* Not not SETVBUF_REVERSED */
  288. setvbuf(refer_log, _IOLBF, NULL, 0);
  289. #endif /* SETVBUF_REVERSED */
  291. if (mainhttpd)
  292. {
  293. setcurrenttime();
  294. fprintf(stderr, "[%s] httpd: Successful restartn",
  295. currenttime);
  296. }
  297. loadfiletypes();
  298. #ifdef HANDLE_COMPRESSED
  299. loadcompresstypes();
  300. #endif /* HANDLE_COMPRESSED */
  301. set_signals();
  302. if (!origeuid)
  303. {
  304. if (seteuid(savedeuid) == -1)
  305. err(1, "seteuid()");
  306. if (setegid(savedegid) == -1)
  307. err(1, "setegid()");
  308. }
  309. }
  311. extern VOID
  312. alarm_handler DECL1(int, sig)
  313. {
  314. alarm(0); setcurrenttime();
  315. fprintf(stderr, "[%s] httpd: Send timed out for `%s'n",
  316. currenttime, remotehost[0] ? remotehost : "(none)");
  317. exit(1);
  318. }
  320. static VOID
  321. core_handler DECL1(int, sig)
  322. {
  323. const char *env;
  325. alarm(0); setcurrenttime();
  326. env = getenv("DOCUMENT_ARGUMENTS");
  327. fprintf(stderr, "[%s] httpd(pid %ld): FATAL SIGNAL %d [from: `%s' req: `%s' params: `%s' referer: `%s']n",
  328. currenttime, (long)getpid(), sig,
  329. remotehost[0] ? remotehost : "(none)",
  330. orig[0] ? orig : "(none)", env ? env : "(none)",
  331. referer[0] ? referer : "(none)");
  332. exit(1);
  333. }
  335. static VOID
  336. set_signals DECL0
  337. {
  338. struct sigaction action;
  340. #ifdef HAVE_SIGEMPTYSET
  341. sigemptyset(&action.sa_mask);
  342. #else /* Not HAVE_SIGEMPTYSET */
  343. action.sa_mask = 0;
  344. #endif /* HAVE_SIGEMPTYSET */
  346. action.sa_handler = open_logs;
  347. #ifdef SA_RESTART
  348. action.sa_flags = SA_RESTART;
  349. #else /* Not SA_RESTART */
  350. action.sa_flags = 0;
  351. #endif /* SA_RESTART */
  352. sigaction(SIGHUP, &action, NULL);
  354. action.sa_handler = child_handler;
  355. action.sa_flags = 0;
  356. sigaction(SIGCHLD, &action, NULL);
  358. action.sa_handler = alarm_handler;
  359. action.sa_flags = 0;
  360. sigaction(SIGALRM, &action, NULL);
  362. action.sa_handler = term_handler;
  363. action.sa_flags = 0;
  364. sigaction(SIGTERM, &action, NULL);
  366. action.sa_handler = term_handler;
  367. action.sa_flags = 0;
  368. sigaction(SIGINT, &action, NULL);
  370. #ifdef SIGBUS
  371. action.sa_handler = core_handler;
  372. action.sa_flags = 0;
  373. sigaction(SIGBUS, &action, NULL);
  374. #endif /* SIGBUS */
  376. #ifdef SIGSEGV
  377. action.sa_handler = core_handler;
  378. action.sa_flags = 0;
  379. sigaction(SIGSEGV, &action, NULL);
  380. #endif /* SIGSEGV */
  381. }
  383. extern VOID
  384. error DECL1C(char *, message)
  385. {
  386. const char *env;
  388. alarm(180); setcurrenttime();
  389. env = getenv("DOCUMENT_ARGUMENTS");
  390. fprintf(stderr, "[%s] httpd(pid %ld): %s [from: `%s' req: `%s' params: `%s' referer: `%s']n",
  391. currenttime, (long)getpid(), message,
  392. remotehost[0] ? remotehost : "(none)",
  393. orig[0] ? orig : "(none)", env ? env : "(none)",
  394. referer[0] ? referer : "(none)");
  395. if (headers)
  396. {
  397. printf("%s %srn", version, message);
  398. stdheaders(1, 1, 1);
  399. }
  400. if (!headonly)
  401. {
  402. printf("rn<HTML><HEAD><TITLE>%s</TITLE></HEAD><BODY>n",
  403. message);
  404. printf("<H1>%s</H1></BODY></HTML>n", message);
  405. }
  406. fflush(stdout); fflush(stderr); alarm(0);
  407. }
  409. extern VOID
  410. redirect DECL2C_(char *, redir, int, permanent)
  411. {
  412. const char *env;
  414. env = getenv("DOCUMENT_ARGUMENTS");
  415. if (headers)
  416. {
  417. printf("%s %s movedrnLocation: %srn", version,
  418. permanent ? "301 Permanently" : "302 Temporarily",
  419. redir);
  420. stdheaders(1, 1, 1);
  421. }
  422. if (!headonly)
  423. {
  424. printf("rn<HTML><HEAD><TITLE>Document has moved</TITLE></HEAD>");
  425. printf("<BODY>n<H1>Document has moved</H1>This document has ");
  426. printf("%smoved to <A HREF="%s%s%s">%s</A>.</BODY></HTML>n",
  427. permanent ? "permanently " : "", redir,
  428. env ? "?" : "", env ? env : "", redir);
  429. }
  430. fflush(stdout);
  431. }
  433. static int
  434. hexdigit DECL1(int, ch)
  435. {
  436. const char *temp, *hexdigits = "0123456789ABCDEF";
  438. if ((temp = strchr(hexdigits, toupper(ch))))
  439. return(temp - hexdigits);
  440. else
  441. {
  442. error("500 Invalid `percent' parameters");
  443. return(-1);
  444. }
  445. }
  447. static int
  448. decode DECL1(char *, str)
  449. {
  450. char *posd, chr;
  451. const char *poss;
  452. int top, bottom;
  454. poss = posd = str;
  455. while ((chr = *poss))
  456. {
  457. if (chr != '%')
  458. {
  459. if (chr == '?')
  460. {
  461. bcopy(poss, posd, strlen(poss) + 1);
  462. return(ERR_NONE);
  463. }
  464. *(posd++) = chr;
  465. poss++;
  466. } else
  467. {
  468. if ((top = hexdigit((int)poss[1])) == -1)
  469. return(ERR_QUIT);
  470. if ((bottom = hexdigit((int)poss[2])) == -1)
  471. return(ERR_QUIT);
  472. *(posd++) = (top << 4) + bottom;
  473. poss += 3;
  474. }
  475. }
  476. *posd = 0;
  477. return(ERR_NONE);
  478. }
  480. static VOID
  481. uudecode DECL1(char *, buffer)
  482. {
  483. unsigned char pr2six[256], bufplain[32], *bufout = bufplain;
  484. int nbytesdecoded, j, nprbytes;
  485. char *bufin = buffer;
  487. for (j = 0; j < 256; j++)
  488. pr2six[j] = 64;
  489. for (j = 0; j < 64; j++)
  490. pr2six[(int)six2pr[j]] = (unsigned char)j;
  491. bufin = buffer;
  492. while (pr2six[(int)*(bufin++)] <= 63)
  493. /* NOTHING HERE */;
  494. nprbytes = bufin - buffer - 1;
  495. nbytesdecoded = ((nprbytes + 3) / 4) * 3;
  496. bufin = buffer;
  497. while (nprbytes > 0)
  498. {
  499. *(bufout++) = (unsigned char) ((pr2six[(int)*bufin] << 2) |
  500. (pr2six[(int)bufin[1]] >> 4));
  501. *(bufout++) = (unsigned char) ((pr2six[(int)bufin[1]] << 4) |
  502. (pr2six[(int)bufin[2]] >> 2));
  503. *(bufout++) = (unsigned char) ((pr2six[(int)bufin[2]] << 6) |
  504. (pr2six[(int)bufin[3]]));
  505. bufin += 4; nprbytes -= 4;
  506. }
  507.    
  508. if (nprbytes & 3)
  509. {
  510. if (pr2six[(int)*(bufin - 2)] > 63)
  511. nbytesdecoded -= 2;
  512. else
  513. nbytesdecoded--;
  514. }
  515. if (nbytesdecoded)
  516. bcopy((char *)bufplain, buffer, nbytesdecoded);
  517. buffer[nbytesdecoded] = 0;
  518. }
  520. extern int
  521. check_auth DECL1(FILE *, authfile)
  522. {
  523. char *search, line[MYBUFSIZ], compare[MYBUFSIZ], *find;
  524. const char *env;
  526. if (!(env = getenv("AUTH_TYPE")))
  527. {
  528. if (headers)
  529. {
  530. printf("%s 401 Unauthorizedrn", version);
  531. printf("WWW-authenticate: basic realm="this page"rn");
  532. stdheaders(1, 1, 1);
  533. }
  534. printf("rn<HTML><HEAD><TITLE>Unauthorized</TITLE></HEAD>n");
  535. printf("<BODY><H1>Unauthorized</H1>nYour client does not ");
  536. printf("understand authentication.n</BODY></HTML>n");
  537. fclose(authfile); return(1);
  538. }
  539. strncpy(line, env, MYBUFSIZ - 1); line[MYBUFSIZ - 1] = 0;
  540. find = line + strlen(line);
  541. while ((find > line) && (*(find - 1) < ' '))
  542. *(--find) = 0;
  543. for (search = line; *search && (*search != ' ') &&
  544. (*search != 9); search++) ;
  545. while ((*search == 9) || (*search == ' '))
  546. search++;
  547. uudecode(search);
  548. if ((find = strchr(search, ':')))
  549. {
  550. *find = 0;
  551. setenv("REMOTE_USER", search, 1);
  552. *find = ':';
  553. setenv("REMOTE_PASSWORD", find + 1, 1);
  554. xs_encrypt(find + 1);
  555. }
  556. while (fgets(compare, MYBUFSIZ, authfile))
  557. {
  558. compare[strlen(compare) - 1] = 0;
  559. if (!strcmp(compare + 1, search))
  560. {
  561. fclose(authfile); return(0);
  562. }
  563. }
  564. fclose(authfile);
  565. server_error("401 Wrong user/password combination", "UNAUTHORIZED");
  566. return(1);
  567. }
  569. extern char *
  570. escape DECL1C(char *, what)
  571. {
  572. char *escapebuf, *w;
  574. if (!(w = escapebuf = (char *)malloc(BUFSIZ)))
  575. return(NULL);
  576. while (*what && ((w - escapebuf) < (BUFSIZ - 10)))
  577. {
  578. switch(*what)
  579. {
  580. case '<':
  581. strcpy(w, "&lt;"); w += 4;
  582. break;
  583. case '>':
  584. strcpy(w, "&gt;"); w += 4;
  585. break;
  586. case '&':
  587. strcpy(w, "&amp;"); w += 5;
  588. break;
  589. case '"':
  590. strcpy(w, "&quot;"); w += 6;
  591. break;
  592. default:
  593. *(w++) = *what;
  594. break;
  595. }
  596. what++;
  597. }
  598. *w = 0;
  599. return(escapebuf);
  600. }
  602. extern VOID
  603. server_error DECL2CC(char *, readable, char *, cgi)
  604. {
  605. struct stat statbuf;
  606. const struct passwd *userinfo;
  607. char *search, cgipath[XS_PATH_MAX], base[XS_PATH_MAX],
  608. *escaped;
  609. const char *env;
  611. if (headonly)
  612. {
  613. error(readable);
  614. return;
  615. }
  616. setenv("ERROR_CODE", cgi, 1);
  617. setenv("ERROR_READABLE", readable, 1);
  618. setenv("ERROR_URL", orig, 1);
  619. setenv("ERROR_URL_EXPANDED", convertpath(orig), 1);
  620. escaped = escape(orig);
  621. setenv("ERROR_URL_ESCAPED", escaped ? escaped : "", 1);
  622. if (escaped)
  623. free(escaped);
  624. env = getenv("DOCUMENT_ARGUMENTS");
  625. if (real_path[1] == '~')
  626. {
  627. if ((search = strchr(real_path + 2, '/')))
  628. *search = 0;
  629. if ((userinfo = getpwnam(real_path + 2)))
  630. {
  631. if (search)
  632. *search = '/';
  633. if (!transform_user_dir(base, userinfo, 0))
  634. {
  635. sprintf(cgipath, "%s/%s/error",
  636. base, HTTPD_SCRIPT_ROOT);
  637. if (!stat(cgipath, &statbuf))
  638. {
  639. sprintf(cgipath, "/~%s/%s/error",
  640. userinfo->pw_name,
  641. HTTPD_SCRIPT_ROOT);
  642. goto EXECUTE;
  643. }
  644. }
  645. }
  646. if (search)
  647. *search = '/';
  648. }
  649. strcpy(base, calcpath(HTTPD_SCRIPT_ROOT_P));
  650. sprintf(cgipath, "%s/error", base);
  651. if (stat(cgipath, &statbuf))
  652. error(readable);
  653. else
  654. {
  655. sprintf(cgipath, "/%s/error", HTTPD_SCRIPT_ROOT);
  656. EXECUTE:
  657. setcurrenttime();
  658. fprintf(stderr, "[%s] httpd(pid %ld): %s [from: `%s' req: `%s' params: `%s' referer: `%s']n",
  659. currenttime, (long)getpid(), readable,
  660. remotehost[0] ? remotehost : "(none)",
  661. orig[0] ? orig : "(none)", env ? env : "(none)",
  662. referer[0] ? referer : "(none)");
  663. do_script(cgipath, headers);
  664. }
  665. }
  667. extern int
  668. readline DECL2(int, sd, char *, buf)
  669. {
  670. char ch, *buf2;
  672. buf2 = buf; *buf2 = 0;
  673. do
  674. {
  675. if (netbufind >= netbufsiz)
  676. {
  677. TRYAGAIN:
  678. netbufsiz = read(sd, netbuf,
  679. readlinemode ? MYBUFSIZ : 1);
  680. if (netbufsiz == -1)
  681. {
  682. if ((errno == EAGAIN) || (errno == EINTR))
  683. {
  684. mysleep(1); goto TRYAGAIN;
  685. }
  686. fprintf(stderr, "[%s] httpd: readline(): %sn",
  687. currenttime, strerror(errno));
  688. if (sd == 0)
  689. error("503 Unexpected network error");
  690. return(ERR_QUIT);
  691. }
  692. if (netbufsiz == 0)
  693. {
  694. if (*buf)
  695. {
  696. *buf2 = 0;
  697. return(ERR_NONE);
  698. }
  699. if (sd == 0)
  700. error("503 You closed the connection!");
  701. return(ERR_QUIT);
  702. }
  703. netbufind = 0;
  704. }
  705. ch = *(buf2++) = netbuf[netbufind++];
  706. } while ((ch != 'n') && (buf2 < (buf + MYBUFSIZ - 64)));
  707. *buf2 = 0;
  708. return(ERR_NONE);
  709. }
  711. static VOID
  712. process_request DECL0
  713. {
  714. char line[MYBUFSIZ], extra[MYBUFSIZ], *temp,
  715. *params, *url, *ver;
  716. int index, readerror;
  717. size_t size;
  719. strcpy(version, "HTTP/0.9");
  720. strcpy(dateformat, "%a %b %e %H:%M:%S %Y");
  721. total[0] = orig[0] = name[0] = referer[0] = line[0] =
  722. real_path[0] = browser[0] = 0;
  723. netbufsiz = netbufind = headonly = postonly = headers = index = 0;
  724. unsetenv("CONTENT_LENGTH"); unsetenv("AUTH_TYPE");
  725. unsetenv("CONTENT_TYPE"); unsetenv("DOCUMENT_ARGUMENTS");
  726. unsetenv("ERROR_CODE"); unsetenv("ERROR_READABLE");
  727. unsetenv("ERROR_URL"); unsetenv("ERROR_URL_ESCAPED");
  728. unsetenv("ERROR_URL_EXPANDED"); unsetenv("REMOTE_USER");
  729. unsetenv("REMOTE_PASSWORD"); unsetenv("HTTP_REFERER");
  730. unsetenv("HTTP_COOKIE");
  732. alarm(180); errno = 0;
  733. readerror = read(0, line, 1);
  734. if (readerror == 1)
  735. readerror = read(0, line + 1, 1);
  736. if (readerror == 1)
  737. readerror = read(0, line + 2, 1);
  738. if (readerror == 1)
  739. readerror = read(0, line + 3, 1);
  740. if (readerror != 1)
  741. {
  742. if (readerror == -1)
  743. fprintf(stderr, "[%s] Request line: read() failed: %sn",
  744. currenttime, strerror(errno));
  745. else
  746. fprintf(stderr, "[%s] Request line: read() got no inputn",
  747. currenttime);
  748. error("400 Unable to read begin of request line");
  749. return;
  750. }
  751. readlinemode = strncasecmp("POST", line, 4);
  752. if (readline(0, line + 4) == ERR_QUIT)
  753. {
  754. error("400 Unable to read request line");
  755. return;
  756. }
  757. size = strlen(line);
  758. bzero(line + size, 16);
  759. temp = orig + strlen(orig);
  760. while ((temp > orig) && (*(temp - 1) <= ' '))
  761. *(--temp) = 0;
  762. url = line;
  763. while (*url && (*url > ' '))
  764. url++;
  765. *(url++) = 0;
  766. while (*url <= ' ')
  767. url++;
  768. ver = url;
  769. while (*ver && (*ver > ' '))
  770. ver++;
  771. *(ver++) = 0;
  772. while (*ver <= ' ')
  773. ver++;
  774. temp = ver;
  775. while (*temp && (*temp > ' '))
  776. temp++;
  777. *temp = 0;
  778. if (!strncasecmp(ver, "HTTP/", 5))
  779. {
  780. headers = 1; strcpy(version, "HTTP/1.0");
  781. setenv("SERVER_PROTOCOL", version, 1);
  782. while (1)
  783. {
  784. char *param;
  786. if (readline(0, extra) == ERR_QUIT)
  787. {
  788. error("400 Unable to read HTTP headers");
  789. return;
  790. }
  791. if (extra[0] <= ' ')
  792. break;
  793. if (!(param = strchr(extra, ':')))
  794. continue;
  795. *(param++) = 0;
  796. while ((*param == ' ') || (*param == 9))
  797. param++;
  798. if (!strcasecmp("Content-length", extra))
  799. setenv("CONTENT_LENGTH", param, 1);
  800. else if (!strcasecmp("Content-type", extra))
  801. setenv("CONTENT_TYPE", param, 1);
  802. else if (!strcasecmp("User-agent", extra))
  803. {
  804. strncpy(browser, param, MYBUFSIZ - 1);
  805. browser[MYBUFSIZ - 1] = 0;
  806. setenv("USER_AGENT", browser, 1);
  807. setenv("HTTP_USER_AGENT", browser, 1);
  808. strtok(browser, "/");
  809. for (temp = browser; *temp; temp++)
  810. *temp = tolower(*temp);
  811. *browser = toupper(*browser);
  812. setenv("USER_AGENT_SHORT", browser, 1);
  813. } else if (!strcasecmp("Referer", extra))
  814. {
  815. strncpy(referer, param, MYBUFSIZ-16);
  816. while (referer[0] &&
  817. referer[strlen(referer) - 1] <= ' ')
  818. referer[strlen(referer) - 1] = 0;
  819. setenv("HTTP_REFERER", referer, 1);
  820. } else if (!strcasecmp("Authorization", extra))
  821. setenv("AUTH_TYPE", param, 1);
  822. else if (!strcasecmp("Cookie", extra))
  823. setenv("HTTP_COOKIE", param, 1);
  824. }
  825. } else
  826. setenv("SERVER_PROTOCOL", version, 1);
  828. if (!getenv("CONTENT_LENGTH"))
  829. setenv("CONTENT_LENGTH", "0", 1);
  830. if (!browser[0])
  831. {
  832. setenv("USER_AGENT", "UNKNOWN", 1);
  833. setenv("HTTP_USER_AGENT", "UNKNOWN", 1);
  834. setenv("USER_AGENT_SHORT", "UNKNOWN", 1);
  835. }
  837. alarm(0);
  838. params = url;
  839. if (decode(params))
  840. return;
  842. size = strlen(params);
  843. bzero(params + size, 16);
  844. bcopy(params, orig, size + 16);
  846. if (referer[0] &&
  847. (!thisdomain[0] || !strcasestr(referer, thisdomain)))
  848. fprintf(refer_log, "%s -> %sn", referer, params);
  850. if (params[0] != '/')
  851. {
  852. server_error("400 Relative URL's are not supported",
  853. "NO_RELATIVE_URLS");
  854. return;
  855. }
  857. setenv("REQUEST_METHOD", line, 1);
  858. if (!strcmp("GET", line))
  859. do_get(params);
  860. else if (!strcmp("HEAD", line))
  861. do_head(params);
  862. else if (!strcmp("POST", line))
  863. do_post(params);
  864. else
  865. server_error("400 Unknown method", "UNKNOWN_METHOD");
  866. }
  868. static VOID
  869. standalone_main DECL0
  870. {
  871. int csd = 0, clen, count, temp;
  872. struct sockaddr_in sa_server, sa_client;
  873. const struct hostent *remote;
  874. pid_t *childs, pid;
  875. struct rlimit limit;
  877. /* Speed hack */
  878. gethostbyname("localhost");
  880. detach(); open_logs(0);
  882. setprocname("xs(MAIN): Initializing deamons...");
  883. if ((sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1)
  884. err(1, "socket()");
  886. temp = 1;
  887. if ((setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &temp, sizeof(temp))) == -1)
  888. err(1, "setsockopt(REUSEADDR)");
  890. temp = 1;
  891. if ((setsockopt(sd, SOL_SOCKET, SO_KEEPALIVE, &temp, sizeof(temp))) == -1)
  892. err(1, "setsockopt(KEEPALIVE)");
  894. memset(&sa_server, 0, sizeof(sa_server));
  895. sa_server.sin_family = AF_INET;
  896. sa_server.sin_addr = thisaddress;
  897. sa_server.sin_port = htons(port);
  898. if (bind(sd, (struct sockaddr *)&sa_server, sizeof(sa_server)) == -1)
  899. err(1, "bind()");
  901. if (listen(sd, MAXLISTEN))
  902. err(1, "listen()");
  904. #ifdef RLIMIT_NPROC
  905. limit.rlim_max = limit.rlim_cur = RLIM_INFINITY;
  906. setrlimit(RLIMIT_NPROC, &limit);
  907. #endif /* RLIMIT_NPROC */
  908. #ifdef RLIMIT_CPU
  909. limit.rlim_max = limit.rlim_cur = RLIM_INFINITY;
  910. setrlimit(RLIMIT_CPU, &limit);
  911. #endif /* RLIMIT_CPU */
  913. set_signals(); reqs = 0;
  914. if (!(childs = (pid_t *)malloc(sizeof(pid_t) * number)))
  915. errx(1, "malloc() failed");
  917. for (count = 0; count < number; count++)
  918. {
  919. switch(pid = fork())
  920. {
  921. case -1:
  922. warn("fork() failed");
  923. killpg(0, SIGTERM);
  924. exit(1);
  925. case 0:
  926. mainhttpd = 0;
  927. goto CHILD;
  928. default:
  929. childs[count] = pid;
  930. }
  931. }
  933. fflush(stdout);
  934. while (1)
  935. {
  936. setprocname("xs(MAIN): Waiting for dead children");
  937. while (mysleep(30))
  938. /* NOTHING HERE */;
  939. setprocname("xs(MAIN): Searching for dead children");
  940. for (count = 0; count < number; count++)
  941. {
  942. if (kill(childs[count], 0))
  943. {
  944. fflush(stdout);
  945. switch(pid = fork())
  946. {
  947. case -1:
  948. fprintf(stderr,
  949. "[%s] httpd: fork() failed: %sn",
  950. currenttime, strerror(errno));
  951. break;
  952. case 0:
  953. mainhttpd = 0;
  954. goto CHILD;
  955. default:
  956. childs[count] = pid;
  957. }
  958. }
  959. }
  960. }
  962. CHILD:
  963. #ifndef SETVBUF_REVERSED
  964. setvbuf(stdout, outputbuffer, _IOFBF, SENDBUFSIZE);
  965. #else /* Not not SETVBUF_REVERSED */
  966. setvbuf(stdout, _IOFBF, outputbuffer, SENDBUFSIZE);
  967. #endif /* SETVBUF_REVERSED */
  968. while (1)
  969. {
  970. struct linger sl;
  972. setprocname("xs(%d): [Reqs: %06d] Setting up myself to accept a connection",
  973. count + 1, reqs);
  974. if (!origeuid && (seteuid(origeuid) == -1))
  975. err(1, "seteuid(%ld) failed", (long)origeuid);
  976. if (!origeuid && (setegid(origegid) == -1))
  977. err(1, "setegid(%ld) failed", (long)origegid);
  978. filedescrs(); clen = sizeof(sa_client);
  979. setprocname("xs(%d): [Reqs: %06d] Waiting for a connection...",
  980. count + 1, reqs);
  981. csd = accept(sd, (struct sockaddr *)&sa_client, &clen);
  982. if (csd < 0)
  983. {
  984. if (errno == EINTR)
  985. child_handler(SIGCHLD);
  986. continue;
  987. }
  988. setprocname("xs(%d): [Reqs: %06d] accept() gave me a connection...",
  989. count + 1, reqs);
  990. if (fcntl(csd, F_SETFL, 0))
  991. warn("fcntl() in standalone_main");
  993. sl.l_onoff = 1; sl.l_linger = 600;
  994. setsockopt(csd, SOL_SOCKET, SO_LINGER, &sl, sizeof(sl));
  995. #ifdef SO_SNDBUF
  996. temp = SENDBUFSIZE + 64;
  997. setsockopt(csd, SOL_SOCKET, SO_SNDBUF, &temp, sizeof(temp));
  998. #endif /* SO_SNDBUF */
  999. #ifdef SO_RCVBUF
  1000. temp = 512;
  1001. setsockopt(csd, SOL_SOCKET, SO_RCVBUF, &temp, sizeof(temp));
  1002. #endif /* SO_RCVBUF */
  1004. dup2(csd, 0); dup2(csd, 1); close(csd);
  1006. #ifndef SETVBUF_REVERSED
  1007. setvbuf(stdin, NULL, _IONBF, 0);
  1008. #else /* Not not SETVBUF_REVERSED */
  1009. setvbuf(stdin, _IONBF, NULL, 0);
  1010. #endif /* SETVBUF_REVERSED */
  1012. if ((remote = gethostbyaddr((char *)&sa_client.sin_addr,
  1013. sizeof(struct in_addr), sa_client.sin_family)))
  1014. {
  1015. strcpy(remotehost, remote->h_name);
  1016. setenv("REMOTE_HOST", remotehost, 1);
  1017. } else
  1018. {
  1019. strcpy(remotehost, inet_ntoa(sa_client.sin_addr));
  1020. unsetenv("REMOTE_HOST");
  1021. }
  1022. setenv("REMOTE_ADDR", inet_ntoa(sa_client.sin_addr), 1);
  1023. setprocname("xs(%d): Connect from `%s'", count + 1, remotehost);
  1024. setcurrenttime();
  1025. if (message503[0])
  1026. {
  1027. alarm(180);
  1028. printf("HTTP/1.0 503 BusyrnContent-type: text/plainrnrn");
  1029. printf("%sn", message503);
  1030. } else
  1031. process_request();
  1032. alarm(0); reqs++;
  1033. fflush(stdout); fflush(stdin); fflush(stderr);
  1034. }
  1035. /* NOTREACHED */
  1036. }
  1038. static VOID
  1039. setup_environment DECL0
  1040. {
  1041. char buffer[16];
  1043. setenv("SERVER_SOFTWARE", SERVER_IDENT, 1);
  1044. setenv("SERVER_NAME", thishostname, 1);
  1045. setenv("GATEWAY_INTERFACE", "CGI/1.1", 1);
  1046. sprintf(buffer, "%d", port);
  1047. setenv("SERVER_PORT", buffer, 1);
  1048. sprintf(buffer, "%d", localmode);
  1049. setenv("LOCALMODE", buffer, 1);
  1050. setenv("HTTPD_ROOT", rootdir, 1);
  1051. }
  1053. int
  1054. main DECL3(int, argc, char **, argv, char **, envp)
  1055. {
  1056. const struct passwd *userinfo;
  1057. const struct group *groupinfo;
  1058. int option, num;
  1059. const struct hostent *hp;
  1061. origeuid = geteuid(); origegid = getegid();
  1062. #ifdef HAVE_SETPRIORITY
  1063. if (setpriority(PRIO_PROCESS, (pid_t)0, PRIO_MAX))
  1064. warn("setpriority");
  1065. #endif /* HAVE_SETPRIORITY */
  1067. for (num = option = 0; option < argc; option++)
  1068. num += (1 + strlen(argv[option]));
  1069. if (!(startparams = (char *)malloc(num)))
  1070. errx(1, "Cannot malloc memory for startparams");
  1071. *startparams = 0;
  1072. for (option = 0; option < argc; option++)
  1073. {
  1074. strcat(startparams, argv[option]);
  1075. if (option < argc - 1)
  1076. strcat(startparams, " ");
  1077. }
  1079. port = 80; number = HTTPD_NUMBER; localmode = 1;
  1080. strcpy(rootdir, HTTPD_ROOT); message503[0] = 0;
  1081. #ifdef THISDOMAIN
  1082. strcpy(thisdomain, THISDOMAIN);
  1083. #else /* Not THISDOMAIN */
  1084. thisdomain[0] = 0;
  1085. #endif /* THISDOMAIN */
  1086. thisaddress.s_addr = htonl(INADDR_ANY);
  1087. if (gethostname(thishostname, MAXHOSTNAMELEN) == -1)
  1088. errx(1, "gethostname() failed");
  1089. if ((userinfo = getpwnam(HTTPD_USERID)))
  1090. user_id = userinfo->pw_uid;
  1091. else
  1092. user_id = 32767;
  1093. if ((groupinfo = getgrnam(HTTPD_GROUPID)))
  1094. group_id = groupinfo->gr_gid;
  1095. else
  1096. group_id = 32766;
  1097. if ((short)user_id == -1)
  1098. err(1, "Check your password file: nobody may not have UID -1 or 65535.");
  1099. if ((short)group_id == -1)
  1100. err(1, "Check your group file: nogroup may not have GID -1 or 65535.");
  1101. sprintf(access_path, "%s/access_log", calcpath(HTTPD_LOG_ROOT));
  1102. sprintf(error_path, "%s/error_log", calcpath(HTTPD_LOG_ROOT));
  1103. sprintf(refer_path, "%s/referer_log", calcpath(HTTPD_LOG_ROOT));
  1104. while ((option = getopt(argc, argv, "a:d:g:l:m:n:p:r:u:A:R:E:")) != EOF)
  1105. {
  1106. switch(option)
  1107. {
  1108. case 'n':
  1109. if ((number = atoi(optarg)) <= 0)
  1110. errx(1, "Invalid number of processes");
  1111. break;
  1112. case 'p':
  1113. if ((port = atoi(optarg)) <= 0)
  1114. errx(1, "Invalid port number");
  1115. break;
  1116. case 'u':
  1117. if ((user_id = atoi(optarg)) > 0)
  1118. break;
  1119. if (!(userinfo = getpwnam(optarg)))
  1120. errx(1, "Invalid user ID");
  1121. user_id = userinfo->pw_uid;
  1122. break;
  1123. case 'g':
  1124. if ((group_id = atoi(optarg)) > 0)
  1125. break;
  1126. if (!(groupinfo = getgrnam(optarg)))
  1127. errx(1, "Invalid group ID");
  1128. group_id = groupinfo->gr_gid;
  1129. break;
  1130. case 'd':
  1131. if (*optarg != '/')
  1132. errx(1, "The -d directory must start with a /");
  1133. strncpy(rootdir, optarg, XS_PATH_MAX-1);
  1134. rootdir[XS_PATH_MAX-1] = 0;
  1135. break;
  1136. case 'a':
  1137. if ((thisaddress.s_addr = inet_addr(optarg)) == -1)
  1138. {
  1139. if ((hp = gethostbyname(optarg)))
  1140. memcpy((char *)&thisaddress,
  1141. hp->h_addr, hp->h_length);
  1142. else
  1143. errx(1, "gethostbyname(`%s') failed",
  1144. optarg);
  1145. }
  1146. strcpy(thishostname, optarg);
  1147. break;
  1148. case 'r':
  1149. strcpy(thisdomain, optarg);
  1150. break;
  1151. case 'l':
  1152. if ((localmode = atoi(optarg)) <= 0)
  1153. errx(1, "Argument to -l is invalid");
  1154. break;
  1155. case 'm':
  1156. strcpy(message503, optarg);
  1157. break;
  1158. case 'A':
  1159. strcpy(access_path, optarg);
  1160. break;
  1161. case 'R':
  1162. strcpy(refer_path, optarg);
  1163. break;
  1164. case 'E':
  1165. strcpy(error_path, optarg);
  1166. break;
  1167. default:
  1168. errx(1, "Usage: httpd [-u username] [-g group] [-p port] [-n number] [-d rootdir]n[-r refer-ignore-domain] [-l localmode] [-a address] [-m service-message]n[-A access-log-path] [-E error-log-path] [-R referer-log-path]");
  1169. }
  1170. }
  1171. initsetprocname(argc, argv, envp);
  1172. setup_environment();
  1173.         standalone_main();
  1174. exit(0);
  1175. }