/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ #pragma ident "%Z%%M% %I% %E% SMI" /* * Copyright 2005 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include <stdio.h> #include <stdlib.h> #include <netdb.h> #include <sys/param.h> #include <sys/stat.h> #include <sys/time.h> #include <sys/socket.h> #include <netinet/in.h> #include <rpc/rpc.h> #include <netdir.h> #include <rpcsvc/rstat.h> #include <rpc/pmap_clnt.h> #define MACHINELEN 15 /* length of machine name printed out */ #define MACHINELENMAX 128 /* maximum machine name length */ #define AVENSIZE (3 * sizeof (long)) #define SLOTS 256 int machinecmp(); int loadcmp(); int uptimecmp(); static int collectnames(); int singlehost(); /* returns 1 if rup of given host fails */ void printsinglehosts(); void printnames(); static void putline(); int netbufeq(struct netbuf *ap, struct netbuf *bp); void usage(void); struct entry { struct netconfig *nconf; struct netbuf *addr; char *machine; struct timeval boottime; time_t curtime; long avenrun[3]; }; int total_entries; int curentry; struct entry *entry; int vers; /* which version did the broadcasting */ int lflag; /* load: sort by load average */ int tflag; /* time: sort by uptime average */ int hflag; /* host: sort by machine name */ int dflag; /* debug: list only first n machines */ int debug; int main(int argc, char *argv[]) { statsvar sv; statstime st; int single, nfailed; enum clnt_stat bstat; /* * set number of slots to be 256 to begin with, * this is large enough for most subnets but not all */ curentry = 0; total_entries = SLOTS; entry = malloc(sizeof (struct entry) * total_entries); single = nfailed = 0; while (argc > 1) { if (argv[1][0] != '-') { single++; nfailed += singlehost(argv[1]); } else { switch (argv[1][1]) { case 'l': lflag++; break; case 't': tflag++; break; case 'h': hflag++; break; case 'd': dflag++; if (argc < 3) usage(); debug = atoi(argv[2]); argc--; argv++; break; default: usage(); } } argv++; argc--; } if (single > 0) { if (hflag || tflag || lflag) printsinglehosts(); if (nfailed == single) { free(entry); exit(1); /* all hosts we tried failed */ } else { free(entry); exit(0); } } if (hflag || tflag || lflag) { printf("collecting responses... "); fflush(stdout); } sv.cp_time.cp_time_val = (int *)NULL; sv.dk_xfer.dk_xfer_val = (int *)NULL; /* * Null out pointers in the statsvar struct * so that we don't follow a random pointer * somewhere when we get our results back. * Set lengths to zero so we don't allocate * some random amount of space we don't need * (in the case where the reply was program * not registered). */ sv.cp_time.cp_time_len = 0; sv.cp_time.cp_time_val = (int *)NULL; sv.dk_xfer.dk_xfer_len = 0; sv.dk_xfer.dk_xfer_val = (int *)NULL; vers = RSTATVERS_VAR; bstat = rpc_broadcast(RSTATPROG, RSTATVERS_VAR, RSTATPROC_STATS, xdr_void, NULL, xdr_statsvar, (caddr_t)&sv, (resultproc_t)collectnames, (char *)0); #ifdef TESTING if (bstat != RPC_SUCCESS) printf("rpc_broadcast for rstat version %d returned %s\n", vers, clnt_sperrno(bstat)); fprintf(stderr, "starting second round of broadcasting\n"); #endif vers = RSTATVERS_TIME; bstat = rpc_broadcast(RSTATPROG, RSTATVERS_TIME, RSTATPROC_STATS, xdr_void, NULL, xdr_statstime, (caddr_t)&st, (resultproc_t)collectnames, (char *)0); #ifdef TESTING if (bstat != RPC_SUCCESS) printf("rpc_broadcast for rstat version %d returned %s\n", vers, clnt_sperrno(bstat)); #endif if (hflag || tflag || lflag) printnames(); free(entry); return (0); } int singlehost(host) char *host; { static int debugcnt; enum clnt_stat err; statstime st; statsvar sw_var; bool_t is_var_vers = FALSE; if (curentry >= total_entries) { struct entry *tmp; total_entries += SLOTS; tmp = realloc((struct entry *)entry, sizeof (struct entry) * total_entries); if (tmp == NULL) { return (1); } entry = tmp; } sw_var.cp_time.cp_time_val = (int *)NULL; sw_var.dk_xfer.dk_xfer_val = (int *)NULL; err = (enum clnt_stat)callrpc(host, RSTATPROG, RSTATVERS_VAR, RSTATPROC_STATS, xdr_void, 0, xdr_statsvar, &sw_var); if (err == RPC_SUCCESS) { is_var_vers = TRUE; } else if (err == RPC_PROGVERSMISMATCH) { err = (enum clnt_stat)callrpc(host, RSTATPROG, RSTATVERS_TIME, RSTATPROC_STATS, xdr_void, 0, xdr_statstime, &st); if (err != RPC_SUCCESS) goto error; } else goto error; debugcnt++; if (!hflag && !lflag && !tflag) { printf("%*.*s ", MACHINELEN, MACHINELEN, host); if (is_var_vers == TRUE) putline(sw_var.curtime.tv_sec, sw_var.boottime, sw_var.avenrun); else putline(st.curtime.tv_sec, st.boottime, st.avenrun); return (0); /* success */ } else { entry[curentry].machine = host; if (is_var_vers == FALSE) { /* RSTATVERS_TIME */ entry[curentry].boottime.tv_sec = st.boottime.tv_sec; entry[curentry].boottime.tv_usec = st.boottime.tv_usec; entry[curentry].curtime = st.curtime.tv_sec; memcpy(entry[curentry].avenrun, st.avenrun, AVENSIZE); } else { /* RSTATVERS_VAR */ entry[curentry].boottime.tv_sec = sw_var.boottime.tv_sec; entry[curentry].boottime.tv_usec = sw_var.boottime.tv_usec; entry[curentry].curtime = sw_var.curtime.tv_sec; memcpy(entry[curentry].avenrun, sw_var.avenrun, AVENSIZE); } } curentry++; if (dflag && debugcnt >= debug) return (1); return (0); error: fprintf(stderr, "%*.*s: ", MACHINELEN, MACHINELEN, host); clnt_perrno(err); /* * clnt_perrno now prints a newline */ /* fprintf(stderr, "\n"); */ return (1); /* a failure */ } static void putline(now, boottime, avenrun) time_t now; struct timeval boottime; long avenrun[]; { int uptime, days, hrs, mins, i; uptime = now - boottime.tv_sec; uptime += 30; if (uptime < 0) /* unsynchronized clocks */ uptime = 0; days = uptime / (60*60*24); uptime %= (60*60*24); hrs = uptime / (60*60); uptime %= (60*60); mins = uptime / 60; printf(" up"); if (days > 0) printf(" %2d day%s", days, days > 1 ? "s," : ", "); else printf(" "); if (hrs > 0) printf(" %2d:%02d, ", hrs, mins); else printf(" %2d min%s", mins, mins > 1 ? "s," : ", "); /* * Print 1, 5, and 15 minute load averages. * (Found by looking in kernel for avenrun). */ printf(" load average:"); for (i = 0; i < (AVENSIZE / sizeof (avenrun[0])); i++) { if (i > 0) printf(","); printf(" %.2f", (double)avenrun[i]/FSCALE); } printf("\n"); } static int collectnames(resultsp, taddr, nconf) char *resultsp; struct t_bind *taddr; struct netconfig *nconf; { static int debugcnt; register struct entry *entryp, *lim; statstime *st; statsvar *sv; struct nd_hostservlist *hs; extern struct netbuf *netbufdup(); extern struct netconfig *netconfigdup(); extern int netbufeq(); /* * need to realloc more space if we have more than 256 machines * that responded to the broadcast */ if (curentry >= total_entries) { struct entry *tmp; total_entries += SLOTS; tmp = realloc((struct entry *)entry, sizeof (struct entry) * total_entries); if (tmp == NULL) { return (1); } entry = tmp; } /* * weed out duplicates */ lim = entry + curentry; for (entryp = entry; entryp < lim; entryp++) if (netbufeq(&taddr->addr, entryp->addr)) return (0); if (vers == RSTATVERS_TIME) { st = (statstime *)resultsp; } else if (vers == RSTATVERS_VAR) { sv = (statsvar *)resultsp; } else { return (0); /* we don't handle this version */ } debugcnt++; entry[curentry].nconf = netconfigdup(nconf); entry[curentry].addr = netbufdup(&taddr->addr); /* * if raw, print this entry out immediately * otherwise store for later sorting */ if (!hflag && !lflag && !tflag) { if (netdir_getbyaddr(nconf, &hs, &taddr->addr) == ND_OK) printf("%*.*s ", MACHINELEN, MACHINELEN, hs->h_hostservs->h_host); else { char *uaddr = taddr2uaddr(nconf, &taddr->addr); if (uaddr) { printf(" %*.*s", MACHINELEN, MACHINELEN, uaddr); (void) free(uaddr); } else printf(" %*.*s", MACHINELEN, MACHINELEN, "unknown"); } if (vers == RSTATVERS_TIME) { putline(st->curtime.tv_sec, st->boottime, st->avenrun); } else if (vers == RSTATVERS_VAR) { putline(sv->curtime.tv_sec, sv->boottime, sv->avenrun); } } else { if (vers == RSTATVERS_TIME) { entry[curentry].boottime.tv_sec = st->boottime.tv_sec; entry[curentry].boottime.tv_usec = st->boottime.tv_usec; entry[curentry].curtime = st->curtime.tv_sec; memcpy(entry[curentry].avenrun, st->avenrun, AVENSIZE); } else if (vers == RSTATVERS_VAR) { entry[curentry].boottime.tv_sec = sv->boottime.tv_sec; entry[curentry].boottime.tv_usec = sv->boottime.tv_usec; entry[curentry].curtime = sv->curtime.tv_sec; memcpy(entry[curentry].avenrun, sv->avenrun, AVENSIZE); } } curentry++; if (dflag && debugcnt >= debug) return (1); return (0); } void printsinglehosts() { register int i; register struct entry *ep; if (hflag) qsort(entry, curentry, sizeof (struct entry), machinecmp); else if (lflag) qsort(entry, curentry, sizeof (struct entry), loadcmp); else qsort(entry, curentry, sizeof (struct entry), uptimecmp); for (i = 0; i < curentry; i++) { ep = &entry[i]; printf("%*.*s ", MACHINELEN, MACHINELEN, ep->machine); putline(ep->curtime, ep->boottime, ep->avenrun); } } void printnames() { char buf[MACHINELENMAX+1]; struct nd_hostservlist *hs; register int i; register struct entry *ep; for (i = 0; i < curentry; i++) { ep = &entry[i]; if (netdir_getbyaddr(ep->nconf, &hs, ep->addr) == ND_OK) sprintf(buf, "%s", hs->h_hostservs->h_host); else { char *uaddr = taddr2uaddr(ep->nconf, ep->addr); if (uaddr) { sprintf(buf, "%s", uaddr); (void) free(uaddr); } else sprintf(buf, "%s", "unknown"); } if (ep->machine = (char *)malloc(MACHINELENMAX + 1)) strcpy(ep->machine, buf); } printf("\n"); printsinglehosts(); } int machinecmp(struct entry *a, struct entry *b) { return (strcmp(a->machine, b->machine)); } int uptimecmp(struct entry *a, struct entry *b) { if (a->boottime.tv_sec != b->boottime.tv_sec) return (a->boottime.tv_sec - b->boottime.tv_sec); else return (a->boottime.tv_usec - b->boottime.tv_usec); } int loadcmp(struct entry *a, struct entry *b) { register int i; for (i = 0; i < AVENSIZE / sizeof (a->avenrun[0]); i++) if (a->avenrun[i] != b->avenrun[i]) return (a->avenrun[i] - b->avenrun[i]); return (0); } struct netbuf * netbufdup(ap) register struct netbuf *ap; { register struct netbuf *np; np = (struct netbuf *) malloc(sizeof (struct netbuf) + ap->len); if (np) { np->maxlen = np->len = ap->len; np->buf = ((char *)np) + sizeof (struct netbuf); (void) memcpy(np->buf, ap->buf, ap->len); } return (np); } struct netconfig * netconfigdup(onp) register struct netconfig *onp; { register int nlookupdirs; register struct netconfig *nnp; extern char *strdup(); nnp = (struct netconfig *)malloc(sizeof (struct netconfig)); if (nnp) { nnp->nc_netid = strdup(onp->nc_netid); nnp->nc_semantics = onp->nc_semantics; nnp->nc_flag = onp->nc_flag; nnp->nc_protofmly = strdup(onp->nc_protofmly); nnp->nc_proto = strdup(onp->nc_proto); nnp->nc_device = strdup(onp->nc_device); nnp->nc_nlookups = onp->nc_nlookups; if (onp->nc_nlookups == 0) nnp->nc_lookups = (char **)0; else { register int i; nnp->nc_lookups = (char **)malloc(onp->nc_nlookups * sizeof (char *)); if (nnp->nc_lookups) for (i = 0; i < onp->nc_nlookups; i++) nnp->nc_lookups[i] = strdup(onp->nc_lookups[i]); } } return (nnp); } int netbufeq(struct netbuf *ap, struct netbuf *bp) { return (ap->len == bp->len && !memcmp(ap->buf, bp->buf, ap->len)); } void usage(void) { fprintf(stderr, "Usage: rup [-h] [-l] [-t] [host ...]\n"); free(entry); exit(1); }