开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
snmpdelta.c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：23k
源码类别：

SNMP编程

开发平台：

Unix_Linux

snmpdelta.c：源码内容
  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.  **********************************************************************/
  29. #include <net-snmp/net-snmp-config.h>
  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
  75. #include <net-snmp/net-snmp-includes.h>
  77. #define MAX_ARGS 256
  78. #define NETSNMP_DS_APP_DONT_FIX_PDUS 0
  80. const char     *SumFile = "Sum";
  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. };
  101. struct varInfo  varinfo[MAX_ARGS];
  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;
  110. void            processFileArgs(char *fileName);
  112. void
  113. usage(void)
  114. {
  115.     fprintf(stderr,
  116.             "Usage: snmpdelta [-Cf] [-CF commandFile] [-Cl] [-CL SumFileName]nt[-Cs] [-Ck] [-Ct] [-CS] [-Cv vars/pkt] [-Cp period]nt[-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 optionsn");
  121.     fprintf(stderr, "  -CfttDon't fix errors and retry the request.n");
  122.     fprintf(stderr, "  -Clttwrite configuration to filen");
  123.     fprintf(stderr, "  -CF configtload configuration from filen");
  124.     fprintf(stderr, "  -Cp periodtspecifies the poll periodn");
  125.     fprintf(stderr, "  -CP peakstreporting period in poll periodsn");
  126.     fprintf(stderr, "  -Cv vars/pkttnumber of variables per packetn");
  127.     fprintf(stderr, "  -Ckttkeep seconds in output timen");
  128.     fprintf(stderr, "  -Cmttshow max valuesn");
  129.     fprintf(stderr, "  -CSttlog to a sum filen");
  130.     fprintf(stderr, "  -Csttshow timestampsn");
  131.     fprintf(stderr, "  -Ctttget timing from agentn");
  132.     fprintf(stderr, "  -CTttprint output in tabular formn");
  133.     fprintf(stderr, "  -CL sumfiletspecifies the sum file namen");
  134. }
  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: %cn", opt);
  185.                 exit(1);
  186.             }
  187.         }
  188.         break;
  189.     }
  190. }
  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;
  201.     seconds = period * peak;
  203.     /*
  204.      * Find the current time 
  205.      */
  206.     gettimeofday(tv, (struct timezone *) 0);
  208.     /*
  209.      * Create a tm struct from it 
  210.      */
  211.     memcpy(&tm, localtime((time_t *) & tv->tv_sec), sizeof(tm));
  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);
  221.     /*
  222.      * Now figure out the amount of time to sleep 
  223.      */
  224.     target = (SecondsAtNextHour - tv->tv_sec) % seconds;
  226.     return target;
  227. }
  229. void
  230. print_log(char *file, char *message)
  231. {
  232.     FILE           *fp;
  234.     fp = fopen(file, "a");
  235.     if (fp == NULL) {
  236.         fprintf(stderr, "Couldn't open %sn", file);
  237.         return;
  238.     }
  239.     fprintf(fp, "%sn", message);
  240.     fclose(fp);
  241. }
  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;
  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.     }
  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);
  273.     if (buf != NULL) {
  274.         free(buf);
  275.     }
  276. }
  278. void
  279. processFileArgs(char *fileName)
  280. {
  281.     FILE           *fp;
  282.     char            buf[260] = { 0 }, *cp;
  283.     int             blank, linenumber = 0;
  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 %sn",
  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. if (current_name >= MAX_ARGS) {
  307.     fprintf(stderr, "Too many variables read at line %d of %s (max %d)n",
  308.      linenumber, fileName, MAX_ARGS);
  309.     exit(1);
  310. }
  311.         varinfo[current_name++].name = strdup(buf);
  312.     }
  313.     fclose(fp);
  314.     return;
  315. }
  317. void
  318. wait_for_period(int period)
  319. {
  320. #ifdef WIN32
  321.     Sleep(period * 1000);
  322. #else                   /* WIN32 */
  323.     struct timeval  m_time, *tv = &m_time;
  324.     struct tm       tm;
  325.     int             count;
  326.     static int      target = 0;
  327.     time_t          nexthour;
  329.     gettimeofday(tv, (struct timezone *) 0);
  331.     if (target) {
  332.         target += period;
  333.     } else {
  334.         memcpy(&tm, localtime((time_t *) & tv->tv_sec), sizeof(tm));
  335.         tm.tm_sec = 0;
  336.         tm.tm_min = 0;
  337.         tm.tm_hour++;
  338.         nexthour = mktime(&tm);
  340.         target = (nexthour - tv->tv_sec) % period;
  341.         if (target == 0)
  342.             target = period;
  343.         target += tv->tv_sec;
  344.     }
  346.     tv->tv_sec = target - tv->tv_sec;
  347.     if (tv->tv_usec != 0) {
  348.         tv->tv_sec--;
  349.         tv->tv_usec = 1000000 - tv->tv_usec;
  350.     }
  351.     if (tv->tv_sec < 0) {
  352.         /*
  353.          * ran out of time, schedule immediately 
  354.          */
  355.         tv->tv_sec = 0;
  356.         tv->tv_usec = 0;
  357.     }
  358.     count = 1;
  359.     while (count != 0) {
  360.         count = select(0, 0, 0, 0, tv);
  361.         switch (count) {
  362.         case 0:
  363.             break;
  364.         case -1:
  365.             /*
  366.              * FALLTHRU 
  367.              */
  368.         default:
  369.             snmp_log_perror("select");
  370.             break;
  371.         }
  372.     }
  373. #endif                   /* WIN32 */
  374. }
  376. oid             sysUpTimeOid[9] = { 1, 3, 6, 1, 2, 1, 1, 3, 0 };
  377. size_t          sysUpTimeLen = 9;
  379. int
  380. main(int argc, char *argv[])
  381. {
  382.     netsnmp_session session, *ss;
  383.     netsnmp_pdu    *pdu, *response;
  384.     netsnmp_variable_list *vars;
  385.     int             arg;
  386.     char           *gateway;
  388.     int             count;
  389.     struct varInfo *vip;
  390.     u_int           value = 0;
  391.     struct counter64 c64value;
  392.     float           printvalue;
  393.     time_t          last_time = 0;
  394.     time_t          this_time;
  395.     time_t          delta_time;
  396.     int             sum;        /* what the heck is this for, its never used? */
  397.     char            filename[128] = { 0 };
  398.     struct timeval  tv;
  399.     struct tm       tm;
  400.     char            timestring[64] = { 0 }, valueStr[64] = {
  401.     0}, maxStr[64] = {
  402.     0};
  403.     char            outstr[256] = { 0 }, peakStr[64] = {
  404.     0};
  405.     int             status;
  406.     int             begin, end, last_end;
  407.     int             print = 1;
  408.     int             exit_code = 0;
  410.     switch (arg = snmp_parse_args(argc, argv, &session, "C:", &optProc)) {
  411.     case -2:
  412.         exit(0);
  413.     case -1:
  414.         usage();
  415.         exit(1);
  416.     default:
  417.         break;
  418.     }
  420.     gateway = session.peername;
  422.     for (; optind < argc; optind++) {
  423. if (current_name >= MAX_ARGS) {
  424.     fprintf(stderr, "%s: Too many variables specified (max %d)n",
  425.      argv[optind], MAX_ARGS);
  426.     exit(1);
  427. }
  428.         varinfo[current_name++].name = argv[optind];
  429.     }
  431.     if (current_name == 0) {
  432.         usage();
  433.         exit(1);
  434.     }
  436.     if (dosum) {
  437. if (current_name >= MAX_ARGS) {
  438.     fprintf(stderr, "Too many variables specified (max %d)n",
  439.      MAX_ARGS);
  440.     exit(1);
  441. }
  442.         varinfo[current_name++].name = 0;
  443.     }
  445.     SOCK_STARTUP;
  447.     /*
  448.      * open an SNMP session 
  449.      */
  450.     ss = snmp_open(&session);
  451.     if (ss == NULL) {
  452.         /*
  453.          * diagnose snmp_open errors with the input netsnmp_session pointer 
  454.          */
  455.         snmp_sess_perror("snmpdelta", &session);
  456.         SOCK_CLEANUP;
  457.         exit(1);
  458.     }
  460.     if (tableForm && timestamp) {
  461.         printf("%s", gateway);
  462.     }
  463.     for (count = 0; count < current_name; count++) {
  464.         vip = varinfo + count;
  465.         if (vip->name) {
  466.             vip->oidlen = MAX_OID_LEN;
  467.             vip->info_oid = (oid *) malloc(sizeof(oid) * vip->oidlen);
  468.             if (snmp_parse_oid(vip->name, vip->info_oid, &vip->oidlen) ==
  469.                 NULL) {
  470.                 snmp_perror(vip->name);
  471.                 SOCK_CLEANUP;
  472.                 exit(1);
  473.             }
  474.             sprint_descriptor(vip->descriptor, vip);
  475.             if (tableForm)
  476.                 printf("t%s", vip->descriptor);
  477.         } else {
  478.             vip->oidlen = 0;
  479.             strcpy(vip->descriptor, SumFile);
  480.         }
  481.         vip->value = 0;
  482.         zeroU64(&vip->c64value);
  483.         vip->time = 0;
  484.         vip->max = 0;
  485.         if (peaks) {
  486.             vip->peak_count = -1;
  487.             vip->peak = 0;
  488.             vip->peak_average = 0;
  489.         }
  490.     }
  492.     wait_for_period(period);
  494.     end = current_name;
  495.     sum = 0;
  496.     while (1) {
  497.         pdu = snmp_pdu_create(SNMP_MSG_GET);
  499.         if (deltat)
  500.             snmp_add_null_var(pdu, sysUpTimeOid, sysUpTimeLen);
  502.         if (end == current_name)
  503.             count = 0;
  504.         else
  505.             count = end;
  506.         begin = count;
  507.         for (; count < current_name
  508.              && count < begin + varbindsPerPacket - deltat; count++) {
  509.             if (varinfo[count].oidlen)
  510.                 snmp_add_null_var(pdu, varinfo[count].info_oid,
  511.                                   varinfo[count].oidlen);
  512.         }
  513.         last_end = end;
  514.         end = count;
  516.       retry:
  517.         status = snmp_synch_response(ss, pdu, &response);
  518.         if (status == STAT_SUCCESS) {
  519.             if (response->errstat == SNMP_ERR_NOERROR) {
  520.                 if (timestamp) {
  521.                     gettimeofday(&tv, (struct timezone *) 0);
  522.                     memcpy(&tm, localtime((time_t *) & tv.tv_sec),
  523.                            sizeof(tm));
  524.                     if (((period % 60)
  525.                          && (!peaks || ((period * peaks) % 60)))
  526.                         || keepSeconds)
  527.                         sprintf(timestring, " [%02d:%02d:%02d %d/%d]",
  528.                                 tm.tm_hour, tm.tm_min, tm.tm_sec,
  529.                                 tm.tm_mon + 1, tm.tm_mday);
  530.                     else
  531.                         sprintf(timestring, " [%02d:%02d %d/%d]",
  532.                                 tm.tm_hour, tm.tm_min,
  533.                                 tm.tm_mon + 1, tm.tm_mday);
  534.                 }
  536.                 vars = response->variables;
  537.                 if (deltat) {
  538.                     if (!vars || !vars->val.integer) {
  539.                         fprintf(stderr, "Missing variable in replyn");
  540.                         continue;
  541.                     } else {
  542.                         this_time = *(vars->val.integer);
  543.                     }
  544.                     vars = vars->next_variable;
  545.                 } else {
  546.                     this_time = 1;
  547.                 }
  549.                 for (count = begin; count < end; count++) {
  550.                     vip = varinfo + count;
  552.                     if (vip->oidlen) {
  553.                         if (!vars || !vars->val.integer) {
  554.                             fprintf(stderr, "Missing variable in replyn");
  555.                             break;
  556.                         }
  557.                         vip->type = vars->type;
  558.                         if (vars->type == ASN_COUNTER64) {
  559.                             u64Subtract(vars->val.counter64,
  560.                                         &vip->c64value, &c64value);
  561.                             memcpy(&vip->c64value, vars->val.counter64,
  562.                                    sizeof(struct counter64));
  563.                         } else {
  564.                             value = *(vars->val.integer) - vip->value;
  565.                             vip->value = *(vars->val.integer);
  566.                         }
  567.                         vars = vars->next_variable;
  568.                     } else {
  569.                         value = sum;
  570.                         sum = 0;
  571.                     }
  572.                     delta_time = this_time - vip->time;
  573.                     if (delta_time <= 0)
  574.                         delta_time = 100;
  575.                     last_time = vip->time;
  576.                     vip->time = this_time;
  577.                     if (last_time == 0)
  578.                         continue;
  580.                     if (vip->oidlen && vip->type != ASN_COUNTER64) {
  581.                         sum += value;
  582.                     }
  584.                     if (tableForm) {
  585.                         if (count == begin) {
  586.                             sprintf(outstr, "%s", timestring + 1);
  587.                         } else {
  588.                             outstr[0] = '';
  589.                         }
  590.                     } else {
  591.                         sprintf(outstr, "%s %s", timestring,
  592.                                 vip->descriptor);
  593.                     }
  595.                     if (deltat || tableForm) {
  596.                         if (vip->type == ASN_COUNTER64) {
  597.                             fprintf(stderr,
  598.                                     "time delta and table form not supported for counter64sn");
  599.                             exit(1);
  600.                         } else {
  601.                             printvalue =
  602.                                 ((float) value * 100) / delta_time;
  603.                             if (tableForm)
  604.                                 sprintf(valueStr, "t%.2f", printvalue);
  605.                             else
  606.                                 sprintf(valueStr, " /sec: %.2f",
  607.                                         printvalue);
  608.                         }
  609.                     } else {
  610.                         printvalue = (float) value;
  611.                         sprintf(valueStr, " /%d sec: ", period);
  612.                         if (vip->type == ASN_COUNTER64)
  613.                             printU64(valueStr + strlen(valueStr),
  614.                                      &c64value);
  615.                         else
  616.                             sprintf(valueStr + strlen(valueStr), "%u",
  617.                                     value);
  618.                     }
  620.                     if (!peaks) {
  621.                         strcat(outstr, valueStr);
  622.                     } else {
  623.                         print = 0;
  624.                         if (vip->peak_count == -1) {
  625.                             if (wait_for_peak_start(period, peaks) == 0)
  626.                                 vip->peak_count = 0;
  627.                         } else {
  628.                             vip->peak_average += printvalue;
  629.                             if (vip->peak < printvalue)
  630.                                 vip->peak = printvalue;
  631.                             if (++vip->peak_count == peaks) {
  632.                                 if (deltat)
  633.                                     sprintf(peakStr,
  634.                                             " /sec: %.2f (%d sec Peak: %.2f)",
  635.                                             vip->peak_average /
  636.                                             vip->peak_count, period,
  637.                                             vip->peak);
  638.                                 else
  639.                                     sprintf(peakStr,
  640.                                             " /%d sec: %.0f (%d sec Peak: %.0f)",
  641.                                             period,
  642.                                             vip->peak_average /
  643.                                             vip->peak_count, period,
  644.                                             vip->peak);
  645.                                 vip->peak_average = 0;
  646.                                 vip->peak = 0;
  647.                                 vip->peak_count = 0;
  648.                                 print = 1;
  649.                                 strcat(outstr, peakStr);
  650.                             }
  651.                         }
  652.                     }
  654.                     if (printmax) {
  655.                         if (printvalue > vip->max) {
  656.                             vip->max = printvalue;
  657.                         }
  658.                         if (deltat)
  659.                             sprintf(maxStr, " (Max: %.2f)", vip->max);
  660.                         else
  661.                             sprintf(maxStr, " (Max: %.0f)", vip->max);
  662.                         strcat(outstr, maxStr);
  663.                     }
  665.                     if (print) {
  666.                         if (fileout) {
  667.                             sprintf(filename, "%s-%s", gateway,
  668.                                     vip->descriptor);
  669.                             print_log(filename, outstr + 1);
  670.                         } else {
  671.                             if (tableForm)
  672.                                 printf("%s", outstr);
  673.                             else
  674.                                 printf("%sn", outstr + 1);
  675.                             fflush(stdout);
  676.                         }
  677.                     }
  678.                 }
  679.                 if (end == last_end && tableForm)
  680.                     printf("n");
  681.             } else {
  682.                 if (response->errstat == SNMP_ERR_TOOBIG) {
  683.                     if (response->errindex <= varbindsPerPacket
  684.                         && response->errindex > 0) {
  685.                         varbindsPerPacket = response->errindex - 1;
  686.                     } else {
  687.                         if (varbindsPerPacket > 30)
  688.                             varbindsPerPacket -= 5;
  689.                         else
  690.                             varbindsPerPacket--;
  691.                     }
  692.                     if (varbindsPerPacket <= 0) {
  693.                         exit_code = 5;
  694.                         break;
  695.                     }
  696.                     end = last_end;
  697.                     continue;
  698.                 } else if (response->errindex != 0) {
  699.                     fprintf(stderr, "Failed object: ");
  700.                     for (count = 1, vars = response->variables;
  701.                          vars && count != response->errindex;
  702.                          vars = vars->next_variable, count++);
  703.                     if (vars)
  704.                         fprint_objid(stderr, vars->name,
  705.                                      vars->name_length);
  706.                     fprintf(stderr, "n");
  707.                     /*
  708.                      * Don't exit when OIDs from file are not found on agent
  709.                      * exit_code = 1;
  710.                      * break;
  711.                      */
  712.                 } else {
  713.                     fprintf(stderr, "Error in packet: %sn",
  714.                             snmp_errstring(response->errstat));
  715.                     exit_code = 1;
  716.                     break;
  717.                 }
  719.                 /*
  720.                  * retry if the errored variable was successfully removed 
  721.                  */
  722.                 if (!netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID, 
  723.     NETSNMP_DS_APP_DONT_FIX_PDUS)) {
  724.                     pdu = snmp_fix_pdu(response, SNMP_MSG_GET);
  725.                     snmp_free_pdu(response);
  726.                     response = NULL;
  727.                     if (pdu != NULL)
  728.                         goto retry;
  729.                 }
  730.             }
  732.         } else if (status == STAT_TIMEOUT) {
  733.             fprintf(stderr, "Timeout: No Response from %sn", gateway);
  734.             response = 0;
  735.             exit_code = 1;
  736.             break;
  737.         } else {                /* status == STAT_ERROR */
  738.             snmp_sess_perror("snmpdelta", ss);
  739.             response = 0;
  740.             exit_code = 1;
  741.             break;
  742.         }
  744.         if (response)
  745.             snmp_free_pdu(response);
  746.         if (end == current_name) {
  747.             wait_for_period(period);
  748.         }
  749.     }
  750.     snmp_close(ss);
  751.     SOCK_CLEANUP;
  752.     return (exit_code);
  753. }