/*

 * snmpdelta.c - Monitor deltas of integer valued SNMP variables

 *

 */

/**********************************************************************

 *

 *           Copyright 1996 by Carnegie Mellon University

 * 

 *                       All Rights Reserved

 * 

 * Permission to use, copy, modify, and distribute this software and its

 * documentation for any purpose and without fee is hereby granted,

 * provided that the above copyright notice appear in all copies and that

 * both that copyright notice and this permission notice appear in

 * supporting documentation, and that the name of CMU not be

 * used in advertising or publicity pertaining to distribution of the

 * software without specific, written prior permission.

 * 

 * CMU DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

 * CMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR

 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,

 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

 * SOFTWARE.

 * 

 **********************************************************************/

#include <net-snmp/net-snmp-config.h>

#if HAVE_STDLIB_H

#include <stdlib.h>

#endif

#if HAVE_UNISTD_H

#include <unistd.h>

#endif

#if HAVE_STRING_H

#include <string.h>

#else

#include <strings.h>

#endif

#include <sys/types.h>

#if HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

#include <stdio.h>

#include <ctype.h>

#if TIME_WITH_SYS_TIME

# include <sys/time.h>

# include <time.h>

#else

# if HAVE_SYS_TIME_H

#  include <sys/time.h>

# else

#  include <time.h>

# endif

#endif

#if HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif

#if HAVE_NETDB_H

#include <netdb.h>

#endif

#if HAVE_ARPA_INET_H

#include <arpa/inet.h>

#endif

#include <net-snmp/net-snmp-includes.h>

#define MAX_ARGS 256

#define NETSNMP_DS_APP_DONT_FIX_PDUS 0

const char     *SumFile = "Sum";

/*

 * Information about the handled variables 

 */

struct varInfo {

    char           *name;

    oid            *info_oid;

    int             type;

    size_t          oidlen;

    char            descriptor[64];

    u_int           value;

    struct counter64 c64value;

    float           max;

    time_t          time;

    int             peak_count;

    float           peak;

    float           peak_average;

    int             spoiled;

};

struct varInfo  varinfo[MAX_ARGS];

int             current_name = 0;

int             period = 1;

int             deltat = 0, timestamp = 0, fileout = 0, dosum =

    0, printmax = 0;

int             keepSeconds = 0, peaks = 0;

int             tableForm = 0;

int             varbindsPerPacket = 60;

static void     processFileArgs(char *fileName);

void

usage(void)

{

    fprintf(stderr,

            "Usage: snmpdelta [-Cf] [-CF commandFile] [-Cl] [-CL SumFileName]\n\t[-Cs] [-Ck] [-Ct] [-CS] [-Cv vars/pkt] [-Cp period]\n\t[-CP peaks] ");

    snmp_parse_args_usage(stderr);

    fprintf(stderr, " oid [oid ...]\n");

    snmp_parse_args_descriptions(stderr);

    fprintf(stderr, "snmpdelta specific options\n");

    fprintf(stderr, "  -Cf\t\tDon't fix errors and retry the request.\n");

    fprintf(stderr, "  -Cl\t\twrite configuration to file\n");

    fprintf(stderr, "  -CF config\tload configuration from file\n");

    fprintf(stderr, "  -Cp period\tspecifies the poll period\n");

    fprintf(stderr, "  -CP peaks\treporting period in poll periods\n");

    fprintf(stderr, "  -Cv vars/pkt\tnumber of variables per packet\n");

    fprintf(stderr, "  -Ck\t\tkeep seconds in output time\n");

    fprintf(stderr, "  -Cm\t\tshow max values\n");

    fprintf(stderr, "  -CS\t\tlog to a sum file\n");

    fprintf(stderr, "  -Cs\t\tshow timestamps\n");

    fprintf(stderr, "  -Ct\t\tget timing from agent\n");

    fprintf(stderr, "  -CT\t\tprint output in tabular form\n");

    fprintf(stderr, "  -CL sumfile\tspecifies the sum file name\n");

}

static void

optProc(int argc, char *const *argv, int opt)

{

    switch (opt) {

    case 'C':

        while (*optarg) {

            switch ((opt = *optarg++)) {

            case 'f':

                netsnmp_ds_toggle_boolean(NETSNMP_DS_APPLICATION_ID,

					  NETSNMP_DS_APP_DONT_FIX_PDUS);

                break;

            case 'p':

                period = atoi(argv[optind++]);

                break;

            case 'P':

                peaks = atoi(argv[optind++]);

                break;

            case 'v':

                varbindsPerPacket = atoi(argv[optind++]);

                break;

            case 't':

                deltat = 1;

                break;

            case 's':

                timestamp = 1;

                break;

            case 'S':

                dosum = 1;

                break;

            case 'm':

                printmax = 1;

                break;

            case 'F':

                processFileArgs(argv[optind++]);

                break;

            case 'l':

                fileout = 1;

                break;

            case 'L':

                SumFile = argv[optind++];

                break;

            case 'k':

                keepSeconds = 1;

                break;

            case 'T':

                tableForm = 1;

                break;

            default:

                fprintf(stderr, "Bad -C options: %c\n", opt);

                exit(1);

            }

        }

        break;

    }

}

int

wait_for_peak_start(int period, int peak)

{

    struct timeval  m_time, *tv = &m_time;

    struct tm       tm;

    time_t          SecondsAtNextHour;

    int             target = 0;

    int             seconds;

    seconds = period * peak;

    /*

     * Find the current time 

     */

    gettimeofday(tv, (struct timezone *) 0);

    /*

     * Create a tm struct from it 

     */

    memcpy(&tm, localtime((time_t *) & tv->tv_sec), sizeof(tm));

    /*

     * Calculate the next hour 

     */

    tm.tm_sec = 0;

    tm.tm_min = 0;

    tm.tm_hour++;

    SecondsAtNextHour = mktime(&tm;;

    /*

     * Now figure out the amount of time to sleep 

     */

    target = (int)(SecondsAtNextHour - tv->tv_sec) % seconds;

    return target;

}

void

print_log(char *file, char *message)

{

    FILE           *fp;

    fp = fopen(file, "a");

    if (fp == NULL) {

        fprintf(stderr, "Couldn't open %s\n", file);

        return;

    }

    fprintf(fp, "%s\n", message);

    fclose(fp);

}

void

sprint_descriptor(char *buffer, struct varInfo *vip)

{

    char           *buf = NULL, *cp = NULL;

    size_t          buf_len = 0, out_len = 0;

    if (!sprint_realloc_objid((u_char **)&buf, &buf_len, &out_len, 1,

                              vip->info_oid, vip->oidlen)) {

        if (buf != NULL) {

            free(buf);

        }

        return;

    }

    for (cp = buf; *cp; cp++);

    while (cp >= buf) {

        if (isalpha((unsigned char)(*cp)))

            break;

        cp--;

    }

    while (cp >= buf) {

        if (*cp == '.')

            break;

        cp--;

    }

    cp++;

    if (cp < buf)

        cp = buf;

    strcpy(buffer, cp);

    if (buf != NULL) {

        free(buf);

    }

}

void

processFileArgs(char *fileName)

{

    FILE           *fp;

    char            buf[260] = { 0 }, *cp;

    int             blank, linenumber = 0;

    fp = fopen(fileName, "r");

    if (fp == NULL)

        return;

    while (fgets(buf, sizeof(buf), fp)) {

        linenumber++;

        if (strlen(buf) > (sizeof(buf) - 2)) {

            fprintf(stderr, "Line too long on line %d of %s\n",

                    linenumber, fileName);

            exit(1);

        }

        if (buf[0] == '#')

            continue;

        blank = TRUE;

        for (cp = buf; *cp; cp++)

            if (!isspace((unsigned char)(*cp))) {

                blank = FALSE;

                break;

            }

        if (blank)

            continue;

        buf[strlen(buf) - 1] = 0;

	if (current_name >= MAX_ARGS) {

	    fprintf(stderr, "Too many variables read at line %d of %s (max %d)\n",

	    	linenumber, fileName, MAX_ARGS);

	    exit(1);

	}

        varinfo[current_name++].name = strdup(buf);

    }

    fclose(fp);

    return;

}

void

wait_for_period(int period)

{

#ifdef WIN32

    Sleep(period * 1000);

#else                   /* WIN32 */

    struct timeval  m_time, *tv = &m_time;

    struct tm       tm;

    int             count;

    static int      target = 0;

    time_t          nexthour;

    gettimeofday(tv, (struct timezone *) 0);

    if (target) {

        target += period;

    } else {

        memcpy(&tm, localtime((time_t *) & tv->tv_sec), sizeof(tm));

        tm.tm_sec = 0;

        tm.tm_min = 0;

        tm.tm_hour++;

        nexthour = mktime(&tm;;

        target = (nexthour - tv->tv_sec) % period;

        if (target == 0)

            target = period;

        target += tv->tv_sec;

    }

    tv->tv_sec = target - tv->tv_sec;

    if (tv->tv_usec != 0) {

        tv->tv_sec--;

        tv->tv_usec = 1000000 - tv->tv_usec;

    }

    if (tv->tv_sec < 0) {

        /*

         * ran out of time, schedule immediately 

         */

        tv->tv_sec = 0;

        tv->tv_usec = 0;

    }

    count = 1;

    while (count != 0) {

        count = select(0, NULL, NULL, NULL, tv);

        switch (count) {

        case 0:

            break;

        case -1:

            /*

             * FALLTHRU 

             */

        default:

            snmp_log_perror("select");

            break;

        }

    }

#endif                   /* WIN32 */

}

oid             sysUpTimeOid[9] = { 1, 3, 6, 1, 2, 1, 1, 3, 0 };

size_t          sysUpTimeLen = 9;

int

main(int argc, char *argv[])

{

    netsnmp_session session, *ss;

    netsnmp_pdu    *pdu, *response;

    netsnmp_variable_list *vars;

    int             arg;

    char           *gateway;

    int             count;

    struct varInfo *vip;

    u_int           value = 0;

    struct counter64 c64value;

    float           printvalue;

    time_t          last_time = 0;

    time_t          this_time;

    time_t          delta_time;

    int             sum;        /* what the heck is this for, its never used? */

    char            filename[128] = { 0 };

    struct timeval  tv;

    struct tm       tm;

    char            timestring[64] = { 0 }, valueStr[64] = {

    0}, maxStr[64] = {

    0};

    char            outstr[256] = { 0 }, peakStr[64] = {

    0};

    int             status;

    int             begin, end, last_end;

    int             print = 1;

    int             exit_code = 1;

    SOCK_STARTUP;

    switch (arg = snmp_parse_args(argc, argv, &session, "C:", &optProc)) {

    case NETSNMP_PARSE_ARGS_ERROR:

        goto out;

    case NETSNMP_PARSE_ARGS_SUCCESS_EXIT:

        exit_code = 0;

        goto out;

    case NETSNMP_PARSE_ARGS_ERROR_USAGE:

        usage();

        goto out;

    default:

        break;

    }

    gateway = session.peername;

    for (; optind < argc; optind++) {

	if (current_name >= MAX_ARGS) {

	    fprintf(stderr, "%s: Too many variables specified (max %d)\n",

	    	argv[optind], MAX_ARGS);

	    goto out;

	}

        varinfo[current_name++].name = argv[optind];

    }

    if (current_name == 0) {

        usage();

        goto out;

    }

    if (dosum) {

	if (current_name >= MAX_ARGS) {

	    fprintf(stderr, "Too many variables specified (max %d)\n",

	    	MAX_ARGS);

	    goto out;

	}

        varinfo[current_name++].name = NULL;

    }

    /*

     * open an SNMP session 

     */

    ss = snmp_open(&session);

    if (ss == NULL) {

        /*

         * diagnose snmp_open errors with the input netsnmp_session pointer 

         */

        snmp_sess_perror("snmpdelta", &session);

        goto out;

    }

    if (tableForm && timestamp) {

        printf("%s", gateway);

    }

    for (count = 0; count < current_name; count++) {

        vip = varinfo + count;

        if (vip->name) {

            vip->oidlen = MAX_OID_LEN;

            vip->info_oid = (oid *) malloc(sizeof(oid) * vip->oidlen);

            if (snmp_parse_oid(vip->name, vip->info_oid, &vip->oidlen) ==

                NULL) {

                snmp_perror(vip->name);

                goto close_session;

            }

            sprint_descriptor(vip->descriptor, vip);

            if (tableForm)

                printf("\t%s", vip->descriptor);

        } else {

            vip->oidlen = 0;

            strlcpy(vip->descriptor, SumFile, sizeof(vip->descriptor));

        }

        vip->value = 0;

        zeroU64(&vip->c64value);

        vip->time = 0;

        vip->max = 0;

        if (peaks) {

            vip->peak_count = -1;

            vip->peak = 0;

            vip->peak_average = 0;

        }

    }

    wait_for_period(period);

    end = current_name;

    sum = 0;

    while (1) {

        pdu = snmp_pdu_create(SNMP_MSG_GET);

        if (deltat)

            snmp_add_null_var(pdu, sysUpTimeOid, sysUpTimeLen);

        if (end == current_name)

            count = 0;

        else

            count = end;

        begin = count;

        for (; count < current_name

             && count < begin + varbindsPerPacket - deltat; count++) {

            if (varinfo[count].oidlen)

                snmp_add_null_var(pdu, varinfo[count].info_oid,

                                  varinfo[count].oidlen);

        }

        last_end = end;

        end = count;

      retry:

        status = snmp_synch_response(ss, pdu, &response);

        if (status == STAT_SUCCESS) {

            if (response->errstat == SNMP_ERR_NOERROR) {

                if (timestamp) {

                    gettimeofday(&tv, (struct timezone *) 0);

                    memcpy(&tm, localtime((time_t *) & tv.tv_sec),

                           sizeof(tm));

                    if (((period % 60)

                         && (!peaks || ((period * peaks) % 60)))

                        || keepSeconds)

                        sprintf(timestring, " [%02d:%02d:%02d %d/%d]",

                                tm.tm_hour, tm.tm_min, tm.tm_sec,

                                tm.tm_mon + 1, tm.tm_mday);

                    else

                        sprintf(timestring, " [%02d:%02d %d/%d]",

                                tm.tm_hour, tm.tm_min,

                                tm.tm_mon + 1, tm.tm_mday);

                }

                vars = response->variables;

                if (deltat) {

                    if (!vars || !vars->val.integer) {

                        fprintf(stderr, "Missing variable in reply\n");

                        continue;

                    } else {

                        this_time = *(vars->val.integer);

                    }

                    vars = vars->next_variable;

                } else {

                    this_time = 1;

                }

                for (count = begin; count < end; count++) {

                    vip = varinfo + count;

                    if (vip->oidlen) {

                        if (!vars || !vars->val.integer) {

                            fprintf(stderr, "Missing variable in reply\n");

                            break;

                        }

                        vip->type = vars->type;

                        if (vars->type == ASN_COUNTER64) {

                            u64Subtract(vars->val.counter64,

                                        &vip->c64value, &c64value);

                            memcpy(&vip->c64value, vars->val.counter64,

                                   sizeof(struct counter64));

                        } else {

                            value = *(vars->val.integer) - vip->value;

                            vip->value = *(vars->val.integer);

                        }

                        vars = vars->next_variable;

                    } else {

                        value = sum;

                        sum = 0;

                    }

                    delta_time = this_time - vip->time;

                    if (delta_time <= 0)

                        delta_time = 100;

                    last_time = vip->time;

                    vip->time = this_time;

                    if (last_time == 0)

                        continue;

                    if (vip->oidlen && vip->type != ASN_COUNTER64) {

                        sum += value;

                    }

                    if (tableForm) {

                        if (count == begin) {

                            sprintf(outstr, "%s", timestring + 1);

                        } else {

                            outstr[0] = '\0';

                        }

                    } else {

                        sprintf(outstr, "%s %s", timestring,

                                vip->descriptor);

                    }

                    if (deltat || tableForm) {

                        if (vip->type == ASN_COUNTER64) {

                            fprintf(stderr,

                                    "time delta and table form not supported for counter64s\n");

                            goto close_session;

                        } else {

                            printvalue =

                                ((float) value * 100) / delta_time;

                            if (tableForm)

                                sprintf(valueStr, "\t%.2f", printvalue);

                            else

                                sprintf(valueStr, " /sec: %.2f",

                                        printvalue);

                        }

                    } else {

                        printvalue = (float) value;

                        sprintf(valueStr, " /%d sec: ", period);

                        if (vip->type == ASN_COUNTER64)

                            printU64(valueStr + strlen(valueStr),

                                     &c64value);

                        else

                            sprintf(valueStr + strlen(valueStr), "%u",

                                    value);

                    }

                    if (!peaks) {

                        strcat(outstr, valueStr);

                    } else {

                        print = 0;

                        if (vip->peak_count == -1) {

                            if (wait_for_peak_start(period, peaks) == 0)

                                vip->peak_count = 0;

                        } else {

                            vip->peak_average += printvalue;

                            if (vip->peak < printvalue)

                                vip->peak = printvalue;

                            if (++vip->peak_count == peaks) {

                                if (deltat)

                                    sprintf(peakStr,

                                            " /sec: %.2f	(%d sec Peak: %.2f)",

                                            vip->peak_average /

                                            vip->peak_count, period,

                                            vip->peak);

                                else

                                    sprintf(peakStr,

                                            " /%d sec: %.0f	(%d sec Peak: %.0f)",

                                            period,

                                            vip->peak_average /

                                            vip->peak_count, period,

                                            vip->peak);

                                vip->peak_average = 0;

                                vip->peak = 0;

                                vip->peak_count = 0;

                                print = 1;

                                strcat(outstr, peakStr);

                            }

                        }

                    }

                    if (printmax) {

                        if (printvalue > vip->max) {

                            vip->max = printvalue;

                        }

                        if (deltat)

                            sprintf(maxStr, "	(Max: %.2f)", vip->max);

                        else

                            sprintf(maxStr, "	(Max: %.0f)", vip->max);

                        strcat(outstr, maxStr);

                    }

                    if (print) {

                        if (fileout) {

                            sprintf(filename, "%s-%s", gateway,

                                    vip->descriptor);

                            print_log(filename, outstr + 1);

                        } else {

                            if (tableForm)

                                printf("%s", outstr);

                            else

                                printf("%s\n", outstr + 1);

                            fflush(stdout);

                        }

                    }

                }

                if (end == last_end && tableForm)

                    printf("\n");

            } else {

                if (response->errstat == SNMP_ERR_TOOBIG) {

                    if (response->errindex <= varbindsPerPacket

                        && response->errindex > 0) {

                        varbindsPerPacket = response->errindex - 1;

                    } else {

                        if (varbindsPerPacket > 30)

                            varbindsPerPacket -= 5;

                        else

                            varbindsPerPacket--;

                    }

                    if (varbindsPerPacket <= 0) {

                        exit_code = 5;

                        break;

                    }

                    end = last_end;

                    continue;

                } else if (response->errindex != 0) {

                    fprintf(stderr, "Failed object: ");

                    for (count = 1, vars = response->variables;

                         vars && count != response->errindex;

                         vars = vars->next_variable, count++);

                    if (vars)

                        fprint_objid(stderr, vars->name,

                                     vars->name_length);

                    fprintf(stderr, "\n");

                    /*

                     * Don't exit when OIDs from file are not found on agent

                     * exit_code = 1;

                     * break;

                     */

                } else {

                    fprintf(stderr, "Error in packet: %s\n",

                            snmp_errstring(response->errstat));

                    exit_code = 1;

                    break;

                }

                /*

                 * retry if the errored variable was successfully removed 

                 */

                if (!netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID, 

					    NETSNMP_DS_APP_DONT_FIX_PDUS)) {

                    pdu = snmp_fix_pdu(response, SNMP_MSG_GET);

                    snmp_free_pdu(response);

                    response = NULL;

                    if (pdu != NULL)

                        goto retry;

                }

            }

        } else if (status == STAT_TIMEOUT) {

            fprintf(stderr, "Timeout: No Response from %s\n", gateway);

            response = NULL;

            exit_code = 1;

            break;

        } else {                /* status == STAT_ERROR */

            snmp_sess_perror("snmpdelta", ss);

            response = NULL;

            exit_code = 1;

            break;

        }

        if (response)

            snmp_free_pdu(response);

        if (end == current_name) {

            wait_for_period(period);

        }

    }

    exit_code = 0;

close_session:

    snmp_close(ss);

out:

    SOCK_CLEANUP;

    return (exit_code);

}