pingctltable.c

snmp的源代码,已经在我的ubuntu下编译通过

     * pingResultsMaxRtt 
     */
    bzero(newoid, newoid_len);
    header_complex_generate_oid(newoid, &newoid_len, pingResultsMaxRtt,
                                sizeof(pingResultsMaxRtt) / sizeof(oid),
                                vars);

    snmp_varlist_add_variable(&var_list, newoid,
                              newoid_len,
                              ASN_UNSIGNED,
                              (u_char *) & (StorageTmp->pingResultsMaxRtt),
                              sizeof(StorageTmp->pingResultsMaxRtt));

    /*
     * pingResultsAverageRtt 
     */
    bzero(newoid, newoid_len);
    header_complex_generate_oid(newoid, &newoid_len, pingResultsAverageRtt,
                                sizeof(pingResultsAverageRtt) /
                                sizeof(oid), vars);

    snmp_varlist_add_variable(&var_list, newoid,
                              newoid_len,
                              ASN_UNSIGNED,
                              (u_char *) & (StorageTmp->
                                            pingResultsAverageRtt),
                              sizeof(StorageTmp->pingResultsAverageRtt));

    /*
     * pingResultsProbeResponses 
     */
    bzero(newoid, newoid_len);
    header_complex_generate_oid(newoid, &newoid_len,
                                pingResultsProbeResponses,
                                sizeof(pingResultsProbeResponses) /
                                sizeof(oid), vars);

    snmp_varlist_add_variable(&var_list, newoid,
                              newoid_len,
                              ASN_UNSIGNED,
                              (u_char *) & (StorageTmp->
                                            pingResultsProbeResponses),
                              sizeof(StorageTmp->
                                     pingResultsProbeResponses));
    /*
     * pingResultsSendProbes 
     */
    bzero(newoid, newoid_len);
    header_complex_generate_oid(newoid, &newoid_len, pingResultsSendProbes,
                                sizeof(pingResultsSendProbes) /
                                sizeof(oid), vars);

    snmp_varlist_add_variable(&var_list, newoid,
                              newoid_len,
                              ASN_UNSIGNED,
                              (u_char *) & (StorageTmp->
                                            pingResultsSendProbes),
                              sizeof(StorageTmp->pingResultsSendProbes));

    /*
     * XXX: stuff based on event table 
     */

    DEBUGMSG(("pingTest:send_ping_trap", "success!\n"));

    send_v2trap(var_list);
    snmp_free_varbind(vars);
    vars = NULL;
    snmp_free_varbind(var_list);
    vars = NULL;
}



void
readloop(struct pingCtlTable_data *item, struct addrinfo *ai, int datalen,
         unsigned long *minrtt, unsigned long *maxrtt,
         unsigned long *averagertt, pid_t pid)
{
    int             size;
    char            recvbuf[BUFSIZE];
    char            sendbuf[BUFSIZE];
    int             nsent = 1;
    socklen_t       len;
    ssize_t         n;
    struct timeval  tval;
    /* static int                    loop_num; */
    /* struct pingProbeHistoryTable_data * current=NULL; */
    struct pingProbeHistoryTable_data current_var;
    int             sockfd;
    int             current_probe_temp;
    int             success_probe = 0;
    int             fail_probe = 0;
    int             flag;
    unsigned long  *sumrtt;
    struct timeval  tv;

    sumrtt = (unsigned long *) malloc(sizeof(unsigned long));
    sockfd = socket(pr->sasend->sa_family, SOCK_RAW, pr->icmpproto);
    setuid(getuid());           /* don't need special permissions any more */

    size = 60 * 1024;           /* OK if setsockopt fails */

    tv.tv_sec = 5;
    tv.tv_usec = 0;
    setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));

    for (current_probe_temp = 1;
         current_probe_temp <= item->pingCtlProbeCount;
         current_probe_temp++) {
        (*pr->fsend) (datalen, pid, nsent, sockfd, sendbuf);
        nsent++;
        len = pr->salen;
        if (readable_timeo(sockfd, item->pingCtlTimeOut) == 0) {
            /* printf("socket timeout!\n"); */
            fail_probe = fail_probe + 1;
            flag = 1;
        } else {
            n = recvfrom(sockfd, recvbuf, sizeof(recvbuf), 0, pr->sarecv,
                         &len);
            success_probe = success_probe + 1;
            flag = 0;
        }

        gettimeofday(&tval, NULL);

        time_t          timep;
        time(&timep);

        (*pr->fproc) (recvbuf, n, &tval, timep, item, ai, datalen, minrtt,
                      maxrtt, sumrtt, averagertt, current_probe_temp,
                      success_probe, fail_probe, flag, &current_var, pid);
        printf("receiver success!\n");
        if (current_probe_temp >= item->pingCtlProbeCount) {
            SNMP_FREE(sumrtt);
            sumrtt = NULL;
            return;
        }
    }
}

unsigned long
round_double(double number)
{
    unsigned long   ret_num = 0;
    if (number - (unsigned long) number < 0.5)
        ret_num = (unsigned long) number;
    else
        ret_num = (unsigned long) number + 1;
    return ret_num;
}

int
proc_v4(char *ptr, ssize_t len, struct timeval *tvrecv, time_t timep,
        struct pingCtlTable_data *item, struct addrinfo *ai, int datalen,
        unsigned long *minrtt, unsigned long *maxrtt,
        unsigned long *sumrtt, unsigned long *averagertt,
        unsigned long current_probe, int success_probe, int fail_probe,
        int flag, struct pingProbeHistoryTable_data *current_temp,
        pid_t pid)
{
    int             hlen1 = 0, icmplen = 0;
    unsigned long   rtt = 0;

    struct ip      *ip = NULL;
    struct icmp    *icmp = NULL;
    struct timeval *tvsend = NULL;
    struct pingProbeHistoryTable_data *temp = NULL;
    static int      probeFailed = 0;
    static int      testFailed = 0;
    static int      series = 0;

    netsnmp_variable_list *vars = NULL;
    struct pingResultsTable_data *StorageNew = NULL;
    if (flag == 0) {
        series = 0;
        ip = (struct ip *) ptr; /* start of IP header */
        hlen1 = ip->ip_hl << 2; /* length of IP header */

        icmp = (struct icmp *) (ptr + hlen1);   /* start of ICMP header */
        if ((icmplen = len - hlen1) < 8)
            printf("icmplen (%d) < 8", icmplen);

        if (icmp->icmp_type == ICMP_ECHOREPLY) {
            if (icmp->icmp_id != pid)
                return;         /* not a response to our ECHO_REQUEST */
            if (icmplen < 16)
                printf("icmplen (%d) < 16", icmplen);


            tvsend = (struct timeval *) icmp->icmp_data;

            rtt =
                round_double((1000000 * (tvrecv->tv_sec - tvsend->tv_sec) +
                              tvrecv->tv_usec - tvsend->tv_usec) / 1000);

            snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) item->pingCtlOwnerIndex, item->pingCtlOwnerIndexLen);     /* pingCtlOwnerIndex */
            snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) item->pingCtlTestName, item->pingCtlTestNameLen); /* pingCtlTestName */


            if ((StorageNew =
                 header_complex_get(pingResultsTableStorage,
                                    vars)) == NULL)
                return SNMP_ERR_NOSUCHNAME;

            if (current_probe == 1) {
                *averagertt = rtt;
                *minrtt = rtt;
                *maxrtt = rtt;
                *sumrtt = rtt;
            } else {
                printf("else\n");
                if (rtt < *minrtt)
                    *minrtt = rtt;
                if (rtt > *maxrtt)
                    *maxrtt = rtt;
                *sumrtt = (*sumrtt) + rtt;
                *averagertt =
                    round_double((*sumrtt) /
                                 (StorageNew->pingResultsProbeResponses +
                                  1));
            }


            StorageNew->pingResultsMinRtt = *minrtt;
            StorageNew->pingResultsMaxRtt = *maxrtt;
            StorageNew->pingResultsAverageRtt = *averagertt;
            StorageNew->pingResultsProbeResponses =
                StorageNew->pingResultsProbeResponses + 1;
            StorageNew->pingResultsSendProbes =
                StorageNew->pingResultsSendProbes + 1;
            StorageNew->pingResultsRttSumOfSquares =
                StorageNew->pingResultsRttSumOfSquares + rtt * rtt;

            StorageNew->pingResultsLastGoodProbe =
                (char *) malloc(strlen(asctime(gmtime(&timep))));
            StorageNew->pingResultsLastGoodProbe =
                strdup(asctime(gmtime(&timep)));
            StorageNew->
                pingResultsLastGoodProbe[strlen(asctime(gmtime(&timep))) -
                                         1] = '\0';
            StorageNew->pingResultsLastGoodProbeLen =
                strlen(asctime(gmtime(&timep))) - 1;



            temp = SNMP_MALLOC_STRUCT(pingProbeHistoryTable_data);

            temp->pingCtlOwnerIndex =
                (char *) malloc(item->pingCtlOwnerIndexLen + 1);
            memcpy(temp->pingCtlOwnerIndex, item->pingCtlOwnerIndex,
                   item->pingCtlOwnerIndexLen + 1);
            temp->pingCtlOwnerIndex[item->pingCtlOwnerIndexLen] = '\0';
            temp->pingCtlOwnerIndexLen = item->pingCtlOwnerIndexLen;

            temp->pingCtlTestName =
                (char *) malloc(item->pingCtlTestNameLen + 1);
            memcpy(temp->pingCtlTestName, item->pingCtlTestName,
                   item->pingCtlTestNameLen + 1);
            temp->pingCtlTestName[item->pingCtlTestNameLen] = '\0';
            temp->pingCtlTestNameLen = item->pingCtlTestNameLen;

            /* add lock to protect */
            pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
            pthread_mutex_lock(&counter_mutex);
            if (item->pingProbeHistoryMaxIndex >=
                (unsigned long) (2147483647))
                item->pingProbeHistoryMaxIndex = 0;
            temp->pingProbeHistoryIndex =
                ++(item->pingProbeHistoryMaxIndex);
            pthread_mutex_unlock(&counter_mutex);


            temp->pingProbeHistoryResponse = rtt;
            temp->pingProbeHistoryStatus = 1;
            temp->pingProbeHistoryLastRC = 0;

            temp->pingProbeHistoryTime =
                (char *) malloc(strlen(asctime(gmtime(&timep))));
            temp->pingProbeHistoryTime = strdup(asctime(gmtime(&timep)));
            temp->pingProbeHistoryTime[strlen(asctime(gmtime(&timep))) -
                                       1] = '\0';
            temp->pingProbeHistoryTimeLen =
                strlen(asctime(gmtime(&timep))) - 1;

            if (StorageNew->pingResultsSendProbes == 1)
                item->pingProbeHis = temp;
            else {
                (current_temp)->next = temp;
            }

            current_temp = temp;

            if (StorageNew->pingResultsSendProbes >=
                item->pingCtlProbeCount) {
                current_temp->next = NULL;
            }

            if (item->pingProbeHis != NULL)
                if (pingProbeHistoryTable_count(item) <
                    item->pingCtlMaxRows) {
                    if (pingProbeHistoryTable_add(current_temp) !=
                        SNMPERR_SUCCESS)
                        DEBUGMSGTL(("pingProbeHistoryTable",
                                    "registered an entry error\n"));
                } else {
                    pingProbeHistoryTable_delLast(item);
                    if (pingProbeHistoryTable_add(current_temp) !=
                        SNMPERR_SUCCESS)
                        DEBUGMSGTL(("pingProbeHistoryTable",
                                    "registered an entry error\n"));

                }

        }
    }

    else if (flag == 1)
    {


        if (series == 0)
            probeFailed = 1;
        else
            probeFailed = probeFailed + 1;
        series = 1;
        testFailed = testFailed + 1;
        snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) item->pingCtlOwnerIndex, item->pingCtlOwnerIndexLen); /*  pingCtlOwnerIndex */
        snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) item->pingCtlTestName, item->pingCtlTestNameLen);     /* pingCtlTestName */


        if ((StorageNew =
             header_complex_get(pingResultsTableStorage, vars)) == NULL)
            return SNMP_ERR_NOSUCHNAME;

        if (current_probe == 1) {
            *averagertt = rtt;
            *minrtt = rtt;
            *maxrtt = rtt;
            *sumrtt = rtt;
        }
        StorageNew->pingResultsSendProbes =
            StorageNew->pingResultsSendProbes + 1;



        temp = SNMP_MALLOC_STRUCT(pingProbeHistoryTable_data);

        temp->pingCtlOwnerIndex =
            (char *) malloc(item->pingCtlOwnerIndexLen + 1);
        memcpy(temp->pingCtlOwnerIndex, item->pingCtlOwnerIndex,
               item->pingCtlOwnerIndexLen + 1);
        temp->pingCtlOwnerIndex[item->pingCtlOwnerIndexLen] = '\0';
        temp->pingCtlOwnerIndexLen = item->pingCtlOwnerIndexLen;

        temp->pingCtlTestName =
            (char *) malloc(item->pingCtlTestNameLen + 1);
        memcpy(temp->pingCtlTestName, item->pingCtlTestName,
               item->pingCtlTestNameLen + 1);
        temp->pingCtlTestName[item->pingCtlTestNameLen] = '\0';
        temp->pingCtlTestNameLen = item->pingCtlTestNameLen;

        /* add lock to protect */
        pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
        pthread_mutex_lock(&counter_mutex);
        temp->pingProbeHistoryIndex = ++(item->pingProbeHistoryMaxIndex);
        pthread_mutex_unlock(&counter_mutex);
        /* end */

        temp->pingProbeHistoryResponse = item->pingCtlTimeOut * 1000;
        temp->pingProbeHistoryStatus = 4;
        temp->pingProbeHistoryLastRC = 1;

        temp->pingProbeHistoryTime =
            (char *) malloc(strlen(asctime(gmtime(&timep))));