home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / FIDO / MSGD2SRC.ZIP / FIDO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-08-07  |  9.2 KB  |  441 lines
  1. /**
  2.  
  3.  * fido/opus style message base support functions for msged
  4.  
  5.  * released into the PUBLIC DOMAIN 30 jul 1990 by jim nutt
  6.  
  7. **/
  8.  
  9. #define CHUNKSZ 10
  10. #define TEXTLEN 96
  11. #define BUFLEN    4096
  12.  
  13. #if defined(__MSC__) || defined(__TURBOC__)
  14. #include <sys\types.h>
  15. #include <fcntl.h>
  16. #endif
  17. #include <sys\stat.h>
  18. #include <dos.h>
  19. #include "msged.h"
  20. #include "date.h"
  21.  
  22. int _pascal dir_findnext(struct _dta * dta);
  23. int _pascal dir_findfirst(char * filename, int attribute, struct _dta * dta);
  24.  
  25. typedef struct _dosdate {
  26.     unsigned int day:5;
  27.     unsigned int mon:4;
  28.     unsigned int year:7;
  29.     unsigned int sec:5;
  30.     unsigned int min:6;
  31.     unsigned int hour:5;
  32. } DOSDATE;
  33.  
  34. void _pascal normalize(char *s);
  35. static int cdecl compare(const void *i, const void *j);
  36.  
  37. typedef struct _fidoheader {
  38.     char from[36];               /* who from,             */
  39.     char to[36];            /* who to,            */
  40.     char subj[72];            /* message subject,        */
  41.     char date[20];            /* creation date,        */
  42.     int times;            /* number of times read,        */
  43.     int dest;            /* destination node,            */
  44.     int orig;            /* originating node        */
  45.     int cost;            /* actual cost this msg           */
  46.     int orig_net;            /* originating net        */
  47.     int dest_net;            /* destination net        */
  48.     DOSDATE written;           /* when it was written           */
  49.     DOSDATE arrived;           /* when it arrived        */
  50.     unsigned int reply;            /* thread to previous msg       */
  51.     struct _attributes attrib;     /* message attributes           */
  52.     int up;              /* thread to next msg        */
  53. } FIDOHEADER;
  54.  
  55. int _pascal fido_writetext(char *text, int n)
  56.  
  57. {
  58.     char    path[PATHLEN];
  59.     FIDOHEADER msghead;
  60.     static    FILE   *fp;
  61.  
  62.     if (fp == NULL) {
  63.         sprintf(path, "%s/%d.MSG", arealist[area].path,n);
  64.         if ((fp = fopen(path, "rb")) == NULL)
  65.             return (FALSE);
  66.         fread(&msghead,sizeof msghead,1,fp);
  67.         fp = freopen(path,"wb",fp);
  68.         fwrite(&msghead, sizeof msghead,1,fp);
  69.     }
  70.  
  71.     if (text == NULL) {
  72.         fputc(0,fp);
  73.         fclose(fp);
  74.         fp = NULL;
  75.         return(TRUE);
  76.     }
  77.  
  78.     fputs(text,fp);
  79.     fflush(fp);
  80.     return(TRUE);
  81. }
  82.  
  83. int _pascal fido_writeheader(MSG *m)
  84.  
  85. {
  86.     char    path[PATHLEN];
  87.     FIDOHEADER msghead;
  88.     FILE   *fp;
  89.     time_t    now = time(NULL);
  90.     struct    tm *ts;
  91.     int     n = m->msgnum;
  92.  
  93.     ts = localtime(&now);
  94.  
  95.     do {
  96.         sprintf(path, "%s/%d.MSG", arealist[area].path,n);
  97.  
  98.         if (m->new) {
  99.             if ((fp = fopen(path,"rb")) != NULL) {
  100.                 fclose(fp);
  101.                 fp = NULL;
  102.                 n = ++m->msgnum;
  103.             }
  104.             else {
  105.                 if ((fp = fopen(path,"wb")) == NULL)
  106.                     return(FALSE);
  107.             }
  108.         }
  109.         else {
  110.             if ((fp = fopen(path,"r+b")) == NULL) {
  111.                 if ((fp = fopen(path,"wb")) == NULL) {
  112.                     return(FALSE);
  113.                 }
  114.             }
  115.             else
  116.                 fseek(fp,0l,SEEK_SET);
  117.         }
  118.     } while (fp == NULL);
  119.  
  120.     memset(&msghead,0,sizeof msghead);
  121.     msghead.attrib = m->attrib;
  122.     msghead.reply = m->replyto;
  123.     msghead.up = m->replyfrom;
  124.     msghead.times = m->times_read;
  125.     msghead.cost = m->cost;
  126.  
  127.     msghead.dest_net = m->to.net;
  128.     msghead.dest = m->to.node;
  129.  
  130.     memcpy(msghead.to,m->isto,min(sizeof msghead.to,strlen(m->isto)));
  131.     memcpy(msghead.from,m->isfrom,min(sizeof msghead.from,strlen(m->isfrom)));
  132.     memcpy(msghead.subj,m->subj,min(sizeof msghead.subj,strlen(m->subj)));
  133.     memcpy(msghead.date, mtime(m->timestamp), 20);
  134.  
  135.     msghead.orig_net = m->from.net;
  136.     msghead.orig = m->from.node;
  137.  
  138.     if (opusdate) {
  139.         msghead.written.year = ts->tm_year - 80;
  140.         msghead.written.mon = ts->tm_mon + 1;
  141.         msghead.written.day = ts->tm_mday;
  142.         msghead.written.hour = ts->tm_hour;
  143.         msghead.written.min = ts->tm_min;
  144.         msghead.written.sec = ts->tm_sec / 2;
  145.         msghead.arrived = msghead.written;
  146.     }
  147.  
  148.     fwrite((char *) &msghead, sizeof(FIDOHEADER), 1, fp);
  149.     fclose(fp);
  150.     return(TRUE);
  151. }
  152.  
  153. MSG *pascal fido_readheader(int n)
  154.  
  155. {
  156.     FIDOHEADER msghead;
  157.     char    path[PATHLEN];
  158.     int     fd = 0;
  159.     MSG    *m;
  160.  
  161.     memset(&msghead,0,sizeof msghead);
  162.     if ((m = (MSG *) calloc(1,sizeof(MSG))) == NULL)
  163.         outamemory();
  164.  
  165.     sprintf(path, "%s/%d.MSG", arealist[area].path,n);
  166.  
  167. #if defined(__MSC__) || defined(__TURBOC__)
  168.     if ((fd = open(path, O_RDONLY|O_BINARY)) == -1) {       /*WRA*/
  169. #else
  170.     if ((fd = dos_open(path, 0)) == -1) {
  171. #endif
  172.         free(m);
  173.         return (NULL);
  174.     }
  175.  
  176.     m->msgnum = n;
  177.  
  178.     read(fd, (char *) &(msghead), (int) sizeof(FIDOHEADER));
  179.  
  180.     m->from.net = msghead.orig_net;
  181.     m->from.node = msghead.orig;
  182.     m->to.net = msghead.dest_net;
  183.     m->to.node = msghead.dest;
  184.  
  185.     memset(path, 0, sizeof path);
  186.     memcpy(path,msghead.date,sizeof msghead.date);
  187.     m->timestamp = parsedate(path);
  188.  
  189.     if ((m->isto = (char *) calloc(1,sizeof msghead.to + 1)) == NULL) outamemory();
  190.     memcpy(m->isto,msghead.to,sizeof msghead.to);
  191.     if ((m->isfrom = (char *) calloc(1,sizeof msghead.from + 1)) == NULL) outamemory();
  192.     memcpy(m->isfrom,msghead.from,sizeof msghead.from);
  193.     if ((m->subj = (char *) calloc(1,sizeof msghead.subj + 1)) == NULL) outamemory();
  194.     memcpy(m->subj,msghead.subj,sizeof msghead.subj);
  195.     m->attrib = msghead.attrib;
  196.     m->replyto = msghead.reply;
  197.     m->replyfrom = msghead.up;
  198.     m->from.zone = thisnode.zone;
  199.     m->to.zone = thisnode.zone;
  200.     m->cost = msghead.cost;
  201.     m->times_read = msghead.times;
  202.     m->text = NULL;
  203.     m->to.fidonet = 1;
  204.     m->from.fidonet = 1;
  205.     close(fd);
  206.     return(m);
  207. }
  208.  
  209. static int cdecl compare(const void *i, const void *j)
  210.  
  211. {
  212.     return(* (int *) i - * (int *) j);
  213. }
  214.  
  215. int _pascal fido_scan(AREA *a)
  216.  
  217. {
  218.     struct _dta fileinfo;
  219.     char    path[PATHLEN];
  220.     int     cnt = 0;
  221.     int lastalloc = 0, c = 10;
  222.     int     msgnum,l;
  223.     FILE   *fp = NULL;
  224.     int     status;
  225.     int    *t = NULL;
  226.  
  227.     if (messages != NULL)
  228.         free(messages);
  229.  
  230.     messages = NULL;
  231.  
  232.     sprintf(path,"%s/*.msg",a->path);
  233.  
  234.     a->last = 0;
  235.  
  236.     status = dir_findfirst(path,0,&fileinfo);
  237.  
  238.     while (status != -1) {
  239.         if (fileinfo.size >= sizeof(FIDOHEADER)) {
  240.             msgnum = atoi(fileinfo.name);
  241.             cnt++;
  242.  
  243.             if (cnt >= lastalloc) {
  244.                 t = calloc((lastalloc += CHUNKSZ), sizeof(int));
  245.                 if (t == NULL) outamemory();
  246.                 if (messages != NULL)
  247.                     memcpy(t,messages,sizeof(int) * cnt);
  248.             }
  249.  
  250.             if (t) {
  251.                 if ((messages != NULL) && (c != lastalloc)) {
  252.                     free(messages);
  253.                     c = lastalloc;
  254.                 }
  255.                 messages = t;
  256.                 messages[cnt - 1] = msgnum;
  257.             }
  258.         }
  259.         if (t == NULL) {
  260.             cnt--;
  261.             break;
  262.         }
  263.         status = dir_findnext(&fileinfo);
  264.     }
  265.  
  266.     qsort(messages,cnt,sizeof(int),compare); /* put them in order */
  267.  
  268.     sprintf(path, "%s/%s",a->path, lastread);
  269.  
  270.     fp = fopen(path, "rb");
  271.     if (fp != NULL) {
  272.         fread(&c, 2, 1, fp);
  273.         if (fread(&l,2,1,fp) != 1)
  274.             l = c;
  275.         fclose(fp);
  276.     }
  277.     else {
  278.         l = c = 0;
  279.         if ((fp = fopen(path, "wb")) != NULL) {
  280.             fputc(0, fp);
  281.             fputc(0, fp);
  282.             fputc(0, fp);
  283.             fputc(0, fp);
  284.             fclose(fp);
  285.         }
  286.     }
  287.  
  288.     if (cnt != 0) {
  289.  
  290.         a->first = messages[0];
  291.         a->last = (a->msgtype==0)?messages[cnt - 1]:cnt;
  292.  
  293.         if (c == 0)
  294.             msgnum = 0;
  295.         else
  296.             for (msgnum = cnt - 1; (msgnum > -1) && (messages[msgnum] != c); msgnum--)
  297.             /* null statement */;
  298.         a->current = (msgnum == -1) ? cnt-1:msgnum;
  299.  
  300.         if (l == 0)
  301.             msgnum = 0;
  302.         else
  303.             for (msgnum = cnt - 1; (msgnum > -1) && (messages[msgnum] != l); msgnum--)
  304.             /* null statement */;
  305.         a->lastread = (msgnum == -1) ? cnt-1:msgnum;
  306.     }
  307.     else
  308.         a->current = a->lastread =
  309.         a->first = a->last = 0;
  310.  
  311.     return (cnt);
  312. }
  313.  
  314. char *pascal fido_readtext(int n)
  315.  
  316. {
  317.     static    char *buffer = NULL;
  318.     static    char *next = NULL;
  319.     static    char *end = NULL;
  320.     static    int fd = 0;
  321.     static    unsigned int s;
  322.     char    path[PATHLEN];
  323.     int     i, l;
  324.     char    *t = NULL;
  325.     char    *text = NULL;
  326.     char    eol = '\0';
  327.  
  328.  
  329.     if (n < 0) {
  330.         close(fd);
  331.         fd = s = 0;
  332.         next = NULL;
  333.         return(NULL);
  334.     }
  335.  
  336.     if (fd == 0) {
  337.  
  338.         sprintf(path, "%s/%d.MSG", arealist[area].path, n);
  339.  
  340.         s = BUFLEN;
  341.  
  342.         if (buffer == NULL)
  343.             buffer = (char *) calloc(sizeof(char),s);
  344.         else
  345.             memset(buffer,0,s);
  346.  
  347. #if defined(__MSC__) || defined(__TURBOC__)
  348.         if ((fd = open(path, O_RDONLY|O_BINARY)) == -1) {  /*WRA*/
  349. #else
  350.         if ((fd = dos_open(path, 0)) == -1) {
  351. #endif
  352.             return (NULL);
  353.         }
  354.         lseek(fd,(long) sizeof(FIDOHEADER), SEEK_SET);
  355.     }
  356.  
  357.     if (next == NULL) {
  358.         i = read(fd, buffer, s - 1);
  359.         if (i < 1) {
  360.             close(fd);
  361.             next = NULL;
  362.             s = 0;
  363.             fd = 0;
  364.             return(NULL);
  365.         }
  366.         next = buffer;
  367.         while (i && (*next == '\0'))
  368.             i--, next++;
  369.         normalize(next);
  370.         end = buffer + strlen(buffer);
  371.     }
  372.  
  373.     t = memchr(next,'\n',(int) (end - next));
  374.  
  375.     if (t == NULL) {
  376.         l = strlen(next);
  377.         memcpy(buffer,next,l+1);
  378.         i = read(fd,buffer+l, s - l - 1);
  379.         if (i < 1) {
  380.             next = NULL;
  381.             return(strdup(buffer));
  382.         }
  383.         *(buffer + l + i) = '\0';
  384.         normalize(buffer+l);
  385.         end = buffer + strlen(buffer);
  386.         next = buffer;
  387.         t = memchr(next,'\n',s);
  388.     }
  389.  
  390.     if (t != NULL) {
  391.         eol = *(t+1);
  392.         *(t+1) = '\0';
  393.     }
  394.  
  395.     text = strdup(next);
  396.  
  397.     if (t != NULL) {
  398.         *(t+1) = eol;
  399.         next = t+1;
  400.     }
  401.     else
  402.         next = NULL;
  403.  
  404.     return(text);
  405. }
  406.  
  407. int _pascal fido_setlast(AREA a)
  408.  
  409. {
  410.     FILE   *fp;
  411.     char    path[PATHLEN];
  412.     int     i = 1;
  413.  
  414.     sprintf(path, "%s/%s", a.path, lastread);
  415.     if ((fp = fopen(path, "w+b")) == NULL)
  416.         return(FALSE);
  417.     fseek(fp,0l,SEEK_SET);
  418.     if (messages) {
  419.         fwrite((char *) &messages[a.current], sizeof(int), 1, fp);
  420.         fwrite((char *) &messages[a.lastread], sizeof(int), 1, fp);
  421.     }
  422.     else {
  423.         fwrite(&i, sizeof(int), 1, fp);
  424.         fwrite(&i, sizeof(int), 1, fp);
  425.     }
  426.     fclose(fp);
  427.     return(TRUE);
  428. }
  429.  
  430.  
  431. int _pascal fido_delete(int n)
  432.  
  433. {
  434.     char path[TEXTLEN];
  435.  
  436.     sprintf(path, "%s/%d.msg", arealist[area].path, msgnum(n));
  437.     remove(path);
  438.     return(TRUE);
  439. }
  440. 
  441.