Annotation of sbbs/sbbs2/smm/smm2msg.c, revision 1.1

1.1     ! root        1: /* SMM2MSG.C */
        !             2: 
        !             3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
        !             4: 
        !             5: /* Scans SMM database and posts any additions/updates into an MSG file */
        !             6: 
        !             7: #define  uint unsigned int
        !             8: 
        !             9: #include <dos.h>
        !            10: #include "smblib.h"
        !            11: #include "smmdefs.h"
        !            12: 
        !            13: #define VERSION "1.00�"
        !            14: 
        !            15: smb_t smb;
        !            16: extern int daylight=0;
        !            17: extern long timezone=0L;
        !            18: 
        !            19: unsigned _stklen=16000;                  /* Set stack size in code, not header */
        !            20: 
        !            21: uchar cryptchar(uchar ch, ulong seed)
        !            22: {
        !            23: if(ch==1)
        !            24:        return(0xfe);
        !            25: if(ch<0x20 || ch&0x80) /* Ctrl chars and ex-ASCII are not xlated */
        !            26:        return(ch);
        !            27: return(ch^(seed&0x1f));
        !            28: }
        !            29: 
        !            30: char *encrypt(uchar *str, ulong seed)
        !            31: {
        !            32:        static uchar out[1024];
        !            33:        int i,j;
        !            34: 
        !            35: j=strlen(str);
        !            36: for(i=0;i<j;i++)
        !            37:        out[i]=cryptchar(str[i],seed^(i&7));
        !            38: out[i]=0;
        !            39: return(out);
        !            40: }
        !            41: 
        !            42: /****************************************************************************/
        !            43: /* Checks the disk drive for the existence of a file. Returns 1 if it       */
        !            44: /* exists, 0 if it doesn't.                                                 */
        !            45: /****************************************************************************/
        !            46: char fexist(char *filespec)
        !            47: {
        !            48:     struct ffblk f;
        !            49: 
        !            50: if(findfirst(filespec,&f,0)==0)
        !            51:     return(1);
        !            52: return(0);
        !            53: }
        !            54: 
        !            55: 
        !            56: /****************************************************************************/
        !            57: /* Updates 16-bit "rcrc" with character 'ch'                                */
        !            58: /****************************************************************************/
        !            59: void ucrc16(uchar ch, ushort *rcrc) {
        !            60:        ushort i, cy;
        !            61:     uchar nch=ch;
        !            62:  
        !            63: for (i=0; i<8; i++) {
        !            64:     cy=*rcrc & 0x8000;
        !            65:     *rcrc<<=1;
        !            66:     if (nch & 0x80) *rcrc |= 1;
        !            67:     nch<<=1;
        !            68:     if (cy) *rcrc ^= 0x1021; }
        !            69: }
        !            70: 
        !            71: /****************************************************************************/
        !            72: /* Returns 16-crc of string (not counting terminating NULL)                            */
        !            73: /****************************************************************************/
        !            74: ushort crc16(char *str)
        !            75: {
        !            76:        int     i=0;
        !            77:        ushort  crc=0;
        !            78: 
        !            79: ucrc16(0,&crc);
        !            80: while(str[i])
        !            81:        ucrc16(str[i++],&crc);
        !            82: ucrc16(0,&crc);
        !            83: ucrc16(0,&crc);
        !            84: return(crc);
        !            85: }
        !            86: 
        !            87: 
        !            88: /****************************************************************************/
        !            89: /* Converts unix time format (long - time_t) into a char str MM/DD/YY          */
        !            90: /****************************************************************************/
        !            91: char *unixtodstr(time_t unix, char *str)
        !            92: {
        !            93:        struct time curtime;
        !            94:        struct date date;
        !            95: 
        !            96: if(!unix)
        !            97:        strcpy(str,"00/00/00");
        !            98: else {
        !            99:        unixtodos(unix,&date,&curtime);
        !           100:        if((unsigned)date.da_mon>12) {    /* DOS leap year bug */
        !           101:                date.da_mon=1;
        !           102:                date.da_year++; }
        !           103:        if((unsigned)date.da_day>31)
        !           104:                date.da_day=1;
        !           105:        sprintf(str,"%02u/%02u/%02u",date.da_mon,date.da_day
        !           106:                ,date.da_year>=2000 ? date.da_year-2000 : date.da_year-1900); }
        !           107: return(str);
        !           108: }
        !           109: 
        !           110: time_t checktime()
        !           111: {
        !           112:        struct tm tm;
        !           113: 
        !           114: memset(&tm,0,sizeof(tm));
        !           115: tm.tm_year=94;
        !           116: tm.tm_mday=1;
        !           117: return(mktime(&tm)^0x2D24BD00L);
        !           118: }
        !           119: 
        !           120: #define BUF_LEN 8192
        !           121: 
        !           122: int main(int argc, char **argv)
        !           123: {
        !           124:        uchar   str[128],tmp[128],msg_dir[128],buf[BUF_LEN],telegram[513],*p;
        !           125:        int     i,j,file;
        !           126:        ushort  xlat;
        !           127:        long    length;
        !           128:        ulong   offset;
        !           129:        time_t  last,t;
        !           130:        user_t  user,from;
        !           131:        wall_t  wall;
        !           132:     smbmsg_t msg;
        !           133:        FILE    *stream;
        !           134: 
        !           135: fprintf(stderr,"\nSMM2MSG v%s - Write SMM data to MSG - Developed 1995-1997 "
        !           136:        "Rob Swindell\n\n",VERSION);
        !           137: 
        !           138: if(checktime()) {
        !           139:     printf("Time problem!\n");
        !           140:     return(-1); }
        !           141: 
        !           142: if(argc<3) {
        !           143:        fprintf(stderr,"usage: smm2msg <smm.dab> <msg_dir>\n\n");
        !           144:        fprintf(stderr,"example: smm2msg c:\\sbbs\\xtrn\\smm\\smm.dab "
        !           145:                "c:\\im\\mail\n");
        !           146:        return(1); }
        !           147: 
        !           148: 
        !           149: strcpy(msg_dir,argv[2]);
        !           150: strupr(msg_dir);
        !           151: 
        !           152: strcpy(str,argv[1]);
        !           153: strupr(str);
        !           154: if((file=open(str,O_RDONLY|O_BINARY|O_DENYNONE))==-1) {
        !           155:        printf("error opening %s\n",str);
        !           156:        return(1); }
        !           157: if((stream=fdopen(file,"rb"))==NULL) {
        !           158:        printf("error fdopening %s\n",str);
        !           159:        return(1); }
        !           160: setvbuf(stream,NULL,_IOFBF,4096);
        !           161: 
        !           162: strcpy(tmp,str);
        !           163: p=strrchr(tmp,'.');
        !           164: if(p) {
        !           165:        (*p)=0;
        !           166:        strcat(tmp,"2MSG.DAB");
        !           167:        if((file=open(tmp,O_RDWR|O_BINARY|O_CREAT,S_IWRITE|S_IREAD))==-1) {
        !           168:                printf("error opening %s\n",str);
        !           169:                return(1); }
        !           170:        t=time(NULL);
        !           171:        if(read(file,&last,sizeof(time_t))!=sizeof(time_t))
        !           172:                last=0;
        !           173:        lseek(file,0L,SEEK_SET);
        !           174:        write(file,&t,sizeof(time_t));
        !           175:        close(file); }
        !           176: 
        !           177: //sprintf(str,"%s.SHD",smb.file);
        !           178: //if(!fexist(str)) {
        !           179: //       printf("%s doesn't exist\n",smb.file);
        !           180: //       return(0); }
        !           181: //fprintf(stderr,"Opening %s\n",smb.file);
        !           182: //smb.retry_time=30;
        !           183: //if((i=smb_open(&smb))!=0) {
        !           184: //       printf("smb_open returned %d\n",i);
        !           185: //       return(1); }
        !           186: 
        !           187: strcpy(str,argv[1]);
        !           188: strupr(str);
        !           189: p=strrchr(str,'\\');
        !           190: if(p) p++;
        !           191: else p=str;
        !           192: strcpy(p,"TELEGRAM.DAB");
        !           193: if((file=open(str,O_RDWR|O_DENYNONE|O_BINARY))!=-1) {
        !           194:        while(!eof(file)) {
        !           195:                read(file,from.system,sizeof(user.system));
        !           196:                read(file,user.system,sizeof(user.system));
        !           197:         read(file,&user.number,sizeof(user.number));
        !           198:                printf("Telegram to: %lu@%s\n",user.number,user.system);
        !           199:                read(file,telegram,512);
        !           200:                telegram[512]=0;
        !           201:                sprintf(buf,"}%lx\r\n%s",user.number,encrypt(telegram,user.number));
        !           202:                strcat(buf,"\r\n"); /* blank line terminates telegram */
        !           203:                strcat(buf,"\r\n--- SMM2MSG v");
        !           204:                strcat(buf,VERSION);
        !           205: 
        !           206:                length=strlen(buf);   /* +2 for translation string */
        !           207: 
        !           208:                if(smb.status.attr&SMB_HYPERALLOC)
        !           209:                        offset=smb_hallocdat(&smb);
        !           210:                else {
        !           211:                        i=smb_open_da(&smb);
        !           212:                        if(i) {
        !           213:                                printf("smb_open_da returned %d\n",i);
        !           214:                                exit(1); }
        !           215:                        offset=smb_allocdat(&smb,length+2,1);
        !           216:                        fclose(smb.sda_fp); }
        !           217: 
        !           218:                fseek(smb.sdt_fp,offset,SEEK_SET);
        !           219:                xlat=XLAT_NONE;
        !           220:                fwrite(&xlat,2,1,smb.sdt_fp);
        !           221:                fwrite(buf,length,1,smb.sdt_fp);
        !           222:                length+=2;
        !           223: 
        !           224:                memset(&msg,0,sizeof(smbmsg_t));
        !           225:                memcpy(msg.hdr.id,"SHD\x1a",4);
        !           226:                msg.hdr.version=SMB_VERSION;
        !           227:                msg.hdr.when_written.time=time(NULL);
        !           228: 
        !           229:                msg.hdr.offset=offset;
        !           230: 
        !           231:                strcpy(str,"SMM");
        !           232:                i=smb_hfield(&msg,RECIPIENT,strlen(str),str);
        !           233:                if(i) {
        !           234:                        printf("smb_hfield returned %d\n",i);
        !           235:                        smb_freemsgdat(&smb,offset,length,1);
        !           236:                        exit(1); }
        !           237:                strlwr(str);
        !           238:                msg.idx.to=crc16(str);
        !           239: 
        !           240:                strcpy(str,from.system);
        !           241:                i=smb_hfield(&msg,SENDER,strlen(str),str);
        !           242:                if(i) {
        !           243:                        printf("smb_hfield returned %d\n",i);
        !           244:                        smb_freemsgdat(&smb,offset,length,1);
        !           245:                        exit(1); }
        !           246:                strlwr(str);
        !           247:                msg.idx.from=crc16(str);
        !           248: 
        !           249:                strcpy(str,user.system);
        !           250:                i=smb_hfield(&msg,SUBJECT,strlen(str),str);
        !           251:                if(i) {
        !           252:                        printf("smb_hfield returned %d\n",i);
        !           253:                        smb_freemsgdat(&smb,offset,length,1);
        !           254:                        exit(1); }
        !           255:                strlwr(str);
        !           256:                msg.idx.subj=crc16(str);
        !           257: 
        !           258:                i=smb_dfield(&msg,TEXT_BODY,length);
        !           259:                if(i) {
        !           260:                        printf("smb_dfield returned %d\n",i);
        !           261:                        smb_freemsgdat(&smb,offset,length,1);
        !           262:                        exit(1); }
        !           263: 
        !           264:                i=smb_addmsghdr(&smb,&msg,smb.status.attr&SMB_HYPERALLOC);
        !           265:                if(i) {
        !           266:                        printf("smb_addmsghdr returned %d\n",i);
        !           267:                        smb_freemsgdat(&smb,offset,length,1);
        !           268:                        exit(1); }
        !           269:                smb_freemsgmem(&msg); }
        !           270:        chsize(file,0L);
        !           271:        close(file); }
        !           272: 
        !           273: strcpy(str,argv[1]);
        !           274: strupr(str);
        !           275: p=strrchr(str,'\\');
        !           276: if(p) p++;
        !           277: else p=str;
        !           278: strcpy(p,"WALL.DAB");
        !           279: if((file=sopen(str,O_RDONLY|O_BINARY,SH_DENYNO))!=-1) {
        !           280:        while(!eof(file)) {
        !           281:                if(!read(file,&wall,sizeof(wall_t)))
        !           282:                        break;
        !           283:                if(last && wall.imported<last)
        !           284:                        continue;
        !           285: 
        !           286:                if(wall.imported!=wall.written)         /* Imported from SMB */
        !           287:                        continue;
        !           288: 
        !           289:                printf("Wall writing from: %s\n",wall.name);
        !           290:                sprintf(buf,"%s\r\n",encrypt(wall.name,wall.written));
        !           291:                sprintf(str,"%s\r\n",encrypt(wall.system,wall.written));
        !           292:                strcat(buf,str);
        !           293:                for(i=0;i<5;i++) {
        !           294:                        sprintf(str,"%s\r\n",encrypt(wall.text[i],wall.written));
        !           295:                        strcat(buf,str); }
        !           296:                sprintf(str,"%lx\r\n",wall.written);
        !           297:                strcat(buf,str);
        !           298:                strcat(buf,"\r\n--- SMM2SMB v");
        !           299:                strcat(buf,VERSION);
        !           300: 
        !           301:                length=strlen(buf);   /* +2 for translation string */
        !           302: 
        !           303:                if(smb.status.attr&SMB_HYPERALLOC)
        !           304:                        offset=smb_hallocdat(&smb);
        !           305:                else {
        !           306:                        i=smb_open_da(&smb);
        !           307:                        if(i) {
        !           308:                                printf("smb_open_da returned %d\n",i);
        !           309:                                exit(1); }
        !           310:                        offset=smb_allocdat(&smb,length+2,1);
        !           311:                        fclose(smb.sda_fp); }
        !           312: 
        !           313:                fseek(smb.sdt_fp,offset,SEEK_SET);
        !           314:                xlat=XLAT_NONE;
        !           315:                fwrite(&xlat,2,1,smb.sdt_fp);
        !           316:                fwrite(buf,length,1,smb.sdt_fp);
        !           317:                length+=2;
        !           318: 
        !           319:                memset(&msg,0,sizeof(smbmsg_t));
        !           320:                memcpy(msg.hdr.id,"SHD\x1a",4);
        !           321:                msg.hdr.version=SMB_VERSION;
        !           322:                msg.hdr.when_written.time=time(NULL);
        !           323: 
        !           324:                msg.hdr.offset=offset;
        !           325: 
        !           326:                strcpy(str,"SMM");
        !           327:                i=smb_hfield(&msg,RECIPIENT,strlen(str),str);
        !           328:                if(i) {
        !           329:                        printf("smb_hfield returned %d\n",i);
        !           330:                        smb_freemsgdat(&smb,offset,length,1);
        !           331:                        exit(1); }
        !           332:                strlwr(str);
        !           333:                msg.idx.to=crc16(str);
        !           334: 
        !           335:                strcpy(str,wall.system);
        !           336:                i=smb_hfield(&msg,SENDER,strlen(str),str);
        !           337:                if(i) {
        !           338:                        printf("smb_hfield returned %d\n",i);
        !           339:                        smb_freemsgdat(&smb,offset,length,1);
        !           340:                        exit(1); }
        !           341:                strlwr(str);
        !           342:                msg.idx.from=crc16(str);
        !           343: 
        !           344:                strcpy(str,"->WALL<-");
        !           345:                i=smb_hfield(&msg,SUBJECT,strlen(str),str);
        !           346:                if(i) {
        !           347:                        printf("smb_hfield returned %d\n",i);
        !           348:                        smb_freemsgdat(&smb,offset,length,1);
        !           349:                        exit(1); }
        !           350:                strlwr(str);
        !           351:                msg.idx.subj=crc16(str);
        !           352: 
        !           353:                i=smb_dfield(&msg,TEXT_BODY,length);
        !           354:                if(i) {
        !           355:                        printf("smb_dfield returned %d\n",i);
        !           356:                        smb_freemsgdat(&smb,offset,length,1);
        !           357:                        exit(1); }
        !           358: 
        !           359:                i=smb_addmsghdr(&smb,&msg,smb.status.attr&SMB_HYPERALLOC);
        !           360:                if(i) {
        !           361:                        printf("smb_addmsghdr returned %d\n",i);
        !           362:                        smb_freemsgdat(&smb,offset,length,1);
        !           363:                        exit(1); }
        !           364:                smb_freemsgmem(&msg); }
        !           365:     close(file); }
        !           366: 
        !           367: 
        !           368: while(!feof(stream)) {
        !           369:        if(!fread(&user,sizeof(user_t),1,stream))
        !           370:                break;
        !           371:        if(user.misc&(USER_FROMSMB|USER_DELETED)
        !           372:                || (last && user.updated<last && user.created<last)
        !           373:                || user.number&0xffff0000L
        !           374:                || user.number==0
        !           375:                || user.system[0]<SP
        !           376:                || user.name[0]<SP
        !           377:                || user.realname[0]<SP
        !           378:                || user.location[0]<SP
        !           379:                || user.zipcode[0]<SP
        !           380:                || user.birth[0]<SP)
        !           381:                continue;
        !           382: 
        !           383:        printf("Profile: %s\n",user.name);
        !           384:        memset(buf,0,BUF_LEN);
        !           385: 
        !           386:        sprintf(str,"0:%.25s\r\n",encrypt(user.name,user.number));
        !           387:        strcat(buf,str);
        !           388:        sprintf(str,"1:%.25s\r\n",encrypt(user.realname,user.number));
        !           389:     strcat(buf,str);
        !           390: 
        !           391:        sprintf(str,"2:%.8s\r\n",encrypt(user.birth,user.number));
        !           392:     strcat(buf,str);
        !           393: 
        !           394:        sprintf(str,"3:%.30s\r\n",encrypt(user.location,user.number));
        !           395:     strcat(buf,str);
        !           396: 
        !           397:        sprintf(str,"4:%.10s\r\n",encrypt(user.zipcode,user.number));
        !           398:     strcat(buf,str);
        !           399:        sprintf(str,"5:%.10s\r\n",encrypt(user.min_zipcode,user.number));
        !           400:     strcat(buf,str);
        !           401:        sprintf(str,"6:%.10s\r\n",encrypt(user.max_zipcode,user.number));
        !           402:     strcat(buf,str);
        !           403:        sprintf(str,"7:%.4s\r\n",encrypt(user.mbtype,user.number));
        !           404:        strcat(buf,str);
        !           405: 
        !           406:        sprintf(str,"A:%.50s\r\n",encrypt(user.note[0],user.number));
        !           407:        strcat(buf,str);
        !           408:        sprintf(str,"B:%.50s\r\n",encrypt(user.note[1],user.number));
        !           409:     strcat(buf,str);
        !           410:        sprintf(str,"C:%.50s\r\n",encrypt(user.note[2],user.number));
        !           411:     strcat(buf,str);
        !           412:        sprintf(str,"D:%.50s\r\n",encrypt(user.note[3],user.number));
        !           413:     strcat(buf,str);
        !           414:        sprintf(str,"E:%.50s\r\n",encrypt(user.note[4],user.number));
        !           415:     strcat(buf,str);
        !           416: 
        !           417:        sprintf(str,"F:%c%c\r\n",user.sex,user.pref_sex);
        !           418:        strcat(buf,str);
        !           419: 
        !           420:        sprintf(str,"G:%x\r\n",user.marital);
        !           421:        strcat(buf,str);
        !           422:        sprintf(str,"H:%x\r\n",user.pref_marital);
        !           423:        strcat(buf,str);
        !           424: 
        !           425:        sprintf(str,"I:%x\r\n",user.race);
        !           426:        strcat(buf,str);
        !           427:        sprintf(str,"J:%x\r\n",user.pref_race);
        !           428:     strcat(buf,str);
        !           429: 
        !           430:        sprintf(str,"K:%x\r\n",user.hair);
        !           431:        strcat(buf,str);
        !           432:        sprintf(str,"L:%x\r\n",user.pref_hair);
        !           433:     strcat(buf,str);
        !           434: 
        !           435:        sprintf(str,"M:%x\r\n",user.eyes);
        !           436:        strcat(buf,str);
        !           437:        sprintf(str,"N:%x\r\n",user.pref_eyes);
        !           438:     strcat(buf,str);
        !           439: 
        !           440:        sprintf(str,"O:%x\r\nP:%x\r\nQ:%x\r\n"
        !           441:                ,user.weight,user.min_weight,user.max_weight);
        !           442:        strcat(buf,str);
        !           443: 
        !           444:        sprintf(str,"R:%x\r\nS:%x\r\nT:%x\r\n"
        !           445:                ,user.height,user.min_height,user.max_height);
        !           446:     strcat(buf,str);
        !           447: 
        !           448:        sprintf(str,"U:%x\r\nV:%x\r\nW:%x\r\n"
        !           449:                ,user.min_age,user.max_age,user.purity);
        !           450:        strcat(buf,str);
        !           451: 
        !           452:        sprintf(str,"X:%lx\r\nY:%lx\r\nZ:%lx\r\n!:%lx\r\n"
        !           453:                ,user.income,user.min_income,user.max_income,time(NULL));
        !           454:        strcat(buf,str);
        !           455: 
        !           456:        for(i=0;i<5;i++) {
        !           457:                if(!user.queans[i].name[0])
        !           458:                        continue;
        !           459:                sprintf(str,"*%d%.8s\r\n",i,encrypt(user.queans[i].name,user.number));
        !           460:                strcat(buf,str);
        !           461:                for(j=0;j<20;j++) {
        !           462:                        sprintf(str," %04x %04x"
        !           463:                                ,user.queans[i].self[j]
        !           464:                                ,user.queans[i].pref[j]);
        !           465:                        strcat(buf,str);
        !           466:                        if(!((j+1)%7))
        !           467:                                strcat(buf,"\r\n"); }
        !           468:                strcat(buf,"\r\n"); }
        !           469: 
        !           470:        strcat(buf,"\r\n--- SMM2MSG v");
        !           471:        strcat(buf,VERSION);
        !           472: 
        !           473:        length=strlen(buf);   /* +2 for translation string */
        !           474: 
        !           475:        if(smb.status.attr&SMB_HYPERALLOC)
        !           476:                offset=smb_hallocdat(&smb);
        !           477:        else {
        !           478:                i=smb_open_da(&smb);
        !           479:                if(i) {
        !           480:                        printf("smb_open_da returned %d\n",i);
        !           481:                        exit(1); }
        !           482:                offset=smb_allocdat(&smb,length+2,1);
        !           483:                fclose(smb.sda_fp); }
        !           484: 
        !           485:        fseek(smb.sdt_fp,offset,SEEK_SET);
        !           486:        xlat=XLAT_NONE;
        !           487:        fwrite(&xlat,2,1,smb.sdt_fp);
        !           488:        fwrite(buf,length,1,smb.sdt_fp);
        !           489:        length+=2;
        !           490: 
        !           491:        memset(&msg,0,sizeof(smbmsg_t));
        !           492:        memcpy(msg.hdr.id,"SHD\x1a",4);
        !           493:        msg.hdr.version=SMB_VERSION;
        !           494:        msg.hdr.when_written.time=time(NULL);
        !           495:     
        !           496:        msg.hdr.offset=offset;
        !           497: 
        !           498:        strcpy(str,"SMM");
        !           499:        i=smb_hfield(&msg,RECIPIENT,strlen(str),str);
        !           500:        if(i) {
        !           501:                printf("smb_hfield returned %d\n",i);
        !           502:                smb_freemsgdat(&smb,offset,length,1);
        !           503:                exit(1); }
        !           504:        strlwr(str);
        !           505:        msg.idx.to=crc16(str);
        !           506: 
        !           507:        strcpy(str,user.system);
        !           508:        i=smb_hfield(&msg,SENDER,strlen(str),str);
        !           509:        if(i) {
        !           510:                printf("smb_hfield returned %d\n",i);
        !           511:                smb_freemsgdat(&smb,offset,length,1);
        !           512:                exit(1); }
        !           513:        strlwr(str);
        !           514:        msg.idx.from=crc16(str);
        !           515: 
        !           516:        sprintf(str,"%lu",user.number);
        !           517:        i=smb_hfield(&msg,SUBJECT,strlen(str),str);
        !           518:        if(i) {
        !           519:                printf("smb_hfield returned %d\n",i);
        !           520:                smb_freemsgdat(&smb,offset,length,1);
        !           521:                exit(1); }
        !           522:        strlwr(str);
        !           523:        msg.idx.subj=crc16(str);
        !           524: 
        !           525:        i=smb_dfield(&msg,TEXT_BODY,length);
        !           526:        if(i) {
        !           527:                printf("smb_dfield returned %d\n",i);
        !           528:                smb_freemsgdat(&smb,offset,length,1);
        !           529:                exit(1); }
        !           530: 
        !           531:        i=smb_addmsghdr(&smb,&msg,smb.status.attr&SMB_HYPERALLOC);
        !           532:        if(i) {
        !           533:                printf("smb_addmsghdr returned %d\n",i);
        !           534:                smb_freemsgdat(&smb,offset,length,1);
        !           535:                exit(1); }
        !           536:        smb_freemsgmem(&msg); }
        !           537: return(0);
        !           538: }
        !           539: 

unix.superglobalmegacorp.com

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