home *** CD-ROM | disk | FTP | other *** search
/ ftp.wwiv.com / ftp.wwiv.com.zip / ftp.wwiv.com / pub / MISC / LO241SRV.ZIP / QUICKMS2.C < prev    next >
Text File  |  1998-05-17  |  50KB  |  1,702 lines
  1.  
  2. // LoraBBS Version 2.41 Free Edition
  3. // Copyright (C) 1987-98 Marco Maccaferri
  4. //
  5. // This program is free software; you can redistribute it and/or modify
  6. // it under the terms of the GNU General Public License as published by
  7. // the Free Software Foundation; either version 2 of the License, or
  8. // (at your option) any later version.
  9. //
  10. // This program is distributed in the hope that it will be useful,
  11. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. // GNU General Public License for more details.
  14. //
  15. // You should have received a copy of the GNU General Public License
  16. // along with this program; if not, write to the Free Software
  17. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  
  19. #include <stdio.h>
  20. #include <time.h>
  21. #include <string.h>
  22. #include <stdlib.h>
  23. #include <io.h>
  24. #include <fcntl.h>
  25. #include <sys\stat.h>
  26.  
  27. #include <cxl\cxlvid.h>
  28.  
  29. #include "lsetup.h"
  30. #include "sched.h"
  31. #include "msgapi.h"
  32. #include "externs.h"
  33. #include "prototyp.h"
  34. #include "quickmsg.h"
  35.  
  36. #define MAX_MESSAGES    1000
  37.  
  38. char *pascal_string (char *);
  39. int quick_msg_attrib(struct _msghdr *, int, int, int);
  40. void quick_text_header(struct _msghdr *, int, FILE *);
  41. int quick_full_read_message (int, struct _msghdr *, struct _gold_msghdr *, int);
  42. void write_pascal_string (char *, char *, word *, word *, FILE *);
  43. void quick_qwk_text_header (struct _msghdr *, int, FILE *, struct QWKmsghd *, long *);
  44. void add_quote_string (char *str, char *from);
  45. void add_quote_header (FILE *fp, char *from, char *to, char *subj, char *dt, char *tm);
  46. int gold_msg_attrib(struct _gold_msghdr *, int, int, int);
  47. void gold_qwk_text_header (struct _gold_msghdr *, int, FILE *, struct QWKmsghd *, long *);
  48. void gold_text_header (struct _gold_msghdr *, int, FILE *);
  49. void bluewave_header (int fdi, long startpos, long numbytes, int msgnum, struct _msg *msgt);
  50.  
  51. extern long *msgidx;
  52. extern int msg_parent, msg_child;
  53. extern struct _msginfo msginfo;
  54. extern struct _gold_msginfo gmsginfo;
  55. extern char *internet_to;
  56.  
  57. void quick_scan_message_base (board, gold_board, area, upd)
  58. int board, gold_board, area;
  59. char upd;
  60. {
  61.    #define MAXREADIDX   100
  62.    int fd, tnum_msg, i, m, x;
  63.    char filename[80];
  64.    long gnum_msg;
  65.    struct _msgidx idx[MAXREADIDX];
  66.    struct _gold_msgidx gidx[MAXREADIDX];
  67.  
  68.    if (gold_board) {
  69.       sprintf (filename, "%sMSGINFO.DAT", fido_msgpath);
  70.       fd = sh_open (filename, SH_DENYWR, O_RDONLY|O_BINARY, S_IREAD|S_IWRITE);
  71.       read (fd, (char *)&gmsginfo, sizeof (struct _gold_msginfo));
  72.       close (fd);
  73.    }
  74.    else {
  75.       sprintf (filename, "%sMSGINFO.BBS", fido_msgpath);
  76.       fd = sh_open (filename, SH_DENYWR, O_RDONLY|O_BINARY, S_IREAD|S_IWRITE);
  77.       read (fd, (char *)&msginfo, sizeof (struct _msginfo));
  78.       close (fd);
  79.    }
  80.  
  81.    msg_parent = msg_child = 0;
  82.    tnum_msg = 0;
  83.    gnum_msg = 0;
  84.    i = 1;
  85.  
  86.    if (msgidx == NULL)
  87.       msgidx = (long *)malloc (MAX_MESSAGES * sizeof (long));
  88.  
  89.    if (gold_board) {
  90.       msgidx[0] = 0;
  91.       gmsginfo.totalonboard[gold_board - 1] = 0;
  92.  
  93.       sprintf (filename, "%sMSGIDX.DAT", fido_msgpath);
  94.    }
  95.    else {
  96.       msgidx[0] = 0;
  97.       msginfo.totalonboard[board - 1] = 0;
  98.  
  99.       sprintf (filename, "%sMSGIDX.BBS", fido_msgpath);
  100.    }
  101.  
  102.    fd = sh_open (filename, SH_DENYNONE, O_RDONLY|O_BINARY, S_IREAD|S_IWRITE);
  103.  
  104.    if (gold_board) {
  105.       do {
  106.          m = read (fd, (char *)&gidx, sizeof (struct _gold_msgidx) * MAXREADIDX);
  107.          m /= sizeof (struct _gold_msgidx);
  108.  
  109.          for (x = 0; x < m; x++) {
  110.                 if (gidx[x].board == gold_board && gidx[x].msgnum > 0) {
  111.                msgidx[i++] = gnum_msg;
  112.                gmsginfo.totalonboard[gold_board - 1]++;
  113.             }
  114.  
  115.             gnum_msg++;
  116.  
  117.             if (i >= MAX_MESSAGES)
  118.                break;
  119.          }
  120.       } while (m == MAXREADIDX);
  121.  
  122.       tnum_msg = (int)gmsginfo.totalonboard[gold_board - 1];
  123.    }
  124.    else {
  125.       do {
  126.          m = read (fd, (char *)&idx, sizeof (struct _msgidx) * MAXREADIDX);
  127.          m /= sizeof (struct _msgidx);
  128.  
  129.          for (x = 0; x < m; x++) {
  130.                 if (idx[x].board == board && idx[x].msgnum > 0 ) {
  131.                msgidx[i++] = tnum_msg;
  132.                msginfo.totalonboard[board - 1]++;
  133.             }
  134.  
  135.             tnum_msg++;
  136.  
  137.             if (i >= MAX_MESSAGES)
  138.                break;
  139.          }
  140.       } while (m == MAXREADIDX);
  141.  
  142.       tnum_msg = msginfo.totalonboard[board - 1];
  143.    }
  144.  
  145.    close (fd);
  146.  
  147.    if (tnum_msg) {
  148.       first_msg = 1;
  149.       last_msg = tnum_msg;
  150.       num_msg = tnum_msg;
  151.    }
  152.    else {
  153.       first_msg = 0;
  154.       last_msg = 0;
  155.       num_msg = 0;
  156.    }
  157.  
  158.    for (i = 0; i < MAXLREAD; i++)
  159.       if (usr.lastread[i].area == area)
  160.          break;
  161.    if (i != MAXLREAD) {
  162.       if (usr.lastread[i].msg_num > last_msg)
  163.          usr.lastread[i].msg_num = last_msg;
  164.       lastread = usr.lastread[i].msg_num;
  165.    }
  166.    else {
  167.       for (i = 0; i < MAXDLREAD; i++)
  168.          if (usr.dynlastread[i].area == area)
  169.             break;
  170.       if (i != MAXDLREAD) {
  171.          if (usr.dynlastread[i].msg_num > last_msg)
  172.             usr.dynlastread[i].msg_num = last_msg;
  173.          lastread = usr.dynlastread[i].msg_num;
  174.       }
  175.       else if (upd) {
  176.          lastread = 0;
  177.          for (i = 1; i < MAXDLREAD; i++) {
  178.             usr.dynlastread[i - 1].area = usr.dynlastread[i].area;
  179.             usr.dynlastread[i - 1].msg_num = usr.dynlastread[i].msg_num;
  180.          }
  181.  
  182.          usr.dynlastread[i - 1].area = area;
  183.          usr.dynlastread[i - 1].msg_num = 0;
  184.       }
  185.       else
  186.          lastread = 0;
  187.    }
  188.  
  189.    if (lastread < 0)
  190.       lastread = 0;
  191. }
  192.  
  193. int quick_read_message (int msg_num, int flag, int fakenum)
  194. {
  195.    FILE *fp;
  196.    int i, z, m, line, colf=0, pp, shead;
  197.    char c, buff[150], wrp[150], *p, okludge;
  198.    long fpos, absnum, startpos;
  199.    struct _msghdr msghdr;
  200.    struct _gold_msghdr gmsghdr;
  201.  
  202.    okludge = 0;
  203.    line = 1;
  204.    shead = 0;
  205.    msg_fzone = msg_tzone = config->alias[sys.use_alias].zone;
  206.    msg_fpoint = msg_tpoint = 0;
  207.    absnum = msgidx[msg_num];
  208.  
  209.    if (sys.gold_board) {
  210.       sprintf (buff, "%sMSGHDR.DAT", fido_msgpath);
  211.       i = sh_open (buff, SH_DENYNONE, O_RDWR|O_BINARY, S_IREAD|S_IWRITE);
  212.       if (i == -1)
  213.          return (0);
  214.       fp = fdopen (i, "r+b");
  215.       if (fp == NULL)
  216.          return (0);
  217.  
  218.       fseek (fp, (long)sizeof (struct _gold_msghdr) * absnum, SEEK_SET);
  219.       fread ((char *)&gmsghdr, sizeof (struct _gold_msghdr), 1, fp);
  220.  
  221.         if (gmsghdr.msgattr & Q_RECKILL)
  222.          return (0);
  223.  
  224.       if (gmsghdr.msgattr & Q_PRIVATE)
  225.          if (stricmp (pascal_string (gmsghdr.whofrom), usr.name) && stricmp (pascal_string (gmsghdr.whoto), usr.name) && stricmp (pascal_string (gmsghdr.whofrom), usr.handle) && stricmp (pascal_string (gmsghdr.whoto), usr.handle) && usr.priv != SYSOP) {
  226.             fclose (fp);
  227.             return (0);
  228.          }
  229.  
  230.       gmsghdr.timesread++;
  231.  
  232.       if (!stricmp (pascal_string (gmsghdr.whoto), usr.name) || !stricmp (pascal_string (gmsghdr.whoto), usr.handle))
  233.          gmsghdr.msgattr |= Q_RECEIVED;
  234.  
  235.       fseek (fp, (long)sizeof (struct _gold_msghdr) * absnum, SEEK_SET);
  236.       fwrite ((char *)&gmsghdr, sizeof (struct _gold_msghdr), 1, fp);
  237.  
  238.       fclose (fp);
  239.  
  240.       for (i = first_msg; i <= last_msg; i++)
  241.          if (gmsghdr.prevreply == msgidx[i])
  242.             break;
  243.       if (i <= last_msg)
  244.          msg_parent = i;
  245.  
  246.       for (i = first_msg; i <= last_msg; i++)
  247.          if (gmsghdr.nextreply == msgidx[i])
  248.             break;
  249.       if (i <= last_msg)
  250.          msg_child = i;
  251.    }
  252.    else {
  253.       sprintf (buff, "%sMSGHDR.BBS", fido_msgpath);
  254.       i = sh_open (buff, SH_DENYNONE, O_RDWR|O_BINARY, S_IREAD|S_IWRITE);
  255.       if (i == -1)
  256.          return (0);
  257.       fp = fdopen (i, "r+b");
  258.       if (fp == NULL)
  259.          return (0);
  260.  
  261.       fseek (fp, (long)sizeof (struct _msghdr) * absnum, SEEK_SET);
  262.       fread ((char *)&msghdr, sizeof (struct _msghdr), 1, fp);
  263.  
  264.         if (msghdr.msgattr & Q_RECKILL)
  265.          return (0);
  266.  
  267.       if (msghdr.msgattr & Q_PRIVATE)
  268.          if (stricmp (pascal_string (msghdr.whofrom), usr.name) && stricmp (pascal_string (msghdr.whoto), usr.name) &&
  269.          stricmp (pascal_string (msghdr.whofrom), usr.handle) && stricmp (pascal_string (msghdr.whoto), usr.handle) && usr.priv != SYSOP) {
  270.             fclose (fp);
  271.             return (0);
  272.          }
  273.  
  274.       msghdr.timesread++;
  275.  
  276.       if (!stricmp (pascal_string (msghdr.whoto), usr.name)||!stricmp(pascal_string (msghdr.whoto), usr.handle))
  277.          msghdr.msgattr |= Q_RECEIVED;
  278.  
  279.       fseek (fp, (long)sizeof (struct _msghdr) * absnum, SEEK_SET);
  280.       fwrite ((char *)&msghdr, sizeof(struct _msghdr), 1, fp);
  281.  
  282.       fclose (fp);
  283.  
  284.       for (i = first_msg; i <= last_msg; i++)
  285.          if (msghdr.prevreply == msgidx[i])
  286.             break;
  287.       if (i <= last_msg)
  288.          msg_parent = i;
  289.  
  290.       for (i = first_msg; i <= last_msg; i++)
  291.          if (msghdr.nextreply == msgidx[i])
  292.             break;
  293.       if (i <= last_msg)
  294.          msg_child = i;
  295.    }
  296.  
  297.    allow_reply = 1;
  298.  
  299.    if (!flag)
  300.       cls ();
  301.  
  302.    if (usr.full_read && !flag) {
  303.       if (sys.gold_board)
  304.          return (quick_full_read_message (msg_num, NULL, &gmsghdr, fakenum));
  305.       else
  306.          return (quick_full_read_message (msg_num, &msghdr, NULL, fakenum));
  307.    }
  308.  
  309.    if (flag)
  310.       m_print (bbstxt[B_TWO_CR]);
  311.  
  312.    if (sys.gold_board) {
  313.       fpos = 256L * (gmsghdr.startblock + gmsghdr.numblocks - 1);
  314.       sprintf (buff, "%sMSGTXT.DAT", fido_msgpath);
  315.    }
  316.    else {
  317.       fpos = 256L * (msghdr.startblock + msghdr.numblocks - 1);
  318.       sprintf (buff, "%sMSGTXT.BBS", fido_msgpath);
  319.    }
  320.    i = sh_open (buff, SH_DENYNONE, O_RDONLY|O_BINARY, S_IREAD|S_IWRITE);
  321.    fp = fdopen (i,"rb");
  322.  
  323.    fseek (fp, fpos, SEEK_SET);
  324.    fpos += fgetc (fp);
  325.  
  326.    if (sys.gold_board)
  327.       startpos = 256L * gmsghdr.startblock;
  328.    else
  329.       startpos = 256L * msghdr.startblock;
  330.  
  331.    fseek (fp, startpos, SEEK_SET);
  332.  
  333.    change_attr (WHITE|_BLACK);
  334.    m_print (" * %s\n", sys.msg_name);
  335.  
  336.    change_attr (CYAN|_BLACK);
  337.  
  338.    i = 0;
  339.    pp = 0;
  340.  
  341.    while (ftell(fp) < fpos) {
  342.       if (!pp)
  343.          fgetc (fp);
  344.  
  345.       c = fgetc (fp);
  346.       pp++;
  347.  
  348.       if (c == '\0')
  349.          break;
  350.  
  351.       if (pp == 255)
  352.          pp = 0;
  353.  
  354.       if ((byte)c == 0x8D || c == 0x0A || c == '\0')
  355.          continue;
  356.  
  357.       buff[i++] = c;
  358.  
  359.       if (c == 0x0D) {
  360.          buff[i - 1] = '\0';
  361.  
  362.          if(buff[0] == 0x01 && !okludge) {
  363.             if (!strncmp(&buff[1],"INTL",4) && !shead)
  364.                sscanf(&buff[6],"%d:%d/%d %d:%d/%d",&msg_tzone,&i,&i,&msg_fzone,&i,&i);
  365.             if (!strncmp(&buff[1],"TOPT",4) && !shead)
  366.                sscanf(&buff[6],"%d",&msg_tpoint);
  367.             if (!strncmp(&buff[1],"FMPT",4) && !shead)
  368.                sscanf(&buff[6],"%d",&msg_fpoint);
  369.             i = 0;
  370.             continue;
  371.          }
  372.          else if (!shead) {
  373.             if (sys.gold_board)
  374.                line = gold_msg_attrib (&gmsghdr, fakenum ? fakenum : msg_num, line, 0);
  375.             else
  376.                line = quick_msg_attrib (&msghdr, fakenum ? fakenum : msg_num, line, 0);
  377.             m_print (bbstxt[B_ONE_CR]);
  378.             shead = 1;
  379.             okludge = 1;
  380.             fseek (fp, startpos, SEEK_SET);
  381.             pp = 0;
  382.             i = 0;
  383.             continue;
  384.          }
  385.  
  386.          if (!usr.kludge && (!strncmp (buff, "SEEN-BY", 7) || buff[0] == 0x01)) {
  387.             i = 0;
  388.             continue;
  389.          }
  390.  
  391.          if (buff[0] == 0x01) {
  392.             m_print (" %s\n", &buff[1]);
  393.             change_attr (CYAN|BLACK);
  394.          }
  395.          else if (!strncmp (buff, "SEEN-BY", 7)) {
  396.             m_print (" %s\n", buff);
  397.             change_attr (LGREY|BLACK);
  398.          }
  399.          else {
  400.             p = &buff[0];
  401.  
  402.             if(((strchr(buff,'>') - p) < 6) && (strchr(buff,'>'))) {
  403.                if(!colf) {
  404.                   change_attr(WHITE|BLACK);
  405.                   colf=1;
  406.                }
  407.             }
  408.             else {
  409.                if(colf) {
  410.                   change_attr(CYAN|_BLACK);
  411.                   colf=0;
  412.                }
  413.             }
  414.  
  415.             if (!strncmp(buff,msgtxt[M_TEAR_LINE],4) || !strncmp(buff,msgtxt[M_ORIGIN_LINE],11))
  416.                m_print("%s\n",buff);
  417.             else
  418.                m_print("%s\n",buff);
  419.  
  420.             if (!strncmp(buff,msgtxt[M_ORIGIN_LINE],11))
  421.                gather_origin_netnode (buff);
  422.          }
  423.  
  424.          i=0;
  425.  
  426.          if(flag == 1)
  427.             line=1;
  428.  
  429.          if(!(++line < (usr.len-1)) && usr.more) {
  430.             if(!continua()) {
  431.                flag=1;
  432.                break;
  433.             }
  434.             else
  435.                line=1;
  436.          }
  437.       }
  438.       else {
  439.          if(i<(usr.width-1))
  440.             continue;
  441.  
  442.          buff[i] = '\0';
  443.          while (i > 0 && buff[i] != ' ')
  444.             i--;
  445.  
  446.          m = 0;
  447.  
  448.          if (i != 0)
  449.             for (z = i + 1; buff[z]; z++)
  450.                wrp[m++] = buff[z];
  451.  
  452.          buff[i] = '\0';
  453.          wrp[m] = '\0';
  454.  
  455.          if (!shead) {
  456.             if (sys.gold_board)
  457.                line = gold_msg_attrib (&gmsghdr, fakenum ? fakenum : msg_num, line, 0);
  458.             else
  459.                line = quick_msg_attrib (&msghdr, fakenum ? fakenum : msg_num, line, 0);
  460.             m_print(bbstxt[B_ONE_CR]);
  461.             shead = 1;
  462.             okludge = 1;
  463.             fseek (fp, startpos, SEEK_SET);
  464.             pp = 0;
  465.             i = 0;
  466.             continue;
  467.          }
  468.  
  469.          if (((strchr(buff,'>') - buff) < 6) && (strchr(buff,'>'))) {
  470.             if(!colf) {
  471.                change_attr(WHITE|_BLACK);
  472.                colf=1;
  473.             }
  474.          }
  475.          else {
  476.             if(colf) {
  477.                change_attr(CYAN|_BLACK);
  478.                colf=0;
  479.             }
  480.          }
  481.  
  482.          if (!strncmp(buff,msgtxt[M_TEAR_LINE],4) || !strncmp(buff,msgtxt[M_ORIGIN_LINE],10))
  483.             m_print("%s\n",buff);
  484.          else
  485.             m_print("%s\n",buff);
  486.  
  487.          if (!strncmp(buff,msgtxt[M_ORIGIN_LINE],11))
  488.             gather_origin_netnode (buff);
  489.  
  490.          if(flag == 1)
  491.             line=1;
  492.  
  493.          if(!(++line < (usr.len-1)) && usr.more) {
  494.             if(!continua()) {
  495.                flag=1;
  496.                break;
  497.             }
  498.             else
  499.                line=1;
  500.          }
  501.  
  502.          strcpy(buff,wrp);
  503.          i=strlen(wrp);
  504.       }
  505.    }
  506.    fclose(fp);
  507.  
  508.    if (!shead) {
  509.       if (sys.gold_board)
  510.          line = gold_msg_attrib (&gmsghdr, msg_num, line, 0);
  511.       else
  512.          line = quick_msg_attrib (&msghdr, msg_num, line, 0);
  513.       m_print (bbstxt[B_ONE_CR]);
  514.       shead = 1;
  515.    }
  516.  
  517.    if (line > 1 && !flag && usr.more) {
  518.       press_enter ();
  519.       line = 1;
  520.    }
  521.  
  522.    return (1);
  523. }
  524.  
  525. int quick_full_read_message (msg_num, msghdr, gmsghdr, fakenum)
  526. int msg_num;
  527. struct _msghdr *msghdr;
  528. struct _gold_msghdr *gmsghdr;
  529. int fakenum;
  530. {
  531.    FILE *fp;
  532.    int i, z, m, line, colf=0, pp, shead;
  533.    char c, buff[150], wrp[150], *p, okludge;
  534.    long fpos, startpos;
  535.  
  536.    okludge = 0;
  537.    line = 2;
  538.    shead = 0;
  539.    msg_fzone = msg_tzone = config->alias[sys.use_alias].zone;
  540.    msg_fpoint = msg_tpoint = 0;
  541.  
  542.    if (gmsghdr != NULL) {
  543.       sprintf (buff, "%sMSGTXT.DAT", fido_msgpath);
  544.       if ((i = sh_open (buff, SH_DENYNONE, O_RDONLY|O_BINARY, S_IREAD|S_IWRITE)) == -1)
  545.          return (1);
  546.       if ((fp = fdopen (i, "rb")) == NULL) {
  547.          close (i);
  548.          return (1);
  549.       }
  550.  
  551.       fpos = 256L * (gmsghdr->startblock + gmsghdr->numblocks - 1);
  552.       fseek (fp, fpos, SEEK_SET);
  553.       fpos += fgetc (fp);
  554.  
  555.       startpos = 256L * gmsghdr->startblock;
  556.    }
  557.    else {
  558.       sprintf (buff, "%sMSGTXT.BBS", fido_msgpath);
  559.       i = sh_open (buff, SH_DENYNONE, O_RDONLY|O_BINARY, S_IREAD|S_IWRITE);
  560.       fp = fdopen (i,"rb");
  561.  
  562.       fpos = 256L * (msghdr->startblock + msghdr->numblocks - 1);
  563.       fseek (fp, fpos, SEEK_SET);
  564.       fpos += fgetc (fp);
  565.  
  566.       startpos = 256L * msghdr->startblock;
  567.    }
  568.  
  569.    fseek (fp, startpos, SEEK_SET);
  570.  
  571.    change_attr (BLUE|_LGREY);
  572.    del_line ();
  573.    m_print (" * %s\n", sys.msg_name);
  574.  
  575.    i = 0;
  576.    pp = 0;
  577.  
  578.    while (ftell (fp) < fpos) {
  579.       if (!pp)
  580.          fgetc (fp);
  581.  
  582.       c = fgetc (fp);
  583.       pp++;
  584.  
  585.       if (c == '\0')
  586.          break;
  587.  
  588.       if (pp == 255)
  589.          pp = 0;
  590.  
  591.       if ((byte)c == 0x8D || c == 0x0A || c == '\0')
  592.          continue;
  593.  
  594.       buff[i++] = c;
  595.  
  596.       if (c == 0x0D) {
  597.          buff[i-1]='\0';
  598.  
  599.          if (buff[0] == 0x01 && !okludge) {
  600.             if (!strncmp(&buff[1],"INTL",4) && !shead)
  601.                sscanf(&buff[6],"%d:%d/%d %d:%d/%d",&msg_tzone,&i,&i,&msg_fzone,&i,&i);
  602.             if (!strncmp(&buff[1],"TOPT",4) && !shead)
  603.                sscanf(&buff[6],"%d",&msg_tpoint);
  604.             if (!strncmp(&buff[1],"FMPT",4) && !shead)
  605.                sscanf(&buff[6],"%d",&msg_fpoint);
  606.             i = 0;
  607.             continue;
  608.          }
  609.          else if (!shead) {
  610.             if (gmsghdr != NULL)
  611.                line = gold_msg_attrib (gmsghdr, fakenum ? fakenum : msg_num, line, 0);
  612.             else
  613.                line = quick_msg_attrib (msghdr, fakenum ? fakenum : msg_num, line, 0);
  614.             change_attr(LGREY|_BLUE);
  615.             del_line();
  616.             change_attr(CYAN|_BLACK);
  617.             m_print(bbstxt[B_ONE_CR]);
  618.             shead = 1;
  619.             okludge = 1;
  620.             fseek (fp, startpos, SEEK_SET);
  621.             pp = 0;
  622.             i = 0;
  623.             continue;
  624.          }
  625.  
  626.          if (!usr.kludge && (!strncmp (buff, "SEEN-BY", 7) || buff[0] == 0x01)) {
  627.             i = 0;
  628.             continue;
  629.          }
  630.  
  631.          if (buff[0] == 0x01) {
  632.             m_print (" %s\n", &buff[1]);
  633.             change_attr (CYAN|BLACK);
  634.          }
  635.          else if (!strncmp (buff, "SEEN-BY", 7)) {
  636.             m_print (" %s\n", buff);
  637.             change_attr (LGREY|BLACK);
  638.          }
  639.          else {
  640.             p = &buff[0];
  641.  
  642.             if(((strchr(buff,'>') - p) < 6) && (strchr(buff,'>'))) {
  643.                if(!colf) {
  644.                   change_attr(WHITE|BLACK);
  645.                   colf=1;
  646.                }
  647.             }
  648.             else {
  649.                if(colf) {
  650.                   change_attr(CYAN|_BLACK);
  651.                   colf=0;
  652.                }
  653.             }
  654.  
  655.             if (!strncmp(buff,msgtxt[M_TEAR_LINE],4) || !strncmp(buff,msgtxt[M_ORIGIN_LINE],11))
  656.                m_print("%s\n",buff);
  657.             else
  658.                m_print("%s\n",buff);
  659.  
  660.             if (!strncmp(buff,msgtxt[M_ORIGIN_LINE],11))
  661.                gather_origin_netnode (buff);
  662.          }
  663.  
  664.          i=0;
  665.  
  666.          if(!(++line < (usr.len-1)) && usr.more) {
  667.             if(!continua()) {
  668.                line = 1;
  669.                break;
  670.             }
  671.             else {
  672.                while (line > 5) {
  673.                   cpos(line--, 1);
  674.                   del_line();
  675.                }
  676.             }
  677.          }
  678.       }
  679.       else {
  680.          if(i<(usr.width-1))
  681.             continue;
  682.  
  683.          buff[i]='\0';
  684.          while(i>0 && buff[i] != ' ')
  685.             i--;
  686.  
  687.          m=0;
  688.  
  689.          if(i != 0)
  690.             for(z=i+1;buff[z];z++)
  691.                wrp[m++]=buff[z];
  692.  
  693.          buff[i]='\0';
  694.          wrp[m]='\0';
  695.  
  696.          if (!shead) {
  697.             if (gmsghdr != NULL)
  698.                line = gold_msg_attrib (gmsghdr, fakenum ? fakenum : msg_num, line, 0);
  699.             else
  700.                line = quick_msg_attrib (msghdr, fakenum ? fakenum : msg_num, line, 0);
  701.             change_attr (LGREY|_BLUE);
  702.             del_line ();
  703.             change_attr (CYAN|_BLACK);
  704.             m_print (bbstxt[B_ONE_CR]);
  705.             shead = 1;
  706.             okludge = 1;
  707.             fseek (fp, startpos, SEEK_SET);
  708.             pp = 0;
  709.             i = 0;
  710.             continue;
  711.          }
  712.  
  713.          if (((strchr(buff,'>') - buff) < 6) && (strchr(buff,'>'))) {
  714.             if(!colf) {
  715.                change_attr(WHITE|_BLACK);
  716.                colf=1;
  717.             }
  718.          }
  719.          else {
  720.             if(colf) {
  721.                change_attr(CYAN|_BLACK);
  722.                colf=0;
  723.             }
  724.          }
  725.  
  726.          if (!strncmp (buff, msgtxt[M_TEAR_LINE], 4) || !strncmp (buff, msgtxt[M_ORIGIN_LINE], 10))
  727.             m_print ("%s\n", buff);
  728.          else
  729.             m_print ("%s\n", buff);
  730.  
  731.          if (!strncmp (buff, msgtxt[M_ORIGIN_LINE], 11))
  732.             gather_origin_netnode (buff);
  733.  
  734.          if (!(++line < (usr.len - 1)) && usr.more) {
  735.             if(!continua ()) {
  736.                line = 1;
  737.                break;
  738.             }
  739.             else {
  740.                while (line > 5) {
  741.                   cpos (line--, 1);
  742.                   del_line ();
  743.                }
  744.             }
  745.          }
  746.  
  747.          strcpy (buff, wrp);
  748.          i = strlen (wrp);
  749.       }
  750.    }
  751.  
  752.    fclose (fp);
  753.  
  754.    if (!shead) {
  755.       if (gmsghdr != NULL)
  756.          line = gold_msg_attrib (gmsghdr, msg_num, line, 0);
  757.       else
  758.          line = quick_msg_attrib (msghdr, msg_num, line, 0);
  759.       m_print (bbstxt[B_ONE_CR]);
  760.       shead = 1;
  761.    }
  762.  
  763.    if (line > 1 && usr.more) {
  764.       press_enter ();
  765.       line = 1;
  766.    }
  767.  
  768.    return (1);
  769. }
  770.  
  771. int quick_msg_attrib (msgt, s, line, f)
  772. struct _msghdr *msgt;
  773. int s, line, f;
  774. {
  775.    int dy, mo, yr, hh, mm;
  776.    char stringa[20];
  777.    struct _msg tmsg;
  778.  
  779.    memset ((char *)&tmsg, 0, sizeof (struct _msg));
  780.  
  781.    if (msgt->msgattr & Q_PRIVATE)
  782.       tmsg.attr |= MSGPRIVATE;
  783.    if(msgt->msgattr & Q_RECEIVED)
  784.       tmsg.attr |= MSGREAD;
  785.    if(msgt->netattr & Q_CRASH)
  786.       tmsg.attr |= MSGCRASH;
  787.    if(msgt->netattr & Q_SENT)
  788.       tmsg.attr |= MSGSENT;
  789.    if(msgt->netattr & Q_FILE)
  790.       tmsg.attr |= MSGFILE;
  791.    if(msgt->netattr & Q_KILL)
  792.       tmsg.attr |= MSGKILL;
  793.    if(msgt->netattr & Q_FRQ)
  794.       tmsg.attr |= MSGFRQ;
  795.    if(msgt->netattr & Q_CPT)
  796.       tmsg.attr |= MSGCPT;
  797.    if(msgt->netattr & Q_ARQ)
  798.       tmsg.attr |= MSGARQ;
  799.  
  800.    strcpy (tmsg.to, pascal_string (msgt->whoto));
  801.    strcpy (tmsg.from, pascal_string (msgt->whofrom));
  802.    strcpy (tmsg.subj, pascal_string (msgt->subject));
  803.  
  804.    strcpy(stringa,pascal_string(msgt->date));
  805.    sscanf(stringa,"%2d-%2d-%2d",&mo,&dy,&yr);
  806.    strcpy(stringa,pascal_string(msgt->time));
  807.    sscanf(stringa,"%2d:%2d",&hh,&mm);
  808.    sprintf(tmsg.date, "%02d %s %02d  %2d:%02d:00", dy, mtext[mo-1], yr, hh, mm);
  809.  
  810.    line = msg_attrib (&tmsg, s, line, f);
  811.    memcpy ((char *)&msg, (char *)&tmsg, sizeof (struct _msg));
  812.  
  813.    return (line);
  814. }
  815.  
  816. int gold_msg_attrib (msgt, s, line, f)
  817. struct _gold_msghdr *msgt;
  818. int s, line, f;
  819. {
  820.    int dy, mo, yr, hh, mm;
  821.    char stringa[20];
  822.    struct _msg tmsg;
  823.  
  824.    memset ((char *)&tmsg, 0, sizeof (struct _msg));
  825.  
  826.    if (msgt->msgattr & Q_PRIVATE)
  827.       tmsg.attr |= MSGPRIVATE;
  828.    if(msgt->msgattr & Q_RECEIVED)
  829.       tmsg.attr |= MSGREAD;
  830.    if(msgt->netattr & Q_CRASH)
  831.       tmsg.attr |= MSGCRASH;
  832.    if(msgt->netattr & Q_SENT)
  833.       tmsg.attr |= MSGSENT;
  834.    if(msgt->netattr & Q_FILE)
  835.       tmsg.attr |= MSGFILE;
  836.    if(msgt->netattr & Q_KILL)
  837.       tmsg.attr |= MSGKILL;
  838.    if(msgt->netattr & Q_FRQ)
  839.       tmsg.attr |= MSGFRQ;
  840.    if(msgt->netattr & Q_CPT)
  841.       tmsg.attr |= MSGCPT;
  842.    if(msgt->netattr & Q_ARQ)
  843.       tmsg.attr |= MSGARQ;
  844.  
  845.    strcpy (tmsg.to, pascal_string (msgt->whoto));
  846.    strcpy (tmsg.from, pascal_string (msgt->whofrom));
  847.    strcpy (tmsg.subj, pascal_string (msgt->subject));
  848.  
  849.    strcpy(stringa,pascal_string(msgt->date));
  850.    sscanf(stringa,"%2d-%2d-%2d",&mo,&dy,&yr);
  851.    strcpy(stringa,pascal_string(msgt->time));
  852.    sscanf(stringa,"%2d:%2d",&hh,&mm);
  853.    sprintf(tmsg.date, "%02d %s %02d  %2d:%02d:00", dy, mtext[mo-1], yr, hh, mm);
  854.  
  855.    line = msg_attrib (&tmsg, s, line, f);
  856.    memcpy ((char *)&msg, (char *)&tmsg, sizeof (struct _msg));
  857.  
  858.    return (line);
  859. }
  860.  
  861. void quick_text_header(msgt, s, fp)
  862. struct _msghdr *msgt;
  863. int s;
  864. FILE *fp;
  865. {
  866.    int dy, mo, yr, hh, mm;
  867.    char stringa[20];
  868.    struct _msg tmsg;
  869.  
  870.    memset ((char *)&tmsg, 0, sizeof (struct _msg));
  871.  
  872.    if (msgt->msgattr & Q_PRIVATE)
  873.       tmsg.attr |= MSGPRIVATE;
  874.    if(msgt->msgattr & Q_RECEIVED)
  875.       tmsg.attr |= MSGREAD;
  876.    if(msgt->netattr & Q_CRASH)
  877.       tmsg.attr |= MSGCRASH;
  878.    if(msgt->netattr & Q_SENT)
  879.       tmsg.attr |= MSGSENT;
  880.    if(msgt->netattr & Q_FILE)
  881.       tmsg.attr |= MSGFILE;
  882.    if(msgt->netattr & Q_KILL)
  883.       tmsg.attr |= MSGKILL;
  884.    if(msgt->netattr & Q_FRQ)
  885.       tmsg.attr |= MSGFRQ;
  886.    if(msgt->netattr & Q_CPT)
  887.       tmsg.attr |= MSGCPT;
  888.    if(msgt->netattr & Q_ARQ)
  889.       tmsg.attr |= MSGARQ;
  890.  
  891.    strcpy (tmsg.to, pascal_string (msgt->whoto));
  892.    strcpy (tmsg.from, pascal_string (msgt->whofrom));
  893.    strcpy (tmsg.subj, pascal_string (msgt->subject));
  894.  
  895.    strcpy(stringa,pascal_string(msgt->date));
  896.    sscanf(stringa,"%2d-%2d-%2d",&mo,&dy,&yr);
  897.    strcpy(stringa,pascal_string(msgt->time));
  898.    sscanf(stringa,"%2d:%2d",&hh,&mm);
  899.    sprintf(tmsg.date, "%02d %s %02d  %2d:%02d:00", dy, mtext[mo-1], yr, hh, mm);
  900.  
  901.    text_header (&tmsg, s, fp);
  902. }
  903.  
  904. void gold_text_header(msgt, s, fp)
  905. struct _gold_msghdr *msgt;
  906. int s;
  907. FILE *fp;
  908. {
  909.    int dy, mo, yr, hh, mm;
  910.    char stringa[20];
  911.    struct _msg tmsg;
  912.  
  913.    memset ((char *)&tmsg, 0, sizeof (struct _msg));
  914.  
  915.    if (msgt->msgattr & Q_PRIVATE)
  916.       tmsg.attr |= MSGPRIVATE;
  917.    if(msgt->msgattr & Q_RECEIVED)
  918.       tmsg.attr |= MSGREAD;
  919.    if(msgt->netattr & Q_CRASH)
  920.       tmsg.attr |= MSGCRASH;
  921.    if(msgt->netattr & Q_SENT)
  922.       tmsg.attr |= MSGSENT;
  923.    if(msgt->netattr & Q_FILE)
  924.       tmsg.attr |= MSGFILE;
  925.    if(msgt->netattr & Q_KILL)
  926.       tmsg.attr |= MSGKILL;
  927.    if(msgt->netattr & Q_FRQ)
  928.       tmsg.attr |= MSGFRQ;
  929.    if(msgt->netattr & Q_CPT)
  930.       tmsg.attr |= MSGCPT;
  931.    if(msgt->netattr & Q_ARQ)
  932.       tmsg.attr |= MSGARQ;
  933.  
  934.    strcpy (tmsg.to, pascal_string (msgt->whoto));
  935.    strcpy (tmsg.from, pascal_string (msgt->whofrom));
  936.    strcpy (tmsg.subj, pascal_string (msgt->subject));
  937.  
  938.    strcpy(stringa,pascal_string(msgt->date));
  939.    sscanf(stringa,"%2d-%2d-%2d",&mo,&dy,&yr);
  940.    strcpy(stringa,pascal_string(msgt->time));
  941.    sscanf(stringa,"%2d:%2d",&hh,&mm);
  942.    sprintf(tmsg.date, "%02d %s %02d  %2d:%02d:00", dy, mtext[mo-1], yr, hh, mm);
  943.  
  944.    text_header (&tmsg, s, fp);
  945. }
  946.  
  947. char *pascal_string(s)
  948. char *s;
  949. {
  950.    strncpy(e_input,(char *)&s[1],(int)s[0]);
  951.    e_input[(int)s[0]] = '\0';
  952.  
  953.    return (e_input);
  954. }
  955.  
  956. int quick_write_message_text(msgn, flags, stringa, sm)
  957. int msgn, flags;
  958. char *stringa;
  959. FILE *sm;
  960. {
  961.    FILE *fp, *fpt;
  962.    int i, m, z, pp, blks, pos;
  963.    char filename[80], c, buff[80], wrp[80], shead, qwkbuffer[130];
  964.    char qfrom[36], qto[36], qtime[10], qdate[10], qsubj[72], *p;
  965.    long fpos, qpos, absnum;
  966.    struct _msghdr msgt;
  967.    struct _gold_msghdr gmsgt;
  968.    struct QWKmsghd QWK;
  969.  
  970.    absnum = msgidx[msgn];
  971.  
  972.    if (sys.gold_board) {
  973.       sprintf (filename, "%sMSGHDR.DAT", fido_msgpath);
  974.       fp = sh_fopen (filename, "r+b", SH_DENYNONE);
  975.       if (fp == NULL)
  976.          return (0);
  977.  
  978.       fseek (fp,(long)sizeof (struct _gold_msghdr) * absnum, SEEK_SET);
  979.       fread ((char *)&gmsgt, sizeof (struct _gold_msghdr), 1, fp);
  980.  
  981.       fclose (fp);
  982.  
  983.         if (gmsgt.msgattr & Q_RECKILL)
  984.          return (0);
  985.  
  986.       if (gmsgt.msgattr & Q_PRIVATE) {
  987.          if (stricmp (pascal_string (gmsgt.whofrom), usr.name) && stricmp(pascal_string (gmsgt.whoto), usr.name)&&
  988.          stricmp (pascal_string (gmsgt.whofrom), usr.handle) && stricmp(pascal_string (gmsgt.whoto), usr.handle))
  989.          return (0);
  990.       }
  991.    }
  992.    else {
  993.       sprintf (filename, "%sMSGHDR.BBS", fido_msgpath);
  994.       fp = sh_fopen (filename, "r+b", SH_DENYNONE);
  995.       if (fp == NULL)
  996.          return (0);
  997.  
  998.       fseek (fp, (long)sizeof (struct _msghdr) * absnum, SEEK_SET);
  999.       fread ((char *)&msgt, sizeof (struct _msghdr), 1, fp);
  1000.  
  1001.       fclose (fp);
  1002.  
  1003.         if (msgt.msgattr & Q_RECKILL)
  1004.          return (0);
  1005.  
  1006.       if (msgt.msgattr & Q_PRIVATE) {
  1007.          if (stricmp (pascal_string (msgt.whofrom), usr.name) && stricmp(pascal_string (msgt.whoto), usr.name)
  1008.          &&stricmp (pascal_string (msgt.whofrom), usr.handle) && stricmp(pascal_string (msgt.whoto), usr.handle))
  1009.                return (0);
  1010.       }
  1011.    }
  1012.  
  1013.    blks = 1;
  1014.    shead = 0;
  1015.    pos = 0;
  1016.  
  1017.    if (sm == NULL) {
  1018.       fpt = fopen(stringa, (flags & APPEND_TEXT) ? "at" : "wt");
  1019.       if (fpt == NULL)
  1020.          return (0);
  1021.    }
  1022.    else
  1023.       fpt = sm;
  1024.  
  1025.    if (sys.gold_board) {
  1026.       sprintf (buff, "%sMSGTXT.DAT",  fido_msgpath);
  1027.       fp = sh_fopen (buff, "rb", SH_DENYNONE);
  1028.  
  1029.       fpos = 256L * (gmsgt.startblock + gmsgt.numblocks - 1);
  1030.       fseek (fp, fpos, SEEK_SET);
  1031.       fpos += fgetc (fp);
  1032.  
  1033.       fseek (fp, 256L * gmsgt.startblock, SEEK_SET);
  1034.    }
  1035.    else {
  1036.       sprintf (buff, "%sMSGTXT.BBS",  fido_msgpath);
  1037.       fp = sh_fopen (buff, "rb", SH_DENYNONE);
  1038.  
  1039.       fpos = 256L * (msgt.startblock + msgt.numblocks - 1);
  1040.       fseek (fp, fpos, SEEK_SET);
  1041.       fpos += fgetc (fp);
  1042.  
  1043.       fseek (fp, 256L * msgt.startblock, SEEK_SET);
  1044.    }
  1045.  
  1046.    i = 0;
  1047.  
  1048.    if (flags & QUOTE_TEXT) {
  1049.       if (sys.gold_board)
  1050.          add_quote_string (buff, pascal_string (gmsgt.whofrom));
  1051.       else
  1052.          add_quote_string (buff, pascal_string (gmsgt.whofrom));
  1053.       i = strlen (buff);
  1054.    }
  1055.    pp = 0;
  1056.  
  1057.    while (ftell (fp) < fpos) {
  1058.       if (!pp)
  1059.          fgetc (fp);
  1060.  
  1061.       c = fgetc (fp);
  1062.       pp++;
  1063.  
  1064.       if (c == '\0')
  1065.          break;
  1066.  
  1067.       if (pp == 255)
  1068.          pp = 0;
  1069.  
  1070.       if ((byte)c == 0x8D || c == 0x0A || c == '\0')
  1071.          continue;
  1072.  
  1073.       buff[i++] = c;
  1074.  
  1075.       if (c == 0x0D) {
  1076.          buff[i-1] = '\0';
  1077.          if (!strnicmp (buff, msgtxt[M_TEAR_LINE], 4))
  1078.             buff[1] = '+';
  1079.          if (!strnicmp (buff, msgtxt[M_ORIGIN_LINE], 10))
  1080.             buff[3] = '0';
  1081.  
  1082.          if ((p = strchr (buff, 0x01)) != NULL) {
  1083.             if (!strncmp(&p[1], "INTL",4) && !shead)
  1084.                sscanf (&p[6], "%d:%d/%d %d:%d/%d", &msg_tzone, &i, &i, &msg_fzone, &i, &i);
  1085.             if (!strncmp(&p[1],"TOPT",4) && !shead)
  1086.                sscanf (&p[6], "%d",&msg_tpoint);
  1087.             if (!strncmp (&p[1], "FMPT",4) && !shead)
  1088.                sscanf (&p[6], "%d",&msg_fpoint);
  1089.          }
  1090.          else if (!shead) {
  1091.             if (flags & INCLUDE_HEADER) {
  1092.                if (sys.gold_board)
  1093.                   gold_text_header (&gmsgt, msgn, fpt);
  1094.                else
  1095.                   quick_text_header (&msgt, msgn, fpt);
  1096.             }
  1097.             else if (flags & QWK_TEXTFILE) {
  1098.                if (sys.gold_board)
  1099.                   gold_qwk_text_header (&gmsgt, msgn, fpt, &QWK, &qpos);
  1100.                else
  1101.                   quick_qwk_text_header (&msgt, msgn, fpt, &QWK, &qpos);
  1102.             }
  1103.             else if (flags & QUOTE_TEXT) {
  1104.                if (sys.gold_board) {
  1105.                   strcpy (qfrom, pascal_string (gmsgt.whofrom));
  1106.                   strcpy (qto, pascal_string (gmsgt.whoto));
  1107.                   strcpy (qdate, pascal_string (gmsgt.date));
  1108.                   strcpy (qtime, pascal_string (gmsgt.time));
  1109.                   strcpy (qsubj, pascal_string (gmsgt.subject));
  1110.                }
  1111.                else {
  1112.                   strcpy (qfrom, pascal_string (msgt.whofrom));
  1113.                   strcpy (qto, pascal_string (msgt.whoto));
  1114.                   strcpy (qdate, pascal_string (msgt.date));
  1115.                   strcpy (qtime, pascal_string (msgt.time));
  1116.                   strcpy (qsubj, pascal_string (msgt.subject));
  1117.                }
  1118.                add_quote_header (fpt, qfrom, qto, qsubj, qdate, qtime);
  1119.             }
  1120.             shead = 1;
  1121.          }
  1122.  
  1123.          if (strchr (buff, 0x01) != NULL || stristr (buff, "SEEN-BY") != NULL) {
  1124.             if (flags & QUOTE_TEXT) {
  1125.                if (sys.gold_board)
  1126.                   add_quote_string (buff, pascal_string (gmsgt.whofrom));
  1127.                else
  1128.                   add_quote_string (buff, pascal_string (gmsgt.whofrom));
  1129.                i = strlen (buff);
  1130.             }
  1131.             else
  1132.                i = 0;
  1133.             continue;
  1134.          }
  1135.  
  1136.          if (flags & QWK_TEXTFILE) {
  1137.             write_qwk_string (buff, qwkbuffer, &pos, &blks, fpt);
  1138.             write_qwk_string ("\r\n", qwkbuffer, &pos, &blks, fpt);
  1139.          }
  1140.          else
  1141.             fprintf (fpt, "%s\n", buff);
  1142.  
  1143.          if (flags & QUOTE_TEXT) {
  1144.             if (sys.gold_board)
  1145.                add_quote_string (buff, pascal_string (gmsgt.whofrom));
  1146.             else
  1147.                add_quote_string (buff, pascal_string (gmsgt.whofrom));
  1148.             i = strlen (buff);
  1149.          }
  1150.          else
  1151.             i = 0;
  1152.       }
  1153.       else {
  1154.          if (i < (usr.width-1))
  1155.             continue;
  1156.  
  1157.          buff[i] = '\0';
  1158.          while (i > 0 && buff[i] != ' ')
  1159.             i--;
  1160.  
  1161.          m = 0;
  1162.  
  1163.          if (i != 0)
  1164.             for (z = i + 1; buff[z]; z++)
  1165.                wrp[m++] = buff[z];
  1166.  
  1167.          buff[i] = '\0';
  1168.          wrp[m] = '\0';
  1169.          if (!strnicmp (buff, msgtxt[M_TEAR_LINE], 4))
  1170.             buff[1] = '+';
  1171.          if (!strnicmp (buff, msgtxt[M_ORIGIN_LINE], 10))
  1172.             buff[3] = '0';
  1173.  
  1174.          if (!shead) {
  1175.             if (flags & INCLUDE_HEADER) {
  1176.                if (sys.gold_board)
  1177.                   gold_text_header (&gmsgt, msgn, fpt);
  1178.                else
  1179.                   quick_text_header (&msgt, msgn, fpt);
  1180.             }
  1181.             else if (flags & QWK_TEXTFILE) {
  1182.                if (sys.gold_board)
  1183.                   gold_qwk_text_header (&gmsgt, msgn, fpt, &QWK, &qpos);
  1184.                else
  1185.                   quick_qwk_text_header (&msgt, msgn, fpt, &QWK, &qpos);
  1186.             }
  1187.             else if (flags & QUOTE_TEXT) {
  1188.                if (sys.gold_board) {
  1189.                   strcpy (qfrom, pascal_string (gmsgt.whofrom));
  1190.                   strcpy (qto, pascal_string (gmsgt.whoto));
  1191.                   strcpy (qdate, pascal_string (gmsgt.date));
  1192.                   strcpy (qtime, pascal_string (gmsgt.time));
  1193.                   strcpy (qsubj, pascal_string (gmsgt.subject));
  1194.                }
  1195.                else {
  1196.                   strcpy (qfrom, pascal_string (msgt.whofrom));
  1197.                   strcpy (qto, pascal_string (msgt.whoto));
  1198.                   strcpy (qdate, pascal_string (msgt.date));
  1199.                   strcpy (qtime, pascal_string (msgt.time));
  1200.                   strcpy (qsubj, pascal_string (msgt.subject));
  1201.                }
  1202.                add_quote_header (fpt, qfrom, qto, qsubj, qdate, qtime);
  1203.             }
  1204.             shead = 1;
  1205.          }
  1206.  
  1207.          if (flags & QWK_TEXTFILE) {
  1208.             write_qwk_string (buff, qwkbuffer, &pos, &blks, fpt);
  1209.             write_qwk_string ("\r\n", qwkbuffer, &pos, &blks, fpt);
  1210.          }
  1211.          else
  1212.             fprintf (fpt, "%s\n", buff);
  1213.  
  1214.          if (flags & QUOTE_TEXT) {
  1215.             if (sys.gold_board)
  1216.                add_quote_string (buff, pascal_string (gmsgt.whofrom));
  1217.             else
  1218.                add_quote_string (buff, pascal_string (gmsgt.whofrom));
  1219.          }
  1220.          else
  1221.             buff[0] = '\0';
  1222.          strcat (buff, wrp);
  1223.          i = strlen (buff);
  1224.       }
  1225.    }
  1226.  
  1227.    fclose (fp);
  1228.  
  1229.    if (flags & QWK_TEXTFILE) {
  1230.       fwrite (qwkbuffer, 128, 1, fpt);
  1231.       blks++;
  1232.  
  1233.       fseek (fpt, qpos, SEEK_SET);         /* Restore back to header start */
  1234.       sprintf (buff, "%d", blks);
  1235.       ljstring (QWK.Msgrecs, buff, 6);
  1236.       fwrite ((char *)&QWK, 128, 1, fpt);  /* Write out the header */
  1237.       fseek (fpt, 0L, SEEK_END);           /* Bump back to end of file */
  1238.  
  1239.       if (sm == NULL)
  1240.          fclose (fpt);
  1241.       return (blks);
  1242.    }
  1243.    else
  1244.       fprintf (fpt, bbstxt[B_TWO_CR]);
  1245.  
  1246.    if (sm == NULL)
  1247.       fclose (fpt);
  1248.  
  1249.    return (1);
  1250. }
  1251.  
  1252. void quick_qwk_text_header (msgt,msgn,fpt,QWK,qpos)
  1253. struct _msghdr *msgt;
  1254. int msgn;
  1255. FILE *fpt;
  1256. struct QWKmsghd *QWK;
  1257. long *qpos;
  1258. {
  1259.    int dy, mo, yr, hh, mm;
  1260.    char stringa[20];
  1261.    struct _msg tmsg;
  1262.  
  1263.    memset ((char *)&tmsg, 0, sizeof (struct _msg));
  1264.  
  1265.    if (msgt->msgattr & Q_PRIVATE)
  1266.       tmsg.attr |= MSGPRIVATE;
  1267.    if(msgt->msgattr & Q_RECEIVED)
  1268.       tmsg.attr |= MSGREAD;
  1269.    strcpy (tmsg.to, pascal_string (msgt->whoto));
  1270.    strcpy (tmsg.from, pascal_string (msgt->whofrom));
  1271.    strcpy (tmsg.subj, pascal_string (msgt->subject));
  1272.  
  1273.    strcpy(stringa,pascal_string(msgt->date));
  1274.    sscanf(stringa,"%2d-%2d-%2d",&mo,&dy,&yr);
  1275.    strcpy(stringa,pascal_string(msgt->time));
  1276.    sscanf(stringa,"%2d:%2d",&hh,&mm);
  1277.    sprintf(tmsg.date, "%02d %s %02d  %2d:%02d:00", dy, mtext[mo-1], yr, hh, mm);
  1278.  
  1279.    qwk_header (&tmsg, QWK, msgn, fpt, qpos);
  1280. }
  1281.  
  1282. void quick_bluewave_text_header (struct _msghdr *msgt, int msgn, int fdi, long bw_start, long bw_len)
  1283. {
  1284.    int dy, mo, yr, hh, mm;
  1285.    char stringa[20];
  1286.    struct _msg tmsg;
  1287.  
  1288.    memset ((char *)&tmsg, 0, sizeof (struct _msg));
  1289.  
  1290.    if (msgt->msgattr & Q_PRIVATE)
  1291.       tmsg.attr |= MSGPRIVATE;
  1292.    if(msgt->msgattr & Q_RECEIVED)
  1293.       tmsg.attr |= MSGREAD;
  1294.    strcpy (tmsg.to, pascal_string (msgt->whoto));
  1295.    strcpy (tmsg.from, pascal_string (msgt->whofrom));
  1296.    strcpy (tmsg.subj, pascal_string (msgt->subject));
  1297.  
  1298.    strcpy(stringa,pascal_string(msgt->date));
  1299.    sscanf(stringa,"%2d-%2d-%2d",&mo,&dy,&yr);
  1300.    strcpy(stringa,pascal_string(msgt->time));
  1301.    sscanf(stringa,"%2d:%2d",&hh,&mm);
  1302.    sprintf(tmsg.date, "%02d %s %02d  %2d:%02d:00", dy, mtext[mo-1], yr, hh, mm);
  1303.  
  1304.    bluewave_header (fdi, bw_start, bw_len, msgn, &tmsg);
  1305. }
  1306.  
  1307. void gold_qwk_text_header (msgt, msgn, fpt, QWK, qpos)
  1308. struct _gold_msghdr *msgt;
  1309. int msgn;
  1310. FILE *fpt;
  1311. struct QWKmsghd *QWK;
  1312. long *qpos;
  1313. {
  1314.    int dy, mo, yr, hh, mm;
  1315.    char stringa[20];
  1316.    struct _msg tmsg;
  1317.  
  1318.    memset ((char *)&tmsg, 0, sizeof (struct _msg));
  1319.  
  1320.    if (msgt->msgattr & Q_PRIVATE)
  1321.       tmsg.attr |= MSGPRIVATE;
  1322.    if(msgt->msgattr & Q_RECEIVED)
  1323.       tmsg.attr |= MSGREAD;
  1324.    strcpy (tmsg.to, pascal_string (msgt->whoto));
  1325.    strcpy (tmsg.from, pascal_string (msgt->whofrom));
  1326.    strcpy (tmsg.subj, pascal_string (msgt->subject));
  1327.  
  1328.    strcpy(stringa,pascal_string(msgt->date));
  1329.    sscanf(stringa,"%2d-%2d-%2d",&mo,&dy,&yr);
  1330.    strcpy(stringa,pascal_string(msgt->time));
  1331.    sscanf(stringa,"%2d:%2d",&hh,&mm);
  1332.    sprintf(tmsg.date, "%02d %s %02d  %2d:%02d:00", dy, mtext[mo-1], yr, hh, mm);
  1333.  
  1334.    qwk_header (&tmsg, QWK, msgn, fpt, qpos);
  1335. }
  1336.  
  1337. void gold_bluewave_text_header (struct _gold_msghdr *msgt, int msgn, int fdi, long bw_start, long bw_len)
  1338. {
  1339.    int dy, mo, yr, hh, mm;
  1340.    char stringa[20];
  1341.    struct _msg tmsg;
  1342.  
  1343.    memset ((char *)&tmsg, 0, sizeof (struct _msg));
  1344.  
  1345.    if (msgt->msgattr & Q_PRIVATE)
  1346.       tmsg.attr |= MSGPRIVATE;
  1347.    if(msgt->msgattr & Q_RECEIVED)
  1348.       tmsg.attr |= MSGREAD;
  1349.    strcpy (tmsg.to, pascal_string (msgt->whoto));
  1350.    strcpy (tmsg.from, pascal_string (msgt->whofrom));
  1351.    strcpy (tmsg.subj, pascal_string (msgt->subject));
  1352.  
  1353.    strcpy(stringa,pascal_string(msgt->date));
  1354.    sscanf(stringa,"%2d-%2d-%2d",&mo,&dy,&yr);
  1355.    strcpy(stringa,pascal_string(msgt->time));
  1356.    sscanf(stringa,"%2d:%2d",&hh,&mm);
  1357.    sprintf(tmsg.date, "%02d %s %02d  %2d:%02d:00", dy, mtext[mo-1], yr, hh, mm);
  1358.  
  1359.    bluewave_header (fdi, bw_start, bw_len, msgn, &tmsg);
  1360. }
  1361.  
  1362. void quick_save_message (char *txt)
  1363. {
  1364.    FILE *fp;
  1365.    word dest, m, nb, x;
  1366.    int fdinfo, i;
  1367.     char filename[80], text[258], buffer[258];
  1368.     long tempo, gdest;
  1369.     unsigned long crc;
  1370.     struct tm *tim;
  1371.     struct _msgidx idx;
  1372.     struct _msghdr hdr;
  1373.    struct _msgtoidx toidx;
  1374.    struct _gold_msgidx gidx;
  1375.    struct _gold_msghdr ghdr;
  1376.  
  1377.     memset ((char *)&toidx, 0, sizeof (struct _msgtoidx));
  1378.  
  1379.     m_print (bbstxt[B_SAVE_MESSAGE]);
  1380.     quick_scan_message_base (sys.quick_board, sys.gold_board, usr.msg, 1);
  1381.  
  1382.     // prima era qui
  1383.     //if (sys.gold_board)
  1384.     //    gdest = gmsginfo.highmsg + 1;
  1385.     //else
  1386.     //    dest = msginfo.highmsg + 1;
  1387.     activation_key ();
  1388.     m_print (" #%d ...", last_msg + 1);
  1389.  
  1390.     if (sys.gold_board) {
  1391.         memset ((char *)&gidx, 0, sizeof (struct _gold_msgidx));
  1392.         memset ((char *)&ghdr, 0, sizeof (struct _gold_msghdr));
  1393.  
  1394.         sprintf (filename, "%sMSGINFO.DAT", fido_msgpath);
  1395.         fdinfo = sh_open (filename, SH_DENYRW, O_RDWR|O_BINARY, S_IREAD|S_IWRITE);
  1396.         if (fdinfo == -1)
  1397.             return;
  1398.         read (fdinfo, (char *)&gmsginfo, sizeof (struct _gold_msginfo));
  1399.         lseek (fdinfo, 0L, SEEK_SET);
  1400.  
  1401.         gdest = gmsginfo.highmsg + 1;
  1402.  
  1403.         sprintf (filename, "%sMSGIDX.DAT", fido_msgpath);
  1404.         i = sh_open (filename, SH_DENYNONE, O_APPEND|O_RDWR|O_BINARY, S_IREAD|S_IWRITE);
  1405.         if (i == -1)
  1406.             return;
  1407.         fp = fdopen (i, "ab");
  1408.  
  1409.         gidx.msgnum = gdest;
  1410.         gidx.board = sys.gold_board;
  1411.  
  1412.         fwrite ((char *)&gidx, sizeof (struct _gold_msgidx), 1, fp);
  1413.         fclose (fp);
  1414.  
  1415.         sprintf (filename, "%sMSGTOIDX.DAT", fido_msgpath);
  1416.     }
  1417.     else {
  1418.         memset ((char *)&idx, 0, sizeof (struct _msgidx));
  1419.         memset ((char *)&hdr, 0, sizeof (struct _msghdr));
  1420.  
  1421.         sprintf (filename, "%sMSGINFO.BBS", fido_msgpath);
  1422.         fdinfo = sh_open (filename, SH_DENYRW, O_RDWR|O_BINARY, S_IREAD|S_IWRITE);
  1423.         if (fdinfo == -1)
  1424.             return;
  1425.         read (fdinfo, (char *)&msginfo, sizeof (struct _msginfo));
  1426.         lseek (fdinfo, 0L, SEEK_SET);
  1427.  
  1428.         dest = msginfo.highmsg + 1;
  1429.  
  1430.         sprintf (filename, "%sMSGIDX.BBS", fido_msgpath);
  1431.         i = sh_open (filename, SH_DENYNONE, O_APPEND|O_RDWR|O_BINARY, S_IREAD|S_IWRITE);
  1432.         if (i == -1)
  1433.             return;
  1434.         fp = fdopen (i, "ab");
  1435.  
  1436.         idx.msgnum = dest;
  1437.         idx.board = sys.quick_board;
  1438.  
  1439.         fwrite ((char *)&idx, sizeof (struct _msgidx), 1, fp);
  1440.         fclose (fp);
  1441.  
  1442.         sprintf (filename, "%sMSGTOIDX.BBS", fido_msgpath);
  1443.     }
  1444.  
  1445.  
  1446.  
  1447.     if ((i = sh_open (filename, SH_DENYNONE, O_APPEND|O_RDWR|O_BINARY, S_IREAD|S_IWRITE)) == -1)
  1448.       return;
  1449.  
  1450.    strcpy (&toidx.string[1], msg.to);
  1451.    toidx.string[0] = strlen (msg.to);
  1452.  
  1453.    write (i, (char *)&toidx, sizeof (struct _msgtoidx));
  1454.    close (i);
  1455.  
  1456.    if (sys.gold_board)
  1457.       sprintf (filename, "%sMSGTXT.DAT", fido_msgpath);
  1458.    else
  1459.         sprintf (filename, "%sMSGTXT.BBS", fido_msgpath);
  1460.  
  1461.    i = sh_open (filename, SH_DENYNONE, O_APPEND|O_RDWR|O_BINARY, S_IREAD|S_IWRITE);
  1462.    if (i == -1)
  1463.       return;
  1464.    fp = fdopen (i, "ab");
  1465.  
  1466.    if (sys.gold_board)
  1467.       ghdr.startblock = filelength (fileno (fp)) / 256L;
  1468.     else
  1469.       hdr.startblock = (word)(filelength (fileno (fp)) / 256L);
  1470.  
  1471.    i = 0;
  1472.    m = 1;
  1473.    nb = 1;
  1474.  
  1475.    memset (text, 0, 256);
  1476.  
  1477.    if (sys.netmail) {
  1478.       if (msg_tpoint) {
  1479.          sprintf (buffer, msgtxt[M_TOPT], msg_tpoint);
  1480.          write_pascal_string (buffer, text, &m, &nb, fp);
  1481.       }
  1482.       if (msg_tzone != msg_fzone) {
  1483.          sprintf (buffer, msgtxt[M_INTL], msg_tzone, msg.dest_net, msg.dest, msg_fzone, msg.orig_net, msg.orig);
  1484.          write_pascal_string (buffer, text, &m, &nb, fp);
  1485.       }
  1486.    }
  1487.  
  1488.    if (sys.echomail) {
  1489.       sprintf(buffer,msgtxt[M_PID], VERSION, registered ? "+" : NOREG);
  1490.         write_pascal_string (buffer, text, &m, &nb, fp);
  1491.  
  1492.         crc = time (NULL);
  1493.         crc = string_crc(msg.from,crc);
  1494.         crc = string_crc(msg.to,crc);
  1495.         crc = string_crc(msg.subj,crc);
  1496.         crc = string_crc(msg.date,crc);
  1497.  
  1498.         sprintf(buffer,msgtxt[M_MSGID], config->alias[sys.use_alias].zone, config->alias[sys.use_alias].net, config->alias[sys.use_alias].node, config->alias[sys.use_alias].point, crc);
  1499.       write_pascal_string (buffer, text, &m, &nb, fp);
  1500.    }
  1501.  
  1502.    if (sys.internet_mail && internet_to != NULL) {
  1503.       fprintf (fp, "To: %s\r\n\r\n", internet_to);
  1504.       free (internet_to);
  1505.    }
  1506.  
  1507.    if (txt == NULL) {
  1508.       while(messaggio[i] != NULL) {
  1509.          write_pascal_string (messaggio[i], text, &m, &nb, fp);
  1510.  
  1511.          if(messaggio[i][strlen(messaggio[i])-1] == '\r')
  1512.             write_pascal_string ("\n", text, &m, &nb, fp);
  1513.  
  1514.          i++;
  1515.       }
  1516.    }
  1517.    else {
  1518.       int fptxt;
  1519.  
  1520.       fptxt = shopen(txt, O_RDONLY|O_BINARY);
  1521.       if (fptxt == -1) {
  1522.          fclose(fp);
  1523.          unlink(filename);
  1524.          close (fdinfo);
  1525.          return;
  1526.       }
  1527.  
  1528.       do {
  1529.          memset (buffer, 0, 256);
  1530.          i = read(fptxt, buffer, 255);
  1531.          for (x = 0; x < i; x++) {
  1532.             if (buffer[x] == 0x1A)
  1533.                buffer[x] = ' ';
  1534.          }
  1535.          buffer[i] = '\0';
  1536.          write_pascal_string (buffer, text, &m, &nb, fp);
  1537.       } while (i == 255);
  1538.  
  1539.       close(fptxt);
  1540.    }
  1541.  
  1542.    write_pascal_string ("\r\n", text, &m, &nb, fp);
  1543.  
  1544.    if (strlen(usr.signature) && registered) {
  1545.       sprintf(buffer,msgtxt[M_SIGNATURE],usr.signature);
  1546.       write_pascal_string (buffer, text, &m, &nb, fp);
  1547.    }
  1548.  
  1549.    if(sys.echomail) {
  1550.       sprintf(buffer,msgtxt[M_TEAR_LINE],VERSION, registered ? "+" : NOREG);
  1551.       write_pascal_string (buffer, text, &m, &nb, fp);
  1552.  
  1553.       if(strlen(sys.origin))
  1554.          sprintf(buffer,msgtxt[M_ORIGIN_LINE],random_origins(),config->alias[sys.use_alias].zone,config->alias[sys.use_alias].net,config->alias[sys.use_alias].node, config->alias[sys.use_alias].point);
  1555.       else
  1556.          sprintf(buffer,msgtxt[M_ORIGIN_LINE],system_name,config->alias[sys.use_alias].zone,config->alias[sys.use_alias].net,config->alias[sys.use_alias].node, config->alias[sys.use_alias].point);
  1557.       write_pascal_string (buffer, text, &m, &nb, fp);
  1558.    }
  1559.  
  1560.    *text = m - 1;
  1561.    fwrite (text, 256, 1, fp);
  1562.  
  1563.    fclose (fp);
  1564.  
  1565.    if (sys.gold_board)
  1566.       sprintf (filename,"%sMSGHDR.DAT",fido_msgpath);
  1567.    else
  1568.       sprintf (filename,"%sMSGHDR.BBS",fido_msgpath);
  1569.  
  1570.    i = sh_open (filename, SH_DENYNONE, O_APPEND|O_RDWR|O_BINARY, S_IREAD|S_IWRITE);
  1571.    if (i == -1)
  1572.       return;
  1573.    fp = fdopen (i, "ab");
  1574.  
  1575.    tempo = time (NULL);
  1576.    tim = localtime (&tempo);
  1577.  
  1578.    if (!first_msg)
  1579.       first_msg = 1;
  1580.    last_msg++;
  1581.    num_msg++;
  1582.  
  1583.    if (sys.gold_board) {
  1584.       ghdr.numblocks = nb;
  1585.         ghdr.msgnum = gdest;
  1586.       ghdr.prevreply = msg.reply;
  1587.       ghdr.nextreply = msg.up;
  1588.       ghdr.timesread = 0;
  1589.       ghdr.destnet = msg.dest_net;
  1590.       ghdr.destnode = msg.dest;
  1591.       ghdr.orignet = msg.orig_net;
  1592.       ghdr.orignode = msg.orig;
  1593.       ghdr.destzone = ghdr.origzone = config->alias[sys.use_alias].zone;
  1594.       ghdr.cost = msg.cost;
  1595.  
  1596.       if (sys.netmail)
  1597.          ghdr.msgattr |= Q_NETMAIL;
  1598.  
  1599.       if (msg.attr & MSGPRIVATE)
  1600.          ghdr.msgattr |= Q_PRIVATE;
  1601.       if (msg.attr & MSGCRASH)
  1602.          ghdr.netattr |= Q_CRASH;
  1603.       if (msg.attr & MSGFILE)
  1604.          ghdr.netattr |= Q_FILE;
  1605.       if (msg.attr & MSGKILL)
  1606.          ghdr.netattr |= Q_KILL;
  1607.       if (msg.attr & MSGFRQ)
  1608.          ghdr.netattr |= Q_FRQ;
  1609.       if (msg.attr & MSGCPT)
  1610.          ghdr.netattr |= Q_CPT;
  1611.       if (msg.attr & MSGARQ)
  1612.          ghdr.netattr |= Q_ARQ;
  1613.  
  1614.       ghdr.msgattr |= Q_LOCAL;
  1615.       ghdr.board = sys.gold_board;
  1616.  
  1617.       sprintf (&ghdr.time[1], "%02d:%02d", tim->tm_hour, tim->tm_min);
  1618.       sprintf (&ghdr.date[1], "%02d-%02d-%02d", tim->tm_mon + 1, tim->tm_mday, tim->tm_year);
  1619.       ghdr.time[0] = 5;
  1620.       ghdr.date[0] = 8;
  1621.  
  1622.       strcpy (&ghdr.whoto[1], msg.to);
  1623.       ghdr.whoto[0] = strlen (msg.to);
  1624.       strcpy (&ghdr.whofrom[1], msg.from);
  1625.       ghdr.whofrom[0] = strlen (msg.from);
  1626.       strcpy (&ghdr.subject[1], msg.subj);
  1627.       ghdr.subject[0] = strlen (msg.subj);
  1628.  
  1629.       gmsginfo.highmsg++;
  1630.       gmsginfo.totalonboard[sys.gold_board - 1]++;
  1631.       gmsginfo.totalmsgs++;
  1632.       msgidx[last_msg] = filelength (fileno (fp)) / sizeof (struct _gold_msghdr);
  1633.  
  1634.       fwrite ((char *)&ghdr, sizeof (struct _gold_msghdr), 1, fp);
  1635.       fclose (fp);
  1636.  
  1637.         write (fdinfo, (char *)&gmsginfo, sizeof (struct _gold_msginfo));
  1638.    }
  1639.    else {
  1640.       hdr.numblocks = nb;
  1641.         hdr.msgnum = dest;
  1642.       hdr.prevreply = msg.reply;
  1643.       hdr.nextreply = msg.up;
  1644.       hdr.timesread = 0;
  1645.       hdr.destnet = msg.dest_net;
  1646.       hdr.destnode = msg.dest;
  1647.       hdr.orignet = msg.orig_net;
  1648.       hdr.orignode = msg.orig;
  1649.       hdr.destzone = hdr.origzone = config->alias[sys.use_alias].zone;
  1650.       hdr.cost = msg.cost;
  1651.  
  1652.       if (sys.netmail)
  1653.          hdr.msgattr |= Q_NETMAIL;
  1654.  
  1655.       if (msg.attr & MSGPRIVATE)
  1656.          hdr.msgattr |= Q_PRIVATE;
  1657.       if (msg.attr & MSGCRASH)
  1658.          hdr.netattr |= Q_CRASH;
  1659.       if (msg.attr & MSGFILE)
  1660.          hdr.netattr |= Q_FILE;
  1661.       if (msg.attr & MSGKILL)
  1662.          hdr.netattr |= Q_KILL;
  1663.       if (msg.attr & MSGFRQ)
  1664.          hdr.netattr |= Q_FRQ;
  1665.       if (msg.attr & MSGCPT)
  1666.          hdr.netattr |= Q_CPT;
  1667.       if (msg.attr & MSGARQ)
  1668.          hdr.netattr |= Q_ARQ;
  1669.  
  1670.       hdr.msgattr |= Q_LOCAL;
  1671.       hdr.board = sys.quick_board;
  1672.  
  1673.       sprintf(&hdr.time[1],"%02d:%02d",tim->tm_hour,tim->tm_min);
  1674.       sprintf(&hdr.date[1],"%02d-%02d-%02d",tim->tm_mon+1,tim->tm_mday,tim->tm_year);
  1675.       hdr.time[0] = 5;
  1676.       hdr.date[0] = 8;
  1677.  
  1678.       strcpy (&hdr.whoto[1], msg.to);
  1679.       hdr.whoto[0] = strlen (msg.to);
  1680.       strcpy (&hdr.whofrom[1], msg.from);
  1681.       hdr.whofrom[0] = strlen (msg.from);
  1682.       strcpy (&hdr.subject[1], msg.subj);
  1683.       hdr.subject[0] = strlen (msg.subj);
  1684.  
  1685.       msginfo.highmsg++;
  1686.       msginfo.totalonboard[sys.quick_board - 1]++;
  1687.       msginfo.totalmsgs++;
  1688.       msgidx[last_msg] = filelength (fileno (fp)) / sizeof (struct _msghdr);
  1689.  
  1690.       fwrite ((char *)&hdr, sizeof (struct _msghdr), 1, fp);
  1691.       fclose (fp);
  1692.  
  1693.       write (fdinfo, (char *)&msginfo, sizeof (struct _msginfo));
  1694.    }
  1695.  
  1696.    close (fdinfo);
  1697.  
  1698.    m_print (bbstxt[B_XPRT_DONE]);
  1699.    status_line (msgtxt[M_INSUFFICIENT_DATA], last_msg, sys.msg_num);
  1700. }
  1701.  
  1702.