Return to dio.c CVS log

Up to [Research Unix] / researchv8dc / cmd / uucp

Annotation of researchv8dc/cmd/uucp/dio.c, revision 1.1

1.1     ! root        1: /*     %W%
        !             2: */
        !             3: #include "uucp.h"
        !             4: VERSION(%W%);
        !             5: 
        !             6: #ifdef DATAKIT
        !             7: #include <dk.h>
        !             8: 
        !             9: #define XBUFSIZ 1024
        !            10: time_t time();
        !            11: static jmp_buf Dfailbuf;
        !            12: 
        !            13: /*
        !            14:  * Datakit protocol
        !            15:  */
        !            16: static dalarm() {longjmp(Dfailbuf);}
        !            17: static int (*dsig)();
        !            18: #ifndef V8
        !            19: static short dkrmode[3] = { DKR_BLOCK, 0, 0 };
        !            20: static short dkeof[3] = { 106, 0, 0 }; /* End of File signal */
        !            21: #endif
        !            22: 
        !            23: /*
        !            24:  * turn on protocol
        !            25:  */
        !            26: dturnon()
        !            27: {
        !            28: 
        !            29:        dsig=signal(SIGALRM, dalarm);
        !            30: #ifndef V8
        !            31:        if(ioctl(Ofn, DIOCRMODE, dkrmode) < 0) {
        !            32:            int ret; extern int errno;
        !            33:            ret=ioctl(Ofn, DIOCRMODE, dkrmode);
        !            34:            DEBUG(4, "dturnon: ret=%d, ", ret);
        !            35:            DEBUG(4, "Ofn=%d, ", Ofn);
        !            36:            DEBUG(4, "errno=%d\n", errno);
        !            37:            return(-1);
        !            38:        }
        !            39: #endif !V8
        !            40:        return(0);
        !            41: }
        !            42: dturnoff()
        !            43: {
        !            44:        (void) signal(SIGALRM, dsig);
        !            45:        return(0);
        !            46: }
        !            47: 
        !            48: /*
        !            49:  * write message across Datakit link
        !            50:  *     type    -> message type
        !            51:  *     str     -> message body (ascii string)
        !            52:  *     fn      -> Datakit file descriptor
        !            53:  * return
        !            54:  *     SUCCESS -> message sent
        !            55:  *     FAIL    -> write failed
        !            56:  */
        !            57: dwrmsg(type, str, fn)
        !            58: register char *str;
        !            59: int fn;
        !            60: char type;
        !            61: {
        !            62:        register char *s;
        !            63:        char bufr[XBUFSIZ];
        !            64: 
        !            65:        bufr[0] = type;
        !            66:        s = &bufr[1];
        !            67:        while (*str)
        !            68:                *s++ = *str++;
        !            69:        *s = '\0';
        !            70:        if (*(--s) == '\n')
        !            71:                *s = '\0';
        !            72:        return(write(fn, bufr, (unsigned) strlen(bufr) + 1) < 0 ? FAIL : SUCCESS);
        !            73: }
        !            74: 
        !            75: /*
        !            76:  * read message from Datakit link
        !            77:  *     str     -> message buffer
        !            78:  *     fn      -> Datakit file descriptor
        !            79:  * return
        !            80:  *     FAIL    -> send timed out
        !            81:  *     SUCCESS -> ok message in str
        !            82:  */
        !            83: drdmsg(str, fn)
        !            84: register char *str;
        !            85: {
        !            86: 
        !            87:        register int len;
        !            88: 
        !            89:        if(setjmp(Dfailbuf))
        !            90:                return(FAIL);
        !            91: 
        !            92:        (void) alarm(60);
        !            93:        for (;;) {
        !            94:                if( (len = read(fn, str, XBUFSIZ)) <= 0) {
        !            95:                        (void) alarm(0);
        !            96:                        return(FAIL);
        !            97:                }
        !            98:                str += len;
        !            99:                if (*(str - 1) == '\0')
        !           100:                        break;
        !           101:        }
        !           102:        (void) alarm(0);
        !           103:        return(SUCCESS);
        !           104: }
        !           105: 
        !           106: /*
        !           107:  * read data from file fp1 and write
        !           108:  * on Datakit link
        !           109:  *     fp1     -> file descriptor
        !           110:  *     fn      -> Datakit descriptor
        !           111:  * returns:
        !           112:  *     FAIL    ->failure in Datakit link
        !           113:  *     SUCCESS -> ok
        !           114:  */
        !           115: dwrdata(fp1, fn)
        !           116: register FILE *fp1;
        !           117: {
        !           118:        register int len, ret;
        !           119:        long bytes;
        !           120:        char bufr[XBUFSIZ];
        !           121:        char text[128];
        !           122:        time_t  ticks;
        !           123: 
        !           124:        bytes = 0L;
        !           125:        (void) millitick();     /* set msec timer */
        !           126:        while ((len = fread(bufr, sizeof (char), XBUFSIZ, fp1)) > 0) {
        !           127:                bytes += len;
        !           128:                ret = write(fn, bufr, (unsigned) len);
        !           129:                if (ret != len) {
        !           130:                        return(FAIL);
        !           131:                }
        !           132:                if (len != XBUFSIZ)
        !           133:                        break;
        !           134:        }
        !           135: #ifndef V8
        !           136:        ioctl(fn, DIOCXCTL, dkeof);
        !           137: #endif
        !           138:        ret = write(fn, bufr, (unsigned) 0);
        !           139:        ticks = millitick();
        !           140:        (void) sprintf(text, "-> %ld / %ld.%.3d secs",
        !           141:                bytes, ticks / 1000, ticks % 1000);
        !           142:        DEBUG(4, "%s\n", text);
        !           143:        syslog(text);
        !           144:        return(SUCCESS);
        !           145: }
        !           146: 
        !           147: /*
        !           148:  * read data from Datakit link and
        !           149:  * write into file
        !           150:  *     fp2     -> file descriptor
        !           151:  *     fn      -> Datakit descriptor
        !           152:  * returns:
        !           153:  *     SUCCESS -> ok
        !           154:  *     FAIL    -> failure on Datakit link
        !           155:  */
        !           156: drddata(fn, fp2)
        !           157: register FILE *fp2;
        !           158: {
        !           159:        register int len;
        !           160:        long bytes;
        !           161:        char text[128];
        !           162:        char bufr[XBUFSIZ];
        !           163:        time_t ticks;
        !           164: 
        !           165:        bytes = 0L;
        !           166:        (void) millitick();     /* set msec timer */
        !           167:        for (;;) {
        !           168:                len = drdblk(bufr, XBUFSIZ, fn);
        !           169:                if (len < 0) {
        !           170:                        return(FAIL);
        !           171:                }
        !           172:                bytes += len;
        !           173:                fwrite(bufr, sizeof (char), len, fp2);
        !           174:                if (len < XBUFSIZ)
        !           175:                        break;
        !           176:        }
        !           177:        ticks = millitick();
        !           178:        (void) sprintf(text, "<- %ld / %ld.%.3d secs",
        !           179:                bytes, ticks / 1000, ticks % 1000);
        !           180:        DEBUG(4, "%s\n", text);
        !           181:        syslog(text);
        !           182:        return(SUCCESS);
        !           183: }
        !           184: 
        !           185: /*
        !           186:  * read block from Datakit link
        !           187:  * reads are timed
        !           188:  *     blk     -> address of buffer
        !           189:  *     len     -> size to read
        !           190:  *     fn      -> Datakit descriptor
        !           191:  * returns:
        !           192:  *     FAIL    -> link error timeout on link
        !           193:  *     i       -> # of bytes read
        !           194:  */
        !           195: drdblk(blk, len,  fn)
        !           196: register char *blk;
        !           197: {
        !           198:        register int i, ret;
        !           199: 
        !           200:        if(setjmp(Dfailbuf))
        !           201:                return(FAIL);
        !           202: 
        !           203:        for (i = 0; i < len; i += ret) {
        !           204:                (void) alarm(60);
        !           205:                if ((ret = read(fn, blk, (unsigned) len - i)) < 0) {
        !           206:                        (void) alarm(0);
        !           207:                        return(FAIL);
        !           208:                }
        !           209:                blk += ret;
        !           210:                if (ret == 0)   /* zero length block contains only EOF signal */
        !           211:                        break;
        !           212:        }
        !           213:        (void) alarm(0);
        !           214:        return(i);
        !           215: }
        !           216: #endif DATAKIT

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