Return to dkxwrite.c CVS log

Up to [Research Unix] / researchv10dc / ipc / bin / OLDdkcc

Annotation of researchv10dc/ipc/bin/OLDdkcc/dkxwrite.c, revision 1.1

1.1     ! root        1:        static char     SCCSID[] = "@(#)dkxwrite.c      2.1 DKHOST 84/08/28";
        !             2: 
        !             3: #include "remfio.h"
        !             4: #include <stdio.h>
        !             5: #include "sysexits.h"
        !             6: 
        !             7:        /* extern int   dkverbose; */
        !             8: 
        !             9: /*
        !            10:  * Write a length-preceeded block over a dkxqt protocol channel
        !            11:  *
        !            12:  *     netfd   = file descriptor to use
        !            13:  *     addr    = character pointer to beginning of block
        !            14:  *     len     = number of bytes in block
        !            15:  *     return  = >0 : write successful
        !            16:  *             | <0 : write failed
        !            17:  */
        !            18: 
        !            19: dkxlwrite(netfd, addr, len)
        !            20:        char                    *addr;
        !            21: {
        !            22:        int                     n;
        !            23:        short                   slen;
        !            24:        char                    clen[3];
        !            25: 
        !            26:        slen = len;
        !            27: 
        !            28:        dktcanon("s", &slen, clen);
        !            29: 
        !            30:        if((n = dkxwrite(netfd, clen, 2)) < 0)
        !            31:                return(n);
        !            32: 
        !            33:        if(len > 0)
        !            34:                n = dkxwrite(netfd, addr, len);
        !            35: 
        !            36:        return(n);
        !            37: }
        !            38: 
        !            39: /*
        !            40:  * Write a block over a dkxqt protocol channel
        !            41:  *
        !            42:  *     netfd   = file descriptor to use
        !            43:  *     addr    = character pointer to beginning of block
        !            44:  *     len     = number of bytes in block
        !            45:  *     return  = >0 : write successful
        !            46:  *             | <0 : write failed
        !            47:  */
        !            48: 
        !            49: dkxwrite(netfd, addr, len)
        !            50:        char                    *addr;
        !            51: {
        !            52:        int                     n;
        !            53: 
        !            54:        if((n = dkxpwrite(netfd, len)) < 0)
        !            55:                return(n);
        !            56: 
        !            57:        return(write(netfd, addr, len));
        !            58: }
        !            59: 
        !            60: /*
        !            61:  * Prepare to write a block over a dkxqt protocol channel
        !            62:  *
        !            63:  * Write the protocol envelope necessary before sending the block itself
        !            64:  *
        !            65:  *     netfd   = file descriptor to use
        !            66:  *     len     = number of bytes in block
        !            67:  *     return  = >0 : write successful
        !            68:  *             | <0 : write failed
        !            69:  */
        !            70: 
        !            71: dkxpwrite(netfd, len)
        !            72: {
        !            73:        int                     n;
        !            74:        struct rem_req          r;
        !            75:        struct rem_reply        s;
        !            76:        char                    sb[REMSIZE], rb[REMSIZE];
        !            77: 
        !            78:        n = iread(netfd, rb, REMSIZE);
        !            79:        dkfcanon(F_REMREQ, rb, &r);
        !            80: 
        !            81:        if(n != REMSIZE || r.r_type != RREAD || r.r_var.rread.r_count != len){
        !            82:                /* if(dkverbose)
        !            83:                        fprintf(stderr, "dkxpwrite: REMREQ wrong\n"); */
        !            84:                return(-EX_PROTOCOL);
        !            85:        }
        !            86: 
        !            87:        s.s_type = RREAD;
        !            88:        s.s_length = len;
        !            89:        s.s_error = 0;
        !            90:        s.s_resid = 0;
        !            91:        dktcanon(F_REMREPLY, &s, sb) ;
        !            92: 
        !            93:        return(write(netfd, sb, REMSIZE));
        !            94: }

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