agent.c

wm PNE 3.3 source code, running at more than vxworks6.x version.

{
int got, szfrom;
struct sockaddr_un mfrom;
char newbuff[2000], *buf = 0;
fd_set ready;
struct timeval timeout;

/* set up a select call and wait for a packet */
FD_ZERO(&ready);
FD_SET(query_socket, &ready);
timeout.tv_sec = 1;
timeout.tv_usec = 0;

if (select(query_socket + 1, &ready, 0, 0, &timeout) <= 0)
    return(1);

szfrom = sizeof(mfrom);
got = recvfrom(query_socket, newbuff, sizeof(newbuff),
               0, (struct sockaddr *)&mfrom, &szfrom);
if ((got < 0) || ((buf = SNMP_memory_alloc(got)) == 0))
    return(2);
MEMCPY(buf, newbuff, got);

EBufferPreLoad(BFL_IS_DYNAMIC, rbuf, buf, got);
return(0);
}

void
  ipcfree(PTR_T addr)
{
SNMP_memory_free(addr);
}

INT_32_T
  ipcayt(PTR_T addr)
{
return(1);
}

void
  ipc_timer(ENVOY_TIMER_T *tm,
            void          *cookiep)
{
Master_Cleanup((bits16_t)((((ENVOY_TIMER_32_T *)cookiep)->id) & 0xFFFF),
               SA_CLEANUP_CONTINUE | SA_CLEANUP_INACTIVE | SA_CLEANUP_TIMEOUT);
SNMP_memory_free(cookiep);
}

INT_32_T
  ipcsend_asy(EBUFFER_T *ebuf,
              PTR_T      addr,
              UINT_16_T  reqid)
{
IPCADDR_T *iaddr;
ENVOY_TIMER_32_T *tm;

tm = (ENVOY_TIMER_32_T *)SNMP_memory_alloc(sizeof(ENVOY_TIMER_32_T));

if (tm == 0)
    return(-1);
envoy_tm_init(&(tm->timer));
tm->id = (bits32_t)reqid;
tm->timer.cookie = tm;
tm->timer.handler = ipc_timer;
if (envoy_tm_set(&(tm->timer), 1000)) {
    SNMP_memory_free(tm);
    return(-1);
    }

iaddr = (IPCADDR_T *)addr;

sendto(query_socket, EBufferStart(ebuf), EBufferUsed(ebuf),
       0, (struct sockaddr *)(&iaddr->from), iaddr->size);
EBufferClean(ebuf);
return(0);
}

#endif

/* Initialize the agent                 */
/* Return 0 on sucess, -1 on failure    */
/*ARGSUSED*/
int
  agent_init(int   port,
             char *syms)
{
struct sockaddr_in      srvr;
#if INSTALL_SNMP_DEMO_AGENT_IPV6
struct sockaddr_in6     srvr_ipv6;
#endif 
#if INSTALL_ENVOY_EPI_MASTER
struct sockaddr_un      master, master_query;
#endif

/* initialize envoy */
envoy_init();

if (read_config() == -1) {
    printf("Can not read configuration file `%s'\n", config_file);
    return -1;
    }

if (trace_level > 0){
    printf("Using kernel file `%s'\n", kernel_file);
    fflush(stdout);
    }

if (setup_mib() == -1) {
    printf("Can not set up management information base (MIB)\n");
    return -1;
    }

if (trace_level > 0) {
    int i;
    OIDC_T *oidp;
    printf("\n\n****HOST INFORMATION****\n");
    printf("sysDescr is \"%s\"\n", snmp_sysDescr);
    printf("sysContact is \"%s\"\n", snmp_sysContact);
    printf("sysLocation is \"%s\"\n", snmp_sysLocation);
    printf("System Boot time was %24.24s\n",
           (char *)ctime((time_t *)&(boot_at.tv_sec)));
    printf("System object identifier has %d components:\n\t",
           snmp_sysObjectID.num_components);
    for (i = 0, oidp = snmp_sysObjectID.component_list;
         i < snmp_sysObjectID.num_components; i++, oidp++)
        printf("%lu.", *oidp);
    printf("\n");

    printf("Local IP address: %d.%d.%d.%d\n", snmp_local_ip_address[0],
           snmp_local_ip_address[1], snmp_local_ip_address[2],
           snmp_local_ip_address[3]);

    printf("\n\n****SNMP AGENT INFORMATION****\n");
    printf("Community names:\n");
    printf("\tRead: \t%s\n\tWrite:\t%s\n\tTrap: \t%s\n",
           snmp_get_request_community, snmp_set_request_community,
           snmp_trap_community);

    if (trap_2_cnt > 0) {
        struct in_addr ia;
        printf("Traps will be sent to:\n");
        for(i = 0; i < trap_2_cnt; i++) {
            ia.s_addr = traplist[i];       
            printf("\t%s\n", (char *)inet_ntoa(ia));
            }
        }
    else printf("No traps receivers defined\n");

    printf("SNMP service will be provided on port %d\n", port);
    printf("\n\n");
    fflush(stdout);
    }

if ((snmp_socket = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
    perror("Can't get socket");
    return -1;
    }

srvr.sin_family = AF_INET;
srvr.sin_port = htons(port);
srvr.sin_addr.s_addr = 0L;

if (bind(snmp_socket, (struct sockaddr *)&srvr, sizeof(srvr)) == -1) {
    perror("Can't bind server socket");
    return -1;
    }

#if INSTALL_SNMP_DEMO_AGENT_IPV6

if ((snmp_ipv6_socket = socket(PF_INET6, SOCK_DGRAM, 0)) == -1) {
    perror("Can't get IPV6 socket");
    return -1;
    }

srvr_ipv6.sin6_family = AF_INET6;
srvr_ipv6.sin6_flowinfo = 0;
srvr_ipv6.sin6_port  = htons(port);
srvr_ipv6.sin6_addr = in6addr_any;

if (bind(snmp_ipv6_socket, (struct sockaddr *)&srvr_ipv6,
         sizeof(srvr_ipv6)) == -1) {
    perror("Can't bind IPV6 server socket");
    return -1;
    }
 
#endif /* INSTALL_SNMP_DEMO_AGENT_IPV6 */
 
#if INSTALL_ENVOY_EPI_MASTER
if ((master_socket = socket(AF_UNIX, SOCK_DGRAM, 0)) == -1) {
    perror("Can't get socket");
    return -1;
    }

unlink(MASTER_AGENT);
master.sun_family = AF_UNIX;
STRCPY(master.sun_path, MASTER_AGENT);

if (bind(master_socket, (struct sockaddr *)&master, sizeof(master)) == -1) {
    perror("Can't bind master agent socket");
    return -1;
    }

if ((query_socket = socket(AF_UNIX, SOCK_DGRAM, 0)) == -1) {
    perror("Can't get socket");
    return -1;
    }

unlink(MASTER_QUERY);
master_query.sun_family = AF_UNIX;
STRCPY(master_query.sun_path, MASTER_QUERY);

if (bind(query_socket, (struct sockaddr *)&master_query,
         sizeof(master_query)) == -1) {
    perror("Can't bind master query socket");
    return -1;
    }

#endif

if (snmpvars_init() == -1) return -1;
if (libfuncs_init() == -1) return -1;
if (sys_init() == -1) return -1;   /* Must preceed if_init() */

#if (defined(INSTALL_on_sunos) && INSTALL_on_sunos)
if (if_init() == -1) return -1;    /* Must come somewhere after sys_init */
if (arp_init() == -1) return -1;
if (icmp_init() == -1) return -1;
if (ip_init() == -1) return -1;
if (icmp_init() == -1) return -1;
if (iprte_init() == -1) return -1;
if (tcp_init() == -1) return -1;
if (udp_init() == -1) return -1;
#endif

#if (INSTALL_ENVOY_SNMP_VERSION_3 || INSTALL_ENVOY_SNMP_DYNAMIC_VIEWS)
SNMP_NV_Config(0);
#endif

return 0;
}

/*ARGSUSED*/
int
  agent_body(int   port,
             char *syms)
{
EBUFFER_T               ebuff;
struct sockaddr_in      from;
struct sockaddr_in      dest;
#if INSTALL_SNMP_DEMO_AGENT_IPV6
struct sockaddr_in6     from_v6;
struct sockaddr_in6     dest_v6;
#endif 
int                     szfrom;
unsigned int            pktnum = 0;
int                     maxsock;

#if INSTALL_ENVOY_EPI_MASTER
unsigned int            mpktnum = 0;
struct sockaddr_un      mfrom;
VBL_T                   rvblist;
IPCADDR_T               *iaddr;

(void)MEMSET(&rvblist, 0, sizeof(VBL_T));
maxsock = max(max(snmp_socket, master_socket), query_socket) + 1;
#else
maxsock = snmp_socket + 1;
#endif

#if INSTALL_SNMP_DEMO_AGENT_IPV6
if (maxsock <= snmp_ipv6_socket)
    maxsock = snmp_ipv6_socket + 1;

(void)MEMSET(&dest_v6, 0, sizeof(dest_v6)); 

send_traps(snmp_ipv6_socket, COLD_START);
#endif 
 
(void)MEMSET(&dest, 0, sizeof(dest));

send_traps(snmp_socket, COLD_START);

EBufferInitialize(&ebuff);
EBufferClean(&ebuff);

if (trace_level > 2)
    printf("Waiting for input...\n");
fflush(stdout);

while(1) {
    int got;
    fd_set ready;

    /* set up the select call and then wait for a packet */
    FD_ZERO(&ready);
    FD_SET(snmp_socket, &ready);
#if INSTALL_ENVOY_EPI_MASTER
    FD_SET(master_socket, &ready);
    FD_SET(query_socket, &ready);
#endif
#if INSTALL_SNMP_DEMO_AGENT_IPV6
    FD_SET(snmp_ipv6_socket, &ready);
#endif
    if (callee) {
        struct timeval tp;
        bits32_t rtime;
        void (*to_call)(void);

        rtime = calltime - envoy_now();
        if (rtime >= 0x10000000) {
            to_call = callee;
            callee = 0;
            (*to_call)();
            continue;
            }
        tp.tv_sec = rtime/1000;
        tp.tv_usec = (rtime%1000) * 1000;
        switch (select(maxsock, &ready, 0, 0, &tp)) {
            case -1:
                perror("Select failed ...\n");
                continue;
            case 0:
                to_call = callee;
                callee = 0;
                (*to_call)();
                continue;
            }
        }
    else  {
        if (select(maxsock, &ready, 0, 0, 0) < 0) {
            perror("Select failed ...\n");
            continue;
            }
        }
    /* if it is a udp packet it is an snmp packet */
    if (FD_ISSET(snmp_socket, &ready)) {
        pktnum++;
        szfrom = sizeof(from);
        if ((got = recvfrom(snmp_socket, rcvbuff, sizeof(rcvbuff),
                            0, (struct sockaddr *)&from, &szfrom))
            == -1) {
            perror("Recvfrom failed");
            continue;
            }

        if (trace_level > 2)
            printf("Received packet...\n");

        /* See if we are supposed to process the packet with
           the async routine, or the old sync routine */
        if (snmp_use_async)
            Process_Rcvd_SNMP_Packet_Async(got, rcvbuff, (SNMPADDR_T *)&from, 
                                           (SNMPADDR_T *)&dest,
                                           SNMP_MAX_PACKET_SIZE,
                                           agent_io_routine,
                                           agent_error_routine,
                                           0);
        else {
            if (Process_Received_SNMP_Packet(rcvbuff, got,
                                             (SNMPADDR_T *)&from, 
                                             (SNMPADDR_T *)&dest,
                                             &ebuff) == -1) {
                if (trace_level > 0)
                    printf("Decode failure\n");
                continue;
                }

            if (trace_level > 2)
                printf("Sending reply...\n");

            (void) sendto(snmp_socket, ebuff.start_bp, EBufferUsed(&ebuff),
                          0, (struct sockaddr *)&from, szfrom);

            EBufferClean(&ebuff);
            }
        fflush(stdout);
        }

#if INSTALL_SNMP_DEMO_AGENT_IPV6
    /* if it is a udp over IPv6 packet it is an snmp packet */
    if (FD_ISSET(snmp_ipv6_socket, &ready)) {
        pktnum++;
        szfrom = sizeof(from_v6);
        if ((got = recvfrom(snmp_ipv6_socket, rcvbuff, sizeof(rcvbuff),
                            0, (struct sockaddr *)&from_v6, &szfrom))
            == -1) {
            perror("Recvfrom failed");
            continue;
            }

        if (trace_level > 2)
            printf("Received packet on IPv6 socket...\n");

        Process_Rcvd_SNMP_Packet_Async(got, rcvbuff, (SNMPADDR_T *)&from_v6, 
                                       (SNMPADDR_T *)&dest_v6,
                                       SNMP_MAX_PACKET_SIZE,
                                       agent_io_routine,
                                       agent_error_routine,
                                       0);
        fflush(stdout);
        }
#endif

#if INSTALL_ENVOY_EPI_MASTER
    if (FD_ISSET(master_socket, &ready)) {
        int hand_ret;
        mpktnum++;
        szfrom = sizeof(mfrom);
        if ((got = recvfrom(master_socket, rcvbuff, sizeof(rcvbuff),
                            0, (struct sockaddr *)&mfrom, &szfrom))
            == -1) {
            perror("Recvfrom failed");
            continue;
            }

        if (trace_level > 2)
            printf("Received sub agent packet...\n");

        iaddr = (IPCADDR_T *)SNMP_memory_alloc(sizeof(IPCADDR_T));
        if (iaddr == 0) {
            continue;
            }

        iaddr->size = szfrom;
        MEMCPY(&iaddr->from, &mfrom, szfrom);
        /* see if we should process sub agent registrations in an async
           fashion or using the older sync style */
        if (snmp_use_async)
            /* Code for processing sub agent registrations in an async style */
            Master_Handler_Async(rcvbuff, (ALENGTH_T)got, (IPCCOMP_T *)ipccomp,
                                 (IPCSEND_AS_T *)ipcsend_asy,
                                 (IPCRCV_T *)ipcrcv,
                                 (IPCFREE_T *)ipcfree, (IPCAYT_T *)ipcayt,
                                 (PTR_T)iaddr, 0);
        else {
            /* Code for processing sub agent registrations in a sync fashion */
            hand_ret = Master_Handler(rcvbuff, (ALENGTH_T)got,
                                  (IPCSEND_T *)ipcsend, (IPCRCV_T *)ipcrcv,
                                  (IPCFREE_T *)ipcfree, (IPCAYT_T *)ipcayt,
                                  (PTR_T)iaddr, &ebuff, &rvblist);
            if (hand_ret == 0) {
                if (trace_level > 0) 
                    printf("Subagent Decode failure\n");
                SNMP_memory_free(iaddr);
                continue;
                }
            if (hand_ret == -1) {
                if (trace_level > 0)
                   printf("Subagent decode error\n");
                SNMP_memory_free(iaddr);
                }

            if (trace_level > 2)
                printf("Subagent sending reply...\n");

            (void) sendto(master_socket, ebuff.start_bp, EBufferUsed(&ebuff),
                          0, (struct sockaddr *)&mfrom, szfrom);

            EBufferClean(&ebuff);
            fflush(stdout);
            }
        }

    if (FD_ISSET(query_socket, &ready)) {
        szfrom = sizeof(mfrom);
        if ((got = recvfrom(query_socket, rcvbuff, sizeof(rcvbuff),
                            0, (struct sockaddr *)&mfrom, &szfrom))
            == -1) {
            perror("Recvfrom failed");
            continue;
            }

        if (trace_level > 2)
            printf("Received sub agent query reply ...\n");

        (void) Master_Query_Reply_Handler(rcvbuff, (ALENGTH_T)got, 1);
        fflush(stdout);
        }
#endif
    }

}