Return to remote.c CVS log

Up to [Research Unix] / researchv10no / cmd / 2500

Annotation of researchv10no/cmd/2500/remote.c, revision 1.1

1.1     ! root        1: #include       <fio.h>
        !             2: #include       "hdr.h"
        !             3: 
        !             4: #define                RELAY           "/v/bin/2500relay"
        !             5: 
        !             6: static int frameno;
        !             7: static int ifd, ofd;
        !             8: static spawn(char *sys, char *relay, char *prog, int *i, int *o);
        !             9: 
        !            10: remsetup(char *system, char *prog, char *relay)
        !            11: {
        !            12:        if(relay == 0)
        !            13:                relay = RELAY;
        !            14:        if(spawn(system, relay, prog,  &ifd, &ofd))
        !            15:                exit(1);
        !            16:        Finit(ofd, (char *)0);
        !            17: }
        !            18: 
        !            19: remsframe(char *str)
        !            20: {
        !            21:        char *s;
        !            22: 
        !            23:        fprint(ifd, "%s\n", str);
        !            24:        if(s = Frdline(ofd)){
        !            25:                if(*s)
        !            26:                        fprint(2, "[remote] %s\n", s);
        !            27:        } else {
        !            28:                perror("remote died");
        !            29:                exit(1);
        !            30:        }
        !            31: }
        !            32: 
        !            33: remiframe(int fr)
        !            34: {
        !            35:        char buf[64];
        !            36: 
        !            37:        if(fr >= 0)
        !            38:                frameno = fr;
        !            39:        sprint(buf, "%d", frameno);
        !            40:        frameno++;
        !            41:        remsframe(buf);
        !            42: }
        !            43: 
        !            44: shoot(int start, int nframes, int snapc)
        !            45: {
        !            46:        int n = nframes;
        !            47:        frameno = start;
        !            48:        print("shooting frames %d..%d\n", start, start+nframes-1);
        !            49:        while(nframes-- > 0){
        !            50:                remiframe(-1);
        !            51:                snap(snapc);
        !            52:        }
        !            53:        print("shot %d frames\n", n);
        !            54: }
        !            55: 
        !            56: static
        !            57: spawn(char *sys, char *relay, char *prog, int *i, int *o)
        !            58: {
        !            59:        int toremote[2], fromremote[2];
        !            60:        int n;
        !            61: 
        !            62:        if((pipe(toremote) < 0) || (pipe(fromremote) < 0)){
        !            63:                perror("pipe");
        !            64:                return(1);
        !            65:        }
        !            66:        if((n = fork()) < 0){
        !            67:                perror("fork");
        !            68:                return(1);
        !            69:        }
        !            70:        if(n){  /* parent */
        !            71:                *i = toremote[1];
        !            72:                close(toremote[0]);
        !            73:                *o = fromremote[0];
        !            74:                close(fromremote[1]);
        !            75:                remsframe(prog);
        !            76:        } else {
        !            77:                char buf[256];
        !            78: 
        !            79:                close(logfd);
        !            80:                dup2(toremote[0], 0);
        !            81:                dup2(fromremote[1], 1);
        !            82:                close(toremote[0]);
        !            83:                close(toremote[1]);
        !            84:                close(fromremote[0]);
        !            85:                close(fromremote[1]);
        !            86:                sprint(buf, "rsh %s '%s'", sys, relay);
        !            87:                system(buf);
        !            88:                sleep(5);
        !            89:                exit(1);
        !            90:        }
        !            91:        return(0);
        !            92: }

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