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

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

Web服务器

开发平台：

Unix_Linux

mbox.c.neu：源码内容
  1. /*
  2. ** mbox.c
  3. **
  4. ** Copyright (c) 1994-1995 Peter Eriksson <pen@signum.se>
  5. **    Mats 謍rman    <matoh@lysator.liu.se>
  6. **
  7. ** This program is free software; you can redistribute it and/or modify
  8. ** it under the terms of the GNU General Public License as published by
  9. ** the Free Software Foundation; either version 2 of the License, or
  10. ** (at your option) any later version.
  11. **
  12. ** This program is distributed in the hope that it will be useful,
  13. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. ** GNU General Public License for more details.
  16. ** You should have received a copy of the GNU General Public License
  17. ** along with this program; if not, write to the Free Software
  18. ** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19. */
  21. #include <stdio.h>
  22. #include <time.h>
  23. #include <string.h>
  24. #include <fcntl.h>
  25. #include <unistd.h>
  26. #include <errno.h>
  27. #include <sys/types.h>
  28. #include <sys/stat.h>
  29. #include <sys/mman.h>
  31. #include "phttpd.h"
  33. #ifndef MAP_FAILED
  34. #define MAP_FAILED ((caddr_t) -1)
  35. #endif
  37. #ifndef MAP_NORESERVE
  38. #define MAP_NORESERVE 0
  39. #endif
  41. #define SF_ARCHIVE
  43. #define MAX_HDR_LINES 96
  45. #define SEP "From "
  46. #define SEPLEN 5 /* = strlen(SEP) */
  48. typedef struct {
  49.   char *subj;
  50.   char *from;
  51.   char *orgz;
  52.   char *date;
  53.   char *id;
  54. } header_info;
  56. static char *index_top_include = NULL;
  57. static char *index_bottom_include = NULL;
  58. static char *mail_top_include = NULL;
  59. static char *mail_bottom_include = NULL;
  61. static struct options mbox_cfg_table[] =
  62. {
  63.     { "index-top-include", T_STRING, &index_top_include, NULL },
  64.     { "index-bottom-include", T_STRING, &index_bottom_include, NULL },
  65.     { "mail-top-include", T_STRING, &mail_top_include, NULL },
  66.     { "mail-bottom-include", T_STRING, &mail_bottom_include, NULL },
  67.     { NULL,                -1,       NULL,                      NULL }
  68. };
  71. int pm_init(const char **argv)
  72. {
  73.     char *cfg_path, *cp;
  74.     const char *name = argv[0];
  75.     int cfgsize;
  77.     
  78.     if (debug > 1)
  79. fprintf(stderr, "*** mbox/pm_init("%s") called ***n", name);
  81. /* 
  82.     cfgsize = strlen(name)+6;
  83.     cfg_path = s_malloc(cfgsize);
  84.     s_strcpy(cfg_path, cfgsize, name);
  85.  
  86.     cp = strrchr(cfg_path, '.');
  87.     if (cp && strcmp(cp, ".so") == 0)
  88.         *cp = '';
  89.  
  90.     s_strcat(cfg_path, cfgsize, ".conf");
  91.     if (config_parse_file(cfg_path, file_cfg_table, 0) < 0)
  92.         return -1;
  93.  
  94.     if (config_parse_argv(argv+1, file_cfg_table) < 0)
  95.         return -1;
  96.  
  97.     if (default_type == NULL)
  98.         default_type = s_strdup("unknown");
  99. */ 
  100.     return 0;
  101. }
  103. void pm_exit(void)
  104. {
  105.     if (debug > 1)
  106. fprintf(stderr, "*** mbox/pm_exit() called ***n");
  107. }
  109. static int all_digits(char *ptr)
  110. {
  111.   for ( ; *ptr != ''; ptr++)
  112.     if (!s_isdigit(*ptr))
  113.       return 0;
  115.   return -1;
  116. }
  118. static void fd_print_msgid_anchor(int fd_out, char *id)
  119. {
  120.   char *begin;
  121.   char *end;
  122.   int len;
  124.   if ((begin = strchr(id, '<')) == NULL)
  125.     begin = id;
  126.   else 
  127.     begin++;
  129.   if ((end = strrchr(begin, '>')) != NULL)
  130.     len = end - begin;
  131.   else
  132.     len = strlen(begin);
  133.   
  134.   fd_puts("<a name="", fd_out);
  135.   fd_write( fd_out, begin, len);
  136.   fd_puts("">n", fd_out);
  137. }
  139. static void fd_print_msgid_link(int fd_out, char *url, char *id)
  140. {
  141.   char *begin;
  142.   char *end;
  143.   int len;
  145.   if ((begin = strchr(id, '<')) == NULL)
  146.     begin = id;
  147.   else 
  148.     begin++;
  150.   if ((end = strrchr(begin, '>')) != NULL)
  151.     len = end - begin;
  152.   else
  153.     len = strlen(begin);
  154.   
  155.   fd_printf(fd_out, "<a href="%s#", url);
  156.   fd_write( fd_out, begin, len);
  157.   fd_puts("">n", fd_out);
  158. }
  160. static int fd_escape_write(int fd_out, char *start, off_t len)
  161. {
  162.   char *begin;
  163.   char *ptr;
  164.   char *end;
  165.   off_t chunklen;
  166.   int retval;
  168.   begin = start;
  169.   end   = start + len;
  171.   for (ptr = start; ptr < end; ptr++) {
  172.     switch (*ptr) {
  173.     case '&':
  174.       if ((chunklen = ptr - begin) > 0)
  175. if ((retval = fd_write(fd_out, begin, chunklen)) != 0)
  176.   return retval;
  177.       begin = ptr + 1;
  178.       fd_puts("&amp;", fd_out);
  179.       break;
  180.     case '<':
  181.       if ((chunklen = ptr - begin) > 0)
  182. if ((retval = fd_write(fd_out, begin, chunklen)) != 0)
  183.   return retval;
  184.       begin = ptr + 1;
  185.       fd_puts("&lt;", fd_out);
  186.       break;
  187.     case '>':
  188.       if ((chunklen = ptr - begin) > 0)
  189. if ((retval = fd_write(fd_out, begin, chunklen)) != 0)
  190.   return retval;
  191.       begin = ptr + 1;
  192.       fd_puts("&gt;", fd_out);
  193.       break;
  194.     }
  195.   }
  196.   if ((chunklen = ptr - begin) > 0)
  197.     if ((retval = fd_write(fd_out, begin, chunklen)) != 0)
  198.       return retval;
  200.   return 0;
  201. }
  203. static int fd_escape_puts(char *str, int fd_out)
  204. {
  205.   off_t len;
  207.   len = strlen(str);
  208.   return fd_escape_write(fd_out, str, len);
  209. }
  211. static int do_file_copy(char *fname, int fd_out)
  212. {
  213.     int fd;
  214.     fd=s_open(fname,O_RDONLY);
  215. /* RK add filecopy to out here...     */
  216.     s_close(fd);
  218. }
  220. static int letter_head_len(char *start, char *limit)
  221. {
  222.   char *ptr;
  224.   for (ptr = start; ptr < limit; ptr++) {
  225.     if (*ptr != 'n')
  226.       continue;
  228.     ptr++;
  230.     if (ptr >= limit || *ptr == 'n')
  231.       break;
  232.   }
  234.   return ptr - start;
  235. }
  237. static char* malloc_letter_head(char *start,   int len, 
  238. char *lines[], int maxlines)
  239. {
  240.   char *mem;
  241.   int i;
  242.   int nlines;
  244.   if (len <= 0 ||
  245.       (mem = s_malloc(len)) == NULL)
  246.     return NULL;
  247.   
  248.   memcpy(mem, start, len);
  250.   nlines = 0;
  251.   if (nlines < maxlines) 
  252.     lines[nlines++] = mem;
  253.     
  254.   for (i = 0; i < len; i++) {
  255.     if (mem[i] != 'n')
  256.       continue;
  258.     if (i+1 < len && s_isspace(mem[i+1]))
  259.       continue;
  261.     mem[i] = '';
  262.     
  263.     if (nlines < maxlines && i+1 < len) 
  264.       lines[nlines++] = mem + i + 1;
  266.   }
  268.   if (nlines < maxlines) 
  269.     lines[nlines++] = NULL;
  270.   else
  271.     lines[maxlines - 1] = NULL;
  273.   return mem;
  274. }
  276. static char* find_header_val(char *key, char *lines[])
  277. {
  278.   int i;
  279.   int keylen;
  280.   char *ptr;
  282.   keylen=strlen(key);
  283.   for (i = 0; lines[i] != NULL; i++) {
  284.     ptr = lines[i];
  285.     if (strncasecmp(key, ptr, keylen) == 0 &&
  286. ptr[keylen] == ':') {
  287.       ptr += keylen + 1;
  288.       while (s_isspace(*ptr))
  289. ptr++;
  290.       return ptr;
  291.     }
  292.   }
  294.   return NULL;
  295. }
  297. static void set_header_info(header_info *hinf, char *lines[])
  298. {
  299.   hinf->subj = find_header_val("subject", lines);
  300.   hinf->from = find_header_val("from", lines);
  301.   hinf->orgz = find_header_val("organization", lines);
  302.   hinf->date = find_header_val("date", lines);
  303.   hinf->id   = find_header_val("message-id", lines);
  304. }
  306. static void fd_print_subject(int fd_out, char *subj, char *id)
  307. {
  308.   if (id) 
  309.     fd_print_msgid_anchor(fd_out, id);
  311.   if (subj) {
  312.     fd_puts("<strong><font size=+1>", fd_out);
  313.     fd_escape_puts(subj, fd_out);
  314.     fd_puts("</font></strong>n", fd_out);
  315.   }
  317.   if (id)
  318.     fd_puts("</a>n", fd_out);
  319. }
  321. static char *do_letter_head(char *start, char *limit, int fd_out)
  322. {
  323.   char *mem;
  324.   int len;
  325.   char *lines[MAX_HDR_LINES];
  326.   header_info hinf;
  328.   fd_puts("<!-- head -->n", fd_out);
  330.   if (start >= limit || start == NULL) 
  331.     return NULL;
  333.   if ((len = letter_head_len(start, limit)) <= 0 ||
  334.       (mem = malloc_letter_head(start, len, lines, MAX_HDR_LINES)) == NULL)
  335.     return NULL;
  336.  
  337.   set_header_info(&hinf, lines);
  339.   fd_puts("<dt>n", fd_out);
  341.   fd_print_subject(fd_out, hinf.subj, hinf.id);
  342.   fd_puts("<br>", fd_out);
  344.   html_email(fd_out, hinf.from);
  345.   fd_puts("<br>", fd_out);
  347.   if (hinf.orgz) {
  348.     fd_escape_puts(hinf.orgz, fd_out);
  349.     fd_puts("<br>", fd_out);
  350.   }
  352.   if (hinf.date) {
  353.     fd_escape_puts(hinf.date, fd_out);
  354.     fd_puts("<br>", fd_out);
  355.   }
  357.   s_free(mem);
  358.   return start + len;
  359. }
  361. static char *do_index_entry(char *start, char *limit, 
  362.     int fd_out, int num, char *url)
  363. {
  364.   char *mem;
  365.   int len;
  366.   char *lines[MAX_HDR_LINES];
  367.   header_info hinf;
  369.   fd_puts("<!-- index entry -->n", fd_out);
  371.   if (start >= limit || start == NULL) 
  372.     return NULL;
  374.   if ((len = letter_head_len(start, limit)) <= 0 ||
  375.       (mem = malloc_letter_head(start, len, lines, MAX_HDR_LINES)) == NULL)
  376.     return NULL;
  377.   
  378.   set_header_info(&hinf, lines);
  380.   fd_puts("<dt>n", fd_out);
  381.   fd_printf(fd_out, "<a href="%s?%d">n", url, num);
  382.   fd_printf(fd_out, "<strong><font size=+1>%d</font></strong>", num);
  383.   fd_puts("</a>n", fd_out);
  384.   fd_puts("<dd>n", fd_out);
  386.   if (hinf.subj) {
  387.     fd_puts("<strong><font size=+1>", fd_out);
  388.     fd_escape_puts(hinf.subj, fd_out);
  389.     fd_puts("</font></strong><br>n", fd_out);
  390.   }
  391.   if (hinf.from) {
  392. #if 0
  393.     fd_escape_puts(hinf.from, fd_out);
  394. #else
  395.     html_email(fd_out, hinf.from);
  396. #endif
  397.     fd_puts("<br>n", fd_out);
  398.   }
  399.   if (hinf.date) {
  400.     fd_escape_puts(hinf.date, fd_out);
  401.     fd_puts("<br>n", fd_out);
  402.   }
  404.   s_free(mem);
  405.   return start + len;
  406. }
  408. static char *do_rindex_entry(char *start, char *limit, 
  409.     int fd_out, int num, char *url)
  410. {
  411.   char *mem;
  412.   int len;
  413.   char *lines[MAX_HDR_LINES];
  414.   header_info hinf;
  416.   fd_puts("<!-- index entry -->n", fd_out);
  418.   if (start >= limit || start == NULL) 
  419.     return NULL;
  421.   if ((len = letter_head_len(start, limit)) <= 0 ||
  422.       (mem = malloc_letter_head(start, len, lines, MAX_HDR_LINES)) == NULL)
  423.     return NULL;
  424.   
  425.   set_header_info(&hinf, lines);
  427.   fd_puts("<dt>n", fd_out);
  428.   fd_printf(fd_out, "<a href="%s?r%d">n", url, num);
  429.   fd_printf(fd_out, "<strong><font size=+1>%d</font></strong>", num);
  430.   fd_puts("</a>n", fd_out);
  431.   fd_puts("<dd>n", fd_out);
  432.   if (hinf.subj) {
  433.     fd_puts("<strong><font size=+1>", fd_out);
  434.     fd_escape_puts(hinf.subj, fd_out);
  435.     fd_puts("</font></strong><br>n", fd_out);
  436.   }
  437.   if (hinf.from) {
  438. #if 0
  439.     fd_escape_puts(hinf.from, fd_out);
  440. #else
  441.     html_email(fd_out, hinf.from);
  442. #endif
  443.     fd_puts("<br>n", fd_out);
  444.   }
  445.   if (hinf.date) {
  446.     fd_escape_puts(hinf.date, fd_out);
  447.     fd_puts("<br>n", fd_out);
  448.   }
  450.   s_free(mem);
  451.   return start + len;
  452. }
  454. static char *do_id_index_entry(char *start, char *limit, 
  455.        int fd_out, int num, char *url)
  456. {
  457.   char *mem;
  458.   int len;
  459.   char *lines[MAX_HDR_LINES];
  460.   header_info hinf;
  462.   fd_puts("<!-- index entry -->n", fd_out);
  464.   if (start >= limit || start == NULL) 
  465.     return NULL;
  467.   if ((len = letter_head_len(start, limit)) <= 0 ||
  468.       (mem = malloc_letter_head(start, len, lines, MAX_HDR_LINES)) == NULL)
  469.     return NULL;
  470.   
  471.   set_header_info(&hinf, lines);
  473.   fd_puts("<dt>n", fd_out);
  474.   fd_printf(fd_out, "<strong><font size=+1>%d</font></strong>n", num);
  475.   fd_puts("<dd>n", fd_out);
  476.   if (hinf.id)   fd_print_msgid_link(fd_out, url, hinf.id);
  477.   if (hinf.subj) {
  478.     fd_puts("<strong><font size=+1>", fd_out);
  479.     fd_escape_puts(hinf.subj, fd_out);
  480.     fd_puts("</font></strong><br>n", fd_out);
  481.   }
  482.   if (hinf.id)   fd_puts("</a>n", fd_out);
  483.   if (hinf.from) {
  484.     fd_escape_puts(hinf.from, fd_out);
  485.     fd_puts("<br>n", fd_out);
  486.   }
  487.   if (hinf.date) {
  488.     fd_escape_puts(hinf.date, fd_out);
  489.     fd_puts("<br>n", fd_out);
  490.   }
  492.   s_free(mem);
  493.   return start + len;
  494. }
  496. static char *do_letter_body(char *start, char *limit, int fd_out)
  497. {
  498.   char *ptr;
  499.   char *end;
  501.   if (start >= limit || start == NULL) 
  502.     return NULL;
  504.   end = limit - strlen("nFrom ");
  506.   for (ptr = start; ptr < end; ptr++) {
  507.     if (*ptr == 'n') {
  509.       if (strncmp(ptr+1, SEP, SEPLEN) == 0) {
  510. limit = ptr+1;
  511. break;
  512.       }
  513.     }
  514.   }
  516.   fd_puts("<dd>n", fd_out);
  517.   fd_puts("<pre><!-- body -->n", fd_out);
  518.   
  519.   if (fd_escape_write(fd_out, start, limit - start) < 0)
  520.     if (debug) {
  521.       fprintf(stderr, "ERROR:");
  522.       perror("write");
  523.     }
  524.   fd_puts("</pre>n", fd_out);
  526.   return limit;
  527. }
  529. char *skip_letter_forward(int n, char *start, char *limit)
  530. {
  531.   char *ptr;
  532.   char *end;
  534.   if (start >= limit || start == NULL) 
  535.     return NULL;
  537.   if (n < 1)
  538.     return start;
  540.   end   = limit - SEPLEN - 1;
  541.   for (ptr = start; ptr < end; ptr++) {
  542.     if (*ptr == 'n') {
  543.       if (strncmp(ptr+1, SEP, SEPLEN) == 0 &&
  544.   --n <= 0) {
  545. return ptr+1;
  546.       }
  547.     }
  548.   }
  550.   return limit;
  551. }
  553. char *skip_letter_backward(int n, char *start, char *lower_limit)
  554. {
  555.   char *ptr;
  556.   char *begin;
  560.   if (start == NULL || (begin = start - SEPLEN) < lower_limit) 
  561.     return NULL;
  563.   if (n < 1)
  564.     return start;
  566.   for (ptr = begin; ptr >= lower_limit; ptr--) {
  567.     if (*ptr == 'n') {
  568.       if (strncmp(ptr+1, SEP, SEPLEN) == 0 &&
  569.   --n <= 0) {
  570. return ptr+1;
  571.       }
  572.     }
  573.   }
  575.   if (strncmp(lower_limit, SEP, SEPLEN) == 0)
  576.     return lower_limit;
  578.   return NULL;
  579. }
  582. static char *mmap_mbox(int fd_in, off_t size)
  583. {
  584.   char *cp;
  586.   cp = mmap((caddr_t) NULL,
  587.     size,
  588.     PROT_READ,
  589.     MAP_PRIVATE+MAP_NORESERVE,
  590.     fd_in, 0);
  592.   if (cp == (char *) MAP_FAILED) {
  593.     if (debug) {
  594.       fprintf(stderr, "ERROR: ");
  595.       perror("mmap");
  596.     }
  597.   } else {
  598.     madvise(cp, size, MADV_NORMAL);
  599.     madvise(cp, size, MADV_WILLNEED);
  600.   }
  601.   return cp;
  602. }
  605. static void do_letter(int fd_in, int fd_out, off_t size)
  606. {
  607.   char *cp;
  608.   char *ptr;
  610.   if ((cp = mmap_mbox(fd_in, size)) != NULL) {
  611.     for (ptr = cp; ptr != NULL;) {
  612.       ptr = do_letter_head(ptr, cp+size, fd_out);
  613.       ptr = do_letter_body(ptr, cp+size, fd_out);
  614.     }
  615.     munmap(cp, size);
  616.   }
  617. }
  619. static void do_num_letter(int fd_in, int fd_out, off_t size, int n)
  620. {
  621.   char *cp;
  622.   char *ptr;
  624.   if ((cp = mmap_mbox(fd_in, size)) != NULL) {
  625.     ptr = skip_letter_forward(n-1, cp, cp+size);
  626.     ptr = do_letter_head(ptr, cp+size, fd_out);
  627.     ptr = do_letter_body(ptr, cp+size, fd_out);
  629.     munmap(cp, size);
  630.   }
  631. }
  633. static void do_rnum_letter(int fd_in, int fd_out, off_t size, int n)
  634. {
  635.   char *cp;
  636.   char *ptr;
  638.   if ((cp = mmap_mbox(fd_in, size)) != NULL) {
  639.     ptr = skip_letter_backward(n, cp+size, cp);
  640.     ptr = do_letter_head(ptr, cp+size, fd_out);
  641.     ptr = do_letter_body(ptr, cp+size, fd_out);
  643.     munmap(cp, size);
  644.   }
  645. }
  647. static void do_index_entries(int fd_in, int fd_out, off_t size, char *url)
  648. {
  649.   char *cp;
  650.   char *ptr;
  651.   int count;
  653.   if ((cp = mmap_mbox(fd_in, size)) != NULL) {
  654.     count = 1;
  655.     for (ptr = cp; ptr != NULL;) {
  656.       ptr = do_index_entry(ptr, cp+size, fd_out, count++, url);
  657.       ptr = skip_letter_forward(1, ptr, cp+size);
  658.     }
  659.     munmap(cp, size);
  660.   }
  661. }
  663. static void do_rindex_entries(int fd_in, int fd_out, off_t size, char *url)
  664. {
  665.   char *cp;
  666.   char *ptr;
  667.   int count;
  669.   if ((cp = mmap_mbox(fd_in, size)) != NULL) {
  670.     count = 1;
  671.     for (ptr = cp + size - 1; ptr != NULL;) {
  672.       ptr = skip_letter_backward(1, ptr, cp);
  673.       do_rindex_entry(ptr, cp+size, fd_out, count++, url);
  674.     }
  675.     munmap(cp, size);
  676.   }
  677. }
  679. static void do_id_index_entries(int fd_in, int fd_out, off_t size, char *url)
  680. {
  681.   char *cp;
  682.   char *ptr;
  683.   int count;
  685.   if ((cp = mmap_mbox(fd_in, size)) != NULL) {
  686.     count = 1;
  687.     for (ptr = cp; ptr != NULL;) {
  688.       ptr = do_id_index_entry(ptr, cp+size, fd_out, count++, url);
  689.       ptr = skip_letter_forward(1, ptr, cp+size);
  690.     }
  691.     munmap(cp, size);
  692.   }
  693. }
  695. static void do_id_rindex_entries(int fd_in, int fd_out, off_t size, char *url)
  696. {
  697.   char *cp;
  698.   char *ptr;
  699.   int count;
  701.   if ((cp = mmap_mbox(fd_in, size)) != NULL) {
  702.     count = 1;
  703.     for (ptr = cp + size - 1; ptr != NULL;) {
  704.       ptr = skip_letter_backward(1, ptr, cp);
  705.       do_id_index_entry(ptr, cp+size, fd_out, count++, url);
  706.     }
  707.     munmap(cp, size);
  708.   }
  709. }
  711. #ifdef SF_ARCHIVE
  713. static void sf_fix_title(char *title, char *buf, int buflen)
  714. {
  715.   char *begin;
  716.   char *end;
  717.   char *src;
  718.   char *dst;
  719.   char *dstend;
  721.   if ((begin = strrchr(title, '/')) == NULL)
  722.     begin = title;
  723.   else
  724.     begin++;
  726.   if ((end = strrchr(begin, '.')) == NULL ||
  727.       strcmp(end, ".mbox") != 0)
  728.     end = begin + strlen(begin);
  730.   dst = buf; dstend = buf + buflen;
  731.   for (src = begin; src < end; src++) {
  733.     switch (*src) {
  735.     case '':
  736.       *dst = '';
  737.       return;
  739.     case ',':
  740.       if (dst + 2 > dstend) {
  741. *dst = '';
  742. return;
  743.       }
  744.       *dst++ = ',';
  745.       *dst++ = ' ';
  746.       break;
  748.     case '_':
  749.       *dst++ = ' ';
  750.       break;
  752.     default:
  753.       *dst++ = *src;
  754.       break;
  755.     }
  757.     if (dst+1 >= dstend) {
  758.       *dst = '';
  759.       return;
  760.     }
  761.   }
  762. }
  764. static void sf_do_file_head(int fd_out, char *title)
  765. {
  766.   fd_printf(fd_out, "<html>n");
  767.   fd_printf(fd_out, "<!-- SF archive mbox converter -->n");
  768.   fd_printf(fd_out, "<head>n");
  769.   fd_printf(fd_out, "<title>Link鰌ing Science Fiction Archive:%s</title>n", title);
  770.   fd_printf(fd_out, "<link rev="made" href="mailto:matoh@lysator.liu.se">n");
  771.   fd_printf(fd_out, "</head>n");
  772. }
  774. static void sf_do_file_body(int fd_in, int fd_out, off_t size, char *title)
  775. {
  776.   fd_printf(fd_out, "<body background="/sf_archive/background.gif">n");
  777.   fd_printf(fd_out, "<dl>n");
  778.   fd_printf(fd_out, "<dt>n");
  779.   fd_printf(fd_out, "<a href="/sf_archive/sf_main.html">n");
  780.   fd_printf(fd_out, "<img align=top src="/sf_archive/small_logo.gif" alt="[Logotype]" border=0></a>n");
  781.   fd_printf(fd_out, "<cite>The Link鰌ing Science Fiction & Fantasy Archive</cite>n");
  782.   fd_printf(fd_out, "<dd>n");
  783.   fd_printf(fd_out, "<h1>%s</h1>n", title);
  784.   fd_printf(fd_out, "<hr noshade>n");
  785.   fd_printf(fd_out, "<dl>n");
  787.   do_letter(fd_in, fd_out, size);
  789.   fd_printf(fd_out, "</dl>n");
  790.   fd_printf(fd_out, "<hr noshade>n");
  791.   fd_printf(fd_out, "<address>n");
  792.   fd_printf(fd_out, "<a href="/sf_archive/sf_main.html">Link鰌ing SF Archive</a> /n");
  793.   fd_printf(fd_out, "<a href="/sf_archive/matoh.html">Mats 謍rman</a>n");
  794.   fd_printf(fd_out, "</address>n");
  795.   fd_printf(fd_out, "</dl>n");
  796.   fd_printf(fd_out, "</body>n");
  797.   fd_printf(fd_out, "</html>n");
  798. }
  800. static void sf_do_all(int fd_in, int fd_out, char *url, off_t size)
  801. {
  802.   char title[256];
  804.   sf_fix_title(url, title, sizeof(title));
  805.   sf_do_file_head(fd_out, title);
  806.   sf_do_file_body(fd_in, fd_out, size, title);
  807. }
  809. #endif
  812. static void fix_title(char *title, char *buf, int buflen)
  813. {
  814.   char *begin;
  815.   char *end;
  816.   int len;
  817.   int i;
  819.   if ((begin = strrchr(title, '/')) == NULL)
  820.     begin = title;
  821.   else 
  822.     begin++;
  824.   if ((end = strrchr(begin, '.')) == NULL ||
  825.       strcmp(end, ".mbox") != 0)
  826.     len = strlen(begin);
  827.   else
  828.     len = end - begin;
  830.   if (len > buflen - 1)
  831.     len = buflen - 1;
  833.   for (i = 0; i < len; i++) {
  834.     buf[i] = begin[i];
  835.   }
  836.   buf[i] = '';
  837. }
  839. static void do_file_head(int fd_out, char *title, char *url)
  840. {
  841.   fd_puts("<html>n",    fd_out);
  842.   fd_puts("<head>n",    fd_out);
  843. #if 0
  844.   fd_printf(fd_out, "<base href="%s%s">n", server_url, url);
  845. #endif
  846.   fd_puts("<title>",     fd_out);
  847.   fd_escape_puts(title, fd_out);
  848.   fd_puts("</title>n",  fd_out);
  849.   fd_puts("</head>n",   fd_out);
  850.   if ( mail_top_include != NULL ) do_file_copy(mail_top_include, fd_out);
  851. }
  853. static void do_file_body(int fd_in, int fd_out, off_t size, char *title)
  854. {
  855.   fd_printf(fd_out, "<body>n");
  856.   fd_printf(fd_out, "<h1>");
  857.   fd_escape_puts(title, fd_out);
  858.   fd_printf(fd_out, "</h1>n");
  859.   fd_printf(fd_out, "<dl>n");
  861.   do_letter(fd_in, fd_out, size);
  863.   fd_printf(fd_out, "</dl>n");
  864.   if ( mail_bottom_include != NULL ) do_file_copy(mail_bottom_include, fd_out);
  865.   fd_printf(fd_out, "</body>n");
  866.   fd_printf(fd_out, "</html>n");
  867. }
  869. static void do_num_file_body(int fd_in, int fd_out, off_t size, 
  870.     int n, char *title)
  871. {
  872.   fd_printf(fd_out, "<body>n");
  873.   fd_printf(fd_out, "<h1>");
  874.   fd_escape_puts(title, fd_out);
  875.   fd_printf(fd_out, ": %d</h1>n", n);
  876.   fd_printf(fd_out, "<dl>n");
  878.   do_num_letter(fd_in, fd_out, size, n);
  880.   fd_printf(fd_out, "</dl>n");
  881.   fd_printf(fd_out, "</body>n");
  882.   fd_printf(fd_out, "</html>n");
  883. }
  885. static void do_rnum_file_body(int fd_in, int fd_out, off_t size, 
  886.     int n, char *title)
  887. {
  888.   fd_printf(fd_out, "<body>n");
  889.   fd_printf(fd_out, "<h1>");
  890.   fd_escape_puts(title, fd_out);
  891.   fd_printf(fd_out, ": %d</h1>n", n);
  892.   fd_printf(fd_out, "<dl>n");
  894.   do_rnum_letter(fd_in, fd_out, size, n);
  896.   fd_printf(fd_out, "</dl>n");
  897.   fd_printf(fd_out, "</body>n");
  898.   fd_printf(fd_out, "</html>n");
  899. }
  901. static void do_index_body(int fd_in, int fd_out, off_t size, char *title, char *url)
  902. {
  903.   fd_printf(fd_out, "<body>n");
  904.   fd_printf(fd_out, "<h1><a href="%s">", url);
  905.   fd_escape_puts(title, fd_out);
  906.   fd_printf(fd_out, "</a>");
  907.   fd_printf(fd_out, ": Index</h1>n");
  908.   fd_printf(fd_out, "<dl compact>n");
  910.   do_index_entries(fd_in, fd_out, size, url);
  912.   fd_printf(fd_out, "</dl>n");
  913.   fd_printf(fd_out, "</body>n");
  914.   fd_printf(fd_out, "</html>n");
  915. }
  917. static void do_rindex_body(int fd_in, int fd_out, off_t size, char *title, char *url)
  918. {
  919.   fd_printf(fd_out, "<body>n");
  920.   fd_printf(fd_out, "<h1><a href="%s">", url);
  921.   fd_escape_puts(title, fd_out);
  922.   fd_printf(fd_out, "</a>");
  923.   fd_printf(fd_out, ": Reverse Index</h1>n");
  924.   fd_printf(fd_out, "<dl compact>n");
  926.   do_rindex_entries(fd_in, fd_out, size, url);
  928.   fd_printf(fd_out, "</dl>n");
  929.   fd_printf(fd_out, "</body>n");
  930.   fd_printf(fd_out, "</html>n");
  931. }
  933. static void do_id_index_body(int fd_in, int fd_out, off_t size, char *title, char *url)
  934. {
  935.   fd_printf(fd_out, "<body>n");
  936.   fd_printf(fd_out, "<h1><a href="%s">", url);
  937.   fd_escape_puts(title, fd_out);
  938.   fd_printf(fd_out, "</a>");
  939.   fd_printf(fd_out, ": Index</h1>n");
  940.   fd_printf(fd_out, "<dl compact>n");
  942.   do_id_index_entries(fd_in, fd_out, size, url);
  944.   fd_printf(fd_out, "</dl>n");
  945.   fd_printf(fd_out, "</body>n");
  946.   fd_printf(fd_out, "</html>n");
  947. }
  949. static void do_id_rindex_body(int fd_in, int fd_out, off_t size, char *title, char *url)
  950. {
  951.   fd_printf(fd_out, "<body>n");
  952.   fd_printf(fd_out, "<h1><a href="%s">", url);
  953.   fd_escape_puts(title, fd_out);
  954.   fd_printf(fd_out, "</a>");
  955.   fd_printf(fd_out, ": Index</h1>n");
  956.   fd_printf(fd_out, "<dl compact>n");
  958.   do_id_rindex_entries(fd_in, fd_out, size, url);
  960.   fd_printf(fd_out, "</dl>n");
  961.   fd_printf(fd_out, "</body>n");
  962.   fd_printf(fd_out, "</html>n");
  963. }
  965. static void do_all(int fd_in, int fd_out, char *url, off_t size)
  966. {
  967.   char title[256];
  969.   fix_title(url, title, sizeof(title));
  970.   do_file_head(fd_out, title, url);
  971.   do_file_body(fd_in, fd_out, size, title);
  972. }
  974. static void do_index(int fd_in, int fd_out, char *url, off_t size)
  975. {
  976.   char title[256];
  978.   fix_title(url, title, sizeof(title));
  979.   do_file_head(fd_out, title, url);
  980.   do_index_body(fd_in, fd_out, size, title, url);
  981. }
  983. static void do_rindex(int fd_in, int fd_out, char *url, off_t size)
  984. {
  985.   char title[256];
  987.   fix_title(url, title, sizeof(title));
  988.   do_file_head(fd_out, title, url);
  989.   do_rindex_body(fd_in, fd_out, size, title, url);
  990. }
  992. static void do_id_index(int fd_in, int fd_out, char *url, off_t size)
  993. {
  994.   char title[256];
  996.   fix_title(url, title, sizeof(title));
  997.   do_file_head(fd_out, title, url);
  998.   do_id_index_body(fd_in, fd_out, size, title, url);
  999. }
  1001. static void do_id_rindex(int fd_in, int fd_out, char *url, off_t size)
  1002. {
  1003.   char title[256];
  1005.   fix_title(url, title, sizeof(title));
  1006.   do_file_head(fd_out, title, url);
  1007.   do_id_rindex_body(fd_in, fd_out, size, title, url);
  1008. }
  1010. static void do_num_search(int fd_in, int fd_out, 
  1011.   char *num, char *url, off_t size)
  1012. {
  1013.   char title[256];
  1014.   int n;
  1016.   n = atoi(num);
  1018.   fix_title(url, title, sizeof(title));
  1019.   do_file_head(fd_out, title, url);
  1020.   do_num_file_body(fd_in, fd_out, size, n, title);
  1021. }
  1023. static void do_rnum_search(int fd_in, int fd_out, 
  1024.   char *num, char *url, off_t size)
  1025. {
  1026.   char title[256];
  1027.   int n;
  1029.   n = atoi(num);
  1031.   fix_title(url, title, sizeof(title));
  1032.   do_file_head(fd_out, title, url);
  1033.   do_rnum_file_body(fd_in, fd_out, size, n, title);
  1034. }
  1036. static int http_get_head(struct connectioninfo *cip)
  1037. {
  1038.     char buf[256], *s_since;
  1039.     char path[1025];
  1040.     struct stat sb;
  1041.     int fd_in, i, status, result;
  1042.     int fd_out = cip->fd;
  1043.     struct httpinfo *hip = cip->hip;
  1044.     
  1045.     
  1046.     if (debug > 1)
  1047. fprintf(stderr, "*** mbox/pm_get() called ***n");
  1049.     if (url_expand(hip->url, path, sizeof(path), &sb, NULL, NULL) == NULL)
  1050. return -1;
  1051.     
  1052.     if (hip->mip &&
  1053. (s_since = mime_getheader(hip->mip, "IF-MODIFIED-SINCE", 1)))
  1054.     {
  1055.         struct tm tm_since;
  1056. int t_since;
  1059. t_since = atotm(s_since, &tm_since);
  1060. if (t_since != -1)
  1061. {
  1062.     if (sb.st_mtime <= (time_t) t_since)
  1063.         return http_not_modified(cip);
  1064. }
  1065. else
  1066. {
  1067.     /* Could not parse the date format - do a string compare */
  1068.     http_time_r(&sb.st_mtime, buf, sizeof(buf));
  1069.     i = strlen(buf);
  1070.     buf[i-1] = '';
  1071.     
  1072.     if (strcmp(s_since, buf) == 0)
  1073.         return http_not_modified(cip);
  1074. }
  1075.     }
  1077.     fd_in = s_open(path, O_RDONLY);
  1078.     if (fd_in < 0)
  1079.     {
  1080. if (debug)
  1081.     perror("open(path)");
  1083. return -1;
  1084.     }
  1085.     
  1086.     result = 200;
  1087.     
  1088.     if (hip->mip != NULL)
  1089.     {
  1090. http_sendheaders(fd_out, cip, result, NULL);
  1091. http_sendlastmodified(fd_out, sb.st_mtime);
  1093. fd_puts("Content-Type: text/htmlnn", fd_out);
  1094.     }
  1095. #if 0
  1096.     hip->length = sb.st_size;
  1097. #endif
  1098.     
  1099.     if (hip->mip != NULL)
  1100. fd_putc('n', fd_out);
  1102.     if (strcasecmp(hip->method, "HEAD") == 0)
  1103.     {
  1104. s_close(fd_in);
  1105. return result;
  1106.     }
  1108. #ifdef SF_ARCHIVE
  1109.     if (strncmp(hip->url, "/sf_archive/", strlen("/sf_archive/")) == 0) {
  1110.       sf_do_all(fd_in, fd_out, hip->url, sb.st_size);
  1111.     } else {
  1112.       if (hip->request == NULL) {
  1113. #if 0
  1114. do_all(fd_in, fd_out, hip->url, sb.st_size);
  1115. #else
  1116. do_rindex(fd_in, fd_out, hip->url, sb.st_size);
  1117. #endif
  1118.       } else if (strcasecmp(hip->request, "all") == 0) {
  1119. do_all(fd_in, fd_out, hip->url, sb.st_size);
  1120.       } else if (strcasecmp(hip->request, "index") == 0) {
  1121. do_index(fd_in, fd_out, hip->url, sb.st_size);
  1122.       } else if (strcasecmp(hip->request, "rindex") == 0) {
  1123. do_rindex(fd_in, fd_out, hip->url, sb.st_size);
  1124.       } else if (strcasecmp(hip->request, "id_index") == 0) {
  1125. do_id_index(fd_in, fd_out, hip->url, sb.st_size);
  1126.       } else if (strcasecmp(hip->request, "id_rindex") == 0) {
  1127. do_id_rindex(fd_in, fd_out, hip->url, sb.st_size);
  1128.       } else if (all_digits(hip->request)) {
  1129. do_num_search(fd_in, fd_out, hip->request, hip->url, sb.st_size);
  1130.       } else if ((hip->request[0] == 'r' || hip->request[0] == '-' ) && 
  1131.  all_digits(hip->request + 1)) {
  1132. do_rnum_search(fd_in, fd_out, hip->request+1, hip->url, sb.st_size);
  1133.       } else {
  1134. #if 0
  1135. do_all(fd_in, fd_out, hip->url, sb.st_size);
  1136. #else
  1137. do_rindex(fd_in, fd_out, hip->url, sb.st_size);
  1138. #endif
  1139.       }
  1140.     }    
  1141. #else
  1142.     do_all(fd_in, fd_out, hip->url, sb.st_size);
  1143. #endif
  1145.     status = s_close(fd_in);
  1146.     if (status < 0)
  1147. if (debug)
  1148. {
  1149.     fprintf(stderr, "ERROR on #%d: ", cip->request_no);
  1150.     perror("close");
  1151. }
  1153.     if (debug > 2)
  1154. fprintf(stderr, "modules/mbox/http_get: Returningn");
  1155.     
  1156.     return result;
  1157. }
  1160. int pm_request(struct connectioninfo *cip)
  1161. {
  1162.     struct httpinfo *hip = cip->hip;
  1163.     
  1164.     if (strcasecmp(hip->method, "GET") == 0 ||
  1165. strcasecmp(hip->method, "HEAD") == 0)
  1166. return http_get_head(cip);
  1167.     else
  1168. return -2;
  1169. }