1 /* $OpenBSD: rup.c,v 1.23 2008/07/09 19:41:56 sobrado Exp $ */ 2 3 /*- 4 * Copyright (c) 1993, John Brezak 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. The name of the author may not be used to endorse or promote products 16 * derived from this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 #ifndef lint 32 static char rcsid[] = "$OpenBSD: rup.c,v 1.23 2008/07/09 19:41:56 sobrado Exp $"; 33 #endif /* not lint */ 34 35 #include <stdio.h> 36 #include <stdlib.h> 37 #include <string.h> 38 #include <time.h> 39 #include <sys/param.h> 40 #include <sys/socket.h> 41 #include <netdb.h> 42 #include <rpc/rpc.h> 43 #include <rpc/pmap_clnt.h> 44 #include <arpa/inet.h> 45 #include <err.h> 46 47 #undef FSHIFT /* Use protocol's shift and scale values */ 48 #undef FSCALE 49 #include <rpcsvc/rstat.h> 50 51 #define HOST_WIDTH 27 52 53 int printtime; /* print the remote host(s)'s time */ 54 55 struct host_list { 56 struct host_list *next; 57 struct in_addr addr; 58 } *hosts; 59 60 void usage(void); 61 int print_rup_data(char *, statstime *host_stat); 62 63 static int 64 search_host(struct in_addr addr) 65 { 66 struct host_list *hp; 67 68 if (!hosts) 69 return(0); 70 71 for (hp = hosts; hp != NULL; hp = hp->next) { 72 if (hp->addr.s_addr == addr.s_addr) 73 return(1); 74 } 75 return(0); 76 } 77 78 static void 79 remember_host(struct in_addr addr) 80 { 81 struct host_list *hp; 82 83 if (!(hp = (struct host_list *)malloc(sizeof(struct host_list)))) { 84 err(1, NULL); 85 /* NOTREACHED */ 86 } 87 hp->addr.s_addr = addr.s_addr; 88 hp->next = hosts; 89 hosts = hp; 90 } 91 92 93 struct rup_data { 94 char *host; 95 struct statstime statstime; 96 }; 97 struct rup_data *rup_data; 98 int rup_data_idx = 0; 99 int rup_data_max = 0; 100 101 enum sort_type { 102 SORT_NONE, 103 SORT_HOST, 104 SORT_LDAV, 105 SORT_UPTIME 106 }; 107 enum sort_type sort_type; 108 109 static int 110 compare(const void *v1, const void *v2) 111 { 112 const struct rup_data *d1 = v1; 113 const struct rup_data *d2 = v2; 114 115 switch(sort_type) { 116 case SORT_HOST: 117 return strcmp(d1->host, d2->host); 118 case SORT_LDAV: 119 return d1->statstime.avenrun[0] 120 - d2->statstime.avenrun[0]; 121 case SORT_UPTIME: 122 return d1->statstime.boottime.tv_sec 123 - d2->statstime.boottime.tv_sec; 124 default: 125 /* something's really wrong here */ 126 abort(); 127 } 128 } 129 130 static void 131 remember_rup_data(char *host, struct statstime *st) 132 { 133 if (rup_data_idx >= rup_data_max) { 134 int newsize; 135 struct rup_data *newrup; 136 137 newsize = rup_data_max + 16; 138 newrup = realloc(rup_data, newsize * sizeof(struct rup_data)); 139 if (newrup == NULL) { 140 err(1, NULL); 141 /* NOTREACHED */ 142 } 143 rup_data = newrup; 144 rup_data_max = newsize; 145 } 146 147 if ((rup_data[rup_data_idx].host = strdup(host)) == NULL) 148 err(1, NULL); 149 rup_data[rup_data_idx].statstime = *st; 150 rup_data_idx++; 151 } 152 153 154 static int 155 rstat_reply(char *replyp, struct sockaddr_in *raddrp) 156 { 157 struct hostent *hp; 158 char *host; 159 statstime *host_stat = (statstime *)replyp; 160 161 if (!search_host(raddrp->sin_addr)) { 162 hp = gethostbyaddr((char *)&raddrp->sin_addr.s_addr, 163 sizeof(struct in_addr), AF_INET); 164 if (hp) 165 host = hp->h_name; 166 else 167 host = inet_ntoa(raddrp->sin_addr); 168 169 remember_host(raddrp->sin_addr); 170 171 if (sort_type != SORT_NONE) 172 remember_rup_data(host, host_stat); 173 else 174 print_rup_data(host, host_stat); 175 } 176 177 return (0); 178 } 179 180 181 int 182 print_rup_data(char *host, statstime *host_stat) 183 { 184 unsigned int ups = 0, upm = 0, uph = 0, upd = 0; 185 struct tm *tmp_time, host_time; 186 char days_buf[16], hours_buf[16]; 187 188 if (printtime) 189 printf("%-*.*s", HOST_WIDTH-8, HOST_WIDTH-8, host); 190 else 191 printf("%-*.*s", HOST_WIDTH, HOST_WIDTH, host); 192 193 tmp_time = localtime((time_t *)&host_stat->curtime.tv_sec); 194 host_time = *tmp_time; 195 196 host_stat->curtime.tv_sec -= host_stat->boottime.tv_sec; 197 198 if (host_stat->curtime.tv_sec > 0) 199 ups = host_stat->curtime.tv_sec; 200 upd = ups / (3600 * 24); 201 ups -= upd * 3600 * 24; 202 uph = ups / 3600; 203 ups -= uph * 3600; 204 upm = ups / 60; 205 206 if (upd != 0) 207 snprintf(days_buf, sizeof days_buf, "%3u day%s, ", upd, 208 (upd > 1) ? "s" : ""); 209 else 210 days_buf[0] = '\0'; 211 212 if (uph != 0) 213 snprintf(hours_buf, sizeof hours_buf, "%2u:%02u, ", 214 uph, upm); 215 else 216 if (upm != 0) 217 snprintf(hours_buf, sizeof hours_buf, "%2u min%s ", 218 upm, (upm == 1) ? ", " : "s,"); 219 else 220 hours_buf[0] = '\0'; 221 222 if (printtime) 223 printf(" %2d:%02d%cm", 224 (host_time.tm_hour % 12) ? (host_time.tm_hour % 12) : 12, 225 host_time.tm_min, 226 (host_time.tm_hour >= 12) ? 'p' : 'a'); 227 228 printf(" up %9.9s%9.9s load average: %.2f %.2f %.2f\n", 229 days_buf, hours_buf, 230 (double)host_stat->avenrun[0] / FSCALE, 231 (double)host_stat->avenrun[1] / FSCALE, 232 (double)host_stat->avenrun[2] / FSCALE); 233 234 return(0); 235 } 236 237 238 static void 239 onehost(char *host) 240 { 241 CLIENT *rstat_clnt; 242 statstime host_stat; 243 static struct timeval timeout = {25, 0}; 244 extern char *__progname; 245 246 rstat_clnt = clnt_create(host, RSTATPROG, RSTATVERS_TIME, "udp"); 247 if (rstat_clnt == NULL) { 248 fprintf(stderr, "%s: %s", __progname, 249 clnt_spcreateerror(host)); 250 return; 251 } 252 253 bzero((char *)&host_stat, sizeof(host_stat)); 254 if (clnt_call(rstat_clnt, RSTATPROC_STATS, xdr_void, NULL, 255 xdr_statstime, &host_stat, timeout) != RPC_SUCCESS) { 256 fprintf(stderr, "%s: %s", __progname, 257 clnt_sperror(rstat_clnt, host)); 258 clnt_destroy(rstat_clnt); 259 return; 260 } 261 262 if (sort_type != SORT_NONE) 263 remember_rup_data(host, &host_stat); 264 else 265 print_rup_data(host, &host_stat); 266 267 clnt_destroy(rstat_clnt); 268 } 269 270 static void 271 allhosts(void) 272 { 273 statstime host_stat; 274 enum clnt_stat clnt_stat; 275 extern char *__progname; 276 277 if (sort_type != SORT_NONE) { 278 printf("collecting responses...\n"); 279 fflush(stdout); 280 } 281 282 clnt_stat = clnt_broadcast(RSTATPROG, RSTATVERS_TIME, RSTATPROC_STATS, 283 xdr_void, NULL, xdr_statstime, (char *)&host_stat, rstat_reply); 284 if (clnt_stat != RPC_SUCCESS && clnt_stat != RPC_TIMEDOUT) { 285 fprintf(stderr, "%s: %s\n", __progname, clnt_sperrno(clnt_stat)); 286 exit(1); 287 } 288 } 289 290 int 291 main(int argc, char *argv[]) 292 { 293 int ch; 294 size_t i; 295 extern int optind; 296 297 sort_type = SORT_NONE; 298 while ((ch = getopt(argc, argv, "dhlt")) != -1) 299 switch (ch) { 300 case 'd': 301 printtime = 1; 302 break; 303 case 'h': 304 sort_type = SORT_HOST; 305 break; 306 case 'l': 307 sort_type = SORT_LDAV; 308 break; 309 case 't': 310 sort_type = SORT_UPTIME; 311 break; 312 default: 313 usage(); 314 /*NOTREACHED*/ 315 } 316 317 setlinebuf(stdout); 318 319 if (argc == optind) 320 allhosts(); 321 else { 322 for (; optind < argc; optind++) 323 onehost(argv[optind]); 324 } 325 326 if (sort_type != SORT_NONE) { 327 qsort(rup_data, rup_data_idx, sizeof(struct rup_data), 328 compare); 329 330 for (i = 0; i < rup_data_idx; i++) { 331 print_rup_data(rup_data[i].host, 332 &rup_data[i].statstime); 333 } 334 } 335 336 exit(0); 337 } 338 339 340 void 341 usage(void) 342 { 343 fprintf(stderr, "usage: rup [-dhlt] [host ...]\n"); 344 exit(1); 345 } 346