lookupctltable.c

开发snmp的开发包有两个开放的SNMP开发库

    case COLUMN_LOOKUPCTLTARGETADDRESSTYPE:
        *write_method = write_lookupCtlTargetAddressType;
        *var_len = sizeof(StorageTmp->lookupCtlTargetAddressType);
        return (u_char *) & StorageTmp->lookupCtlTargetAddressType;

    case COLUMN_LOOKUPCTLTARGETADDRESS:
        *write_method = write_lookupCtlTargetAddress;
        *var_len = (StorageTmp->lookupCtlTargetAddressLen);

        return (u_char *) StorageTmp->lookupCtlTargetAddress;

    case COLUMN_LOOKUPCTLOPERSTATUS:
        *var_len = sizeof(StorageTmp->lookupCtlOperStatus);

        return (u_char *) & StorageTmp->lookupCtlOperStatus;

    case COLUMN_LOOKUPCTLTIME:
        *var_len = sizeof(StorageTmp->lookupCtlTime);

        return (u_char *) & StorageTmp->lookupCtlTime;

    case COLUMN_LOOKUPCTLRC:
        *var_len = sizeof(StorageTmp->lookupCtlRc);

        return (u_char *) & StorageTmp->lookupCtlRc;

    case COLUMN_LOOKUPCTLROWSTATUS:
        *write_method = write_lookupCtlRowStatus;
        *var_len = sizeof(StorageTmp->lookupCtlRowStatus);

        return (u_char *) & StorageTmp->lookupCtlRowStatus;

    default:
        ERROR_MSG("");
    }
    return NULL;
}


void
run_lookup(struct lookupTable_data *item)
{

    long            addressType;
    char           *address = NULL;
    size_t          addresslen;
    struct lookupResultsTable_data *head = NULL;
    struct lookupResultsTable_data *current = NULL;
    struct lookupResultsTable_data *temp = NULL;
    int             i = 0, n = 1, t = 0;

    /* for ipv4,ipv6 */
    unsigned int    addr_in, addr_in6;
    struct hostent *lookup = NULL;
    struct sockaddr_in *addr = NULL;

    struct timeval  tpstart, tpend;
    unsigned long   timeuse, timeuse4, timeuse6;

    /* for dns */

    struct in_addr  a;
    struct in6_addr a6;
    char           *strptr = NULL;
    struct addrinfo hints, *res = NULL, *tempinfo = NULL;
    struct sockaddr_in6 myaddress6;
    char            buf[BUFSIZ];


    if (item == NULL)
        return;

    addressType = (long) item->lookupCtlTargetAddressType;
    addresslen = (size_t) item->lookupCtlTargetAddressLen;
    address = (char *) malloc(addresslen + 1);
    memcpy(address, item->lookupCtlTargetAddress, addresslen + 1);
    address[addresslen] = '\0';

    if (addressType == 1) {
        addr_in = inet_addr(address);
        if (addr_in == 0xffffffff
            && strcmp(address, "255.255.255.255") != 0) {
            DEBUGMSGTL(("lookupResultsTable", "Invalid argument: %s\n",
                        address));
            return;
        }

        gettimeofday(&tpstart, NULL);
        lookup = gethostbyaddr((char *) &addr_in, 4, AF_INET);
        gettimeofday(&tpend, NULL);
        timeuse = 1000000 * (tpend.tv_sec - tpstart.tv_sec) +
            tpend.tv_usec - tpstart.tv_usec;
        timeuse /= 1000;
        modify_lookupCtlTime(item, timeuse);
        modify_lookupCtlOperStatus(item, 3l);

        if (lookup == NULL) {
            DEBUGMSGTL(("lookupCtlTable",
                        "Can't get a network host entry for ipv4 address: %s\n",
                        address));
            modify_lookupCtlRc(item, 1l);
            return;
        } else {
            modify_lookupCtlRc(item, 0l);
            if (lookup->h_name != NULL) {
                current = temp =
                    SNMP_MALLOC_STRUCT(lookupResultsTable_data);
                if (temp == NULL) {
                    exit(1);
                }
                temp->lookupResultsIndex = n;

                temp->lookupCtlOwnerIndex =
                    (char *) malloc(item->lookupCtlOwnerIndexLen + 1);
                if (temp->lookupCtlOwnerIndex == NULL) {
                    exit(1);
                }
                memcpy(temp->lookupCtlOwnerIndex,
                       item->lookupCtlOwnerIndex,
                       item->lookupCtlOwnerIndexLen + 1);
                temp->lookupCtlOwnerIndex[item->lookupCtlOwnerIndexLen] =
                    '\0';
                temp->lookupCtlOwnerIndexLen =
                    item->lookupCtlOwnerIndexLen;

                temp->lookupCtlOperationName =
                    (char *) malloc(item->lookupCtlOperationNameLen + 1);
                if (temp->lookupCtlOperationName == NULL) {
                    exit(1);
                }
                memcpy(temp->lookupCtlOperationName,
                       item->lookupCtlOperationName,
                       item->lookupCtlOperationNameLen + 1);
                temp->lookupCtlOperationName[item->
                                             lookupCtlOperationNameLen] =
                    '\0';
                temp->lookupCtlOperationNameLen =
                    item->lookupCtlOperationNameLen;

                temp->lookupResultsAddressType = 16;
                temp->lookupResultsAddress =
                    (char *) malloc(strlen(lookup->h_name) + 1);
                memcpy(temp->lookupResultsAddress, lookup->h_name,
                       strlen(lookup->h_name) + 1);
                temp->lookupResultsAddress[strlen(lookup->h_name)] = '\0';
                temp->lookupResultsAddressLen = strlen(lookup->h_name);
                item->ResultsTable = temp;
                n = n + 1;

            }

            i = 0;
            while (lookup->h_aliases[i]) {
                temp = SNMP_MALLOC_STRUCT(lookupResultsTable_data);
                if (temp == NULL) {
                    exit(1);
                }
                temp->lookupCtlOwnerIndex =
                    (char *) malloc(item->lookupCtlOwnerIndexLen + 1);
                if (temp->lookupCtlOwnerIndex == NULL) {
                    exit(1);
                }
                memcpy(temp->lookupCtlOwnerIndex,
                       item->lookupCtlOwnerIndex,
                       item->lookupCtlOwnerIndexLen + 1);
                temp->lookupCtlOwnerIndex[item->lookupCtlOwnerIndexLen] =
                    '\0';
                temp->lookupCtlOwnerIndexLen =
                    item->lookupCtlOwnerIndexLen;

                temp->lookupCtlOperationName =
                    (char *) malloc(item->lookupCtlOperationNameLen + 1);
                if (temp->lookupCtlOperationName == NULL) {
                    exit(1);
                }
                memcpy(temp->lookupCtlOperationName,
                       item->lookupCtlOperationName,
                       item->lookupCtlOperationNameLen + 1);
                temp->lookupCtlOperationName[item->
                                             lookupCtlOperationNameLen] =
                    '\0';
                temp->lookupCtlOperationNameLen =
                    item->lookupCtlOperationNameLen;

                temp->lookupResultsIndex = n;
                temp->lookupResultsAddressType = 16;
                temp->lookupResultsAddress =
                    (char *) malloc(strlen(lookup->h_aliases[i]) + 1);
                memcpy(temp->lookupResultsAddress, lookup->h_aliases[i],
                       strlen(lookup->h_aliases[i]) + 1);
                temp->lookupResultsAddress[strlen(lookup->h_aliases[i])] =
                    '\0';
                temp->lookupResultsAddressLen =
                    strlen(lookup->h_aliases[i]);
                current->next = temp;
                current = temp;
                i = i + 1;
                n = n + 1;
            }
            current->next = NULL;

        }


        if (item->ResultsTable != NULL)
            if (lookupResultsTable_add(item) != SNMPERR_SUCCESS)
                DEBUGMSGTL(("lookupResultsTable",
                            "registered an entry error\n"));

        SNMP_FREE(address);
        address = NULL;
        return;
    }

    else if (addressType == 16) {

        gettimeofday(&tpstart, NULL);
        lookup = gethostbyname(address);
        gettimeofday(&tpend, NULL);
        timeuse4 = 1000000 * (tpend.tv_sec - tpstart.tv_sec) +
            tpend.tv_usec - tpstart.tv_usec;
        timeuse4 /= 1000;
        if (lookup == NULL) {
            DEBUGMSGTL(("lookupCtlTable",
                        "Can't get a network host entry for %s\n",
                        address));
        } else {
            while (*lookup->h_addr_list) {
                bcopy(*lookup->h_addr_list++, (char *) &a, sizeof(a));

                temp = SNMP_MALLOC_STRUCT(lookupResultsTable_data);
                if (temp == NULL) {
                    exit(1);
                }
                temp->lookupResultsIndex = n;

                temp->lookupCtlOwnerIndex =
                    (char *) malloc(item->lookupCtlOwnerIndexLen + 1);
                if (temp->lookupCtlOwnerIndex == NULL) {
                    exit(1);
                }
                memcpy(temp->lookupCtlOwnerIndex,
                       item->lookupCtlOwnerIndex,
                       item->lookupCtlOwnerIndexLen + 1);
                temp->lookupCtlOwnerIndex[item->lookupCtlOwnerIndexLen] =
                    '\0';
                temp->lookupCtlOwnerIndexLen =
                    item->lookupCtlOwnerIndexLen;

                temp->lookupCtlOperationName =
                    (char *) malloc(item->lookupCtlOperationNameLen + 1);
                if (temp->lookupCtlOperationName == NULL) {
                    exit(1);
                }

                memcpy(temp->lookupCtlOperationName,
                       item->lookupCtlOperationName,
                       item->lookupCtlOperationNameLen + 1);
                temp->lookupCtlOperationName[item->
                                             lookupCtlOperationNameLen] =
                    '\0';
                temp->lookupCtlOperationNameLen =
                    item->lookupCtlOperationNameLen;

                temp->lookupResultsAddressType = 1;
                temp->lookupResultsAddress =
                    (char *) malloc(strlen(inet_ntoa(a)) + 1);
                if (temp->lookupResultsAddress == NULL) {
                    exit(1);
                }
                memcpy(temp->lookupResultsAddress, inet_ntoa(a),
                       strlen(inet_ntoa(a)) + 1);
                temp->lookupResultsAddress[strlen(inet_ntoa(a))] = '\0';
                temp->lookupResultsAddressLen = strlen(inet_ntoa(a));
                if (n == 1)
                    item->ResultsTable = temp;
                else
                    current->next = temp;
                current = temp;
                n = n + 1;

            }
            current->next = NULL;
            t = n;

        }

        struct hostent *hp;
        char            pa[64];
        char           *hostname = NULL;

        gettimeofday(&tpstart, NULL);
        hp = gethostbyname2(address, AF_INET6);
        gettimeofday(&tpend, NULL);
        timeuse6 = 1000000 * (tpend.tv_sec - tpstart.tv_sec) +
            tpend.tv_usec - tpstart.tv_usec;
        timeuse6 /= 1000;

        if (hp == NULL) {
            DEBUGMSGTL(("lookupCtlTable",
                        "Can't get a ipv6 network host entry for %s\n",
                        address));
        } else {
            while (*hp->h_addr_list) {
                memmove((caddr_t) & a6, *hp->h_addr_list++, 16);
                hostname = (char *) hp->h_name;

                temp = SNMP_MALLOC_STRUCT(lookupResultsTable_data);
                if (temp == NULL) {
                    exit(1);
                }
                temp->lookupResultsIndex = n;

                temp->lookupCtlOwnerIndex =
                    (char *) malloc(item->lookupCtlOwnerIndexLen + 1);
                if (temp->lookupCtlOwnerIndex == NULL) {
                    exit(1);
                }
                memcpy(temp->lookupCtlOwnerIndex,
                       item->lookupCtlOwnerIndex,
                       item->lookupCtlOwnerIndexLen + 1);
                temp->lookupCtlOwnerIndex[item->lookupCtlOwnerIndexLen] =
                    '\0';
                temp->lookupCtlOwnerIndexLen =
                    item->lookupCtlOwnerIndexLen;

                temp->lookupCtlOperationName =
                    (char *) malloc(item->lookupCtlOperationNameLen + 1);
                if (temp->lookupCtlOperationName == NULL) {
                    exit(1);
                }
                memcpy(temp->lookupCtlOperationName,
                       item->lookupCtlOperationName,
                       item->lookupCtlOperationNameLen + 1);
                temp->lookupCtlOperationName[item->
                                             lookupCtlOperationNameLen] =
                    '\0';
                temp->lookupCtlOperationNameLen =
                    item->lookupCtlOperationNameLen;

                temp->lookupResultsAddressType = 2;
                temp->lookupResultsAddress =
                    (char *)
                    malloc(strlen(inet_ntop(AF_INET6, &a6, pa, 64)) + 1);
                memcpy(temp->lookupResultsAddress,
                       inet_ntop(AF_INET6, &a6, pa, 64),
                       strlen(inet_ntop(AF_INET6, &a6, pa, 64)) + 1);
                temp->
                    lookupResultsAddress[strlen
                                         (inet_ntop
                                          (AF_INET6, &a6, pa, 64))] = '\0';
                temp->lookupResultsAddressLen =
                    strlen(inet_ntop(AF_INET6, &a6, pa, 64));
                if (n == 1)
                    item->ResultsTable = temp;
                else
                    current->next = temp;
                current = temp;
                n = n + 1;

            }
            current->next = NULL;
        }
        timeuse = timeuse4 + timeuse6;
        modify_lookupCtlTime(item, timeuse);
        modify_lookupCtlOperStatus(item, 3l);

        if (item->ResultsTable != NULL) {

            modify_lookupCtlRc(item, 0l);
            if (lookupResultsTable_add(item) != SNMPERR_SUCCESS)
                DEBUGMSGTL(("lookupResultsTable",
                            "registered an entry error\n"));
        } else {
            modify_lookupCtlRc(item, 1l);
        }
        SNMP_FREE(address);
        address = NULL;

        return;

    }


    else if (addressType == 2) {
        if (inet_pton(AF_INET6, address, &addr_in6) == 1)
            DEBUGMSGTL(("lookupCtlTable", "success! \n"));