Return to cisrc.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso

Annotation of 43BSDReno/sys/netiso/cisrc.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1989, 1990 Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * %sccs.include.redist.c%
        !             6:  */
        !             7: #ifndef lint
        !             8: static char sccsid[] = "%W% (Berkeley) %G%";
        !             9: #endif /* not lint */
        !            10: 
        !            11: /*
        !            12:  * This is a test program to be a source for ISO packets.
        !            13:  */
        !            14: #include <sys/types.h>
        !            15: #include <sys/socket.h>
        !            16: #include <sys/uio.h>
        !            17: #include <sys/ioctl.h>
        !            18: #include <net/route.h>
        !            19: #include <net/if.h>
        !            20: #define  TCPT_NTIMERS 4
        !            21: #include <netiso/iso.h>
        !            22: #include <netiso/tp_user.h>
        !            23: 
        !            24: #include <stdio.h>
        !            25: #include <errno.h>
        !            26: #include <ctype.h>
        !            27: #include <netdb.h>
        !            28: 
        !            29: 
        !            30: #define dbprintf if(verbose)printf
        !            31: #define try(a,b,c) {x = (a b);dbprintf("%s%s returns %d\n",c,"a",x);\
        !            32:                    if (x < 0) {perror("a"); exit(1);}}
        !            33: 
        !            34: struct iso_addr eon = {20, 0x47, 0, 6, 3, 0, 0, 0, 25 /*EGP for Berkeley*/};
        !            35: struct  sockaddr_iso to_s = { sizeof(to_s), AF_ISO }, *to = &to_s;
        !            36: struct  sockaddr_iso old_s = { sizeof(to_s), AF_ISO }, *old = &old_s;
        !            37: fd_set readfds, writefds, exceptfds;
        !            38: long size, count = 10;
        !            39: int verbose = 1, selectp, type = SOCK_SEQPACKET, nobuffs, errno, playtag = 0;
        !            40: int verify = 0, dgramp = 1, debug = 0;
        !            41: short portnumber = 3000;
        !            42: char your_it[] = "You're it!";
        !            43: char *Servername, *conndata, data_msg[2048];
        !            44: char Serverbuf[128];
        !            45: char name[128];
        !            46: struct iovec iov[1] = {data_msg};
        !            47: union {
        !            48:     struct {
        !            49:            struct cmsghdr      cmhdr;
        !            50:            char                cmdata[128 - sizeof(struct cmsghdr)];
        !            51:     } cm;
        !            52:     char data[128];
        !            53: } cm;
        !            54: struct msghdr msg = { 0, 0, iov, 1, 0, 0, 0};
        !            55: 
        !            56: main(argc, argv)
        !            57: int argc;
        !            58: char *argv[];
        !            59: {
        !            60:        register char **av = argv;
        !            61:        register char *cp;
        !            62:        struct iso_addr iso_addr();
        !            63:        u_long len;
        !            64:        int handy;
        !            65: 
        !            66:        while(--argc > 0) {
        !            67:                av++;
        !            68:                if(strcmp(*av,"Servername")==0) {
        !            69:                        av++;
        !            70:                        Servername = *av;
        !            71:                        argc--;
        !            72:                } else if(strcmp(*av,"conndata")==0) {
        !            73:                        av++;
        !            74:                        conndata = *av;
        !            75:                        argc--;
        !            76:                } else if(strcmp(*av,"host")==0) {
        !            77:                        av++;
        !            78:                        to_s.siso_addr = iso_addr(*av);
        !            79:                        argc--;
        !            80:                } else if(strcmp(*av,"port")==0) {
        !            81:                        av++;
        !            82:                        sscanf(*av,"%hd",&portnumber);
        !            83:                        argc--;
        !            84:                } else if(strcmp(*av,"count")==0) {
        !            85:                        av++;
        !            86:                        sscanf(*av,"%ld",&count);
        !            87:                        argc--;
        !            88:                } else if(strcmp(*av,"size")==0) {
        !            89:                        av++;
        !            90:                        sscanf(*av,"%ld",&size);
        !            91:                        iov->iov_len = size;
        !            92:                } else if (strcmp(*av,"eon") == 0) {
        !            93:                        unsigned long l, inet_addr();
        !            94: 
        !            95:                        l = inet_addr(*++av); argc--;
        !            96:                        to_s.siso_addr = eon;
        !            97:                        bcopy((char *)&l, &to_s.siso_data[15], 4);
        !            98:                }
        !            99:        }
        !           100:        maketoaddr();
        !           101:        tisrc();
        !           102: }
        !           103: 
        !           104: maketoaddr()
        !           105: {
        !           106:        if (Servername) {
        !           107:                int tlen = strlen(Servername);
        !           108:                int len =  tlen + TSEL(to) - (caddr_t) to;
        !           109:                if (len < sizeof(*to)) len = sizeof(*to);
        !           110:                if (len > to->siso_len) {
        !           111:                        if (old != &old_s) free(old);
        !           112:                        old = (struct sockaddr_iso *)malloc(len);
        !           113:                        *old = *to; /* We dont care if all old tsel is copied*/
        !           114:                        old->siso_len = len;
        !           115:                        if (to != &to_s) free(to);
        !           116:                        to = (struct sockaddr_iso *)malloc(len);
        !           117:                }
        !           118:                bcopy(Servername, TSEL(old), tlen);
        !           119:        } else {
        !           120:                old->siso_tlen = sizeof(portnumber);
        !           121:                portnumber = htons(portnumber);
        !           122:                bcopy((char *)&portnumber, TSEL(old), sizeof(portnumber));
        !           123:        }
        !           124:        bcopy(old, to, old->siso_len);
        !           125: }
        !           126: 
        !           127: 
        !           128: tisrc() {
        !           129:        int x, s, pid, on = 1, flags = 8, n;
        !           130: 
        !           131:        if (dgramp) type = SOCK_DGRAM;
        !           132:        try(socket, (AF_ISO, type, 0),"");
        !           133:        s = x;
        !           134: 
        !           135:        if (debug)
        !           136:                try(setsockopt, (s, SOL_SOCKET, SO_DEBUG, &on, sizeof on), "");
        !           137:        if (dgramp == 0) {
        !           138:                if (conndata)
        !           139:                        doconndata(s);
        !           140:                try(connect, (s, (struct sockaddr *) to, to->siso_len), "");
        !           141:        }
        !           142:        if (selectp) {
        !           143:                FD_ZERO(&writefds); FD_SET(s, &writefds);
        !           144:                select(1, &writefds, 0, 0, 0);
        !           145:        }
        !           146:        while (count-- > 0) {
        !           147:                if (size <= 0 && get_record(&flags) == EOF)
        !           148:                        exit(0);
        !           149:                n = put_record(s, flags);
        !           150:                if (n < iov->iov_len) {
        !           151:                        if (n==-1 && errno == 55) {
        !           152:                                nobuffs++;
        !           153:                                count++;
        !           154:                                continue;
        !           155:                        }
        !           156:                        fprintf(stderr, "wrote %d < %d, count %d,",
        !           157:                                                n, iov->iov_len, count);
        !           158:                        perror("due to");
        !           159:                }
        !           160:        }
        !           161:        if (playtag) {
        !           162:                printf("Tag time!\n");
        !           163:                iov->iov_base = your_it;
        !           164:                iov->iov_len = sizeof your_it;
        !           165:                sendmsg(s, &msg, MSG_EOR);
        !           166:                sendmsg(s, &msg, MSG_EOR);
        !           167:                iov->iov_base = data_msg;
        !           168:                iov->iov_len = sizeof data_msg;
        !           169:                try(recvmsg, (s, &msg, flags), " playtag ");
        !           170:        }
        !           171:        if(nobuffs) {
        !           172:                printf("looped %d times waiting for bufs\n", nobuffs);
        !           173:        }
        !           174: }
        !           175: int localsize;
        !           176: char dupbuf[4096];
        !           177: 
        !           178: put_record(s, flags)
        !           179: int s, flags;
        !           180: {
        !           181:        int fd, buflen;
        !           182:        char *buf;
        !           183:        int x, saved_x;
        !           184: 
        !           185:        msg.msg_flags = flags;
        !           186:        if (verbose) {
        !           187:                if (msg.msg_controllen) {
        !           188:                        printf("(CMessage Type is %x) ", cm.cm.cmhdr.cmsg_type);
        !           189:                        dumpit("CMsg data:\n", &msg.msg_control, msg.msg_controllen);
        !           190:                }
        !           191:                if (iov->iov_len) {
        !           192:                        printf("sending: %s %s",
        !           193:                        (flags & MSG_OOB ? "(OOB Data)" : ""),
        !           194:                                (flags & MSG_EOR ? "(Record Mark)" : ""));
        !           195:                        dumpit("data: ", data_msg, localsize);
        !           196:                }
        !           197:        }
        !           198:        if (verify) {
        !           199:                buflen = iov->iov_len;
        !           200:                bcopy(iov->iov_base, dupbuf, buflen);
        !           201:        }
        !           202:        if (dgramp) {
        !           203:                msg.msg_name = (caddr_t)to;
        !           204:                msg.msg_namelen = to->siso_len;
        !           205:        }
        !           206:        try(sendmsg, (s, &msg, flags), " put_record ");
        !           207:        saved_x = x;
        !           208:        while (verify && buflen > 0) {
        !           209:                iov->iov_len = buflen;
        !           210:                iov->iov_base = dupbuf;
        !           211:                try(recvmsg, (s, &msg, flags), " put_record ");
        !           212:                if (dgramp) {
        !           213:                        if (msg.msg_namelen)
        !           214:                                dumpit("from: ", to, msg.msg_namelen);
        !           215:                        msg.msg_namelen = old->siso_len;
        !           216:                }
        !           217:                printf("verify got %d\n", x);
        !           218:                buflen -= x;
        !           219:        }
        !           220:        bcopy(old, to, old->siso_len);
        !           221:        msg.msg_control = 0;
        !           222:        return (saved_x);
        !           223: }
        !           224: dumpit(what, where, n)
        !           225: char *what; unsigned short *where; int n;
        !           226: {
        !           227:        unsigned short *s = where;
        !           228:        unsigned short *z = where + (n+1)/2;
        !           229:        int count = 0;
        !           230:        if (verbose == 0)
        !           231:                return;
        !           232:        printf(what);
        !           233:        while(s < z) {
        !           234:                count++;
        !           235:                printf("%x ",*s++);
        !           236:                if ((count & 15) == 0)
        !           237:                        putchar('\n');
        !           238:        }
        !           239:        if (count & 15)
        !           240:                putchar('\n');
        !           241:        fflush(stdout);
        !           242: }
        !           243: int *datasize = &iov->iov_len;
        !           244: char *cp, *cplim;
        !           245: 
        !           246: get_control_data(type)
        !           247: {
        !           248: 
        !           249:        datasize = &msg.msg_controllen;
        !           250:        cp = cm.cm.cmdata;
        !           251:        cplim = cp + sizeof(cm.cm.cmdata);
        !           252:        cm.cm.cmhdr.cmsg_level = SOL_TRANSPORT;
        !           253:        cm.cm.cmhdr.cmsg_type = type;
        !           254:        msg.msg_control = cm.data;
        !           255: }
        !           256: 
        !           257: doconndata(s)
        !           258: {
        !           259:        get_control_data(TPOPT_CONN_DATA);
        !           260:        *datasize = strlen(conndata) + sizeof(cm.cm.cmhdr);
        !           261:        cm.cm.cmhdr.cmsg_len = *datasize;
        !           262:        bcopy(conndata, cp, *datasize);
        !           263:        put_record(s, 0);
        !           264: }
        !           265: 
        !           266: get_altbuf(addrbuf)
        !           267: char *addrbuf;
        !           268: {
        !           269:        if (dgramp == 0) {
        !           270:                printf("illegal option for stream\n");
        !           271:                return 1;
        !           272:        }
        !           273:        return (scanf("%s", addrbuf) == EOF ? 1 : 0);
        !           274: }
        !           275: 
        !           276: get_record(flags)
        !           277: int *flags;
        !           278: {
        !           279:        int factor = 1, x = 0, newaddr = 0;
        !           280:        char workbuf[10240];
        !           281:        char addrbuf[128];
        !           282: 
        !           283:        *flags = 0;
        !           284:        *datasize = 0;
        !           285:        datasize = &iov->iov_len;
        !           286:        cp = data_msg;
        !           287:        cplim  = cp + sizeof(data_msg);
        !           288: 
        !           289:        for(;;) {
        !           290:                x = scanf("%s", workbuf);
        !           291:                if (x == EOF)
        !           292:                        break;
        !           293:                if (strcmp(workbuf, "disc") == 0)
        !           294:                        x = get_control_data(TPOPT_DISC_DATA);
        !           295:                else if (strcmp(workbuf, "cfrm") == 0)
        !           296:                        x = get_control_data(TPOPT_CFRM_DATA);
        !           297:                else if (strcmp(workbuf, "oob") == 0)
        !           298:                        *flags |= MSG_OOB;
        !           299:                else if (strcmp(workbuf, "eom") == 0)
        !           300:                        *flags |= MSG_EOR;
        !           301:                else if (strcmp(workbuf, "host") == 0) {
        !           302:                        if (get_altbuf(addrbuf))
        !           303:                                break;
        !           304:                        to->siso_addr = iso_addr(addrbuf);
        !           305:                        newaddr = 1;
        !           306:                } else if (strcmp(workbuf, "Servername") == 0) {
        !           307:                        if (get_altbuf(Serverbuf))
        !           308:                                break;
        !           309:                        Servername = Serverbuf;
        !           310:                        newaddr = 1;
        !           311:                } else if (strcmp(workbuf, "port") == 0) {
        !           312:                        x = scanf("%hd", &portnumber);
        !           313:                        if (x == EOF)
        !           314:                                break;
        !           315:                        Servername = 0;
        !           316:                        newaddr = 1;
        !           317:                } else if (strcmp(workbuf, "factor") == 0) {
        !           318:                        x = scanf("%d", &factor);
        !           319:                        if (factor <= 0) factor = 1;
        !           320:                        if (x == EOF)
        !           321:                                break;
        !           322:                } else {
        !           323:                        int len = strlen(workbuf);
        !           324:                        localsize = 0;
        !           325:                        while ((factor-- > 0) &&
        !           326:                               ((cp + len) < cplim)) {
        !           327:                                        strcpy(cp, workbuf);
        !           328:                                        cp += len;
        !           329:                                        localsize += len;
        !           330:                        }
        !           331:                        *datasize = localsize;
        !           332:                        if (datasize != &iov->iov_len) {
        !           333:                                *datasize += sizeof(cm.cm.cmhdr);
        !           334:                                cm.cm.cmhdr.cmsg_len = *datasize;
        !           335:                        }
        !           336:                        break;
        !           337:                }
        !           338:        }
        !           339:        errno = 0;
        !           340:        if (newaddr)
        !           341:                maketoaddr();
        !           342:        return (x);
        !           343: }

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