Import ezmlm-idx 0.40

[ezmlm] / idxthread.c

/*$Id: idxthread.c,v 1.35 1999/11/22 01:47:45 lindberg Exp $*/
/*$Name: ezmlm-idx-040 $*/

/* idxthread.c contains routines to from the ezmlm-idx subject index build */
/* a structure of unique subjects as well as a table of messages with      */
/* pointers to the subject. This leads to information on message threads   */
/* arranged chronologically within the thread, and with the threads        */
/* arranged chronologically by the first message within the range.         */
/* idx_mkthreads() will arrange the author list in a similar manner. This  */
/* saves some space, and takes a little extra time. It's needed when       */
/* generating an author index. */

#include <sys/types.h>
#include <sys/stat.h>
#include "error.h"
#include "alloc.h"
#include "str.h"
#include "stralloc.h"
#include "strerr.h"
#include "lock.h"
#include "idx.h"
#include "errtxt.h"
#include "substdio.h"
#include "fmt.h"
#include "readwrite.h"
#include "makehash.h"
#include "yyyymm.h"

#define DATENO 100
static stralloc line = {0};             /* primary input */
static stralloc authline = {0};         /* second line of primary input */
static stralloc dummyind = {0};

static substdio ssindex;
static char indexbuf[1024];

static char strnum[FMT_ULONG];

struct stat st;
                        /* if no data, these may be the entire table, so */
                        /* need to be static */
static subentry sdummy;
static authentry adummy;


static void die_nomem(fatal)
char *fatal;
{
  strerr_die2x(111,fatal,ERR_NOMEM);
}

int fdlock;

/* NOTE: These do NOT prevent double locking */
static void lockup(fatal)
char *fatal;
{
  fdlock = open_append("lock");
  if (fdlock == -1)
    strerr_die2sys(111,fatal,ERR_OPEN_LOCK);
  if (lock_ex(fdlock) == -1) {
    close(fdlock);
    strerr_die2sys(111,fatal,ERR_OBTAIN_LOCK);
  }
}

static void unlock()
{
    close(fdlock);
}

static void newsub(psubt,subject,sublen,msg,fatal)
/* Initializes subentry pointed to by psubt, adds a '\0' to subject,    */
/* allocates space and copies in subject, and puts a pointer to it in   */
/* the entry. */
subentry *psubt;
char *subject;
unsigned int sublen;
unsigned long msg;
char *fatal;
{
  register char *cpfrom, *cpto;
  register unsigned int cpno;

  psubt->higher = (subentry *) 0;
  psubt->lower = (subentry *) 0;
  psubt->firstmsg = msg;
  psubt->lastmsg = msg;
  psubt->msginthread = 1;
  if (!(psubt->sub = alloc ((sublen) * sizeof(char))))
    die_nomem(fatal);
  cpto = psubt->sub;
  cpno = sublen;
  cpfrom = subject;
  while (cpno--) *(cpto++) = *(cpfrom++);
  psubt->sublen = sublen;
}

static void newauth(pautht,author,authlen,msg,fatal)
/* Allocates space for author of length authlen+1 adding a terminal '\0' */
/* and puts the pointer in pautht->auth. Analog to newsub().             */
authentry *pautht;      /* entry for current message */
char *author;           /* pointer to author string (not sz!) */
unsigned int authlen;   /* lenth of author */
unsigned long msg;
char *fatal;            /* sz */

{
  register char *cpfrom, *cpto;
  register unsigned int cpno;

  pautht->higher = (subentry *) 0;
  pautht->lower = (subentry *) 0;
  pautht->firstmsg = msg;
  if (!(pautht->auth = alloc ((authlen) * sizeof(char))))
    die_nomem(fatal);
  cpto = pautht->auth;
  cpno = authlen;
  cpfrom = author;
  while (cpno--) *(cpto++) = *(cpfrom++);
  pautht->authlen = authlen;
}

static void init_dummy(fatal)
char *fatal;
{
  unsigned int i;

  if (!stralloc_ready(&dummyind,HASHLEN + 1)) die_nomem(fatal);
  for (i = 0; i< HASHLEN; i++)
    dummyind.s[i] = 'a';
  dummyind.len = HASHLEN;
  if (!stralloc_append(&dummyind," ")) die_nomem(fatal);
}

void idx_mkthreads(pmsgtable,psubtable,pauthtable,pdatetable,
        msg_from,msg_to,msg_latest,locked,fatal)
/* Threads messages msg_from -> msg_to into pmsgtable & psubtable. When  */
/* reading the latest index file (containing msg_latest) it locks the    */
/* directory, unless it is already locked (as in digest creation).       */
/* msgtable has the subject number 1.. (0 if there is no subject match,  */
/* which should happen only if the subject index is corrupt.)            */

/* 19971107 Changed to deal with index files that are missing, or have   */
/* missing entries, not necessarily reflecting missing archive files.    */
/* This all to make ezmlm-get more robust to get maximal info out of     */
/* corrupted archives.                                                   */

  msgentry **pmsgtable;         /* table of message<->subject */
  subentry **psubtable;         /* subject no, len, str char * */
  authentry **pauthtable;       /* author no, len, str char * */
  dateentry **pdatetable;       /* message per date */
  unsigned long msg_from;       /* first message in range */
  unsigned long msg_to;         /* last message in range */
  unsigned long msg_latest;     /* latest message in archive (for locking) */
  int locked;                   /* if already locked */
  char *fatal;                  /* Program-specific */

{
  unsigned long idxlatest;      /* need to lock for this (last) index file */
  unsigned long msg;            /* current msg number */
  unsigned long endmsg;         /* max msg in this idx file */
  unsigned long tmpmsg;         /* index entry's msg number */
  unsigned long idx;            /* current index file no */
  unsigned long idxto;          /* index containing end of range */
  unsigned long ulmrange;       /* total # of messages in range */
  char *subject;                /* subject on line */
  unsigned int sublen;          /* length of subject */
  char *auth;
  unsigned int authlen;
  unsigned int pos,posa;
  unsigned long submax;         /* max subject num in subtable */
  subentry *psubnext;           /* points to next entry in subtable */
  subentry *psubt;              /* points to entry in subtable */
  authentry *pauthnext;         /* points to next entry in authtable */
  authentry *pautht;            /* points to entry in authtable */
  int fd;                       /* index file handle */
  int flagmissingindex;         /* current index file is missing */
  int flagauth;                 /* read index entry has author info */
  int hasauth;                  /* current msg's entry has author info */
  msgentry *pmsgt;
  int res;
  int match;
  unsigned int datepos,datemax;
  unsigned int datetablesize,datetableunit;
  unsigned int lastdate = 0;
  unsigned int thisdate;
  register msgentry *x, *y;

                                /* a few unnecessary sanity checks */
  if (msg_to > msg_latest)
    msg_to = msg_latest;
  if (msg_to < msg_from)
    strerr_die2x(100,fatal,"Program error: bad range in idx_mkthreads");
  ulmrange = msg_to - msg_from + 1;
  if (!(*pmsgtable = (msgentry *) alloc(ulmrange * sizeof(msgentry))))
        die_nomem(fatal);
  y = *pmsgtable;
  x = y + ulmrange;             /* clear */
  while (--x >= y) {
    x->subnum = 0;
    x->authnum = 0;
    x->date = 0;
  }
                                /* max entries - acceptable waste for now */
  if (!(*psubtable = (subentry *) alloc((ulmrange+1) * sizeof(subentry))))
        die_nomem(fatal);

  if (!(*pauthtable = (authentry *) alloc((ulmrange+1) * sizeof(authentry))))
        die_nomem(fatal);
  datetableunit = DATENO * sizeof(dateentry);
  datetablesize = datetableunit;
  if (!(*pdatetable = (dateentry *) alloc(datetablesize)))
        die_nomem(fatal);
  datepos = 0;
  datemax = DATENO - 2;         /* entry 0 and end marker */
  lastdate = 0;

  idxlatest = msg_latest / 100;
  idxto = msg_to / 100;
  submax = 0;
  psubnext = *psubtable;        /* dummy node to get tree going. Basically, */
  psubt = &sdummy;              /* assure that subject > psubt-sub and that */
  init_dummy(fatal);            /* below ok unless HASHLEN > 40 */
  psubt->sub = "                                       ";
  psubt->sublen = 40;           /* there is something to hold psubt->higher */
  psubt->higher = (subentry *) 0;
  psubt->lower = (subentry *) 0;
  pauthnext = *pauthtable;
  pautht = &adummy;
  pautht->auth = psubt->sub;
  pautht->authlen = psubt->sublen;
  pautht->higher = (authentry *) 0;
  pautht->lower = (authentry *) 0;
  for (idx = msg_from / 100; idx <= idxto; idx++) {
                                /* make index file name */
    if (!stralloc_copys(&line,"archive/")) die_nomem(fatal);
    if (!stralloc_catb(&line,strnum,fmt_ulong(strnum,idx))) die_nomem(fatal);
    if (!stralloc_cats(&line,"/index")) die_nomem(fatal);
    if (!stralloc_0(&line)) die_nomem(fatal);
    if (!locked && idx == idxlatest)
      lockup(fatal);
    flagmissingindex = 0;
    fd = open_read(line.s);
    if (fd == -1) {
      if (errno == error_noent) {       /* this means the index is not here */
                                        /* but the lists is supposedly indexed*/
        flagmissingindex = 1;
      } else
        strerr_die4sys(111,fatal,ERR_OPEN,line.s,": ");
    } else
      substdio_fdbuf(&ssindex,read,fd,indexbuf,sizeof(indexbuf));

    msg = 100L * idx;                   /* current msg# */
    endmsg = msg + 99L;                 /* max msg in this index */
    if (!msg) msg = 1L;                 /* for start to make msg > tmpmsg */
    tmpmsg = 0L;                        /* msg number of read index line */
    if (endmsg > msg_to)                /* skip non-asked for subjects */
      endmsg = msg_to;
    for (; msg <= endmsg; msg++) {
      if (!flagmissingindex && (msg > tmpmsg)) {
        flagauth = 0;
        if (getln(&ssindex,&line,&match,'\n') == -1)
          strerr_die3sys(111,fatal,ERR_READ,"index: ");
        if (!match)
          flagmissingindex = 1;
        else {
          pos = scan_ulong(line.s,&tmpmsg);
          if (line.s[pos++] == ':') {
            if (getln(&ssindex,&authline,&match,'\n') == -1)
              strerr_die3sys(111,fatal,ERR_READ,"index: ");
            if (!match)
              flagmissingindex = 1;
            else {
              flagauth = 1;
            }
            pos++;
          }
        }
      }
      if (msg < msg_from)       /* Nothing before start of range */
        continue;
      if (msg == tmpmsg) {
        subject = line.s + pos;
        sublen = line.len - pos;
        if (sublen <= HASHLEN)
          strerr_die2x(100,fatal,ERR_BAD_INDEX);
        hasauth = flagauth;
      } else {
        subject = dummyind.s;
        sublen = dummyind.len;
        hasauth = 0;
      }
      for(;;) {         /* search among already known subjects */
        res = str_diffn(psubt->sub,subject,HASHLEN);
        if (res < 0) {
          if (psubt->higher)
            psubt = psubt->higher;
          else {
            newsub(psubnext,subject,sublen,msg,fatal);
            psubt->higher = psubnext;
            psubt = psubnext;
            psubnext++;
            break;
          }
        } else if (res > 0) {
          if (psubt->lower)
            psubt = psubt->lower;
          else {
            newsub(psubnext,subject,sublen,msg,fatal);
            psubt->lower = psubnext;
            psubt = psubnext;
            psubnext++;
            break;
          }
        } else {
          psubt->lastmsg = msg;
          (psubt->msginthread)++;       /* one more message in thread */
          break;
        }
      }
                                /* first subnum =1 (=0 is empty for thread) */
      pmsgt = *pmsgtable + msg - msg_from;
      pmsgt->subnum = (unsigned int) (psubt - *psubtable + 1);
      pmsgt->date = lastdate;
      if (hasauth) {
        pos = 0;
        while (authline.s[pos] && authline.s[pos] != ' ') pos++;
        if (authline.s[++pos]) {
          thisdate = date2yyyymm(authline.s + pos);
          if (thisdate) pmsgt->date = thisdate;
          if (pmsgt->date > lastdate) {
            lastdate = pmsgt->date;
            if (datepos >= datemax) {           /* more space */
              datemax += DATENO;
              if (!(*pdatetable = (dateentry *) alloc_re(*pdatetable,
                        datetablesize,datetablesize+datetableunit)))
                die_nomem(fatal);
            }
            (*pdatetable)[datepos].msg = msg;   /* first msg this mo */
            (*pdatetable)[datepos].date = lastdate;
            datepos++;
          }
          posa = byte_chr(authline.s,authline.len,';');
          if (authline.len > posa + HASHLEN + 1 && authline.s[pos+1] != ' ') {
                                        /* old: "; auth", new: ";hash auth" */
            auth = authline.s + posa + 1;
            authlen = authline.len - posa - 1;
          } else {
            auth = dummyind.s;
            authlen = dummyind.len;
          }
        }
                        /* allright! Same procedure, but for author */
        for (;;) {      /* search among already known authors */
          res = str_diffn(pautht->auth,auth,HASHLEN);
          if (res < 0) {
            if (pautht->higher)
              pautht = pautht->higher;
            else {
              newauth(pauthnext,auth,authlen,msg,fatal);
              pautht->higher = pauthnext;
              pautht = pauthnext;
              pauthnext++;
              break;
            }
          } else if (res > 0) {
            if (pautht->lower)
              pautht = pautht->lower;
            else {
              newauth(pauthnext,auth,authlen,msg,fatal);
              pautht->lower = pauthnext;
              pautht = pauthnext;
              pauthnext++;
              break;
            }
          } else {
            break;
          }
        }                       /* link from message to this author */
        pmsgt->authnum = (unsigned int) (pautht - *pauthtable + 1);
        pautht = *pauthtable;
      }

      psubt = *psubtable;       /* setup psubt. Done here rather than before */
                                /* the for loop, so that we can start off    */
                                /* the dummy node. */
    }
    if (fd != -1)
      close(fd);
    if (!locked && idx == idxlatest)
      unlock();                 /* 'locked' refers to locked before calling */
  }
  psubnext->sub = (char *) 0;           /* end of table marker */
  pauthnext->auth = (char *) 0;         /* end of table marker */
  (*pdatetable)[datepos].msg = msg_to + 1;
  (*pdatetable)[datepos].date = lastdate + 1;
}


void idx_mkthread(pmsgtable,psubtable,pauthtable,msg_from,msg_to,msg_master,
                msg_latest,locked,fatal)
/* Works like idx_mkthreads, except that it finds the subject for message   */
/* msg_master, then identifies messages in the range that have the same     */
/* subject. msgtable entries with subject 0 do not match, with '1' do match.*/

msgentry **pmsgtable;           /* pointer to table of message<->subject */
subentry **psubtable;           /* ptr to tbl of subject no, len, str char * */
authentry **pauthtable;
unsigned long msg_from;         /* first message in range */
unsigned long msg_to;           /* last message in range */
unsigned long msg_latest;       /* latest message in archive (for locking) */
unsigned long msg_master;       /* master message for single thread, else 0*/
int locked;                     /* if already locked */
char *fatal;                    /* Program-specific */

{
  unsigned long idxlatest;      /* need to lock for this (last) index file */
  unsigned long idxto;          /* index for last msg in range */
  unsigned long idx;            /* current index file no */
  unsigned long msg;            /* index entry's msg number */
  unsigned long ulmrange;       /* total # of messages in range */
  subentry *psubt;              /* points to last entry in subtable */
  int ffound;                   /* msg subject was found in subtable */
  int flagauth;                 /* there is author info */
  int firstfound = 1;           /* = 1 until first message in thread found */
  int res;                      /* comparison result */
  char *auth;
  unsigned int authlen;
  authentry *pauthnext;         /* points to next entry in authtable */
  authentry *pautht;            /* points to entry in authtable */
  unsigned int pos;
  int fd;                       /* index file handle */
  int match;
  msgentry *pmsgt;
  register msgentry *x,*y;

  if ((ulmrange = msg_to - msg_from +1) <= 0)
    strerr_die2x(100,fatal,"Program error: bad range in idx_mkthreads");
  if (!(*pmsgtable = (msgentry *) alloc(ulmrange * sizeof(msgentry))))
         die_nomem(fatal);
  y = *pmsgtable;
  x = y + ulmrange;
  while (--x >= y) {
    x->subnum = 0;
    x->authnum = 0;
    x->date = 0;
  }

  if (!(*psubtable = (subentry *) alloc(2 * sizeof(subentry))))
          die_nomem(fatal);

  if (!(*pauthtable = (authentry *) alloc((ulmrange + 1) * sizeof(authentry))))
          die_nomem(fatal);

  pauthnext = *pauthtable;
  pautht = &adummy;
  init_dummy();
  pautht->auth = "                     ";
  pautht->authlen = 21;
  pautht->higher = (authentry *) 0;
  pautht->lower = (authentry *) 0;
  idxlatest = msg_latest / 100;
  idxto = msg_to / 100;
  idx = msg_master / 100;       /* index for master subject */

                                /* Get master subject */
  if (!stralloc_copys(&line,"archive/")) die_nomem(fatal);
  if (!stralloc_catb(&line,strnum,fmt_ulong(strnum,idx))) die_nomem(fatal);
  if (!stralloc_cats(&line,"/index")) die_nomem(fatal);
  if (!stralloc_0(&line)) die_nomem(fatal);
  ffound = 0;
  if (!locked && idx == idxlatest)
    lockup(fatal);
  fd = open_read(line.s);
  psubt = *psubtable;
  if (fd == -1) {
    if (errno != error_noent)
      strerr_die4sys(111,fatal,ERR_OPEN,line.s,": ");
    else
      strerr_die2x(111,fatal,ERR_NOINDEX);      /* temp - admin can fix! */
  } else {
    substdio_fdbuf(&ssindex,read,fd,indexbuf,sizeof(indexbuf));
    for(;;) {
      if (getln(&ssindex,&line,&match,'\n') == -1)
          strerr_die3sys(111,fatal,ERR_OPEN,"index: ");
      if (!match)
        break;
      pos=scan_ulong(line.s,&msg);
      if (line.s[pos++] == ':') {        /* marker for author info */
        pos++;
        flagauth = 1;
      } else
        flagauth = 0;
      if (msg == msg_master) {
        newsub(psubt,line.s+pos,line.len-pos,msg,fatal);
                                        /* need to update msg later! */
        ffound = 1;
        break;
      }
      if (flagauth) {                   /* skip author line */
        if (getln(&ssindex,&line,&match,'\n') == -1)
          strerr_die3sys(111,fatal,ERR_OPEN,"index: ");
      if (!match)
        break;
      }
    }
    close(fd);
  }
  if (!locked && idx == idxlatest)
    unlock();
  if (!ffound)
      strerr_die2x(100,fatal,ERR_NOINDEX);
  for (idx = msg_from / 100; idx <= idxto; idx++) {
                /* make index file name */
    if (!stralloc_copys(&line,"archive/")) die_nomem(fatal);
    if (!stralloc_catb(&line,strnum,fmt_ulong(strnum,idx))) die_nomem(fatal);
    if (!stralloc_cats(&line,"/index")) die_nomem(fatal);
    if (!stralloc_0(&line)) die_nomem(fatal);
    if (!locked && idx == idxlatest)
      lockup(fatal);
    fd = open_read(line.s);
    if (fd == -1) {
      if (errno != error_noent)
        strerr_die4sys(111,fatal,ERR_OPEN,line.s,": ");
    } else {
      substdio_fdbuf(&ssindex,read,fd,indexbuf,sizeof(indexbuf));
      for(;;) {
        if (getln(&ssindex,&line,&match,'\n') == -1)
          strerr_die3sys(111,fatal,ERR_READ,"index: ");
        if (!match)
          break;
        pos=scan_ulong(line.s,&msg);
        if (line.s[pos++] == ':') {
          pos++;
          flagauth = 1;
          if (getln(&ssindex,&authline,&match,'\n') == -1)
            strerr_die3sys(111,fatal,ERR_READ,"index: ");
          if (!match)
            break;
        } else
          flagauth = 0;
        if (msg < msg_from)     /* Nothing before start of range */
          continue;
        if (msg > msg_to)       /* Don't do anything after range */
          break;
        if (!str_diffn(psubt->sub,line.s+pos,HASHLEN)) {
          pmsgt = *pmsgtable + msg - msg_from;
          if (firstfound) {     /* update to first message with this subj */
            psubt->firstmsg = msg;
            firstfound = 0;
          }
          psubt->lastmsg = msg;
          pmsgt->subnum = 1;
          if (flagauth) {
            if (*authline.s)
              pmsgt->date = date2yyyymm(authline.s + 1);
            pos = byte_chr(authline.s,authline.len,';');
            if (authline.len > pos + HASHLEN + 1 && authline.s[pos+1] != ' ') {
                                        /* old: "; auth", new: ";hash auth" */
              auth = authline.s + pos + 1;
              authlen = authline.len - pos - 1;
            } else {
              auth = dummyind.s;
              authlen = dummyind.len;
            }
            for (;;) {          /* search among already known authors */
              res = str_diffn(pautht->auth,auth,HASHLEN);
              if (res < 0) {
                if (pautht->higher)
                  pautht = pautht->higher;
                else {
                  newauth(pauthnext,auth,authlen,msg,fatal);
                  pautht->higher = pauthnext;
                  pautht = pauthnext;
                  pauthnext++;
                  break;
                }
              } else if (res > 0) {
                if (pautht->lower)
                  pautht = pautht->lower;
                else {
                  newauth(pauthnext,auth,authlen,msg,fatal);
                  pautht->lower = pauthnext;
                  pautht = pauthnext;
                  pauthnext++;
                  break;
                }
              } else {
                break;
              }
            }                   /* link from message to this author */
            pmsgt->authnum = (unsigned int) (pautht - *pauthtable + 1);
            pautht = *pauthtable;
          }

        }
      }
      close(fd);
    }
    if (!locked && idx == idxlatest)
      unlock();
  }
  ++psubt;
  psubt->sub = (char *) 0;      /* end of table marker */
  pauthnext->auth = (char *) 0; /* end of table marker */
}

void idx_mklist(pmsgtable,psubtable,pauthtable,msg_from,msg_to,fatal)
/* Like mkthreads, except that it works without a subject index. The result */
/* is just a dummy subject and a sequential list of messages. This to allow */
/* use of the same routines when creating digest from lists that have no    */
/* subject index (for whatever reason). */
msgentry **pmsgtable;           /* pointer to table of message<->subject */
subentry **psubtable;           /* ptr to tbl of subject no, len, str char * */
authentry **pauthtable;
unsigned long msg_from;         /* first message in range */
unsigned long msg_to;           /* last message in range */
char *fatal;                    /* Program-specific */
{
  unsigned long ulmrange;
  register msgentry *x,*y;
  subentry *psubt;
  authentry *pautht;

  if ((ulmrange = msg_to - msg_from +1) <= 0)
    strerr_die2x(111,fatal,"bad range in idx_mkthreads :");

  if (!(*pmsgtable = (msgentry *) alloc(ulmrange * sizeof(msgentry))))
         die_nomem(fatal);

  y = *pmsgtable;
  x = y + ulmrange;
  while (--x >= y) {
    x->subnum = 1;
    x->authnum = 0;
    x->date = 0;
  }

  if (!(*psubtable = (subentry *) alloc(2 * sizeof(subentry))))
          die_nomem(fatal);
  psubt = *psubtable;
  newsub(psubt,dummyind.s,dummyind.len,msg_from,fatal);
  psubt->lastmsg = msg_to;
  ++psubt;
  psubt->sub = (char *) 0;
  if (!(*pauthtable = (authentry *) alloc(sizeof(authentry))))
          die_nomem(fatal);     /* nodata. Avoid dangling ptr. */
  pautht = *pauthtable;
  pautht->auth = 0;             /* tells app that there are no author data */
  pautht->higher = (authentry *) 0;
  pautht->lower = (authentry *) 0;
}

void idx_destroythread(msgtable,subtable,authtable)
/* Frees space allocated by idxthread routines. This is needed only if */
/* one does several threadings in one program run. Otherwise, exit()   */
/* should free all allocated memory, which will be faster. */
msgentry *msgtable; subentry *subtable; authentry *authtable;
{
  subentry *psubt;
  authentry *pautht;

  psubt = subtable;             /* free subjects */
  while(psubt->sub) {
    alloc_free(psubt->sub);
    psubt++;
  }

  pautht = authtable;           /* free authors */
  while(pautht->auth) {
    alloc_free(pautht->auth);
    pautht++;
  }

  alloc_free(subtable);         /* free subtable */
  alloc_free(authtable);        /* free authtable */
  alloc_free(msgtable);         /* free msgtable */
  subtable = (subentry *) 0;    /* kill pointers */
  authtable = (authentry *) 0;
  msgtable = (msgentry *) 0;
}