ezmlm-cgi.c

Go to the documentation of this file.

#include <sys/types.h>
#include <unistd.h>
#include "alloc.h"
#include "direntry.h"
#include "datetime.h"
#include "now.h"
#include "stralloc.h"
#include "logmsg.h"
#include "error.h"
#include "env.h"
#include "sig.h"
#include "open.h"
#include "getln.h"
#include "case.h"
#include "scan.h"
#include "str.h"
#include "fmt.h"
#include "readwrite.h"
#include "wait.h"
#include "exit.h"
#include "buffer.h"
#include "getconf.h"
#include "alloc.h"
#include "constmap.h"
#include "byte.h"
#include "subscribe.h"
#include "errtxt.h"
#include "makehash.h"
#include "mime.h"
#include "idx.h"
#include "date2yyyymm.h"
#include "cgi.h"
#include "constmap.h"
 
#define WHO "ezmlm-cgi"

 
#define SUBSCRIBE "-subscribe"
#define FAQ "-faq"
#define TXT_CGI_SUBSCRIBE "\">[Subscribe To List]</a>\n"
#define TXT_CGI_FAQ "\">[List FAQ]</a>\n"
 
int flagshowhtml = 1;    /* show text/html parts. This leads to duplication */
                         /* when both text/plain and text/html are in a     */
                         /* multipart/alternative message, but it is assumed*/
                         /* that text/html is not frivolous, but only used  */
                         /* when the formatting is important. */
int flagobscure = 0;     /* Don't remove Sender's E-mail address in message path. */
                         /* Overridden by config file (- before list name). */
 
/**************** Header processing ***********************/
char headers_used[] = "Subject\\From\\Date\\content-type\\"
        "content-transfer-encoding\\mime-version";
/* index of headers displayed (shown in order listed above) */
int headers_shown[] = {1,1,1,0,0,0};
/* index of specific headers */
#define NO_HDRS     6
#define HDR_SUBJECT 1
#define HDR_FROM    2
#define HDR_CT      4
#define HDR_CTENC   5
#define HDR_VERSION 6
 
/* Need to add inits if you increase NO_HDRS */
stralloc hdr[NO_HDRS] = { {0},{0},{0},{0},{0},{0} };
/**************** Header processing ***********************/
 
 
/* index of subject in above, first = 1 */
 
/* TODO: Sort headers before display. Find a way to display the body with the */
/* correct charset, ideally letting the browser do the work (should really */
/* be able to specify charset for DIV !) */
 
/* ulong at least 32 bits. (Creating a Year 0xffffff problem ;-) */
#define MAXULONG 0xffffffff
 
/* navigation: navstr[0] = {m,s,a,d,i} ; item (message, subject, author, date, index) */
/*             navstr[1] = {m,s,a}     ; view (no date, no index) */
/*             navstr[2] = {p,s,n,p,n} ; direction (previous, same, next, previous, next) */
/* SHOULD:     navstr[2] = {F,p,s,n,L} ; direction (First, previous, same, next, Last) */
 
char navstr[5] = "xxx:";
#define VIEW "-msadiz"
#define VIEW_MESSAGE 1
#define VIEW_TOPIC   2                 // build up by ezmlm-archive ./archive/subjects/[ab]
#define VIEW_AUTHOR  3                 // build up by ezmlm-archive; ./archive/authors/[ab] 
#define VIEW_DATE    4                 // no such peristent thing; p -> s -> n message
#define VIEW_INDEX   5                 // generic ./archive; indexed by ezmlm-idx => ./archive/[n]/index
 
#define DIRECT "psnpnz"                // toggle: p->s->n->p->n
#define DIRECT_SAME  0
#define DIRECT_NEXT  1
#define DIRECT_PREV -1                 /* use only as the argument for some functions. Terrible hack for date links (fixed) */
#define DIRECT_FIRST 3
#define DIRECT_LAST  2
 
char *dir = 0;
char *local = 0;
char *host = 0;
char *home = 0;
char *banner = 0;
const char *charset = 0;
char *stylesheet = 0;
char *cntl = 0;                          // three character control code => navstr
char strnum[FMT_ULONG];
/* these are the only headers we really care about for message display */
/* one can always retrieve the complete message by E-mail */
stralloc charg = {0};
stralloc url = {0};
stralloc author = {0};
stralloc subject = {0};
stralloc base = {0};
stralloc line = {0};
stralloc decline = {0};                /* for rfc2047-decoded headers and QP/base64 */
stralloc cfline = {0};                 /* from config file */
stralloc fname = {0};
stralloc dtline = {0};
stralloc headers = {0};
stralloc encoding = {0};
stralloc content = {0};
stralloc charsetbase = {0};
stralloc curcharset = {0};
stralloc sainit = {0};
stralloc listname = {0};
struct constmap headermap;
unsigned long uid,euid;
int recursion_level;
int so = 0;
int ss23 = 0;
int state = 0;
int newlevel;
int match;                             /* used everywhere and no overlap */
int fd;                                /* same; never >1 open */
int cache;                             /* 0 = don't; 1 = don't know; 2 = do */
int child, wstat;
int flagtoplevel;
unsigned int flagmime;
unsigned int cs, csbase, pos;
int flagrobot;
int flagpre;
int precharcount;
char cn1 = 0;
char cn2 = 0;
char lastjp[] = "B";                   /* to get back to the correct JP after line break */
char *bannerargs[4];                   // external banner does not work  --eh
 
 
struct msginfo {                       /* clean info on the target message */
  char item;                           /* What we want (= message) */
  char view;                           /* View of desired items */
  int  direction;                      /* Relation to current view [may be calculated] */
  unsigned long source;                /* reference message number */
  unsigned long target;
  unsigned long date;
  unsigned long *authnav;              /* msgnav structure */
  unsigned long *subjnav;              /* msgnav structure */
  char *author;
  char *subject;
  char *cgiarg;                        /* sub/auth as expected from view */
} msginfo;
 
mime_info *mime_current = 0;
mime_info *mime_tmp = 0;
 
datetime_sec when;
struct datetime dt;
 
char inbuf[4096];
buffer bi;
 
static void die_nomem() { logmsg(WHO,111,FATAL,ERR_NOMEM); }
static void die_syntax(const char *s) { logmsg(WHO,100,ERROR,B(ERR_SYNTAX,"ezcgirc: ",s)); }
 
char outbuf[4096];
buffer bo = BUFFER_INIT(write,1,outbuf,sizeof(outbuf));
 
void oput(const char *s,unsigned int l)
{
  if (buffer_put(&bo,s,l) == -1)
    logmsg(WHO,111,FATAL,B(ERR_WRITE,"stdout"));
}
 
void oputs(const char *s)
{
  oput(s,str_len(s));
}
 
/* this error is for things that happen only if program logic is screwed up */
 
void die_prog(const char *s) 
{ 
  logmsg(WHO,100,FATAL,B("program error (please send bug report to ezmlmx@fehcom.de): ",s," Command: ",cntl));
 }

 
void cgierr(const char *s,const char *s1,const char *s2)
{
  logmsg(WHO,0,WARN,B("cgierr: ",s,s1,s2));
  oputs("Content-type: text/html\n");
  oputs("Status: 404 \n\n");
  oputs("<html>\n <head> </head> <body> \n");
  oputs("<h3><strong>ezmlm-cgi</strong>: <tt> ");
  if (s) oputs(s);
  if (s1) oputs(s1);
  if (s2) oputs(s2);
  oputs("</tt></h3>\n</body>\n</html>\n");
  buffer_flush(&bo);
  _exit(0);
}
 
unsigned long msgnav[5]; /* 0 prev prev 1 prev 2 this 3 next 4 next-next */
 
void toggle_flagpre(int flag)
{
  flagpre = flag;
  precharcount = 0;
  cn1 = 0; cn2 = 0;        /* just in case */
}

 
unsigned int decode_charset(const char *s,unsigned int l)
{
  if (case_startb(s,l,"iso-8859") || case_startb(s,l,"us-ascii") ||
      case_startb(s,l,"utf"))     /* at the moment, we can do utf-8 right */
    return CS_NONE;               /* what is utf-7 (used by OE)? */
  if (case_startb(s,l,"x-cp") ||
    case_startb(s,l,"cp") ||
    case_startb(s,l,"x-mac") ||
    case_startb(s,l,"koi8")) return CS_NONE;
  if (!l || *s == 'x' || *s == 'X') return CS_BAD;
  if (case_startb(s,l,"iso-2022")) {
    if (case_startb(s+8,l-8,"-cn"))
      return CS_2022_CN;
    if (case_startb(s+8,l-8,"-jp"))
      return CS_2022_JP;
    return CS_2022_KR;
  }
  if (case_startb(s,l,"cn-") ||
      case_startb(s,l,"hz-gb") ||
      case_startb(s,l,"gb") ||
      case_startb(s,l,"big5"))
    return CS_CN;                 /* Only consideration for linebreak */
  if (case_startb(s,l,"iso_8859") ||
      case_startb(s,l,"latin") ||
      case_startb(s,l,"windows")) return CS_NONE;
  return CS_BAD;
}

 
void html_put (const char *s,unsigned int l)
{
  if (!cs) {                                     /* us-ascii & iso-8859- & unrecognized */
    for (;l--;s++) {
      precharcount++;
      switch (*s) {
        case '>':  oputs("&gt;"); break;
        case '<':  oputs("&lt;"); break;
        case '"':  oputs("&quot;"); break;
        case '&':  oputs("&amp;"); break;
        case '\n': precharcount = 0; oput(s,1); break;
        case ' ':  if (precharcount >= 84 && flagpre) {
                     oput("\n",1);               /* in place of ' ' */
                     precharcount = 0;
                   } else
                     oput(s,1);                  /* otherwise out with it. */
                   break;
        default:   oput(s,1); break;
      }
    }
  } else if (cs == CS_CN) {                      /* cn-, gb*, big5 */
    for (;l--;s++) {
      precharcount++;
      if (cn1) { cn2 = cn1; cn1 = 0; }           /* this is byte 2 */
      else { cn2 = 0; cn1 = *s & 0x80; }         /* this is byte 1/2 or ascii */
      if (!cn1 && !cn2) {                        /* ascii */
        switch (*s) {
          case '>':  oputs("&gt;"); break;
          case '<':  oputs("&lt;"); break;
          case '"':  oputs("&quot;"); break;
          case '&':  oputs("&amp;"); break;
          case '\n': precharcount = 0; oput(s,1); break;
          case ' ':  if (precharcount >= 84 && flagpre) {
                       oput("\n",1);             /* break in ascii sequence */
                       precharcount = 0;
                     } else
                       oput(s,1);
                     break;
          default:   oput(s,1); break;
        }
      } else if (precharcount >= 84 && flagpre && cn2) {
        oput("\n",1);                            /* break after 2-byte code */
        precharcount = 0;
      }
    }
  } else {                                       /* iso-2022 => PAIN! */
    for (; l--; s++) {
      precharcount++;
      if (ss23) {                                /* ss2/ss3 character */
        ss23--;
        oput(s,1);
        continue;
      }
      if (so) {                                  /* = 0 ascii, = 1 SO charset */
        if (!(*s & 0xe0)) {                      /* ctrl-char */
          switch (*s) {
           case ESC:  state = 1; break;
           case SI:   so = 0; break;
           case '\n': precharcount = 0; break;
           default:   break;
         }
       }
      oput(s,1);
      } else {                                   /* check only ascii */
        switch (*s) {
          case '>': oputs("&gt;"); break;
          case '<': oputs("&lt;"); break;
          case '"': oputs("&quot;"); break;
          case '&': oputs("&amp;"); break;
          case ' ': if (precharcount >= 84 && flagpre) {
                      oput("\n",1);              /* break in ascii sequence */
                      precharcount = 0;
                    } else
                      oput(s,1);
                    break;
          default: oput(s,1);
                   if (!(*s & 0xe0)) {
                     switch (*s) {
                       case SO: so = 1; break;
                       case ESC: state = 1; break;
                       case SI: so = 0; break;   /* shouldn't happen */
                       case '\n': precharcount = 0; break;
                       default: break;
                     }
                   }
        }
      }                                
 
      /* by now all output is done, now ESC interpretation */
 
      if (state) {
        /* ESC code - don't count */
        if (precharcount) precharcount--;
        state++;
        switch (state) {
          case 2:  break;                        /* this was the ESC */
          case 3:  switch (*s) {
                     case 'N': ss23 = (cs & 1) + 1; state = 0; break;
                     case 'O': ss23 = 2; state = 0; break;
                     case '(': state = 20; so = 0; break; /* JP ascii */
                     case '$': break;            /* var S2/SS2/SS3 des*/
                     case '.': state = 10;       /* g3 settings, one more char */
                     default:  state = 0; break; /* or JP */
                   }
                   break;
          case 4:  switch (*s) {                 /* s2/ss2/ss3 or JP 2 byte shift */
                    case 'B':
                    case '@': lastjp[0] = *s;
                              so = 1; state = 0; break; /* JP */
                    default:  break;             /* other SS2/3 des */
                   }
                   break;
          case 5:  state = 0; break;             /* 4th char of ESC $ *|+|) X */
          case 11: state = 0; break;             /* 3nd char of ESC . */
          case 21: state = 0; break;             /* ESC ( X for JP */
          default: die_prog("bad state in html_put"); break;
        }
      } else if (so && flagpre && precharcount >= 84) {
        /* 84 is nicer than 78/80 since most use GUI browser */
        /* iso-2022-* line splitter here. SO only, SI done above */
        /* For JP need even precharcount, add ESC ( B \n ESC $B */
          if (so && !(precharcount & 1)) {       /* even */
            precharcount = 0;                    /* reset */
            if (cs == CS_2022_JP) {              /* JP uses ESC like SI/SO */
              oputs(TOASCII);
              oput("\n",1);
              oputs(TOJP);
              oput(lastjp,1);
            } else {
              if (so) {
        /* For iso-2022-CN: nothing if SI, otherwise SI \n SO */
        /* For iso-2022-KR same */
                oputs(SI_LF_SO);
              } else
                oput("\n",1);
            } 
          }
        }
    }  // end for loop
  }  // end else
}
 
char hexchar[] = "0123456789ABCDEF";
char enc_url[] = "%00";
 
void urlencode_put(const char *s,unsigned int l)
{
  for (; l--; s++) {
    unsigned char ch;
    ch = (unsigned char) *s;
    if (ch <= 32 || ch > 127 || byte_chr("?<>=/:%+#\"",10,ch) != 10) {
      enc_url[2] = hexchar[ch & 0xf];
      enc_url[1] = hexchar[(ch >> 4) & 0xf];
      oput(enc_url,3);
    } else
      oput(s,1);
  }
}
 
void urlencode_puts(const char *s)
{
  urlencode_put(s,str_len(s));
}
 
void anchor_put(unsigned char *s,unsigned int l)
{
  unsigned char *cpl, *cpafter, *cpstart, *cpend;
  unsigned int pos, i;
 
  pos = byte_chr(s,l,':'); //+
  if (pos + 3 >= l || !pos) {                    /* no ':' no URL (most lines) */
    html_put(s,l);
    return;
  }
 
  cpl = s;
  cpafter = s + l;
  for (;;) {
    cpstart = (char *) 0;
    if (s[pos + 1] == '/' && s[pos + 2] == '/') {
      cpend = s + pos + 2;
 
      for (i = pos - 1; (i < l && i + 6 >= pos); i--) {     /* pos always >=1 */
        if ((s[i] < 'a' || s[i] > 'z') && (s[i] < 'A' || s[i] > 'Z')) {
          cpstart = s + i + 1;                   /* "[:alpha:]{1,5}://" accepted */
          break;
        }
        if (!i && i + 6 < pos) {
          cpstart = s;
          break;
        }
      }
    }
    if (cpstart) {                               /* found URL */
      while (cpend < cpafter && str_chr(" \t\n",*cpend) == 3) 
        cpend++;
      cpend--;                                   /* locate end */
      while (cpend > cpstart && str_chr(".,;])>\"\'",*cpend) != 8) 
        cpend--;
      html_put(cpl,cpstart - cpl);               /* std txt */
      oputs("<a href=\"");                       /* link start */
      oput(cpstart,cpend - cpstart + 1);         /* link */
      oputs("\">");
      html_put(cpstart,cpend - cpstart + 1);     /* visible */
      oputs("</a>");                             /* end */
      cpl = cpend + 1;
      pos = cpend - s;
      if (pos >= l) return;
    } else
      pos++;
 
    pos += byte_chr(s + pos,l - pos,':'); //*
    if (pos + 3 >= l) {
      html_put(cpl,cpafter - cpl);               /* std txt */
      return;
    }
  }
}
 
int checkhash(const char *s)
{
  int l = HASHLEN;
  while (l--) {
    if (*s < 'a' || *s > 'p') return 0;          /* illegal */
    s++;
  }
  if (*s) return 0;                              /* extraneous junk */
  return 1;
}

 
int uri2fn(stralloc *sa,char item,unsigned long n,const char *hash)
{
  if (!stralloc_copys(sa,"archive/")) die_nomem();
  if (item == VIEW_MESSAGE) {
    if (!stralloc_catb(sa,strnum,fmt_ulong(strnum,n/100))) die_nomem();
    if (!stralloc_cats(sa,"/")) die_nomem();
    if (!stralloc_catb(sa,strnum,fmt_uint0(strnum,(unsigned int) (n%100),2))) die_nomem();
  } else if (item == VIEW_DATE) {
    if (!stralloc_cats(sa,"threads/")) die_nomem();
    if (!stralloc_catb(sa,strnum,fmt_ulong(strnum,n)))
    die_nomem();
  } else if (item == VIEW_INDEX) {
    if (!stralloc_catb(sa,strnum,fmt_ulong(strnum,n/100))) die_nomem();
    if (!stralloc_cats(sa,"/index")) die_nomem();
  } else {
    if (item == VIEW_AUTHOR) {
      if (!stralloc_cats(sa,"authors/")) die_nomem();
    } else {
      if (!stralloc_cats(sa,"subjects/")) die_nomem();
    }
    if (!hash) return 0; 
    if (!stralloc_catb(sa,hash,2)) die_nomem();
    if (!stralloc_cats(sa,"/")) die_nomem();
    if (!stralloc_catb(sa,hash + 2,HASHLEN - 2)) die_nomem();
  }
  if (!stralloc_0(sa)) die_nomem();
 
  return 1;
}

 
void alink(struct msginfo *infop,unsigned char item,unsigned char view,
           unsigned long msgnum,const char *data,unsigned int l)
{
  const char *cp;
 
  cp = (const char *) 0;
  if (view == VIEW_TOPIC && infop->target == msgnum)
    oputs("<a name=\"b\"></a>");
 
  oput(url.s,url.len);
  navstr[0] = VIEW[item];
  navstr[1] = VIEW[view];
  navstr[2] = DIRECT[DIRECT_SAME + 1];           // DIRECT_NEXT
  
  if (item == VIEW_MESSAGE && view == VIEW_AUTHOR) {
    if (infop->subject) {
      navstr[1] = VIEW[VIEW_TOPIC];
      cp = infop->subject;                       /* always HASLEN in length due to decode_cmd */
    }
  }
  oputs(navstr);                                 /* e.g. map: */
  oput(strnum,fmt_ulong(strnum,msgnum));
  if (!cp && l >= HASHLEN)
    cp = data;
  if (infop->date) {
    oput(":",1); //+
    oput(strnum,fmt_ulong(strnum,infop->date));
  }
  if (cp) {
    oput(":",1); //
    oput(cp,HASHLEN);
  }
  switch (item) {
    case VIEW_MESSAGE: oputs("\" class=\"mlk\">"); break;
    case VIEW_AUTHOR:  oputs("#b\" class=\"alk\">"); break;
    case VIEW_TOPIC:   oputs("#b\" class=\"slk\">"); break;
    default: oputs("#b\">"); break;
  }
  if (HASHLEN + 1 < l)
    html_put(data + HASHLEN + 1,l - HASHLEN - 1);
  else
    oputs("(none)");
  oputs("</a>");
}

 
void index_messages(struct msginfo *infop,unsigned char item)
{
  oput(url.s,url.len);
  navstr[0] = VIEW[item];
  navstr[1] = VIEW[item];
  navstr[2] = DIRECT[DIRECT_SAME + 1];
  unsigned char c = navstr[2];
  if (c != 's' && c != 'p' && c != 'n') navstr[2] = 'p';
  navstr[3] = ':';
  oputs(navstr);                                 /* e.g. map: */
  oput(strnum,fmt_ulong(strnum,infop->target));
 
  if (infop->date) {
    oput(":",1); // +
    oput(strnum,fmt_ulong(strnum,infop->date));
  }
 
  switch (item) {
    case VIEW_AUTHOR: if (infop->author) {
                        oput(":",1); //
                        oputs(infop->author);
                      } break;
    case VIEW_TOPIC:  if (infop->subject) {
                        oput(":",1); // +
                        oputs(infop->subject);
                      } break;
    default:          break;
  }
  oputs("#b\"");
}

 
void nav_links(struct msginfo *infop,unsigned char view,unsigned char direction)
{
  unsigned long msgnum;
  char *acc;
 
  oput(url.s,url.len);
  navstr[0] = VIEW[VIEW_MESSAGE];
  navstr[1] = VIEW[view];
  navstr[2] = DIRECT[direction + 1];   // DIRECT_PREV = -1 ;-)
  unsigned char c = navstr[2];
  if (c != 's' && c != 'p' && c != 'n') navstr[2] = 'p';   // UB fix
  navstr[3] = ':';
  msgnum = infop->target;
  acc = 0;
 
  switch (view) {
    case VIEW_TOPIC:   if (infop->subject) acc = infop->subject;
                       if (infop->subjnav) {     /* translate to message navigation */
                         if (infop->subjnav[direction]) {
                           msgnum = infop->subjnav[direction];
                           navstr[2] = DIRECT[DIRECT_SAME + 1];
                         }
                       }
                       acc = infop->subject; break;
    case VIEW_AUTHOR:  if (infop->author) acc = infop->author;
                       if (infop->authnav) {     /* translate to message navigation */
                         if (infop->authnav[direction]) {
                           msgnum = infop->authnav[direction];
                           navstr[2] = DIRECT[DIRECT_SAME + 1];
                         }
                       }
                       acc = infop->author; break;
    default:           break;
  }
 
  oputs(navstr);
  oput(strnum,fmt_ulong(strnum,msgnum));
 
  if (acc) {
    oputs(":"); //+
    oputs(acc);
  }
  oputs("\">");
}
 
void justpress()
{
  oputs("?subject=");
  urlencode_puts("Just Click \"SEND\"!");
}
 
void home_link()
{
  const char *cp, *cp1, *cp2;
 
  if (home && *home) {
    cp = home;
    for(;;) {
      cp1 = cp;
      while (*cp1 && *cp1 != '=') 
        cp1++;
      if (!*cp1) break;
      cp2 = cp1;
      while (*cp2 && *cp2 != ',') cp2++;
      oputs("<a href=\"");
      oput(cp1 + 1,cp2 - cp1 - 1);
      oputs("\">");
      oput(cp,cp1 - cp);
      oputs("</a>\n");
      if (!*cp2) break;
      cp = cp2 + 1;
    }
  }
}
 
void subfaq_link()
{
  oputs("<a href=\"mailto:");
  oputs(local);
  oputs(SUBSCRIBE);
  oputs("@");
  oputs(host);
  justpress();
  oputs(TXT_CGI_SUBSCRIBE);
  oputs("<a href=\"mailto:");
  oputs(local);
  oputs(FAQ);
  oputs("@");
  oputs(host);
  justpress();
  oputs(TXT_CGI_FAQ);
}

 
void message_links(struct msginfo *infop)
{
  oputs("<div class=msglinks><strong>Messages by: \n");
 
  nav_links(infop,VIEW_TOPIC,DIRECT_PREV);  // <- topic ->
  oputs("[&larr;</a> ");
  index_messages(infop,VIEW_TOPIC);
  oputs(">topic</a> ");
  nav_links(infop,VIEW_TOPIC,DIRECT_NEXT);
  oputs("&rarr;]</a> \n");
 
  nav_links(infop,VIEW_MESSAGE,DIRECT_PREV); // <- date ->
  oputs("[&larr;</a> ");
  index_messages(infop,VIEW_INDEX);
  oputs(">time</a> ");
  nav_links(infop,VIEW_MESSAGE,DIRECT_NEXT);
  oputs("&rarr;]</a> \n");
 
  nav_links(infop,VIEW_AUTHOR,DIRECT_PREV);  // <- author ->
  oputs("[&larr;</a> ");
  index_messages(infop,VIEW_AUTHOR);
  oputs(">author</a> ");
  nav_links(infop,VIEW_AUTHOR,DIRECT_NEXT);
  oputs("&rarr;]</a> |\n");
  index_messages(infop,VIEW_DATE);
 
  oputs(">[Topics]</a>\n");                // [Threads]
  home_link();
 
  subfaq_link();
  oputs("</strong></div>\n");
}
 
#define SPC_BASE 1
#define SPC_BANNER 2

 
void html_header(const char *t,const char *s,unsigned int l,const char *class,int flagspecial)
{
  oputs("Content-Type: text/html; charset=");
  oput(curcharset.s,curcharset.len);
 
  oputs("\nCache-Control: ");
  switch (cache) {
    case 0: oputs("no-cache"); break;            /* known upper border */
    case 1: oputs("max-age=300"); break;         /* 5 min - most lists aren't that fast*/
    case 2: oputs("max-age=1209600"); break;     /* 14 days is a long time */
  }
  oputs("\n\n");
  oputs("<!DOCTYPE html>\n<html>\n<head>\n<title>");
 
  if (local) {
    oputs(local);
    oputs("@");
    oputs(host);
    oputs(": ");
  }
  if (t) oputs(t);
  if (s) html_put(s,l);
  oputs("</title>\n");
  if (class && *class && stylesheet && *stylesheet) {
    oputs("<link href=\"");
    oputs(stylesheet);
    oputs("\" rel=\"stylesheet\" type=\"text/css\" />\n");
  }
  if (!flagrobot)    /* robot access allowed to follow */
    oputs("<meta name=\"robots\" content=\"noindex\" />\n");
  if (flagrobot < 2)
    oputs("<meta name=\"robots\" content=\"nofollow\" />\n");
  if (flagspecial & SPC_BASE)
    oput(base.s,base.len);
  oputs("</head>\n");
  if (class && *class) {
    oputs("<body class=");
    oputs(class);
    oputs(">\n");
  } else
    oputs("<body>\n");
 
}
 
void html_footer(int flagspecial)
{
  if ((flagspecial & SPC_BANNER) && banner && *banner) {
    oputs("<div class=\"banner\">\n");
    if (*banner == '<') {
      oputs(banner);
      oputs("</div>\n");
    } else { 
      // system(banner);    // still missing; cat iframe?
      logmsg(WHO,100,ERROR,"Sorry - banner programs not supported");
    }
  }
  oputs("</body>\n</html>\n");
  buffer_flush(&bo);
}
 
/* DATE functions */

 
void date_links(struct msginfo *infop,unsigned long d,char direction)
{
  oput(url.s,url.len);
  navstr[0] = VIEW[VIEW_DATE];
  navstr[1] = VIEW[VIEW_DATE];
  navstr[2] = DIRECT[direction + 1];
  oputs(navstr);
  if (direction == DIRECT_LAST)
    oput("0",1);                                 /* suppress msgnum to avoid going there */
  else
    oput(strnum,fmt_ulong(strnum,infop->target));
  oputs(":"); //+
  oput(strnum,fmt_ulong(strnum,d));
  oputs("#b\">");
 
  switch (direction) {
    case DIRECT_SAME:  if (dateline(&dtline,d) < 0) die_nomem(); 
                       oput(dtline.s,dtline.len); break;
    case DIRECT_PREV:  oputs("[&larr;]"); break; 
    case DIRECT_NEXT:  oputs("[&rarr;]"); break;
    case DIRECT_FIRST: oputs("[&lArr;]"); break;
    case DIRECT_LAST:  oputs("[&rArr;]"); break;
  }
  oputs("</a>");
}

 
void finddate(struct msginfo *infop)
{
  DIR *archivedir;
  direntry *d;
  unsigned long ddate, startdate;
  unsigned long below, above;
 
  below = 0L;
  above = MAXULONG;                              /* creating a Y 0xffffff problem */
  startdate = infop->date;
  archivedir = opendir("archive/threads/");
  if (!archivedir)
    if (errno != ENOENT)
      logmsg(WHO,111,ERROR,B(ERR_OPEN,"/archive/threads: ",dir));
    else
      logmsg(WHO,100,ERROR,B(ERR_OPEN,"/archive/threads: ",dir));
 
  while ((d = readdir(archivedir))) {            /* dxxx/ */
    if (str_equal(d->d_name,".")) continue;
    if (str_equal(d->d_name,"..")) continue;
    scan_ulong(d->d_name,&ddate);
    if (!ddate) continue;                        /* just in case some smart guy ... */
    if (startdate) {
      if (ddate > startdate && ddate < above) above = ddate;
      if (ddate < startdate && ddate > below) below = ddate;
    } else {
      if (ddate < above) above = ddate;
      if (ddate > below) below = ddate;
    }
  }
  closedir(archivedir);
 
  if (infop->direction == DIRECT_NEXT && (above != MAXULONG || !below))
    /* we always give a valid date as long as there is at least one */
    infop->date = above;
  else
    infop->date = below;
  return;
}
 
void latestdate(struct msginfo *infop,int flagfail)
{
  if (!flagfail) {
    datetime_tai(&dt,now());
    infop->date = ((unsigned long) dt.year + 2000) * 100 + dt.mon + 1;
  } else {
    infop->date = 0;
    infop->direction = DIRECT_PREV;    // DIRECT_PREV = -1;!!
    finddate(infop);
  }
}
 
void firstdate(struct msginfo *infop)
{
    infop->date = 0;
    infop->direction = DIRECT_NEXT;
    finddate(infop);
}

 
void gtdate(struct msginfo *infop,int flagfail)
{
  if (!flagfail) {                               /* guess */
    if (infop->direction == DIRECT_NEXT) {
      infop->date++;
      if (infop->date%100 > 12) infop->date += (100 - 12);
    } else if (infop->direction == DIRECT_PREV) {
      infop->date--;
      if (!infop->date%100) infop->date -= (100 - 12);
    }
  } else
    finddate(infop);
  return;
}
 
void index_links(struct msginfo *infop)
{
  unsigned long tmpmsg;
 
  tmpmsg = infop->target;
  infop->target = 1;
  oputs("<div class=idxlinks><strong>\n");
  index_messages(infop,VIEW_INDEX);
  oputs(">[&lArr;]</a>\n");
  if (tmpmsg >= 100) infop->target = tmpmsg - 100;
  index_messages(infop,VIEW_INDEX);
  oputs(">[&larr;]</a>\n");
  infop->target = tmpmsg + 100;
  index_messages(infop,VIEW_INDEX);
  oputs(">[&rarr;]</a>\n");
  infop->target = MAXULONG;
  index_messages(infop,VIEW_INDEX);
  oputs(">[&rArr;]</a> |\n");
  infop->target = tmpmsg;
  index_messages(infop,VIEW_DATE);
  oputs(">[Topics by date]</a>\n");
  subfaq_link();
  home_link();
  oputs("</strong></div>\n");
}
 
int show_index(struct msginfo *infop)
{
  unsigned long thismsg;
  unsigned int pos,l;
  char ch;
 
  uri2fn(&fname,VIEW_INDEX,msginfo.target,"");
 
  if ((fd = open_read(fname.s)) == -1) {
    if (errno == ENOENT)
      return 0;
    else
      logmsg(WHO,111,ERROR,B(ERR_OPEN,fname.s));
  }
 
  buffer_init(&bi,buffer_unixread,fd,inbuf,sizeof(inbuf));
  if (!stralloc_copyb(&line,strnum,fmt_ulong(strnum,(unsigned long) (infop->target/100))))
    die_nomem();
  if (!stralloc_cats(&line,"xx")) die_nomem();
  html_header("Messages ",line.s,line.len,"idxbody",SPC_BANNER | SPC_BASE);
  index_links(infop);
  oputs("<div><hr /></div><h1 id=\"idxhdr\">");
  oputs("Messages ");
  oput(line.s,line.len);
  oputs("</h1>\n");
  oputs("<div class=\"idx\"><hr />\n");
 
  for (;;) {
    if (getln(&bi,&line,&match,'\n') == -1)
      logmsg(WHO,111,ERROR,B(ERR_READ,fname.s));
    if (!match) break;
    pos = scan_ulong(line.s,&thismsg);
    l = pos;
    ch = line.s[pos++];
    pos++;
    if (line.len < pos + 1 + HASHLEN)
      logmsg(WHO,100,ERROR,"index line with truncated subject entry");
    if (!stralloc_copyb(&subject,line.s + pos,HASHLEN)) die_nomem();
    if (!stralloc_0(&subject)) die_nomem();
    infop->view = VIEW_TOPIC;
    infop->subject = subject.s;
    oput(strnum,fmt_uint0(strnum,(unsigned int) thismsg % 100,2));
    oputs(": "); // +
    alink(infop,VIEW_MESSAGE,VIEW_TOPIC,thismsg,line.s + pos,line.len - pos - 1);
    oputs("\n");
    if (ch == ':') { //+
      if (getln(&bi,&line,&match,'\n') == -1)
        logmsg(WHO,111,ERROR,B(ERR_READ,fname.s));
      if (!match) break;
      pos = byte_chr(line.s,line.len,';');
      if (pos != line.len) {
        infop->date = date2yyyymm(line.s);
        oputs("(");
        alink(infop,VIEW_AUTHOR,VIEW_AUTHOR,thismsg,line.s + pos + 1,line.len - pos - 2);
        oputs(")<br>\n");
      }
    }
  }
 
  close(fd);
  oputs("\n<hr /></div>\n");
  index_links(infop);
  html_footer(SPC_BANNER);
  return 1;
}
 
void object_links(struct msginfo *infop,char item)
{
 
  oputs("<div class=objlinks><strong>\n");
  if (item == VIEW_DATE) {
    date_links(infop,0,DIRECT_FIRST);
    date_links(infop,infop->date,DIRECT_PREV);
    date_links(infop,infop->date,DIRECT_NEXT);
    date_links(infop,0,DIRECT_LAST);
    oputs("\n");
  } else {
    if (!infop->target) infop->view = VIEW_DATE;
    index_messages(infop,VIEW_DATE);
    oputs(">[Topics by date]</a>\n");
  }
  if (item != VIEW_INDEX) {
    index_messages(infop,VIEW_INDEX);
    oputs(">[Messages by date]</a>\n");
  }
  home_link();
  subfaq_link();
  oputs("</strong></div>\n");
}

 
int show_object(struct msginfo *infop,char item)
{
  unsigned long lastdate, thisdate, thismsg;
  char linkitem;
  char targetitem;
  unsigned int pos;
 
 
  lastdate = 0L;
  targetitem = VIEW_MESSAGE;                     /* default message is target */
 
  switch (item) {
    case VIEW_TOPIC:  if (!uri2fn(&fname,VIEW_TOPIC,0L,infop->subject)) return 0; break;
    case VIEW_AUTHOR: if (!uri2fn(&fname,VIEW_AUTHOR,0L,infop->author)) return 0; break;
    case VIEW_DATE:   if (!uri2fn(&fname,VIEW_DATE,infop->date,"")) return 0; break;
    default:          die_prog("Bad object type in show_object");
  }
 
  if ((fd = open_read(fname.s)) == -1) {
    if (errno == ENOENT) 
      return 0;
    else
      logmsg(WHO,111,ERROR,B(ERR_OPEN,fname.s));
  }
 
  buffer_init(&bi,buffer_unixread,fd,inbuf,sizeof(inbuf));
  if (item != VIEW_DATE) {
    if (getln(&bi,&line,&match,'\n') == -1)      /* read subject */
      logmsg(WHO,111,ERROR,B(ERR_READ,fname.s));
    if (!match || line.len < HASHLEN + 2)
      logmsg(WHO,111,ERROR,B(ERR_READ,fname.s," nothing there"));
  }
  switch (item) {
    case VIEW_TOPIC:  html_header("Topics on: ",line.s + HASHLEN + 1,
                      line.len - HASHLEN - 2,"subjbody",SPC_BANNER | SPC_BASE);
                      object_links(infop,item);
                      oputs("<div><hr /></div><h1>On: ");
                      oput(line.s + HASHLEN + 1,line.len - HASHLEN - 2);
                      oputs("</h1>\n");
                      break;
    case VIEW_AUTHOR: html_header("Posts by: ",line.s + HASHLEN + 1,
                      line.len - HASHLEN - 2,"authbody",SPC_BANNER | SPC_BASE);
                      object_links(infop,item);
                      oputs("<hr><h1>By: ");
                      oput(line.s + HASHLEN + 1,line.len - HASHLEN - 2);
                      oputs("</h1>\n");
                      break;
     /*    targetitem = VIEW_TOPIC;*/    /* thread index is target */
    case VIEW_DATE:   thisdate = infop->date;
                      if (dateline(&dtline,infop->date) < 0) die_nomem();
                      html_header("Topics for ",
                      dtline.s,dtline.len,"threadsbody",SPC_BANNER | SPC_BASE);
                      object_links(infop,item);
                      oputs("<hr>\n<h1>Topics for ");
 
                      oput(dtline.s,dtline.len);
                      oputs("</h1>\n");
                      break;
    default:          die_prog("unrecognized object type in show_object");
  }
 
  oputs("<div class=obj>\n");
 
 
  for (;;) {
    if (getln(&bi,&line,&match,'\n') == -1)      /* read subject */
      logmsg(WHO,111,ERROR,B(ERR_READ,fname.s));
    if (!match) break;
    pos = scan_ulong(line.s,&thismsg);
    if (line.s[pos++] != ':')
      logmsg(WHO,100,ERROR,B("entry in ",fname.s," lacks message number"));
    if (item != VIEW_DATE) {                     /* no date for threads by date */
      pos += scan_ulong(line.s + pos,&thisdate);
      infop->date = thisdate;
      if (line.s[pos++] != ':') 
        logmsg(WHO,100,ERROR,B("entry in ",fname.s," lacks date"));
    }
    if (line.len < pos + HASHLEN + 2) 
      logmsg(WHO,100,ERROR,B("entry in ",fname.s," lacks hash"));
 
    if (thisdate != lastdate) {
      oputs("</ul><hr>\n");                      // first </ul> ingnored; why bother? (a must)
    //  oput(dtline.s,dtline.len);
      lastdate = thisdate;
      oputs("<ul>\n");
    }    
    oputs("<li>");
    if (item == VIEW_TOPIC)
      linkitem = VIEW_AUTHOR;
    else 
      linkitem = VIEW_TOPIC;
    alink(infop,targetitem,linkitem,thismsg,line.s + pos,line.len - pos - 1);
    oputs("</li>\n");                            /* li terminated at each link */
  }
  close(fd);
 
  oputs("</ul>\n");
  if (!infop->target) oputs("<a name=b></a>");
  oputs("<hr>\n");
  object_links(infop,item);
  html_footer(SPC_BANNER);
 
  return 1;
}
 
void clear_mime()
{
  mime_current->charset.len = 0;                 /* exist but need emptying */
  mime_current->boundary.len = 0;
  mime_current->ctype.len = 0;
  mime_current->mimetype = MIME_NONE;
  mime_current->ctenc = CTENC_NONE;
  mime_current->cs = CS_NONE;
}
 
void new_mime()
{
  mime_tmp = mime_current;
  if (mime_current)
    mime_current = mime_current->next;
  if (!mime_current) {
    if (!(mime_current = (mime_info *) alloc(sizeof (mime_info))))
    die_nomem();
    mime_current->charset = sainit;              /* init */
    mime_current->boundary = sainit;
    mime_current->ctype = sainit;
    mime_current->next = (mime_info *) 0;
    mime_current->previous = mime_tmp;
  }
  clear_mime();
  if (mime_tmp)
    mime_current->level = mime_tmp->level + 1;
  else
    mime_current->level = 1;
}

 
void mime_getarg(stralloc *sa,char **s, unsigned int *l)
{
  char *cp, *cpafter, *cpnext;
 
  if (!*l || !**s) return;
  if (**s == '"') {
    (*s)++; (*l)--;
    cp = *s; cpnext = cp + *l; cpafter = cpnext;
    while (cp < cpafter) {
      if (*cp == '"') break;
      cp++;
    }
    cpnext = cp;
  } else {
    cp = *s; cpnext = cp + *l; cpafter = cpnext;
    while (cp < cpafter) {
      if (*cp == ' ' || *cp == '\t' || *cp == '\n' || *cp == ';') break;
      cp++;
    }
    cpnext = cp;
  }
 
  if (!stralloc_copyb(sa,*s,cp - *s)) die_nomem();
  *l = cpafter - cpnext;                         /* always >= 0 */
  *s = cpnext;
 
  return;
}
 
void decode_mime_type(char *s,unsigned int l,unsigned int flagmime)
{
  char *st;
  unsigned int r, lt;
 
  if (!flagmime || !l) {                         /* treat non-MIME as plain text */
    mime_current->mimetype = MIME_TEXT_PLAIN;
    if (!stralloc_copys(&curcharset,charset)) die_nomem();
    /* should be us-ascii, but this is very likely better */
    return;
  }
  r = MIME_APPLICATION_OCTETSTREAM;
  while (l && (*s == ' ' || *s == '\t')) { s++; l--; }     /* skip LWSP */
  mime_getarg(&(mime_current->ctype),&s,&l);
  st = mime_current->ctype.s;
  lt = mime_current->ctype.len;
  if (case_startb(st,lt,"text")) {               /* text types */
    r = MIME_TEXT; st += 4; lt -= 4;
    if (case_startb(st,lt,"/plain")) {
      r = MIME_TEXT_PLAIN; st += 6; lt -= 6;
    } else if (case_startb(st,lt,"/html")) {
      r = MIME_TEXT_HTML; st += 5; lt -= 5;
    } else if (case_startb(st,lt,"/enriched")) {
      r = MIME_TEXT_ENRICHED; st += 9; lt -= 9;
    } else if (case_startb(st,lt,"/x-vcard")) {
      r = MIME_TEXT_ENRICHED; st += 8; lt -= 8;
    }
  } else if (case_startb(st,lt,"multipart")) {   /* multipart types */
    r = MIME_MULTI; st += 9; lt -= 9;
    if (case_startb(st,lt,"/alternative")) {
      r = MIME_MULTI_ALTERNATIVE; st += 12; lt -= 12;
    } else if (case_startb(st,lt,"/mixed")) {
      r = MIME_MULTI_MIXED; st += 6; lt -= 6;
    } else if (case_startb(st,lt,"/digest")) {
      r = MIME_MULTI_DIGEST; st += 7; lt -= 7;
    } else if (case_startb(st,lt,"/signed")) {
      r = MIME_MULTI_SIGNED; st += 7; lt -= 7;
    }
  } else if (case_startb(st,lt,"message")) {     /* message types */
    r = MIME_MESSAGE; st += 7; lt -= 7;
    if (case_startb(st,lt,"/rfc822")) {
      r = MIME_MESSAGE_RFC822; st += 7; lt -= 7;
    }
  }
  mime_current->mimetype = r;
 
  while (l) {
    while (l && (*s == ' ' || *s == '\t' || *s == ';' || *s == '\n')) {
     s++; l--; }                                 /* skip ;LWSP */
    if (case_startb(s,l,"boundary=")) {
      s += 9; l -= 9;
      mime_getarg(&(mime_current->boundary),&s,&l);
    } else if (case_startb(s,l,"charset=")) {
      s += 8; l -= 8;
      mime_getarg(&(mime_current->charset),&s,&l);
      cs = decode_charset(mime_current->charset.s,
        mime_current->charset.len);
      if (cs == CS_BAD) cs = csbase;             /* keep base cs */
      else
        if (!stralloc_copy(&curcharset,&mime_current->charset)) die_nomem();
    } else {                                     /* skip non LWSP */
      for (;;) {
        if (!l) break;
        if (*s == '"') {
          s++, l--;
          while (l && *s != '"') { s++, l--; }
          if (l) { s++, l--; }
          break;
        } else {
          if (!l || *s == ' ' || *s == '\t' || *s == '\n') break;
          s++; l--;
        }
      }
    }
  }
 
  return;
}
 
void decode_transfer_encoding(char *s,unsigned int l)
{
  unsigned int r;
  mime_current->ctenc = CTENC_NONE;
  if (!l || (mime_current->mimetype & MIME_MULTI)) return;
                                                 /* base64/QP ignored for multipart */
  r = CTENC_NONE;
  while (l && (*s == ' ' || *s == '\t')) { s++; l--; }     /* skip LWSP */
  s[l-1] = 0;
  if (case_startb(s,l,"quoted-printable")) {
    r = CTENC_QP;
  } else if (case_startb(s,l,"base64")) {
    r = CTENC_BASE64;
  }
  mime_current->ctenc = r;
  return;
}

 
int check_boundary()
{
  mime_info *tmp;
 
  if (*line.s != '-' || line.s[1] != '-') return 0;
  tmp = mime_current;
  while (tmp) {
    if (tmp->boundary.len) {
      if (line.len > tmp->boundary.len + 2 &&
          !case_diffb(line.s+2,tmp->boundary.len,tmp->boundary.s)) {
        if (line.s[tmp->boundary.len + 2] == '-' &&
            line.s[tmp->boundary.len + 3] == '-') {   /* end */
          mime_current = tmp;
          clear_mime();
          return 2;
        } else {                                        /* start */
          mime_current = tmp;
          new_mime();
          return 1;
        }
      }
    }
    tmp = tmp->previous;
  }
  if (!stralloc_copys(&curcharset,charset)) die_nomem();
            /* suprtfluous since header done by now */
  cs = csbase;
 
  return 0;
}

 
void start_message_page(struct msginfo *infop)
{
  if (!stralloc_copyb(&decline,strnum,fmt_ulong(strnum,infop->target)))
    die_nomem();
  if (!stralloc_cats(&decline,":")) die_nomem();
  if (!stralloc_0(&decline)) die_nomem();
  decode_hdr(hdr[HDR_SUBJECT - 1].s,hdr[HDR_SUBJECT - 1].len,&line);
  if (!mime_current)
    new_mime();                                  /* allocate */
  else
    clear_mime();
  decode_mime_type(hdr[HDR_CT - 1].s,hdr[HDR_CT - 1].len,hdr[HDR_VERSION - 1].len);
  html_header(decline.s,line.s,line.len - 1,"msgbody",SPC_BASE);
  decline.len = 0;                               /* reset */
  message_links(infop);                          // top page
  oputs("<div class=\"message\">\n");
}

 
void show_part(struct msginfo *infop,int flagshowheaders,int flagstartseen)
{
  char *cp;
  int flaginheader;
  int whatheader;
  int flaggoodfield;
  int flaghtml;
  int btype, i;
  unsigned int colpos;
  char linetype;
 
  flaginheader = 1;
  for (i = 0; i < NO_HDRS; i++) hdr[i].len = 0;
  flaggoodfield = 1;
  match = 1;
  recursion_level++;                             /* one up */
 
  for (flaghtml = whatheader = 0;;) {
    if (!match) return;
    if (getln(&bi,&line,&match,'\n') == -1)
      logmsg(WHO,111,ERROR,B(ERR_READ,fname.s));
    if (!match) return;
    if ((btype = check_boundary())) {
      if (decline.len) {                         /* flush last line that doesn't */
        if (flaghtml)                            /* end in \n for QP/base64 */
          oput(decline.s,decline.len);
        else
          anchor_put(decline.s,decline.len);
        decline.len = 0;
      }
      if (flagpre) {                              /* ending part was <pre> */
              oputs("</pre>");
        toggle_flagpre(0);
      }
      if (mime_current->level < recursion_level) return;
      if (btype == 1) {
        flagstartseen = 1;
        flaggoodfield = 1;
        flaginheader = 1;
      } else
        flagstartseen = 0;
        continue;
    }
    if (!flagstartseen) continue;                /* skip to start */
    if (flaginheader) {
      if (line.len == 1) {
        if (flagshowheaders) {                   /* rfc822hdr only */
          if (flagtoplevel)
            start_message_page(infop);           /* so we can put subj in TITLE */
          oputs("<div class=\"rfc822hdr\"><hr />\n");
      
          for (i = 0; i < NO_HDRS; i++) {
            if (!hdr[i].len || !headers_shown[i]) continue;
            if (i == HDR_SUBJECT - 1 && flagtoplevel)
              oputs("<span class=\"subject\">");
            oputs("<em>");
            oputs(constmap_get(&headermap,i + 1));
            oputs(":</em>");
            decode_hdr(hdr[i].s,hdr[i].len,&line);
            if (i == HDR_SUBJECT - 1 && flagtoplevel) {
              oputs("<a class=\"relk\" href=\"mailto:");
              oputs(local);
              oput("@",1);
              oputs(host);
              oputs("?subject=");
              urlencode_put(line.s + 1,line.len - 2);
              oputs("\">");
            }
            if (flagobscure && i == HDR_FROM - 1) {
              int k;
              oputs(" ");
              k = author_name(&cp,line.s,line.len);
              decode_hdr(cp,k,&decline);
              html_put(decline.s,decline.len);
            } else {
              decode_hdr(hdr[i].s,hdr[i].len,&decline);
              html_put(decline.s,decline.len - 1);
            }
            if (i == HDR_SUBJECT - 1 && flagtoplevel)
              oputs("</a></span>");
            oputs("\n<br />"); // FIXME
          } 
 
          oputs("</div>\n");
        }
        flaginheader = 0;
        flagtoplevel = 0;
        flaggoodfield = 1;
        flaghtml = 0;
        if (!flagmime)
          flagmime = hdr[HDR_VERSION - 1].len;   /* MIME-Version header */
        decode_mime_type(hdr[HDR_CT - 1].s,hdr[HDR_CT - 1].len,flagmime);
        decode_transfer_encoding(hdr[HDR_CTENC - 1].s,hdr[HDR_CTENC - 1].len);
        content.len = 0; encoding.len = 0;
    
        switch (mime_current->mimetype) {
          case MIME_MULTI_SIGNED:
          case MIME_MULTI_MIXED:
          case MIME_MULTI_ALTERNATIVE:
          case MIME_MULTI_DIGEST:   show_part(infop,0,0);
                                    recursion_level--;
                                    flagstartseen = 0;
                                    flaginheader = 1;
                                    continue; // we are in a for loop
          case MIME_MESSAGE_RFC822: oputs("\n<pre>");
                                    toggle_flagpre(1);
                                    flagshowheaders = 1;
                                    flaginheader = 1;
                                    flagmime = 0;/* need new MIME-Version header */
                                    continue;
          case MIME_TEXT_HTML:      if (flagshowhtml) {
                                      oputs("<hr />\n");
                                      flaghtml = 1;
                                    } else {
                                      oputs("<strong>[\"");
                                      oput(mime_current->ctype.s,mime_current->ctype.len);
                                      oputs("\" not shown]</strong>\n");
                                      flaggoodfield = 0;    /* hide */
                                    }
                                    continue;
          case MIME_TEXT_PLAIN:
          case MIME_TEXT:           /* in honor of Phil using "text" on the qmail list and rfc2045:5.2 */
          case MIME_NONE:           oputs("<hr>\n<pre>\n");
                                    toggle_flagpre(1);
                                    continue;
          case MIME_TEXT_VCARD:
 
      /* application/octetstream...*/
          default:                  oputs("<hr><strong>[\"");
                                    oput(mime_current->ctype.s,mime_current->ctype.len);
                                    oputs("\" not shown]</strong>\n");
                                    flaggoodfield = 0;    /* hide */
                                    continue;
        }
      } else if (line.s[0] != ' ' && line.s[0] != '\t') {
        linetype = ' ';
        flaggoodfield = 0;
        colpos = byte_chr(line.s,line.len,':'); // FIXME
        if ((whatheader = constmap_index(&headermap,line.s,colpos))) {
          flaggoodfield = 1;
          if (!stralloc_copyb(&hdr[whatheader - 1],line.s + colpos + 1,
          line.len - colpos - 1)) die_nomem();
        }
      } else {
        if (whatheader)
          if (!stralloc_catb(&hdr[whatheader - 1],line.s,line.len))
            die_nomem();
      }
    } else {
      if (flaggoodfield) {
        if (mime_current->ctenc) {
          if (mime_current->ctenc == CTENC_QP)
            decode_qp(line.s,line.len,&decline);
          else
            decode_b64(line.s,line.len,&decline);
          if (decline.s[decline.len - 1] == '\n') {   /* complete line */
            if (!stralloc_copy(&line,&decline)) die_nomem();
            decline.len = 0;
          } else                                 /* incomplete - wait for next */
            line.len = 0;                        /* in case URL is split */
        } 
        if (flaghtml)
          oput(line.s,line.len);
        else {
          anchor_put(line.s,line.len);           /* body */
        }
      }
    }
  }
}
 
int show_message(struct msginfo *infop)
{
  char *psz;
 
  if(!stralloc_copys(&headers,(char *) headers_used)) die_nomem();
  if (!stralloc_0(&headers)) die_nomem();
  psz = headers.s;
 
  while (*psz) {
    if (*psz == '\\') *psz = '\0';
    ++psz;
  }
  if (!constmap_init(&headermap,headers.s,headers.len,0))
    die_nomem();
 
  uri2fn(&fname,VIEW_MESSAGE,msginfo.target,"");
 
  if ((fd = open_read(fname.s)) == -1) {
    if (errno == ENOENT)
      return 0;
    else
      logmsg(WHO,111,ERROR,B(ERR_OPEN,fname.s));
  }
 
  buffer_init(&bi,buffer_unixread,fd,inbuf,sizeof(inbuf));
  toggle_flagpre(0);
  recursion_level = 0;                 /* recursion level for show_part */
  flagmime = 0;                        /* no active mime */
  flagtoplevel = 1;                    /* top message/rfc822 get special rx */
  new_mime();                          /* initiate a MIME info storage slot */
 
  show_part(infop,1,1);                       /* do real work, including html header etc */
  if (flagpre) oputs("</pre>\n");      // output done; close FD
  close(fd);
  oputs("<hr /></div>\n");
  message_links(infop);                    // bottom page
  html_footer(0);
 
  return 1;
}
 
char decode_item(char ch)
{
  switch (ch) {
    case 'm': return VIEW_MESSAGE;
    case 'a': return VIEW_AUTHOR;
    case 's': return VIEW_TOPIC;
    case 'd': return VIEW_DATE;
    case 'i': return VIEW_INDEX;
    default:  cgierr("Navigation command contains ","illegal item code","");
  }
  return 0;    /* never reached */
}
 
char decode_direction(char ch)
{
  switch (ch) {
    case 's': return DIRECT_SAME;
    case 'n': return DIRECT_NEXT;
    case 'p': return DIRECT_PREV;
    default:  cgierr("Navigation command contains ","illegal direction code","");
  }
  return 0;   /* never reached */
}

 
int decode_cmd(char *cmd,struct msginfo *infop)
{
  char ch;
 
  infop->source = 0L;
  infop->date = 0L;
  infop->author = (char *)0;
  infop->subject = (char *)0;
  infop->cgiarg = (char *)0;
 
  if (!cmd || !*cmd) {                 /* main index */
    infop->item = VIEW_DATE;
    infop->view = VIEW_DATE;
    infop->direction = DIRECT_SAME;
    latestdate(&msginfo,0);
    infop->target = MAXULONG;
    return 1;
  }
 
  ch = *(cmd++);
  if (ch >= '0' && ch <= '9') {        /* numeric - simplified cntl: msgnum ... */
    cmd--;
    infop->item = VIEW_MESSAGE;
    infop->view = VIEW_MESSAGE;
    infop->direction = DIRECT_SAME;
  } else {                             /* item|view|direction:msgnum ... */
    infop->item = decode_item(ch);
    ch = *(cmd++);
    infop->view = decode_item(ch);
    ch = *(cmd++);
    infop->direction = decode_direction(ch);
    if (*(cmd++) != ':') return 0; //+
  }
  cmd += scan_ulong(cmd,&(infop->source));
  if (*(cmd++) != ':') return 0; //+
  if (*cmd >= '0' && *cmd <= '9') {    /* numeric cmd hint [date] */
    cmd += scan_ulong(cmd,&(infop->date));
    if (!*cmd++) return 1;             /* skip any char - should be ':' unless NUL */
  }
  if (checkhash(cmd)) {                /* Ignore if illegal rather than complaining*/
    if (!stralloc_copyb(&charg,cmd,HASHLEN)) die_nomem();
    if (!stralloc_0(&charg)) die_nomem();
    infop->cgiarg = charg.s;
  }
  return 1;
}
 
int msg2hash(struct msginfo *infop)
{
  unsigned int pos;
  unsigned long tmpmsg;
 
  if (!infop->source) die_prog("source is 0 in msg2hash");
 
  uri2fn(&fname,VIEW_INDEX,infop->source,"");
  if ((fd = open_read(fname.s)) == -1) {
    if (errno == ENOENT)
      return 0;
    else
      logmsg(WHO,111,ERROR,B(ERR_OPEN,fname.s));
  }
 
  buffer_init(&bi,buffer_unixread,fd,inbuf,sizeof(inbuf));
  for (;;) {
    if (getln(&bi,&line,&match,'\n') == -1)
      logmsg(WHO,111,ERROR,B(ERR_READ,"index "));
    if (!match)
      return 0;                                  /* didn't find message */
 
    if (*line.s == '\t') continue;               /* author line */
      pos = scan_ulong(line.s,&tmpmsg);
 
    if (tmpmsg == infop->source) {
      if (line.s[pos++] != ':' || line.s[pos++] != ' ')
        logmsg(WHO,100,ERROR,B(ERR_SYNTAX,fname.s," missing subject separator"));
      if (line.len < HASHLEN + pos)
        logmsg(WHO,100,ERROR,B(ERR_SYNTAX,fname.s," missing subject hash"));
      if (!stralloc_copyb(&subject,line.s+pos,HASHLEN)) die_nomem();
      if (!stralloc_0(&subject)) die_nomem();
      infop->subject = subject.s;
      if (getln(&bi,&line,&match,'\n') == -1)
        logmsg(WHO,111,ERROR,B(ERR_READ,"index"));
      if (!match)
        logmsg(WHO,100,ERROR,B(ERR_SYNTAX,fname.s," author info missing. Truncated?"));
      pos = byte_chr(line.s,line.len,';');
      if (pos == line.len)
        logmsg(WHO,100,ERROR,B(ERR_SYNTAX,fname.s,"missing ';' after date"));
      if (pos > 1)
        infop->date = date2yyyymm(line.s+1);     /* ';' marks end ok */
      pos++;
      if (line.len < HASHLEN + pos)
        logmsg(WHO,100,ERROR,B(ERR_SYNTAX,fname.s," missing author hash"));
      if (!stralloc_copyb(&author,line.s + pos,HASHLEN)) die_nomem();
      if (!stralloc_0(&author)) die_nomem();
      infop->author = author.s;
      close(fd);
 
      return 1;                                  /* success */
    }
  }
 
  close(fd);
  return 0;                                      /* failed to match */
}

 
void set_message(struct msginfo *infop)
{
  if (infop->direction == DIRECT_SAME) {
    infop->target = infop->source;
    return;
  }
  if ((fd = open_read(fname.s)) == -1) {
    if (errno == ENOENT)
      logmsg(WHO,100,ERROR,B(ERR_OPEN,fname.s," in set_message. Rerun ezmlm-archive!"));
    else
      logmsg(WHO,111,ERROR,B(ERR_OPEN,fname.s));
  }
 
  buffer_init(&bi,buffer_unixread,fd,inbuf,sizeof(inbuf));
  if (infop->view != VIEW_DATE) {
    if (getln(&bi,&line,&match,'\n') == -1)      /* first line */
      logmsg(WHO,111,ERROR,B(ERR_READ,fname.s));
    if (!match)
      logmsg(WHO,100,ERROR,B(ERR_SYNTAX,fname.s,": first line missing"));
  }
  msgnav[3] = 0L;                                /* next */
  msgnav[4] = 0L;                                /* after */
  infop->target = 0L;
 
  for (;;) {
    if (getln(&bi,&line,&match,'\n') == -1)
      logmsg(WHO,111,ERROR,B(ERR_READ,fname.s));
    if (!match) break;
    msgnav[0] = msgnav[1];
    msgnav[1] = msgnav[2];
    pos = scan_ulong(line.s,&(msgnav[2]));
    if (infop->direction == DIRECT_FIRST && infop->view == VIEW_DATE) {
      if (pos + HASHLEN + 1 < line.len)
        if (!stralloc_copyb(&subject,line.s + pos + 1,HASHLEN)) die_nomem();
      if (!stralloc_0(&subject)) die_nomem();
      break;
    }
    if (msgnav[2] == infop->source) {
      if (getln(&bi,&line,&match,'\n') == -1)
        logmsg(WHO,111,ERROR,B(ERR_READ,fname.s));
      if (!match) break;
      scan_ulong(line.s,&(msgnav[3]));
      if (getln(&bi,&line,&match,'\n') == -1)
        logmsg(WHO,111,ERROR,B(ERR_READ,fname.s));
      if (!match) break;
      scan_ulong(line.s,&(msgnav[4]));
      break;
    }
  }
  close(fd);
 
  switch (infop->view) {
    case VIEW_AUTHOR: infop->authnav = msgnav + 2 + infop->direction;
                      infop->target = *(infop->authnav);
                      infop->subject = (char *)0;    /* what we know is not for this msg */
                      infop->date = 0;
                      break;
    case VIEW_TOPIC:  if (infop->direction == DIRECT_FIRST)
                        infop->target = msgnav[2];
                      else {
                        infop->subjnav = msgnav + 2 + infop->direction;
                        infop->target = *(infop->subjnav);
                      }
                      infop->author = (char *)0;     /* what we know is not for this msg */
                      infop->date = 0;
                      break;
    case VIEW_DATE:   infop->target = msgnav[2];
                      infop->subject = (char *)0;    /* what we know is not for this msg */
                      infop->author = (char *)0;     /* what we know is not for this msg */
                      break;
    default:          die_prog("Bad item in set_message");
  }
  return;
}
 
void auth2msg(struct msginfo *infop)
{
  if (!infop->author) die_prog("no such author in authmsg");
  if (!uri2fn(&fname,VIEW_AUTHOR,0L,infop->author)) die_prog("auth2msg");
  set_message(infop);
}
 
void subj2msg(struct msginfo *infop)
{
  if (!infop->subject) die_prog("no such subject in subj2msg");
  if (!uri2fn(&fname,VIEW_TOPIC,0L,infop->subject)) die_prog("subj2msg");
  set_message(infop);
}
 
void date2msg(struct msginfo *infop)
/* this is all a terrible hack */
{
  uri2fn(&fname,VIEW_DATE,infop->date,"");
  infop->direction = DIRECT_FIRST;
  infop->view = VIEW_DATE;
  set_message(infop);        /* got first thread */
  infop->subject = subject.s;
  infop->view = VIEW_TOPIC;
  subj2msg(infop);           /* get 1st message no in that thread */
}
 
void findlastmsg(struct msginfo *infop)
{
  if (!getconf_line(&line,"num",0,dir))
    cgierr("Sorry, there are no more messages in the archive","","");
  if (!stralloc_0(&line)) die_nomem();
  scan_ulong(line.s,&(infop->target));
}

 
int navigate(struct msginfo *infop)
{
  infop->target = infop->source;
 
  switch (infop->item) {
    /* we want to get a message back */
    case VIEW_MESSAGE: switch (infop->view) {
                         case VIEW_MESSAGE: if (infop->direction == DIRECT_SAME)
                                              break;
                                            else if (infop->direction == DIRECT_NEXT)
                                              (infop->target)++;
                                            else {                   /* previous */
                                              cache = 2;
                                              if (infop->target >= 2)
                                                (infop->target)--;
                                              else
                                                infop->target = 1;
                                            }
                                            break;
                         case VIEW_AUTHOR:  infop->author = infop->cgiarg;
                                            if (!infop->author)      /* we don't know author hash */
                                              if (!msg2hash(infop)) return 0;
                                            auth2msg(infop);
                                            break;
                         case VIEW_TOPIC: infop->subject = infop->cgiarg;
                                            if (!infop->subject)     /* we don't know Subject hash */
                                              if (!msg2hash(infop)) return 0;
                                            subj2msg(infop);
                                            break;
                       }
                       break;
    case VIEW_AUTHOR:  switch (infop->view) {
                         case VIEW_MESSAGE: if (!infop->author)
                                              if (!msg2hash(infop)) return 0;
                                            break;
                         case VIEW_AUTHOR:  infop->author = infop->cgiarg;
                                            if (!infop->author)
                                              if (!msg2hash(infop)) return 0;
                                            auth2msg(infop);
                                            break;
                         case VIEW_TOPIC: infop->subject = infop->cgiarg;
                                            if (!infop->subject)     /* we don't know Subject hash */
                                              if (!msg2hash(infop)) return 0;
                                            subj2msg(infop);
                                            break;
                       }
                       break;
    case VIEW_TOPIC: switch (infop->view) {
                         case VIEW_MESSAGE: if (!msg2hash(infop)) return 0;
                                            break;
                         case VIEW_AUTHOR:  infop->author = infop->cgiarg;
                                            if (!infop->author)
                                              if (!msg2hash(infop)) return 0;
                                            auth2msg(infop);
                                            break;
                         case VIEW_TOPIC: infop->subject = infop->cgiarg;
                                            if (!infop->subject)     /* we don't know Subject hash */
                                              if (!msg2hash(infop)) return 0;
                                            subj2msg(infop);
                                            break;
                       }
                       break;
      case VIEW_DATE:  switch (infop->view) {                        /* want a date reference */
                         case VIEW_MESSAGE:
                         case VIEW_AUTHOR:
                         case VIEW_TOPIC:
                         case VIEW_DATE: if (!infop->date && infop->source)
                                           if (!msg2hash(infop)) return 0;
                                         gtdate(infop,0);
                                         break;
                       }
                       break;
      case VIEW_INDEX: if (!infop->target)                           /* ignore direction etc - only for index */
                         infop->target = infop->source;
                       break;
  }
 
  return 1;
}

 
void list_list(const char *listname)
{
  DIR *archivedir;
  direntry *d;
  unsigned long msgset;
 
  flagrobot = 2;
  archivedir = opendir("archive/");
  if (!archivedir)
    if (errno != ENOENT)
      logmsg(WHO,111,ERROR,B(ERR_OPEN,"/archive: ",dir));
    else
      logmsg(WHO,100,ERROR,B(ERR_OPEN,"/archive: ",dir));
 
  cache = 1;
  html_header("Robot index for message sets in list",0,0,0,0);
 
  while ((d = readdir(archivedir))) {
    if (d->d_name[scan_ulong(d->d_name,&msgset)]) 
      continue;                        /* not numeric */
    oputs("<a href=\"../");            /* from /ezcgi/0/index to /ezcgi/listnum/index*/
    oputs(listname);
    oputs("/index/");
    oputs(d->d_name);
    oputs("\">[link]</a>\n");
  }
  closedir(archivedir);
  html_footer(0);
}
 
void list_set(unsigned long msgset)
{
  unsigned int msgfirst,msgmax;
  unsigned long lastset;
 
  flagrobot = 2;
  findlastmsg(&msginfo);
  if (!stralloc_copys(&line,"<a href=\"../")) die_nomem();
  if (!stralloc_catb(&line,strnum,fmt_ulong(strnum,msgset))) die_nomem();
  lastset = msginfo.target/100;
  cache = 2;
  msgfirst = 0;
  if (!msgset)
    msgfirst = 1;
  msgmax = 99;
  if (msgset > lastset) {        /* assure empty list */
    msgmax = 0;
    msgfirst = 1;
  } else if (msgset == lastset) {
    cache = 0;                /* still changing */
    msgmax = msginfo.target % 100;
  }
  html_header("Robot index for messages in set",0,0,0,0);
  while (msgfirst <= msgmax) {
    oput(line.s,line.len);
    oput(strnum,fmt_uint0(strnum,msgfirst,2));
    oputs("\">[link]</a>\n");
    msgfirst++;
  }
  html_footer(0);
}
 
/**************** MAY BE SUID ROOT HERE ****************************/
void drop_priv(int flagchroot)
{
  if (!uid) logmsg(WHO,100,FATAL,ERR_SUID);       /* not as root */
  if (!euid) {
    if (flagchroot)
      if (chroot(dir) == -1)                      /* chroot listdir */
        logmsg(WHO,111,FATAL,B("failed to chroot to: ",dir));
    if (setuid(uid) == -1)                        /* setuid */
      logmsg(WHO,111,FATAL,ERR_SETUID);
  }
  euid = (unsigned long) geteuid();
  if (!euid) logmsg(WHO,100,FATAL,ERR_SUID);     /* setuid didn't do it*/
}
/*******************************************************************/
 
int main(int argc,char **argv)
{
  char *cp = 0; 
  char *cppath = 0;
  char *thislistname = 0;
  unsigned long tmpuid, msgset;
  unsigned long msgnum = 0;
  unsigned long port = 0L;
  unsigned long tmptarget;
  unsigned int pos,l;
  int flagindex = 0;
  int flagchroot = 1;                            /* chroot listdir if SUID root */
  int r = 0;
  char sep = '|';
  char *ezcgirc = 0;
 
/******************** we may be SUID ROOT ******************************/
  uid = (unsigned long) getuid();                /* should be http */
  euid = (unsigned long) geteuid();              /* chroot only if 0 */
 
  if ((ezcgirc = env_get("EZCGIRC"))) {
    if ((fd = open_read(ezcgirc)) == -1)         /* read ezcgirc from envionment */
      logmsg(WHO,111,FATAL,B(ERR_OPEN,"ezcigrc from environment: ","'",ezcgirc,"'"));
  } else if (!euid) {
    if ((fd = open_read(EZ_CGIRC)) == -1)        /* open system ezcgirc */
      logmsg(WHO,111,FATAL,B(ERR_OPEN,EZ_CGIRC));
  } else {
    if ((fd = open_read(EZ_CGIRC_LOC)) == -1)    /* open local ezcgirc */
      logmsg(WHO,111,FATAL,B(ERR_OPEN,EZ_CGIRC_LOC));
  }
 
  buffer_init(&bi,buffer_unixread,fd,inbuf,sizeof(inbuf));  /* set up buffer */
 
  cntl = env_get("QUERY_STRING");                /* get command */
  cppath = env_get("PATH_INFO");                 /* get path_info */
 
  if (!cntl && !cppath) {
    cntl = argv[1];                              // call from command line
  }
 
  if (!cppath || !*cppath) {
    if (cntl && *cntl) {                         // QUERY_STRING: WHO/listname+nav:.....
      pos = str_chr(cntl,'+');
      if (cntl[pos] == '+') {
        cntl[pos] = '\0';
        thislistname = cntl;
        cntl += pos + 1;
      }
    }
  } else if (*cppath == '/') {                   // PATH_INFO: WHO/listname/msgno
    cppath++;
    thislistname = cppath;
    pos = str_chr(cppath,'/');               
    if (thislistname[pos] == '/') {
      thislistname[pos] = '\0';
      cppath += pos;
     }
  } 
 
  if (!thislistname || !*thislistname) {        // No list requested
    drop_priv(0);
    close(fd);
    cgierr("Sorry, no mailing list requested","","");
    _exit(0);
  }
 
  for (;;) {
    if (getln(&bi,&cfline,&match,'\n') == -1)    /* read line */
      logmsg(WHO,111,ERROR,B(ERR_READ,fname.s));
    if (!match) break;
    if (*cfline.s == '#' || cfline.len == 1) continue;    /* skip comment/blank */
    cfline.s[cfline.len - 1] = '\0';             /* so all are sz */
    pos = str_chr(cfline.s,sep);                /* list name for line */
    if (pos < cfline.len)
      stralloc_copyb(&listname,cfline.s,pos);
    if (str_diffn(thislistname,listname.s,listname.len)) continue;
    if (cfline.s[++pos] == '-') {                /* no chroot if -uid*/
      flagchroot = 0;
      pos++;
    }
    pos += scan_ulong(cfline.s + pos,&tmpuid);   /* listno for line */
    if (tmpuid) uid = tmpuid;                    /* override default */
    if (cfline.s[pos++] != sep)
      die_syntax("missing separator after user id");
    if (cfline.s[pos] != '/')
      die_syntax("dir does not start with slash");/* absolute path */
    l = byte_chr(cfline.s + pos,cfline.len - pos,sep);
    if (l == cfline.len - pos)                   /* listno:path:...*/
      die_syntax("missing separator after path");
    dir = cfline.s + pos;
    pos += l;
    cfline.s[pos++] = '\0';                      /* .../dir\0 */
    break;                                       /* do rest after dropping priv */
  }
  close(fd);                                     /* don't accept uid 0 */
 
  if (!dir) {
    drop_priv(0);                                /* don't trust cgierr. No dir, no chroot */
    cgierr("list ",thislistname,ERR_NOEXIST);
  }
  if (chdir(dir) == -1)                          /* chdir listdir */
    logmsg(WHO,111,FATAL,B(ERR_SWITCH,dir));
 
  drop_priv(flagchroot);
 
/******************************* RELAX **********************************/
 
/********************* continue to process config line ******************/
 
  flagrobot = 0;
  if (cfline.s[pos] == '-') {
    flagobscure = 1;
    pos++;
  }
  local = cfline.s + pos;
  l = byte_chr(cfline.s + pos, cfline.len - pos,sep);      /* ... home */
  if (l < cfline.len - pos) {                              /* optional */
    pos += l;
    cfline.s[pos++] = '\0';
    home = cfline.s + pos;
    l = byte_chr(cfline.s + pos, cfline.len - pos,sep);    /* ... charset */
    if (l < cfline.len - pos) {                            /* optional */
      pos += l;
      cfline.s[pos++] = '\0';
      charset = cfline.s + pos;
      l = byte_chr(cfline.s + pos,cfline.len - pos,sep);   /* ... stylesheet */
      if (l < cfline.len - pos) {                          /* optional */
        pos += l;
        cfline.s[pos++] = '\0';
        stylesheet = cfline.s + pos;
        l = byte_chr(cfline.s + pos,cfline.len - pos,sep); /* ... bannerURL */
        if (l < cfline.len - pos) {                        /* optional */
          pos += l;
          cfline.s[pos++] = '\0';
          banner = cfline.s + pos;
        }
      }
    }
  }
  if (!charset || !*charset)                               /* UTF-8 default */
    charset = EZ_CHARSET;
  if (!stralloc_copys(&curcharset,charset)) die_nomem();
  csbase = decode_charset(curcharset.s,curcharset.len);
  if (csbase == CS_BAD) csbase = CS_NONE;
  cs = csbase;
  pos = str_rchr(local,'@');
  if (local[pos] != '@')
    die_syntax("listaddress lacks '@'");                   /* require host */
  local[pos++] = '\0';
  host = local + pos;
 
/********************* Accomodate robots and PATH_INFO ****************/
 
  if (flagindex) {
    if (*(cppath++) == '/') {                              /* /2/index/123 */
      cppath += scan_ulong(cppath,&msgset);
      list_set(msgset);
    } else                                                 /* /2/index */
      list_list(thislistname);
    _exit(0);
  }
 
  if (cppath && *cppath) {                                 /* /2/msgnum */
    flagrobot = 1;                                         /* allow index, but "nofollow" */
    scan_ulong(cppath,&msgnum);
  }                                                        /* dealt with normally */
 
/********************* Get info from server on BASE etc ****************/
 
 
  if (!stralloc_copys(&url,"<a href=\"")) die_nomem();
  if (!stralloc_copys(&base,"<base href=\"http://")) die_nomem();
 
 
  cp = env_get("SERVER_PORT");
  if (cp) {                                                /* port */
    (void) scan_ulong(cp,&port);
    if ((unsigned int) port == 443) {                      /* https: */
      if (!stralloc_copys(&base,"<base href=\"https://")) die_nomem();
    }
  }
  if ((cp = env_get("HTTP_HOST")) || (cp = env_get("SERVER_NAME"))) {
    if (!stralloc_cats(&base,cp)) die_nomem();
    if (port && (unsigned int) port != 80 && (unsigned int) port != 443) {
      if (!stralloc_cats(&base,":")) die_nomem();
      if (!stralloc_catb(&base,strnum,fmt_ulong(strnum,port))) die_nomem();
    }
  }
  if ((cp = env_get("SCRIPT_NAME")) != 0) {
    if (!stralloc_cats(&base,cp)) die_nomem();
    pos = str_rchr(cp,'/');
    if (cp[pos] == '/')
      if (!stralloc_cats(&url,cp + pos + 1)) die_nomem();
  }
  if (!stralloc_cats(&base,"\" />\n")) die_nomem();
  if (!stralloc_cats(&url,"?")) die_nomem();
  if (thislistname) {
    if (!stralloc_cats(&url,thislistname)) die_nomem();
    if (!stralloc_cats(&url,"+")) die_nomem();
  }
  cache = 1;                                     /* don't know if we want to cache */
 
/****************************** Get command ****************************/
 
  if (msgnum) {                                  /* to support /listnum/msgno */
    msginfo.target = msgnum;
    msginfo.item = VIEW_MESSAGE;
    cache = 2;
  } else {
    decode_cmd(cntl,&msginfo);
    if (!navigate(&msginfo))
      cgierr("I'm sorry, Cpt. Nelson ... I can't navigate towards that, Cpt. Nelson ...","","");
  }
 
  switch (msginfo.item) {
    case VIEW_MESSAGE: if (!(r = show_message(&msginfo))) {     /* assume next exists ... */
                         cache = 0;                             /* border cond. - no cache */
                         msginfo.target = msginfo.source;       /* show same */
                         msginfo.subjnav = 0;
                         msginfo.authnav = 0;
                         r = show_message(&msginfo);
                       }
                       break;
    case VIEW_AUTHOR:  if (!(r = show_object(&msginfo,VIEW_AUTHOR)))
                         cgierr("I couldn't find the author for that message","","");
                       break;
    case VIEW_TOPIC:   if (!(r = show_object(&msginfo,VIEW_TOPIC)))
                         cgierr("I couldn't find the subject for that message","","");
                       break;
    case VIEW_DATE:    if (!(r = show_object(&msginfo,VIEW_DATE))) {
                         finddate(&msginfo);
                         r = show_object(&msginfo,VIEW_DATE);
                       }
                       break;
    case VIEW_INDEX:   r = 1;
                       if (show_index(&msginfo)) break;          /* msgnumber valid */
                       tmptarget = msginfo.target;
                       findlastmsg(&msginfo);
                       cache = 0;                                /* latest one - no cache */
                       if (msginfo.target > tmptarget) {
                         cache = 2;                              /* first one won't change */
                         msginfo.target = 1;                     /* try */
                         if (show_index(&msginfo)) break;
                         msginfo.date = 0;                       /* first indexes missing */
                         firstdate(&msginfo);                    /* instead get first msg of first */
                         date2msg(&msginfo);                     /* thread. */
                         if (show_index(&msginfo)) break;
                       } else
                         r = show_index(&msginfo);
                       break;
    default:           logmsg(WHO,100,ERROR,"bad item in main");
  }
  if (!r) {
    findlastmsg(&msginfo);                                      /* as last resort; last msgindex */
    cache = 0;
    r = show_message(&msginfo);
  }
 
  _exit(0);
 
  return 0;
}