1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 #pragma ident "%Z%%M% %I% %E% SMI"
23
24 /*
25 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
26 * Use is subject to license terms.
27 */
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <netdb.h>
32 #include <sys/param.h>
33 #include <sys/stat.h>
34 #include <sys/time.h>
35 #include <sys/socket.h>
36 #include <netinet/in.h>
37 #include <rpc/rpc.h>
38 #include <netdir.h>
39 #include <rpcsvc/rstat.h>
40 #include <rpc/pmap_clnt.h>
41
42
43 #define MACHINELEN 15 /* length of machine name printed out */
44 #define MACHINELENMAX 128 /* maximum machine name length */
45 #define AVENSIZE (3 * sizeof (long))
46 #define SLOTS 256
47
48 int machinecmp();
49 int loadcmp();
50 int uptimecmp();
51 static int collectnames();
52 int singlehost(); /* returns 1 if rup of given host fails */
53 void printsinglehosts();
54 void printnames();
55 static void putline();
56 int netbufeq(struct netbuf *ap, struct netbuf *bp);
57 void usage(void);
58
59 struct entry {
60 struct netconfig *nconf;
61 struct netbuf *addr;
62 char *machine;
63 struct timeval boottime;
64 time_t curtime;
65 long avenrun[3];
66 };
67
68 int total_entries;
69 int curentry;
70 struct entry *entry;
71 int vers; /* which version did the broadcasting */
72 int lflag; /* load: sort by load average */
73 int tflag; /* time: sort by uptime average */
74 int hflag; /* host: sort by machine name */
75 int dflag; /* debug: list only first n machines */
76 int debug;
77
78 int
79 main(int argc, char *argv[])
80 {
81 statsvar sv;
82 statstime st;
83 int single, nfailed;
84 enum clnt_stat bstat;
85
86 /*
87 * set number of slots to be 256 to begin with,
88 * this is large enough for most subnets but not all
89 */
90
91 curentry = 0;
92 total_entries = SLOTS;
93 entry = malloc(sizeof (struct entry) * total_entries);
94 single = nfailed = 0;
95 while (argc > 1) {
96 if (argv[1][0] != '-') {
97 single++;
98 nfailed += singlehost(argv[1]);
99 } else {
100 switch (argv[1][1]) {
101
102 case 'l':
103 lflag++;
104 break;
105 case 't':
106 tflag++;
107 break;
108 case 'h':
109 hflag++;
110 break;
111 case 'd':
112 dflag++;
113 if (argc < 3)
114 usage();
115 debug = atoi(argv[2]);
116 argc--;
117 argv++;
118 break;
119 default:
120 usage();
121 }
122 }
123 argv++;
124 argc--;
125 }
126 if (single > 0) {
127 if (hflag || tflag || lflag)
128 printsinglehosts();
129 if (nfailed == single) {
130 free(entry);
131 exit(1); /* all hosts we tried failed */
132 } else {
133 free(entry);
134 exit(0);
135 }
136
137 }
138 if (hflag || tflag || lflag) {
139 printf("collecting responses... ");
140 fflush(stdout);
141 }
142
143 sv.cp_time.cp_time_val = (int *)NULL;
144 sv.dk_xfer.dk_xfer_val = (int *)NULL;
145
146 /*
147 * Null out pointers in the statsvar struct
148 * so that we don't follow a random pointer
149 * somewhere when we get our results back.
150 * Set lengths to zero so we don't allocate
151 * some random amount of space we don't need
152 * (in the case where the reply was program
153 * not registered).
154 */
155 sv.cp_time.cp_time_len = 0;
156 sv.cp_time.cp_time_val = (int *)NULL;
157 sv.dk_xfer.dk_xfer_len = 0;
158 sv.dk_xfer.dk_xfer_val = (int *)NULL;
159
160 vers = RSTATVERS_VAR;
161 bstat = rpc_broadcast(RSTATPROG, RSTATVERS_VAR, RSTATPROC_STATS,
162 xdr_void, NULL, xdr_statsvar, (caddr_t)&sv,
163 (resultproc_t)collectnames, (char *)0);
164 #ifdef TESTING
165 if (bstat != RPC_SUCCESS)
166 printf("rpc_broadcast for rstat version %d returned %s\n",
167 vers, clnt_sperrno(bstat));
168 fprintf(stderr, "starting second round of broadcasting\n");
169 #endif
170 vers = RSTATVERS_TIME;
171 bstat = rpc_broadcast(RSTATPROG, RSTATVERS_TIME, RSTATPROC_STATS,
172 xdr_void, NULL, xdr_statstime, (caddr_t)&st,
173 (resultproc_t)collectnames, (char *)0);
174 #ifdef TESTING
175 if (bstat != RPC_SUCCESS)
176 printf("rpc_broadcast for rstat version %d returned %s\n",
177 vers, clnt_sperrno(bstat));
178 #endif
179 if (hflag || tflag || lflag)
180 printnames();
181
182
183
184 free(entry);
185 return (0);
186 }
187
188 int
189 singlehost(host)
190 char *host;
191 {
192 static int debugcnt;
193 enum clnt_stat err;
194 statstime st;
195 statsvar sw_var;
196 bool_t is_var_vers = FALSE;
197
198
199 if (curentry >= total_entries) {
200 struct entry *tmp;
201
202 total_entries += SLOTS;
203 tmp = realloc((struct entry *)entry, sizeof (struct entry)
204 * total_entries);
205 if (tmp == NULL) {
206 return (1);
207 }
208 entry = tmp;
209 }
210
211 sw_var.cp_time.cp_time_val = (int *)NULL;
212 sw_var.dk_xfer.dk_xfer_val = (int *)NULL;
213 err = (enum clnt_stat)callrpc(host, RSTATPROG, RSTATVERS_VAR,
214 RSTATPROC_STATS, xdr_void, 0, xdr_statsvar, &sw_var);
215 if (err == RPC_SUCCESS) {
216 is_var_vers = TRUE;
217 } else if (err == RPC_PROGVERSMISMATCH) {
218 err = (enum clnt_stat)callrpc(host, RSTATPROG, RSTATVERS_TIME,
219 RSTATPROC_STATS, xdr_void, 0, xdr_statstime, &st);
220 if (err != RPC_SUCCESS)
221 goto error;
222 } else
223 goto error;
224
225 debugcnt++;
226 if (!hflag && !lflag && !tflag) {
227 printf("%*.*s ", MACHINELEN, MACHINELEN, host);
228 if (is_var_vers == TRUE)
229 putline(sw_var.curtime.tv_sec, sw_var.boottime,
230 sw_var.avenrun);
231 else
232 putline(st.curtime.tv_sec, st.boottime, st.avenrun);
233 return (0); /* success */
234 } else {
235 entry[curentry].machine = host;
236 if (is_var_vers == FALSE) { /* RSTATVERS_TIME */
237 entry[curentry].boottime.tv_sec = st.boottime.tv_sec;
238 entry[curentry].boottime.tv_usec =
239 st.boottime.tv_usec;
240 entry[curentry].curtime = st.curtime.tv_sec;
241 memcpy(entry[curentry].avenrun, st.avenrun, AVENSIZE);
242 } else { /* RSTATVERS_VAR */
243 entry[curentry].boottime.tv_sec =
244 sw_var.boottime.tv_sec;
245 entry[curentry].boottime.tv_usec =
246 sw_var.boottime.tv_usec;
247 entry[curentry].curtime = sw_var.curtime.tv_sec;
248 memcpy(entry[curentry].avenrun, sw_var.avenrun,
249 AVENSIZE);
250 }
251 }
252 curentry++;
253 if (dflag && debugcnt >= debug)
254 return (1);
255 return (0);
256
257 error:
258 fprintf(stderr, "%*.*s: ", MACHINELEN, MACHINELEN, host);
259 clnt_perrno(err);
260 /*
261 * clnt_perrno now prints a newline
262 */
263 /* fprintf(stderr, "\n"); */
264 return (1); /* a failure */
265 }
266
267 static void
268 putline(now, boottime, avenrun)
269 time_t now;
270 struct timeval boottime;
271 long avenrun[];
272 {
273 int uptime, days, hrs, mins, i;
274
275 uptime = now - boottime.tv_sec;
276 uptime += 30;
277 if (uptime < 0) /* unsynchronized clocks */
278 uptime = 0;
279 days = uptime / (60*60*24);
280 uptime %= (60*60*24);
281 hrs = uptime / (60*60);
282 uptime %= (60*60);
283 mins = uptime / 60;
284
285 printf(" up");
286 if (days > 0)
287 printf(" %2d day%s", days, days > 1 ? "s," : ", ");
288 else
289 printf(" ");
290 if (hrs > 0)
291 printf(" %2d:%02d, ", hrs, mins);
292 else
293 printf(" %2d min%s", mins, mins > 1 ? "s," : ", ");
294
295 /*
296 * Print 1, 5, and 15 minute load averages.
297 * (Found by looking in kernel for avenrun).
298 */
299 printf(" load average:");
300 for (i = 0; i < (AVENSIZE / sizeof (avenrun[0])); i++) {
301 if (i > 0)
302 printf(",");
303 printf(" %.2f", (double)avenrun[i]/FSCALE);
304 }
305 printf("\n");
306 }
307
308 static int
309 collectnames(resultsp, taddr, nconf)
310 char *resultsp;
311 struct t_bind *taddr;
312 struct netconfig *nconf;
313 {
314 static int debugcnt;
315 register struct entry *entryp, *lim;
316 statstime *st;
317 statsvar *sv;
318 struct nd_hostservlist *hs;
319 extern struct netbuf *netbufdup();
320 extern struct netconfig *netconfigdup();
321 extern int netbufeq();
322
323 /*
324 * need to realloc more space if we have more than 256 machines
325 * that responded to the broadcast
326 */
327
328 if (curentry >= total_entries) {
329 struct entry *tmp;
330
331 total_entries += SLOTS;
332 tmp = realloc((struct entry *)entry, sizeof (struct entry)
333 * total_entries);
334 if (tmp == NULL) {
335 return (1);
336 }
337 entry = tmp;
338 }
339 /*
340 * weed out duplicates
341 */
342 lim = entry + curentry;
343 for (entryp = entry; entryp < lim; entryp++)
344 if (netbufeq(&taddr->addr, entryp->addr))
345 return (0);
346
347 if (vers == RSTATVERS_TIME) {
348 st = (statstime *)resultsp;
349 } else if (vers == RSTATVERS_VAR) {
350 sv = (statsvar *)resultsp;
351 } else {
352 return (0); /* we don't handle this version */
353 }
354 debugcnt++;
355 entry[curentry].nconf = netconfigdup(nconf);
356 entry[curentry].addr = netbufdup(&taddr->addr);
357
358 /*
359 * if raw, print this entry out immediately
360 * otherwise store for later sorting
361 */
362 if (!hflag && !lflag && !tflag) {
363 if (netdir_getbyaddr(nconf, &hs, &taddr->addr) == ND_OK)
364 printf("%*.*s ", MACHINELEN, MACHINELEN,
365 hs->h_hostservs->h_host);
366 else {
367 char *uaddr = taddr2uaddr(nconf, &taddr->addr);
368
369 if (uaddr) {
370 printf(" %*.*s", MACHINELEN, MACHINELEN,
371 uaddr);
372 (void) free(uaddr);
373 } else
374 printf(" %*.*s", MACHINELEN, MACHINELEN,
375 "unknown");
376 }
377 if (vers == RSTATVERS_TIME) {
378 putline(st->curtime.tv_sec, st->boottime, st->avenrun);
379 } else if (vers == RSTATVERS_VAR) {
380 putline(sv->curtime.tv_sec, sv->boottime, sv->avenrun);
381 }
382 } else {
383 if (vers == RSTATVERS_TIME) {
384 entry[curentry].boottime.tv_sec = st->boottime.tv_sec;
385 entry[curentry].boottime.tv_usec =
386 st->boottime.tv_usec;
387 entry[curentry].curtime = st->curtime.tv_sec;
388 memcpy(entry[curentry].avenrun, st->avenrun, AVENSIZE);
389 } else if (vers == RSTATVERS_VAR) {
390 entry[curentry].boottime.tv_sec = sv->boottime.tv_sec;
391 entry[curentry].boottime.tv_usec =
392 sv->boottime.tv_usec;
393 entry[curentry].curtime = sv->curtime.tv_sec;
394 memcpy(entry[curentry].avenrun, sv->avenrun, AVENSIZE);
395 }
396 }
397 curentry++;
398 if (dflag && debugcnt >= debug)
399 return (1);
400 return (0);
401 }
402
403 void
404 printsinglehosts()
405 {
406 register int i;
407 register struct entry *ep;
408
409
410 if (hflag)
411 qsort(entry, curentry, sizeof (struct entry), machinecmp);
412 else if (lflag)
413 qsort(entry, curentry, sizeof (struct entry), loadcmp);
414 else
415 qsort(entry, curentry, sizeof (struct entry), uptimecmp);
416 for (i = 0; i < curentry; i++) {
417 ep = &entry[i];
418 printf("%*.*s ", MACHINELEN, MACHINELEN, ep->machine);
419 putline(ep->curtime, ep->boottime, ep->avenrun);
420
421 }
422 }
423
424 void
425 printnames()
426 {
427 char buf[MACHINELENMAX+1];
428 struct nd_hostservlist *hs;
429 register int i;
430 register struct entry *ep;
431
432
433 for (i = 0; i < curentry; i++) {
434 ep = &entry[i];
435 if (netdir_getbyaddr(ep->nconf, &hs, ep->addr) == ND_OK)
436 sprintf(buf, "%s", hs->h_hostservs->h_host);
437 else {
438 char *uaddr = taddr2uaddr(ep->nconf, ep->addr);
439
440 if (uaddr) {
441 sprintf(buf, "%s", uaddr);
442 (void) free(uaddr);
443 } else
444 sprintf(buf, "%s", "unknown");
445 }
446 if (ep->machine = (char *)malloc(MACHINELENMAX + 1))
447 strcpy(ep->machine, buf);
448 }
449 printf("\n");
450 printsinglehosts();
451 }
452
453 int
454 machinecmp(struct entry *a, struct entry *b)
455 {
456 return (strcmp(a->machine, b->machine));
457 }
458
459 int
460 uptimecmp(struct entry *a, struct entry *b)
461 {
462 if (a->boottime.tv_sec != b->boottime.tv_sec)
463 return (a->boottime.tv_sec - b->boottime.tv_sec);
464 else
465 return (a->boottime.tv_usec - b->boottime.tv_usec);
466 }
467
468 int
469 loadcmp(struct entry *a, struct entry *b)
470 {
471 register int i;
472
473 for (i = 0; i < AVENSIZE / sizeof (a->avenrun[0]); i++)
474 if (a->avenrun[i] != b->avenrun[i])
475 return (a->avenrun[i] - b->avenrun[i]);
476
477 return (0);
478 }
479
480 struct netbuf *
481 netbufdup(ap)
482 register struct netbuf *ap;
483 {
484 register struct netbuf *np;
485
486 np = (struct netbuf *) malloc(sizeof (struct netbuf) + ap->len);
487 if (np) {
488 np->maxlen = np->len = ap->len;
489 np->buf = ((char *)np) + sizeof (struct netbuf);
490 (void) memcpy(np->buf, ap->buf, ap->len);
491 }
492 return (np);
493 }
494
495 struct netconfig *
496 netconfigdup(onp)
497 register struct netconfig *onp;
498 {
499 register int nlookupdirs;
500 register struct netconfig *nnp;
501 extern char *strdup();
502
503 nnp = (struct netconfig *)malloc(sizeof (struct netconfig));
504 if (nnp) {
505 nnp->nc_netid = strdup(onp->nc_netid);
506 nnp->nc_semantics = onp->nc_semantics;
507 nnp->nc_flag = onp->nc_flag;
508 nnp->nc_protofmly = strdup(onp->nc_protofmly);
509 nnp->nc_proto = strdup(onp->nc_proto);
510 nnp->nc_device = strdup(onp->nc_device);
511 nnp->nc_nlookups = onp->nc_nlookups;
512 if (onp->nc_nlookups == 0)
513 nnp->nc_lookups = (char **)0;
514 else {
515 register int i;
516
517 nnp->nc_lookups = (char **)malloc(onp->nc_nlookups *
518 sizeof (char *));
519 if (nnp->nc_lookups)
520 for (i = 0; i < onp->nc_nlookups; i++)
521 nnp->nc_lookups[i] =
522 strdup(onp->nc_lookups[i]);
523 }
524 }
525
526 return (nnp);
527 }
528
529 int
530 netbufeq(struct netbuf *ap, struct netbuf *bp)
531 {
532 return (ap->len == bp->len && !memcmp(ap->buf, bp->buf, ap->len));
533 }
534
535 void
536 usage(void)
537 {
538 fprintf(stderr, "Usage: rup [-h] [-l] [-t] [host ...]\n");
539 free(entry);
540 exit(1);
541 }