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

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

Web服务器

开发平台：

Unix_Linux

methods.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. /* Global structures */
  91. typedef struct ftypes
  92. {
  93. struct ftypes *next;
  94. char name[32], ext[16];
  95. } ftypes;
  97. #ifdef HANDLE_COMPRESSED
  98. typedef struct ctypes
  99. {
  100. struct ctypes *next;
  101. char prog[XS_PATH_MAX], ext[16];
  102. } ctypes;
  103. #endif /* HANDLE_COMPRESSED */
  105. static ftypes *ftype = NULL;
  106. #ifdef HANDLE_COMPRESSED
  107. static ctypes *ctype = NULL;
  108. #endif /* HANDLE_COMPRESSED */
  110. extern VOID
  111. senduncompressed DECL1(int, fd)
  112. {
  113. #ifdef WANT_SSI
  114. int errval, html;
  115. #endif /* WANT_SSI */
  116. #ifndef HAVE_MMAP
  117. size_t readtotal, writetotal;
  118. #endif /* HAVE_MMAP */
  119. size_t size, written;
  120. char modified[32];
  122. alarm(180);
  123. if ((size = lseek(fd, 0, SEEK_END)) == -1)
  124. {
  125. error("500 Cannot lseek() to end of file");
  126. return;
  127. }
  128. if (lseek(fd, 0, SEEK_SET))
  129. {
  130. error("500 Cannot lseek() to beginning of file");
  131. return;
  132. }
  133. if (headers)
  134. {
  135. printf("%s 200 OKrn", version);
  136. stdheaders(0, 0, 0);
  138. #ifndef WANT_SSI
  139. getfiletype(1);
  140. printf("Content-length: %ldrn", (long)size);
  141. #else /* Not WANT_SSI */
  142. html = getfiletype(1);
  143. if (!html)
  144. printf("Content-length: %ldrn", (long)size);
  145. #endif /* WANT_SSI */
  146. strftime(modified, sizeof(modified),
  147. "%a, %d %b %Y %T GMT", gmtime(&modtime));
  148. printf("Last-modified: %srnrn", modified);
  149. }
  150. #ifdef WANT_SSI
  151. else
  152. {
  153. html = getfiletype(0);
  154. if (html)
  155. printf("rn");
  156. }
  157. #endif /* WANT_SSI */
  159. if (headonly)
  160. goto DONE;
  162. UNPARSED:
  163. #ifdef WANT_SSI
  164. if (!html)
  165. #endif /* WANT_SSI */
  166. #ifdef HAVE_MMAP
  167. {
  168. char *buffer;
  170. if ((buffer = (char *)mmap((caddr_t)0, size, PROT_READ,
  171. MAP_SHARED, fd, 0)) == (char *)-1)
  172. {
  173. fprintf(stderr, "[%s] httpd: mmap() failed: %sn",
  174. currenttime, strerror(errno));
  175. exit(1);
  176. }
  177. alarm((size / MINBYTESPERSEC) + 20);
  178. fflush(stdout);
  179. if ((written = write(fileno(stdout), buffer, size)) != size)
  180. {
  181. if (written != -1)
  182. fprintf(stderr, "[%s] httpd: Aborted for `%s' (%ld of %ld bytes sent)n",
  183. currenttime,
  184. remotehost[0] ? remotehost : "(none)",
  185. (long)written, (long)size);
  186. else
  187. fprintf(stderr, "[%s] httpd: Aborted for `%s'n",
  188. currenttime,
  189. remotehost[0] ? remotehost : "(none)");
  190. }
  191. munmap(buffer, size); size = written;
  192. alarm(0);
  193. }
  194. #else /* Not HAVE_MMAP */
  195. {
  196. char buffer[SENDBUFSIZE];
  198. writetotal = 0;
  199. alarm((size / MINBYTESPERSEC) + 20);
  200. fflush(stdout);
  201. while ((readtotal = read(fd, buffer, SENDBUFSIZE)) > 0)
  202. {
  203. if ((written = write(fileno(stdout), buffer,
  204. readtotal)) != readtotal)
  205. {
  206. fprintf(stderr,
  207. "[%s] httpd: Aborted for `%s' (No mmap) (%ld of %ld bytes sent)n",
  208. currenttime,
  209. remotehost[0] ? remotehost : "(none)",
  210. writetotal + written, size);
  211. size = writetotal;
  212. alarm(0); goto DONE;
  213. }
  214. writetotal += written;
  215. }
  216. size = writetotal;
  217. alarm(0);
  218. }
  219. #endif /* HAVE_MMAP */
  220. #ifdef WANT_SSI
  221. else
  222. {
  223. size = 0;
  224. alarm((size / MINBYTESPERSEC) + 60);
  225. errval = sendwithdirectives(fd, &size);
  226. close(fd);
  227. switch(errval)
  228. {
  229. case ERR_QUIT:
  230. fprintf(stderr, "[%s] httpd: Aborted for `%s' (ERR_QUIT)n",
  231. currenttime,
  232. remotehost[0] ? remotehost : "(none)");
  233. break;
  234. case ERR_CONT:
  235. html = 0; goto UNPARSED;
  236. default:
  237. break;
  238. }
  239. }
  240. #endif /* WANT_SSI */
  242. DONE:
  243. {
  244. char buffer[80];
  245. time_t theclock;
  247. time(&theclock);
  248. strftime(buffer, 80, "%d/%b/%Y:%H:%M:%S", localtime(&theclock));
  249. fprintf(access_log, "%s - - [%s +0000] "%s %s %s" 200 %ldn",
  250. remotehost, buffer, headonly ? "HEAD" : "GET", real_path,
  251. version, size > 0 ? (long)size : (long)0);
  252. }
  253. close(fd);
  254. }
  256. #ifdef HANDLE_COMPRESSED
  257. extern VOID
  258. sendcompressed DECL2_C(int, fd, char *, method)
  259. {
  260. pid_t pid;
  261. int count, processed;
  262. char *tmp;
  264. #ifdef HAVE_TEMPNAM
  265. if (!(tmp = tempnam(TEMPORARYPATH, "xs-www")))
  266. #endif /* HAVE_TEMPNAM */
  267. {
  268. if (!(tmp = (char *)malloc(32 + strlen(TEMPORARYPATH))))
  269. {
  270. error("500 Out of memory in sendcompressed()");
  271. close(fd); return;
  272. }
  273. sprintf(tmp, "%s/.xs-www.%016ld",
  274. TEMPORARYPATH, (long)getpid());
  275. }
  276. remove(tmp);
  277. if ((processed = open(tmp, O_CREAT | O_TRUNC | O_RDWR | O_EXCL,
  278. S_IWUSR | S_IRUSR )) < 0)
  279. {
  280. fprintf(stderr, "[%s] httpd: Cannot open(`%s'): %sn",
  281. currenttime, tmp, strerror(errno));
  282. error("500 Unable to open temporary file");
  283. exit(1);
  284. }
  285. remove(tmp); free(tmp); fflush(stdout);
  286. switch(pid = fork())
  287. {
  288. case -1:
  289. fprintf(stderr, "[%s] httpd: Cannot fork(): %sn",
  290. currenttime, strerror(errno));
  291. error("500 Cannot fork() in sendcompressed()");
  292. close(fd); close(processed); return;
  293. case 0:
  294. #ifdef HAVE_SETSID
  295. if (setsid() == -1)
  296. {
  297. error("500 setsid() failed");
  298. exit(1);
  299. }
  300. #else /* Not HAVE_SETSID */
  301. if (setpgrp(getpid(), 0)) == -1)
  302. {
  303. error("500 setpgrp() failed");
  304. exit(1);
  305. }
  306. #endif /* HAVE_SETSID */
  307. dup2(fd, 0); dup2(processed, 1);
  308. for (count = 3; count < 64; count++)
  309. close(count);
  310. execl(method, method, NULL);
  311. fprintf(stderr, "[%s] httpd: Cannot execl(`%s'): %sn",
  312. currenttime, method, strerror(errno));
  313. error("500 Cannot start conversion program");
  314. exit(1);
  315. default:
  316. close(fd);
  317. if (!kill(pid, 0) && mysleep(180))
  318. {
  319. close(processed);
  320. killpg(pid, SIGTERM);
  321. mysleep(3);
  322. killpg(pid, SIGKILL);
  323. error("500 Conversion program timed out");
  324. return;
  325. }
  326. if (!kill(pid, 0))
  327. {
  328. close(processed);
  329. killpg(pid, SIGKILL);
  330. error("500 Interrupted during conversion");
  331. return;
  332. }
  333. }
  334. senduncompressed(processed);
  335. }
  336. #endif /* HANDLE_COMPRESSED */
  338. extern VOID
  339. do_get DECL1(char *, params)
  340. {
  341. char *temp, auth[XS_PATH_MAX], base[XS_PATH_MAX];
  342. const char *file, *question;
  343. int fd, wasdir;
  344. size_t size;
  345. struct stat statbuf;
  346. const struct passwd *userinfo;
  347. FILE *authfile;
  348. #ifdef HANDLE_COMPRESSED
  349. const ctypes *search = NULL;
  350. #endif /* HANDLE_COMPRESSED */
  352. alarm(240);
  353. question = strchr(params, '?');
  354. while ((temp = strstr(params, "//")))
  355. {
  356. if (!question || (temp < question))
  357. bcopy(temp + 1, temp, strlen(temp));
  358. else
  359. break;
  360. }
  361. strcpy(real_path, params);
  362. bzero(params + strlen(params), 16);
  363. setprocname("xs: Handling `%s' from `%s'", real_path, remotehost);
  364. userinfo = NULL;
  366. if (params[1] == '~')
  367. {
  368. if ((temp = strchr(params + 2, '/')))
  369. *temp = 0;
  370. if (!(userinfo = getpwnam(params + 2)))
  371. {
  372. server_error("404 User is unknown", "USER_UNKNOWN");
  373. return;
  374. }
  375. if (transform_user_dir(base, userinfo, 1))
  376. return;
  377. if (!origeuid)
  378. {
  379. setegid(userinfo->pw_gid);
  380. setgroups(1, (gid_t *)&userinfo->pw_gid);
  381. seteuid(userinfo->pw_uid);
  382. }
  383. if (!geteuid())
  384. {
  385. error("500 Effective UID is not valid");
  386. return;
  387. }
  388. if (temp)
  389. {
  390. *temp = '/';
  391. file = temp;
  392. } else
  393. file = params + strlen(params);
  394. } else
  395. {
  396. file = params;
  397. strcpy(base, calcpath(HTTPD_DOCUMENT_ROOT));
  398. strcat(base, "/");
  399. if (!origeuid)
  400. {
  401. setegid(group_id);
  402. setgroups(1, &group_id);
  403. seteuid(user_id);
  404. }
  405. if (!geteuid())
  406. {
  407. error("500 Effective UID is not valid");
  408. return;
  409. }
  410. }
  412. size = strlen(HTTPD_SCRIPT_ROOT);
  413. if (*file && (!strncmp(file + 1, HTTPD_SCRIPT_ROOT, size)) &&
  414. (file[size + 1] == '/'))
  415. {
  416. do_script(params, 1);
  417. return;
  418. }
  420. if (postonly)
  421. {
  422. server_error("403 Cannot use POST method on non-CGI",
  423. "POST_ON_NON_CGI");
  424. return;
  425. }
  427. if ((temp = strchr(file, '?')))
  428. {
  429. *temp = 0;
  430. setenv("DOCUMENT_ARGUMENTS", temp + 1, 1);
  431. if ((temp = strchr(real_path, '?')))
  432. *temp = 0;
  433. }
  435. if (*file)
  436. wasdir = (file[strlen(file) - 1] == '/');
  437. else
  438. wasdir = 0;
  439. if (strstr(file, "..") || strstr(file, "/.x"))
  440. {
  441. server_error("403 Invalid path specified", "INVALID_PATH");
  442. return;
  443. }
  445. /* if (*file == '/')
  446. file++; */
  447. if ((temp = strrchr(file, '/')))
  448. {
  449. *temp = 0;
  450. size = strlen(base);
  451. ((char *)file)[XS_PATH_MAX - (temp - file + 1 + size)] = 0;
  452. strcpy(base + size, file);
  453. strcat(base + size, "/");
  454. file = temp + 1;
  455. }
  457. if ((!*file) && (wasdir))
  458. strcat(real_path, file = INDEX_HTML);
  460. RETRY:
  461. sprintf(total, "%s/.xsuid", base);
  462. if (!stat(total, &statbuf))
  463. {
  464. if (!origeuid)
  465. {
  466. seteuid(origeuid);
  467. setegid(group_id);
  468. setgroups(1, &group_id);
  469. seteuid(user_id);
  470. }
  471. if (!geteuid())
  472. {
  473. error("500 Effective UID is not valid");
  474. return;
  475. }
  476. }
  477. sprintf(total, "%s%s.redir", base, file);
  478. if ((fd = open(total, O_RDONLY, 0)) >= 0)
  479. {
  480. if ((size = read(fd, total, MYBUFSIZ)) <= 0)
  481. {
  482. error("500 Redirection file error");
  483. close(fd); return;
  484. }
  485. total[size] = 0;
  486. strtok(total, "rn"); redirect(total, 0);
  487. close(fd); return;
  488. }
  489. sprintf(total, "%s/.redir", base);
  490. if ((fd = open(total, O_RDONLY, 0)) >= 0)
  491. {
  492. if ((size = read(fd, total, XS_PATH_MAX - strlen(file) - 16)) <= 0)
  493. {
  494. error("500 Directory redirection file error");
  495. close(fd); return;
  496. }
  497. close(fd);
  498. temp = total + size; *temp = 0;
  499. while ((temp > total) && (*(temp - 1) < ' '))
  500. *(--temp) = 0;
  501. strcat(total, file);
  502. strtok(total, "rn"); redirect(total, 0);
  503. return;
  504. }
  505. sprintf(total, "%s/.noxs", base);
  506. if (!stat(total, &statbuf))
  507. {
  508. server_error("403 Directory is not available", "DIR_NOT_AVAIL");
  509. return;
  510. }
  512. #ifdef HANDLE_COMPRESSED
  513. search = NULL;
  514. #endif /* HANDLE_COMPRESSED */
  515. sprintf(total, "%s%s", base, file);
  516. if (stat(total, &statbuf))
  517. #ifdef HANDLE_COMPRESSED
  518. {
  519. search = ctype;
  520. temp = total + strlen(total);
  521. while (search)
  522. {
  523. strcpy(temp, search->ext);
  524. if (!stat(total, &statbuf))
  525. break;
  526. search = search->next;
  527. }
  528. if (!search)
  529. goto NOTFOUND;
  530. }
  531. #else /* Not HANDLE_COMPRESSED */
  532. goto NOTFOUND;
  533. #endif /* HANDLE_COMPRESSED */
  535. if (!S_ISREG(statbuf.st_mode))
  536. {
  537. if (!S_ISDIR(statbuf.st_mode))
  538. {
  539. server_error("403 Not a regular file", "NOT_REGULAR");
  540. return;
  541. }
  542. if (!strcmp(file, INDEX_HTML) || !strcmp(file, INDEX_HTML_2))
  543. {
  544. error("403 The index may not be a directory");
  545. return;
  546. }
  547. if (wasdir)
  548. {
  549. wasdir = 0;
  550. strcat(real_path, file = INDEX_HTML);
  551. goto RETRY;
  552. } else
  553. {
  554. if (port != 80)
  555. sprintf(total, "http://%s:%d%s/",
  556. thishostname, port, orig);
  557. else
  558. sprintf(total, "http://%s%s/",
  559. thishostname, orig);
  560. redirect(total, 1);
  561. return;
  562. }
  563. }
  565. sprintf(auth, "%s/%s", base, AUTHFILE);
  566. if ((authfile = fopen(auth, "r")))
  567. {
  568. if (check_auth(authfile))
  569. return;
  570. }
  572. modtime = statbuf.st_mtime;
  573. if ((fd = open(total, O_RDONLY, 0)) < 0)
  574. {
  575. server_error("403 File permissions deny access", "PERMISSION");
  576. return;
  577. }
  578. strcpy(name, file);
  580. #ifdef HANDLE_COMPRESSED
  581. if (search)
  582. sendcompressed(fd, search->prog);
  583. else
  584. #endif /* HANDLE_COMPRESSED */
  585. senduncompressed(fd);
  586. return;
  588. NOTFOUND:
  589. if (!strcmp(file, INDEX_HTML) && strcmp(INDEX_HTML, INDEX_HTML_2))
  590. {
  591. strcpy(real_path + strlen(real_path) - strlen(INDEX_HTML),
  592. file = INDEX_HTML_2);
  593. wasdir = 0;
  594. goto RETRY;
  595. }
  596. server_error("404 Requested URL not found", "NOT_FOUND");
  597. }
  599. extern VOID
  600. do_post DECL1(char *, params)
  601. {
  602. postonly = 1;
  603. do_get(params);
  604. }
  606. extern VOID
  607. do_head DECL1(char *, params)
  608. {
  609. headonly = 1;
  610. do_get(params);
  611. }
  613. extern VOID
  614. loadfiletypes DECL0
  615. {
  616. char line[MYBUFSIZ], *end, *comment;
  617. const char *mimepath;
  618. FILE *mime;
  619. ftypes *prev, *new;
  621. while (ftype)
  622. {
  623. new = ftype->next;
  624. free(ftype); ftype = new;
  625. }
  626. mimepath = calcpath(MIMETYPESFILE);
  627. if (!(mime = fopen(mimepath, "r")))
  628. err(1, "fopen(`%s' [read])", mimepath);
  629. prev = NULL;
  630. while (fgets(line, MYBUFSIZ, mime))
  631. {
  632. if ((comment = strchr(line, '#')))
  633. *comment = 0;
  634. end = line + strlen(line);
  635. while ((end > line) && (*(end - 1) <= ' '))
  636. *(--end) = 0;
  637. if (end == line)
  638. continue;
  639. if (!(new = (ftypes *)malloc(sizeof(ftypes))))
  640. errx(1, "Out of memory in loadfiletypes()");
  641. if (prev)
  642. prev->next = new;
  643. else
  644. ftype = new;
  645. prev = new; new->next = NULL;
  646. if (sscanf(line, "%s %s", new->name, new->ext) != 2)
  647. errx(1, "Unable to parse line `%s' in `%s'",
  648. line, mimepath);
  649. }
  650. fclose(mime);
  651. }
  653. #ifdef HANDLE_COMPRESSED
  654. extern VOID
  655. loadcompresstypes DECL0
  656. {
  657. char line[MYBUFSIZ], *end, *comment;
  658. const char *path;
  659. FILE *methods;
  660. ctypes *prev, *new;
  662. while (ctype)
  663. {
  664. new = ctype->next;
  665. free(ctype); ctype = new;
  666. }
  667. path = calcpath(COMPRESS_METHODS);
  668. if (!(methods = fopen(path, "r")))
  669. err(1, "fopen(`%s' [read])", path);
  670. prev = NULL;
  671. while (fgets(line, MYBUFSIZ, methods))
  672. {
  673. if ((comment = strchr(line, '#')))
  674. *comment = 0;
  675. end = line + strlen(line);
  676. while ((end > line) && (*(end - 1) <= ' '))
  677. *(--end) = 0;
  678. if (line == end)
  679. continue;
  680. if (!(new = (ctypes *)malloc(sizeof(ctypes))))
  681. errx(1, "Out of memory in loadcompresstypes()");
  682. if (prev)
  683. prev->next = new;
  684. else
  685. ctype = new;
  686. prev = new; new->next = NULL;
  687. if (sscanf(line, "%s %s", new->prog, new->ext) != 2)
  688. errx(1, "Unable to parse `%s' in `%s'", line, path);
  689. }
  690. fclose(methods);
  691. }
  692. #endif /* HANDLE_COMPRESSED */
  694. extern int
  695. getfiletype DECL1(int, print)
  696. {
  697. const ftypes *search;
  698. const char *ext;
  699. char extension[20];
  700. int count;
  702. if (!(ext = strrchr(name, '.')) || !(*(++ext)))
  703. {
  704. if (print)
  705. printf("Content-type: text/plainrn");
  706. return(0);
  707. }
  708. for (count = 0; ext[count] && (count < 16); count++)
  709. extension[count] = tolower(ext[count]);
  710. extension[count] = 0;
  711. search = ftype;
  712. while (search)
  713. {
  714. if (!strcmp(extension, search->ext))
  715. {
  716. if (print)
  717. printf("Content-type: %srn", search->name);
  718. return(!strcmp(search->name, "text/html"));
  719. }
  720. search = search->next;
  721. }
  722. if (print)
  723. printf("Content-type: application/octet-streamrn");
  724. return(0);
  725. }