/*          * Convert the offset to an array index based on the number of         * bytes in the bitmap.         */        byteIndex = WVNET_MASKSIZE - 1 - byteOffset;        /*         * Set event map so WV_NET_EVENT_TEST macro will accept the         * specified event.         */        mask = 1 << (offset % 8);        wvNetEventMap [index].bitmap [byteIndex] |= mask;        }    return (result);    }/********************************************************************************* wvNetEventDisable - deactivate specific network events** This routine prevents reporting of a single event within the priority equal * to <level>. The activation is overridden if the setting for the entire * priority level changes. The available priority values are:**     WV_NET_EMERGENCY (1)*     WV_NET_ALERT (2)*     WV_NET_CRITICAL (3)*     WV_NET_ERROR (4)*     WV_NET_WARNING (5)*     WV_NET_NOTICE (6)*     WV_NET_INFO (7)*     WV_NET_VERBOSE (8)* * Offset values for individual events are listed in the documentation.** RETURNS: OK, or ERROR for unknown event.** ERRNO: N/A*/STATUS wvNetEventDisable    (    int priority, 	/* priority level of event */    int offset 		/* identifier within priority level */    )    {    STATUS result = OK;    int index;    UCHAR mask;    int byteOffset;    int byteIndex;    switch (priority)        {        case WV_NET_EMERGENCY:            if (offset > maxEmergencyOffset)                result = ERROR;            break;        case WV_NET_ALERT:            if (offset > maxAlertOffset)                result = ERROR;            break;        case WV_NET_CRITICAL:            if (offset > maxCriticalOffset)                result = ERROR;            break;        case WV_NET_ERROR:            if (offset > maxErrorOffset)                result = ERROR;            break;        case WV_NET_WARNING:            if (offset > maxWarningOffset)                result = ERROR;            break;        case WV_NET_NOTICE:            if (offset > maxNoticeOffset)                result = ERROR;            break;        case WV_NET_INFO:            if (offset > maxInfoOffset)                result = ERROR;            break;        case WV_NET_VERBOSE:            if (offset > maxVerboseOffset)                result = ERROR;            break;        default: 	/* Unknown priority level */            result = ERROR;            break;        }    /*      * Because of array indexing, the index into the event map is one     * less than the value assigned to the priority level.     */    index = priority - 1;    if (result == OK)        {                byteOffset = offset / 8;        /*          * Convert the offset to an array index based on the number of         * bytes in the bitmap.         */        byteIndex = WVNET_MASKSIZE - 1 - byteOffset;        /*         * Set event map so WV_NET_EVENT_TEST macro will reject the         * specified event.         */        mask = ~ (1 << (offset % 8));        wvNetEventMap [index].bitmap [byteIndex] &= mask;        }    return (result);    }/********************************************************************************* wvNetAddressFilterSet - specify an address filter for events** This routine activates an additional test that disables certain events* that do not match the specified IP address. The <pAddress> parameter* provides the test value in dotted-decimal format. The <type> parameter* indicates whether that address is compared against the source or* destination values, and the <direction> value identifies whether the * <type> is interpreted from the perspective of incoming or outgoing traffic.* The <pMask> parameter provides a network mask to support testing for a* group of events.** RETURNS: OK if filter set, or ERROR otherwise.** ERRNO: N/A**/STATUS wvNetAddressFilterSet    (    char * 	pAddress, 	/* target address for event comparisons */    char * 	pMask, 		/* mask value applied to data fields */    int 	type, 		/* 0 for source, 1 for destination */     int 	direction 	/* 0 for input, 1 for output */    )    {    int targetAddr;    int targetMask;    STATUS result = OK;    targetAddr = inet_addr (pAddress);    targetMask = inet_addr (pMask);    if (targetAddr == ERROR)   /* targetMask of 255.255.255.255 is OK. */        return (ERROR);    if (direction == 0 && type == 0)        {        wvNetInputSrcAddr = targetAddr;        wvNetInputSrcMask = targetMask;        wvNetInputSrcAddrFlag = TRUE;        }    else if (direction == 0 && type == 1)        {        wvNetInputDstAddr = targetAddr;        wvNetInputDstMask = targetMask;        wvNetInputDstAddrFlag = TRUE;        }    else if (direction == 1 && type == 0)        {        wvNetOutputSrcAddr = targetAddr;        wvNetOutputSrcMask = targetMask;        wvNetOutputSrcAddrFlag = TRUE;        }    else if (direction == 1 && type == 1)        {        wvNetOutputDstAddr = targetAddr;        wvNetOutputDstMask = targetMask;        wvNetOutputDstAddrFlag = TRUE;        }     else        result = ERROR;    return (result);    }/********************************************************************************* wvNetAddressFilterClear - remove the address filter for events** This routine removes any active address filter test indicated by* the <type> and <direction> parameters used to enable it. Affected* events will be reported unconditionally.** RETURNS: N/A** ERRNO: N/A*/void wvNetAddressFilterClear    (    int 	type, 		/* 0 for source, 1 for destination */     int 	direction 	/* 0 for input, 1 for output */    )    {    if (direction == 0 && type == 0)        wvNetInputSrcAddrFlag = FALSE;    else if (direction == 0 && type == 1)        wvNetInputDstAddrFlag = FALSE;    else if (direction == 1 && type == 0)        wvNetOutputSrcAddrFlag = FALSE;    else if (direction == 1 && type == 1)        wvNetOutputDstAddrFlag = FALSE;    return;    }/********************************************************************************* wvNetPortFilterSet - specify an address filter for events** This routine activates an additional filter, which disables certain events * that do not match the specified port value. The <port> parameter provides * the test value and the <type> parameter indicates whether that value is * compared against the source or destination fields. The <direction> setting * identifies whether the <type> is interpreted from the perspective of * incoming or outgoing traffic.** RETURNS: OK if filter set, or ERROR otherwise.** ERRNO: N/A*/STATUS wvNetPortFilterSet    (    int 	port, 		/* target port for event comparisons */    int 	type, 		/* 0 for source, 1 for destination */     int 	direction 	/* 0 for input, 1 for output */    )    {    STATUS result = OK;    if (direction == 0 && type == 0)        {        wvNetInputSrcPort = port;        wvNetInputSrcPortFlag = TRUE;        }    else if (direction == 0 && type == 1)        {        wvNetInputDstPort = port;        wvNetInputDstPortFlag = TRUE;        }    else if (direction == 1 && type == 0)        {        wvNetOutputSrcPort = port;        wvNetOutputSrcPortFlag = TRUE;        }    else if (direction == 1 && type == 1)        {        wvNetOutputDstPort = port;        wvNetOutputDstPortFlag = TRUE;        }     else        result = ERROR;    return (result);    }/********************************************************************************* wvNetPortFilterClear - remove the port number filter for events** This routine removes any active port filter test indicated by* the <type> and <direction> parameters used to enable it. Affected* events will be reported unconditionally.** RETURNS: N/A** ERRNO: N/A*/void wvNetPortFilterClear    (    int 	type, 		/* 0 for source, 1 for destination */     int 	direction 	/* 0 for input, 1 for output */    )    {    if (direction == 0 && type == 0)        wvNetInputSrcPortFlag = FALSE;    else if (direction == 0 && type == 1)        wvNetInputDstPortFlag = FALSE;    else if (direction == 1 && type == 0)        wvNetOutputSrcPortFlag = FALSE;    else if (direction == 1 && type == 1)        wvNetOutputDstPortFlag = FALSE;    return;    }/********************************************************************************* wvNetAddressFilterTest - compare the given addresses with filter values** This routine is invoked by the WV_NET_ADDR_FILTER_TEST macro within* an event block. It returns TRUE if no filters are in effect or if the* target values for each filter match the given addresses.** RETURNS: TRUE if filter passes, or FALSE otherwise.** ERRNO: N/A** NOMANUAL*/BOOL wvNetAddressFilterTest    (    int filterType, 	/* 0 for input filter or 1 for output filter */    int targetType,	/* 1 for dst only, 2 for src only, or 3 for both */    ULONG srcAddr, 	/* current source address for event block */    ULONG dstAddr	/* current destination address for event block */    )    {    BOOL result = TRUE;    if (filterType == 0) 	/* Compare given addresses to input values. */        {        if (wvNetInputSrcAddrFlag && targetType != 1)            result = ((srcAddr & wvNetInputSrcMask) == wvNetInputSrcAddr);        /* Only test the destination address if any source test passed. */        if (result && wvNetInputDstAddrFlag && targetType != 2)            result = ((dstAddr & wvNetInputDstMask) == wvNetInputDstAddr);        }    if (filterType == 1)       /* Compare given addresses to output values. */        {        if (wvNetOutputSrcAddrFlag && targetType != 1)            result = ((srcAddr & wvNetOutputSrcMask) == wvNetOutputSrcAddr);        /* Only test the destination address if any source test passed. */        if (result && wvNetOutputDstAddrFlag && targetType != 2)            result = ((dstAddr & wvNetOutputDstMask) == wvNetOutputDstAddr);        }    /* if (!result)    /@ XXX - for testing, include if desired. @/        logMsg ("Address filter ignoring event.\n", 0, 0, 0, 0, 0, 0); */    return (result);    }/********************************************************************************* wvNetPortFilterTest - compare the given port numbers with filter values** This routine is invoked by the WV_NET_PORT_FILTER_TEST macro within* an event block. It returns TRUE if no filters are in effect or if the* target values for each filter match the given port numbers.** INTERNAL* Unlike the address filter tests, both the source and destination ports* are always available for the filtered events, so the <targetType> * parameter is not needed.** RETURNS: TRUE if filter passes, or FALSE otherwise.** ERRNO: N/A** NOMANUAL*/BOOL wvNetPortFilterTest    (    int filterType, 	/* 0 for input filter or 1 for output filter */    USHORT srcPort, 	/* current source port for event block */    USHORT dstPort	/* current destination port for event block */    )    {    BOOL result = TRUE;    if (filterType == 0) 	/* Compare given ports to input values. */        {        if (wvNetInputSrcPortFlag)            result = (srcPort == wvNetInputSrcPort);        /* Only test the destination port if any source test passed. */        if (result && wvNetInputDstPortFlag)            result = (dstPort == wvNetInputDstPort);        }    if (filterType == 1)       /* Compare given addresses to output values. */        {        if (wvNetOutputSrcPortFlag)            result = (srcPort == wvNetOutputSrcPort);        /* Only test the destination address if any source test passed. */        if (result && wvNetOutputDstPortFlag)            result = (dstPort == wvNetOutputDstPort);        }    return (result);    }#if 0/********************************************************************************* wvNetEventTest - check if event is enabled** This routine duplicates the WV_NET_EVENT_TEST macro. It checks the bitmap* for an event to determine if it should be reported to the host-side of the * WindView tool. It is never called, and is present only to illustrate the * macro behavior.** RETURNS: TRUE if event is selected, or FALSE otherwise.** ERRNO: N/A** NOMANUAL*/BOOL wvNetEventTest    (    int priority, 	/* priority level of event */    int offset 		/* identifier within priority level */    )    {    BOOL result;    int index;    UCHAR mask;    int byteOffset;    int byteIndex;    /*      * Because of array indexing, the index into the event map is one     * less than the value assigned to the priority level.     */    index = priority - 1;    byteOffset = offset / 8;    /*      * Convert the offset to an array index based on the number of     * bytes in the bitmap.     */    byteIndex = WVNET_MASKSIZE - 1 - byteOffset;    /* Check the flag in the bitmap for the specified event. */    mask = 1 << (offset % 8);    result = (wvNetEventMap [index].bitmap [byteIndex] & mask);    return (result);    }#endif