home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1998 September / PCO_0998.ISO / filesbbs / dos / sbbs_src.exe / SBBS / ECHO / SBBSECHO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-18  |  151.6 KB  |  5,033 lines
  1. /* SBBSECHO.C */
  2.  
  3. /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885    */
  4.  
  5. /* Portions written by Allen Christiansen 1994-1996                         */
  6.  
  7. /* Synchronet FidoNet EchoMail Scanning/Tossing and NetMail Tossing Utility */
  8.  
  9. #include <dos.h>
  10. #include <mem.h>
  11. #include <time.h>
  12. #include <errno.h>
  13. #include <stdio.h>
  14. #include <conio.h>
  15. #include <ctype.h>
  16. #include <fcntl.h>
  17. #include <share.h>
  18. #include <malloc.h>
  19. #include <stdarg.h>
  20. #include <stdlib.h>
  21. #include <string.h>
  22. #include <process.h>
  23. #include <sys\stat.h>
  24.  
  25. #include "sbbsdefs.h"
  26. #include "smblib.h"
  27. #include "scfglib.h"
  28. #define GLOBAL extern    /* turn vars.c and scfgvars.c files into headers */
  29. #include "scfgvars.c"
  30. #include "post.h"
  31. #include "lzh.h"
  32. #include "sbbsecho.h"
  33.  
  34. extern long crc32tbl[];
  35. ulong crc32(char *str);
  36.  
  37. #ifndef __FLAT__
  38.     #include "..\..\spawno\spawno.h"
  39. #endif
  40.  
  41. #ifdef __TURBOC__
  42.     unsigned _stklen=20000;
  43. #endif
  44.  
  45. #ifdef __WATCOMC__
  46.     #define O_DENYNONE SH_DENYNO
  47. #endif
  48.  
  49. char *wday[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
  50. char *mon[]={"Jan","Feb","Mar","Apr","May","Jun"
  51.             ,"Jul","Aug","Sep","Oct","Nov","Dec"};
  52.  
  53. smb_t *smb,*email;
  54. long misc=(IMPORT_PACKETS|IMPORT_NETMAIL|IMPORT_ECHOMAIL|EXPORT_ECHOMAIL
  55.             |DELETE_NETMAIL|DELETE_PACKETS);
  56. ulong netmail=0;
  57. char tmp[256],pkt_type=0;
  58. faddr_t sys_faddr;
  59. config_t cfg;
  60. int nodefile,secure,cur_smb=0;
  61. FILE *fidologfile=NULL;
  62. two_two_t two_two;
  63. two_plus_t two_plus;
  64.  
  65. #ifdef __WATCOMC__
  66. /******************************************************************************
  67.  A DOS to Unix function - because WATCOM doesn't have one
  68. ******************************************************************************/
  69. time_t dostounix(struct date *d,struct time *t)
  70. {
  71.     struct tm tm;
  72.  
  73. tm.tm_sec=t->ti_sec;
  74. tm.tm_min=t->ti_min;
  75. tm.tm_hour=t->ti_hour;
  76. tm.tm_mday=d->da_day;
  77. tm.tm_mon=(d->da_mon-1);
  78. tm.tm_year=d->da_year-1900;
  79. tm.tm_isdst=0;
  80.  
  81. return(mktime(&tm));
  82. }
  83. #endif
  84.  
  85. #ifndef __NT__
  86. #define delfile(x) remove(x)
  87. #else
  88. int delfile(char *filename)
  89. {
  90.     int i=0;
  91.  
  92. while(remove(filename) && i++<120)    /* Wait up to 60 seconds to delete file */
  93.     delay(500);                     /* for Win95 bug fix */
  94. return(i);
  95. }
  96. #endif
  97.  
  98. /******************************************************************************
  99.  This turns the DOS file date garbage into a long
  100. ******************************************************************************/
  101. long ddtol(ushort ftim, ushort fdat)
  102. {
  103.     struct date date;
  104.     struct time time;
  105.  
  106.     date.da_year=((fdat&0xfe00)>>9)+1980;
  107.     date.da_mon=((fdat&0x01e0)>>5);
  108.     date.da_day=(fdat&0x001f);
  109.     time.ti_hour=((ftim&0xf800)>>11);
  110.     time.ti_min=((ftim&0x07e0)>>5);
  111.     time.ti_sec=((ftim&0x001f)<<1);
  112.     time.ti_hund=0;
  113.     return(dostounix(&date,&time));
  114. }
  115. void checkmem(void)
  116. {
  117. #ifdef __WATCOMC__
  118.     char *p=NULL;
  119.     long size=640L*1024L,over;
  120.  
  121.     while(size>0) {
  122.         p=(char *)LMALLOC(size);
  123.         if(p)
  124.             break;
  125.         size-=1024L; }
  126.  
  127.     printf("\nAvailable Memory = %ld bytes",size);
  128.     if(p)
  129.         LFREE(p);
  130. #elif !defined(__OS2__)
  131.     printf("\nAvailable Memory = %ld bytes",farcoreleft());
  132. #endif
  133. }
  134.  
  135. /**********************/
  136. /* Log print function */
  137. /**********************/
  138. void logprintf(char *str, ...)
  139. {
  140.     va_list argptr;
  141.     char buf[256];
  142.     time_t now;
  143.     struct tm *gm;
  144.  
  145. if(!(misc&LOGFILE) || fidologfile==NULL)
  146.     return;
  147. va_start(argptr,str);
  148. vsprintf(buf,str,argptr);
  149. va_end(argptr);
  150. now=time(NULL);
  151. gm=localtime(&now);
  152. fseek(fidologfile,0L,SEEK_END);
  153. fprintf(fidologfile,"%02u/%02u/%02u %02u:%02u:%02u %s\r\n"
  154.     ,gm->tm_mon+1,gm->tm_mday,gm->tm_year,gm->tm_hour,gm->tm_min,gm->tm_sec
  155.     ,buf);
  156. fflush(fidologfile);
  157. }
  158.  
  159. /****************************************************************************/
  160. /* Puts a backslash on path strings                                         */
  161. /****************************************************************************/
  162. void backslash(char *str)
  163. {
  164.     int i;
  165.  
  166. i=strlen(str);
  167. if(i && str[i-1]!='\\') {
  168.     str[i]='\\'; str[i+1]=0; }
  169. }
  170.  
  171. /*****************************************************************************/
  172. /* Returns command line generated from instr with %c replacments             */
  173. /*****************************************************************************/
  174. char *cmdstr(char *instr, char *fpath, char *fspec)
  175. {
  176.     static char cmd[128];
  177.     char str[256],str2[128];
  178.     int i,j,len;
  179.  
  180. len=strlen(instr);
  181. for(i=j=0;i<len && j<128;i++) {
  182.     if(instr[i]=='%') {
  183.         i++;
  184.         cmd[j]=0;
  185.         switch(toupper(instr[i])) {
  186.             case 'F':   /* File path */
  187.                 strcat(cmd,fpath);
  188.                 break;
  189.             case 'G':   /* Temp directory */
  190.                 if(temp_dir[0]!='\\' && temp_dir[1]!=':') {
  191.                     strcpy(str,node_dir);
  192.                     strcat(str,temp_dir);
  193.                     if(_fullpath(str2,str,40))
  194.                         strcpy(str,str2);
  195.                     backslash(str);
  196.                     strcat(cmd,str);}
  197.                 else
  198.                     strcat(cmd,temp_dir);
  199.                 break;
  200.             case 'J':
  201.                 if(data_dir[0]!='\\' && data_dir[1]!=':') {
  202.                     strcpy(str,node_dir);
  203.                     strcat(str,data_dir);
  204.                     if(_fullpath(str2,str,40))
  205.                         strcpy(str,str2);
  206.                     backslash(str);
  207.                     strcat(cmd,str); }
  208.                 else
  209.                     strcat(cmd,data_dir);
  210.                 break;
  211.             case 'K':
  212.                 if(ctrl_dir[0]!='\\' && ctrl_dir[1]!=':') {
  213.                     strcpy(str,node_dir);
  214.                     strcat(str,ctrl_dir);
  215.                     if(_fullpath(str2,str,40))
  216.                         strcpy(str,str2);
  217.                     backslash(str);
  218.                     strcat(cmd,str); }
  219.                 else
  220.                     strcat(cmd,ctrl_dir);
  221.                 break;
  222.             case 'N':   /* Node Directory (same as SBBSNODE environment var) */
  223.                 strcat(cmd,node_dir);
  224.                 break;
  225.             case 'O':   /* SysOp */
  226.                 strcat(cmd,sys_op);
  227.                 break;
  228.             case 'Q':   /* QWK ID */
  229.                 strcat(cmd,sys_id);
  230.                 break;
  231.             case 'S':   /* File Spec */
  232.                 strcat(cmd,fspec);
  233.                 break;
  234.             case '!':   /* EXEC Directory */
  235.                 if(exec_dir[0]!='\\' && exec_dir[1]!=':') {
  236.                     strcpy(str,node_dir);
  237.                     strcat(str,exec_dir);
  238.                     if(_fullpath(str2,str,40))
  239.                         strcpy(str,str2);
  240.                     backslash(str);
  241.                     strcat(cmd,str); }
  242.                 else
  243.                     strcat(cmd,exec_dir);
  244.                 break;
  245.             case '#':   /* Node number (same as SBBSNNUM environment var) */
  246.                 sprintf(str,"%d",node_num);
  247.                 strcat(cmd,str);
  248.                 break;
  249.             case '*':
  250.                 sprintf(str,"%03d",node_num);
  251.                 strcat(cmd,str);
  252.                 break;
  253.             case '%':   /* %% for percent sign */
  254.                 strcat(cmd,"%");
  255.                 break;
  256.             default:    /* unknown specification */
  257.                 printf("ERROR Checking Command Line '%s'\n",instr);
  258.                 logprintf("ERROR line %d Checking Command Line '%s'",__LINE__
  259.                     ,instr);
  260.                 exit(1);
  261.                 break; }
  262.         j=strlen(cmd); }
  263.     else
  264.         cmd[j++]=instr[i]; }
  265. cmd[j]=0;
  266.  
  267. return(cmd);
  268. }
  269.  
  270. /****************************************************************************/
  271. /* Runs an external program directly using spawnvp                            */
  272. /****************************************************************************/
  273. int execute(char *cmdline)
  274. {
  275.     char c,d,e,cmdlen,*arg[30],str[256];
  276.     int i;
  277.  
  278. strcpy(str,cmdline);
  279. arg[0]=str;    /* point to the beginning of the string */
  280. cmdlen=strlen(str);
  281. for(c=0,d=1,e=0;c<cmdlen;c++,e++)    /* Break up command line */
  282.     if(str[c]==SP) {
  283.         str[c]=0;            /* insert nulls */
  284.         arg[d++]=str+c+1;    /* point to the beginning of the next arg */
  285.         e=0; }
  286. arg[d]=0;
  287. #ifndef __FLAT__
  288. if(node_swap) {
  289.     printf("Swapping...\n");
  290.     i=spawnvpo(".\\",(const char *)arg[0],(const char **)arg); }
  291. else
  292. #endif
  293.     i=spawnvp(P_WAIT,arg[0],arg);
  294. return(i);
  295. }
  296. /******************************************************************************
  297.  Returns the system address with the same zone as the address passed
  298. ******************************************************************************/
  299. faddr_t getsysfaddr(short zone)
  300. {
  301.     int i;
  302.     faddr_t sysfaddr;
  303.  
  304. sysfaddr.zone=sysfaddr.net=sysfaddr.node=1;
  305. sysfaddr.point=0;
  306. if(!total_faddrs)
  307.     return(sys_faddr);
  308. sysfaddr=faddr[0];
  309. if(total_faddrs==1)
  310.     return(sysfaddr);
  311. for(i=0;i<total_faddrs;i++)
  312.     if(faddr[i].zone==zone)
  313.         return(faddr[i]);
  314. return(sysfaddr);
  315. }
  316. /******************************************************************************
  317.  This function creates or appends on existing Binkley compatible .?LO file
  318.  attach file.
  319.  Returns 0 on success.
  320. ******************************************************************************/
  321. int write_flofile(char *attachment, faddr_t dest)
  322. {
  323.     char fname[256],outbound[128],str[128],ch;
  324.     ushort attr=0;
  325.     int i,file;
  326.     FILE *stream;
  327.  
  328. i=matchnode(dest,0);
  329. if(i<cfg.nodecfgs)
  330.     attr=cfg.nodecfg[i].attr;
  331.  
  332. if(attr&ATTR_CRASH) ch='C';
  333. else if(attr&ATTR_HOLD) ch='H';
  334. else if(attr&ATTR_DIRECT) ch='D';
  335. else ch='F';
  336. if(dest.zone==faddr[0].zone)        /* Default zone, use default outbound */
  337.     strcpy(outbound,cfg.outbound);
  338. else                                /* Inter-zone outbound is OUTBOUND.XXX */
  339.     sprintf(outbound,"%.*s.%03X\\"
  340.         ,strlen(cfg.outbound)-1,cfg.outbound,dest.zone);
  341. if(dest.point) {                    /* Point destination is OUTBOUND\*.PNT */
  342.     sprintf(str,"%04X%04X.PNT"
  343.         ,dest.net,dest.node);
  344.     strcat(outbound,str); }
  345. if(outbound[strlen(outbound)-1]=='\\')
  346.     outbound[strlen(outbound)-1]=0;
  347. mkdir(outbound);
  348. strcat(outbound,"\\");
  349. if(dest.point)
  350.     sprintf(fname,"%s%08X.%cLO",outbound,dest.point,ch);
  351. else
  352.     sprintf(fname,"%s%04X%04X.%cLO",outbound,dest.net,dest.node,ch);
  353. if((stream=fnopen(&file,fname,O_WRONLY|O_CREAT))==NULL) {
  354.     printf("\7ERROR opening %s %s\n",fname,sys_errlist[errno]);
  355.     logprintf("ERROR line %d opening %s %s",__LINE__,fname,sys_errlist[errno]);
  356.     return(-1); }
  357.  
  358. fseek(stream,0L,SEEK_END);
  359. fprintf(stream,"^%s\r\n",attachment);
  360. fclose(stream);
  361. return(0);
  362. }
  363.  
  364. /******************************************************************************
  365.  This function will create a netmail message (.MSG format).
  366.  If file is non-zero, will set file attachment bit (for bundles).
  367.  Returns 0 on success.
  368. ******************************************************************************/
  369. int create_netmail(char *to,char *subject,char *body,faddr_t dest,int file)
  370. {
  371.     FILE *fstream;
  372.     char str[256],fname[256];
  373.     ushort attr=0;
  374.     int fmsg;
  375.     uint i;
  376.     static uint startmsg;
  377.     time_t t;
  378.     fmsghdr_t hdr;
  379.     struct tm *tm;
  380.  
  381. if(!startmsg) startmsg=1;
  382. i=matchnode(dest,0);
  383. if(i<cfg.nodecfgs) {
  384.     attr=cfg.nodecfg[i].attr;
  385.     if(!attr) {
  386.         i=matchnode(dest,2);
  387.         if(i<cfg.nodecfgs)
  388.             attr=cfg.nodecfg[i].attr; } }
  389.  
  390. do {
  391.     for(i=startmsg;i;i++) {
  392.         sprintf(fname,"%s%u.MSG",netmail_dir,i);
  393.         if(!fexist(fname))
  394.             break; }
  395.     if(!i) {
  396.         printf("\7%s directory full!\n",netmail_dir);
  397.         logprintf("Directory full: %s",netmail_dir);
  398.         return(-1); }
  399.     startmsg=i+1;
  400.     strupr(fname);
  401.     if((fstream=fnopen(&fmsg,fname,O_RDWR|O_CREAT))==NULL) {
  402.         printf("\7ERROR opening %s %s\n",fname,sys_errlist[errno]);
  403.         logprintf("ERROR line %d opening %s %s",__LINE__,fname,sys_errlist[errno]);
  404.         return(-1); }
  405.  
  406.     memset(&hdr,0,sizeof(fmsghdr_t));
  407.     hdr.origzone=faddr[0].zone;
  408.     hdr.orignet=faddr[0].net;
  409.     hdr.orignode=faddr[0].node;
  410.     hdr.origpoint=faddr[0].point;
  411.     hdr.destzone=dest.zone;
  412.     hdr.destnet=dest.net;
  413.     hdr.destnode=dest.node;
  414.     hdr.destpoint=dest.point;
  415.  
  416.     hdr.attr=(FIDO_PRIVATE|FIDO_KILLSENT|FIDO_LOCAL);
  417.     if(file)
  418.         hdr.attr|=FIDO_FILE;
  419.  
  420.     if(attr&ATTR_HOLD)
  421.         hdr.attr|=FIDO_HOLD;
  422.     if(attr&ATTR_CRASH)
  423.         hdr.attr|=FIDO_CRASH;
  424.  
  425.     sprintf(hdr.from,"SBBSecho");
  426.  
  427.     t=time(NULL);
  428.     tm=gmtime(&t);
  429.     sprintf(hdr.time,"%02u %3.3s %02u  %02u:%02u:%02u"
  430.         ,tm->tm_mday,mon[tm->tm_mon],tm->tm_year
  431.         ,tm->tm_hour,tm->tm_min,tm->tm_sec);
  432.  
  433.     if(to)
  434.         sprintf(hdr.to,"%s",to);
  435.     else
  436.         sprintf(hdr.to,"SYSOP");
  437.  
  438.     sprintf(hdr.subj,"%.71s",subject);
  439.  
  440.     fwrite(&hdr,sizeof(fmsghdr_t),1,fstream);
  441.     sprintf(str,"\1INTL %u:%u/%u %u:%u/%u\r"
  442.         ,hdr.destzone,hdr.destnet,hdr.destnode
  443.         ,hdr.origzone,hdr.orignet,hdr.orignode);
  444.     fwrite(str,strlen(str),1,fstream);
  445.     if(attr&ATTR_DIRECT) {
  446.         fwrite("\1FLAGS DIR",10,1,fstream);
  447.         if(file)
  448.             fwrite(" KFS\r",5,1,fstream);
  449.         else
  450.             fwrite("\r",1,1,fstream); }
  451.     if(hdr.destpoint) {
  452.         sprintf(str,"\1TOPT %u\r",hdr.destpoint);
  453.         fwrite(str,strlen(str),1,fstream); }
  454.     if(hdr.origpoint) {
  455.         sprintf(str,"\1FMPT %u\r",hdr.origpoint);
  456.         fwrite(str,strlen(str),1,fstream); }
  457.     if(!file || (!(attr&ATTR_DIRECT) && file))
  458.         fwrite(body,strlen(body)+1,1,fstream);    /* Write additional NULL */
  459.     else
  460.         fwrite("\0",1,1,fstream);               /* Write NULL */
  461.     fclose(fstream);
  462. } while(!fexist(fname));
  463. return(0);
  464. }
  465.  
  466. /******************************************************************************
  467.  This function takes the contents of 'infile' and puts it into a netmail
  468.  message bound for addr.
  469. ******************************************************************************/
  470. void file_to_netmail(FILE *infile,char *title,faddr_t addr,char *to)
  471. {
  472.     char *buf,*p;
  473.     long l,m,len;
  474.  
  475. l=len=ftell(infile);
  476. if(len>8192L)
  477.     len=8192L;
  478. rewind(infile);
  479. if((buf=(char *)MALLOC(len+1))==NULL) {
  480.     printf("ERROR allocating %lu bytes for file to netmail buffer.\n",len);
  481.     logprintf("ERROR line %d allocating %lu for file to netmail buf",__LINE__
  482.         ,len);
  483.     return; }
  484. while((m=fread(buf,1,(len>8064L) ? 8064L:len,infile))>0) {
  485.     buf[m]=0;
  486.     if(l>8064L && (p=strrchr(buf,'\n'))!=NULL) {
  487.         p++;
  488.         if(*p) {
  489.             *p=0;
  490.             p++;
  491.             fseek(infile,-1L,SEEK_CUR);
  492.             while(*p) {             /* Seek back to end of last line */
  493.                 p++;
  494.                 fseek(infile,-1L,SEEK_CUR); } } }
  495.     if(ftell(infile)<l)
  496.         strcat(buf,"\r\nContinued in next message...\r\n");
  497.     create_netmail(to,title,buf,addr,0); }
  498. FREE(buf);
  499. }
  500. /******************************************************************************
  501.  This function sends a notify list to applicable nodes, this list includes the
  502.  settings configured for the node, as well as a list of areas the node is
  503.  connected to.
  504. ******************************************************************************/
  505. void notify_list(void)
  506. {
  507.     FILE *tmpf;
  508.     char str[256];
  509.     int i,j,k;
  510.  
  511. for(k=0;k<cfg.nodecfgs;k++) {
  512.  
  513.     if(!(cfg.nodecfg[k].attr&SEND_NOTIFY))
  514.         continue;
  515.  
  516.     if((tmpf=tmpfile())==NULL) {
  517.         printf("\7ERROR couldn't open tmpfile.\n");
  518.         logprintf("ERROR line %d couldn't open tmpfile",__LINE__);
  519.         return; }
  520.  
  521.     fprintf(tmpf,"Following are the options set for your system and a list "
  522.         "of areas\r\nyou are connected to.  Please make sure everything "
  523.         "is correct.\r\n\r\n");
  524.     fprintf(tmpf,"Packet Type       %s\r\n"
  525.         ,cfg.nodecfg[k].pkt_type==PKT_TWO ? "2"
  526.         :cfg.nodecfg[k].pkt_type==PKT_TWO_TWO ? "2.2":"2+");
  527.     fprintf(tmpf,"Archive Type      %s\r\n"
  528.         ,(cfg.nodecfg[k].arctype>cfg.arcdefs) ?
  529.          "None":cfg.arcdef[cfg.nodecfg[k].arctype].name);
  530.     fprintf(tmpf,"Mail Status       %s\r\n"
  531.         ,cfg.nodecfg[k].attr&ATTR_CRASH ? "Crash"
  532.         :cfg.nodecfg[k].attr&ATTR_HOLD ? "Hold" : "None");
  533.     fprintf(tmpf,"Direct            %s\r\n"
  534.         ,cfg.nodecfg[k].attr&ATTR_DIRECT ? "Yes":"No");
  535.     fprintf(tmpf,"Passive           %s\r\n"
  536.         ,cfg.nodecfg[k].attr&ATTR_PASSIVE ? "Yes":"No");
  537.     fprintf(tmpf,"Remote AreaMgr    %s\r\n\r\n"
  538.         ,cfg.nodecfg[k].password[0] ? "Yes" : "No");
  539.  
  540.     fprintf(tmpf,"Connected Areas\r\n---------------\r\n");
  541.     for(i=0;i<cfg.areas;i++) {
  542.         sprintf(str,"%s\r\n",cfg.area[i].name);
  543.         if(str[0]=='*')
  544.             continue;
  545.         for(j=0;j<cfg.area[i].uplinks;j++)
  546.             if(!memcmp(&cfg.nodecfg[k].faddr,&cfg.area[i].uplink[j]
  547.                 ,sizeof(faddr_t)))
  548.                 break;
  549.         if(j<cfg.area[i].uplinks)
  550.             fprintf(tmpf,"%s",str); }
  551.  
  552.     if(ftell(tmpf))
  553.         file_to_netmail(tmpf,"SBBSecho Notify List",cfg.nodecfg[k].faddr,0);
  554.     fclose(tmpf); }
  555. }
  556. /******************************************************************************
  557.  This function creates a netmail to addr showing a list of available areas (0),
  558.  a list of connected areas (1), or a list of removed areas (2).
  559. ******************************************************************************/
  560. void netmail_arealist(char type,faddr_t addr)
  561. {
  562.     FILE *stream,*tmpf;
  563.     char str[256],temp[256],title[81],match,*p;
  564.     int file,i,j,k,x,y;
  565.  
  566. if(!type)
  567.     strcpy(title,"List of Available Areas");
  568. else if(type==1)
  569.     strcpy(title,"List of Connected Areas");
  570. else
  571.     strcpy(title,"List of Unlinked Areas");
  572.  
  573. if((tmpf=tmpfile())==NULL) {
  574.     printf("\7ERROR couldn't open tmpfile.\n");
  575.     logprintf("ERROR line %d couldn't open tmpfile",__LINE__);
  576.     return; }
  577.  
  578. if(type==1 || (type!=1 && !(misc&ELIST_ONLY))) {
  579.     for(i=0;i<cfg.areas;i++) {
  580.         sprintf(str,"%s\r\n",cfg.area[i].name);
  581.         if(type) {
  582.             for(j=0;j<cfg.area[i].uplinks;j++)
  583.                 if(!memcmp(&addr,&cfg.area[i].uplink[j],sizeof(faddr_t)))
  584.                     break;
  585.             if((type==1 && j<cfg.area[i].uplinks) ||
  586.                 (type==2 && j==cfg.area[i].uplinks))
  587.                     fprintf(tmpf,"%s",str); }
  588.         else
  589.             fprintf(tmpf,"%s",str); } }
  590.  
  591. if(!type) {
  592.     i=matchnode(addr,0);
  593.     if(i<cfg.nodecfgs) {
  594.         for(j=0;j<cfg.listcfgs;j++) {
  595.             match=0;
  596.             for(k=0;k<cfg.listcfg[j].numflags;k++) {
  597.                 if(match) break;
  598.                 for(x=0;x<cfg.nodecfg[i].numflags;x++)
  599.                     if(!stricmp(cfg.listcfg[j].flag[k].flag
  600.                         ,cfg.nodecfg[i].flag[x].flag)) {
  601.                         if((stream=fnopen(&file
  602.                             ,cfg.listcfg[j].listpath,O_RDONLY))==NULL) {
  603.                             printf("\7ERROR couldn't open %s.\n"
  604.                                 ,cfg.listcfg[j].listpath);
  605.                             logprintf("ERROR line %d couldn't open %s %s"
  606.                                 ,__LINE__,cfg.listcfg[j].listpath
  607.                                 ,sys_errlist[errno]);
  608.                             match=1;
  609.                             break; }
  610.                         while(!feof(stream)) {
  611.                             if(!fgets(str,255,stream))
  612.                                 break;
  613.                             truncsp(str);
  614.                             strcat(str,"\r\n");
  615.                             p=str;
  616.                             while(*p && *p<=SP) p++;
  617.                             if(*p==';')     /* Ignore Comment Lines */
  618.                                 continue;
  619.                             strcpy(temp,p);
  620.                             p=temp;
  621.                             while(*p && *p>SP) p++;
  622.                             *p=0;
  623.                             if(!(misc&ELIST_ONLY)) {
  624.                                 for(y=0;y<cfg.areas;y++)
  625.                                     if(!stricmp(cfg.area[y].name,temp))
  626.                                         break;
  627.                                 if(y==cfg.areas)
  628.                                     fprintf(tmpf,"%s",str); }
  629.                             else
  630.                                 fprintf(tmpf,"%s",str); }
  631.                         fclose(stream);
  632.                         match=1;
  633.                         break; } } } } }
  634.  
  635. if(!ftell(tmpf))
  636.     create_netmail(0,title,"None.",addr,0);
  637. else
  638.     file_to_netmail(tmpf,title,addr,0);
  639. fclose(tmpf);
  640. }
  641. /******************************************************************************
  642.  Imitation of Borland's tempnam function because Watcom doesn't have it
  643. ******************************************************************************/
  644. //#ifdef __WATCOMC__
  645. char *tempname(char *dir, char *prefix)
  646. {
  647.     char str[256],*p;
  648.     int i;
  649.  
  650. for(i=0;i<1000;i++) {
  651.     sprintf(str,"%s%s%03u.$$$",dir,prefix,i);
  652.     if(!fexist(str))
  653.         break; }
  654. if(i>=1000) {
  655.     logprintf("tempnam: too many files");
  656.     return(NULL); }
  657. p=malloc(strlen(str)+1);
  658. if(!p) {
  659.     logprintf("tempnam: couldn't malloc %u",strlen(str)+1);
  660.     return(NULL); }
  661. strcpy(p,str);
  662. return(p);
  663. }
  664. //#endif
  665.  
  666. char check_elists(char *areatag,faddr_t addr)
  667. {
  668.     FILE *stream;
  669.     char str[1025],quit=0,match=0,*p;
  670.     int i,j,k,x,file;
  671.  
  672. i=matchnode(addr,0);
  673. if(i<cfg.nodecfgs) {
  674.     for(j=0;j<cfg.listcfgs;j++) {
  675.         quit=0;
  676.         for(k=0;k<cfg.listcfg[j].numflags;k++) {
  677.             if(quit) break;
  678.             for(x=0;x<cfg.nodecfg[i].numflags;x++)
  679.                 if(!stricmp(cfg.listcfg[j].flag[k].flag
  680.                     ,cfg.nodecfg[i].flag[x].flag)) {
  681.                     if((stream=fnopen(&file
  682.                         ,cfg.listcfg[j].listpath,O_RDONLY))==NULL) {
  683.                         printf("\7ERROR couldn't open %s.\n"
  684.                             ,cfg.listcfg[j].listpath);
  685.                         logprintf("ERROR line %d opening %s"
  686.                             ,__LINE__,cfg.listcfg[j].listpath);
  687.                         quit=1;
  688.                         break; }
  689.                     while(!feof(stream)) {
  690.                         if(!fgets(str,255,stream))
  691.                             break;
  692.                         truncsp(str);
  693.                         strcat(str,"\r\n");
  694.                         p=str;
  695.                         while(*p && *p<=SP) p++;
  696.                         if(*p==';')     /* Ignore Comment Lines */
  697.                             continue;
  698.                         strcpy(str,p);
  699.                         p=str;
  700.                         while(*p && *p>SP) p++;
  701.                         *p=0;
  702.                         if(!stricmp(areatag,str)) {
  703.                             match=1;
  704.                             break; } }
  705.                     fclose(stream);
  706.                     quit=1;
  707.                     if(match)
  708.                         return(match);
  709.                     break; } } } }
  710. return(match);
  711. }
  712. /******************************************************************************
  713.  Used by AREAFIX to add/remove/change areas in the areas file
  714. ******************************************************************************/
  715. void alter_areas(area_t add_area,area_t del_area,faddr_t addr)
  716. {
  717.     FILE *nmfile,*afilein,*afileout,*reqfile,*fwdfile;
  718.     char str[1025],fields[1025],field1[81],field2[81],field3[81]
  719.         ,drive[3],dir[66],name[9],ext[5],outpath[128]
  720.         ,*outname,*p,*tp,nomatch=0,match=0;
  721.     int i,j,k,x,y,file;
  722.     ulong tagcrc;
  723.  
  724. _splitpath(cfg.areafile,drive,dir,name,ext);
  725. sprintf(outpath,"%s%s",drive,dir);
  726. if((outname=tempname(outpath,"AREAS"))==NULL) {
  727.     printf("\7ERROR creating temp file name for %s.\n",outpath);
  728.     logprintf("ERROR tempnam(%s,AREAS)",outpath);
  729.     return; }
  730. if((nmfile=tmpfile())==NULL) {
  731.     printf("\7ERROR couldn't open NetMail temp file.\n");
  732.     logprintf("ERROR in tmpfile()");
  733.     free(outname);
  734.     return; }
  735. if((afileout=fopen(outname,"w+b"))==NULL) {
  736.     printf("\7ERROR couldn't open %s.\n",outname);
  737.     logprintf("ERROR line %d opening %s %s",__LINE__,outname
  738.         ,sys_errlist[errno]);
  739.     fclose(nmfile);
  740.     free(outname);
  741.     return; }
  742. if((afilein=fnopen(&file,cfg.areafile,O_RDONLY))==NULL) {
  743.     printf("\7ERROR couldn't open %s.\n",cfg.areafile);
  744.     logprintf("ERROR line %d opening %s %s",__LINE__,cfg.areafile
  745.         ,sys_errlist[errno]);
  746.     fclose(afileout);
  747.     fclose(nmfile);
  748.     free(outname);
  749.     return; }
  750. while(!feof(afilein)) {
  751.     if(!fgets(fields,1024,afilein))
  752.         break;
  753.     truncsp(fields);
  754.     strcat(fields,"\r\n");
  755.     p=fields;
  756.     while(*p && *p<=SP) p++;
  757.     if(*p==';') {    /* Skip Comment Lines */
  758.         fprintf(afileout,"%s",fields);
  759.         continue; }
  760.     sprintf(field1,"%-.81s",p);         /* Internal Code Field */
  761.     tp=field1;
  762.     while(*tp && *tp>SP) tp++;
  763.     *tp=0;
  764.     while(*p && *p>SP) p++;
  765.     while(*p && *p<=SP) p++;
  766.     sprintf(field2,"%-.81s",p);         /* Areatag Field */
  767.     tp=field2;
  768.     while(*tp && *tp>SP) tp++;
  769.     *tp=0;
  770.     while(*p && *p>SP) p++;
  771.     while(*p && *p<=SP) p++;
  772.     if((tp=strchr(p,';'))!=NULL) {
  773.         sprintf(field3,"%-.81s",p);     /* Comment Field (if any) */
  774.         while(*tp && *tp>SP) tp++;
  775.         *tp=0; }
  776.     else
  777.         field3[0]=0;
  778.     if(del_area.tags) {                 /* Check for areas to remove */
  779.         for(i=0;i<del_area.tags;i++) {
  780.             if(!stricmp(del_area.tag[i],field2) ||
  781.                 !stricmp(del_area.tag[0],"-ALL"))     /* Match Found */
  782.                 break; }
  783.         if(i<del_area.tags) {
  784.             for(i=0;i<cfg.areas;i++) {
  785.                 if(!stricmp(field2,cfg.area[i].name)) {
  786.                     for(j=0;j<cfg.area[i].uplinks;j++)
  787.                         if(!memcmp(&cfg.area[i].uplink[j],&addr
  788.                             ,sizeof(faddr_t)))
  789.                             break;
  790.                     if(j==cfg.area[i].uplinks &&
  791.                         stricmp(del_area.tag[0],"-ALL")) {
  792.                         fprintf(afileout,"%s",fields);
  793.                         fprintf(nmfile,"%s not connected.\r\n",field2);
  794.                         break; }
  795.  
  796.                     /* Added 12/4/95 to remove uplink from connected uplinks */
  797.  
  798.                     for(k=j;k<cfg.area[i].uplinks-1;k++)
  799.                         memcpy(&cfg.area[i].uplink[k],&cfg.area[i].uplink[k+1]
  800.                             ,sizeof(faddr_t));
  801.                     --cfg.area[i].uplinks;
  802.                     if((cfg.area[i].uplink=(faddr_t *)
  803.                         REALLOC(cfg.area[i].uplink,sizeof(faddr_t)
  804.                         *(cfg.area[i].uplinks)))==NULL) {
  805.                         printf("ERROR allocating memory for area #%u "
  806.                             "uplinks.\n",i+1);
  807.                         logprintf("ERROR line %d allocating memory for area "
  808.                             "#%u uplinks.\n",__LINE__,i+1);
  809.                         exit(1); }
  810.  
  811.                     fprintf(afileout,"%-16s%-23s ",field1,field2);
  812.                     for(j=0;j<cfg.area[i].uplinks;j++) {
  813.                         if(!memcmp(&cfg.area[i].uplink[j],&addr
  814.                             ,sizeof(faddr_t)))
  815.                             continue;
  816.                         fprintf(afileout,"%s "
  817.                             ,faddrtoa(cfg.area[i].uplink[j])); }
  818.                     if(field3[0])
  819.                         fprintf(afileout,"%s",field3);
  820.                     fprintf(afileout,"\r\n");
  821.                     fprintf(nmfile,"%s removed.\r\n",field2);
  822.                     break; } }
  823.             if(i==cfg.areas)            /* Something screwy going on */
  824.                 fprintf(afileout,"%s",fields);
  825.             continue; } }                /* Area match so continue on */
  826.     if(add_area.tags) {                 /* Check for areas to add */
  827.         for(i=0;i<add_area.tags;i++)
  828.             if(!stricmp(add_area.tag[i],field2) ||
  829.                 !stricmp(add_area.tag[0],"+ALL"))      /* Match Found */
  830.                 break;
  831.         if(i<add_area.tags) {
  832.             if(stricmp(add_area.tag[i],"+ALL"))
  833.                 add_area.tag[i][0]=0;  /* So we can check other lists */
  834.             for(i=0;i<cfg.areas;i++) {
  835.                 if(!stricmp(field2,cfg.area[i].name)) {
  836.                     for(j=0;j<cfg.area[i].uplinks;j++)
  837.                         if(!memcmp(&cfg.area[i].uplink[j],&addr
  838.                             ,sizeof(faddr_t)))
  839.                             break;
  840.                     if(j<cfg.area[i].uplinks) {
  841.                         fprintf(afileout,"%s",fields);
  842.                         fprintf(nmfile,"%s already connected.\r\n",field2);
  843.                         break; }
  844.                     if(misc&ELIST_ONLY && !check_elists(field2,addr)) {
  845.                         fprintf(afileout,"%s",fields);
  846.                         break; }
  847.  
  848.                     /* Added 12/4/95 to add uplink to connected uplinks */
  849.  
  850.                     ++cfg.area[i].uplinks;
  851.                     if((cfg.area[i].uplink=(faddr_t *)
  852.                         REALLOC(cfg.area[i].uplink,sizeof(faddr_t)
  853.                         *(cfg.area[i].uplinks)))==NULL) {
  854.                         printf("ERROR allocating memory for area #%u "
  855.                             "uplinks.\n",i+1);
  856.                         logprintf("ERROR line %d allocating memory for area "
  857.                             "#%u uplinks.\n",__LINE__,i+1);
  858.                         exit(1); }
  859.                     memcpy(&cfg.area[i].uplink[j],&addr,sizeof(faddr_t));
  860.  
  861.                     fprintf(afileout,"%-16s%-23s ",field1,field2);
  862.                     for(j=0;j<cfg.area[i].uplinks;j++)
  863.                         fprintf(afileout,"%s "
  864.                             ,faddrtoa(cfg.area[i].uplink[j]));
  865. #if 0 // Removed (02/26/96) rrs
  866.                     fprintf(afileout,"%s ",faddrtoa(addr));
  867. #endif
  868.                     if(field3[0])
  869.                         fprintf(afileout,"%s",field3);
  870.                     fprintf(afileout,"\r\n");
  871.                     fprintf(nmfile,"%s added.\r\n",field2);
  872.                     break; } }
  873.             if(i==cfg.areas)            /* Something screwy going on */
  874.                 fprintf(afileout,"%s",fields);
  875.             continue; }                 /* Area match so continue on */
  876.         nomatch=1; }                    /* This area wasn't in there */
  877.     fprintf(afileout,"%s",fields); }    /* No match so write back line */
  878. fclose(afilein);
  879. if(nomatch || (add_area.tags && !stricmp(add_area.tag[0],"+ALL"))) {
  880.     i=matchnode(addr,0);
  881.     if(i<cfg.nodecfgs) {
  882.         for(j=0;j<cfg.listcfgs;j++) {
  883.             match=0;
  884.             for(k=0;k<cfg.listcfg[j].numflags;k++) {
  885.                 if(match) break;
  886.                 for(x=0;x<cfg.nodecfg[i].numflags;x++)
  887.                     if(!stricmp(cfg.listcfg[j].flag[k].flag
  888.                         ,cfg.nodecfg[i].flag[x].flag)) {
  889.                         if((fwdfile=tmpfile())==NULL) {
  890.                             printf("\7ERROR couldn't open forwarding temp "
  891.                                 "file.\n");
  892.                             logprintf("ERROR line %d opening forward temp "
  893.                                 "file",__LINE__);
  894.                             match=1;
  895.                             break; }
  896.                         if((afilein=fnopen(&file
  897.                             ,cfg.listcfg[j].listpath,O_RDONLY))==NULL) {
  898.                             printf("\7ERROR couldn't open %s.\n"
  899.                                 ,cfg.listcfg[j].listpath);
  900.                             logprintf("ERROR line %d opening %s"
  901.                                 ,__LINE__,cfg.listcfg[j].listpath);
  902.                             fclose(fwdfile);
  903.                             match=1;
  904.                             break; }
  905.                         while(!feof(afilein)) {
  906.                             if(!fgets(str,255,afilein))
  907.                                 break;
  908.                             truncsp(str);
  909.                             strcat(str,"\r\n");
  910.                             p=str;
  911.                             while(*p && *p<=SP) p++;
  912.                             if(*p==';')     /* Ignore Comment Lines */
  913.                                 continue;
  914.                             strcpy(str,p);
  915.                             p=str;
  916.                             while(*p && *p>SP) p++;
  917.                             *p=0;
  918.                             if(!stricmp(add_area.tag[0],"+ALL")) {
  919.                                 sprintf(fields,"%.1024s",str);
  920.                                 tagcrc=crc32(strupr(fields));
  921.                                 for(y=0;y<cfg.areas;y++)
  922.                                     if(tagcrc==cfg.area[y].tag)
  923.                                         break;
  924.                                 if(y<cfg.areas)
  925.                                     continue; }
  926.                             for(y=0;y<add_area.tags;y++)
  927.                                 if((!stricmp(add_area.tag[y],str) &&
  928.                                     add_area.tag[y][0]) ||
  929.                                     !stricmp(add_area.tag[0],"+ALL"))
  930.                                     break;
  931.                             if(y<add_area.tags) {
  932.                                 fprintf(afileout,"%-16s%-23s","P",str);
  933.                                 if(cfg.listcfg[j].forward.zone)
  934.                                     fprintf(afileout," %s"
  935.                                         ,faddrtoa(cfg.listcfg[j].forward));
  936.                                 fprintf(afileout," %s\r\n",faddrtoa(addr));
  937.                                 fprintf(nmfile,"%s added.\r\n",str);
  938.                                 if(stricmp(add_area.tag[0],"+ALL"))
  939.                                     add_area.tag[y][0]=0;
  940.                                 if(!(cfg.listcfg[j].misc&NOFWD)
  941.                                     && cfg.listcfg[j].forward.zone)
  942.                                     fprintf(fwdfile,"%s\r\n",str); } }
  943.                         fclose(afilein);
  944.                         if(!(cfg.listcfg[j].misc&NOFWD) && ftell(fwdfile)>0)
  945.                             file_to_netmail(fwdfile,cfg.listcfg[j].password
  946.                                 ,cfg.listcfg[j].forward,"Areafix");
  947.                         fclose(fwdfile);
  948.                         match=1;
  949.                         break; } } } } }
  950. if(add_area.tags && stricmp(add_area.tag[0],"+ALL")) {
  951.     for(i=0;i<add_area.tags;i++)
  952.         if(add_area.tag[i][0])
  953.             fprintf(nmfile,"%s not found.\r\n",add_area.tag[i]); }
  954. if(!ftell(nmfile))
  955.     create_netmail(0,"Area Change Request","No changes made.",addr,0);
  956. else
  957.     file_to_netmail(nmfile,"Area Change Request",addr,0);
  958. fclose(nmfile);
  959. fclose(afileout);
  960. if(delfile(cfg.areafile))                    /* Delete AREAS.BBS */
  961.     logprintf("ERROR line %d removing %s %s",__LINE__,cfg.areafile
  962.         ,sys_errlist[errno]);
  963. if(rename(outname,cfg.areafile))           /* Rename new AREAS.BBS file */
  964.     logprintf("ERROR line %d renaming %s to %s",__LINE__,outname,cfg.areafile);
  965. free(outname);
  966. }
  967. /******************************************************************************
  968.  Used by AREAFIX to add/remove/change uplink info in the configuration file
  969.  old = the old setting for this option, new = what the setting is changing to
  970.  option = 0 for compression type change
  971.           1 for areafix password change
  972.           2 to set this node to passive
  973.           3 to set this node to active (remove passive)
  974. ******************************************************************************/
  975. void alter_config(faddr_t addr,char *old,char *new,char option)
  976. {
  977.     FILE *outfile,*cfgfile;
  978.     char str[257],outpath[128],tmp[257],tmp2[257],*outname,*p,*tp
  979.         ,drive[3],dir[66],name[9],ext[5],match=0;
  980.     int i,j,k,file;
  981.     faddr_t taddr;
  982.  
  983. i=matchnode(addr,0);                  /* i = config number from here on */
  984. _splitpath(cfg.cfgfile,drive,dir,name,ext);
  985. sprintf(outpath,"%s%s",drive,dir);
  986. if((outname=tempname(outpath,"CFG"))==NULL) {
  987.     printf("\7ERROR creating temporary file name for %s.\n",outpath);
  988.     logprintf("ERROR tempnam(%s,CFG)",outpath);
  989.     return; }
  990. if((outfile=fopen(outname,"w+b"))==NULL) {
  991.     printf("\7ERROR couldn't open %s.\n",outname);
  992.     logprintf("ERROR line %d opening %s %s",__LINE__,outname
  993.         ,sys_errlist[errno]);
  994.     free(outname);
  995.     return; }
  996. if((cfgfile=fnopen(&file,cfg.cfgfile,O_RDONLY))==NULL) {
  997.     printf("\7ERROR couldn't open %s.\n",cfg.cfgfile);
  998.     logprintf("ERROR line %d opening %s",__LINE__,cfg.cfgfile
  999.         ,sys_errlist[errno]);
  1000.     fclose(outfile);
  1001.     free(outname);
  1002.     return; }
  1003.  
  1004. while(!feof(cfgfile)) {
  1005.     if(!fgets(str,256,cfgfile))
  1006.         break;
  1007.     truncsp(str);
  1008.     p=str;
  1009.     while(*p && *p<=SP) p++;
  1010.     if(*p==';') {
  1011.         fprintf(outfile,"%s\r\n",str);
  1012.         continue; }
  1013.     sprintf(tmp,"%-.25s",p);
  1014.     tp=strchr(tmp,SP);
  1015.     if(tp)
  1016.         *tp=0;                                /* Chop off at space */
  1017.     strupr(tmp);                            /* Convert code to uppercase */
  1018.     while(*p>SP) p++;                        /* Skip code */
  1019.     while(*p && *p<=SP) p++;                /* Skip white space */
  1020.  
  1021.     if(option==0 && !strcmp(tmp,"USEPACKER")) {     /* Change Compression */
  1022.         if(!*p)
  1023.             continue;
  1024.         strcpy(tmp2,p);
  1025.         p=tmp2;
  1026.         while(*p && *p>SP) p++;
  1027.         *p=0;
  1028.         p++;
  1029.         if(!stricmp(new,tmp2)) {   /* Add to new definition */
  1030.             fprintf(outfile,"%-10s %s %s %s\r\n",tmp,tmp2
  1031.                 ,faddrtoa(cfg.nodecfg[i].faddr)
  1032.                 ,(*p) ? p : "");
  1033.             match=1;
  1034.             continue; }
  1035.         else if(!stricmp(old,tmp2)) {    /* Remove from old def */
  1036.             for(j=k=0;j<cfg.nodecfgs;j++) {
  1037.                 if(j==i)
  1038.                     continue;
  1039.                 if(!stricmp(cfg.arcdef[cfg.nodecfg[j].arctype].name,tmp2)) {
  1040.                     if(!k) {
  1041.                         fprintf(outfile,"%-10s %s",tmp,tmp2);
  1042.                         k++; }
  1043.                     fprintf(outfile," %s"
  1044.                         ,faddrtoa(cfg.nodecfg[j].faddr)); } }
  1045.             fprintf(outfile,"\r\n");
  1046.             continue; } }
  1047.  
  1048.     if(option==1 && !strcmp(tmp,"AREAFIX")) {       /* Change Password */
  1049.         if(!*p)
  1050.             continue;
  1051.         taddr=atofaddr(p);
  1052.         if(!memcmp(&cfg.nodecfg[i].faddr,&taddr,sizeof(faddr_t))) {
  1053.             while(*p && *p>SP) p++;     /* Skip over address */
  1054.             while(*p && *p<=SP) p++;    /* Skip over whitespace */
  1055.             while(*p && *p>SP) p++;     /* Skip over password */
  1056.             while(*p && *p<=SP) p++;    /* Skip over whitespace */
  1057.             fprintf(outfile,"%-10s %s %s %s\r\n",tmp
  1058.                 ,faddrtoa(cfg.nodecfg[i].faddr),new,p);
  1059.             continue; } }
  1060.  
  1061.     if(option>1 && !strcmp(tmp,"PASSIVE")) {        /* Toggle Passive Areas */
  1062.         match=1;
  1063.         for(j=k=0;j<cfg.nodecfgs;j++) {
  1064.             if(option==2 && j==i) {
  1065.                 if(!k) fprintf(outfile,"%-10s",tmp);
  1066.                 fprintf(outfile," %s",faddrtoa(cfg.nodecfg[j].faddr));
  1067.                 k++;
  1068.                 continue; }
  1069.             if(option==3 && j==i)
  1070.                 continue;
  1071.             if(cfg.nodecfg[j].attr&ATTR_PASSIVE) {
  1072.                 if(!k) fprintf(outfile,"%-10s",tmp);
  1073.                 fprintf(outfile," %s",faddrtoa(cfg.nodecfg[j].faddr));
  1074.                 k++; } }
  1075.         if(k) fprintf(outfile,"\r\n");
  1076.         continue; }
  1077.     fprintf(outfile,"%s\r\n",str); }
  1078.  
  1079. if(!match) {
  1080.     if(option==0)
  1081.         fprintf(outfile,"%-10s %s %s\r\n","USEPACKER",new
  1082.             ,faddrtoa(cfg.nodecfg[i].faddr));
  1083.     if(option==2)
  1084.         fprintf(outfile,"%-10s %s\r\n","PASSIVE"
  1085.             ,faddrtoa(cfg.nodecfg[i].faddr)); }
  1086.  
  1087. fclose(cfgfile);
  1088. fclose(outfile);
  1089. if(delfile(cfg.cfgfile))
  1090.     logprintf("ERROR line %d removing %s %s",__LINE__,cfg.cfgfile
  1091.         ,sys_errlist[errno]);
  1092. if(rename(outname,cfg.cfgfile))
  1093.     logprintf("ERROR line %d renaming %s to %s",__LINE__,outname,cfg.cfgfile);
  1094. free(outname);
  1095. }
  1096. /******************************************************************************
  1097.  Used by AREAFIX to process any '%' commands that come in via netmail
  1098. ******************************************************************************/
  1099. void command(char *instr,faddr_t addr)
  1100. {
  1101.     FILE *stream,*tmpf;
  1102.     char str[256],temp[256],match,*buf,*p;
  1103.     int  file,i,j,node;
  1104.     long l;
  1105.     area_t add_area,del_area;
  1106.  
  1107. node=matchnode(addr,0);
  1108. if(node==cfg.nodecfgs)
  1109.     return;
  1110. memset(&add_area,0,sizeof(area_t));
  1111. memset(&del_area,0,sizeof(area_t));
  1112. strupr(instr);
  1113. if((p=strstr(instr,"HELP"))!=NULL) {
  1114.     sprintf(str,"%s%sAREAMGR.HLP",(exec_dir[0]=='.') ? node_dir:"",exec_dir);
  1115.     if(!fexist(str))
  1116.         return;
  1117.     if((stream=fnopen(&file,str,O_RDONLY))==NULL) {
  1118.         printf("\7ERROR couldn't open %s.\n",str);
  1119.         logprintf("ERROR line %d opening %s %s",__LINE__,str
  1120.             ,sys_errlist[errno]);
  1121.         return; }
  1122.     l=filelength(file);
  1123.     if((buf=(char *)LMALLOC(l+1L))==NULL) {
  1124.         printf("ERROR line %d allocating %lu bytes for %s\n",__LINE__,l,str);
  1125.         return; }
  1126.     fread(buf,l,1,stream);
  1127.     fclose(stream);
  1128.     buf[l]=0;
  1129.     create_netmail(0,"Area Manager Help",buf,addr,0);
  1130.     LFREE(buf);
  1131.     return; }
  1132.  
  1133. if((p=strstr(instr,"LIST"))!=NULL) {
  1134.     netmail_arealist(0,addr);
  1135.     return; }
  1136.  
  1137. if((p=strstr(instr,"QUERY"))!=NULL) {
  1138.     netmail_arealist(1,addr);
  1139.     return; }
  1140.  
  1141. if((p=strstr(instr,"UNLINKED"))!=NULL) {
  1142.     netmail_arealist(2,addr);
  1143.     return; }
  1144.  
  1145. if((p=strstr(instr,"COMPRESSION"))!=NULL) {
  1146.     while(*p && *p>SP) p++;
  1147.     while(*p && *p<=SP) p++;
  1148.     for(i=0;i<cfg.arcdefs;i++)
  1149.         if(!stricmp(p,cfg.arcdef[i].name))
  1150.             break;
  1151.     if(!stricmp(p,"NONE"))
  1152.         i=0xffff;
  1153.     if(i==cfg.arcdefs) {
  1154.         if((tmpf=tmpfile())==NULL) {
  1155.             printf("\7ERROR couldn't open tmpfile.\n");
  1156.             logprintf("ERROR line %d opening tmpfile()",__LINE__);
  1157.             return; }
  1158.         fprintf(tmpf,"Compression type unavailable.\r\n\r\n"
  1159.             "Available types are:\r\n");
  1160.         for(i=0;i<cfg.arcdefs;i++)
  1161.             fprintf(tmpf,"                     %s\r\n",cfg.arcdef[i].name);
  1162.         file_to_netmail(tmpf,"Compression Type Change",addr,0);
  1163.         fclose(tmpf);
  1164.         LFREE(buf);
  1165.         return; }
  1166.     alter_config(addr,cfg.arcdef[cfg.nodecfg[node].arctype].name
  1167.         ,cfg.arcdef[i].name,0);
  1168.     cfg.nodecfg[node].arctype=i;
  1169.     sprintf(str,"Compression type changed to %s.",cfg.arcdef[i].name);
  1170.     create_netmail(0,"Compression Type Change",str,addr,0);
  1171.     return; }
  1172.  
  1173. if((p=strstr(instr,"PASSWORD"))!=NULL) {
  1174.     while(*p && *p>SP) p++;
  1175.     while(*p && *p<=SP) p++;
  1176.     sprintf(temp,"%-.25s",p);
  1177.     p=temp;
  1178.     while(*p && *p>SP) p++;
  1179.     *p=0;
  1180.     if(node==cfg.nodecfgs)           /* Should never happen */
  1181.         return;
  1182.     if(!stricmp(temp,cfg.nodecfg[node].password)) {
  1183.         sprintf(str,"Your password was already set to %s."
  1184.             ,cfg.nodecfg[node].password);
  1185.         create_netmail(0,"Password Change Request",str,addr,0);
  1186.         return; }
  1187.     alter_config(addr,cfg.nodecfg[node].password,temp,1);
  1188.     sprintf(str,"Your password has been changed from %s to %.25s."
  1189.         ,cfg.nodecfg[node].password,temp);
  1190.     sprintf(cfg.nodecfg[node].password,"%.25s",temp);
  1191.     create_netmail(0,"Password Change Request",str,addr,0);
  1192.     return; }
  1193.  
  1194. if((p=strstr(instr,"RESCAN"))!=NULL) {
  1195.     export_echomail("",addr);
  1196.     create_netmail(0,"Rescan Areas"
  1197.         ,"All connected areas carried by your hub have been rescanned."
  1198.         ,addr,0);
  1199.     return; }
  1200.  
  1201. if((p=strstr(instr,"ACTIVE"))!=NULL) {
  1202.     if(!(cfg.nodecfg[node].attr&ATTR_PASSIVE)) {
  1203.         create_netmail(0,"Reconnect Disconnected Areas"
  1204.             ,"Your areas are already connected.",addr,0);
  1205.         return; }
  1206.     alter_config(addr,0,0,3);
  1207.     create_netmail(0,"Reconnect Disconnected Areas"
  1208.         ,"Temporarily disconnected areas have been reconnected.",addr,0);
  1209.     return; }
  1210.  
  1211. if((p=strstr(instr,"PASSIVE"))!=NULL) {
  1212.     if(cfg.nodecfg[node].attr&ATTR_PASSIVE) {
  1213.         create_netmail(0,"Temporarily Disconnect Areas"
  1214.             ,"Your areas are already temporarily disconnected.",addr,0);
  1215.         return; }
  1216.     alter_config(addr,0,0,2);
  1217.     create_netmail(0,"Temporarily Disconnect Areas"
  1218.         ,"Your areas have been temporarily disconnected.",addr,0);
  1219.     return; }
  1220.  
  1221. if((p=strstr(instr,"FROM"))!=NULL);
  1222.  
  1223. if((p=strstr(instr,"+ALL"))!=NULL) {
  1224.     if((add_area.tag=(char **)REALLOC(add_area.tag
  1225.         ,sizeof(char *)*add_area.tags+1))==NULL) {
  1226.         printf("ERROR allocating memory for add area tag #%u.\n"
  1227.             ,add_area.tags+1);
  1228.         logprintf("ERROR line %d allocating memory for add area tag #%u"
  1229.             ,__LINE__,add_area.tags+1);
  1230.         exit(1); }
  1231.     if((add_area.tag[add_area.tags]=(char *)LMALLOC(strlen(instr)+1))==NULL) {
  1232.         printf("ERROR allocating memory for add area tag #%u.\n"
  1233.             ,add_area.tags+1);
  1234.         logprintf("ERROR line %d allocating memory for add area tag #%u"
  1235.             ,__LINE__,add_area.tags+1);
  1236.         exit(1); }
  1237.     strcpy(add_area.tag[add_area.tags],instr);
  1238.     add_area.tags++;
  1239.     alter_areas(add_area,del_area,addr);
  1240.     for(i=0;i<add_area.tags;i++)
  1241.         LFREE(add_area.tag[i]);
  1242.     FREE(add_area.tag);
  1243.     return; }
  1244.  
  1245. if((p=strstr(instr,"-ALL"))!=NULL) {
  1246.     if((del_area.tag=(char **)REALLOC(del_area.tag
  1247.         ,sizeof(char *)*del_area.tags+1))==NULL) {
  1248.         printf("ERROR allocating memory for del area tag #%u.\n"
  1249.             ,del_area.tags+1);
  1250.         logprintf("ERROR line %d allocating memory for del area tag #%u"
  1251.             ,__LINE__,del_area.tags+1);
  1252.         exit(1); }
  1253.     if((del_area.tag[del_area.tags]=(char *)LMALLOC(strlen(instr)+1))==NULL) {
  1254.         printf("ERROR allocating memory for del area tag #%u.\n"
  1255.             ,del_area.tags+1);
  1256.         logprintf("ERROR line %d allocating memory for del area tag #%u"
  1257.             ,__LINE__,del_area.tags+1);
  1258.         exit(1); }
  1259.     strcpy(del_area.tag[del_area.tags],instr);
  1260.     del_area.tags++;
  1261.     alter_areas(add_area,del_area,addr);
  1262.     for(i=0;i<del_area.tags;i++)
  1263.         LFREE(del_area.tag[i]);
  1264.     FREE(del_area.tag);
  1265.     return; }
  1266. }
  1267. /******************************************************************************
  1268.  This is where we're gonna process any netmail that comes in for areafix.
  1269.  Returns text for message body for the local sysop if necessary.
  1270. ******************************************************************************/
  1271. char *process_areafix(faddr_t addr,char HUGE16 *inbuf,char *password)
  1272. {
  1273.     static char body[512],str[81];
  1274.     char *p,*tp,action,percent=0;
  1275.     int i;
  1276.     ulong l,m;
  1277.     area_t add_area,del_area;
  1278.  
  1279. p=(char *)inbuf;
  1280.  
  1281. while(*p==1) {                /* Skip kludge lines 11/05/95 */
  1282.     while(*p && *p!=CR)
  1283.         p++;                /* Skip meat */
  1284.     if(*p)
  1285.         p++; }                /* Skip CR */
  1286.  
  1287. #if 0 // Removed 11/05/95
  1288. while(*p && (tp=strchr(p,'\1'))!=NULL) {    /* Remove ^A kludge lines */
  1289.     p=tp;
  1290.     while(*p && *p!=CR) p++; }
  1291. if(*p==CR)
  1292.     p++;
  1293. #endif
  1294.  
  1295. if(((tp=strstr(p,"---\r"))!=NULL || (tp=strstr(p,"--- "))!=NULL) &&
  1296.     (*(tp-1)==10 || *(tp-1)==13))
  1297.     *tp=0;
  1298.  
  1299. if(!strnicmp(p,"%FROM",5)) {    /* Remote Remote Maintenance (must be first) */
  1300.     sprintf(str,"%.80s",p+6);
  1301.     if((tp=strchr(str,CR))!=NULL)
  1302.         *tp=0;
  1303.     logprintf("Remote maintenance for %s requested via %s",str,faddrtoa(addr));
  1304.     addr=atofaddr(str); }
  1305.  
  1306. i=matchnode(addr,0);
  1307. if(i==cfg.nodecfgs) {
  1308.     sprintf(body,"Your node is not configured for Areafix, please "
  1309.         "contact your hub.\r\n");
  1310.     create_netmail(0,"Areafix Request",body,addr,0);
  1311.     sprintf(body,"An areafix request was made by node %s.\r\nThis node "
  1312.         "is not currently configured for areafix.\r\n",faddrtoa(addr));
  1313.     return(body); }
  1314.  
  1315. if(stricmp(cfg.nodecfg[i].password,password)) {
  1316.     create_netmail(0,"Areafix Request","Invalid Password.",addr,0);
  1317.     sprintf(body,"Node %s attempted an areafix request using an invalid "
  1318.         "password.\r\nThe password attempted was %s.\r\nThe correct password "
  1319.         "for this node is %s.\r\n",faddrtoa(addr),password
  1320.         ,(cfg.nodecfg[i].password[0]) ? cfg.nodecfg[i].password
  1321.          : "[None Defined]");
  1322.     return(body); }
  1323.  
  1324. m=strlen(p);
  1325. add_area.tags=0;
  1326. add_area.tag=NULL;
  1327. del_area.tags=0;
  1328. del_area.tag=NULL;
  1329. for(l=0;l<m;l++) {
  1330.     while(*(p+l) && *(p+l)<=SP) l++;
  1331.     if(!(*(p+l))) break;
  1332.     if(*(p+l)=='+' || *(p+l)=='-' || *(p+l)=='%') {
  1333.         action=*(p+l);
  1334.         l++; }
  1335.     else
  1336.         action='+';
  1337.     sprintf(str,"%.80s",p+l);
  1338.     if((tp=strchr(str,CR))!=NULL)
  1339.         *tp=0;
  1340.     switch(action) {
  1341.         case '+':                       /* Add Area */
  1342.             if((add_area.tag=(char **)REALLOC(add_area.tag
  1343.                 ,sizeof(char *)*add_area.tags+1))==NULL) {
  1344.                 printf("ERROR allocating memory for add area tag #%u.\n"
  1345.                     ,add_area.tags+1);
  1346.                 logprintf("ERROR line %d allocating memory for add area "
  1347.                     "tag #%u",__LINE__,add_area.tags+1);
  1348.                 exit(1); }
  1349.             if((add_area.tag[add_area.tags]=(char *)LMALLOC(strlen(str)+1))
  1350.                 ==NULL) {
  1351.                 printf("ERROR allocating memory for add area tag #%u.\n"
  1352.                     ,add_area.tags+1);
  1353.                 logprintf("ERROR line %d allocating memory for add area "
  1354.                     "tag #%u",__LINE__,add_area.tags+1);
  1355.                 exit(1); }
  1356.             strcpy(add_area.tag[add_area.tags],str);
  1357.             add_area.tags++;
  1358.             break;
  1359.         case '-':                       /* Remove Area */
  1360.             if((del_area.tag=(char **)REALLOC(del_area.tag
  1361.                 ,sizeof(char *)*del_area.tags+1))==NULL) {
  1362.                 printf("ERROR allocating memory for del area tag #%u.\n"
  1363.                     ,del_area.tags+1);
  1364.                 logprintf("ERROR line %d allocating memory for del area "
  1365.                     "tag #%u",__LINE__,del_area.tags+1);
  1366.                 exit(1); }
  1367.             if((del_area.tag[del_area.tags]=(char *)LMALLOC(strlen(str)+1))
  1368.                 ==NULL) {
  1369.                 printf("ERROR allocating memory for del area tag #%u.\n"
  1370.                     ,del_area.tags+1);
  1371.                 logprintf("ERROR line %d allocating memory for del area "
  1372.                     "tag #%u",__LINE__,del_area.tags+1);
  1373.                 exit(1); }
  1374.             strcpy(del_area.tag[del_area.tags],str);
  1375.             del_area.tags++;
  1376.             break;
  1377.         case '%':                       /* Process Command */
  1378.             command(str,addr);
  1379.             percent++;
  1380.             break; }
  1381.  
  1382.     while(*(p+l) && *(p+l)!=CR) l++; }
  1383.  
  1384. if(!percent && !add_area.tags && !del_area.tags) {
  1385.     create_netmail(0,"Areafix Request","No commands to process.",addr,0);
  1386.     sprintf(body,"Node %s attempted an areafix request with an empty message "
  1387.         "body or with no valid commands.\r\n",faddrtoa(addr));
  1388.     return(body); }
  1389. if(add_area.tags || del_area.tags)
  1390.     alter_areas(add_area,del_area,addr);
  1391. if(add_area.tags) {
  1392.     for(i=0;i<add_area.tags;i++)
  1393.         LFREE(add_area.tag[i]);
  1394.     FREE(add_area.tag); }
  1395. if(del_area.tags) {
  1396.     for(i=0;i<del_area.tags;i++)
  1397.         LFREE(del_area.tag[i]);
  1398.     FREE(del_area.tag); }
  1399. return(0);
  1400. }
  1401. /******************************************************************************
  1402.  This function will compare the archive signatures defined in the CFG file and
  1403.  extract 'infile' using the appropriate de-archiver.
  1404. ******************************************************************************/
  1405. int unpack(char *infile)
  1406. {
  1407.     FILE *stream;
  1408.     char str[256],tmp[3];
  1409.     int i,j,k,ch,file;
  1410.  
  1411. if((stream=fnopen(&file,infile,O_RDONLY))==NULL) {
  1412.     printf("\7ERROR couldn't open %s.\n",infile);
  1413.     logprintf("ERROR line %d opening %s %s",__LINE__,infile
  1414.         ,sys_errlist[errno]);
  1415.     exit(1); }
  1416. for(i=0;i<cfg.arcdefs;i++) {
  1417.     str[0]=0;
  1418.     fseek(stream,cfg.arcdef[i].byteloc,SEEK_SET);
  1419.     for(j=0;j<strlen(cfg.arcdef[i].hexid)/2;j++) {
  1420.         ch=fgetc(stream);
  1421.         if(ch==EOF) {
  1422.             i=cfg.arcdefs;
  1423.             break; }
  1424.         sprintf(tmp,"%02X",ch);
  1425.         strcat(str,tmp); }
  1426.     if(!stricmp(str,cfg.arcdef[i].hexid))
  1427.         break; }
  1428. fclose(stream);
  1429.  
  1430. if(i==cfg.arcdefs) {
  1431.     printf("\7ERROR couldn't determine filetype of %s.\n",infile);
  1432.     logprintf("ERROR line %d determining filetype of %s",__LINE__,infile);
  1433.     return(1); }
  1434.  
  1435. j=execute(cmdstr(cfg.arcdef[i].unpack,infile
  1436.     ,secure ? cfg.secure : cfg.inbound));
  1437. if(j) {
  1438.     printf("\7ERROR %d (%d) executing %s\n"
  1439.         ,j,errno,cmdstr(cfg.arcdef[i].unpack,infile
  1440.             ,secure ? cfg.secure : cfg.inbound));
  1441.     logprintf("ERROR %d (%d) line %d executing %s"
  1442.         ,j,errno,__LINE__,cmdstr(cfg.arcdef[i].unpack,infile
  1443.             ,secure ? cfg.secure : cfg.inbound));
  1444.     return(j); }
  1445. return(0);
  1446. }
  1447. /******************************************************************************
  1448.  This function will check the 'dest' for the type of archiver to use (as
  1449.  defined in the CFG file) and compress 'srcfile' into 'destfile' using the
  1450.  appropriate archive program.
  1451. ******************************************************************************/
  1452. void pack(char *srcfile,char *destfile,faddr_t dest)
  1453. {
  1454.     int i,j;
  1455.     uint use=0;
  1456.  
  1457. i=matchnode(dest,0);
  1458. if(i<cfg.nodecfgs)
  1459.     use=cfg.nodecfg[i].arctype;
  1460.  
  1461. j=execute(cmdstr(cfg.arcdef[use].pack,destfile,srcfile));
  1462. if(j) {
  1463.     printf("\7ERROR %d (%d) executing %s\n"
  1464.         ,j,errno,cmdstr(cfg.arcdef[use].pack,destfile,srcfile));
  1465.     logprintf("ERROR %d (%d) line %d executing %s"
  1466.         ,j,errno,__LINE__,cmdstr(cfg.arcdef[use].pack,destfile,srcfile)); }
  1467. }
  1468.  
  1469. char attachment(char *bundlename,faddr_t dest,char cleanup)
  1470. {
  1471.     FILE *fidomsg,*stream;
  1472.     char str[1025],path[512],fname[129],*p;
  1473.     int last,fmsg,file,error=0L;
  1474.     long fncrc,*mfncrc=0L,num_mfncrc=0L;
  1475.     struct find_t ff;
  1476.     attach_t attach;
  1477.     fmsghdr_t hdr;
  1478.  
  1479. sprintf(fname,"%sBUNDLES.SBE",cfg.outbound);
  1480. if((stream=fnopen(&file,fname,O_RDWR|O_CREAT))==NULL) {
  1481.     printf("\7ERROR opening %s %s\n",fname,sys_errlist[errno]);
  1482.     logprintf("ERROR line %d opening %s %s",__LINE__,fname,sys_errlist[errno]);
  1483.     return(1); }
  1484.  
  1485. if(cleanup==2) {                /* Check for existance in BUNDLES.SBE */
  1486.     while(!feof(stream)) {
  1487.         if(!fread(&attach,1,sizeof(attach_t),stream))
  1488.             break;
  1489.         if(!stricmp(attach.fname,bundlename)) {
  1490.             fclose(stream);
  1491.             return(1); } }
  1492.     fclose(stream);
  1493.     return(0); }
  1494.  
  1495. if(cleanup==1) {                /* Create netmail attaches */
  1496.  
  1497. if(!filelength(file)) {
  1498.     fclose(stream);
  1499.     return(0); }
  1500.                                 /* Get attach names from existing MSGs */
  1501. sprintf(str,"%s*.MSG",netmail_dir);
  1502. for(last=_dos_findfirst(str,0,&ff);!last;last=_dos_findnext(&ff)) {
  1503.     sprintf(path,"%s%s",netmail_dir,ff.name);
  1504.     strupr(path);
  1505.     if((fidomsg=fnopen(&fmsg,path,O_RDWR))==NULL) {
  1506.         printf("\7ERROR opening %s\n",path);
  1507.         logprintf("ERROR line %d opening %s %s",__LINE__,path
  1508.             ,sys_errlist[errno]);
  1509.         continue; }
  1510.     if(filelength(fmsg)<sizeof(fmsghdr_t)) {
  1511.         printf("\7ERROR %s has invalid length of %u bytes\n",path
  1512.             ,filelength(fmsg));
  1513.         logprintf("ERROR line %d %s has invalid length of %u bytes"
  1514.             ,__LINE__,path,filelength(fmsg));
  1515.         fclose(fidomsg);
  1516.         continue; }
  1517.     if(fread(&hdr,sizeof(fmsghdr_t),1,fidomsg)!=1) {
  1518.         fclose(fidomsg);
  1519.         printf("\7ERROR reading %u bytes from %s"
  1520.             ,sizeof(fmsghdr_t),path);
  1521.         logprintf("ERROR line %d reading %u bytes from %s"
  1522.             ,__LINE__,sizeof(fmsghdr_t),path);
  1523.         continue; }
  1524.     fclose(fidomsg);
  1525.     if(!(hdr.attr&FIDO_FILE))        /* Not a file attach */
  1526.         continue;
  1527.     num_mfncrc++;
  1528.     if((p=strrchr(hdr.subj,'\\'))!=NULL)
  1529.         p++;
  1530.     else
  1531.         p=hdr.subj;
  1532.     if((mfncrc=(long *)REALLOC(mfncrc,num_mfncrc*sizeof(long)))==NULL) {
  1533.         printf("ERROR allocating %lu bytes for bundle name crc.\n"
  1534.             ,num_mfncrc*sizeof(long));
  1535.         logprintf("ERROR line %d allocating %lu for bundle name crc"
  1536.             ,__LINE__,num_mfncrc*sizeof(long));
  1537.         continue; }
  1538.     mfncrc[num_mfncrc-1]=crc32(strupr(p)); }
  1539.  
  1540.     while(!feof(stream)) {
  1541.         if(!fread(&attach,1,sizeof(attach_t),stream))
  1542.             break;
  1543.         sprintf(str,"%s%s",cfg.outbound,attach.fname);
  1544.         if(!fexist(str))
  1545.             continue;
  1546.         fncrc=crc32(strupr(attach.fname));
  1547.         for(last=0;last<num_mfncrc;last++)
  1548.             if(mfncrc[last]==fncrc)
  1549.                 break;
  1550.         if(last==num_mfncrc)
  1551.             if(create_netmail(0,str,"\1FLAGS KFS\r",attach.dest,1))
  1552.                 error=1; }
  1553.     if(!error)                /* don't truncate if an error occured */
  1554.         chsize(file,0L);
  1555.     fclose(stream);
  1556.     if(num_mfncrc)
  1557.         FREE(mfncrc);
  1558. #ifdef __WATCOMC__
  1559.    _dos_findclose(&ff);
  1560. #endif
  1561.     return(0); }
  1562.  
  1563. while(!feof(stream)) {
  1564.     if(!fread(&attach,1,sizeof(attach_t),stream))
  1565.         break;
  1566.     if(!stricmp(attach.fname,bundlename)) {
  1567.         fclose(stream);
  1568.         return(0); } }
  1569.  
  1570. memcpy(&attach.dest,&dest,sizeof(faddr_t));
  1571. strcpy(attach.fname,bundlename);
  1572. fwrite(&attach,sizeof(attach_t),1,stream);
  1573. fclose(stream);
  1574. return(0);
  1575. }
  1576.  
  1577. /******************************************************************************
  1578.  This function is called when a message packet has reached it's maximum size.
  1579.  It places packets into a bundle until that bundle is full, at which time the
  1580.  last character of the extension increments (1 thru 0 and then A thru Z).  If
  1581.  all bundles have reached their maximum size remaining packets are placed into
  1582.  the Z bundle.
  1583. ******************************************************************************/
  1584. void pack_bundle(char *infile,faddr_t dest)
  1585. {
  1586.     char str[256],fname[256],outbound[128],day[3],ch,*p;
  1587.     int i,j,file,node;
  1588.     time_t now;
  1589.  
  1590. node=matchnode(dest,0);
  1591. strcpy(str,infile);
  1592. str[strlen(str)-1]='T';
  1593. if(rename(infile,str))                   /* Change .PK_ file to .PKT file */
  1594.     logprintf("ERROR line %d renaming %s to %s",__LINE__,infile,str);
  1595. infile[strlen(infile)-1]='T';
  1596. time(&now);
  1597. sprintf(day,"%-.2s",ctime(&now));
  1598. strupr(day);
  1599. if(misc&FLO_MAILER) {
  1600.     if(node<cfg.nodecfgs && cfg.nodecfg[node].route.zone)
  1601.         dest=cfg.nodecfg[node].route;
  1602.     if(dest.zone==faddr[0].zone)    /* Default zone, use default outbound */
  1603.         strcpy(outbound,cfg.outbound);
  1604.     else                            /* Inter-zone outbound is OUTBOUND.XXX */
  1605.         sprintf(outbound,"%.*s.%03X\\"
  1606.             ,strlen(cfg.outbound)-1,cfg.outbound,dest.zone);
  1607.     if(dest.point) {                /* Point destination is OUTBOUND\*.PNT */
  1608.         sprintf(str,"%04X%04X.PNT"
  1609.             ,dest.net,dest.node);
  1610.         strcat(outbound,str); }
  1611.     }
  1612. else
  1613.     strcpy(outbound,cfg.outbound);
  1614. if(outbound[strlen(outbound)-1]=='\\')
  1615.     outbound[strlen(outbound)-1]=0;
  1616. mkdir(outbound);
  1617. strcat(outbound,"\\");
  1618.  
  1619. if(node<cfg.nodecfgs)
  1620.     if(cfg.nodecfg[node].arctype==0xffff) {    /* Uncompressed! */
  1621.         if(misc&FLO_MAILER)
  1622.             i=write_flofile(infile,dest);
  1623.         else
  1624.             i=create_netmail(0,infile,"\1FLAGS KFS\r",dest,1);
  1625.         if(i) exit(1);
  1626.         return; }
  1627.  
  1628. sprintf(fname,"%s%04hX%04hX.%s",outbound,(short)(faddr[0].net-dest.net)
  1629.     ,(short)(faddr[0].node-dest.node),day);
  1630. if(dest.point && !(misc&FLO_MAILER))
  1631.     sprintf(fname,"%s%04hXP%03hX.%s",outbound,0,(short)dest.point,day);
  1632. for(i='0';i<='Z';i++) {
  1633.     if(i==':')
  1634.         i='A';
  1635.     sprintf(str,"%s%c",fname,i);
  1636.     if(flength(str)==0)
  1637.         if(delfile(str))
  1638.             logprintf("ERROR line %d removing %s %s",__LINE__,str
  1639.                 ,sys_errlist[errno]);
  1640.     if(fexist(str)) {
  1641.         if((p=strrchr(str,'\\'))!=NULL)
  1642.             p++;
  1643.         else
  1644.             p=str;
  1645.         if(flength(str)>=cfg.maxbdlsize)
  1646.             continue;
  1647.         file=sopen(str,O_WRONLY,SH_DENYRW);
  1648.         if(file==-1)        /* Can't open?!? Probably being sent */
  1649.             continue;
  1650.         close(file);
  1651.         if(!attachment(p,dest,2))
  1652.             attachment(p,dest,0);
  1653.         pack(infile,str,dest);
  1654.         if(delfile(infile))
  1655.             logprintf("ERROR line %d removing %s %s",__LINE__,infile
  1656.                 ,sys_errlist[errno]);
  1657.         return; }
  1658.     else {
  1659.         if(misc&FLO_MAILER)
  1660.             j=write_flofile(str,dest);
  1661.         else {
  1662.             if((p=strrchr(str,'\\'))!=NULL)
  1663.                 p++;
  1664.             else
  1665.                 p=str;
  1666.             j=attachment(p,dest,0); }
  1667.         if(j)
  1668.             exit(1);
  1669.         pack(infile,str,dest);
  1670.         if(delfile(infile))
  1671.             logprintf("ERROR line %d removing %s %s",__LINE__,infile
  1672.                 ,sys_errlist[errno]);
  1673.         return; } }
  1674.  
  1675. pack(infile,str,dest);    /* Won't get here unless all bundles are full */
  1676. }
  1677.  
  1678. /******************************************************************************
  1679.  This function checks the inbound directory for the first bundle it finds, it
  1680.  will then unpack and delete the bundle.  If no bundles exist this function
  1681.  returns a 0, otherwise a 1 is returned.
  1682. ******************************************************************************/
  1683. int unpack_bundle(void)
  1684. {
  1685.     char str[256];
  1686.     static char fname[256];
  1687.     int i,j;
  1688.     static struct find_t ff;
  1689.  
  1690. for(i=0;i<7;i++) {
  1691.     sprintf(str,"%s*.%s?",secure ? cfg.secure : cfg.inbound
  1692.         ,(i==0) ? "SU" : (i==1) ? "MO" : (i==2) ? "TU" : (i==3) ? "WE" : (i==4)
  1693.         ? "TH" : (i==5) ? "FR" : "SA");
  1694.     if(!ff.name[0])
  1695.         j=_dos_findfirst(str,0,&ff);
  1696.     else {
  1697.         j=_dos_findnext(&ff);
  1698.         if(j) {
  1699. #ifdef __WATCOMC__
  1700.             _dos_findclose(&ff);
  1701. #endif
  1702.             j=_dos_findfirst(str,0,&ff); } }
  1703.     if(!j) {
  1704.         sprintf(fname,"%s%s",secure ? cfg.secure : cfg.inbound,ff.name);
  1705.         if(unpack(fname)) {
  1706.             if((ddtol(ff.wr_time,ff.wr_date)+(48L*60L*60L))>time(NULL)) {
  1707.                 strcpy(str,fname);
  1708.                 str[strlen(str)-2]='_';
  1709.                 if(fexist(str))
  1710.                     str[strlen(str)-2]='-';
  1711.                 if(fexist(str))
  1712.                     delfile(str);
  1713.                 if(rename(fname,str))
  1714.                     logprintf("ERROR line %d renaming %s to %s"
  1715.                         ,__LINE__,fname,str); } }
  1716.         else if(delfile(fname))
  1717.             logprintf("ERROR line %d removing %s %s",__LINE__,fname
  1718.                 ,sys_errlist[errno]);
  1719.         return(1); } }
  1720.  
  1721. #ifdef __WATCOMC__
  1722. _dos_findclose(&ff);
  1723. #endif
  1724. return(0);
  1725. }
  1726.  
  1727.  
  1728. /******************************************************************************
  1729.  Displays characters locally
  1730. ******************************************************************************/
  1731. long lputs(char *str)
  1732. {
  1733.     char tmp[256];
  1734.     int i,j,k;
  1735.  
  1736.  
  1737. j=strlen(str);
  1738. for(i=k=0;i<j;i++)      /* remove CRs */
  1739.     if(str[i]==CR && str[i+1]==LF)
  1740.         continue;
  1741.     else
  1742.         tmp[k++]=str[i];
  1743. tmp[k]=0;
  1744. return(fputs(tmp,stdout));
  1745. }
  1746.  
  1747. /******************************************/
  1748. /* CRC-16 routines required for SMB index */
  1749. /******************************************/
  1750.  
  1751. /***********************************************)**********************)*****/
  1752. /* Updates 16-bit "rcrc" with character 'ch'                                */
  1753. /****************************************************************************/
  1754. void ucrc16(uchar ch, ushort *rcrc) {
  1755.     ushort i, cy;
  1756.     uchar nch=ch;
  1757.  
  1758. for (i=0; i<8; i++) {
  1759.     cy=*rcrc & 0x8000;
  1760.     *rcrc<<=1;
  1761.     if (nch & 0x80) *rcrc |= 1;
  1762.     nch<<=1;
  1763.     if (cy) *rcrc ^= 0x1021; }
  1764. }
  1765.  
  1766. /****************************************************************************/
  1767. /* Returns 16-crc of string (not counting terminating NULL)                 */
  1768. /****************************************************************************/
  1769. ushort crc16(char *str)
  1770. {
  1771.     int     i=0;
  1772.     ushort    crc=0;
  1773.  
  1774. ucrc16(0,&crc);
  1775. while(str[i])
  1776.     ucrc16(str[i++],&crc);
  1777. ucrc16(0,&crc);
  1778. ucrc16(0,&crc);
  1779. return(crc);
  1780. }
  1781.  
  1782. /****************************************************************************/
  1783. /* Performs printf() through local assembly routines                        */
  1784. /* Called from everywhere                                                   */
  1785. /****************************************************************************/
  1786. int lprintf(char *fmat, ...)
  1787. {
  1788.     va_list argptr;
  1789.     char sbuf[256];
  1790.     int chcount;
  1791.  
  1792. va_start(argptr,fmat);
  1793. chcount=vsprintf(sbuf,fmat,argptr);
  1794. va_end(argptr);
  1795. lputs(sbuf);
  1796. return(chcount);
  1797. }
  1798.  
  1799. /****************************************************************************/
  1800. /* Reads the data for node number 'number' into the structure 'node'        */
  1801. /* from NODE.DAB                                                            */
  1802. /* if lockit is non-zero, locks this node's record. putnodedat() unlocks it */
  1803. /****************************************************************************/
  1804. void getnodedat(uint number, node_t *node, char lockit)
  1805. {
  1806.     char str[256];
  1807.     int count=0;
  1808.  
  1809. number--;    /* make zero based */
  1810. while(count<LOOP_NODEDAB) {
  1811.     lseek(nodefile,(long)number*sizeof(node_t),SEEK_SET);
  1812.     if(lockit
  1813.         && lock(nodefile,(long)number*sizeof(node_t),sizeof(node_t))==-1) {
  1814.         count++;
  1815.         continue; }
  1816.     if(read(nodefile,node,sizeof(node_t))==sizeof(node_t))
  1817.         break;
  1818.     count++; }
  1819. if(count==LOOP_NODEDAB) {
  1820.     printf("\7ERROR unlocking and reading NODE.DAB\n");
  1821.     logprintf("ERROR line %d unlocking and reading NODE.DAB",__LINE__); }
  1822. }
  1823.  
  1824. /****************************************************************************/
  1825. /* Write the data from the structure 'node' into NODE.DAB                      */
  1826. /* getnodedat(num,&node,1); must have been called before calling this func  */
  1827. /*          NOTE: ------^   the indicates the node record has been locked   */
  1828. /****************************************************************************/
  1829. void putnodedat(uint number, node_t node)
  1830. {
  1831.     char str[256];
  1832.     int count;
  1833.  
  1834. number--;    /* make zero based */
  1835. lseek(nodefile,(long)number*sizeof(node_t),SEEK_SET);
  1836. if(write(nodefile,&node,sizeof(node_t))!=sizeof(node_t)) {
  1837.     unlock(nodefile,(long)number*sizeof(node_t),sizeof(node_t));
  1838.     printf("\7ERROR writing NODE.DAB for node %u\n",number+1);
  1839.     logprintf("ERROR line %d writing NODE.DAB for node %u",__LINE__,number+1);
  1840.     return; }
  1841. unlock(nodefile,(long)number*sizeof(node_t),sizeof(node_t));
  1842. }
  1843.  
  1844. /****************************************************************************/
  1845. /* Creates a short message for 'usernumber' than contains 'strin'            */
  1846. /****************************************************************************/
  1847. void putsmsg(int usernumber, char *strin)
  1848. {
  1849.     char str[256];
  1850.     int file,i;
  1851.     node_t node;
  1852.  
  1853. sprintf(str,"%sMSGS\\%4.4u.MSG",data_dir,usernumber);
  1854. if((file=nopen(str,O_WRONLY|O_CREAT|O_APPEND))==-1) {
  1855.     printf("\7ERROR opening/creating %s for create/append access\n",str);
  1856.     logprintf("ERROR line %d opening/creating %s",__LINE__,str);
  1857.     return; }
  1858. i=strlen(strin);
  1859. if(write(file,strin,i)!=i) {
  1860.     close(file);
  1861.     printf("\7ERROR writing %u bytes to %s\n",i,str);
  1862.     logprintf("ERROR line %d writing to %s",__LINE__,str);
  1863.     return; }
  1864. close(file);
  1865. for(i=1;i<=sys_nodes;i++) {        /* flag node if user on that msg waiting */
  1866.     getnodedat(i,&node,0);
  1867.     if(node.useron==usernumber
  1868.         && (node.status==NODE_INUSE || node.status==NODE_QUIET)
  1869.         && !(node.misc&NODE_MSGW)) {
  1870.         getnodedat(i,&node,1);
  1871.         node.misc|=NODE_MSGW;
  1872.         putnodedat(i,node); } }
  1873. }
  1874.  
  1875. /****************************************************************************/
  1876. /* Converts an ASCII Hex string into an ulong                       */
  1877. /****************************************************************************/
  1878. ulong ahtoul(char *str)
  1879. {
  1880.     ulong l,val=0;
  1881.  
  1882. while((l=(*str++)|0x20)!=0x20)
  1883.     val=(l&0xf)+(l>>6&1)*9+val*16;
  1884. return(val);
  1885. }
  1886.  
  1887. /****************************************************************************/
  1888. /* Truncates white-space chars off end of 'str' and terminates at first tab */
  1889. /****************************************************************************/
  1890. void truncsp(char *str)
  1891. {
  1892.     int c;
  1893.  
  1894. c=strlen(str);
  1895. while(c && (uchar)str[c-1]<=SP) c--;
  1896. str[c]=0;
  1897. }
  1898.  
  1899.  
  1900. void remove_re(char *str)
  1901. {
  1902. while(!strnicmp(str,"RE:",3)) {
  1903.     strcpy(str,str+3);
  1904.     while(str[0]==SP)
  1905.         strcpy(str,str+1); }
  1906. }
  1907.  
  1908. /****************************************************************************/
  1909. /* Moves or copies a file from one dir to another                           */
  1910. /* both 'src' and 'dest' must contain full path and filename                */
  1911. /* returns 0 if successful, -1 if error                                     */
  1912. /****************************************************************************/
  1913. int mv(char *src, char *dest, char copy)
  1914. {
  1915.     char buf[4096],str[256];
  1916.     int  ind,outd;
  1917.     long length,chunk=4096,l;
  1918. #ifdef __WATCOMC__
  1919.     unsigned short ftime,fdate;
  1920. #else
  1921.     unsigned ftime,fdate;
  1922. #endif
  1923.     FILE *inp,*outp;
  1924.  
  1925. if(!strcmp(src,dest))    /* source and destination are the same! */
  1926.     return(0);
  1927. if(!fexist(src)) {
  1928.     logprintf("MV ERROR: Source doesn't exist '%s",src);
  1929.     return(-1); }
  1930. if(!copy && fexist(dest)) {
  1931.     logprintf("MV ERROR: Destination already exists '%s'",dest);
  1932.     return(-1); }
  1933. if(!copy && ((src[1]!=':' && dest[1]!=':')
  1934.     || (src[1]==':' && dest[1]==':' && toupper(src[0])==toupper(dest[0])))) {
  1935.     if(rename(src,dest)) {                        /* same drive, so move */
  1936.         logprintf("MV ERROR: Error renaming %s to %s",src,dest);
  1937.         return(-1); }
  1938.     return(0); }
  1939. if((ind=nopen(src,O_RDONLY))==-1) {
  1940.     logprintf("MV ERROR: ERR_OPEN %s",src);
  1941.     return(-1); }
  1942. if((inp=fdopen(ind,"rb"))==NULL) {
  1943.     close(ind);
  1944.     logprintf("MV ERROR: ERR_FDOPEN %s",str);
  1945.     return(-1); }
  1946. setvbuf(inp,NULL,_IOFBF,8*1024);
  1947. if((outd=nopen(dest,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
  1948.     fclose(inp);
  1949.     logprintf("MV ERROR: ERR_OPEN %s",dest);
  1950.     return(-1); }
  1951. if((outp=fdopen(outd,"wb"))==NULL) {
  1952.     close(outd);
  1953.     fclose(inp);
  1954.     logprintf("MV ERROR: ERR_FDOPEN %s",str);
  1955.     return(-1); }
  1956. setvbuf(outp,NULL,_IOFBF,8*1024);
  1957. length=filelength(ind);
  1958. l=0L;
  1959. while(l<length) {
  1960.     if(l+chunk>length)
  1961.         chunk=length-l;
  1962.     fread(buf,chunk,1,inp);
  1963.     fwrite(buf,chunk,1,outp);
  1964.     l+=chunk; }
  1965. _dos_getftime(ind,&fdate,&ftime);
  1966. _dos_setftime(outd,fdate,ftime);
  1967. fclose(inp);
  1968. fclose(outp);
  1969. if(!copy && delfile(src)) {
  1970.     logprintf("ERROR line %d removing %s %s",__LINE__,src,sys_errlist[errno]);
  1971.     return(-1); }
  1972. return(0);
  1973. }
  1974.  
  1975. /****************************************************************************/
  1976. /* Returns the total number of msgs in the sub-board and sets 'ptr' to the  */
  1977. /* date of the last message in the sub (0) if no messages.                    */
  1978. /****************************************************************************/
  1979. ulong getlastmsg(uint subnum, ulong *ptr, time_t *t)
  1980. {
  1981.     char str[256];
  1982.     int i;
  1983.     smb_t smbfile;
  1984.  
  1985. if(subnum>=total_subs) {
  1986.     printf("\nERROR getlastmsg, subnum=%d\n",subnum);
  1987.     logprintf("ERROR line %d getlastmsg %d",__LINE__,subnum);
  1988.     exit(1); }
  1989. sprintf(smbfile.file,"%s%s",sub[subnum]->data_dir,sub[subnum]->code);
  1990. smbfile.retry_time=smb_retry_time;
  1991. if((i=smb_open(&smbfile))!=0) {
  1992.     printf("ERROR %d opening %s\n",i,smbfile.file);
  1993.     logprintf("ERROR %d line %d opening %s",i,__LINE__,smbfile.file);
  1994.     return(0); }
  1995.  
  1996. if(!filelength(fileno(smbfile.shd_fp))) {            /* Empty base */
  1997.     if(ptr) (*ptr)=0;
  1998.     smb_close(&smbfile);
  1999.     return(0); }
  2000. #if 0    // Not necessary with SMBLIB v2.0
  2001. if((i=smb_locksmbhdr(&smbfile))!=0) {
  2002.     smb_close(&smbfile);
  2003.     printf("ERROR %d locking %s\n",i,smbfile.file);
  2004.     logprintf("ERROR %d line %d locking %s smbhdr",i,__LINE__
  2005.         ,smbfile.file);
  2006.     return(0); }
  2007. if((i=smb_getstatus(&smbfile))!=0) {
  2008.     smb_unlocksmbhdr(&smbfile);
  2009.     smb_close(&smbfile);
  2010.     printf("ERROR %d reading %s\n",i,smbfile.file);
  2011.     logprintf("ERROR %d line %d reading %s",i,__LINE__,smbfile.file);
  2012.     return(0); }
  2013. smb_unlocksmbhdr(&smbfile);
  2014. #endif
  2015. smb_close(&smbfile);
  2016. if(ptr) (*ptr)=smbfile.status.last_msg;
  2017. return(smbfile.status.total_msgs);
  2018. }
  2019.  
  2020.  
  2021. ulong loadmsgs(post_t HUGE16 **post, ulong ptr)
  2022. {
  2023.     int i;
  2024.     long l=0,total;
  2025.     idxrec_t idx;
  2026.  
  2027.  
  2028. if((i=smb_locksmbhdr(&smb[cur_smb]))!=0) {
  2029.     printf("ERROR %d locking %s\n",i,smb[cur_smb].file);
  2030.     logprintf("ERROR %d line %d locking %s",i,__LINE__,smb[cur_smb].file);
  2031.     return(0L); }
  2032.  
  2033. /* total msgs in sub */
  2034. total=filelength(fileno(smb[cur_smb].sid_fp))/sizeof(idxrec_t);
  2035.  
  2036. if(!total) {            /* empty */
  2037.     smb_unlocksmbhdr(&smb[cur_smb]);
  2038.     return(0); }
  2039.  
  2040. if(((*post)=(post_t HUGE16 *)LMALLOC(sizeof(post_t)*total))    /* alloc for max */
  2041.     ==NULL) {
  2042.     smb_unlocksmbhdr(&smb[cur_smb]);
  2043.     printf("ERROR allocating %lu bytes for %s\n",sizeof(post_t *)*total
  2044.         ,smb[cur_smb].file);
  2045.     logprintf("ERROR line %d allocating %lu bytes for %s",__LINE__
  2046.         ,sizeof(post_t *)*total,smb[cur_smb].file);
  2047.     return(0); }
  2048.  
  2049. fseek(smb[cur_smb].sid_fp,0L,SEEK_SET);
  2050. while(!feof(smb[cur_smb].sid_fp)) {
  2051.     if(!fread(&idx,sizeof(idxrec_t),1,smb[cur_smb].sid_fp))
  2052.         break;
  2053.  
  2054.     if(idx.number<=ptr || idx.attr&MSG_DELETE)
  2055.         continue;
  2056.  
  2057.     if(idx.attr&MSG_MODERATED && !(idx.attr&MSG_VALIDATED))
  2058.         break;
  2059.  
  2060.     (*post)[l].offset=idx.offset;
  2061.     (*post)[l].number=idx.number;
  2062.     (*post)[l].to=idx.to;
  2063.     (*post)[l].from=idx.from;
  2064.     (*post)[l].subj=idx.subj;
  2065.     l++; }
  2066. smb_unlocksmbhdr(&smb[cur_smb]);
  2067. if(!l)
  2068.     LFREE(*post);
  2069. return(l);
  2070. }
  2071.  
  2072. void allocfail(uint size)
  2073. {
  2074. printf("\7ERROR allocating %u bytes of memory.\n",size);
  2075. bail(1);
  2076. }
  2077.  
  2078. void bail(int code)
  2079. {
  2080. exit(code);
  2081. }
  2082.  
  2083. /****************************************************************************/
  2084. /* Returns the length of the file in 'filespec'                             */
  2085. /****************************************************************************/
  2086. long flength(char *filespec)
  2087. {
  2088.     struct find_t f;
  2089.     uint i;
  2090.  
  2091. i=_dos_findfirst(filespec,0,&f);
  2092. #ifdef __WATCOMC__
  2093. _dos_findclose(&f);
  2094. #endif
  2095. if(!i)
  2096.     return(f.size);
  2097. return(-1L);
  2098. }
  2099.  
  2100. /****************************************************************************/
  2101. /* Checks the disk drive for the existence of a file. Returns 1 if it       */
  2102. /* exists, 0 if it doesn't.                                                 */
  2103. /* Called from upload                                                       */
  2104. /****************************************************************************/
  2105. char fexist(char *filespec)
  2106. {
  2107.     struct find_t f;
  2108.     uint i;
  2109.  
  2110. i=_dos_findfirst(filespec,0,&f);
  2111. #ifdef __WATCOMC__
  2112. _dos_findclose(&f);
  2113. #endif
  2114. if(!i)
  2115.     return(1);
  2116. return(0);
  2117. }
  2118.  
  2119. typedef struct {
  2120.     ulong    alias,
  2121.             real;
  2122.             } username_t;
  2123.  
  2124. /****************************************************************************/
  2125. /* Note: Wrote another version of this function that read all userdata into */
  2126. /****************************************************************************/
  2127. /* Looks for a perfect match amoung all usernames (not deleted users)        */
  2128. /* Returns the number of the perfect matched username or 0 if no match        */
  2129. /* Called from functions waitforcall and newuser                            */
  2130. /* memory then scanned it from memory... took longer - always.              */
  2131. /****************************************************************************/
  2132. ulong matchname(char *inname)
  2133. {
  2134.     static ulong total_users;
  2135.     static username_t *username;
  2136.     ulong last_user;
  2137.     int userdat,i;
  2138.     char str[256],name[LEN_NAME+1],alias[LEN_ALIAS+1],c;
  2139.     ulong l,crc;
  2140.  
  2141. if(!total_users) {        /* Load CRCs */
  2142.     fprintf(stderr,"\n%-25s","Loading user names...");
  2143.     sprintf(str,"%sUSER\\USER.DAT",data_dir);
  2144.     if((userdat=nopen(str,O_RDONLY|O_DENYNONE))==-1)
  2145.         return(0);
  2146.     last_user=filelength(userdat)/U_LEN;
  2147.     for(total_users=0;total_users<last_user;total_users++) {
  2148.         printf("%5ld\b\b\b\b\b",total_users);
  2149.         if((username=(username_t *)REALLOC(username
  2150.             ,(total_users+1L)*sizeof(username_t)))==NULL)
  2151.             break;
  2152.         username[total_users].alias=0;
  2153.         username[total_users].real=0;
  2154.         i=0;
  2155.         while(i<LOOP_NODEDAB
  2156.             && lock(userdat,(long)((long)(total_users)*U_LEN)+U_ALIAS
  2157.                 ,LEN_ALIAS+LEN_NAME)==-1)
  2158.             i++;
  2159.         if(i>=LOOP_NODEDAB) {       /* Couldn't lock USER.DAT record */
  2160.             logprintf("ERROR locking USER.DAT record #%ld",total_users);
  2161.             continue; }
  2162.         lseek(userdat,(long)((long)(total_users)*U_LEN)+U_ALIAS,SEEK_SET);
  2163.         read(userdat,alias,LEN_ALIAS);
  2164.         read(userdat,name,LEN_NAME);
  2165.         lseek(userdat,(long)(((long)total_users)*U_LEN)+U_MISC,SEEK_SET);
  2166.         read(userdat,tmp,8);
  2167.         for(c=0;c<8;c++)
  2168.             if(tmp[c]==ETX || tmp[c]==CR) break;
  2169.         tmp[c]=0;
  2170.         unlock(userdat,(long)((long)(total_users)*U_LEN)+U_ALIAS
  2171.             ,LEN_ALIAS+LEN_NAME);
  2172.         if(ahtoul(tmp)&DELETED)
  2173.             continue;
  2174.         for(c=0;c<LEN_ALIAS;c++)
  2175.             if(alias[c]==ETX || alias[c]==CR) break;
  2176.         alias[c]=0;
  2177.         strupr(alias);
  2178.         for(c=0;c<LEN_NAME;c++)
  2179.             if(name[c]==ETX || name[c]==CR) break;
  2180.         name[c]=0;
  2181.         strupr(name);
  2182.         username[total_users].alias=crc32(alias);
  2183.         username[total_users].real=crc32(name); }
  2184.     close(userdat);
  2185.     fprintf(stderr,"     \b\b\b\b\b");  // Clear counter
  2186.     fprintf(stderr,
  2187.         "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
  2188.         "%25s"
  2189.         "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
  2190.         ,""); }
  2191.  
  2192. strcpy(str,inname);
  2193. strupr(str);
  2194. crc=crc32(str);
  2195. for(l=0;l<total_users;l++)
  2196.     if((crc==username[l].alias || crc==username[l].real))
  2197.         return(l+1);
  2198. return(0);
  2199. }
  2200.  
  2201. /****************************************************************************/
  2202. /* Converts goofy FidoNet time format into Unix format                        */
  2203. /****************************************************************************/
  2204. time_t fmsgtime(char *str)
  2205. {
  2206.     char month[4];
  2207.     struct tm tm;
  2208.  
  2209. memset(&tm,0,sizeof(tm));
  2210. if(isdigit(str[1])) {    /* Regular format: "01 Jan 86  02:34:56" */
  2211.     tm.tm_mday=atoi(str);
  2212.     sprintf(month,"%3.3s",str+3);
  2213.     if(!stricmp(month,"jan"))
  2214.         tm.tm_mon=0;
  2215.     else if(!stricmp(month,"feb"))
  2216.         tm.tm_mon=1;
  2217.     else if(!stricmp(month,"mar"))
  2218.         tm.tm_mon=2;
  2219.     else if(!stricmp(month,"apr"))
  2220.         tm.tm_mon=3;
  2221.     else if(!stricmp(month,"may"))
  2222.         tm.tm_mon=4;
  2223.     else if(!stricmp(month,"jun"))
  2224.         tm.tm_mon=5;
  2225.     else if(!stricmp(month,"jul"))
  2226.         tm.tm_mon=6;
  2227.     else if(!stricmp(month,"aug"))
  2228.         tm.tm_mon=7;
  2229.     else if(!stricmp(month,"sep"))
  2230.         tm.tm_mon=8;
  2231.     else if(!stricmp(month,"oct"))
  2232.         tm.tm_mon=9;
  2233.     else if(!stricmp(month,"nov"))
  2234.         tm.tm_mon=10;
  2235.     else
  2236.         tm.tm_mon=11;
  2237.     tm.tm_year=atoi(str+7);
  2238.     tm.tm_hour=atoi(str+11);
  2239.     tm.tm_min=atoi(str+14);
  2240.     tm.tm_sec=atoi(str+17); }
  2241.  
  2242. else {                    /* SEAdog  format: "Mon  1 Jan 86 02:34" */
  2243.     tm.tm_mday=atoi(str+4);
  2244.     sprintf(month,"%3.3s",str+7);
  2245.     if(!stricmp(month,"jan"))
  2246.         tm.tm_mon=0;
  2247.     else if(!stricmp(month,"feb"))
  2248.         tm.tm_mon=1;
  2249.     else if(!stricmp(month,"mar"))
  2250.         tm.tm_mon=2;
  2251.     else if(!stricmp(month,"apr"))
  2252.         tm.tm_mon=3;
  2253.     else if(!stricmp(month,"may"))
  2254.         tm.tm_mon=4;
  2255.     else if(!stricmp(month,"jun"))
  2256.         tm.tm_mon=5;
  2257.     else if(!stricmp(month,"jul"))
  2258.         tm.tm_mon=6;
  2259.     else if(!stricmp(month,"aug"))
  2260.         tm.tm_mon=7;
  2261.     else if(!stricmp(month,"sep"))
  2262.         tm.tm_mon=8;
  2263.     else if(!stricmp(month,"oct"))
  2264.         tm.tm_mon=9;
  2265.     else if(!stricmp(month,"nov"))
  2266.         tm.tm_mon=10;
  2267.     else
  2268.         tm.tm_mon=11;
  2269.     tm.tm_year=atoi(str+11);
  2270.     tm.tm_hour=atoi(str+14);
  2271.     tm.tm_min=atoi(str+17);
  2272.     tm.tm_sec=0; }
  2273. return(mktime(&tm));
  2274. }
  2275.  
  2276. #if 1        /* Old way */
  2277.  
  2278. char HUGE16 *getfmsg(FILE *stream, ulong *outlen)
  2279. {
  2280.     uchar HUGE16 *fbuf;
  2281.     int ch;
  2282.     ulong l,length,start;
  2283.  
  2284. length=0L;
  2285. start=ftell(stream);                        /* Beginning of Message */
  2286. while(1) {
  2287.     ch=fgetc(stream);                        /* Look for Terminating NULL */
  2288.     if(!ch || ch==EOF)                        /* Found end of message */
  2289.         break;
  2290.     length++; }                             /* Increment the Length */
  2291.  
  2292. if((fbuf=(char *)LMALLOC(length+1))==NULL) {
  2293.     printf("Unable to allocate %lu bytes for message.\n",length+1);
  2294.     logprintf("ERROR line %d allocating %lu bytes of memory",__LINE__,length+1);
  2295.     exit(0); }
  2296.  
  2297. fseek(stream,start,SEEK_SET);
  2298. for(l=0;l<length;l++)
  2299.     fbuf[l]=fgetc(stream);
  2300. fbuf[length]=0;
  2301. if(!ch)
  2302.     fgetc(stream);        /* Read NULL */
  2303. if(outlen)
  2304.     *outlen=length;
  2305. return(fbuf);
  2306. }
  2307.  
  2308. #else
  2309.  
  2310. #define FBUF_BLOCK 4096
  2311.  
  2312. char *getfmsg(FILE *stream)
  2313. {
  2314.     uchar *fbuf,*p;
  2315.     ulong l,n,length,start;
  2316.  
  2317. length=0L;
  2318. start=ftell(stream);                        /* Beginning of Message */
  2319. if((fbuf=LMALLOC(FBUF_BLOCK))==NULL)
  2320.     return(fbuf);
  2321. while(!feof(stream)) {
  2322.     l=fread(fbuf+length,1,FBUF_BLOCK,stream);
  2323.     if(l<1)
  2324.         break;
  2325.     *(fbuf+length+l)=0;
  2326.     n=strlen(fbuf+length);
  2327.     if(n<l) {
  2328.         length+=(n+1);
  2329.         break; }
  2330.     printf(",");
  2331.     length+=l;
  2332.     if(l<FBUF_BLOCK)
  2333.         break;
  2334.     printf("<");
  2335.     if((p=REALLOC(fbuf,length+FBUF_BLOCK+1))==NULL) {
  2336.         LFREE(fbuf);
  2337.         printf("!");
  2338.         fseek(stream,-l,SEEK_CUR);
  2339.         return(NULL); }
  2340.     fbuf=p;
  2341.     printf(">");
  2342.     }
  2343. printf(".");
  2344.  
  2345. fseek(stream,start+length,SEEK_SET);
  2346. return(fbuf);
  2347. }
  2348.  
  2349. #endif
  2350.  
  2351. #define MAX_TAILLEN 1024
  2352.  
  2353. /****************************************************************************/
  2354. /* Coverts a FidoNet message into a Synchronet message                        */
  2355. /* Returns 1 on success, 0 on failure, -1 on dupe.                            */
  2356. /****************************************************************************/
  2357. int fmsgtosmsg(uchar HUGE16 *fbuf, fmsghdr_t fmsghdr, uint user, uint subnum)
  2358. {
  2359.     uchar    ch,HUGE16 *sbody,HUGE16 *stail,HUGE16 *outbuf
  2360.             ,done,col,esc,cr,*p,str[128];
  2361.     int     i,chunk,lzh=0,storage;
  2362.     ushort    xlat,net;
  2363.     ulong    l,m,length,lzhlen,bodylen,taillen,crc;
  2364.     faddr_t faddr,origaddr,destaddr;
  2365.     smbmsg_t    msg;
  2366.     smb_t    *smbfile;
  2367.  
  2368. memset(&msg,0,sizeof(smbmsg_t));
  2369. memcpy(msg.hdr.id,"SHD\x1a",4);
  2370. msg.hdr.version=SMB_VERSION;
  2371. if(fmsghdr.attr&FIDO_PRIVATE)
  2372.     msg.idx.attr|=MSG_PRIVATE;
  2373. msg.hdr.attr=msg.idx.attr;
  2374.  
  2375. if(fmsghdr.attr&FIDO_FILE)
  2376.     msg.hdr.auxattr|=MSG_FILEATTACH;
  2377.  
  2378. msg.hdr.when_imported.time=time(NULL);
  2379. msg.hdr.when_imported.zone=sys_timezone;
  2380. msg.hdr.when_written.time=fmsgtime(fmsghdr.time);
  2381.  
  2382. origaddr.zone=fmsghdr.origzone;     /* only valid if NetMail */
  2383. origaddr.net=fmsghdr.orignet;
  2384. origaddr.node=fmsghdr.orignode;
  2385. origaddr.point=fmsghdr.origpoint;
  2386.  
  2387. destaddr.zone=fmsghdr.destzone;     /* only valid if NetMail */
  2388. destaddr.net=fmsghdr.destnet;
  2389. destaddr.node=fmsghdr.destnode;
  2390. destaddr.point=fmsghdr.destpoint;
  2391.  
  2392. smb_hfield(&msg,SENDER,strlen(fmsghdr.from),fmsghdr.from);
  2393. strlwr(fmsghdr.from);
  2394. if(subnum==INVALID_SUB)
  2395.     msg.idx.from=0;
  2396. else
  2397.     msg.idx.from=crc16(fmsghdr.from);
  2398.  
  2399. smb_hfield(&msg,RECIPIENT,strlen(fmsghdr.to),fmsghdr.to);
  2400. strlwr(fmsghdr.to);
  2401. msg.idx.to=crc16(fmsghdr.to);
  2402.  
  2403. if(user) {
  2404.     sprintf(str,"%u",user);
  2405.     smb_hfield(&msg,RECIPIENTEXT,strlen(str),str);
  2406.     msg.idx.to=user; }
  2407.  
  2408. smb_hfield(&msg,SUBJECT,strlen(fmsghdr.subj),fmsghdr.subj);
  2409. remove_re(fmsghdr.subj);
  2410. strlwr(fmsghdr.subj);
  2411. msg.idx.subj=crc16(fmsghdr.subj);
  2412. if(fbuf==NULL) {
  2413.     printf("ERROR allocating fbuf\n");
  2414.     logprintf("ERROR line %d allocating fbuf",__LINE__);
  2415.     smb_freemsgmem(&msg);
  2416.     return(0); }
  2417. length=strlen((char *)fbuf);
  2418. if((sbody=(char HUGE16 *)LMALLOC((length+1)*2))==NULL) {
  2419.     printf("ERROR allocating %lu bytes for body",(length+1)*2L);
  2420.     logprintf("ERROR line %d allocating %lu bytes for body",__LINE__
  2421.         ,(length+1)*2L);
  2422.     smb_freemsgmem(&msg);
  2423.     return(0); }
  2424. if((stail=(char HUGE16 *)LMALLOC(MAX_TAILLEN))==NULL) {
  2425.     printf("ERROR allocating %lu bytes\n",MAX_TAILLEN);
  2426.     logprintf("ERROR line %d allocating %lu bytes for tail",__LINE__
  2427.         ,MAX_TAILLEN);
  2428.     LFREE(sbody);
  2429.     smb_freemsgmem(&msg);
  2430.     return(0); }
  2431.  
  2432. for(col=l=esc=done=bodylen=taillen=0,cr=1;l<length;l++) {
  2433.  
  2434.     if(!l && !strncmp((char *)fbuf,"AREA:",5)) {
  2435.         l+=5;
  2436.         while(l<length && fbuf[l]<=SP) l++;
  2437.         m=l;
  2438.         while(m<length && fbuf[m]!=CR) m++;
  2439.         while(m && fbuf[m-1]<=SP) m--;
  2440.         if(m>l)
  2441.             smb_hfield(&msg,FIDOAREA,m-l,fbuf+l);
  2442.         while(l<length && fbuf[l]!=CR) l++;
  2443.         continue; }
  2444.  
  2445.     ch=fbuf[l];
  2446.     if(ch==1 && cr) {    /* kludge line */
  2447.  
  2448.         if(!strncmp((char *)fbuf+l+1,"TOPT ",5))
  2449.             destaddr.point=atoi((char *)fbuf+l+6);
  2450.  
  2451.         else if(!strncmp((char *)fbuf+l+1,"FMPT ",5))
  2452.             origaddr.point=atoi((char *)fbuf+l+6);
  2453.  
  2454.         else if(!strncmp((char *)fbuf+l+1,"INTL ",5)) {
  2455.             faddr=atofaddr((char *)fbuf+l+6);
  2456.             destaddr.zone=faddr.zone;
  2457.             destaddr.net=faddr.net;
  2458.             destaddr.node=faddr.node;
  2459.             l+=6;
  2460.             while(l<length && fbuf[l]!=SP) l++;
  2461.             faddr=atofaddr((char *)fbuf+l+1);
  2462.             origaddr.zone=faddr.zone;
  2463.             origaddr.net=faddr.net;
  2464.             origaddr.node=faddr.node; }
  2465.  
  2466.         else if(!strncmp((char *)fbuf+l+1,"MSGID:",6)) {
  2467.             l+=7;
  2468.             while(l<length && fbuf[l]<=SP) l++;
  2469.             m=l;
  2470.             while(m<length && fbuf[m]!=CR) m++;
  2471.             while(m && fbuf[m-1]<=SP) m--;
  2472.             if(m>l)
  2473.                 smb_hfield(&msg,FIDOMSGID,m-l,fbuf+l); }
  2474.  
  2475.         else if(!strncmp((char *)fbuf+l+1,"REPLY:",6)) {
  2476.             l+=7;
  2477.             while(l<length && fbuf[l]<=SP) l++;
  2478.             m=l;
  2479.             while(m<length && fbuf[m]!=CR) m++;
  2480.             while(m && fbuf[m-1]<=SP) m--;
  2481.             if(m>l)
  2482.                 smb_hfield(&msg,FIDOREPLYID,m-l,fbuf+l); }
  2483.  
  2484.         else if(!strncmp((char *)fbuf+l+1,"FLAGS:",6)) {
  2485.             l+=7;
  2486.             while(l<length && fbuf[l]<=SP) l++;
  2487.             m=l;
  2488.             while(m<length && fbuf[m]!=CR) m++;
  2489.             while(m && fbuf[m-1]<=SP) m--;
  2490.             if(m>l)
  2491.                 smb_hfield(&msg,FIDOFLAGS,m-l,fbuf+l); }
  2492.  
  2493.         else if(!strncmp((char *)fbuf+l+1,"PATH:",5)) {
  2494.             l+=6;
  2495.             while(l<length && fbuf[l]<=SP) l++;
  2496.             m=l;
  2497.             while(m<length && fbuf[m]!=CR) m++;
  2498.             while(m && fbuf[m-1]<=SP) m--;
  2499.             if(m>l && misc&STORE_PATH)
  2500.                 smb_hfield(&msg,FIDOPATH,m-l,fbuf+l); }
  2501.  
  2502.         else if(!strncmp((char *)fbuf+l+1,"PID:",4)) {
  2503.             l+=5;
  2504.             while(l<length && fbuf[l]<=SP) l++;
  2505.             m=l;
  2506.             while(m<length && fbuf[m]!=CR) m++;
  2507.             while(m && fbuf[m-1]<=SP) m--;
  2508.             if(m>l)
  2509.                 smb_hfield(&msg,FIDOPID,m-l,fbuf+l); }
  2510.  
  2511.         else {        /* Unknown kludge line */
  2512.             while(l<length && fbuf[l]<=SP) l++;
  2513.             m=l;
  2514.             while(m<length && fbuf[m]!=CR) m++;
  2515.             while(m && fbuf[m-1]<=SP) m--;
  2516.             if(m>l && misc&STORE_KLUDGE)
  2517.                 smb_hfield(&msg,FIDOCTRL,m-l,fbuf+l); }
  2518.  
  2519.         while(l<length && fbuf[l]!=CR) l++;
  2520.         continue; }
  2521.  
  2522.     if(ch!=LF && ch!=0x8d) {    /* ignore LF and soft CRs */
  2523.         if(cr && (!strncmp((char *)fbuf+l,"--- ",4)
  2524.             || !strncmp((char *)fbuf+l,"---\r",4)))
  2525.             done=1;             /* tear line and down go into tail */
  2526.         if(done && cr && !strncmp((char *)fbuf+l,"SEEN-BY:",8)) {
  2527.             l+=8;
  2528.             while(l<length && fbuf[l]<=SP) l++;
  2529.             m=l;
  2530.             while(m<length && fbuf[m]!=CR) m++;
  2531.             while(m && fbuf[m-1]<=SP) m--;
  2532.             if(m>l && misc&STORE_SEENBY)
  2533.                 smb_hfield(&msg,FIDOSEENBY,m-l,fbuf+l);
  2534.             while(l<length && fbuf[l]!=CR) l++;
  2535.             continue; }
  2536.         if(done) {
  2537.             if(taillen<MAX_TAILLEN)
  2538.                 stail[taillen++]=ch; }
  2539.         else
  2540.             sbody[bodylen++]=ch;
  2541.         col++;
  2542.         if(ch==CR) {
  2543.             cr=1;
  2544.             col=0;
  2545.             if(done) {
  2546.                 if(taillen<MAX_TAILLEN)
  2547.                     stail[taillen++]=LF; }
  2548.             else
  2549.                 sbody[bodylen++]=LF; }
  2550.         else {
  2551.             cr=0;
  2552.             if(col==1 && !strncmp((char *)fbuf+l," * Origin: ",11)) {
  2553.                 p=(char *)fbuf+l+11;
  2554.                 while(*p && *p!=CR) p++;     /* Find CR */
  2555.                 while(p && *p!='(') p--;     /* rewind to '(' */
  2556.                 if(p)
  2557.                     origaddr=atofaddr(p+1);     /* get orig address */
  2558.                 done=1; }
  2559.             if(done)
  2560.                 continue;
  2561.  
  2562.             if(ch==ESC) esc=1;        /* ANSI codes */
  2563.             if(ch==SP && col>40 && !esc) {    /* word wrap */
  2564.                 for(m=l+1;m<length;m++)     /* find next space */
  2565.                     if(fbuf[m]<=SP)
  2566.                         break;
  2567.                 if(m<length && m-l>80-col) {  /* if it's beyond the eol */
  2568.                     sbody[bodylen++]=CR;
  2569.                     sbody[bodylen++]=LF;
  2570.                     col=0; } }
  2571.             } } }
  2572.  
  2573. if(bodylen>=2 && sbody[bodylen-2]==CR && sbody[bodylen-1]==LF)
  2574.     bodylen-=2;                         /* remove last CRLF if present */
  2575.  
  2576. if(smb[cur_smb].status.max_crcs) {
  2577.     for(l=0,crc=0xffffffff;l<bodylen;l++)
  2578.         crc=ucrc32(sbody[l],crc);
  2579.     crc=~crc;
  2580.     i=smb_addcrc(&smb[cur_smb],crc);
  2581.     if(i) {
  2582.         if(i==1)
  2583.             printf("Duplicate ");
  2584.         else
  2585.             printf("smb_addcrc returned %d ",i);
  2586.         smb_freemsgmem(&msg);
  2587.         LFREE(sbody);
  2588.         LFREE(stail);
  2589.         if(i==1)
  2590.             return(-1);
  2591.         return(0); } }
  2592.  
  2593. while(taillen && stail[taillen-1]<=SP)    /* trim all garbage off the tail */
  2594.     taillen--;
  2595.  
  2596. if(!origaddr.zone && subnum==INVALID_SUB)
  2597.     net=NET_NONE;                        /* Message from SBBSecho */
  2598. else
  2599.     net=NET_FIDO;                        /* Record origin address */
  2600.  
  2601. if(net) {
  2602.     smb_hfield(&msg,SENDERNETTYPE,sizeof(ushort),&net);
  2603.     smb_hfield(&msg,SENDERNETADDR,sizeof(fidoaddr_t),&origaddr); }
  2604.  
  2605. if(subnum==INVALID_SUB) {
  2606.     smbfile=email;
  2607.     if(net) {
  2608.         smb_hfield(&msg,RECIPIENTNETTYPE,sizeof(ushort),&net);
  2609.         smb_hfield(&msg,RECIPIENTNETADDR,sizeof(fidoaddr_t),&destaddr); } }
  2610. else
  2611.     smbfile=&smb[cur_smb];
  2612.  
  2613. if(subnum!=INVALID_SUB && sub[subnum]->misc&SUB_LZH
  2614.     && bodylen+2L+taillen+2L>=SDT_BLOCK_LEN && bodylen) {
  2615.     if((outbuf=(char *)LMALLOC(bodylen*2L))==NULL) {
  2616.         printf("ERROR allocating %lu bytes for lzh\n",bodylen*2);
  2617.         logprintf("ERROR line %d allocating %lu bytes for lzh",__LINE__
  2618.             ,bodylen*2);
  2619.         smb_freemsgmem(&msg);
  2620.         LFREE(sbody);
  2621.         LFREE(stail);
  2622.         return(0); }
  2623.     lzhlen=lzh_encode((uchar *)sbody,bodylen,(uchar *)outbuf);
  2624.     if(lzhlen>1 &&
  2625.         smb_datblocks(lzhlen+4L+taillen+2L)<
  2626.         smb_datblocks(bodylen+2L+taillen+2L)) {
  2627.         bodylen=lzhlen;     /* Compressable */
  2628.         l=bodylen+4;
  2629.         LFREE(sbody);
  2630.         lzh=1;
  2631.         sbody=outbuf; }
  2632.     else {                    /* Uncompressable */
  2633.         l=bodylen+2;
  2634.         LFREE(outbuf); } }
  2635. else
  2636.     l=bodylen+2;
  2637.  
  2638. if(taillen)
  2639.     l+=(taillen+2);
  2640.  
  2641. if(l&0xfff00000) {
  2642.     printf("ERROR checking msg len %lu\n",l);
  2643.     logprintf("ERROR line %d checking msg len %lu",__LINE__,l);
  2644.     smb_freemsgmem(&msg);
  2645.     LFREE(sbody);
  2646.     LFREE(stail);
  2647.     return(0); }
  2648.  
  2649. if(smbfile->status.attr&SMB_HYPERALLOC) {
  2650.     if((i=smb_locksmbhdr(smbfile))!=0) {
  2651.         printf("ERROR %d locking %s\n",i,smbfile->file);
  2652.         logprintf("ERROR %d line %d locking %s",i,__LINE__,smbfile->file);
  2653.         smb_freemsgmem(&msg);
  2654.         LFREE(sbody);
  2655.         LFREE(stail);
  2656.         return(0); }
  2657.     msg.hdr.offset=smb_hallocdat(smbfile);
  2658.     storage=SMB_HYPERALLOC; }
  2659. else {
  2660.     if((i=smb_open_da(smbfile))!=0) {
  2661.         smb_freemsgmem(&msg);
  2662.         printf("ERROR %d opening %s.SDA\n",i,smbfile->file);
  2663.         logprintf("ERROR %d line %d opening %s.SDA",i,__LINE__
  2664.             ,smbfile->file);
  2665.         LFREE(sbody);
  2666.         LFREE(stail);
  2667.         return(0); }
  2668.     if(subnum!=INVALID_SUB && sub[subnum]->misc&SUB_FAST) {
  2669.         msg.hdr.offset=smb_fallocdat(smbfile,l,1);
  2670.         storage=SMB_FASTALLOC; }
  2671.     else {
  2672.         msg.hdr.offset=smb_allocdat(smbfile,l,1);
  2673.         storage=SMB_SELFPACK; }
  2674.     smb_close_da(smbfile); }
  2675.  
  2676. if(msg.hdr.offset && msg.hdr.offset<1L) {
  2677.     if(smbfile->status.attr&SMB_HYPERALLOC)
  2678.         smb_unlocksmbhdr(smbfile);
  2679.     smb_freemsgmem(&msg);
  2680.     LFREE(sbody);
  2681.     LFREE(stail);
  2682.     printf("ERROR %ld allocating records\n",msg.hdr.offset);
  2683.     logprintf("ERROR line %d %ld allocating records",__LINE__,msg.hdr.offset);
  2684.     return(0); }
  2685. fseek(smbfile->sdt_fp,msg.hdr.offset,SEEK_SET);
  2686. if(lzh) {
  2687.     xlat=XLAT_LZH;
  2688.     fwrite(&xlat,2,1,smbfile->sdt_fp); }
  2689. xlat=XLAT_NONE;
  2690. fwrite(&xlat,2,1,smbfile->sdt_fp);
  2691. chunk=30000;
  2692. for(l=0;l<bodylen;l+=chunk) {
  2693.     if(l+chunk>bodylen)
  2694.         chunk=bodylen-l;
  2695.     fwrite(sbody+l,1,chunk,smbfile->sdt_fp); }
  2696. if(taillen) {
  2697.     fwrite(&xlat,2,1,smbfile->sdt_fp);
  2698.     fwrite(stail,1,taillen,smbfile->sdt_fp); }
  2699. LFREE(sbody);
  2700. LFREE(stail);
  2701. fflush(smbfile->sdt_fp);
  2702. if(smbfile->status.attr&SMB_HYPERALLOC)
  2703.     smb_unlocksmbhdr(smbfile);
  2704.  
  2705. if(lzh)
  2706.     bodylen+=2;
  2707. bodylen+=2;
  2708. smb_dfield(&msg,TEXT_BODY,bodylen);
  2709. if(taillen)
  2710.     smb_dfield(&msg,TEXT_TAIL,taillen+2);
  2711.  
  2712. i=smb_addmsghdr(smbfile,&msg,storage);
  2713. smb_freemsgmem(&msg);
  2714. if(i) {
  2715.     printf("ERROR smb_addmsghdr returned %d\n",i);
  2716.     logprintf("ERROR line %d smb_addmsghdr returned %d"
  2717.         ,__LINE__,i);
  2718.     return(0); }
  2719. return(1);
  2720. }
  2721.  
  2722. /***********************************************************************/
  2723. /* Get zone and point from kludge lines from the stream  if they exist */
  2724. /***********************************************************************/
  2725. void getzpt(FILE *stream, fmsghdr_t *hdr)
  2726. {
  2727.     char buf[0x1000];
  2728.     int i,len,cr=0;
  2729.     long pos;
  2730.     faddr_t faddr;
  2731.  
  2732. pos=ftell(stream);
  2733. len=fread(buf,1,0x1000,stream);
  2734. for(i=0;i<len;i++) {
  2735.     if((!i || cr) && buf[i]==1) {    /* kludge */
  2736.         if(!strncmp(buf+i+1,"TOPT ",5))
  2737.             hdr->destpoint=atoi(buf+i+6);
  2738.         else if(!strncmp(buf+i+1,"FMPT ",5))
  2739.             hdr->origpoint=atoi(buf+i+6);
  2740.         else if(!strncmp(buf+i+1,"INTL ",5)) {
  2741.             faddr=atofaddr(buf+i+6);
  2742.             hdr->destzone=faddr.zone;
  2743.             hdr->destnet=faddr.net;
  2744.             hdr->destnode=faddr.node;
  2745.             i+=6;
  2746.             while(buf[i] && buf[i]!=SP) i++;
  2747.             faddr=atofaddr(buf+i+1);
  2748.             hdr->origzone=faddr.zone;
  2749.             hdr->orignet=faddr.net;
  2750.             hdr->orignode=faddr.node; }
  2751.         while(i<len && buf[i]!=CR) i++;
  2752.         cr=1;
  2753.         continue; }
  2754.     if(buf[i]==CR)
  2755.         cr=1;
  2756.     else
  2757.         cr=0; }
  2758. fseek(stream,pos,SEEK_SET);
  2759. }
  2760. /******************************************************************************
  2761.  This function will seek to the next NULL found in stream
  2762. ******************************************************************************/
  2763. void seektonull(FILE *stream)
  2764. {
  2765.     char ch;
  2766.  
  2767. while(!feof(stream)) {
  2768.     if(!fread(&ch,1,1,stream))
  2769.         break;
  2770.     if(!ch)
  2771.         break; }
  2772.  
  2773. }
  2774.  
  2775. /******************************************************************************
  2776.  This function returns a packet name - used for outgoing packets
  2777. ******************************************************************************/
  2778. char *pktname(void)
  2779. {
  2780.     static char str[128];
  2781.     int i;
  2782.     time_t now;
  2783.     struct tm *tm;
  2784.  
  2785. now=time(NULL);
  2786. for(i=0;i<MAX_TOTAL_PKTS*2;i++) {
  2787.     now+=i;
  2788.     tm=gmtime(&now);
  2789.     sprintf(str,"%s%02u%02u%02u%02u.PK_",cfg.outbound,tm->tm_mday,tm->tm_hour
  2790.         ,tm->tm_min,tm->tm_sec);
  2791.     if(!fexist(str))                /* Add 1 second if name exists */
  2792.         break; }
  2793. return(str);
  2794. }
  2795. /******************************************************************************
  2796.  This function puts a message into a Fido packet, writing both the header
  2797.  information and the message body
  2798. ******************************************************************************/
  2799. void putfmsg(FILE *stream,uchar HUGE16 *fbuf,fmsghdr_t fmsghdr,areasbbs_t area
  2800.     ,addrlist_t seenbys,addrlist_t paths)
  2801. {
  2802.     char str[256],seenby[256],*p;
  2803.     short i,j,lastlen=0,net_exists=0;
  2804.     faddr_t addr,sysaddr;
  2805.  
  2806. addr=getsysfaddr(fmsghdr.destzone);
  2807.  
  2808. i=0x0002;
  2809. fwrite(&i,2,1,stream);
  2810. fwrite(&addr.node,2,1,stream);
  2811. fwrite(&fmsghdr.destnode,2,1,stream);
  2812. fwrite(&addr.net,2,1,stream);
  2813. fwrite(&fmsghdr.destnet,2,1,stream);
  2814. fwrite(&fmsghdr.attr,2,1,stream);
  2815. fwrite(&fmsghdr.cost,2,1,stream);
  2816. fwrite(fmsghdr.time,strlen(fmsghdr.time)+1,1,stream);
  2817. fwrite(fmsghdr.to,strlen(fmsghdr.to)+1,1,stream);
  2818. fwrite(fmsghdr.from,strlen(fmsghdr.from)+1,1,stream);
  2819. fwrite(fmsghdr.subj,strlen(fmsghdr.subj)+1,1,stream);
  2820. if(area.name)
  2821.     if(strncmp((char *)fbuf,"AREA:",5))                     /* No AREA: Line */
  2822.         fprintf(stream,"AREA:%s\r",area.name);              /* So add one */
  2823. fwrite(fbuf,strlen((char *)fbuf),1,stream);
  2824. lastlen=9;
  2825. if(fbuf[strlen((char *)fbuf)-1]!=CR)
  2826.     fputc(CR,stream);
  2827.  
  2828. if(area.name && addr.zone!=fmsghdr.destzone)    /* Zone Gate */
  2829.     fprintf(stream,"SEEN-BY: %d/%d\r",fmsghdr.destnet,fmsghdr.destnode);
  2830.  
  2831. if(area.name && addr.zone==fmsghdr.destzone) {    /* Not NetMail */
  2832.     fprintf(stream,"SEEN-BY:");
  2833.     for(i=0;i<seenbys.addrs;i++) {              /* Put back original SEEN-BYs */
  2834.         strcpy(seenby," ");
  2835.         if(seenbys.addr[i].zone!=addr.zone)
  2836.             continue;
  2837.         if(seenbys.addr[i].net!=addr.net || !net_exists) {
  2838.             net_exists=1;
  2839.             addr.net=seenbys.addr[i].net;
  2840.             sprintf(str,"%d/",addr.net);
  2841.             strcat(seenby,str); }
  2842.         sprintf(str,"%d",seenbys.addr[i].node);
  2843.         strcat(seenby,str);
  2844.         if(lastlen+strlen(seenby)<80) {
  2845.             fwrite(seenby,strlen(seenby),1,stream);
  2846.             lastlen+=strlen(seenby); }
  2847.         else {
  2848.             --i;
  2849.             lastlen=9; /* +strlen(seenby); */
  2850.             net_exists=0;
  2851.             fprintf(stream,"\rSEEN-BY:"); } }
  2852.  
  2853.     for(i=0;i<area.uplinks;i++) {            /* Add all uplinks to SEEN-BYs */
  2854.         strcpy(seenby," ");
  2855.         if(area.uplink[i].zone!=addr.zone || area.uplink[i].point)
  2856.             continue;
  2857.         for(j=0;j<seenbys.addrs;j++)
  2858.             if(!memcmp(&area.uplink[i],&seenbys.addr[j],sizeof(faddr_t)))
  2859.                 break;
  2860.         if(j==seenbys.addrs) {
  2861.             if(area.uplink[i].net!=addr.net || !net_exists) {
  2862.                 net_exists=1;
  2863.                 addr.net=area.uplink[i].net;
  2864.                 sprintf(str,"%d/",addr.net);
  2865.                 strcat(seenby,str); }
  2866.             sprintf(str,"%d",area.uplink[i].node);
  2867.             strcat(seenby,str);
  2868.             if(lastlen+strlen(seenby)<80) {
  2869.                 fwrite(seenby,strlen(seenby),1,stream);
  2870.                 lastlen+=strlen(seenby); }
  2871.             else {
  2872.                 --i;
  2873.                 lastlen=9; /* +strlen(seenby); */
  2874.                 net_exists=0;
  2875.                 fprintf(stream,"\rSEEN-BY:"); } } }
  2876.  
  2877.     for(i=0;i<total_faddrs;i++) {                /* Add AKAs to SEEN-BYs */
  2878.         strcpy(seenby," ");
  2879.         if(faddr[i].zone!=addr.zone || faddr[i].point)
  2880.             continue;
  2881.         for(j=0;j<seenbys.addrs;j++)
  2882.             if(!memcmp(&faddr[i],&seenbys.addr[j],sizeof(faddr_t)))
  2883.                 break;
  2884.         if(j==seenbys.addrs) {
  2885.             if(faddr[i].net!=addr.net || !net_exists) {
  2886.                 net_exists=1;
  2887.                 addr.net=faddr[i].net;
  2888.                 sprintf(str,"%d/",addr.net);
  2889.                 strcat(seenby,str); }
  2890.             sprintf(str,"%d",faddr[i].node);
  2891.             strcat(seenby,str);
  2892.             if(lastlen+strlen(seenby)<80) {
  2893.                 fwrite(seenby,strlen(seenby),1,stream);
  2894.                 lastlen+=strlen(seenby); }
  2895.             else {
  2896.                 --i;
  2897.                 lastlen=9; /* +strlen(seenby); */
  2898.                 net_exists=0;
  2899.                 fprintf(stream,"\rSEEN-BY:"); } } }
  2900.  
  2901.     lastlen=7;
  2902.     net_exists=0;
  2903.     fprintf(stream,"\r\1PATH:");
  2904.     addr=getsysfaddr(fmsghdr.destzone);
  2905.     for(i=0;i<paths.addrs;i++) {              /* Put back the original PATH */
  2906.         strcpy(seenby," ");
  2907.         if(paths.addr[i].zone!=addr.zone || paths.addr[i].point)
  2908.             continue;
  2909.         if(paths.addr[i].net!=addr.net || !net_exists) {
  2910.             net_exists=1;
  2911.             addr.net=paths.addr[i].net;
  2912.             sprintf(str,"%d/",addr.net);
  2913.             strcat(seenby,str); }
  2914.         sprintf(str,"%d",paths.addr[i].node);
  2915.         strcat(seenby,str);
  2916.         if(lastlen+strlen(seenby)<80) {
  2917.             fwrite(seenby,strlen(seenby),1,stream);
  2918.             lastlen+=strlen(seenby); }
  2919.         else {
  2920.             --i;
  2921.             lastlen=7; /* +strlen(seenby); */
  2922.             net_exists=0;
  2923.             fprintf(stream,"\r\1PATH:"); } }
  2924.  
  2925.     strcpy(seenby," ");         /* Add first address with same zone to PATH */
  2926.     sysaddr=getsysfaddr(fmsghdr.destzone);
  2927.     if(!sysaddr.point) {
  2928.         if(sysaddr.net!=addr.net || !net_exists) {
  2929.             net_exists=1;
  2930.             addr.net=sysaddr.net;
  2931.             sprintf(str,"%d/",addr.net);
  2932.             strcat(seenby,str); }
  2933.         sprintf(str,"%d",sysaddr.node);
  2934.         strcat(seenby,str);
  2935.         if(lastlen+strlen(seenby)<80)
  2936.             fwrite(seenby,strlen(seenby),1,stream);
  2937.         else {
  2938.             fprintf(stream,"\r\1PATH:");
  2939.             fwrite(seenby,strlen(seenby),1,stream); } }
  2940.  
  2941.     fputc(CR,stream); }
  2942.  
  2943. fputc(0,stream);
  2944. }
  2945.  
  2946. /******************************************************************************
  2947.  This function creates a binary list of the message seen-bys and path from
  2948.  inbuf.
  2949. ******************************************************************************/
  2950. void gen_psb(addrlist_t *seenbys,addrlist_t *paths,char HUGE16 *inbuf
  2951.     ,ushort zone)
  2952. {
  2953.     char str[128],seenby[256],*p,*p1,*p2,HUGE16 *fbuf;
  2954.     int i,j,len;
  2955.     faddr_t addr;
  2956.  
  2957. if(!inbuf)
  2958.     return;
  2959. fbuf=strstr((char *)inbuf,"\r * Origin: ");
  2960. if(!fbuf)
  2961. fbuf=strstr((char *)inbuf,"\n * Origin: ");
  2962. if(!fbuf)
  2963.     fbuf=inbuf;
  2964. if(seenbys->addr) {
  2965.     FREE(seenbys->addr);
  2966.     seenbys->addr=0;
  2967.     seenbys->addrs=0; }
  2968. addr.zone=addr.net=addr.node=addr.point=seenbys->addrs=0;
  2969. p=strstr((char *)fbuf,"\rSEEN-BY:");
  2970. if(!p) p=strstr((char *)fbuf,"\nSEEN-BY:");
  2971. if(p) {
  2972.     while(1) {
  2973.         sprintf(str,"%-.100s",p+10);
  2974.         if((p1=strchr(str,CR))!=NULL)
  2975.             *p1=0;
  2976.         p1=str;
  2977.         i=j=0;
  2978.         len=strlen(str);
  2979.         while(i<len) {
  2980.             j=i;
  2981.             while(i<len && *(p1+i)!=SP)
  2982.                 ++i;
  2983.             if(j>len)
  2984.                 break;
  2985.             sprintf(seenby,"%-.*s",(i-j),p1+j);
  2986.             if((p2=strchr(seenby,':'))!=NULL) {
  2987.                 addr.zone=atoi(seenby);
  2988.                 addr.net=atoi(p2+1); }
  2989.             else if((p2=strchr(seenby,'/'))!=NULL)
  2990.                 addr.net=atoi(seenby);
  2991.             if((p2=strchr(seenby,'/'))!=NULL)
  2992.                 addr.node=atoi(p2+1);
  2993.             else
  2994.                 addr.node=atoi(seenby);
  2995.             if((p2=strchr(seenby,'.'))!=NULL)
  2996.                 addr.point=atoi(p2+1);
  2997.             if(!addr.zone)
  2998.                 addr.zone=zone;         /* Was 1 */
  2999.             if((seenbys->addr=(faddr_t *)REALLOC(seenbys->addr
  3000.                 ,sizeof(faddr_t)*(seenbys->addrs+1)))==NULL) {
  3001.                 printf("ERROR allocating memory for seenbys\n");
  3002.                 logprintf("ERROR line %d allocating memory for message "
  3003.                     "seenbys.",__LINE__);
  3004.                 exit(1); }
  3005.             memcpy(&seenbys->addr[seenbys->addrs],&addr,sizeof(faddr_t));
  3006.             seenbys->addrs++;
  3007.             ++i; }
  3008.         p1=strstr(p+10,"\rSEEN-BY:");
  3009.         if(!p1)
  3010.             p1=strstr(p+10,"\nSEEN-BY:");
  3011.         if(!p1)
  3012.             break;
  3013.         p=p1; } }
  3014. else {
  3015.     if((seenbys->addr=(faddr_t *)REALLOC(seenbys->addr
  3016.         ,sizeof(faddr_t)))==NULL) {
  3017.         printf("ERROR allocating memory for seenbys\n");
  3018.         logprintf("ERROR line %d allocating memory for message seenbys."
  3019.             ,__LINE__);
  3020.         exit(1); }
  3021.     memset(&seenbys->addr[0],0,sizeof(faddr_t)); }
  3022.  
  3023. if(paths->addr) {
  3024.     FREE(paths->addr);
  3025.     paths->addr=0;
  3026.     paths->addrs=0; }
  3027. addr.zone=addr.net=addr.node=addr.point=paths->addrs=0;
  3028. if((p=strstr((char *)fbuf,"\1PATH:"))!=NULL) {
  3029.     while(1) {
  3030.         sprintf(str,"%-.100s",p+7);
  3031.         if((p1=strchr(str,CR))!=NULL)
  3032.             *p1=0;
  3033.         p1=str;
  3034.         i=j=0;
  3035.         len=strlen(str);
  3036.         while(i<len) {
  3037.             j=i;
  3038.             while(i<len && *(p1+i)!=SP)
  3039.                 ++i;
  3040.             if(j>len)
  3041.                 break;
  3042.             sprintf(seenby,"%-.*s",(i-j),p1+j);
  3043.             if((p2=strchr(seenby,':'))!=NULL) {
  3044.                 addr.zone=atoi(seenby);
  3045.                 addr.net=atoi(p2+1); }
  3046.             else if((p2=strchr(seenby,'/'))!=NULL)
  3047.                 addr.net=atoi(seenby);
  3048.             if((p2=strchr(seenby,'/'))!=NULL)
  3049.                 addr.node=atoi(p2+1);
  3050.             else
  3051.                 addr.node=atoi(seenby);
  3052.             if((p2=strchr(seenby,'.'))!=NULL)
  3053.                 addr.point=atoi(p2+1);
  3054.             if(!addr.zone)
  3055.                 addr.zone=zone;         /* Was 1 */
  3056.             if((paths->addr=(faddr_t *)REALLOC(paths->addr
  3057.                 ,sizeof(faddr_t)*(paths->addrs+1)))==NULL) {
  3058.                 printf("ERROR allocating memory for paths\n");
  3059.                 logprintf("ERROR line %d allocating memory for message "
  3060.                     "paths.",__LINE__);
  3061.                 exit(1); }
  3062.             memcpy(&paths->addr[paths->addrs],&addr,sizeof(faddr_t));
  3063.             paths->addrs++;
  3064.             ++i; }
  3065.         if((p1=strstr(p+7,"\1PATH:"))==NULL)
  3066.             break;
  3067.         p=p1; } }
  3068. else {
  3069.     if((paths->addr=(faddr_t *)REALLOC(paths->addr
  3070.         ,sizeof(faddr_t)))==NULL) {
  3071.         printf("ERROR allocating memory for paths\n");
  3072.         logprintf("ERROR line %d allocating memory for message paths."
  3073.             ,__LINE__);
  3074.         exit(1); }
  3075.     memset(&paths->addr[0],0,sizeof(faddr_t)); }
  3076. }
  3077.  
  3078. /******************************************************************************
  3079.  This function takes the addrs passed to it and compares them to the address
  3080.  passed in inaddr.    1 is returned if inaddr matches any of the addrs
  3081.  otherwise a 0 is returned.
  3082. ******************************************************************************/
  3083. char check_psb(addrlist_t addrlist,faddr_t inaddr)
  3084. {
  3085.     int i;
  3086.  
  3087. for(i=0;i<addrlist.addrs;i++) {
  3088.     if(!memcmp(&addrlist.addr[i],&inaddr,sizeof(faddr_t)))
  3089.         return(1); }
  3090. return(0);
  3091. }
  3092. /******************************************************************************
  3093.  This function strips the message seen-bys and path from inbuf.
  3094. ******************************************************************************/
  3095. void strip_psb(char HUGE16 *inbuf)
  3096. {
  3097.     char *p,HUGE16 *fbuf;
  3098.  
  3099. if(!inbuf)
  3100.     return;
  3101. fbuf=strstr((char *)inbuf,"\r * Origin: ");
  3102. if(!fbuf)
  3103.     fbuf=inbuf;
  3104. if((p=strstr((char *)fbuf,"\rSEEN-BY:"))!=NULL)
  3105.     *(p)=0;
  3106. if((p=strstr((char *)fbuf,"\r\1PATH:"))!=NULL)
  3107.     *(p)=0;
  3108. }
  3109. void attach_bundles()
  3110. {
  3111.     FILE *fidomsg;
  3112.     char str[1025],path[512],packet[128];
  3113.     int fmsg;
  3114.     ulong l;
  3115.     faddr_t pkt_faddr;
  3116.     pkthdr_t pkthdr;
  3117.     struct find_t ff;
  3118.  
  3119. sprintf(path,"%s*.PK_",cfg.outbound);
  3120. for(l=_dos_findfirst(path,0,&ff);!l && !kbhit();l=_dos_findnext(&ff)) {
  3121.     sprintf(packet,"%s%s",cfg.outbound,ff.name);
  3122.     printf("%21s: %s ","Outbound Packet",packet);
  3123.     if((fmsg=sopen(packet,O_RDWR,SH_DENYRW))==-1) {
  3124.         printf("ERROR opening.\n");
  3125.         logprintf("ERROR line %d opening %s",__LINE__,packet);
  3126.         continue; }
  3127.     if((fidomsg=fdopen(fmsg,"r+b"))==NULL) {
  3128.         close(fmsg);
  3129.         printf("\7ERROR fdopening.\n");
  3130.         logprintf("ERROR line %d fdopening %s",__LINE__,packet);
  3131.         continue; }
  3132.     if(filelength(fmsg)<sizeof(pkthdr_t)) {
  3133.         printf("ERROR invalid length of %u bytes for %s\n",filelength(fmsg)
  3134.             ,packet);
  3135.         logprintf("ERROR line %d invalid length of %u bytes for %s"
  3136.             ,__LINE__,filelength(fmsg),packet);
  3137.         fclose(fidomsg);
  3138.         if(delfile(packet))
  3139.             logprintf("ERROR line %d removing %s %s",__LINE__,packet
  3140.                 ,sys_errlist[errno]);
  3141.         continue; }
  3142.     if(fread(&pkthdr,sizeof(pkthdr_t),1,fidomsg)!=1) {
  3143.         fclose(fidomsg);
  3144.         printf("\7ERROR reading %u bytes from %s\n",sizeof(pkthdr_t),packet);
  3145.         logprintf("ERROR line %d reading %u bytes from %s",__LINE__
  3146.             ,sizeof(pkthdr_t),packet);
  3147.         continue; }
  3148.     fseek(fidomsg,-2L,SEEK_END);
  3149.     fread(str,2,1,fidomsg);
  3150.     fclose(fidomsg);
  3151.     if(!str[0] && !str[1]) {    /* Check for two nulls at end of packet */
  3152.         pkt_faddr.zone=pkthdr.destzone;
  3153.         pkt_faddr.net=pkthdr.destnet;
  3154.         pkt_faddr.node=pkthdr.destnode;
  3155.         pkt_faddr.point=0;                /* No point info in the 2.0 hdr! */
  3156.         memcpy(&two_plus,&pkthdr.empty,20);
  3157.         if(two_plus.cword==_rotr(two_plus.cwcopy,8)  /* 2+ Packet Header */
  3158.             && two_plus.cword && two_plus.cword&1)
  3159.             pkt_faddr.point=two_plus.destpoint;
  3160.         else if(pkthdr.baud==2) {                /* Type 2.2 Packet Header */
  3161.             memcpy(&two_two,&pkthdr.empty,20);
  3162.             pkt_faddr.point=pkthdr.month; }
  3163.         printf("Sending to %s\n",faddrtoa(pkt_faddr));
  3164.         pack_bundle(packet,pkt_faddr); }
  3165.     else {
  3166.         fclose(fidomsg);
  3167.         printf("Possibly still in use\n"); } }
  3168. #ifdef __WATCOMC__
  3169. _dos_findclose(&ff);
  3170. #endif
  3171. }
  3172. /******************************************************************************
  3173.  This is where we put outgoing messages into packets.  Set the 'cleanup'
  3174.  parameter to 1 to force all the remaining packets closed and stuff them into
  3175.  a bundle.
  3176. ******************************************************************************/
  3177. void pkt_to_pkt(uchar HUGE16 *fbuf,areasbbs_t area,faddr_t faddr
  3178.     ,fmsghdr_t fmsghdr,addrlist_t seenbys,addrlist_t paths,char cleanup)
  3179. {
  3180.     int i,j,k,file;
  3181.     short node;
  3182.     time_t now;
  3183.     struct tm *tm;
  3184.     pkthdr_t pkthdr;
  3185.     static ushort openpkts,totalpkts;
  3186.     static outpkt_t outpkt[MAX_TOTAL_PKTS];
  3187.     faddr_t sysaddr;
  3188.     two_two_t two;
  3189.     two_plus_t two_p;
  3190.  
  3191.  
  3192. if(cleanup==1) {
  3193.     for(i=0;i<totalpkts;i++) {
  3194.         if(outpkt[i].curopen) {
  3195.             fputc(0,outpkt[i].stream);
  3196.             fputc(0,outpkt[i].stream);
  3197.             fclose(outpkt[i].stream); }
  3198.         else {
  3199.             if((outpkt[i].stream=fnopen(&file,outpkt[i].filename
  3200.                 ,O_WRONLY|O_APPEND))==NULL) {
  3201.                 printf("ERROR opening %s for write.\n",outpkt[i].filename);
  3202.                 logprintf("ERROR line %d opening %s %s",__LINE__
  3203.                     ,outpkt[i].filename,sys_errlist[errno]);
  3204.                 continue; }
  3205.             fputc(0,outpkt[i].stream);
  3206.             fputc(0,outpkt[i].stream);
  3207.             fclose(outpkt[i].stream); }
  3208. //          pack_bundle(outpkt[i].filename,outpkt[i].uplink);
  3209.         memset(&outpkt[i],0,sizeof(outpkt_t)); }
  3210.     totalpkts=openpkts=0;
  3211.     attach_bundles();
  3212.     attachment(0,faddr,1);
  3213.     return; }
  3214.  
  3215. if(fbuf==NULL) {
  3216.     printf("ERROR allocating fbuf\n");
  3217.     logprintf("ERROR line %d allocating fbuf",__LINE__);
  3218.     return; }
  3219. /* We want to see if there's already a packet open for this area.   */
  3220. /* If not, we'll open a new one.  Once we have a packet, we'll add  */
  3221. /* messages to it as they come in.    If necessary, we'll close an    */
  3222. /* open packet to open a new one.                                    */
  3223.  
  3224. for(j=0;j<area.uplinks;j++) {
  3225.     if((cleanup==2 && memcmp(&faddr,&area.uplink[j],sizeof(faddr_t))) ||
  3226.         (!cleanup && (!memcmp(&faddr,&area.uplink[j],sizeof(faddr_t)) ||
  3227.         check_psb(seenbys,area.uplink[j]))))
  3228.         continue;
  3229.     node=matchnode(area.uplink[j],0);
  3230.     if(node<cfg.nodecfgs && cfg.nodecfg[node].attr&ATTR_PASSIVE)
  3231.         continue;
  3232.     sysaddr=getsysfaddr(area.uplink[j].zone);
  3233.     printf("%s ",faddrtoa(area.uplink[j]));
  3234.     for(i=0;i<totalpkts;i++) {
  3235.         if(!memcmp(&area.uplink[j],&outpkt[i].uplink,sizeof(faddr_t))) {
  3236.             if(!outpkt[i].curopen) {
  3237.                 if(openpkts==DFLT_OPEN_PKTS)
  3238.                     for(k=0;k<totalpkts;k++) {
  3239.                         if(outpkt[k].curopen) {
  3240.                             fclose(outpkt[k].stream);
  3241.                             outpkt[k].curopen=0;
  3242.                             break; } }
  3243.                 if((outpkt[i].stream=fnopen(&file,outpkt[i].filename
  3244.                     ,O_WRONLY|O_APPEND))==NULL) {
  3245.                     printf("Unable to open %s for write.\n"
  3246.                         ,outpkt[i].filename);
  3247.                     logprintf("ERROR line %d opening %s %s",__LINE__
  3248.                         ,outpkt[i].filename,sys_errlist[errno]);
  3249.                     exit(1); }
  3250.                 outpkt[i].curopen=1; }
  3251.             if((strlen((char *)fbuf)+1+ftell(outpkt[i].stream))
  3252.                 <=cfg.maxpktsize) {
  3253.                 fmsghdr.destnode=area.uplink[j].node;
  3254.                 fmsghdr.destnet=area.uplink[j].net;
  3255.                 fmsghdr.destzone=area.uplink[j].zone;
  3256.                 putfmsg(outpkt[i].stream,fbuf,fmsghdr,area,seenbys,paths); }
  3257.             else {
  3258.                 fputc(0,outpkt[i].stream);
  3259.                 fputc(0,outpkt[i].stream);
  3260.                 fclose(outpkt[i].stream);
  3261. //                  pack_bundle(outpkt[i].filename,outpkt[i].uplink);
  3262.                 outpkt[i].stream=outpkt[totalpkts-1].stream;
  3263.                 memcpy(&outpkt[i],&outpkt[totalpkts-1],sizeof(outpkt_t));
  3264.                 memset(&outpkt[totalpkts-1],0,sizeof(outpkt_t));
  3265.                 --totalpkts;
  3266.                 --openpkts;
  3267.                 i=totalpkts; }
  3268.             break; } }
  3269.         if(i==totalpkts) {
  3270.             if(openpkts==DFLT_OPEN_PKTS)
  3271.                 for(k=0;k<totalpkts;k++) {
  3272.                     if(outpkt[k].curopen) {
  3273.                         fclose(outpkt[k].stream);
  3274.                         outpkt[k].curopen=0;
  3275.                         --openpkts;
  3276.                         break; } }
  3277.             strcpy(outpkt[i].filename,pktname());
  3278.             now=time(NULL);
  3279.             tm=gmtime(&now);
  3280.             if((outpkt[i].stream=fnopen(&file,outpkt[i].filename
  3281.                 ,O_WRONLY|O_CREAT))==NULL) {
  3282.                 printf("Unable to open %s for write.\n"
  3283.                     ,outpkt[i].filename);
  3284.                 logprintf("ERROR line %d opening %s %s"
  3285.                     ,__LINE__,outpkt[i].filename,sys_errlist[errno]);
  3286.                 exit(1); }
  3287.             pkthdr.orignode=sysaddr.node;
  3288.             fmsghdr.destnode=pkthdr.destnode=area.uplink[j].node;
  3289.             if(cfg.nodecfg[node].pkt_type==PKT_TWO_TWO) {
  3290.                 pkthdr.year=sysaddr.point;
  3291.                 pkthdr.month=area.uplink[j].point;
  3292.                 pkthdr.day=0;
  3293.                 pkthdr.hour=0;
  3294.                 pkthdr.min=0;
  3295.                 pkthdr.sec=0;
  3296.                 pkthdr.baud=0x0002; }
  3297.             else {
  3298.                 pkthdr.year=tm->tm_year;
  3299.                 pkthdr.month=tm->tm_mon;
  3300.                 pkthdr.day=tm->tm_mday;
  3301.                 pkthdr.hour=tm->tm_hour;
  3302.                 pkthdr.min=tm->tm_min;
  3303.                 pkthdr.sec=tm->tm_sec;
  3304.                 pkthdr.baud=0; }
  3305.             pkthdr.pkttype=0x0002;
  3306.             pkthdr.orignet=sysaddr.net;
  3307.             fmsghdr.destnet=pkthdr.destnet=area.uplink[j].net;
  3308.             pkthdr.prodcode=0;
  3309.             pkthdr.sernum=0;
  3310.             if(node<cfg.nodecfgs)
  3311.                 memcpy(pkthdr.password,cfg.nodecfg[node].pktpwd,8);
  3312.             else
  3313.                 memset(pkthdr.password,0,8);
  3314.             pkthdr.origzone=sysaddr.zone;
  3315.             fmsghdr.destzone=pkthdr.destzone=area.uplink[j].zone;
  3316.             memset(pkthdr.empty,0,sizeof(two_two_t));
  3317.  
  3318.             if(cfg.nodecfg[node].pkt_type==PKT_TWO_TWO) {
  3319.                 memset(&two,0,20);
  3320.                 strcpy(two.origdomn,"fidonet");
  3321.                 strcpy(two.destdomn,"fidonet");
  3322.                 memcpy(&pkthdr.empty,&two,20); }
  3323.             else if(cfg.nodecfg[node].pkt_type==PKT_TWO_PLUS) {
  3324.                 memset(&two_p,0,20);
  3325.                 if(sysaddr.point) {
  3326.                     pkthdr.orignet=-1;
  3327.                     two_p.auxnet=sysaddr.net; }
  3328.                 two_p.cwcopy=0x0100;
  3329.                 two_p.prodcode=pkthdr.prodcode;
  3330.                 two_p.revision=pkthdr.sernum;
  3331.                 two_p.cword=0x0001;
  3332.                 two_p.origzone=pkthdr.origzone;
  3333.                 two_p.destzone=pkthdr.destzone;
  3334.                 two_p.origpoint=sysaddr.point;
  3335.                 two_p.destpoint=area.uplink[j].point;
  3336.                 memcpy(&pkthdr.empty,&two_p,sizeof(two_plus_t)); }
  3337.  
  3338.             fwrite(&pkthdr,sizeof(pkthdr_t),1,outpkt[totalpkts].stream);
  3339.             putfmsg(outpkt[totalpkts].stream,fbuf,fmsghdr,area,seenbys,paths);
  3340.             outpkt[totalpkts].curopen=1;
  3341.             memcpy(&outpkt[totalpkts].uplink,&area.uplink[j]
  3342.                 ,sizeof(faddr_t));
  3343.             ++openpkts;
  3344.             ++totalpkts;
  3345.             if(totalpkts>=MAX_TOTAL_PKTS) {
  3346.                 fclose(outpkt[totalpkts-1].stream);
  3347. //                  pack_bundle(outpkt[totalpkts-1].filename
  3348. //                      ,outpkt[totalpkts-1].uplink);
  3349.                 --totalpkts;
  3350.                 --openpkts; }
  3351.             } }
  3352. }
  3353.  
  3354. /**************************************/
  3355. /* Send netmail, returns 0 on success */
  3356. /**************************************/
  3357. int import_netmail(char *path,fmsghdr_t hdr, FILE *fidomsg)
  3358. {
  3359.     uchar info[512],str[256],tmp[256],subj[256]
  3360.         ,HUGE16 *fmsgbuf=NULL,*p,*tp,*sp;
  3361.     int i,match,usernumber;
  3362.     ulong l;
  3363.     faddr_t addr;
  3364.  
  3365. hdr.destzone=hdr.origzone=sys_faddr.zone;
  3366. hdr.destpoint=hdr.origpoint=0;
  3367. getzpt(fidomsg,&hdr);                /* use kludge if found */
  3368. for(match=0;match<total_faddrs;match++)
  3369.     if((hdr.destzone==faddr[match].zone || misc&FUZZY_ZONE)
  3370.         && hdr.destnet==faddr[match].net
  3371.         && hdr.destnode==faddr[match].node
  3372.         && hdr.destpoint==faddr[match].point)
  3373.         break;
  3374. if(match<total_faddrs && misc&FUZZY_ZONE)
  3375.     hdr.origzone=hdr.destzone=faddr[match].zone;
  3376. if(hdr.origpoint)
  3377.     sprintf(tmp,".%u",hdr.origpoint);
  3378. else
  3379.     tmp[0]=0;
  3380. if(hdr.destpoint)
  3381.     sprintf(str,".%u",hdr.destpoint);
  3382. else
  3383.     str[0]=0;
  3384. sprintf(info,"%s%s%s (%u:%u/%u%s) To: %s (%u:%u/%u%s)"
  3385.     ,path,path[0] ? " ":""
  3386.     ,hdr.from,hdr.origzone,hdr.orignet,hdr.orignode,tmp
  3387.     ,hdr.to,hdr.destzone,hdr.destnet,hdr.destnode,str);
  3388. printf("%s ",info);
  3389.  
  3390. if(!(misc&IMPORT_NETMAIL)) {
  3391.     if(!path[0]) {
  3392.         fmsgbuf=getfmsg(fidomsg,&l);
  3393.         if(!fmsgbuf) {
  3394.             printf("ERROR Netmail allocation");
  3395.             logprintf("ERROR line %d netmail allocation",__LINE__);
  3396.             return(2); }
  3397.  
  3398.         if(!l && misc&KILL_EMPTY_MAIL)
  3399.             printf("Empty NetMail - ");
  3400.         else {
  3401.             for(i=1;i;i++) {
  3402.                 sprintf(str,"%s%u.MSG",netmail_dir,i);
  3403.                 if(!fexist(str))
  3404.                     break; }
  3405.             if(!i) {
  3406.                 printf("Too many netmail messages");
  3407.                 logprintf("Too many netmail messages");
  3408.                 return(2); }
  3409.             if((i=nopen(str,O_WRONLY|O_CREAT))==-1) {
  3410.                 printf("ERROR opening %s",str);
  3411.                 logprintf("ERROR opening %s",str);
  3412.                 return(2); }
  3413.             write(i,&hdr,sizeof(hdr));
  3414.             write(i,fmsgbuf,strlen((char *)fmsgbuf)+1); /* Write the NULL too */
  3415.             close(i); }
  3416.         FREE(fmsgbuf); }
  3417.     printf("Ignored");
  3418.     if(cfg.log&LOG_IGNORED)
  3419.         logprintf("%s Ignored",info);
  3420.     return(-1); }
  3421.  
  3422. if(hdr.attr&FIDO_ORPHAN) {
  3423.     printf("Orphaned");
  3424.     return(1); }
  3425. if(!(misc&IGNORE_ADDRESS) && match==total_faddrs && path[0]) {
  3426.     printf("Skipped");
  3427.     return(2); }
  3428. if(!(misc&IGNORE_RECV) && hdr.attr&FIDO_RECV) {
  3429.     printf("Already received");
  3430.     return(3); }
  3431. if(hdr.attr&FIDO_LOCAL && !(misc&LOCAL_NETMAIL)) {
  3432.     printf("Created locally");
  3433.     return(4); }
  3434.  
  3435. if(email->shd_fp==NULL) {
  3436.     sprintf(email->file,"%sMAIL",data_dir);
  3437.     email->retry_time=smb_retry_time;
  3438.     if((i=smb_open(email))!=0) {
  3439.         printf("ERROR %d opening %s\n",i,email->file);
  3440.         logprintf("ERROR %d line %d opening %s",i,__LINE__,email->file);
  3441.         exit(1); } }
  3442.  
  3443. if(!filelength(fileno(email->shd_fp))) {
  3444.     email->status.max_crcs=mail_maxcrcs;
  3445.     email->status.max_msgs=MAX_SYSMAIL;
  3446.     email->status.max_age=mail_maxage;
  3447.     email->status.attr=SMB_EMAIL;
  3448.     if((i=smb_create(email))!=0) {
  3449.         sprintf(str,"ERROR %d creating %s",i,email->file);
  3450.         printf("%s\n",str);
  3451.         logprintf(str);
  3452.         exit(1); } }
  3453.  
  3454. if(!stricmp(hdr.to,"AREAFIX") || !stricmp(hdr.to,"SBBSECHO")) {
  3455.     fmsgbuf=getfmsg(fidomsg,NULL);
  3456.     if(path[0]) {
  3457.         if(misc&DELETE_NETMAIL) {
  3458.             fclose(fidomsg);
  3459.             if(delfile(path))
  3460.                 logprintf("ERROR line %d removing %s %s",__LINE__,path
  3461.                     ,sys_errlist[errno]); }
  3462.         else {
  3463.             hdr.attr|=FIDO_RECV;
  3464.             fseek(fidomsg,0L,SEEK_SET);
  3465.             fwrite(&hdr,sizeof(fmsghdr_t),1,fidomsg);
  3466.             fclose(fidomsg); } }    /* Gotta close it here for areafix stuff */
  3467.     addr.zone=hdr.origzone;
  3468.     addr.net=hdr.orignet;
  3469.     addr.node=hdr.orignode;
  3470.     addr.point=hdr.origpoint;
  3471.     strcpy(hdr.to,sys_op);
  3472.     strcpy(hdr.from,"SBBSecho");
  3473.     strcpy(str,hdr.subj);
  3474.     strcpy(hdr.subj,"Areafix Request");
  3475.     hdr.origzone=hdr.orignet=hdr.orignode=hdr.origpoint=0;
  3476.     p=process_areafix(addr,fmsgbuf,str);
  3477. #if 0 // Not necessary with SMBLIB v2.0
  3478.     if((i=smb_locksmbhdr(email))!=0) {
  3479.         printf("ERROR %d locking %s smbhdr",i,email->file);
  3480.         logprintf("ERROR %d line %d locking %s smbhdr",i,__LINE__,email->file);
  3481.         exit(1); }
  3482.     if((i=smb_getstatus(email))!=0) {
  3483.         printf("ERROR %d reading %s status header",i,email->file);
  3484.         logprintf("ERROR %d line %d reading %s status header",i,__LINE__
  3485.             ,email->file);
  3486.         exit(1); }
  3487. #endif
  3488.     if(p && cfg.notify)
  3489.         if(fmsgtosmsg(p,hdr,cfg.notify,INVALID_SUB)==1) {
  3490.             sprintf(str,"\7\1n\1hSBBSecho \1n\1msent you mail\r\n");
  3491.             putsmsg(cfg.notify,str); }
  3492. //      smb_unlocksmbhdr(email);
  3493.     if(fmsgbuf)
  3494.         FREE(fmsgbuf);
  3495.     if(cfg.log&LOG_AREAFIX)
  3496.         logprintf(info);
  3497.     return(-2); }
  3498.  
  3499. usernumber=atoi(hdr.to);
  3500. if(!stricmp(hdr.to,"SYSOP"))  /* NetMail to "sysop" goes to #1 */
  3501.     usernumber=1;
  3502. if(!usernumber && match<total_faddrs)
  3503.     usernumber=matchname(hdr.to);
  3504. if(!usernumber) {
  3505.     if(misc&UNKNOWN_NETMAIL && match<total_faddrs)    /* receive unknown user */
  3506.         usernumber=1;                                /* mail to 1 */
  3507.     else {
  3508.         if(match<total_faddrs) {
  3509.             printf("Unknown user ");
  3510.             if(cfg.log&LOG_UNKNOWN)
  3511.                 logprintf("%s Unknown user",info); }
  3512. /***
  3513.         hdr.attr|=FIDO_ORPHAN;
  3514.         fseek(fidomsg,0L,SEEK_SET);
  3515.         fwrite(&hdr,sizeof(fmsghdr_t),1,fidomsg);
  3516. ***/
  3517.         if(!path[0]) {
  3518.             fmsgbuf=getfmsg(fidomsg,&l);
  3519.             if(!fmsgbuf) {
  3520.                 printf("ERROR Netmail allocation");
  3521.                 logprintf("ERROR line %d netmail allocation",__LINE__);
  3522.                 return(2); }
  3523.             if(!l && misc&KILL_EMPTY_MAIL) {
  3524.                 printf("Empty NetMail - Ignored");
  3525.                 if(cfg.log&LOG_IGNORED)
  3526.                     logprintf("%s Empty - Ignored",info); }
  3527.             else {
  3528.                 for(i=1;i;i++) {
  3529.                     sprintf(str,"%s%u.MSG",netmail_dir,i);
  3530.                     if(!fexist(str))
  3531.                         break; }
  3532.                 if(!i) {
  3533.                     printf("Too many netmail messages");
  3534.                     logprintf("Too many netmail messages");
  3535.                     return(2); }
  3536.                 if((i=nopen(str,O_WRONLY|O_CREAT))==-1) {
  3537.                     printf("ERROR opening %s",str);
  3538.                     logprintf("ERROR opening %s",str);
  3539.                     return(2); }
  3540.                 write(i,&hdr,sizeof(hdr));
  3541.                 write(i,fmsgbuf,strlen((char *)fmsgbuf)+1); /* Write the NULL too */
  3542.                 close(i); }
  3543.             FREE(fmsgbuf); }
  3544.         return(2); } }
  3545.  
  3546. /*********************/
  3547. /* Importing NetMail */
  3548. /*********************/
  3549.  
  3550. fmsgbuf=getfmsg(fidomsg,&l);
  3551.  
  3552. #if 0 // Unnecessary with SMBLIB v2.0
  3553. if((i=smb_locksmbhdr(email))!=0) {
  3554.     printf("ERROR %d locking %s smbhdr",i,email->file);
  3555.     logprintf("ERROR %d line %d locking %s smbhdr",i,__LINE__,email->file);
  3556.     exit(1); }
  3557. if((i=smb_getstatus(email))!=0) {
  3558.     printf("ERROR %d reading %s status header",i,email->file);
  3559.     logprintf("ERROR %d line %d reading %s status header"
  3560.         ,i,__LINE__,email->file);
  3561.     exit(1); }
  3562. #endif
  3563.  
  3564. if(!l && misc&KILL_EMPTY_MAIL) {
  3565.     printf("Empty NetMail - Ignored");
  3566.     if(cfg.log&LOG_IGNORED)
  3567.         logprintf("%s Empty - Ignored",info);
  3568.     if(fmsgbuf)
  3569.         FREE(fmsgbuf);
  3570.     return(0); }
  3571.  
  3572. i=fmsgtosmsg(fmsgbuf,hdr,usernumber,INVALID_SUB);
  3573. if(i!=1) {
  3574.     printf("ERROR (%d) Importing",i);
  3575.     logprintf("ERROR (%d) Importing %s",i,info);
  3576.     if(fmsgbuf)
  3577.         FREE(fmsgbuf);
  3578.     return(10); }
  3579.  
  3580. addr.zone=hdr.origzone;
  3581. addr.net=hdr.orignet;
  3582. addr.node=hdr.orignode;
  3583. addr.point=hdr.origpoint;
  3584. sprintf(str,"\7\1n\1hSBBSecho: \1m%.36s \1n\1msent you NetMail from "
  3585.     "\1h%s\1n\r\n",hdr.from,faddrtoa(addr));
  3586. putsmsg(usernumber,str);
  3587.  
  3588. if(hdr.attr&FIDO_FILE) {    /* File attachment */
  3589.     strcpy(subj,hdr.subj);
  3590.     tp=subj;
  3591.     while(1) {
  3592.         p=strchr(tp,SP);
  3593.         if(p) *p=0;
  3594.         sp=strrchr(tp,'/');              /* sp is slash pointer */
  3595.         if(!sp) sp=strrchr(tp,'\\');
  3596.         if(sp) tp=sp+1;
  3597.         sprintf(str,"%s%s",fidofile_dir,tp);
  3598.         sprintf(tmp,"%sFILE\\%04u.IN",data_dir,usernumber);
  3599.         mkdir(tmp);
  3600.         strcat(tmp,"\\");
  3601.         strcat(tmp,tp);
  3602.         mv(str,tmp,0);
  3603.         if(!p)
  3604.             break;
  3605.         tp=p+1; } }
  3606. netmail++;
  3607.  
  3608. if(fmsgbuf)
  3609.     FREE(fmsgbuf);
  3610.  
  3611. /***************************/
  3612. /* Updating message header */
  3613. /***************************/
  3614. /***    NOT packet compatible
  3615. if(!(misc&DONT_SET_RECV)) {
  3616.     hdr.attr|=FIDO_RECV;
  3617.     fseek(fidomsg,0L,SEEK_SET);
  3618.     fwrite(&hdr,sizeof(fmsghdr_t),1,fidomsg); }
  3619. ***/
  3620. if(cfg.log&LOG_IMPORTED)
  3621.     logprintf("%s Imported",info);
  3622. return(0);
  3623. }
  3624.  
  3625. /******************************************************************************
  3626.  This is where we export echomail.    This was separated from function main so
  3627.  it could be used for the remote rescan function.  Passing anything but an
  3628.  empty address as 'addr' designates that a rescan should be done for that
  3629.  address.
  3630. ******************************************************************************/
  3631. void export_echomail(char *sub_code,faddr_t addr)
  3632. {
  3633.     char str[1025],tear,cr,HUGE16 *buf;
  3634.     uchar HUGE16 *fmsgbuf=NULL;
  3635.     int g,i,j,k,file;
  3636.     ulong f,l,m,exp,ptr,msgs,lastmsg,posts,exported=0;
  3637.     float export_time;
  3638.     smbmsg_t msg;
  3639.     fmsghdr_t hdr;
  3640.     struct    tm *tm;
  3641.     faddr_t pkt_faddr;
  3642.     post_t HUGE16 *post;
  3643.     areasbbs_t fakearea,curarea;
  3644.     addrlist_t msg_seen,msg_path;
  3645.     clock_t start_tick=0,export_ticks=0;
  3646.  
  3647. memset(&msg_seen,0,sizeof(addrlist_t));
  3648. memset(&msg_path,0,sizeof(addrlist_t));
  3649. memset(&pkt_faddr,0,sizeof(faddr_t));
  3650. start_tick=0;
  3651.  
  3652. printf("\nScanning for Outbound EchoMail...\n");
  3653.  
  3654. for(g=0;g<total_grps;g++)
  3655. for(i=0;i<total_subs;i++)
  3656.     if(sub[i]->misc&SUB_FIDO && sub[i]->grp==g) {
  3657.         for(j=0;j<cfg.areas;j++)    /* Skip areas with no uplinks */
  3658.             if(cfg.area[j].sub==i)
  3659.                 break;
  3660.         if(j==cfg.areas || (j<cfg.areas && !cfg.area[j].uplinks))
  3661.             continue;
  3662.         if(addr.zone) {         /* Skip areas not meant for this address */
  3663.             if(j<cfg.areas)
  3664.                 for(k=0;k<cfg.area[j].uplinks;k++)
  3665.                     if(!memcmp(&cfg.area[j].uplink[k],&addr,sizeof(faddr_t)))
  3666.                         break;
  3667.             if(k==cfg.area[j].uplinks)
  3668.                 continue; }
  3669.         if(sub_code[0] && stricmp(sub_code,sub[i]->code))
  3670.             continue;
  3671.         printf("\nScanning %-15.15s %s\n"
  3672.             ,grp[sub[i]->grp]->sname,sub[i]->lname);
  3673.         ptr=0;
  3674.         if(!addr.zone && !(misc&IGNORE_MSGPTRS)) {
  3675.             sprintf(str,"%s%s.SFP",sub[i]->data_dir,sub[i]->code);
  3676.             if((file=nopen(str,O_RDONLY))!=-1) {
  3677.                 read(file,&ptr,sizeof(time_t));
  3678.                 close(file); } }
  3679.  
  3680.         msgs=getlastmsg(i,&lastmsg,0);
  3681.         if(!msgs || (!addr.zone && !(misc&IGNORE_MSGPTRS) && ptr>=lastmsg)) {
  3682.             printf("No new messages.");
  3683.             if(ptr>lastmsg && !addr.zone && !(misc&LEAVE_MSGPTRS)) {
  3684.                 printf("Fixing new-scan pointer.");
  3685.                 sprintf(str,"%s%s.SFP",sub[i]->data_dir,sub[i]->code);
  3686.                 if((file=nopen(str,O_WRONLY|O_CREAT))==-1) {
  3687.                     printf("\7ERROR opening/creating %s",str);
  3688.                     logprintf("ERROR line %d opening/creating %s"
  3689.                         ,__LINE__,str); }
  3690.                 else {
  3691.                     write(file,&lastmsg,4);
  3692.                     close(file); } }
  3693.             continue; }
  3694.  
  3695.         sprintf(smb[cur_smb].file,"%s%s"
  3696.             ,sub[i]->data_dir,sub[i]->code);
  3697.         smb[cur_smb].retry_time=smb_retry_time;
  3698.         if((j=smb_open(&smb[cur_smb]))!=0) {
  3699.             printf("ERROR %d opening %s\n",j,smb[cur_smb].file);
  3700.             logprintf("ERROR %d line %d opening %s",j,__LINE__
  3701.                 ,smb[cur_smb].file);
  3702.             continue; }
  3703.  
  3704.         post=NULL;
  3705.         posts=loadmsgs(&post,ptr);
  3706.  
  3707.         if(!posts)    { /* no new messages */
  3708.             smb_close(&smb[cur_smb]);
  3709.             if(post)
  3710.                 LFREE(post);
  3711.             continue; }
  3712.  
  3713.         if(start_tick)
  3714.             export_ticks+=clock()-start_tick;
  3715.         start_tick=clock();
  3716.  
  3717.         for(m=exp=0;m<posts;m++) {
  3718.             printf("\r%8s %5lu of %-5lu  "
  3719.                 ,sub[i]->code,m+1,posts);
  3720.             msg.idx.offset=post[m].offset;
  3721.             if((k=smb_lockmsghdr(&smb[cur_smb],&msg))!=0) {
  3722.                 printf("ERROR %d locking %s msghdr\n",k,smb[cur_smb].file);
  3723.                 logprintf("ERROR %d line %d locking %s msghdr\n"
  3724.                     ,k,__LINE__,smb[cur_smb].file);
  3725.                 continue; }
  3726.             k=smb_getmsghdr(&smb[cur_smb],&msg);
  3727.             if(k || msg.hdr.number!=post[m].number) {
  3728.                 smb_unlockmsghdr(&smb[cur_smb],&msg);
  3729.                 smb_freemsgmem(&msg);
  3730.  
  3731.                 msg.hdr.number=post[m].number;
  3732.                 if((k=smb_getmsgidx(&smb[cur_smb],&msg))!=0) {
  3733.                     printf("ERROR %d reading %s index\n",k,smb[cur_smb].file);
  3734.                     logprintf("ERROR %d line %d reading %s index",k,__LINE__
  3735.                         ,smb[cur_smb].file);
  3736.                     continue; }
  3737.                 if((k=smb_lockmsghdr(&smb[cur_smb],&msg))!=0) {
  3738.                     printf("ERROR %d locking %s msghdr\n",k,smb[cur_smb].file);
  3739.                     logprintf("ERROR %d line %d locking %s msghdr",k,__LINE__
  3740.                         ,smb[cur_smb].file);
  3741.                     continue; }
  3742.                 if((k=smb_getmsghdr(&smb[cur_smb],&msg))!=0) {
  3743.                     smb_unlockmsghdr(&smb[cur_smb],&msg);
  3744.                     printf("ERROR %d reading %s msghdr\n",k,smb[cur_smb].file);
  3745.                     logprintf("ERROR %d line %d reading %s msghdr",k,__LINE__
  3746.                         ,smb[cur_smb].file);
  3747.                     continue; } }
  3748.  
  3749.             if((!addr.zone && !(misc&EXPORT_ALL)
  3750.                 && msg.from_net.type==NET_FIDO)
  3751.                 || !strnicmp(msg.subj,"NE:",3)) {   /* no echo */
  3752.                 smb_unlockmsghdr(&smb[cur_smb],&msg);
  3753.                 smb_freemsgmem(&msg);
  3754.                 continue; }  /* From a Fido node, ignore it */
  3755.  
  3756.             if(msg.from_net.type && msg.from_net.type!=NET_FIDO
  3757.                 && !(sub[i]->misc&SUB_GATE)) {
  3758.                 smb_unlockmsghdr(&smb[cur_smb],&msg);
  3759.                 smb_freemsgmem(&msg);
  3760.                 continue; }
  3761.  
  3762.             memset(&hdr,0,sizeof(fmsghdr_t));     /* Zero the header */
  3763.             hdr.origzone=sub[i]->faddr.zone;
  3764.             hdr.orignet=sub[i]->faddr.net;
  3765.             hdr.orignode=sub[i]->faddr.node;
  3766.             hdr.origpoint=sub[i]->faddr.point;
  3767.  
  3768.             hdr.attr=FIDO_LOCAL;
  3769.             if(msg.hdr.attr&MSG_PRIVATE)
  3770.                 hdr.attr|=FIDO_PRIVATE;
  3771.  
  3772.             sprintf(hdr.from,"%.35s",msg.from);
  3773.  
  3774.             tm=gmtime((time_t *)&msg.hdr.when_written.time);
  3775.             sprintf(hdr.time,"%02u %3.3s %02u  %02u:%02u:%02u"
  3776.                 ,tm->tm_mday,mon[tm->tm_mon],tm->tm_year
  3777.                 ,tm->tm_hour,tm->tm_min,tm->tm_sec);
  3778.  
  3779.             sprintf(hdr.to,"%.35s",msg.to);
  3780.  
  3781.             sprintf(hdr.subj,"%.71s",msg.subj);
  3782.  
  3783.             buf=smb_getmsgtxt(&smb[cur_smb],&msg,GETMSGTXT_TAILS);
  3784.             if(!buf) {
  3785.                 smb_unlockmsghdr(&smb[cur_smb],&msg);
  3786.                 smb_freemsgmem(&msg);
  3787.                 continue; }
  3788.             fmsgbuf=MALLOC(strlen((char *)buf)+512);
  3789.             if(!fmsgbuf) {
  3790.                 printf("ERROR allocating %lu bytes for fmsgbuf\n");
  3791.                 logprintf("ERROR line %d allocating %lu bytes for fmsgbuf"
  3792.                     ,__LINE__,strlen((char *)buf)+512);
  3793.                 smb_unlockmsghdr(&smb[cur_smb],&msg);
  3794.                 smb_freemsgmem(&msg);
  3795.                 continue; }
  3796.  
  3797.             tear=0;
  3798.             for(l=f=0,cr=1;buf[l];l++) {
  3799.                 if(buf[l]==1) { /* Ctrl-A, so skip it and the next char */
  3800.                     l++;
  3801.                     if(!buf[l])
  3802.                         break;
  3803.                     continue; }
  3804.                 if(buf[l]==LF)    /* Ignore line feeds */
  3805.                     continue;
  3806.                 if(cr) {
  3807.                     if(buf[l]=='-' && buf[l+1]=='-'
  3808.                         && buf[l+2]=='-'
  3809.                         && (buf[l+3]==SP || buf[l+3]==CR)) {
  3810.                         if(misc&CONVERT_TEAR)    /* Convert to === */
  3811.                             buf[l]=buf[l+1]=buf[l+2]='=';
  3812.                         else
  3813.                             tear=1; }
  3814.                     else if(!strncmp((char *)buf+l," * Origin: ",11))
  3815.                         buf[l+1]='#'; } /* Convert * Origin into # Origin */
  3816.  
  3817.                 if(buf[l]==CR)
  3818.                     cr=1;
  3819.                 else
  3820.                     cr=0;
  3821.                 if(sub[i]->misc&SUB_ASCII || misc&ASCII_ONLY) {
  3822.                     if(buf[l]<SP && buf[l]!=CR) /* Ctrl ascii */
  3823.                         buf[l]='.';             /* converted to '.' */
  3824.                     if((uchar)buf[l]>0x7f)        /* extended ASCII */
  3825.                         buf[l]='*'; }           /* converted to '*' */
  3826.  
  3827.                 fmsgbuf[f++]=buf[l]; }
  3828.  
  3829.             FREE(buf);
  3830.             fmsgbuf[f]=0;
  3831.  
  3832.             if(!(sub[i]->misc&SUB_NOTAG)) {
  3833.                 if(!tear) {  /* No previous tear line */
  3834.                     sprintf(str,"--- Synchronet+SBBSecho v%s\r",SBBSECHO_VER);
  3835.                     strcat((char *)fmsgbuf,str); }
  3836.  
  3837.                 sprintf(str," * Origin: %s (%s)\r"
  3838.                     ,sub[i]->origline[0] ? sub[i]->origline : origline
  3839.                     ,faddrtoa(sub[i]->faddr));
  3840.                 strcat((char *)fmsgbuf,str); }
  3841.  
  3842.             for(k=0;k<cfg.areas;k++)
  3843.                 if(cfg.area[k].sub==i) {
  3844.                     cfg.area[k].exported++;
  3845.                     pkt_to_pkt(fmsgbuf,cfg.area[k]
  3846.                         ,(addr.zone) ? addr:pkt_faddr,hdr,msg_seen
  3847.                         ,msg_path,(addr.zone) ? 2:0);
  3848.                     break; }
  3849.             FREE(fmsgbuf);
  3850.             exported++;
  3851.             exp++;
  3852.             printf("Exp: %lu ",exp);
  3853.             smb_unlockmsghdr(&smb[cur_smb],&msg);
  3854.             smb_freemsgmem(&msg); }
  3855.  
  3856.         smb_close(&smb[cur_smb]);
  3857.         LFREE(post);
  3858.  
  3859.         /***********************/
  3860.         /* Update FIDO_PTR.DAB */
  3861.         /***********************/
  3862.         if(!addr.zone && !(misc&LEAVE_MSGPTRS) && lastmsg>ptr) {
  3863.             sprintf(str,"%s%s.SFP",sub[i]->data_dir,sub[i]->code);
  3864.             if((file=nopen(str,O_WRONLY|O_CREAT))==-1) {
  3865.                 printf("\7ERROR opening/creating %s",str);
  3866.                 logprintf("ERROR line %d opening/creating %s",__LINE__,str); }
  3867.             else {
  3868.                 write(file,&lastmsg,4);
  3869.                 close(file); } } }
  3870.  
  3871. printf("\n");
  3872. if(start_tick)    /* Last possible increment of export_ticks */
  3873.     export_ticks+=clock()-start_tick;
  3874.  
  3875. pkt_to_pkt(buf,fakearea,pkt_faddr,hdr,msg_seen,msg_path,1);
  3876.  
  3877. if(!addr.zone && cfg.log&LOG_AREA_TOTALS && exported)
  3878.     for(i=0;i<cfg.areas;i++)
  3879.         if(cfg.area[i].exported)
  3880.             logprintf("Exported: %5u msgs %8s -> %s"
  3881.                 ,cfg.area[i].exported,sub[cfg.area[i].sub]->code
  3882.                 ,cfg.area[i].name);
  3883.  
  3884. export_time=((float)export_ticks)/(float)CLK_TCK;
  3885. if(cfg.log&LOG_TOTALS && exported && export_time) {
  3886.     printf("\nExported %lu EchoMail messages in %.1f seconds "
  3887.         ,exported,export_time);
  3888.     logprintf("Exported: %5lu msgs in %.1f sec (%.1f/min %.1f/sec)"
  3889.         ,exported,export_time
  3890.         ,export_time/60.0 ? (float)exported/(export_time/60.0) :(float)exported
  3891.         ,(float)exported/export_time);
  3892.     if(export_time/60.0)
  3893.         printf("(%.1f/min) ",(float)exported/(export_time/60.0));
  3894.     printf("(%.1f/sec)\n",(float)exported/export_time); }
  3895.  
  3896. }
  3897. /***********************************/
  3898. /* Synchronet/FidoNet Message util */
  3899. /***********************************/
  3900. int main(int argc, char **argv)
  3901. {
  3902.     FILE    *fidomsg;
  3903.     char    ch,str[1025],fname[256],path[512],sub_code[9]
  3904.             ,*p,*tp,*sp,*buf,cr,tear,lzh
  3905.             ,areatagstr[129],packet[128],outbound[128];
  3906.     uchar    HUGE16 *fmsgbuf=NULL;
  3907.     ushort    xlat,attr;
  3908.     int     i,j,k,n,x,y,z,last,file,fmsg,g,grunged;
  3909.     uint    subnum[MAX_OPEN_SMBS]={INVALID_SUB};
  3910.     ulong    files,msgfiles,echomail=0,crc,ptr,
  3911.             l,m,f,length,lastmsg,posts,msgs,exp,areatag;
  3912.     time_t    now;
  3913.     float    import_time;
  3914.     clock_t start_tick=0,import_ticks=0;
  3915.     read_cfg_text_t txt;
  3916.     struct    find_t ff;
  3917.     struct    tm *tm;
  3918.     fmsghdr_t hdr;
  3919.     faddr_t addr,pkt_faddr;
  3920.     post_t    HUGE16 *post;
  3921.     FILE    *stream,*fstream;
  3922.     smbmsg_t msg;
  3923.     pkthdr_t pkthdr;
  3924.     addrlist_t msg_seen,msg_path;
  3925.     areasbbs_t fakearea,curarea;
  3926.     char *usage="\n"
  3927. "usage: sbbsecho [cfg_file] [/switches] [sub_code]\n"
  3928. "\n"
  3929. "where: cfg_file is the filename of config file (default is ctrl\\sbbsecho.cfg)\n"
  3930. "       sub_code is the internal code for a sub-board (default is ALL subs)\n"
  3931. "\n"
  3932. "valid switches:\n"
  3933. "\n"
  3934. "p: do not import packets                 x: do not delete packets after import\n"
  3935. "n: do not import netmail                 d: do not delete netmail after import\n"
  3936. "i: do not import echomail                e: do not export echomail\n"
  3937. "m: ignore echomail ptrs (export all)     u: update echomail ptrs (export none)\n"
  3938. "j: ignore recieved bit on netmail        t: do not update echomail ptrs\n"
  3939. "l: create log file (data\\sbbsecho.log)   r: create report of import totals\n"
  3940. "h: export all echomail (hub rescan)      b: import locally created netmail too\n"
  3941. "a: export ASCII characters only          f: create packets for outbound netmail\n"
  3942. "g: generate notify lists                 =: change existing tear lines to ===\n"
  3943. "y: import netmail for unknown users to sysop\n"
  3944. "o: import all netmail regardless of destination address\n"
  3945. "s: import private echomail override (strip private status)\n"
  3946. "!: notify users of received echomail\n";
  3947.  
  3948. if((email=(smb_t *)MALLOC(sizeof(smb_t)))==NULL) {
  3949.     printf("ERROR allocating memory for email.\n");
  3950.     exit(1); }
  3951. memset(email,0,sizeof(smb_t));
  3952. if((smb=(smb_t *)MALLOC(MAX_OPEN_SMBS*sizeof(smb_t)))==NULL) {
  3953.     printf("ERROR allocating memory for smbs.\n");
  3954.     exit(1); }
  3955. for(i=0;i<MAX_OPEN_SMBS;i++)
  3956.     memset(&smb[i],0,sizeof(smb_t));
  3957. memset(&cfg,0,sizeof(config_t));
  3958. memset(&msg_seen,0,sizeof(addrlist_t));
  3959. memset(&msg_path,0,sizeof(addrlist_t));
  3960. printf("\nSBBSecho Version %s (%s) SMBLIB %s · Synchronet FidoNet Packet "
  3961.     "Tosser\n"
  3962.     ,SBBSECHO_VER
  3963. #if defined(__OS2__)
  3964.     ,"OS/2"
  3965. #elif defined(__NT__)
  3966.     ,"Win32"
  3967. #elif defined(__DOS4G__)
  3968.     ,"DOS4G"
  3969. #elif defined(__FLAT__)
  3970.     ,"DOS32"
  3971. #else
  3972.     ,"DOS16"
  3973. #endif
  3974.     ,SMBLIB_VERSION
  3975.     );
  3976.  
  3977. putenv("TZ=UCT0");
  3978. putenv("TMP=");
  3979. _fmode=O_BINARY;
  3980. setvbuf(stdout,NULL,_IONBF,0);
  3981.  
  3982. txt.openerr="\7\nError opening %s for read.\n";
  3983. txt.reading="\nReading %s...";
  3984. txt.readit="\rRead %s       ";
  3985. txt.allocerr="\7\nError allocating %u bytes of memory\n";
  3986. txt.error="\7\nERROR: Offset %lu in %s\n\n";
  3987.  
  3988. node_dir[0]=sub_code[0]=0;
  3989. for(i=1;i<argc;i++) {
  3990.     if(argv[i][0]=='/') {
  3991.         j=1;
  3992.         while(argv[i][j]) {
  3993.             switch(toupper(argv[i][j])) {
  3994.                 case 'A':
  3995.                     misc|=ASCII_ONLY;
  3996.                     break;
  3997.                 case 'B':
  3998.                     misc|=LOCAL_NETMAIL;
  3999.                     break;
  4000.                 case 'D':
  4001.                     misc&=~DELETE_NETMAIL;
  4002.                     break;
  4003.                 case 'E':
  4004.                     misc&=~EXPORT_ECHOMAIL;
  4005.                     break;
  4006.                 case 'F':
  4007.                     misc|=PACK_NETMAIL;
  4008.                     break;
  4009.                 case 'G':
  4010.                     misc|=GEN_NOTIFY_LIST;
  4011.                     break;
  4012.                 case 'H':
  4013.                     misc|=EXPORT_ALL;
  4014.                     break;
  4015.                 case 'I':
  4016.                     misc&=~IMPORT_ECHOMAIL;
  4017.                     break;
  4018.                 case 'J':
  4019.                     misc|=IGNORE_RECV;
  4020.                     break;
  4021.                 case 'L':
  4022.                     misc|=LOGFILE;
  4023.                     break;
  4024.                 case 'M':
  4025.                     misc|=IGNORE_MSGPTRS;
  4026.                     break;
  4027.                 case 'N':
  4028.                     misc&=~IMPORT_NETMAIL;
  4029.                     break;
  4030.                 case 'O':
  4031.                     misc|=IGNORE_ADDRESS;
  4032.                     break;
  4033.                 case 'P':
  4034.                     misc&=~IMPORT_PACKETS;
  4035.                     break;
  4036.                 case 'R':
  4037.                     misc|=REPORT;
  4038.                     break;
  4039.                 case 'S':
  4040.                     misc|=IMPORT_PRIVATE;
  4041.                     break;
  4042.                 case 'T':
  4043.                     misc|=LEAVE_MSGPTRS;
  4044.                     break;
  4045.                 case 'U':
  4046.                     misc|=UPDATE_MSGPTRS;
  4047.                     misc&=~EXPORT_ECHOMAIL;
  4048.                     break;
  4049.                 case 'X':
  4050.                     misc&=~DELETE_PACKETS;
  4051.                     break;
  4052.                 case 'Y':
  4053.                     misc|=UNKNOWN_NETMAIL;
  4054.                     break;
  4055.                 case '=':
  4056.                     misc|=CONVERT_TEAR;
  4057.                     break;
  4058.                 case '!':
  4059.                     misc|=NOTIFY_RECEIPT;
  4060.                     break;
  4061.                 case 'Q':
  4062.                     exit(0);
  4063.                 default:
  4064.                     printf(usage);
  4065.                     exit(0); }
  4066.             j++; } }
  4067.     else {
  4068.         if(strchr(argv[i],'\\') || argv[i][1]==':' || strchr(argv[i],'.'))
  4069.             sprintf(cfg.cfgfile,"%.100s",argv[i]);
  4070.         else
  4071.             sprintf(sub_code,"%.8s",argv[i]); }  }
  4072.  
  4073. if(!(misc&(IMPORT_NETMAIL|IMPORT_ECHOMAIL)))
  4074.     misc&=~IMPORT_PACKETS;
  4075. if(!node_dir[0]) {
  4076.     p=getenv("SBBSNODE");
  4077.     if(p==NULL) {
  4078.         printf("\7\nSBBSNODE environment variable not set.\n");
  4079.         exit(1); }
  4080.     strcpy(node_dir,p); }
  4081.  
  4082. strupr(node_dir);
  4083.  
  4084. if(node_dir[strlen(node_dir)-1]!='\\')
  4085.     strcat(node_dir,"\\");
  4086.  
  4087. read_node_cfg(txt);
  4088. if(ctrl_dir[0]=='.') {   /* Relative path */
  4089.     strcpy(str,ctrl_dir);
  4090.     sprintf(ctrl_dir,"%s%s",node_dir,str);
  4091.     if(_fullpath(str,ctrl_dir,40))
  4092.         strcpy(ctrl_dir,str); }
  4093. backslash(ctrl_dir);
  4094.  
  4095. read_main_cfg(txt);
  4096. if(data_dir[0]=='.') {   /* Relative path */
  4097.     strcpy(str,data_dir);
  4098.     sprintf(data_dir,"%s%s",node_dir,str);
  4099.     if(_fullpath(str,data_dir,40))
  4100.         strcpy(data_dir,str); }
  4101. backslash(data_dir);
  4102. if(text_dir[0]=='.') {   /* Relative path */
  4103.     strcpy(str,text_dir);
  4104.     sprintf(text_dir,"%s%s",node_dir,str);
  4105.     if(_fullpath(str,text_dir,40))
  4106.         strcpy(text_dir,str); }
  4107. backslash(text_dir);
  4108. read_msgs_cfg(txt);
  4109.  
  4110. #ifndef __FLAT__
  4111.  
  4112. __spawn_ext = (node_swap & SWAP_EXT) != 0 ;
  4113. __spawn_ems = (node_swap & SWAP_EMS) != 0 ;
  4114. __spawn_xms = (node_swap & SWAP_XMS) != 0 ;
  4115.  
  4116. #endif
  4117.  
  4118. if(total_faddrs<1) {
  4119.     sys_faddr.zone=sys_faddr.net=sys_faddr.node=1;
  4120.     sys_faddr.point=0; }
  4121. else
  4122.     sys_faddr=faddr[0];
  4123.  
  4124. sprintf(str,"%s%s",ctrl_dir,"NODE.DAB");
  4125. if((nodefile=sopen(str,O_BINARY|O_RDWR,SH_DENYNO))==-1) {
  4126.     printf("\n\7ERROR opening %s\n",str);
  4127.     exit(1); }
  4128.  
  4129. if(!cfg.cfgfile[0])
  4130.     sprintf(cfg.cfgfile,"%sSBBSECHO.CFG",ctrl_dir);
  4131. strcpy(cfg.inbound,fidofile_dir);
  4132. sprintf(cfg.areafile,"%sAREAS.BBS",data_dir);
  4133. sprintf(cfg.logfile,"%sSBBSECHO.LOG",data_dir);
  4134.  
  4135. read_cfg();
  4136.  
  4137. if(misc&LOGFILE)
  4138.     if((fidologfile=_fsopen(cfg.logfile,"ab",SH_DENYNO))==NULL) {
  4139.         printf("\7ERROR opening %s\n",cfg.logfile);
  4140.         exit(1); }
  4141.  
  4142.  
  4143. if(exec_dir[0]!='\\' && exec_dir[1]!=':') {
  4144.     strcpy(path,node_dir);
  4145.     strcat(path,exec_dir);
  4146.     if(_fullpath(str,path,40))
  4147.         strcpy(path,str);
  4148.     backslash(path); }
  4149. else
  4150.     strcpy(path,exec_dir);
  4151.  
  4152. /******* READ IN AREAS.BBS FILE *********/
  4153.  
  4154. printf("Reading %s",cfg.areafile);
  4155. if((stream=fnopen(&file,cfg.areafile,O_RDONLY))==NULL) {
  4156.     printf("Unable to open %s for read.\n",cfg.areafile);
  4157.     exit(1); }
  4158. cfg.areas=0;        /* Total number of areas in AREAS.BBS */
  4159. cfg.area=NULL;
  4160. while(1) {
  4161.     if(!fgets(str,1024,stream))
  4162.         break;
  4163.     truncsp(str);
  4164.     p=str;
  4165.     while(*p && *p<=SP) p++;    /* Find first printable char */
  4166.     if(*p==';' || !*p)          /* Ignore blank lines or start with ; */
  4167.         continue;
  4168.     if((cfg.area=(areasbbs_t *)REALLOC(cfg.area,sizeof(areasbbs_t)*
  4169.         (cfg.areas+1)))==NULL) {
  4170.         printf("ERROR allocating memory for area #%u.\n",cfg.areas+1);
  4171.         exit(1); }
  4172.     memset(&cfg.area[cfg.areas],0,sizeof(areasbbs_t));
  4173.  
  4174.     cfg.area[cfg.areas].sub=INVALID_SUB;    /* Default to passthru */
  4175.  
  4176.     sprintf(tmp,"%-.8s",p);
  4177.     tp=tmp;
  4178.     while(*tp>SP) tp++;
  4179.     *tp=0;
  4180.     for(i=0;i<total_subs;i++)
  4181.         if(!stricmp(tmp,sub[i]->code))
  4182.             break;
  4183.     if(i<total_subs)
  4184.         cfg.area[cfg.areas].sub=i;
  4185.     else if(stricmp(tmp,"P")) {
  4186.         printf("\n%s: Unrecongized internal code, assumed passthru",tmp);
  4187.         logprintf("%s: Unrecognized internal code, assumed passthru",tmp); }
  4188.  
  4189.     while(*p>SP) p++;                /* Skip code */
  4190.     while(*p && *p<=SP) p++;        /* Skip white space */
  4191.     sprintf(tmp,"%-.50s",p);        /* Area tag */
  4192.     if((tp=strchr(tmp,TAB))!=NULL)    /* Chop off any TABs */
  4193.         *tp=0;
  4194.     if((tp=strchr(tmp,SP))!=NULL)    /* Chop off any spaces */
  4195.         *tp=0;
  4196.     strupr(tmp);
  4197.     if(tmp[0]=='*')         /* UNKNOWN-ECHO area */
  4198.         cfg.badecho=cfg.areas;
  4199.     if((cfg.area[cfg.areas].name=(char *)MALLOC(strlen(tmp)+1))==NULL) {
  4200.         printf("ERROR allocating memory for area #%u tag name.\n"
  4201.             ,cfg.areas+1);
  4202.         exit(1); }
  4203.     strcpy(cfg.area[cfg.areas].name,tmp);
  4204.     strupr(tmp);
  4205.     cfg.area[cfg.areas].tag=crc32(tmp);
  4206.  
  4207.     while(*p>SP) p++;                /* Skip tag */
  4208.     while(*p && *p<=SP) p++;        /* Skip white space */
  4209.  
  4210.     while(*p && *p!=';') {
  4211.         if((cfg.area[cfg.areas].uplink=(faddr_t *)
  4212.             REALLOC(cfg.area[cfg.areas].uplink
  4213.             ,sizeof(faddr_t)*(cfg.area[cfg.areas].uplinks+1)))==NULL) {
  4214.             printf("ERROR allocating memory for area #%u uplinks.\n"
  4215.                 ,cfg.areas+1);
  4216.             exit(1); }
  4217.         cfg.area[cfg.areas].uplink[cfg.area[cfg.areas].uplinks]=atofaddr(p);
  4218.         while(*p>SP) p++;            /* Skip address */
  4219.         while(*p && *p<=SP) p++;    /* Skip white space */
  4220.         cfg.area[cfg.areas].uplinks++; }
  4221.  
  4222.     if(cfg.area[cfg.areas].sub!=INVALID_SUB || cfg.area[cfg.areas].uplinks)
  4223.         cfg.areas++;        /* Don't allocate if no tossing */
  4224.     }
  4225. fclose(stream);
  4226.  
  4227. printf("\n");
  4228.  
  4229. if(!cfg.areas) {
  4230.     printf("No areas defined!\n");
  4231.     exit(1); }
  4232.  
  4233. #if 0
  4234.     /* AREAS.BBS DEBUG */
  4235.     for(i=0;i<cfg.areas;i++) {
  4236.         printf("%4u: %-8s"
  4237.             ,i+1
  4238.             ,cfg.area[i].sub==INVALID_SUB ? "Passthru" :
  4239.             sub[cfg.area[i].sub]->code);
  4240.         for(j=0;j<cfg.area[i].uplinks;j++)
  4241.             printf(" %s",faddrtoa(cfg.area[i].uplink[j]));
  4242.         printf("\n"); }
  4243. #endif
  4244.  
  4245. if(misc&GEN_NOTIFY_LIST) {
  4246. printf("\nGenerating Notify Lists...\n");
  4247. notify_list(); }
  4248.  
  4249. /* Find any packets that have been left behind in the OUTBOUND directory */
  4250. printf("\nScanning for Stray Outbound Packets...\n");
  4251. sprintf(path,"%s*.PK_",cfg.outbound);
  4252. for(l=_dos_findfirst(path,0,&ff);!l && !kbhit();l=_dos_findnext(&ff)) {
  4253.     sprintf(packet,"%s%s",cfg.outbound,ff.name);
  4254.     printf("%21s: %s ","Outbound Packet",packet);
  4255.     if((fmsg=sopen(packet,O_RDWR,SH_DENYRW))==-1) {
  4256.         printf("ERROR opening.\n");
  4257.         logprintf("ERROR line %d opening %s",__LINE__,packet);
  4258.         continue; }
  4259.     if((fidomsg=fdopen(fmsg,"r+b"))==NULL) {
  4260.         close(fmsg);
  4261.         printf("\7ERROR fdopening.\n");
  4262.         logprintf("ERROR line %d fdopening %s",__LINE__,packet);
  4263.         continue; }
  4264.     if(filelength(fmsg)<sizeof(pkthdr_t)) {
  4265.         printf("ERROR invalid length of %u bytes for %s\n",filelength(fmsg)
  4266.             ,packet);
  4267.         logprintf("ERROR line %d invalid length of %u bytes for %s"
  4268.             ,__LINE__,filelength(fmsg),packet);
  4269.         fclose(fidomsg);
  4270.         if(delfile(packet))
  4271.             logprintf("ERROR line %d removing %s %s",__LINE__,packet
  4272.                 ,sys_errlist[errno]);
  4273.         continue; }
  4274.     if(fread(&pkthdr,sizeof(pkthdr_t),1,fidomsg)!=1) {
  4275.         fclose(fidomsg);
  4276.         printf("\7ERROR reading %u bytes from %s\n",sizeof(pkthdr_t),packet);
  4277.         logprintf("ERROR line %d reading %u bytes from %s",__LINE__
  4278.             ,sizeof(pkthdr_t),packet);
  4279.         continue; }
  4280.     if((ddtol(ff.wr_time,ff.wr_date)+(60L*60L))<=time(NULL)) {
  4281.         fseek(fidomsg,-3L,SEEK_END);
  4282.         fread(str,3,1,fidomsg);
  4283.         if(str[2])                        /* No ending NULL, probably junk */
  4284.             fputc(0,fidomsg);
  4285.         if(str[1])
  4286.             fputc(0,fidomsg);
  4287.         if(str[0])
  4288.             fputc(0,fidomsg);
  4289.         fclose(fidomsg);
  4290.         pkt_faddr.zone=pkthdr.destzone;
  4291.         pkt_faddr.net=pkthdr.destnet;
  4292.         pkt_faddr.node=pkthdr.destnode;
  4293.         pkt_faddr.point=0;                /* No point info in the 2.0 hdr! */
  4294.         memcpy(&two_plus,&pkthdr.empty,20);
  4295.         if(two_plus.cword==_rotr(two_plus.cwcopy,8)  /* 2+ Packet Header */
  4296.             && two_plus.cword && two_plus.cword&1)
  4297.             pkt_faddr.point=two_plus.destpoint;
  4298.         else if(pkthdr.baud==2) {                /* Type 2.2 Packet Header */
  4299.             memcpy(&two_two,&pkthdr.empty,20);
  4300.             pkt_faddr.point=pkthdr.month; }
  4301.         printf("Sending to %s\n",faddrtoa(pkt_faddr));
  4302.         pack_bundle(packet,pkt_faddr); }
  4303.     else {
  4304.         fclose(fidomsg);
  4305.         printf("Possibly still in use\n"); } }
  4306. #ifdef __WATCOMC__
  4307. _dos_findclose(&ff);
  4308. #endif
  4309.  
  4310. if(misc&IMPORT_PACKETS) {
  4311.  
  4312. printf("\nScanning for Inbound Packets...\n");
  4313.  
  4314. /* We want to loop while there are bundles waiting for us, but first we want */
  4315. /* to take care of any packets that may already be hanging around for some     */
  4316. /* reason or another (thus the do/while loop) */
  4317.  
  4318. echomail=0;
  4319. for(secure=0;secure<2;secure++) {
  4320.     if(secure && !cfg.secure[0])
  4321.         break;
  4322. do {
  4323. /****** START OF IMPORT PKT ROUTINE ******/
  4324.  
  4325. sprintf(path,"%s*.PKT",secure ? cfg.secure : cfg.inbound);
  4326. for(l=_dos_findfirst(path,0,&ff);!l && !kbhit();l=_dos_findnext(&ff)) {
  4327.  
  4328.     sprintf(packet,"%s%s",secure ? cfg.secure : cfg.inbound,ff.name);
  4329.  
  4330.     if((fidomsg=fnopen(&fmsg,packet,O_RDWR))==NULL) {
  4331.         printf("\7ERROR opening %s\n",packet);
  4332.         logprintf("ERROR line %d opening %s %s",__LINE__,packet
  4333.             ,sys_errlist[errno]);
  4334.         continue; }
  4335.     if(filelength(fmsg)<sizeof(pkthdr_t)) {
  4336.         printf("\7Invalid length of %u bytes\n",filelength(fmsg));
  4337.         fclose(fidomsg);
  4338.         continue; }
  4339.  
  4340.     fseek(fidomsg,-2L,SEEK_END);
  4341.     fread(str,2,1,fidomsg);
  4342.     if((str[0] || str[1]) &&
  4343.         (ddtol(ff.wr_time,ff.wr_date)+(48L*60L*60L))<=time(NULL)) {
  4344.         fclose(fidomsg);
  4345.         printf("\7ERROR packet %s not terminated correctly\n",packet);
  4346.         logprintf("ERROR line %d packet %s not terminated correctly",__LINE__
  4347.             ,packet);
  4348.         continue; }
  4349.     fseek(fidomsg,0L,SEEK_SET);
  4350.     if(fread(&pkthdr,sizeof(pkthdr_t),1,fidomsg)!=1) {
  4351.         fclose(fidomsg);
  4352.         printf("\7ERROR reading %u bytes\n",sizeof(pkthdr_t));
  4353.         logprintf("ERROR line %d reading %u bytes from %s",__LINE__
  4354.             ,sizeof(pkthdr_t),packet);
  4355.         continue; }
  4356.  
  4357.     pkt_faddr.zone=pkthdr.origzone ? pkthdr.origzone:sys_faddr.zone;
  4358.     pkt_faddr.net=pkthdr.orignet;
  4359.     pkt_faddr.node=pkthdr.orignode;
  4360.     pkt_faddr.point=0;
  4361.  
  4362.     printf("%21s: %s "
  4363.         ,secure ? "Importing Secure Pkt" : "Importing Packet",ff.name);
  4364.     memcpy(&two_plus,&pkthdr.empty,20);
  4365.     if(two_plus.cword==_rotr(two_plus.cwcopy,8)  /* 2+ Packet Header */
  4366.         && two_plus.cword && two_plus.cword&1) {
  4367.         pkt_type=PKT_TWO_PLUS;
  4368.         pkt_faddr.point=two_plus.origpoint ? two_plus.origpoint:0;
  4369.         if(pkt_faddr.point && pkthdr.orignet==-1)
  4370.             pkt_faddr.net=two_plus.auxnet ? two_plus.auxnet:sys_faddr.zone;
  4371.         printf("(Type 2+)");
  4372.         if(cfg.log&LOG_PACKETS)
  4373.             logprintf("Importing %s%s (Type 2+) from %s"
  4374.                 ,secure ? "(secure) ":"",ff.name,faddrtoa(pkt_faddr)); }
  4375.     else if(pkthdr.baud==2) {                /* Type 2.2 Packet Header */
  4376.         pkt_type=PKT_TWO_TWO;
  4377.         memcpy(&two_two,&pkthdr.empty,20);
  4378.         pkt_faddr.point=pkthdr.year ? pkthdr.year:0;
  4379.         printf("(Type 2.2)");
  4380.         if(cfg.log&LOG_PACKETS)
  4381.             logprintf("Importing %s%s (Type 2.2) from %s"
  4382.                 ,secure ? "(secure) ":"",ff.name,faddrtoa(pkt_faddr)); }
  4383.     else {
  4384.         pkt_type=PKT_TWO;
  4385.         printf("(Type 2)");
  4386.         if(cfg.log&LOG_PACKETS)
  4387.             logprintf("Importing %s%s (Type 2) from %s"
  4388.                 ,secure ? "(secure) ":"",ff.name,faddrtoa(pkt_faddr)); }
  4389.  
  4390.     printf(" from %s\n",faddrtoa(pkt_faddr));
  4391.  
  4392.     if(misc&SECURE) {
  4393.         k=matchnode(pkt_faddr,1);
  4394.         if(k<cfg.nodecfgs && cfg.nodecfg[k].pktpwd[0] &&
  4395.             stricmp(pkthdr.password,cfg.nodecfg[k].pktpwd)) {
  4396.             sprintf(str,"Packet %s from %s - "
  4397.                 "Incorrect password ('%s' instead of '%s')"
  4398.                 ,ff.name,faddrtoa(pkt_faddr)
  4399.                 ,pkthdr.password,cfg.nodecfg[k].pktpwd);
  4400.             printf("Security Violation (Incorrect Password)\n");
  4401.             if(cfg.log&LOG_SECURITY)
  4402.                 logprintf(str);
  4403.             fclose(fidomsg);
  4404.             continue; } }
  4405.  
  4406.     while(!feof(fidomsg)) {
  4407.  
  4408.         memset(&hdr,0,sizeof(fmsghdr_t));
  4409.  
  4410.         if(start_tick)
  4411.             import_ticks+=clock()-start_tick;
  4412.         start_tick=clock();
  4413.  
  4414.         if(fmsgbuf) {
  4415.             FREE(fmsgbuf);
  4416.             fmsgbuf=0; }
  4417.         if(misc&CHECKMEM)
  4418.             checkmem();
  4419.         if(!fread(&ch,1,1,fidomsg))          /* Message type (0200h) */
  4420.             break;
  4421.         if(ch!=02)
  4422.             continue;
  4423.         if(!fread(&ch,1,1,fidomsg))
  4424.             break;
  4425.         if(ch!=00)
  4426.             continue;
  4427.         fread(&hdr.orignode,2,1,fidomsg);
  4428.         fread(&hdr.destnode,2,1,fidomsg);
  4429.         fread(&hdr.orignet,2,1,fidomsg);
  4430.         fread(&hdr.destnet,2,1,fidomsg);
  4431.         fread(&hdr.attr,2,1,fidomsg);
  4432.         fread(&hdr.cost,2,1,fidomsg);
  4433.  
  4434.         grunged=0;
  4435.  
  4436.         for(i=0;i<sizeof(hdr.time);i++)         /* Read in the Date/Time */
  4437.             if(!fread(hdr.time+i,1,1,fidomsg) || !hdr.time[i])
  4438.                 break;
  4439.         if(i==sizeof(hdr.time)) grunged=1;
  4440.  
  4441.         for(i=0;!grunged && i<sizeof(hdr.to);i++) /* Read in the 'To' Field */
  4442.             if(!fread(hdr.to+i,1,1,fidomsg) || !hdr.to[i])
  4443.                 break;
  4444.         if(i==sizeof(hdr.to)) grunged=1;
  4445.  
  4446.         for(i=0;!grunged && i<sizeof(hdr.from);i++) /* Read in 'From' Field */
  4447.             if(!fread(hdr.from+i,1,1,fidomsg) || !hdr.from[i])
  4448.                 break;
  4449.         if(i==sizeof(hdr.from)) grunged=1;
  4450.  
  4451.         for(i=0;!grunged && i<sizeof(hdr.subj);i++) /* Read in 'Subj' Field */
  4452.             if(!fread(hdr.subj+i,1,1,fidomsg) || !hdr.subj[i])
  4453.                 break;
  4454.         if(i==sizeof(hdr.subj)) grunged=1;
  4455.  
  4456.         str[0]=0;
  4457.         for(i=0;!grunged && i<sizeof(str);i++)    /* Read in the 'AREA' Field */
  4458.             if(!fread(str+i,1,1,fidomsg) || str[i]==CR)
  4459.                 break;
  4460.         if(i<sizeof(str))
  4461.             str[i]=0;
  4462.         else
  4463.             grunged=1;
  4464.  
  4465.         if(!str[0] || grunged) {
  4466.             start_tick=0;
  4467.             if(cfg.log&LOG_GRUNGED)
  4468.                 logprintf("Grunged message");
  4469.             seektonull(fidomsg);
  4470.             printf("Grunged message!\n");
  4471.             continue; }
  4472.  
  4473.         if(i)
  4474.             fseek(fidomsg,(long)-(i+1),SEEK_CUR);
  4475.  
  4476.         truncsp(str);
  4477.         strupr(str);
  4478.         p=strstr(str,"AREA:");
  4479.         if(!p) {                    /* Netmail */
  4480.             start_tick=0;
  4481.             if(import_netmail("",hdr,fidomsg))
  4482.                 seektonull(fidomsg);
  4483.             printf("\n");
  4484.             continue; }
  4485.  
  4486.         if(!(misc&IMPORT_ECHOMAIL)) {
  4487.             start_tick=0;
  4488.             printf("EchoMail Ignored");
  4489.             seektonull(fidomsg);
  4490.             printf("\n");
  4491.             continue; }
  4492.  
  4493.         p+=5;                                /* Skip "AREA:" */
  4494.         while(*p && *p<=SP) p++;            /* Skip any white space */
  4495.         printf("%21s: ",p);                 /* Show areaname: */
  4496.         sprintf(areatagstr,"%.128s",p);
  4497.         strupr(p);
  4498.         areatag=crc32(p);
  4499.  
  4500.         for(i=0;i<cfg.areas;i++)                /* Do we carry this area? */
  4501.             if(cfg.area[i].tag==areatag) {
  4502.                 if(cfg.area[i].sub!=INVALID_SUB)
  4503.                     printf("%s ",sub[cfg.area[i].sub]->code);
  4504.                 else
  4505.                     printf("(Passthru) ");
  4506.                 fmsgbuf=getfmsg(fidomsg,NULL);
  4507.                 gen_psb(&msg_seen,&msg_path,fmsgbuf,pkthdr.destzone);
  4508.                 break; }
  4509.  
  4510.         if(i==cfg.areas) {
  4511.             printf("(Unknown) ");
  4512.             if(cfg.badecho>=0) {
  4513.                 i=cfg.badecho;
  4514.                 if(cfg.area[i].sub!=INVALID_SUB)
  4515.                     printf("%s ",sub[cfg.area[i].sub]->code);
  4516.                 else
  4517.                     printf("(Passthru) ");
  4518.                 fmsgbuf=getfmsg(fidomsg,NULL);
  4519.                 gen_psb(&msg_seen,&msg_path,fmsgbuf,pkthdr.destzone); }
  4520.             else {
  4521.                 start_tick=0;
  4522.                 printf("Skipped\n");
  4523.                 seektonull(fidomsg);
  4524.                 continue; } }
  4525.  
  4526.         if(misc&SECURE && cfg.area[i].sub!=INVALID_SUB) {
  4527.             for(j=0;j<cfg.area[i].uplinks;j++)
  4528.                 if(!memcmp(&cfg.area[i].uplink[j],&pkt_faddr,sizeof(faddr_t)))
  4529.                     break;
  4530.             if(j==cfg.area[i].uplinks) {
  4531.                 if(cfg.log&LOG_SECURITY)
  4532.                     logprintf("%s: Security violation - %s not in AREAS.BBS"
  4533.                         ,areatagstr,faddrtoa(pkt_faddr));
  4534.                 printf("Security Violation (Not in AREAS.BBS)\n");
  4535.                 seektonull(fidomsg);
  4536.                 continue; } }
  4537.  
  4538.         /* From here on out, i = area number and area[i].sub = sub number */
  4539.  
  4540.         memcpy(&curarea,&cfg.area[i],sizeof(areasbbs_t));
  4541.         curarea.name=areatagstr;
  4542.  
  4543.         if(cfg.area[i].sub==INVALID_SUB) {            /* Passthru */
  4544.             start_tick=0;
  4545.             strip_psb(fmsgbuf);
  4546.             pkt_to_pkt(fmsgbuf,curarea,pkt_faddr,hdr,msg_seen,msg_path,0);
  4547.             printf("\n");
  4548.             continue; }                         /* On to the next message */
  4549.  
  4550.  
  4551.         for(j=0;j<total_faddrs;j++)
  4552.             if(check_psb(msg_path,faddr[j]))
  4553.                 break;
  4554.         if(j<total_faddrs) {
  4555.             start_tick=0;
  4556.             printf("Circular path (%s) ",faddrtoa(faddr[j]));
  4557.             cfg.area[i].circular++;
  4558.             if(cfg.log&LOG_CIRCULAR)
  4559.                 logprintf("%s: Circular path detected for %s"
  4560.                     ,areatagstr,faddrtoa(faddr[j]));
  4561.             strip_psb(fmsgbuf);
  4562.             pkt_to_pkt(fmsgbuf,curarea,pkt_faddr,hdr,msg_seen,msg_path,0);
  4563.             printf("\n");
  4564.             continue; }
  4565.  
  4566. #if 0 // Allen's way (broken?)
  4567.         for(j=0;j<num_open;j++)
  4568.             if(openbase[j]==cfg.area[i].sub)
  4569.                 break;
  4570.         if(j && j<num_open) {
  4571.             cur_smb=j;
  4572.             k=openbase[0];
  4573.             openbase[0]=openbase[j];
  4574.             openbase[j]=k; }
  4575.         else if(j && j==num_open && j<MAX_OPEN_SMBS) {
  4576.             cur_smb=j;
  4577.             openbase[j]=openbase[0];
  4578.             openbase[0]=INVALID_SUB; }
  4579.         else if(j==num_open && j>=MAX_OPEN_SMBS) {
  4580.             cur_smb=j-1;
  4581.             k=openbase[0];
  4582.             openbase[0]=openbase[j-1];
  4583.             openbase[j-1]=k; }
  4584.  
  4585.         if(openbase[0]!=cfg.area[i].sub) {
  4586.             if(openbase[0]!=INVALID_SUB) {
  4587.                 smb_close(&smb[cur_smb]);
  4588.                 --num_open; }
  4589. #endif
  4590.  
  4591.         // Rob's way
  4592.         for(j=0;j<MAX_OPEN_SMBS;j++)
  4593.             if(subnum[j]==cfg.area[i].sub)
  4594.                 break;
  4595.         if(j<MAX_OPEN_SMBS)                 /* already open */
  4596.             cur_smb=j;
  4597.         else {
  4598.             if(smb[cur_smb].shd_fp)         /* If open */
  4599.                 cur_smb=!cur_smb;            /* toggle between 0 and 1 */
  4600.             smb_close(&smb[cur_smb]);        /* close, if open */
  4601.             subnum[cur_smb]=INVALID_SUB; }    /* reset subnum (just incase) */
  4602.  
  4603.         if(smb[cur_smb].shd_fp==NULL) {     /* Currently closed */
  4604.             sprintf(smb[cur_smb].file,"%s%s",sub[cfg.area[i].sub]->data_dir
  4605.                 ,sub[cfg.area[i].sub]->code);
  4606.             smb[cur_smb].retry_time=smb_retry_time;
  4607.             if((j=smb_open(&smb[cur_smb]))!=0) {
  4608.                 sprintf(str,"ERROR %d opening %s area #%d, sub #%d)"
  4609.                     ,j,smb[cur_smb].file,i+1,cfg.area[i].sub+1);
  4610.                 printf(str);
  4611.                 logprintf(str);
  4612.                 strip_psb(fmsgbuf);
  4613.                 pkt_to_pkt(fmsgbuf,curarea,pkt_faddr,hdr,msg_seen
  4614.                     ,msg_path,0);
  4615.                 printf("\n");
  4616.                 continue; }
  4617.             if(!filelength(fileno(smb[cur_smb].shd_fp))) {
  4618.                 smb[cur_smb].status.max_crcs=sub[cfg.area[i].sub]->maxcrcs;
  4619.                 smb[cur_smb].status.max_msgs=sub[cfg.area[i].sub]->maxmsgs;
  4620.                 smb[cur_smb].status.max_age=sub[cfg.area[i].sub]->maxage;
  4621.                 smb[cur_smb].status.attr=sub[cfg.area[i].sub]->misc&SUB_HYPER
  4622.                         ? SMB_HYPERALLOC:0;
  4623.                 if((j=smb_create(&smb[cur_smb]))!=0) {
  4624.                     sprintf(str,"ERROR %d creating %s",j,smb[cur_smb].file);
  4625.                     printf(str);
  4626.                     logprintf(str);
  4627.                     smb_close(&smb[cur_smb]);
  4628.                     strip_psb(fmsgbuf);
  4629.                     pkt_to_pkt(fmsgbuf,curarea,pkt_faddr,hdr,msg_seen
  4630.                         ,msg_path,0);
  4631.                     printf("\n");
  4632.                     continue; } }
  4633.  
  4634. #if 0    // Unnecessary with SMBLIB v2.0
  4635.  
  4636.             if((j=smb_locksmbhdr(&smb[cur_smb]))!=0) {
  4637.                 printf("ERROR %d locking %s smbhdr\n",j,smb[cur_smb].file);
  4638.                 logprintf("ERROR %d line %d locking %s smbhdr",j,__LINE__
  4639.                     ,smb[cur_smb].file);
  4640.                 smb_close(&smb[cur_smb]);
  4641.                 strip_psb(fmsgbuf);
  4642.                 pkt_to_pkt(fmsgbuf,curarea,pkt_faddr,hdr,msg_seen
  4643.                     ,msg_path,0);
  4644.                 printf("\n");
  4645.                 continue; }
  4646.  
  4647.             if((j=smb_getstatus(&smb[cur_smb]))!=0) {
  4648.                 sprintf(str,"ERROR %d reading %s SMB header",j
  4649.                     ,smb[cur_smb].file);
  4650.                 printf(str);
  4651.                 logprintf(str);
  4652.                 smb_unlocksmbhdr(&smb[cur_smb]);
  4653.                 smb_close(&smb[cur_smb]);
  4654.                 strip_psb(fmsgbuf);
  4655.                 pkt_to_pkt(fmsgbuf,curarea,pkt_faddr,hdr,msg_seen
  4656.                     ,msg_path,0);
  4657.                 printf("\n");
  4658.                 continue; }
  4659.  
  4660.             smb_unlocksmbhdr(&smb[cur_smb]);
  4661. #endif
  4662.             //openbase[0]=cfg.area[i].sub;
  4663.             //++num_open;
  4664.             subnum[cur_smb]=cfg.area[i].sub;
  4665.             }
  4666.  
  4667.         if(hdr.attr&FIDO_PRIVATE && !(sub[cfg.area[i].sub]->misc&SUB_PRIV)) {
  4668.             if(misc&IMPORT_PRIVATE)
  4669.                 hdr.attr&=~FIDO_PRIVATE;
  4670.             else {
  4671.                 start_tick=0;
  4672.                 printf("Private posts disallowed.");
  4673.                 if(cfg.log&LOG_PRIVATE)
  4674.                     logprintf("%s: Private posts disallowed"
  4675.                         ,areatagstr);
  4676.                 strip_psb(fmsgbuf);
  4677.                 pkt_to_pkt(fmsgbuf,curarea,pkt_faddr,hdr,msg_seen
  4678.                     ,msg_path,0);
  4679.                 printf("\n");
  4680.                 continue; } }
  4681.  
  4682.         if(!(hdr.attr&FIDO_PRIVATE) && sub[cfg.area[i].sub]->misc&SUB_PONLY)
  4683.             hdr.attr|=MSG_PRIVATE;
  4684.  
  4685.         /**********************/
  4686.         /* Importing EchoMail */
  4687.         /**********************/
  4688.         j=fmsgtosmsg(fmsgbuf,hdr,0,cfg.area[i].sub);
  4689.  
  4690.         if(start_tick) {
  4691.             import_ticks+=clock()-start_tick;
  4692.             start_tick=0; }
  4693.  
  4694.         if(j==-1) {
  4695.             if(cfg.log&LOG_DUPES)
  4696.                 logprintf("%s Duplicate message",areatagstr);
  4697.             cfg.area[i].dupes++; }
  4698.         else {       /* Not a dupe */
  4699.             strip_psb(fmsgbuf);
  4700.             pkt_to_pkt(fmsgbuf,curarea,pkt_faddr
  4701.                 ,hdr,msg_seen,msg_path,0); }
  4702.  
  4703.         if(j==1) {        /* Successful import */
  4704.             echomail++;
  4705.             cfg.area[i].imported++;
  4706.             if(misc&NOTIFY_RECEIPT && (m=matchname(hdr.to))!=0) {
  4707.                 sprintf(str
  4708.                 ,"\7\1n\1hSBBSecho: \1m%.36s \1n\1msent you EchoMail on "
  4709.                     "\1h%s \1n\1m%s\1n\r\n"
  4710.                     ,hdr.from
  4711.                     ,grp[sub[cfg.area[i].sub]->grp]->sname
  4712.                     ,sub[cfg.area[i].sub]->sname);
  4713.                 putsmsg(m,str); } }
  4714.         printf("\n");
  4715.         }
  4716.     fclose(fidomsg);
  4717.     if(misc&DELETE_PACKETS)
  4718.         if(delfile(packet))
  4719.             logprintf("ERROR line %d removing %s %s",__LINE__,packet
  4720.                 ,sys_errlist[errno]); }
  4721. #ifdef __WATCOMC__
  4722. _dos_findclose(&ff);
  4723. #endif
  4724.  
  4725. if(start_tick) {
  4726.     import_ticks+=clock()-start_tick;
  4727.     start_tick=0; }
  4728.  
  4729. } while(!kbhit() && unpack_bundle());
  4730.  
  4731. if(kbhit()) printf("\nKey pressed - premature termination\n");
  4732. while(kbhit()) getch();
  4733.  
  4734. }    /* End of Secure : Inbound loop */
  4735.  
  4736. if(start_tick)    /* Last possible increment of import_ticks */
  4737.     import_ticks+=clock()-start_tick;
  4738.  
  4739. for(j=MAX_OPEN_SMBS;j>0;j--)        /* Close open bases */
  4740.     if(smb[j].shd_fp)
  4741.         smb_close(&smb[j]);
  4742.  
  4743. pkt_to_pkt(fmsgbuf,fakearea,pkt_faddr,hdr,msg_seen,msg_path,1);
  4744.  
  4745. /******* END OF IMPORT PKT ROUTINE *******/
  4746.  
  4747. if(cfg.log&LOG_AREA_TOTALS) {
  4748.     for(i=0;i<cfg.areas;i++) {
  4749.         if(cfg.area[i].imported)
  4750.             logprintf("Imported: %5u msgs %8s <- %s"
  4751.                 ,cfg.area[i].imported,sub[cfg.area[i].sub]->code
  4752.                 ,cfg.area[i].name); }
  4753.     for(i=0;i<cfg.areas;i++) {
  4754.         if(cfg.area[i].circular)
  4755.             logprintf("Circular: %5u detected in %s"
  4756.                 ,cfg.area[i].circular,cfg.area[i].name); }
  4757.     for(i=0;i<cfg.areas;i++) {
  4758.         if(cfg.area[i].dupes)
  4759.             logprintf("Duplicate: %5u detected in %s"
  4760.                 ,cfg.area[i].dupes,cfg.area[i].name); } }
  4761.  
  4762. import_time=((float)import_ticks)/(float)CLK_TCK;
  4763. if(cfg.log&LOG_TOTALS && import_time && echomail) {
  4764.     printf("\nImported %lu EchoMail messages in %.1f seconds "
  4765.         ,echomail,import_time);
  4766.     logprintf("Imported: %5lu msgs in %.1f sec (%.1f/min %.1f/sec)"
  4767.         ,echomail,import_time
  4768.         ,import_time/60.0 ? (float)echomail/(import_time/60.0) :(float)echomail
  4769.         ,(float)echomail/import_time);
  4770.     if(import_time/60.0)
  4771.         printf("(%.1f/min) ",(float)echomail/(import_time/60.0));
  4772.     printf("(%.1f/sec)\n",(float)echomail/import_time); }
  4773. if(fmsgbuf) {
  4774.     FREE(fmsgbuf);
  4775.     fmsgbuf=0; }
  4776.  
  4777. }
  4778.  
  4779. if(misc&IMPORT_NETMAIL) {
  4780.  
  4781. printf("\nScanning for Inbound NetMail Messages...\n");
  4782.  
  4783. sprintf(str,"%s*.MSG",netmail_dir);
  4784.  
  4785. for(last=_dos_findfirst(str,0,&ff);!last;last=_dos_findnext(&ff)) {
  4786.     sprintf(path,"%s%s",netmail_dir,ff.name);
  4787.     strupr(path);
  4788.     if((fidomsg=fnopen(&fmsg,path,O_RDWR))==NULL) {
  4789.         printf("\7ERROR opening %s\n",path);
  4790.         logprintf("ERROR line %d opening %s %s",__LINE__,path
  4791.             ,sys_errlist[errno]);
  4792.         continue; }
  4793.     if(filelength(fmsg)<sizeof(fmsghdr_t)) {
  4794.         printf("\7ERROR invalid length of %u bytes for %s\n",filelength(fmsg)
  4795.             ,path);
  4796.         logprintf("ERROR line %d invalid length of %u bytes for %s",__LINE__
  4797.             ,filelength(fmsg),path);
  4798.         fclose(fidomsg);
  4799.         continue; }
  4800.     if(fread(&hdr,sizeof(fmsghdr_t),1,fidomsg)!=1) {
  4801.         fclose(fidomsg);
  4802.         printf("\7ERROR reading %u bytes from %s"
  4803.             ,sizeof(fmsghdr_t),path);
  4804.         logprintf("ERROR line %d reading %u bytes from %s",__LINE__
  4805.             ,sizeof(fmsghdr_t),path);
  4806.         continue; }
  4807.     i=import_netmail(path,hdr,fidomsg);
  4808.     /**************************************/
  4809.     /* Delete source netmail if specified */
  4810.     /**************************************/
  4811.     if(i==0) {
  4812.         if(misc&DELETE_NETMAIL) {
  4813.             fclose(fidomsg);
  4814.             if(delfile(path))
  4815.                 logprintf("ERROR line %d removing %s %s",__LINE__,path
  4816.                     ,sys_errlist[errno]); }
  4817.         else {
  4818.             hdr.attr|=FIDO_RECV;
  4819.             fseek(fidomsg,0L,SEEK_SET);
  4820.             fwrite(&hdr,sizeof(fmsghdr_t),1,fidomsg);
  4821.             fclose(fidomsg); } }
  4822.     else if(i!=-2)
  4823.         fclose(fidomsg);
  4824.     printf("\n"); }
  4825. #ifdef __WATCOMC__
  4826. _dos_findclose(&ff);
  4827. #endif
  4828. }
  4829.  
  4830.  
  4831. if(misc&EXPORT_ECHOMAIL) {
  4832.     memset(&addr,0,sizeof(faddr_t));
  4833.     export_echomail(sub_code,addr);
  4834. }
  4835.  
  4836.  
  4837. if(misc&PACK_NETMAIL) {
  4838.  
  4839. memset(&msg_seen,0,sizeof(addrlist_t));
  4840. memset(&msg_path,0,sizeof(addrlist_t));
  4841. memset(&fakearea,0,sizeof(areasbbs_t));
  4842.  
  4843. printf("\nPacking Outbound NetMail...\n");
  4844.  
  4845. sprintf(str,"%s*.MSG",netmail_dir);
  4846.  
  4847. for(last=_dos_findfirst(str,0,&ff);!last;last=_dos_findnext(&ff)) {
  4848.     sprintf(path,"%s%s",netmail_dir,ff.name);
  4849.     strupr(path);
  4850.     if((fidomsg=fnopen(&fmsg,path,O_RDWR))==NULL) {
  4851.         printf("\7ERROR opening %s\n",path);
  4852.         logprintf("ERROR line %d opening %s %s",__LINE__,path
  4853.             ,sys_errlist[errno]);
  4854.         continue; }
  4855.     if(filelength(fmsg)<sizeof(fmsghdr_t)) {
  4856.         printf("\7%s Invalid length of %u bytes\n",path,filelength(fmsg));
  4857.         fclose(fidomsg);
  4858.         continue; }
  4859.     if(fread(&hdr,sizeof(fmsghdr_t),1,fidomsg)!=1) {
  4860.         fclose(fidomsg);
  4861.         printf("\7ERROR reading %u bytes from %s"
  4862.             ,sizeof(fmsghdr_t),path);
  4863.         logprintf("ERROR line %d reading %u bytes from %s",__LINE__
  4864.             ,sizeof(fmsghdr_t),path);
  4865.         continue; }
  4866.     hdr.destzone=hdr.origzone=sys_faddr.zone;
  4867.     hdr.destpoint=hdr.origpoint=0;
  4868.     getzpt(fidomsg,&hdr);                /* use kludge if found */
  4869.     addr.zone=hdr.destzone;
  4870.     addr.net=hdr.destnet;
  4871.     addr.node=hdr.destnode;
  4872.     addr.point=hdr.destpoint;
  4873.     for(i=0;i<total_faddrs;i++)
  4874.         if(!memcmp(&addr,&faddr[i],sizeof(faddr_t)))
  4875.             break;
  4876.     if(i<total_faddrs)                      /* In-bound, so ignore */
  4877.         continue;
  4878.     printf("\n%s to %s ",path,faddrtoa(addr));
  4879.     if(cfg.log&LOG_PACKING)
  4880.         logprintf("Packing %s (%s)",path,faddrtoa(addr));
  4881.     fmsgbuf=getfmsg(fidomsg,NULL);
  4882.     if(!fmsgbuf) {
  4883.         printf("ERROR allocating memory for NetMail fmsgbuf\n");
  4884.         logprintf("ERROR line %d allocating memory for NetMail fmsgbuf"
  4885.             ,__LINE__);
  4886.         exit(1); }
  4887.     fclose(fidomsg);
  4888.  
  4889.     if(misc&FLO_MAILER) {
  4890.         attr=0;
  4891.         i=matchnode(addr,0);
  4892.         if(i<cfg.nodecfgs)
  4893.             if(cfg.nodecfg[i].route.zone
  4894.                 && !(hdr.attr&(FIDO_CRASH|FIDO_HOLD))) {
  4895.                 addr=cfg.nodecfg[i].route;        /* Routed */
  4896.                 if(cfg.log&LOG_ROUTING)
  4897.                     logprintf("Routing %s to %s",path,faddrtoa(addr));
  4898.                 i=matchnode(addr,0); }
  4899.         if(i<cfg.nodecfgs)
  4900.             attr=cfg.nodecfg[i].attr;
  4901.         if(hdr.attr&FIDO_CRASH)
  4902.             attr|=ATTR_CRASH;
  4903.         else if(hdr.attr&FIDO_HOLD)
  4904.             attr|=ATTR_HOLD;
  4905.         if(attr&ATTR_CRASH) ch='C';
  4906.         else if(attr&ATTR_HOLD) ch='H';
  4907.         else if(attr&ATTR_DIRECT) ch='D';
  4908.         else ch='O';
  4909.         if(addr.zone==faddr[0].zone) /* Default zone, use default outbound */
  4910.             strcpy(outbound,cfg.outbound);
  4911.         else                         /* Inter-zone outbound is OUTBOUND.XXX */
  4912.             sprintf(outbound,"%.*s.%03X\\"
  4913.                 ,strlen(cfg.outbound)-1,cfg.outbound,addr.zone);
  4914.         if(addr.point) {            /* Point destination is OUTBOUND.PNT */
  4915.             sprintf(str,"%04X%04X.PNT"
  4916.                 ,addr.net,addr.node);
  4917.             strcat(outbound,str); }
  4918.         if(outbound[strlen(outbound)-1]=='\\')
  4919.             outbound[strlen(outbound)-1]=0;
  4920.         mkdir(outbound);
  4921.         strcat(outbound,"\\");
  4922.         if(addr.point)
  4923.             sprintf(packet,"%s%08X.%cUT",outbound,addr.point,ch);
  4924.         else
  4925.             sprintf(packet,"%s%04X%04X.%cUT",outbound,addr.net,addr.node,ch);
  4926.         if(hdr.attr&FIDO_FILE)
  4927.             if(write_flofile(hdr.subj,addr))
  4928.                 exit(1); }
  4929.     else
  4930.         strcpy(packet,pktname());
  4931.  
  4932.     now=time(NULL);
  4933.     tm=gmtime(&now);
  4934.     if((stream=fnopen(&file,packet,O_WRONLY|O_APPEND|O_CREAT))==NULL) {
  4935.         printf("Unable to open %s for write.\n"
  4936.             ,packet);
  4937.         logprintf("ERROR line %d opening %s %s",__LINE__,packet
  4938.             ,sys_errlist[errno]);
  4939.         exit(1); }
  4940.  
  4941.     if(!filelength(file)) {
  4942.         pkthdr.orignode=hdr.orignode;
  4943.         pkthdr.destnode=hdr.destnode;
  4944.         pkthdr.year=tm->tm_year;
  4945.         pkthdr.month=tm->tm_mon;
  4946.         pkthdr.day=tm->tm_mday;
  4947.         pkthdr.hour=tm->tm_hour;
  4948.         pkthdr.min=tm->tm_min;
  4949.         pkthdr.sec=tm->tm_sec;
  4950.         pkthdr.baud=0x00;
  4951.         pkthdr.pkttype=0x0002;
  4952.         pkthdr.orignet=hdr.orignet;
  4953.         pkthdr.destnet=hdr.destnet;
  4954.         pkthdr.prodcode=0x00;
  4955.         pkthdr.sernum=0;
  4956.         i=matchnode(addr,0);
  4957.         if(i<cfg.nodecfgs)
  4958.             memcpy(pkthdr.password,cfg.nodecfg[i].pktpwd,8);
  4959.         else
  4960.             memset(pkthdr.password,0,8);
  4961.         pkthdr.origzone=hdr.origzone;
  4962.         pkthdr.destzone=hdr.destzone;
  4963.         memset(pkthdr.empty,0,20);
  4964.         fwrite(&pkthdr,sizeof(pkthdr_t),1,stream); }
  4965.  
  4966.     putfmsg(stream,fmsgbuf,hdr,fakearea,msg_seen,msg_path);
  4967.  
  4968.     FREE(fmsgbuf);
  4969.     fclose(stream);
  4970.     /**************************************/
  4971.     /* Delete source netmail if specified */
  4972.     /**************************************/
  4973.     if(misc&DELETE_NETMAIL)
  4974.         if(delfile(path))
  4975.             logprintf("ERROR line %d removing %s %s",__LINE__,path
  4976.                 ,sys_errlist[errno]);
  4977.     printf("\n"); }
  4978. #ifdef __WATCOMC__
  4979. _dos_findclose(&ff);
  4980. #endif
  4981. }
  4982.  
  4983.  
  4984. if(misc&UPDATE_MSGPTRS) {
  4985.  
  4986. printf("\nUpdating Message Pointers to Last Posted Message...\n");
  4987.  
  4988. for(g=0;g<total_grps;g++)
  4989. for(i=0;i<total_subs;i++)
  4990.     if(sub[i]->misc&SUB_FIDO && sub[i]->grp==g) {
  4991.         printf("\n%-15.15s %s\n"
  4992.             ,grp[sub[i]->grp]->sname,sub[i]->lname);
  4993.         getlastmsg(i,&l,0);
  4994.         sprintf(str,"%s%s.SFP",sub[i]->data_dir,sub[i]->code);
  4995.         if((file=nopen(str,O_WRONLY|O_CREAT))==-1) {
  4996.             printf("\7ERROR opening/creating %s",str);
  4997.             logprintf("ERROR line %d opening/creating %s",__LINE__,str); }
  4998.         else {
  4999.             write(file,&l,sizeof(time_t));
  5000.             close(file); } } }
  5001.  
  5002. if(misc&(IMPORT_NETMAIL|IMPORT_ECHOMAIL) && misc&REPORT) {
  5003.     now=time(NULL);
  5004.     sprintf(str,"%sSBBSECHO.MSG",text_dir);
  5005.     if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
  5006.         printf("ERROR opening %s\n",str);
  5007.         logprintf("ERROR line %d opening %s",__LINE__,str);
  5008.         exit(1); }
  5009.     sprintf(fname,"\1c\1h               "
  5010.         "▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄\r\n");
  5011.     sprintf(path,"\1c\1h               "
  5012.         "▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀\r\n");
  5013.     write(file,fname,strlen(fname));
  5014.     sprintf(str,"               \1n\1k\0016"
  5015.         " Last FidoNet Transfer on %.24s \1n\r\n",ctime(&now));
  5016.     write(file,str,strlen(str));
  5017.     write(file,path,strlen(path));
  5018.     write(file,fname,strlen(fname));
  5019.     sprintf(tmp,"Imported %lu EchoMail and %lu NetMail Messages"
  5020.         ,echomail,netmail);
  5021.     sprintf(str,"               \1n\1k\0016 %-50.50s\1n\r\n",tmp);
  5022.     write(file,str,strlen(str));
  5023.     write(file,path,strlen(path));
  5024.     close(file); }
  5025.  
  5026. pkt_to_pkt(buf,fakearea,pkt_faddr,hdr,msg_seen,msg_path,1);
  5027. if(email->shd_fp)
  5028.     smb_close(email);
  5029. FREE(smb);
  5030. FREE(email);
  5031. return(0);
  5032. }
  5033.