pingctltable.c

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

        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"));

            }

        if ((item->
             pingCtlTrapGeneration[0] & PINGTRAPGENERATION_PROBEFAILED) !=
            0) {
            if (probeFailed >= item->pingCtlTrapProbeFailureFilter)
                send_ping_trap(item, pingProbeFailed,
                               sizeof(pingProbeFailed) / sizeof(oid));
        }


    }

    if (current_probe == item->pingCtlProbeCount) {
        if ((item->
             pingCtlTrapGeneration[0] & PINGTRAPGENERATION_TESTCOMPLETED)
            != 0) {
            send_ping_trap(item, pingTestCompleted,
                           sizeof(pingTestCompleted) / sizeof(oid));
        } else
            if ((item->
                 pingCtlTrapGeneration[0] & PINGTRAPGENERATION_TESTFAILED)
                != 0) {

            if (testFailed >= item->pingCtlTrapTestFailureFilter)
                send_ping_trap(item, pingTestFailed,
                               sizeof(pingTestFailed) / sizeof(oid));
        }

        else if ((item->
                  pingCtlTrapGeneration[0] &
                  PINGTRAPGENERATION_PROBEFAILED) != 0) {;
        } else {
            ;
        }

        series = 0;
        probeFailed = 0;
        testFailed = 0;

    }
    return;
}



void
send_v4(int datalen, pid_t pid, int nsent, int sockfd, char *sendbuf)
{
    int             len;
    struct icmp    *icmp = NULL;
    struct timeval *temp = NULL;

    icmp = (struct icmp *) sendbuf;
    icmp->icmp_type = ICMP_ECHO;
    icmp->icmp_code = 0;
    icmp->icmp_id = pid;
    icmp->icmp_seq = nsent;
    gettimeofday((struct timeval *) icmp->icmp_data, NULL);
    temp = (struct timeval *) icmp->icmp_data;

    len = 8 + datalen;          /* checksum ICMP header and data */
    icmp->icmp_cksum = 0;
    icmp->icmp_cksum = in_cksum((u_short *) icmp, len);

    sendto(sockfd, sendbuf, len, 0, pr->sasend, pr->salen);
}


void
run_ping(unsigned int clientreg, void *clientarg)
/* run_ping(struct pingCtlTable_data *item) */
{
    struct pingCtlTable_data *item = clientarg;
    netsnmp_variable_list *vars = NULL;
    struct pingResultsTable_data *StorageNew = NULL;

    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;

    StorageNew->pingResultsSendProbes = 0;
    StorageNew->pingResultsProbeResponses = 0;

    if (item->pingCtlTargetAddressType == 1
        || item->pingCtlTargetAddressType == 16) {
        struct proto    proto_v4 =
            { proc_v4, send_v4, NULL, NULL, 0, IPPROTO_ICMP };
        char           *host = NULL;
        pid_t           pid;    /* our PID */

        int             datalen;
        unsigned long  *minrtt = NULL;
        unsigned long  *maxrtt = NULL;
        unsigned long  *averagertt = NULL;

        datalen = 56;           /* data that goes with ICMP echo request */
        unsigned int    n = 1;
        int             c;
        struct addrinfo *ai = NULL;
        minrtt = malloc(sizeof(unsigned long));
        maxrtt = malloc(sizeof(unsigned long));
        averagertt = malloc(sizeof(unsigned long));
        host = item->pingCtlTargetAddress;
        pid = getpid();

        ai = host_serv(host, NULL, 0, 0);

        printf("PING %s (%s): %d data bytes\n", ai->ai_canonname,
               sock_ntop_host(ai->ai_addr, ai->ai_addrlen), datalen);

        /*
         * 4initialize according to protocol 
         */
        if (ai->ai_family == AF_INET) {
            pr = &proto_v4;
#ifdef	IPV6
        } else if (ai->ai_family == AF_INET6) {
            pr = &proto_v6;

            if (IN6_IS_ADDR_V4MAPPED(&(((struct sockaddr_in6 *)
                                        ai->ai_addr)->sin6_addr)))
                printf("cannot ping IPv4-mapped IPv6 address");
#endif
        } else
            printf("unknown address family %d", ai->ai_family);

        pr->sasend = ai->ai_addr;
        pr->sarecv = calloc(1, ai->ai_addrlen);
        pr->salen = ai->ai_addrlen;
        readloop(item, ai, datalen, minrtt, maxrtt, averagertt, pid);

        SNMP_FREE(minrtt);
        minrtt = NULL;
        SNMP_FREE(maxrtt);
        maxrtt = NULL;
        SNMP_FREE(averagertt);
        averagertt = NULL;
        free(ai);
        ai = NULL;
    }

    else if (item->pingCtlTargetAddressType == 2) {

        int             ch = 0, hold = 0, packlen = 0;
        u_char         *packet = NULL;
        char           *target = NULL;
        struct sockaddr_in6 firsthop;
        int             socket_errno = 0;
        struct icmp6_filter filter;
        int             err = 0, csum_offset = 0, sz_opt = 0;

        static int      icmp_sock = 0;
        int             uid = 0;
        struct sockaddr_in6 source;
        int             preload = 0;
        struct cmsghdr *srcrt = NULL;
        static unsigned char cmsgbuf[4096];
        static int      cmsglen = 0;
        struct sockaddr_in6 whereto;    /* who to ping */
        int             options = 0;
        char           *hostname = NULL;
        char           *device = NULL;
        int             interval = 1000;        /* interval between packets (msec) */
        int             pmtudisc = -1;
        int             datalen = DEFDATALEN;
        int             timing = 0;     /* flag to do timing */
        int             working_recverr = 0;
        __u32           flowlabel = 0;
        __u32           tclass = 0;

        int             ident = 0;      /* process id to identify our packets */
        u_char          outpack[MAX_PACKET];
        struct timeval  start_time;
        static int      screen_width = INT_MAX;
        int             deadline = 0;   /* time to die */
        int             timeout = 0;

        timeout = item->pingCtlTimeOut;
        memset(&source, 0, sizeof(source));
        icmp_sock = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
        socket_errno = errno;

        uid = getuid();
        setuid(uid);

        source.sin6_family = AF_INET6;
        memset(&firsthop, 0, sizeof(firsthop));
        firsthop.sin6_family = AF_INET6;
        preload = 1;

        target = item->pingCtlTargetAddress;

        memset(&whereto, 0, sizeof(struct sockaddr_in6));
        whereto.sin6_family = AF_INET6;
        whereto.sin6_port = htons(IPPROTO_ICMPV6);

        if (inet_pton(AF_INET6, target, &whereto.sin6_addr) <= 0) {
            struct hostent *hp = NULL;

            hp = gethostbyname2(target, AF_INET6);

            if (hp == NULL) {
                fprintf(stderr, "unknown host\n");
                return;
            }

            memcpy(&whereto.sin6_addr, hp->h_addr_list[0], 16);
        } else {
            options |= F_NUMERIC;
        }
        if (ipv6_addr_any(&firsthop.sin6_addr))
            memcpy(&firsthop.sin6_addr, &whereto.sin6_addr, 16);

        hostname = target;

        if (ipv6_addr_any(&source.sin6_addr)) {

            int             alen;
            int             probe_fd = socket(AF_INET6, SOCK_DGRAM, 0);

            if (probe_fd < 0) {
                printf("error!\n");
                perror("socket");
                return;
            }
            if (device) {
                struct ifreq    ifr;
                memset(&ifr, 0, sizeof(ifr));
                strncpy(ifr.ifr_name, device, IFNAMSIZ - 1);
                if (setsockopt
                    (probe_fd, SOL_SOCKET, SO_BINDTODEVICE, device,
                     strlen(device) + 1) == -1) {
#ifdef HAVE_SIN6_SCOPEID
                    if ((firsthop.sin6_addr.
                         s6_addr16[0] & htons(0xffc0)) == htons(0xfe80)
                        || (firsthop.sin6_addr.
                            s6_addr16[0] & htons(0xffff)) ==
                        htons(0xff02)) {
                        if (ioctl(probe_fd, SIOCGIFINDEX, &ifr) < 0) {
                            fprintf(stderr, "ping: unknown iface %s\n",
                                    device);
                            return;
                        }
                        firsthop.sin6_scope_id = ifr.ifr_ifindex;
                    }
#endif
                }
            }
            firsthop.sin6_port = htons(1025);
            if (connect
                (probe_fd, (struct sockaddr *) &firsthop,
                 sizeof(firsthop)) == -1) {
                perror("connect");
                return;
            }
            alen = sizeof(source);
            if (getsockname(probe_fd, (struct sockaddr *) &source, &alen)
                == -1) {
                perror("getsockname");
                return;
            }
            source.sin6_port = 0;
            close(probe_fd);
        }

        if (icmp_sock < 0) {
            errno = socket_errno;
            perror("ping: icmp open socket");
            return;
        }

        if ((whereto.sin6_addr.s6_addr16[0] & htons(0xff00)) ==
            htons(0xff00)) {
            if (uid) {
                if (interval < 1000) {
                    fprintf(stderr,
                            "ping: multicast ping with too short interval.\n");
                    return;
                }
                if (pmtudisc >= 0 && pmtudisc != IPV6_PMTUDISC_DO) {
                    fprintf(stderr,
                            "ping: multicast ping does not fragment.\n");
                    return;
                }
            }
            if (pmtudisc < 0)
                pmtudisc = IPV6_PMTUDISC_DO;
        }

        if (pmtudisc >= 0) {
            if (setsockopt
                (icmp_sock, SOL_IPV6, IPV6_MTU_DISCOVER, &pmtudisc,
                 sizeof(pmtudisc)) == -1) {
                perror("ping: IPV6_MTU_DISCOVER");
                return;
            }
        }
        if (bind(icmp_sock, (struct sockaddr *) &source, sizeof(source)) ==
            -1) {
            perror("ping: bind icmp socket");
            return;
        }
        if (datalen >= sizeof(struct timeval))  /* can we time transfer */
            timing = 1;
        packlen = datalen + 8 + 4096 + 40 + 8;  /* 4096 for rthdr */
        if (!(packet = (u_char *) malloc((u_int) packlen))) {
            fprintf(stderr, "ping: out of memory.\n");
            return;
        }

        working_recverr = 1;
        hold = 1;
        if (setsockopt
            (icmp_sock, SOL_IPV6, IPV6_RECVERR, (char *) &hold,
             sizeof(hold))) {
            fprintf(stderr,
                    "WARNING: your kernel is veeery old. No problems.\n");
            working_recverr = 0;
        }

        /*
         * Estimate memory eaten by single packet. It is rough estimate.
         * * Actually, for small datalen's it depends on kernel side a lot. 
         */
        hold = datalen + 8;
        hold += ((hold + 511) / 512) * (40 + 16 + 64 + 160);
        sock_setbufs(icmp_sock, hold, preload);

        csum_offset = 2;
        sz_opt = sizeof(int);

        err =
            setsockopt(icmp_sock, SOL_RAW, IPV6_CHECKSUM, &csum_offset,
                       sz_opt);
        if (err < 0) {