?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dnscrypto-proxy: Update to release 1.3.0
[tomato.git] / release / src / router / snmp / apps / snmpdelta.c
blob0d78c97e7e5945296b36671724e40b2b21487f76
1 /*
2 * snmpdelta.c - Monitor deltas of integer valued SNMP variables
3 *
4 */
5 /**********************************************************************
6 *
7 * Copyright 1996 by Carnegie Mellon University
8 *
9 * All Rights Reserved
10 *
11 * Permission to use, copy, modify, and distribute this software and its
12 * documentation for any purpose and without fee is hereby granted,
13 * provided that the above copyright notice appear in all copies and that
14 * both that copyright notice and this permission notice appear in
15 * supporting documentation, and that the name of CMU not be
16 * used in advertising or publicity pertaining to distribution of the
17 * software without specific, written prior permission.
18 *
19 * CMU DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
20 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
21 * CMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
22 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
23 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
24 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
25 * SOFTWARE.
26 *
27 **********************************************************************/
28
29 #include <net-snmp/net-snmp-config.h>
30
31 #if HAVE_STDLIB_H
32 #include <stdlib.h>
33 #endif
34 #if HAVE_UNISTD_H
35 #include <unistd.h>
36 #endif
37 #if HAVE_STRING_H
38 #include <string.h>
39 #else
40 #include <strings.h>
41 #endif
42 #include <sys/types.h>
43 #if HAVE_NETINET_IN_H
44 #include <netinet/in.h>
45 #endif
46 #include <stdio.h>
47 #include <ctype.h>
48 #if TIME_WITH_SYS_TIME
49 # ifdef WIN32
50 # include <sys/timeb.h>
51 # else
52 # include <sys/time.h>
53 # endif
54 # include <time.h>
55 #else
56 # if HAVE_SYS_TIME_H
57 # include <sys/time.h>
58 # else
59 # include <time.h>
60 # endif
61 #endif
62 #if HAVE_SYS_SELECT_H
63 #include <sys/select.h>
64 #endif
65 #if HAVE_WINSOCK_H
66 #include <winsock.h>
67 #endif
68 #if HAVE_NETDB_H
69 #include <netdb.h>
70 #endif
71 #if HAVE_ARPA_INET_H
72 #include <arpa/inet.h>
73 #endif
74
75 #include <net-snmp/net-snmp-includes.h>
76
77 #define MAX_ARGS 256
78 #define NETSNMP_DS_APP_DONT_FIX_PDUS 0
79
80 const char *SumFile = "Sum";
81
82 /*
83 * Information about the handled variables
84 */
85 struct varInfo {
86 char *name;
87 oid *info_oid;
88 int type;
89 size_t oidlen;
90 char descriptor[64];
91 u_int value;
92 struct counter64 c64value;
93 float max;
94 time_t time;
95 int peak_count;
96 float peak;
97 float peak_average;
98 int spoiled;
99 };
100
101 struct varInfo varinfo[128];
102 int current_name = 0;
103 int period = 1;
104 int deltat = 0, timestamp = 0, fileout = 0, dosum =
105 0, printmax = 0;
106 int keepSeconds = 0, peaks = 0;
107 int tableForm = 0;
108 int varbindsPerPacket = 60;
109
110 void processFileArgs(char *fileName);
111
112 void
113 usage(void)
114 {
115 fprintf(stderr,
116 "Usage: snmpdelta [-Cf] [-CF commandFile] [-Cl] [-CL SumFileName]\n\t[-Cs] [-Ck] [-Ct] [-CS] [-Cv vars/pkt] [-Cp period]\n\t[-CP peaks] ");
117 snmp_parse_args_usage(stderr);
118 fprintf(stderr, " oid [oid ...]\n");
119 snmp_parse_args_descriptions(stderr);
120 fprintf(stderr, "snmpdelta specific options\n");
121 fprintf(stderr, " -Cf\t\tDon't fix errors and retry the request.\n");
122 fprintf(stderr, " -Cl\t\twrite configuration to file\n");
123 fprintf(stderr, " -CF config\tload configuration from file\n");
124 fprintf(stderr, " -Cp period\tspecifies the poll period\n");
125 fprintf(stderr, " -CP peaks\treporting period in poll periods\n");
126 fprintf(stderr, " -Cv vars/pkt\tnumber of variables per packet\n");
127 fprintf(stderr, " -Ck\t\tkeep seconds in output time\n");
128 fprintf(stderr, " -Cm\t\tshow max values\n");
129 fprintf(stderr, " -CS\t\tlog to a sum file\n");
130 fprintf(stderr, " -Cs\t\tshow timestamps\n");
131 fprintf(stderr, " -Ct\t\tget timing from agent\n");
132 fprintf(stderr, " -CT\t\tprint output in tabular form\n");
133 fprintf(stderr, " -CL sumfile\tspecifies the sum file name\n");
134 }
135
136 static void
137 optProc(int argc, char *const *argv, int opt)
138 {
139 switch (opt) {
140 case 'C':
141 while (*optarg) {
142 switch ((opt = *optarg++)) {
143 case 'f':
144 netsnmp_ds_toggle_boolean(NETSNMP_DS_APPLICATION_ID,
145 NETSNMP_DS_APP_DONT_FIX_PDUS);
146 break;
147 case 'p':
148 period = atoi(argv[optind++]);
149 break;
150 case 'P':
151 peaks = atoi(argv[optind++]);
152 break;
153 case 'v':
154 varbindsPerPacket = atoi(argv[optind++]);
155 break;
156 case 't':
157 deltat = 1;
158 break;
159 case 's':
160 timestamp = 1;
161 break;
162 case 'S':
163 dosum = 1;
164 break;
165 case 'm':
166 printmax = 1;
167 break;
168 case 'F':
169 processFileArgs(argv[optind++]);
170 break;
171 case 'l':
172 fileout = 1;
173 break;
174 case 'L':
175 SumFile = argv[optind++];
176 break;
177 case 'k':
178 keepSeconds = 1;
179 break;
180 case 'T':
181 tableForm = 1;
182 break;
183 default:
184 fprintf(stderr, "Bad -C options: %c\n", opt);
185 exit(1);
186 }
187 }
188 break;
189 }
190 }
191
192 int
193 wait_for_peak_start(int period, int peak)
194 {
195 struct timeval m_time, *tv = &m_time;
196 struct tm tm;
197 time_t SecondsAtNextHour;
198 int target = 0;
199 int seconds;
200
201 seconds = period * peak;
202
203 /*
204 * Find the current time
205 */
206 gettimeofday(tv, (struct timezone *) 0);
207
208 /*
209 * Create a tm struct from it
210 */
211 memcpy(&tm, localtime((time_t *) & tv->tv_sec), sizeof(tm));
212
213 /*
214 * Calculate the next hour
215 */
216 tm.tm_sec = 0;
217 tm.tm_min = 0;
218 tm.tm_hour++;
219 SecondsAtNextHour = mktime(&tm);
220
221 /*
222 * Now figure out the amount of time to sleep
223 */
224 target = (SecondsAtNextHour - tv->tv_sec) % seconds;
225
226 return target;
227 }
228
229 void
230 print_log(char *file, char *message)
231 {
232 FILE *fp;
233
234 fp = fopen(file, "a");
235 if (fp == NULL) {
236 fprintf(stderr, "Couldn't open %s\n", file);
237 return;
238 }
239 fprintf(fp, "%s\n", message);
240 fclose(fp);
241 }
242
243 void
244 sprint_descriptor(char *buffer, struct varInfo *vip)
245 {
246 u_char *buf = NULL, *cp = NULL;
247 size_t buf_len = 0, out_len = 0;
248
249 if (!sprint_realloc_objid(&buf, &buf_len, &out_len, 1,
250 vip->info_oid, vip->oidlen)) {
251 if (buf != NULL) {
252 free(buf);
253 }
254 return;
255 }
256
257 for (cp = buf; *cp; cp++);
258 while (cp >= buf) {
259 if (isalpha(*cp))
260 break;
261 cp--;
262 }
263 while (cp >= buf) {
264 if (*cp == '.')
265 break;
266 cp--;
267 }
268 cp++;
269 if (cp < buf)
270 cp = buf;
271 strcpy(buffer, cp);
272
273 if (buf != NULL) {
274 free(buf);
275 }
276 }
277
278 void
279 processFileArgs(char *fileName)
280 {
281 FILE *fp;
282 char buf[260] = { 0 }, *cp;
283 int blank, linenumber = 0;
284
285 fp = fopen(fileName, "r");
286 if (fp == NULL)
287 return;
288 while (fgets(buf, sizeof(buf), fp)) {
289 linenumber++;
290 if (strlen(buf) > (sizeof(buf) - 2)) {
291 fprintf(stderr, "Line too long on line %d of %s\n",
292 linenumber, fileName);
293 exit(1);
294 }
295 if (buf[0] == '#')
296 continue;
297 blank = TRUE;
298 for (cp = buf; *cp; cp++)
299 if (!isspace(*cp)) {
300 blank = FALSE;
301 break;
302 }
303 if (blank)
304 continue;
305 buf[strlen(buf) - 1] = 0;
306 varinfo[current_name++].name = strdup(buf);
307 }
308 fclose(fp);
309 return;
310 }
311
312 void
313 wait_for_period(int period)
314 {
315 struct timeval m_time, *tv = &m_time;
316 struct tm tm;
317 int count;
318 static int target = 0;
319 time_t nexthour;
320
321 gettimeofday(tv, (struct timezone *) 0);
322
323 if (target) {
324 target += period;
325 } else {
326 memcpy(&tm, localtime((time_t *) & tv->tv_sec), sizeof(tm));
327 tm.tm_sec = 0;
328 tm.tm_min = 0;
329 tm.tm_hour++;
330 nexthour = mktime(&tm);
331
332 target = (nexthour - tv->tv_sec) % period;
333 if (target == 0)
334 target = period;
335 target += tv->tv_sec;
336 }
337
338 tv->tv_sec = target - tv->tv_sec;
339 if (tv->tv_usec != 0) {
340 tv->tv_sec--;
341 tv->tv_usec = 1000000 - tv->tv_usec;
342 }
343 if (tv->tv_sec < 0) {
344 /*
345 * ran out of time, schedule immediately
346 */
347 tv->tv_sec = 0;
348 tv->tv_usec = 0;
349 }
350 count = 1;
351 while (count != 0) {
352 count = select(0, 0, 0, 0, tv);
353 switch (count) {
354 case 0:
355 break;
356 case -1:
357 /*
358 * FALLTHRU
359 */
360 default:
361 snmp_log_perror("select");
362 break;
363 }
364 }
365 }
366
367 oid sysUpTimeOid[9] = { 1, 3, 6, 1, 2, 1, 1, 3, 0 };
368 size_t sysUpTimeLen = 9;
369
370 int
371 main(int argc, char *argv[])
372 {
373 netsnmp_session session, *ss;
374 netsnmp_pdu *pdu, *response;
375 netsnmp_variable_list *vars;
376 int arg;
377 char *gateway;
378
379 int count;
380 struct varInfo *vip;
381 u_int value = 0;
382 struct counter64 c64value;
383 float printvalue;
384 time_t last_time = 0;
385 time_t this_time;
386 time_t delta_time;
387 int sum; /* what the heck is this for, its never used? */
388 char filename[128] = { 0 };
389 struct timeval tv;
390 struct tm tm;
391 char timestring[64] = { 0 }, valueStr[64] = {
392 0}, maxStr[64] = {
393 0};
394 char outstr[256] = { 0 }, peakStr[64] = {
395 0};
396 int status;
397 int begin, end, last_end;
398 int print = 1;
399 int exit_code = 0;
400
401 switch (arg = snmp_parse_args(argc, argv, &session, "C:", &optProc)) {
402 case -2:
403 exit(0);
404 case -1:
405 usage();
406 exit(1);
407 default:
408 break;
409 }
410
411 gateway = session.peername;
412
413 for (; optind < argc; optind++)
414 varinfo[current_name++].name = argv[optind];
415
416 if (current_name == 0) {
417 usage();
418 exit(1);
419 }
420
421 if (dosum) {
422 varinfo[current_name++].name = 0;
423 }
424
425 SOCK_STARTUP;
426
427 /*
428 * open an SNMP session
429 */
430 ss = snmp_open(&session);
431 if (ss == NULL) {
432 /*
433 * diagnose snmp_open errors with the input netsnmp_session pointer
434 */
435 snmp_sess_perror("snmpdelta", &session);
436 SOCK_CLEANUP;
437 exit(1);
438 }
439
440 if (tableForm && timestamp) {
441 printf("%s", gateway);
442 }
443 for (count = 0; count < current_name; count++) {
444 vip = varinfo + count;
445 if (vip->name) {
446 vip->oidlen = MAX_OID_LEN;
447 vip->info_oid = (oid *) malloc(sizeof(oid) * vip->oidlen);
448 if (snmp_parse_oid(vip->name, vip->info_oid, &vip->oidlen) ==
449 NULL) {
450 snmp_perror(vip->name);
451 SOCK_CLEANUP;
452 exit(1);
453 }
454 sprint_descriptor(vip->descriptor, vip);
455 if (tableForm)
456 printf("\t%s", vip->descriptor);
457 } else {
458 vip->oidlen = 0;
459 strcpy(vip->descriptor, SumFile);
460 }
461 vip->value = 0;
462 zeroU64(&vip->c64value);
463 vip->time = 0;
464 vip->max = 0;
465 if (peaks) {
466 vip->peak_count = -1;
467 vip->peak = 0;
468 vip->peak_average = 0;
469 }
470 }
471
472 wait_for_period(period);
473
474 end = current_name;
475 sum = 0;
476 while (1) {
477 pdu = snmp_pdu_create(SNMP_MSG_GET);
478
479 if (deltat)
480 snmp_add_null_var(pdu, sysUpTimeOid, sysUpTimeLen);
481
482 if (end == current_name)
483 count = 0;
484 else
485 count = end;
486 begin = count;
487 for (; count < current_name
488 && count < begin + varbindsPerPacket - deltat; count++) {
489 if (varinfo[count].oidlen)
490 snmp_add_null_var(pdu, varinfo[count].info_oid,
491 varinfo[count].oidlen);
492 }
493 last_end = end;
494 end = count;
495
496 retry:
497 status = snmp_synch_response(ss, pdu, &response);
498 if (status == STAT_SUCCESS) {
499 if (response->errstat == SNMP_ERR_NOERROR) {
500 if (timestamp) {
501 gettimeofday(&tv, (struct timezone *) 0);
502 memcpy(&tm, localtime((time_t *) & tv.tv_sec),
503 sizeof(tm));
504 if (((period % 60)
505 && (!peaks || ((period * peaks) % 60)))
506 || keepSeconds)
507 sprintf(timestring, " [%02d:%02d:%02d %d/%d]",
508 tm.tm_hour, tm.tm_min, tm.tm_sec,
509 tm.tm_mon + 1, tm.tm_mday);
510 else
511 sprintf(timestring, " [%02d:%02d %d/%d]",
512 tm.tm_hour, tm.tm_min,
513 tm.tm_mon + 1, tm.tm_mday);
514 }
515
516 vars = response->variables;
517 if (deltat) {
518 if (!vars) {
519 fprintf(stderr, "Missing variable in reply\n");
520 continue;
521 } else {
522 this_time = *(vars->val.integer);
523 }
524 vars = vars->next_variable;
525 } else {
526 this_time = 1;
527 }
528
529 for (count = begin; count < end; count++) {
530 vip = varinfo + count;
531
532 if (vip->oidlen) {
533 if (!vars) {
534 fprintf(stderr, "Missing variable in reply\n");
535 break;
536 }
537 vip->type = vars->type;
538 if (vars->type == ASN_COUNTER64) {
539 u64Subtract(vars->val.counter64,
540 &vip->c64value, &c64value);
541 memcpy(&vip->c64value, vars->val.counter64,
542 sizeof(struct counter64));
543 } else {
544 value = *(vars->val.integer) - vip->value;
545 vip->value = *(vars->val.integer);
546 }
547 vars = vars->next_variable;
548 } else {
549 value = sum;
550 sum = 0;
551 }
552 delta_time = this_time - vip->time;
553 if (delta_time <= 0)
554 delta_time = 100;
555 last_time = vip->time;
556 vip->time = this_time;
557 if (last_time == 0)
558 continue;
559
560 if (vip->oidlen && vip->type != ASN_COUNTER64) {
561 sum += value;
562 }
563
564 if (tableForm) {
565 if (count == begin) {
566 sprintf(outstr, "%s", timestring + 1);
567 }
568 } else {
569 sprintf(outstr, "%s %s", timestring,
570 vip->descriptor);
571 }
572
573 if (deltat || tableForm) {
574 if (vip->type == ASN_COUNTER64) {
575 fprintf(stderr,
576 "time delta and table form not supported for counter64s\n");
577 exit(1);
578 } else {
579 printvalue =
580 ((float) value * 100) / delta_time;
581 if (tableForm)
582 sprintf(valueStr, "\t%.2f", printvalue);
583 else
584 sprintf(valueStr, " /sec: %.2f",
585 printvalue);
586 }
587 } else {
588 printvalue = (float) value;
589 sprintf(valueStr, " /%d sec: ", period);
590 if (vip->type == ASN_COUNTER64)
591 printU64(valueStr + strlen(valueStr),
592 &c64value);
593 else
594 sprintf(valueStr + strlen(valueStr), "%u",
595 value);
596 }
597
598 if (!peaks) {
599 strcat(outstr, valueStr);
600 } else {
601 print = 0;
602 if (vip->peak_count == -1) {
603 if (wait_for_peak_start(period, peaks) == 0)
604 vip->peak_count = 0;
605 } else {
606 vip->peak_average += printvalue;
607 if (vip->peak < printvalue)
608 vip->peak = printvalue;
609 if (++vip->peak_count == peaks) {
610 if (deltat)
611 sprintf(peakStr,
612 " /sec: %.2f (%d sec Peak: %.2f)",
613 vip->peak_average /
614 vip->peak_count, period,
615 vip->peak);
616 else
617 sprintf(peakStr,
618 " /%d sec: %.0f (%d sec Peak: %.0f)",
619 period,
620 vip->peak_average /
621 vip->peak_count, period,
622 vip->peak);
623 vip->peak_average = 0;
624 vip->peak = 0;
625 vip->peak_count = 0;
626 print = 1;
627 strcat(outstr, peakStr);
628 }
629 }
630 }
631
632 if (printmax) {
633 if (printvalue > vip->max) {
634 vip->max = printvalue;
635 }
636 if (deltat)
637 sprintf(maxStr, " (Max: %.2f)", vip->max);
638 else
639 sprintf(maxStr, " (Max: %.0f)", vip->max);
640 strcat(outstr, maxStr);
641 }
642
643 if (print) {
644 if (fileout) {
645 sprintf(filename, "%s-%s", gateway,
646 vip->descriptor);
647 print_log(filename, outstr + 1);
648 } else {
649 if (tableForm)
650 printf("%s", outstr);
651 else
652 printf("%s\n", outstr + 1);
653 fflush(stdout);
654 }
655 }
656 }
657 if (end == last_end && tableForm)
658 printf("\n");
659 } else {
660 if (response->errstat == SNMP_ERR_TOOBIG) {
661 if (response->errindex <= varbindsPerPacket
662 && response->errindex > 0) {
663 varbindsPerPacket = response->errindex - 1;
664 } else {
665 if (varbindsPerPacket > 30)
666 varbindsPerPacket -= 5;
667 else
668 varbindsPerPacket--;
669 }
670 if (varbindsPerPacket <= 0) {
671 exit_code = 5;
672 break;
673 }
674 end = last_end;
675 continue;
676 } else if (response->errindex != 0) {
677 fprintf(stderr, "Failed object: ");
678 for (count = 1, vars = response->variables;
679 vars && count != response->errindex;
680 vars = vars->next_variable, count++);
681 if (vars)
682 fprint_objid(stderr, vars->name,
683 vars->name_length);
684 fprintf(stderr, "\n");
685 /*
686 * Don't exit when OIDs from file are not found on agent
687 * exit_code = 1;
688 * break;
689 */
690 } else {
691 fprintf(stderr, "Error in packet: %s\n",
692 snmp_errstring(response->errstat));
693 exit_code = 1;
694 break;
695 }
696
697 /*
698 * retry if the errored variable was successfully removed
699 */
700 if (!netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID,
701 NETSNMP_DS_APP_DONT_FIX_PDUS)) {
702 pdu = snmp_fix_pdu(response, SNMP_MSG_GET);
703 snmp_free_pdu(response);
704 response = NULL;
705 if (pdu != NULL)
706 goto retry;
707 }
708 }
709
710 } else if (status == STAT_TIMEOUT) {
711 fprintf(stderr, "Timeout: No Response from %s\n", gateway);
712 response = 0;
713 exit_code = 1;
714 break;
715 } else { /* status == STAT_ERROR */
716 snmp_sess_perror("snmpdelta", ss);
717 response = 0;
718 exit_code = 1;
719 break;
720 }
721
722 if (response)
723 snmp_free_pdu(response);
724 if (end == current_name) {
725 wait_for_period(period);
726 }
727 }
728 snmp_close(ss);
729 SOCK_CLEANUP;
730 return (exit_code);
731 }
Tomato firmware and modifications.