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

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.