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

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.