Return to pktdump.c CVS log

Up to [Synchronet] / sbbs / src / sbbs3

Annotation of sbbs/src/sbbs3/pktdump.c, revision 1.1

1.1     ! root        1: /* pktdump.c */
        !             2: 
        !             3: /* $Id: pktdump.c,v 1.1 2006/12/28 08:36:00 rswindell Exp $ */
        !             4: 
        !             5: #include "fidodefs.h"
        !             6: #include "sbbsdefs.h"  /* faddr_t */
        !             7: 
        !             8: FILE* nulfp;
        !             9: FILE* bodyfp;
        !            10: 
        !            11: /****************************************************************************/
        !            12: /* Returns an ASCII string for FidoNet address 'addr'                       */
        !            13: /****************************************************************************/
        !            14: char *faddrtoa(faddr_t* addr, char* outstr)
        !            15: {
        !            16:        static char str[64];
        !            17:     char point[25];
        !            18: 
        !            19:        if(addr==NULL)
        !            20:                return("0:0/0");
        !            21:        sprintf(str,"%hu:%hu/%hu",addr->zone,addr->net,addr->node);
        !            22:        if(addr->point) {
        !            23:                sprintf(point,".%hu",addr->point);
        !            24:                strcat(str,point); }
        !            25:        if(outstr==NULL)
        !            26:                return(str);
        !            27:        strcpy(outstr,str);
        !            28:        return(outstr);
        !            29: }
        !            30: 
        !            31: char* freadstr(FILE* fp, char* str, size_t maxlen)
        !            32: {
        !            33:        int             ch;
        !            34:        size_t  len=0;
        !            35: 
        !            36:        while((ch=fgetc(fp))!=EOF && len<maxlen) {
        !            37:                str[len++]=ch;
        !            38:                if(ch==0)
        !            39:                        break;
        !            40:        }
        !            41: 
        !            42:        str[maxlen-1]=0;
        !            43: 
        !            44:        return(str);
        !            45: }
        !            46:        
        !            47: 
        !            48: int pktdump(FILE* fp, const char* fname)
        !            49: {
        !            50:        int                     ch,lastch;
        !            51:        char            buf[128];
        !            52:        char            origdomn[16]="";
        !            53:        char            destdomn[16]="";
        !            54:        char            to[FIDO_NAME_LEN];
        !            55:        char            from[FIDO_NAME_LEN];
        !            56:        char            subj[FIDO_SUBJ_LEN];
        !            57:        long            offset;
        !            58:        faddr_t         orig;
        !            59:        faddr_t         dest;
        !            60:        fpkthdr_t       pkthdr;
        !            61:        fpkdmsg_t       pkdmsg;
        !            62: 
        !            63:        if(fread(&pkthdr,sizeof(BYTE),sizeof(pkthdr),fp)!=sizeof(pkthdr)) {
        !            64:                fprintf(stderr,"%s !Error reading pkthdr (%u bytes)\n"
        !            65:                        ,fname,sizeof(pkthdr));
        !            66:                return(-1);
        !            67:        }
        !            68: 
        !            69:        fseek(fp,-2L,SEEK_END);
        !            70:        fread(buf,sizeof(BYTE),sizeof(buf),fp);
        !            71:        if(memcmp(buf,"\x00\x00",2)) {
        !            72:                fprintf(stderr,"%s !Packet missing terminating nulls: %02X %02X\n"
        !            73:                        ,fname,buf[0],buf[1]);
        !            74: //             return(-2);
        !            75:        }
        !            76: 
        !            77:        orig.zone=pkthdr.origzone;
        !            78:        orig.net=pkthdr.orignet;
        !            79:        orig.node=pkthdr.orignode;
        !            80:        orig.point=0;
        !            81: 
        !            82:        dest.zone=pkthdr.destzone;
        !            83:        dest.net=pkthdr.destnet;
        !            84:        dest.node=pkthdr.destnode;
        !            85:        dest.point=0;                           /* No point info in the 2.0 hdr! */
        !            86: 
        !            87:        printf("%s Packet Type ", fname);
        !            88: 
        !            89:        if(pkthdr.fill.two_plus.cword==_rotr(pkthdr.fill.two_plus.cwcopy,8)  /* 2+ Packet Header */
        !            90:                && pkthdr.fill.two_plus.cword&1) {
        !            91:                fprintf(stdout,"2+");
        !            92:                dest.point=pkthdr.fill.two_plus.destpoint;
        !            93:        } else if(pkthdr.baud==2) {                                     /* Type 2.2 Packet Header */
        !            94:                fprintf(stdout,"2.2");
        !            95:                dest.point=pkthdr.month; 
        !            96:                sprintf(origdomn,"@%s",pkthdr.fill.two_two.origdomn);
        !            97:                sprintf(destdomn,"@%s",pkthdr.fill.two_two.destdomn);
        !            98:        } else
        !            99:                fprintf(stdout,"2.0");
        !           100: 
        !           101:        printf(" from %s%s",faddrtoa(&orig,NULL),origdomn);
        !           102:        printf(" to %s%s\n"     ,faddrtoa(&dest,NULL),destdomn);
        !           103: 
        !           104:        fseek(fp,sizeof(pkthdr),SEEK_SET);
        !           105: 
        !           106:        /* Read/Display packed messages */
        !           107:        while(!feof(fp)) {
        !           108: 
        !           109:                printf("%08lX\n",offset=ftell(fp));
        !           110: 
        !           111:                /* Read fixed-length header fields */
        !           112:                if(fread(&pkdmsg,sizeof(BYTE),sizeof(pkdmsg),fp)!=sizeof(pkdmsg))
        !           113:                        break;
        !           114:                /* Display fixed-length fields */
        !           115:                printf("%s %06lX Packed Message Type: %d from %u/%u to %u/%u\n"
        !           116:                        ,fname
        !           117:                        ,offset
        !           118:                        ,pkdmsg.type
        !           119:                        ,pkdmsg.orignet, pkdmsg.orignode
        !           120:                        ,pkdmsg.destnet, pkdmsg.destnode);
        !           121:                printf("Attribute: %04X\n",pkdmsg.attr);
        !           122:                printf("Date/Time: %s\n",pkdmsg.time);
        !           123: 
        !           124:                /* Read variable-length header fields */
        !           125:                freadstr(fp,to,sizeof(to));
        !           126:                freadstr(fp,from,sizeof(from));
        !           127:                freadstr(fp,subj,sizeof(subj));
        !           128:        
        !           129:                /* Display variable-length fields */
        !           130:                printf("%-4s : %s\n","To",to);
        !           131:                printf("%-4s : %s\n","From",from);
        !           132:                printf("%-4s : %s\n","Subj",subj);
        !           133: 
        !           134:                fprintf(bodyfp,"\n-start of message text-\n");
        !           135: 
        !           136:                while((ch=fgetc(fp))!=EOF && ch!=0) {
        !           137:                        if(lastch=='\r' && ch!='\n')
        !           138:                                fputc('\n',bodyfp);
        !           139:                        fputc(lastch=ch,bodyfp);
        !           140:                }
        !           141: 
        !           142:                fprintf(bodyfp,"\n-end of message text-\n");
        !           143:        }
        !           144: 
        !           145:        return(0);
        !           146: }
        !           147: 
        !           148: int main(int argc, char** argv)
        !           149: {
        !           150:        FILE*   fp;
        !           151:        int             i;
        !           152: 
        !           153:        if((nulfp=fopen(_PATH_DEVNULL,"w+"))==NULL) {
        !           154:                perror(_PATH_DEVNULL);
        !           155:                return -1;
        !           156:        }
        !           157:        bodyfp=nulfp;
        !           158: 
        !           159:        if(sizeof(fpkthdr_t)!=FIDO_PACKET_HDR_LEN) {
        !           160:                printf("sizeof(fpkthdr_t)=%d, expected: %d\n",sizeof(fpkthdr_t),FIDO_PACKET_HDR_LEN);
        !           161:                return(-1);
        !           162:        }
        !           163:        if(sizeof(fpkdmsg_t)!=FIDO_PACKED_MSG_HDR_LEN) {
        !           164:                printf("sizeof(fpkdmsg_t)=%d, expected: %d\n",sizeof(fpkdmsg_t),FIDO_PACKED_MSG_HDR_LEN);
        !           165:                return(-1);
        !           166:        }
        !           167:        if(sizeof(fmsghdr_t)!=FIDO_STORED_MSG_HDR_LEN) {
        !           168:                printf("sizeof(fmsghdr_t)=%d, expected: %d\n",sizeof(fmsghdr_t),FIDO_STORED_MSG_HDR_LEN);
        !           169:                return(-1);
        !           170:        }
        !           171: 
        !           172:        for(i=1;i<argc;i++) {
        !           173:                if(argv[i][0]=='-') {
        !           174:                        switch(tolower(argv[i][1])) {
        !           175:                                case 'b':
        !           176:                                        bodyfp=stdout;;
        !           177:                                        break;
        !           178:                                default:
        !           179:                                        printf("usage: pktdump [-text] <files.pkt>\n");
        !           180:                                        return(0);
        !           181:                        }
        !           182:                        continue;
        !           183:                }
        !           184:                fprintf(stdout,"Opening %s\n",argv[i]);
        !           185:                if((fp=fopen(argv[i],"rb"))==NULL) {
        !           186:                        perror(argv[i]);
        !           187:                        continue;
        !           188:                }
        !           189:                pktdump(fp, argv[i]);
        !           190:                fclose(fp);
        !           191:        }
        !           192: 
        !           193:        return(0);
        !           194: }

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