Return to getbids.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / dsh / src

Annotation of 43BSD/contrib/dsh/src/getbids.c, revision 1.1.1.1

1.1       root        1: #include <sys/types.h>
                      2: #include <sys/socket.h>
                      3: #include <netinet/in.h>
                      4: #include <stdio.h>
                      5: #include <errno.h>
                      6: #include <sys/wait.h>
                      7: #include <signal.h>
                      8: #include <sys/time.h>
                      9: #include "dsh.h"
                     10: #include "dbid.h"
                     11: 
                     12: #define MAXWAIT        90              /* maximum time to wait */
                     13: #define MINWAIT 30             /* minimum time to wait */
                     14: 
                     15: int    errno;                  /* global error location */
                     16: bool   hflg;                   /* TRUE if specific host called for */
                     17: char   *spechost;              /* the specific host */
                     18: 
                     19: struct bid     *thebid;        /* pointer to the bids */
                     20: 
                     21: char           *myhostname();
                     22: long           myhostaddr();
                     23: bool           aflg;
                     24: 
                     25: /*
                     26:  *     get bids from the machines 
                     27:  */
                     28: getbids (av, thehost)
                     29: char   *av[];                  /* the command */
                     30: struct hostdef *thehost;       /* the hosts to use */
                     31: {
                     32:     int                        sock, port;
                     33:     char               portstr[10];
                     34:     int                        waiting;
                     35:     int                        fds, readfds;
                     36:     int                        rv, nodes, responses;
                     37:     int                        argc, ac;
                     38:     char               *argv[100];
                     39:     struct sockaddr_in addr;
                     40:     struct bidmsg      bm;
                     41:     struct hostdef     *hp;
                     42:     struct bid         *bp;
                     43:     bool               done;
                     44:     struct timeval     timeout;
                     45: 
                     46:     port = 0;
                     47:     sock = makedgsocket (&port);
                     48:     for (nodes = 0, hp = thehost; hp != 0; nodes++, hp = hp->h_next) {
                     49: 
                     50:        if (!hflg || (strcmp (spechost, hp->h_name) == 0)) {
                     51: 
                     52:            /* build the command */
                     53:            argc = 0;
                     54:            argv[argc++] = BIDCMD;
                     55:            argv[argc++] = "\"";
                     56:            for (ac = 0; av[ac] != 0; ac++) {
                     57:                argv[argc++] = av[ac];
                     58:            }
                     59:            argv[argc++] = "\"";
                     60:            argv[argc++] = myhostname();
                     61:            sprintf (portstr, "%d", port);
                     62:            argv[argc++] = portstr;
                     63:            argv[argc++] = hp->h_name;
                     64:            argv[argc] = 0;
                     65: 
                     66:            /* start up the bidcommand */
                     67:            rshell (hp, argv, FALSE, TRUE, FALSE, TRUE);
                     68:        }
                     69:     }
                     70: 
                     71:     /* wait for replies */
                     72:     waiting = responses = 0;
                     73:     thebid = 0;
                     74:     done = FALSE;
                     75:     do {
                     76:        readfds = 1<<sock;
                     77:        timeout.tv_sec = 2;
                     78:        timeout.tv_usec = 0;
                     79:        fds = select (20, &readfds, 0, 0, &timeout);
                     80:        if (fds == 0)
                     81:            waiting += 2;
                     82:        if (readfds & (1<<sock)) {
                     83:            rv = recvdg (sock, &bm, sizeof (struct bidmsg));
                     84:            if (rv < 0) {
                     85:                warn ("receiving bid");
                     86:            }
                     87:            for (hp = thehost; hp != 0; hp = hp->h_next) {
                     88:                if (strcmp (bm.bm_host, hp->h_name) == 0) {
                     89:                    strcpy (hp->h_dir, bm.bm_dir);
                     90:                    bp = new (struct bid);
                     91:                    bp->b_next = thebid;
                     92:                    /*
                     93:                    printf ("%s %s %f %f\n", hp->h_name, hp->h_dir,
                     94:                        hp->h_weight, bm.bm_bid);
                     95:                    */
                     96:                    bp->b_bid = bm.bm_bid * hp->h_weight;
                     97:                    bp->b_host = hp;
                     98:                    thebid = bp;
                     99:                    responses++;
                    100:                    break;
                    101:                }
                    102:            }
                    103:        }
                    104:        if (!aflg) {
                    105:            done = (waiting > MINWAIT && responses > 0) || (waiting > MAXWAIT)
                    106:                   || (nodes <= responses);
                    107:        } else {
                    108:            done = (waiting > MAXWAIT) || (nodes <= responses);
                    109:        }
                    110:     } while (!done);
                    111: }
                    112: 
                    113: 
                    114: /*
                    115:  *     find the highest bidder
                    116:  */
                    117: struct hostdef *
                    118: highest()
                    119: {
                    120:     struct bid         *bp, *bpp;
                    121:     double             high;
                    122: 
                    123:     /* find the highest bid */
                    124:     high = 0.0;
                    125:     bpp = 0;
                    126:     for (bp = thebid; bp != 0; bp = bp->b_next) {
                    127:        if (bp->b_bid > high) {
                    128:            high = bp->b_bid;
                    129:            bpp = bp;
                    130:        }
                    131:     }
                    132: 
                    133:     if (bpp == 0) {
                    134:        return (0);
                    135:     } else {
                    136: 
                    137:        /* remove highest from the list */
                    138:        if (bpp == thebid) {
                    139:            thebid = bpp->b_next;
                    140:        } else {
                    141:            for (bp = thebid; bp->b_next != bpp; bp = bp->b_next);
                    142:            bp->b_next = bpp->b_next;
                    143:        }
                    144:        return (bpp->b_host);
                    145:     }
                    146: }

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