/* m2UdpLib.c - MIB-II UDP-group API for SNMP agents *//* Copyright 1984 - 2001 Wind River Systems, Inc. */#include "copyright_wrs.h"/*modification history--------------------01e,15oct01,rae  merge from truestack ver 01i, base 01d (SPR #68597, VS)01d,08mar97,vin  added changes to accomodate changes in pcb structure.01c,25jan95,jdi  doc cleanup.01b,11nov94,rhp  edited man pages01a,08dec93,jag  written*//*DESCRIPTIONThis library provides MIB-II services for the UDP group.  It providesroutines to initialize the group, access the group scalar variables, andread the table of UDP listeners.  For a broader description of MIB-IIservices, see the manual entry for m2Lib.To use this feature, include the following component:INCLUDE_MIB2_UDPUSING THIS LIBRARYThis library can be initialized and deleted by callingm2UdpInit() and m2UdpDelete() respectively, if only the UDP group's services are needed.  If full MIB-II support is used, this group and all othergroups can be initialized and deleted by calling m2Init() and m2Delete().The group scalar variables are accessed by calling m2UdpGroupInfoGet()as follows:.CS    M2_UDP   udpVars;    if (m2UdpGroupInfoGet (&udpVars) == OK)	/@ values in udpVars are valid @/.CEThe UDP table of listeners can be accessed in lexicographical order.The first entry in the table can be accessed by setting the tableindex to zero in a call to m2UdpTblEntryGet().  Every other entrythereafter can be accessed by incrementing the index returned from theprevious invocation to the next possible lexicographical index, andrepeatedly calling m2UdpTblEntryGet() with the M2_NEXT_VALUE constantas the search parameter. For example:.CSM2_UDPTBL  udpEntry;    /@ Specify zero index to get the first entry in the table @/    udpEntry.udpLocalAddress = 0;    /@ local IP Address in host byte order  @/    udpEntry.udpLocalPort    = 0;    /@ local port Number                  @/    /@ get the first entry in the table @/    if ((m2UdpTblEntryGet (M2_NEXT_VALUE, &udpEntry) == OK)	/@ values in udpEntry in the first entry are valid  @/    /@ process first entry in the table @/    /@      * For the next call, increment the index returned in the previous call.     * The increment is to the next possible lexicographic entry; for     * example, if the returned index was 0.0.0.0.3000 the index passed in the     * next invocation should be 0.0.0.0.3001.  If an entry in the table     * matches the specified index, then that entry is returned.       * Otherwise the closest entry following it, in lexicographic order,     * is returned.     @/    /@ get the second entry in the table @/    if ((m2UdpTblEntryGet (M2_NEXT_VALUE, &udpEntry) == OK)	/@ values in udpEntry in the second entry are valid  @/.CEINCLUDE FILES: m2Lib.h SEE ALSO:m2Lib, m2IfLib, m2IpLib, m2IcmpLib, m2TcpLib, m2SysLib*//* includes */#include "vxWorks.h"#include "vwModNum.h"#include "m2Lib.h"#include "socket.h"#include <net/route.h>#include <netinet/in.h>#include <netinet/ip.h>#include <netinet/ip_var.h>#include <netinet/udp.h>#include <netinet/udp_var.h>#include <netinet/in_pcb.h>#include "errnoLib.h"#ifdef VIRTUAL_STACK#include "netinet/vsLib.h"#endif    /* VIRTUAL_STACK *//* external declarations */#ifndef VIRTUAL_STACKextern struct udpstat     udpstat;	/* UDP statistics variable */extern struct inpcbhead   udb;		/* UDP link list of listen requests */#endif    /* VIRTUAL_STACK *//********************************************************************************* m2UdpInit - initialize MIB-II UDP-group access** This routine allocates the resources needed to allow access to the UDP * MIB-II variables.  This routine must be called before any UDP variables* can be accessed.** RETURNS: OK, always.** SEE ALSO:* m2UdpGroupInfoGet(), m2UdpTblEntryGet(), m2UdpDelete()*/STATUS m2UdpInit (void)    {    return (OK);    }/********************************************************************************* m2UdpGroupInfoGet - get MIB-II UDP-group scalar variables** This routine fills in the UDP structure at <pUdpInfo> with the MIB-II* UDP scalar variables.** RETURNS: OK, or ERROR if <pUdpInfo> is not a valid pointer.** ERRNO:* S_m2Lib_INVALID_PARAMETER** SEE ALSO:* m2UdpInit(), m2UdpTblEntryGet(), m2UdpDelete()*/STATUS m2UdpGroupInfoGet    (    M2_UDP * pUdpInfo		/* pointer to the UDP group structure */    )    {     /* Validate Pointer to UDP structure */     if (pUdpInfo == NULL)	{	errnoSet (S_m2Lib_INVALID_PARAMETER);        return (ERROR);	}     pUdpInfo->udpNoPorts      = udpstat.udps_noport + 				udpstat.udps_noportbcast;     pUdpInfo->udpOutDatagrams = udpstat.udps_opackets;    /*  The number UDP packets deliever to UDP users. */    pUdpInfo->udpInDatagrams  = udpstat.udps_ipackets    -                                (udpstat.udps_hdrops     +                                udpstat.udps_badsum      +                                udpstat.udps_badlen      +                                udpstat.udps_noportbcast +                                udpstat.udps_fullsock);     /*  The number UDP packets not deliever due to errors */    pUdpInfo->udpInErrors     = udpstat.udps_hdrops +                                udpstat.udps_badsum +                                udpstat.udps_badlen;     return (OK);    }/********************************************************************************* m2UdpTblEntryGet - get a UDP MIB-II entry from the UDP list of listeners** This routine traverses the UDP table of listeners and does an* M2_EXACT_VALUE or a M2_NEXT_VALUE search based on the* <search> parameter.  The calling routine is responsible for* supplying a valid MIB-II entry index in the input structure* <pUdpEntry>.  The index is made up of the IP address and the local* port number.  The first entry in the table is retrieved by doing a* M2_NEXT_VALUE search with the index fields set to zero.** RETURNS:* OK, or ERROR if the input parameter is not specified or a match is not * found.** ERRNO:*  S_m2Lib_INVALID_PARAMETER*  S_m2Lib_ENTRY_NOT_FOUND** SEE ALSO:* m2Lib, m2UdpInit(), m2UdpGroupInfoGet(), m2UdpDelete()*/STATUS m2UdpTblEntryGet    (    int              search,        /* M2_EXACT_VALUE or M2_NEXT_VALUE */    M2_UDPTBL      * pUdpEntry      /* ptr to the requested entry with index */    )    {    M2_UDPTBL        savedEntry;    /* Possible M2_NEXT_VALUE Entry in UDP */				    /* table */    M2_UDPTBL        currEntry;    int              netLock;       /* Use to secure the Network Code Access */    struct inpcb   * pPcb;          /* Pointer to UDP Listener structure. */      /* Validate Pointer to UDP Table Entry structure */     if (pUdpEntry == NULL)	{	errnoSet (S_m2Lib_INVALID_PARAMETER);        return (ERROR);	}     /*      * Initialize Entry for M2_NEXT_VALUE entry search.  Not used in     * M2_EXACT_VALUE search.     */     savedEntry.udpLocalAddress = -1;    /* Largest possible value. */    savedEntry.udpLocalPort    = -1;    /* Largest possible value. */     netLock = splnet ();             /* Get exclusive access to Network Code */     for (pPcb = udb.lh_first; pPcb != NULL; pPcb = pPcb->inp_list.le_next )        {	currEntry.udpLocalAddress = ntohl (pPcb->inp_laddr.s_addr);	currEntry.udpLocalPort    = ntohs (pPcb->inp_lport);        if (search == M2_EXACT_VALUE)            {	    /* Check that the specified index matches the current entry */            if ((pUdpEntry->udpLocalAddress == currEntry.udpLocalAddress) &&                (pUdpEntry->udpLocalPort == currEntry.udpLocalPort))                {                splx (netLock);   /* Give up exclusive access to Network Code */                return (OK);      /* The answer is in the structure pUdpEntry */                }            }        else            {            /*             * A NEXT search is satisfied by an entry that is lexicographicaly             * equal to or greater than the input UDP connection entry. Because	     * the UDP connection list is not in order, the list must be 	     * traverse completely before a selection is made.  The rules for a 	     * lexicographical comparison are built in the next statement.             */  	    if (((currEntry.udpLocalAddress > pUdpEntry->udpLocalAddress) ||		  ((currEntry.udpLocalAddress == pUdpEntry->udpLocalAddress) &&		   (currEntry.udpLocalPort >= pUdpEntry->udpLocalPort))) &&                 ((currEntry.udpLocalAddress < savedEntry.udpLocalAddress) ||                   ((currEntry.udpLocalAddress == savedEntry.udpLocalAddress) &&                    (currEntry.udpLocalPort < savedEntry.udpLocalPort))))                {		/* 		 * Save the entry which qualifies as the NEXT greater 		 * lexicographic entry.  Because the table is not order the		 * search must proceed to the end of the table.		 */                savedEntry.udpLocalAddress =  currEntry.udpLocalAddress;                savedEntry.udpLocalPort    =  currEntry.udpLocalPort;                }            }        }     splx (netLock);             /* Give up exclusive access to Network Code */    /* If a match was found fill, the requested structure */    if (savedEntry.udpLocalPort != -1)        {        pUdpEntry->udpLocalAddress = savedEntry.udpLocalAddress;        pUdpEntry->udpLocalPort    = savedEntry.udpLocalPort;        return (OK);        }     errnoSet (S_m2Lib_ENTRY_NOT_FOUND);    return (ERROR);    }/********************************************************************************* m2UdpDelete - delete all resources used to access the UDP group** This routine frees all the resources allocated at the time the group was* initialized.  The UDP group should not be accessed after this routine has been* called.** RETURNS: OK, always.** SEE ALSO:* m2UdpInit(), m2UdpGroupInfoGet(), m2UdpTblEntryGet()*/STATUS m2UdpDelete (void)    {    return (OK);    }