semGive (proxySemId);    return (OK);    }/********************************************************************************* proxyNetDelete - delete a proxy network** This routine deletes the proxy network specified by <proxyAddr>.  It also* removes all the proxy clients that exist on that network.** RETURNS: OK, or ERROR if unsuccessful.**/STATUS proxyNetDelete    (    char *  			proxyAddr	/* proxy net address 	*/    )    {    PROXY_NET *			pNet;		/* proxy network	*/    NODE *			pNode;		/* client node		*/    PROXY_CLNT *		pClient;	/* proxy client		*/    STATUS 			status = ERROR;	/* return value		*/    struct in_addr		proxyAddrIn;    semTake (proxySemId, WAIT_FOREVER);    proxyAddrIn.s_addr = inet_addr (proxyAddr);    if ((pNet = proxyNetFind (&proxyAddrIn)) != NULL)	{					/* clear out the clients */        for (pNode = lstFirst (&pNet->clientList); pNode != NULL;)	    {	    pClient = NODE_TO_CLIENT (pNode);	    proxyClientRemove (pClient);	    pNode = lstNext (pNode);	    KHEAP_FREE((caddr_t)pClient);	    }    	lstDelete (&proxyNetList, &pNet->netNode);    	KHEAP_FREE((caddr_t)pNet);	status = OK;	}    semGive (proxySemId);    return (status);    }/********************************************************************************* proxyNetFind - find a proxy network structure** This routine finds the proxy network structure associated * with <proxyAddr>.  The `proxySemId' semaphore must already * be taken before calling this routine.** RETURNS: A PROXY_NET pointer if found, otherwise NULL.** ERRNO: *  S_proxyArpLib_INVALID_NET** NOMANUAL*/LOCAL PROXY_NET * proxyNetFind    (    struct in_addr *		pProxyAddr	/* proxy address */    )    {    PROXY_NET *			pNet;		/* proxy network */    for (pNet = (PROXY_NET *) lstFirst (&proxyNetList); (pNet != NULL);	 pNet = (PROXY_NET *) lstNext (&pNet->netNode))	if (pNet->proxyAddr.s_addr == pProxyAddr->s_addr)	    return (pNet);    errno = S_proxyArpLib_INVALID_PROXY_NET;    return (NULL);    }/********************************************************************************* proxyIsAMainNet - is the interface a main network ?** This routine determines if <mainAddr> is a main network.  * `proxySemId' must already be taken before this routine is called.** RETURNS: TRUE if a main network, FALSE otherwise.** NOMANUAL*/LOCAL BOOL proxyIsAMainNet    (    struct in_addr *		pMainAddr	/* main address */    )    {    PROXY_NET *			pNet;		/* proxy network */    for (pNet = (PROXY_NET *) lstFirst (&proxyNetList); (pNet != NULL);	 pNet = (PROXY_NET *) lstNext (&pNet->netNode))	if (pNet->mainAddr.s_addr == pMainAddr->s_addr)	   return (TRUE);    return (FALSE);    }/********************************************************************************* proxyNetShow - show proxy ARP networks** This routine displays the proxy networks and their associated clients.** EXAMPLE* .CS*     -> proxyNetShow*     main interface 147.11.1.182 proxy interface 147.11.1.183*        client 147.11.1.184* .CE** RETURNS: N/A** INTERNAL* calls printf while semaphore taken.*/void proxyNetShow (void)    {    PROXY_NET *		pNet;			/* proxy net		*/    PROXY_CLNT *	pClient;		/* proxy client		*/    NODE *		pNode;			/* pointer to node	*/						/* address in ascii	*/    char 		asciiAddr [ INET_ADDR_LEN ];    semTake (proxySemId, WAIT_FOREVER);    for (pNet = (PROXY_NET *) lstFirst (&proxyNetList);	 pNet != NULL; pNet = (PROXY_NET *) lstNext (&pNet->netNode))	{	inet_ntoa_b (pNet->mainAddr, asciiAddr);	printf ("main interface %s ", asciiAddr);	inet_ntoa_b (pNet->proxyAddr, asciiAddr);	printf ("proxy interface %s\n", asciiAddr);	for (pNode = lstFirst (&pNet->clientList); pNode != NULL;	     pNode = lstNext (pNode))	    {	    pClient = NODE_TO_CLIENT (pNode);	    inet_ntoa_b (pClient->ipaddr, asciiAddr);	    printf ("    client:%s\n", asciiAddr);	    }	}    semGive (proxySemId);    }/********************************************************************************* proxyClientAdd - add a proxy client** This routine adds the client, whose ip address is <pArpcom>.ac_ipaddr, onto * the proxy network identified by <pProxyNetAddr>.** RETURNS: OK, or ERROR if unsuccessful.** ERRNO:*  S_proxyArpLib_INVALID_ADDRESS** NOMANUAL*/LOCAL STATUS proxyClientAdd    (    struct arpcom * 	pArpcom, 	/* interface on proxy network */    struct in_addr * 	pClientAddr, 	/* client internet address */    u_char * 		pClientHwAddr 	/* client hardware address */    )    {    PROXY_NET * 	pNet; 		/* proxy net		*/    PROXY_CLNT * 	pClient; 	/* proxy client 	*/    struct sockaddr_in 	sin;		/* sin structure 	*/    struct ifaddr * 	pIfa;		/* interface address	*/    struct in_addr * 	pProxyNetAddr;	/* proxy net address	*/    int flags; 				/* ARP flags */    /* validate addresses */    pProxyNetAddr = &pArpcom->ac_ipaddr;    if ((in_netof (*pProxyNetAddr) != in_netof (*pClientAddr)) ||        in_broadcast (*pClientAddr, (struct ifnet *)pArpcom))	{	errno = S_proxyArpLib_INVALID_ADDRESS;	return (ERROR);	}    if ((pClient = (PROXY_CLNT *) KHEAP_ALLOC(sizeof(PROXY_CLNT))) == NULL)	return (ERROR);    bzero ((char *)pClient, sizeof(PROXY_CLNT));    semTake (proxySemId, WAIT_FOREVER);    if (!proxyIsAproxyNet (pClientAddr) &&        ((pNet = (PROXY_NET *) proxyNetFind (pProxyNetAddr)) != NULL))	{						/* find main interface */    	SIN_FILL (&sin, AF_INET, pNet->mainAddr.s_addr, 0);    	if ((pIfa = ifa_ifwithaddr ((struct sockaddr *) &sin)) != NULL)	    {	    (void) proxyClientDelete (pClientAddr);	    /*	     * Create a cloneable route (which will ultimately produce a	     * standard ARP entry for the client) and add the client to             * the active list.	     */	    if (proxyRouteCmd (pClientAddr->s_addr, pProxyNetAddr->s_addr, 			  SIOCADDRT) == OK)		{		pClient->pNet	= pNet;		pClient->ipaddr	= *pClientAddr;	        bcopy (pClientHwAddr, pClient->hwaddr,                       sizeof (struct ether_addr));              		hashTblPut (clientTbl, &pClient->hashNode);		lstAdd (&pNet->clientList, &pClient->clientNode);                /*                 * Send a gratuitous ARP request to update any entries                 * on the main network.                 */	        proxyArpSend (pIfa->ifa_ifp, ARPOP_REQUEST, ETHERTYPE_IP,			      (u_char *) pClientAddr, (u_char *) NULL,			      (u_char *) pClientAddr);                /*                 * Add a proxy ARP entry allowing the standard ARP processing                 * to reply to requests for this client from hosts on other                 * networks. Ignore failures caused if an entry already exists.                 */                flags = ATF_PUBL | ATF_PROXY | ATF_PERM;                arpCmd (SIOCSARP, pClientAddr, pClientHwAddr, &flags);	        if (proxyArpVerbose)		    logMsg ("added client 0x%x proxyNet 0x%x\n",			    ntohl (pClientAddr->s_addr), 			    ntohl (pProxyNetAddr->s_addr), 0, 0, 0, 0);		semGive (proxySemId);		return (OK);		}	    }	else	    {	    if (proxyArpVerbose)		logMsg ("proxyClientAdd: no main if 0x%x\n",			ntohl (pNet->mainAddr.s_addr), 0, 0, 0, 0, 0);	    }	}    semGive (proxySemId);    KHEAP_FREE((caddr_t)pClient);    return (ERROR);    }/********************************************************************************* proxyClientDelete - delete a proxy client** This routines deletes the proxy client specified by <pClientAddr>.** RETURNS: OK, or ERROR if unsuccessful.** NOMANUAL*/LOCAL STATUS proxyClientDelete    (    struct in_addr *		pClientAddr		/* client address   */    )    {    PROXY_CLNT *		pClient;		/* proxy client     */    STATUS 			status = ERROR;		/* return status    */    semTake (proxySemId, WAIT_FOREVER);    if ((pClient = proxyClientFind (pClientAddr)) != NULL)	{	proxyClientRemove (pClient);	lstDelete (&pClient->pNet->clientList, &pClient->clientNode);    	if (proxyArpVerbose)	    logMsg ("deleted client 0x%x\n", ntohl (pClientAddr->s_addr), 0, 		    0, 0, 0, 0);	status = OK;	}    semGive (proxySemId);    if (pClient != NULL)	KHEAP_FREE((caddr_t)pClient);    return (status);    }/********************************************************************************* proxyClientFind - find a proxy client** This routine finds the proxy client structure associated with <pClientAddr>.* Caller must have taken `proxySemId' before this routine is called.** RETURNS: Pointer to PROXY_CLNT if found, NULL otherwise.** ERRNO:*  S_proxyArpLib_INVALID_CLIENT** NOMANUAL*/LOCAL PROXY_CLNT * proxyClientFind    (    struct in_addr *		pClientAddr		/* client address    */    )    {    PROXY_CLNT			client;			/* client to find    */    PROXY_CLNT *		pClient;		/* pointer to client */    client.ipaddr.s_addr = pClientAddr->s_addr;    if ((pClient = (PROXY_CLNT *)	   hashTblFind (clientTbl, &client.hashNode, 0)) == NULL)    	errno = S_proxyArpLib_INVALID_CLIENT;    return (pClient);    }/********************************************************************************* proxyPortFwdOn - enable broadcast forwarding for a particular port** This routine enables broadcasts destined for the port, <port>, to be * forwarded to and from the proxy network.  To enable all ports, specify * zero for <port>.** RETURNS: OK, or ERROR if unsuccessful.*/STATUS proxyPortFwdOn    (    int			port			/* port number 		*/    )    {    PORT_NODE *		pPort;			/* port node 		*/    if ((pPort = (PORT_NODE *) KHEAP_ALLOC(sizeof(PORT_NODE))) == NULL)	return (ERROR);    bzero ((char *)pPort, sizeof(PORT_NODE));    semTake (portTblSemId, WAIT_FOREVER);    if (portTblFind (port) != NULL)	/* already enabled so ok */	{	semGive (portTblSemId);	KHEAP_FREE((caddr_t)pPort);	return (OK);	}    pPort->port = (int) port;    (void) hashTblPut (portTbl, &pPort->hashNode);    semGive (portTblSemId);    return (OK);    }/********************************************************************************* proxyPortFwdOff - disable broadcast forwarding for a particular port** This routine disables broadcast forwarding on port number <port>.  To* disable the (previously enabled) forwarding of all ports via* proxyPortFwdOn(), specify zero for <port>.** RETURNS: OK, or ERROR if unsuccessful.*/STATUS proxyPortFwdOff    (    int			port			/* port number		*/    )    {    PORT_NODE *		pPort;			/* port node 		*/    semTake (portTblSemId, WAIT_FOREVER);    if ((pPort = portTblFind (port)) == NULL)	{				/* not in port table so ok */	semGive (portTblSemId);	return (OK);	}    (void) hashTblRemove (portTbl, &pPort->hashNode);    semGive (portTblSemId);    KHEAP_FREE((caddr_t)pPort);    return (OK);    }/********************************************************************************* portTblFind - find the port node** This routine finds the port node associated with port number <port>.** RETURNS: A pointer to the port node, or NULL if not found.** NOMANUAL*/LOCAL PORT_NODE * portTblFind    (    int		port			/* port number		*/    )    {    PORT_NODE		portNode;		/* port node		*/    portNode.port = (int) port;    return ((PORT_NODE *) hashTblFind (portTbl, &portNode.hashNode, 0));    }/********************************************************************************* proxyPortShow - show ports enabled for broadcast forwarding** This routine displays the destination ports for which the proxy ARP server* will forward broadcast messages between the physically separate networks.** EXAMPLE* .CS*     -> proxyPortShow*     enabled ports:*        port 67* .CE** RETURNS: N/A** INTERNAL* calls printf() while semaphore taken.*/void proxyPortShow (void)    {    semTake (portTblSemId, WAIT_FOREVER);    printf ("enabled ports:\n");    if (portTblFind (0) != NULL)	printf ("    all ports enabled\n");    else	hashTblEach (portTbl, proxyPortPrint, 0);    semGive (portTblSemId);    }/********************************************************************************* proxyPortPrint - print ports enabled*