Return to sbbsecho.c CVS log

Up to [Synchronet] / sbbs / sbbs2 / echo

Annotation of sbbs/sbbs2/echo/sbbsecho.c, revision 1.1

1.1     ! root        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: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.