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

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

Web服务器

开发平台：

Unix_Linux

mbox.c：源码内容
  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;
  58. int pm_init(const char **argv)
  59. {
  60.     const char *name = argv[0];
  62.     
  63.     if (debug > 1)
  64. fprintf(stderr, "*** mbox/pm_init("%s") called ***n", name);
  66.     return 0;
  67. }
  69. void pm_exit(void)
  70. {
  71.     if (debug > 1)
  72. fprintf(stderr, "*** mbox/pm_exit() called ***n");
  73. }
  75. static int all_digits(char *ptr)
  76. {
  77.   for ( ; *ptr != ''; ptr++)
  78.     if (!s_isdigit(*ptr))
  79.       return 0;
  81.   return -1;
  82. }
  84. static void fd_print_msgid_anchor(int fd_out, char *id)
  85. {
  86.   char *begin;
  87.   char *end;
  88.   int len;
  90.   if ((begin = strchr(id, '<')) == NULL)
  91.     begin = id;
  92.   else 
  93.     begin++;
  95.   if ((end = strrchr(begin, '>')) != NULL)
  96.     len = end - begin;
  97.   else
  98.     len = strlen(begin);
  99.   
  100.   fd_puts("<a name="", fd_out);
  101.   fd_write( fd_out, begin, len);
  102.   fd_puts("">n", fd_out);
  103. }
  105. static void fd_print_msgid_link(int fd_out, char *url, char *id)
  106. {
  107.   char *begin;
  108.   char *end;
  109.   int len;
  111.   if ((begin = strchr(id, '<')) == NULL)
  112.     begin = id;
  113.   else 
  114.     begin++;
  116.   if ((end = strrchr(begin, '>')) != NULL)
  117.     len = end - begin;
  118.   else
  119.     len = strlen(begin);
  120.   
  121.   fd_printf(fd_out, "<a href="%s#", url);
  122.   fd_write( fd_out, begin, len);
  123.   fd_puts("">n", fd_out);
  124. }
  126. static int fd_escape_write(int fd_out, char *start, off_t len)
  127. {
  128.   char *begin;
  129.   char *ptr;
  130.   char *end;
  131.   off_t chunklen;
  132.   int retval;
  134.   begin = start;
  135.   end   = start + len;
  137.   for (ptr = start; ptr < end; ptr++) {
  138.     switch (*ptr) {
  139.     case '&':
  140.       if ((chunklen = ptr - begin) > 0)
  141. if ((retval = fd_write(fd_out, begin, chunklen)) != 0)
  142.   return retval;
  143.       begin = ptr + 1;
  144.       fd_puts("&amp;", fd_out);
  145.       break;
  146.     case '<':
  147.       if ((chunklen = ptr - begin) > 0)
  148. if ((retval = fd_write(fd_out, begin, chunklen)) != 0)
  149.   return retval;
  150.       begin = ptr + 1;
  151.       fd_puts("&lt;", fd_out);
  152.       break;
  153.     case '>':
  154.       if ((chunklen = ptr - begin) > 0)
  155. if ((retval = fd_write(fd_out, begin, chunklen)) != 0)
  156.   return retval;
  157.       begin = ptr + 1;
  158.       fd_puts("&gt;", fd_out);
  159.       break;
  160.     }
  161.   }
  162.   if ((chunklen = ptr - begin) > 0)
  163.     if ((retval = fd_write(fd_out, begin, chunklen)) != 0)
  164.       return retval;
  166.   return 0;
  167. }
  169. static int fd_escape_puts(char *str, int fd_out)
  170. {
  171.   off_t len;
  173.   len = strlen(str);
  174.   return fd_escape_write(fd_out, str, len);
  175. }
  177. static int letter_head_len(char *start, char *limit)
  178. {
  179.   char *ptr;
  181.   for (ptr = start; ptr < limit; ptr++) {
  182.     if (*ptr != 'n')
  183.       continue;
  185.     ptr++;
  187.     if (ptr >= limit || *ptr == 'n')
  188.       break;
  189.   }
  191.   return ptr - start;
  192. }
  194. static char* malloc_letter_head(char *start,   int len, 
  195. char *lines[], int maxlines)
  196. {
  197.   char *mem;
  198.   int i;
  199.   int nlines;
  201.   if (len <= 0 ||
  202.       (mem = s_malloc(len)) == NULL)
  203.     return NULL;
  204.   
  205.   memcpy(mem, start, len);
  207.   nlines = 0;
  208.   if (nlines < maxlines) 
  209.     lines[nlines++] = mem;
  210.     
  211.   for (i = 0; i < len; i++) {
  212.     if (mem[i] != 'n')
  213.       continue;
  215.     if (i+1 < len && s_isspace(mem[i+1]))
  216.       continue;
  218.     mem[i] = '';
  219.     
  220.     if (nlines < maxlines && i+1 < len) 
  221.       lines[nlines++] = mem + i + 1;
  223.   }
  225.   if (nlines < maxlines) 
  226.     lines[nlines++] = NULL;
  227.   else
  228.     lines[maxlines - 1] = NULL;
  230.   return mem;
  231. }
  233. static char* find_header_val(char *key, char *lines[])
  234. {
  235.   int i;
  236.   int keylen;
  237.   char *ptr;
  239.   keylen=strlen(key);
  240.   for (i = 0; lines[i] != NULL; i++) {
  241.     ptr = lines[i];
  242.     if (strncasecmp(key, ptr, keylen) == 0 &&
  243. ptr[keylen] == ':') {
  244.       ptr += keylen + 1;
  245.       while (s_isspace(*ptr))
  246. ptr++;
  247.       return ptr;
  248.     }
  249.   }
  251.   return NULL;
  252. }
  254. static void set_header_info(header_info *hinf, char *lines[])
  255. {
  256.   hinf->subj = find_header_val("subject", lines);
  257.   hinf->from = find_header_val("from", lines);
  258.   hinf->orgz = find_header_val("organization", lines);
  259.   hinf->date = find_header_val("date", lines);
  260.   hinf->id   = find_header_val("message-id", lines);
  261. }
  263. static void fd_print_subject(int fd_out, char *subj, char *id)
  264. {
  265.   if (id) 
  266.     fd_print_msgid_anchor(fd_out, id);
  268.   if (subj) {
  269.     fd_puts("<strong><font size=+1>", fd_out);
  270.     fd_escape_puts(subj, fd_out);
  271.     fd_puts("</font></strong>n", fd_out);
  272.   }
  274.   if (id)
  275.     fd_puts("</a>n", fd_out);
  276. }
  278. static char *do_letter_head(char *start, char *limit, int fd_out)
  279. {
  280.   char *mem;
  281.   int len;
  282.   char *lines[MAX_HDR_LINES];
  283.   header_info hinf;
  285.   fd_puts("<!-- head -->n", fd_out);
  287.   if (start >= limit || start == NULL) 
  288.     return NULL;
  290.   if ((len = letter_head_len(start, limit)) <= 0 ||
  291.       (mem = malloc_letter_head(start, len, lines, MAX_HDR_LINES)) == NULL)
  292.     return NULL;
  293.  
  294.   set_header_info(&hinf, lines);
  296.   fd_puts("<dt>n", fd_out);
  298.   fd_print_subject(fd_out, hinf.subj, hinf.id);
  299.   fd_puts("<br>", fd_out);
  301.   html_email(fd_out, hinf.from);
  302.   fd_puts("<br>", fd_out);
  304.   if (hinf.orgz) {
  305.     fd_escape_puts(hinf.orgz, fd_out);
  306.     fd_puts("<br>", fd_out);
  307.   }
  309.   if (hinf.date) {
  310.     fd_escape_puts(hinf.date, fd_out);
  311.     fd_puts("<br>", fd_out);
  312.   }
  314.   s_free(mem);
  315.   return start + len;
  316. }
  318. static char *do_index_entry(char *start, char *limit, 
  319.     int fd_out, int num, char *url)
  320. {
  321.   char *mem;
  322.   int len;
  323.   char *lines[MAX_HDR_LINES];
  324.   header_info hinf;
  326.   fd_puts("<!-- index entry -->n", fd_out);
  328.   if (start >= limit || start == NULL) 
  329.     return NULL;
  331.   if ((len = letter_head_len(start, limit)) <= 0 ||
  332.       (mem = malloc_letter_head(start, len, lines, MAX_HDR_LINES)) == NULL)
  333.     return NULL;
  334.   
  335.   set_header_info(&hinf, lines);
  337.   fd_puts("<dt>n", fd_out);
  338.   fd_printf(fd_out, "<a href="%s?%d">n", url, num);
  339.   fd_printf(fd_out, "<strong><font size=+1>%d</font></strong>", num);
  340.   fd_puts("</a>n", fd_out);
  341.   fd_puts("<dd>n", fd_out);
  343.   if (hinf.subj) {
  344.     fd_puts("<strong><font size=+1>", fd_out);
  345.     fd_escape_puts(hinf.subj, fd_out);
  346.     fd_puts("</font></strong><br>n", fd_out);
  347.   }
  348.   if (hinf.from) {
  349. #if 0
  350.     fd_escape_puts(hinf.from, fd_out);
  351. #else
  352.     html_email(fd_out, hinf.from);
  353. #endif
  354.     fd_puts("<br>n", fd_out);
  355.   }
  356.   if (hinf.date) {
  357.     fd_escape_puts(hinf.date, fd_out);
  358.     fd_puts("<br>n", fd_out);
  359.   }
  361.   s_free(mem);
  362.   return start + len;
  363. }
  365. static char *do_rindex_entry(char *start, char *limit, 
  366.     int fd_out, int num, char *url)
  367. {
  368.   char *mem;
  369.   int len;
  370.   char *lines[MAX_HDR_LINES];
  371.   header_info hinf;
  373.   fd_puts("<!-- index entry -->n", fd_out);
  375.   if (start >= limit || start == NULL) 
  376.     return NULL;
  378.   if ((len = letter_head_len(start, limit)) <= 0 ||
  379.       (mem = malloc_letter_head(start, len, lines, MAX_HDR_LINES)) == NULL)
  380.     return NULL;
  381.   
  382.   set_header_info(&hinf, lines);
  384.   fd_puts("<dt>n", fd_out);
  385.   fd_printf(fd_out, "<a href="%s?r%d">n", url, num);
  386.   fd_printf(fd_out, "<strong><font size=+1>%d</font></strong>", num);
  387.   fd_puts("</a>n", fd_out);
  388.   fd_puts("<dd>n", fd_out);
  389.   if (hinf.subj) {
  390.     fd_puts("<strong><font size=+1>", fd_out);
  391.     fd_escape_puts(hinf.subj, fd_out);
  392.     fd_puts("</font></strong><br>n", fd_out);
  393.   }
  394.   if (hinf.from) {
  395. #if 0
  396.     fd_escape_puts(hinf.from, fd_out);
  397. #else
  398.     html_email(fd_out, hinf.from);
  399. #endif
  400.     fd_puts("<br>n", fd_out);
  401.   }
  402.   if (hinf.date) {
  403.     fd_escape_puts(hinf.date, fd_out);
  404.     fd_puts("<br>n", fd_out);
  405.   }
  407.   s_free(mem);
  408.   return start + len;
  409. }
  411. static char *do_id_index_entry(char *start, char *limit, 
  412.        int fd_out, int num, char *url)
  413. {
  414.   char *mem;
  415.   int len;
  416.   char *lines[MAX_HDR_LINES];
  417.   header_info hinf;
  419.   fd_puts("<!-- index entry -->n", fd_out);
  421.   if (start >= limit || start == NULL) 
  422.     return NULL;
  424.   if ((len = letter_head_len(start, limit)) <= 0 ||
  425.       (mem = malloc_letter_head(start, len, lines, MAX_HDR_LINES)) == NULL)
  426.     return NULL;
  427.   
  428.   set_header_info(&hinf, lines);
  430.   fd_puts("<dt>n", fd_out);
  431.   fd_printf(fd_out, "<strong><font size=+1>%d</font></strong>n", num);
  432.   fd_puts("<dd>n", fd_out);
  433.   if (hinf.id)   fd_print_msgid_link(fd_out, url, hinf.id);
  434.   if (hinf.subj) {
  435.     fd_puts("<strong><font size=+1>", fd_out);
  436.     fd_escape_puts(hinf.subj, fd_out);
  437.     fd_puts("</font></strong><br>n", fd_out);
  438.   }
  439.   if (hinf.id)   fd_puts("</a>n", fd_out);
  440.   if (hinf.from) {
  441.     fd_escape_puts(hinf.from, fd_out);
  442.     fd_puts("<br>n", fd_out);
  443.   }
  444.   if (hinf.date) {
  445.     fd_escape_puts(hinf.date, fd_out);
  446.     fd_puts("<br>n", fd_out);
  447.   }
  449.   s_free(mem);
  450.   return start + len;
  451. }
  453. static char *do_letter_body(char *start, char *limit, int fd_out)
  454. {
  455.   char *ptr;
  456.   char *end;
  458.   if (start >= limit || start == NULL) 
  459.     return NULL;
  461.   end = limit - strlen("nFrom ");
  463.   for (ptr = start; ptr < end; ptr++) {
  464.     if (*ptr == 'n') {
  466.       if (strncmp(ptr+1, SEP, SEPLEN) == 0) {
  467. limit = ptr+1;
  468. break;
  469.       }
  470.     }
  471.   }
  473.   fd_puts("<dd>n", fd_out);
  474.   fd_puts("<pre><!-- body -->n", fd_out);
  475.   
  476.   if (fd_escape_write(fd_out, start, limit - start) < 0)
  477.     if (debug) {
  478.       fprintf(stderr, "ERROR:");
  479.       perror("write");
  480.     }
  481.   fd_puts("</pre>n", fd_out);
  483.   return limit;
  484. }
  486. char *skip_letter_forward(int n, char *start, char *limit)
  487. {
  488.   char *ptr;
  489.   char *end;
  491.   if (start >= limit || start == NULL) 
  492.     return NULL;
  494.   if (n < 1)
  495.     return start;
  497.   end   = limit - SEPLEN - 1;
  498.   for (ptr = start; ptr < end; ptr++) {
  499.     if (*ptr == 'n') {
  500.       if (strncmp(ptr+1, SEP, SEPLEN) == 0 &&
  501.   --n <= 0) {
  502. return ptr+1;
  503.       }
  504.     }
  505.   }
  507.   return limit;
  508. }
  510. char *skip_letter_backward(int n, char *start, char *lower_limit)
  511. {
  512.   char *ptr;
  513.   char *begin;
  517.   if (start == NULL || (begin = start - SEPLEN) < lower_limit) 
  518.     return NULL;
  520.   if (n < 1)
  521.     return start;
  523.   for (ptr = begin; ptr >= lower_limit; ptr--) {
  524.     if (*ptr == 'n') {
  525.       if (strncmp(ptr+1, SEP, SEPLEN) == 0 &&
  526.   --n <= 0) {
  527. return ptr+1;
  528.       }
  529.     }
  530.   }
  532.   if (strncmp(lower_limit, SEP, SEPLEN) == 0)
  533.     return lower_limit;
  535.   return NULL;
  536. }
  539. static char *mmap_mbox(int fd_in, off_t size)
  540. {
  541.   char *cp;
  543.   cp = mmap((caddr_t) NULL,
  544.     size,
  545.     PROT_READ,
  546.     MAP_PRIVATE+MAP_NORESERVE,
  547.     fd_in, 0);
  549.   if (cp == (char *) MAP_FAILED) {
  550.     if (debug) {
  551.       fprintf(stderr, "ERROR: ");
  552.       perror("mmap");
  553.     }
  554.   } else {
  555.     madvise(cp, size, MADV_NORMAL);
  556.     madvise(cp, size, MADV_WILLNEED);
  557.   }
  558.   return cp;
  559. }
  562. static void do_letter(int fd_in, int fd_out, off_t size)
  563. {
  564.   char *cp;
  565.   char *ptr;
  567.   if ((cp = mmap_mbox(fd_in, size)) != NULL) {
  568.     for (ptr = cp; ptr != NULL;) {
  569.       ptr = do_letter_head(ptr, cp+size, fd_out);
  570.       ptr = do_letter_body(ptr, cp+size, fd_out);
  571.     }
  572.     munmap(cp, size);
  573.   }
  574. }
  576. static void do_num_letter(int fd_in, int fd_out, off_t size, int n)
  577. {
  578.   char *cp;
  579.   char *ptr;
  581.   if ((cp = mmap_mbox(fd_in, size)) != NULL) {
  582.     ptr = skip_letter_forward(n-1, cp, cp+size);
  583.     ptr = do_letter_head(ptr, cp+size, fd_out);
  584.     ptr = do_letter_body(ptr, cp+size, fd_out);
  586.     munmap(cp, size);
  587.   }
  588. }
  590. static void do_rnum_letter(int fd_in, int fd_out, off_t size, int n)
  591. {
  592.   char *cp;
  593.   char *ptr;
  595.   if ((cp = mmap_mbox(fd_in, size)) != NULL) {
  596.     ptr = skip_letter_backward(n, cp+size, cp);
  597.     ptr = do_letter_head(ptr, cp+size, fd_out);
  598.     ptr = do_letter_body(ptr, cp+size, fd_out);
  600.     munmap(cp, size);
  601.   }
  602. }
  604. static void do_index_entries(int fd_in, int fd_out, off_t size, char *url)
  605. {
  606.   char *cp;
  607.   char *ptr;
  608.   int count;
  610.   if ((cp = mmap_mbox(fd_in, size)) != NULL) {
  611.     count = 1;
  612.     for (ptr = cp; ptr != NULL;) {
  613.       ptr = do_index_entry(ptr, cp+size, fd_out, count++, url);
  614.       ptr = skip_letter_forward(1, ptr, cp+size);
  615.     }
  616.     munmap(cp, size);
  617.   }
  618. }
  620. static void do_rindex_entries(int fd_in, int fd_out, off_t size, char *url)
  621. {
  622.   char *cp;
  623.   char *ptr;
  624.   int count;
  626.   if ((cp = mmap_mbox(fd_in, size)) != NULL) {
  627.     count = 1;
  628.     for (ptr = cp + size - 1; ptr != NULL;) {
  629.       ptr = skip_letter_backward(1, ptr, cp);
  630.       do_rindex_entry(ptr, cp+size, fd_out, count++, url);
  631.     }
  632.     munmap(cp, size);
  633.   }
  634. }
  636. static void do_id_index_entries(int fd_in, int fd_out, off_t size, char *url)
  637. {
  638.   char *cp;
  639.   char *ptr;
  640.   int count;
  642.   if ((cp = mmap_mbox(fd_in, size)) != NULL) {
  643.     count = 1;
  644.     for (ptr = cp; ptr != NULL;) {
  645.       ptr = do_id_index_entry(ptr, cp+size, fd_out, count++, url);
  646.       ptr = skip_letter_forward(1, ptr, cp+size);
  647.     }
  648.     munmap(cp, size);
  649.   }
  650. }
  652. static void do_id_rindex_entries(int fd_in, int fd_out, off_t size, char *url)
  653. {
  654.   char *cp;
  655.   char *ptr;
  656.   int count;
  658.   if ((cp = mmap_mbox(fd_in, size)) != NULL) {
  659.     count = 1;
  660.     for (ptr = cp + size - 1; ptr != NULL;) {
  661.       ptr = skip_letter_backward(1, ptr, cp);
  662.       do_id_index_entry(ptr, cp+size, fd_out, count++, url);
  663.     }
  664.     munmap(cp, size);
  665.   }
  666. }
  668. #ifdef SF_ARCHIVE
  670. static void sf_fix_title(char *title, char *buf, int buflen)
  671. {
  672.   char *begin;
  673.   char *end;
  674.   char *src;
  675.   char *dst;
  676.   char *dstend;
  678.   if ((begin = strrchr(title, '/')) == NULL)
  679.     begin = title;
  680.   else
  681.     begin++;
  683.   if ((end = strrchr(begin, '.')) == NULL ||
  684.       strcmp(end, ".mbox") != 0)
  685.     end = begin + strlen(begin);
  687.   dst = buf; dstend = buf + buflen;
  688.   for (src = begin; src < end; src++) {
  690.     switch (*src) {
  692.     case '':
  693.       *dst = '';
  694.       return;
  696.     case ',':
  697.       if (dst + 2 > dstend) {
  698. *dst = '';
  699. return;
  700.       }
  701.       *dst++ = ',';
  702.       *dst++ = ' ';
  703.       break;
  705.     case '_':
  706.       *dst++ = ' ';
  707.       break;
  709.     default:
  710.       *dst++ = *src;
  711.       break;
  712.     }
  714.     if (dst+1 >= dstend) {
  715.       *dst = '';
  716.       return;
  717.     }
  718.   }
  719. }
  721. static void sf_do_file_head(int fd_out, char *title)
  722. {
  723.   fd_printf(fd_out, "<html>n");
  724.   fd_printf(fd_out, "<!-- SF archive mbox converter -->n");
  725.   fd_printf(fd_out, "<head>n");
  726.   fd_printf(fd_out, "<title>Link鰌ing Science Fiction Archive:%s</title>n", title);
  727.   fd_printf(fd_out, "<link rev="made" href="mailto:matoh@lysator.liu.se">n");
  728.   fd_printf(fd_out, "</head>n");
  729. }
  731. static void sf_do_file_body(int fd_in, int fd_out, off_t size, char *title)
  732. {
  733.   fd_printf(fd_out, "<body background="/sf_archive/background.gif">n");
  734.   fd_printf(fd_out, "<dl>n");
  735.   fd_printf(fd_out, "<dt>n");
  736.   fd_printf(fd_out, "<a href="/sf_archive/sf_main.html">n");
  737.   fd_printf(fd_out, "<img align=top src="/sf_archive/small_logo.gif" alt="[Logotype]" border=0></a>n");
  738.   fd_printf(fd_out, "<cite>The Link鰌ing Science Fiction & Fantasy Archive</cite>n");
  739.   fd_printf(fd_out, "<dd>n");
  740.   fd_printf(fd_out, "<h1>%s</h1>n", title);
  741.   fd_printf(fd_out, "<hr noshade>n");
  742.   fd_printf(fd_out, "<dl>n");
  744.   do_letter(fd_in, fd_out, size);
  746.   fd_printf(fd_out, "</dl>n");
  747.   fd_printf(fd_out, "<hr noshade>n");
  748.   fd_printf(fd_out, "<address>n");
  749.   fd_printf(fd_out, "<a href="/sf_archive/sf_main.html">Link鰌ing SF Archive</a> /n");
  750.   fd_printf(fd_out, "<a href="/sf_archive/matoh.html">Mats 謍rman</a>n");
  751.   fd_printf(fd_out, "</address>n");
  752.   fd_printf(fd_out, "</dl>n");
  753.   fd_printf(fd_out, "</body>n");
  754.   fd_printf(fd_out, "</html>n");
  755. }
  757. static void sf_do_all(int fd_in, int fd_out, char *url, off_t size)
  758. {
  759.   char title[256];
  761.   sf_fix_title(url, title, sizeof(title));
  762.   sf_do_file_head(fd_out, title);
  763.   sf_do_file_body(fd_in, fd_out, size, title);
  764. }
  766. #endif
  769. static void fix_title(char *title, char *buf, int buflen)
  770. {
  771.   char *begin;
  772.   char *end;
  773.   int len;
  774.   int i;
  776.   if ((begin = strrchr(title, '/')) == NULL)
  777.     begin = title;
  778.   else 
  779.     begin++;
  781.   if ((end = strrchr(begin, '.')) == NULL ||
  782.       strcmp(end, ".mbox") != 0)
  783.     len = strlen(begin);
  784.   else
  785.     len = end - begin;
  787.   if (len > buflen - 1)
  788.     len = buflen - 1;
  790.   for (i = 0; i < len; i++) {
  791.     buf[i] = begin[i];
  792.   }
  793.   buf[i] = '';
  794. }
  796. static void do_file_head(int fd_out, char *title, char *url)
  797. {
  798.   fd_puts("<html>n",    fd_out);
  799.   fd_puts("<head>n",    fd_out);
  800. #if 0
  801.   fd_printf(fd_out, "<base href="%s%s">n", server_url, url);
  802. #endif
  803.   fd_puts("<title>",     fd_out);
  804.   fd_escape_puts(title, fd_out);
  805.   fd_puts("</title>n",  fd_out);
  806.   fd_puts("</head>n",   fd_out);
  807. }
  809. static void do_file_body(int fd_in, int fd_out, off_t size, char *title)
  810. {
  811.   fd_printf(fd_out, "<body>n");
  812.   fd_printf(fd_out, "<h1>");
  813.   fd_escape_puts(title, fd_out);
  814.   fd_printf(fd_out, "</h1>n");
  815.   fd_printf(fd_out, "<dl>n");
  817.   do_letter(fd_in, fd_out, size);
  819.   fd_printf(fd_out, "</dl>n");
  820.   fd_printf(fd_out, "</body>n");
  821.   fd_printf(fd_out, "</html>n");
  822. }
  824. static void do_num_file_body(int fd_in, int fd_out, off_t size, 
  825.     int n, char *title)
  826. {
  827.   fd_printf(fd_out, "<body>n");
  828.   fd_printf(fd_out, "<h1>");
  829.   fd_escape_puts(title, fd_out);
  830.   fd_printf(fd_out, ": %d</h1>n", n);
  831.   fd_printf(fd_out, "<dl>n");
  833.   do_num_letter(fd_in, fd_out, size, n);
  835.   fd_printf(fd_out, "</dl>n");
  836.   fd_printf(fd_out, "</body>n");
  837.   fd_printf(fd_out, "</html>n");
  838. }
  840. static void do_rnum_file_body(int fd_in, int fd_out, off_t size, 
  841.     int n, char *title)
  842. {
  843.   fd_printf(fd_out, "<body>n");
  844.   fd_printf(fd_out, "<h1>");
  845.   fd_escape_puts(title, fd_out);
  846.   fd_printf(fd_out, ": %d</h1>n", n);
  847.   fd_printf(fd_out, "<dl>n");
  849.   do_rnum_letter(fd_in, fd_out, size, n);
  851.   fd_printf(fd_out, "</dl>n");
  852.   fd_printf(fd_out, "</body>n");
  853.   fd_printf(fd_out, "</html>n");
  854. }
  856. static void do_index_body(int fd_in, int fd_out, off_t size, char *title, char *url)
  857. {
  858.   fd_printf(fd_out, "<body>n");
  859.   fd_printf(fd_out, "<h1><a href="%s">", url);
  860.   fd_escape_puts(title, fd_out);
  861.   fd_printf(fd_out, "</a>");
  862.   fd_printf(fd_out, ": Index</h1>n");
  863.   fd_printf(fd_out, "<dl compact>n");
  865.   do_index_entries(fd_in, fd_out, size, url);
  867.   fd_printf(fd_out, "</dl>n");
  868.   fd_printf(fd_out, "</body>n");
  869.   fd_printf(fd_out, "</html>n");
  870. }
  872. static void do_rindex_body(int fd_in, int fd_out, off_t size, char *title, char *url)
  873. {
  874.   fd_printf(fd_out, "<body>n");
  875.   fd_printf(fd_out, "<h1><a href="%s">", url);
  876.   fd_escape_puts(title, fd_out);
  877.   fd_printf(fd_out, "</a>");
  878.   fd_printf(fd_out, ": Reverse Index</h1>n");
  879.   fd_printf(fd_out, "<dl compact>n");
  881.   do_rindex_entries(fd_in, fd_out, size, url);
  883.   fd_printf(fd_out, "</dl>n");
  884.   fd_printf(fd_out, "</body>n");
  885.   fd_printf(fd_out, "</html>n");
  886. }
  888. static void do_id_index_body(int fd_in, int fd_out, off_t size, char *title, char *url)
  889. {
  890.   fd_printf(fd_out, "<body>n");
  891.   fd_printf(fd_out, "<h1><a href="%s">", url);
  892.   fd_escape_puts(title, fd_out);
  893.   fd_printf(fd_out, "</a>");
  894.   fd_printf(fd_out, ": Index</h1>n");
  895.   fd_printf(fd_out, "<dl compact>n");
  897.   do_id_index_entries(fd_in, fd_out, size, url);
  899.   fd_printf(fd_out, "</dl>n");
  900.   fd_printf(fd_out, "</body>n");
  901.   fd_printf(fd_out, "</html>n");
  902. }
  904. static void do_id_rindex_body(int fd_in, int fd_out, off_t size, char *title, char *url)
  905. {
  906.   fd_printf(fd_out, "<body>n");
  907.   fd_printf(fd_out, "<h1><a href="%s">", url);
  908.   fd_escape_puts(title, fd_out);
  909.   fd_printf(fd_out, "</a>");
  910.   fd_printf(fd_out, ": Index</h1>n");
  911.   fd_printf(fd_out, "<dl compact>n");
  913.   do_id_rindex_entries(fd_in, fd_out, size, url);
  915.   fd_printf(fd_out, "</dl>n");
  916.   fd_printf(fd_out, "</body>n");
  917.   fd_printf(fd_out, "</html>n");
  918. }
  920. static void do_all(int fd_in, int fd_out, char *url, off_t size)
  921. {
  922.   char title[256];
  924.   fix_title(url, title, sizeof(title));
  925.   do_file_head(fd_out, title, url);
  926.   do_file_body(fd_in, fd_out, size, title);
  927. }
  929. static void do_index(int fd_in, int fd_out, char *url, off_t size)
  930. {
  931.   char title[256];
  933.   fix_title(url, title, sizeof(title));
  934.   do_file_head(fd_out, title, url);
  935.   do_index_body(fd_in, fd_out, size, title, url);
  936. }
  938. static void do_rindex(int fd_in, int fd_out, char *url, off_t size)
  939. {
  940.   char title[256];
  942.   fix_title(url, title, sizeof(title));
  943.   do_file_head(fd_out, title, url);
  944.   do_rindex_body(fd_in, fd_out, size, title, url);
  945. }
  947. static void do_id_index(int fd_in, int fd_out, char *url, off_t size)
  948. {
  949.   char title[256];
  951.   fix_title(url, title, sizeof(title));
  952.   do_file_head(fd_out, title, url);
  953.   do_id_index_body(fd_in, fd_out, size, title, url);
  954. }
  956. static void do_id_rindex(int fd_in, int fd_out, char *url, off_t size)
  957. {
  958.   char title[256];
  960.   fix_title(url, title, sizeof(title));
  961.   do_file_head(fd_out, title, url);
  962.   do_id_rindex_body(fd_in, fd_out, size, title, url);
  963. }
  965. static void do_num_search(int fd_in, int fd_out, 
  966.   char *num, char *url, off_t size)
  967. {
  968.   char title[256];
  969.   int n;
  971.   n = atoi(num);
  973.   fix_title(url, title, sizeof(title));
  974.   do_file_head(fd_out, title, url);
  975.   do_num_file_body(fd_in, fd_out, size, n, title);
  976. }
  978. static void do_rnum_search(int fd_in, int fd_out, 
  979.   char *num, char *url, off_t size)
  980. {
  981.   char title[256];
  982.   int n;
  984.   n = atoi(num);
  986.   fix_title(url, title, sizeof(title));
  987.   do_file_head(fd_out, title, url);
  988.   do_rnum_file_body(fd_in, fd_out, size, n, title);
  989. }
  991. static int http_get_head(struct connectioninfo *cip)
  992. {
  993.     char buf[256], *s_since;
  994.     char path[1025];
  995.     struct stat sb;
  996.     int fd_in, i, status, result;
  997.     int fd_out = cip->fd;
  998.     struct httpinfo *hip = cip->hip;
  999.     
  1000.     
  1001.     if (debug > 1)
  1002. fprintf(stderr, "*** mbox/pm_get() called ***n");
  1004.     if (url_expand(hip->url, path, sizeof(path), &sb, NULL, NULL) == NULL)
  1005. return -1;
  1006.     
  1007.     if (hip->mip &&
  1008. (s_since = mime_getheader(hip->mip, "IF-MODIFIED-SINCE", 1)))
  1009.     {
  1010.         struct tm tm_since;
  1011. int t_since;
  1014. t_since = atotm(s_since, &tm_since);
  1015. if (t_since != -1)
  1016. {
  1017.     if (sb.st_mtime <= (time_t) t_since)
  1018.         return http_not_modified(cip);
  1019. }
  1020. else
  1021. {
  1022.     /* Could not parse the date format - do a string compare */
  1023.     http_time_r(&sb.st_mtime, buf, sizeof(buf));
  1024.     i = strlen(buf);
  1025.     buf[i-1] = '';
  1026.     
  1027.     if (strcmp(s_since, buf) == 0)
  1028.         return http_not_modified(cip);
  1029. }
  1030.     }
  1032.     fd_in = s_open(path, O_RDONLY);
  1033.     if (fd_in < 0)
  1034.     {
  1035. if (debug)
  1036.     perror("open(path)");
  1038. return -1;
  1039.     }
  1040.     
  1041.     result = 200;
  1042.     
  1043.     if (hip->mip != NULL)
  1044.     {
  1045. http_sendheaders(fd_out, cip, result, NULL);
  1046. http_sendlastmodified(fd_out, sb.st_mtime);
  1048. fd_puts("Content-Type: text/htmlnn", fd_out);
  1049.     }
  1050. #if 0
  1051.     hip->length = sb.st_size;
  1052. #endif
  1053.     
  1054.     if (hip->mip != NULL)
  1055. fd_putc('n', fd_out);
  1057.     if (strcasecmp(hip->method, "HEAD") == 0)
  1058.     {
  1059. s_close(fd_in);
  1060. return result;
  1061.     }
  1063. #ifdef SF_ARCHIVE
  1064.     if (strncmp(hip->url, "/sf_archive/", strlen("/sf_archive/")) == 0) {
  1065.       sf_do_all(fd_in, fd_out, hip->url, sb.st_size);
  1066.     } else {
  1067.       if (hip->request == NULL) {
  1068. #if 0
  1069. do_all(fd_in, fd_out, hip->url, sb.st_size);
  1070. #else
  1071. do_rindex(fd_in, fd_out, hip->url, sb.st_size);
  1072. #endif
  1073.       } else if (strcasecmp(hip->request, "all") == 0) {
  1074. do_all(fd_in, fd_out, hip->url, sb.st_size);
  1075.       } else if (strcasecmp(hip->request, "index") == 0) {
  1076. do_index(fd_in, fd_out, hip->url, sb.st_size);
  1077.       } else if (strcasecmp(hip->request, "rindex") == 0) {
  1078. do_rindex(fd_in, fd_out, hip->url, sb.st_size);
  1079.       } else if (strcasecmp(hip->request, "id_index") == 0) {
  1080. do_id_index(fd_in, fd_out, hip->url, sb.st_size);
  1081.       } else if (strcasecmp(hip->request, "id_rindex") == 0) {
  1082. do_id_rindex(fd_in, fd_out, hip->url, sb.st_size);
  1083.       } else if (all_digits(hip->request)) {
  1084. do_num_search(fd_in, fd_out, hip->request, hip->url, sb.st_size);
  1085.       } else if ((hip->request[0] == 'r' || hip->request[0] == '-' ) && 
  1086.  all_digits(hip->request + 1)) {
  1087. do_rnum_search(fd_in, fd_out, hip->request+1, hip->url, sb.st_size);
  1088.       } else {
  1089. #if 0
  1090. do_all(fd_in, fd_out, hip->url, sb.st_size);
  1091. #else
  1092. do_rindex(fd_in, fd_out, hip->url, sb.st_size);
  1093. #endif
  1094.       }
  1095.     }    
  1096. #else
  1097.     do_all(fd_in, fd_out, hip->url, sb.st_size);
  1098. #endif
  1100.     status = s_close(fd_in);
  1101.     if (status < 0)
  1102. if (debug)
  1103. {
  1104.     fprintf(stderr, "ERROR on #%d: ", cip->request_no);
  1105.     perror("close");
  1106. }
  1108.     if (debug > 2)
  1109. fprintf(stderr, "modules/mbox/http_get: Returningn");
  1110.     
  1111.     return result;
  1112. }
  1115. int pm_request(struct connectioninfo *cip)
  1116. {
  1117.     struct httpinfo *hip = cip->hip;
  1118.     
  1119.     if (strcasecmp(hip->method, "GET") == 0 ||
  1120. strcasecmp(hip->method, "HEAD") == 0)
  1121. return http_get_head(cip);
  1122.     else
  1123. return -2;
  1124. }