pppvsend.c

这是全套的PPP协议的源码

/* globals */

END_OBJ * pppVsEndLoad (char *initString, void *tmp);

/* locals */

/* forward declarations */

/* END driver NET_FUNCS forward declarations */

LOCAL STATUS pppUnload (END_OBJ *);
LOCAL STATUS pppStart (PPP_DRV_CTRL *pDrvCtrl);
LOCAL STATUS pppStop (PPP_DRV_CTRL *pDrvCtrl);
LOCAL STATUS pppSend (void * pCookie, M_BLK_ID pMblk);
LOCAL STATUS pppEndPollReceive(void * pCookie, M_BLK_ID pMblk);
LOCAL STATUS pppBind (PPP_DRV_CTRL * pDrvCtrl,void * pNetSvcInfo, 
                      void * drvInfo, long type);
LOCAL STATUS pppPacketDataGet (M_BLK_ID pMblk,LL_HDR_INFO *llHdrInfo);
LOCAL int pppIoctl (END_OBJ * pEnd, int cmd, caddr_t data);
LOCAL M_BLK_ID pppAddressForm (M_BLK_ID pMblk, M_BLK_ID pSrcAddr,
                               M_BLK_ID pDstAddr, BOOL bcastFlag);
LOCAL STATUS pppMCastAddrAdd (PPP_DRV_CTRL* pDrvCtrl, char* pAddress);
LOCAL STATUS pppMCastAddrDel (PPP_DRV_CTRL* pDrvCtrl, char* pAddress);
LOCAL STATUS pppMCastAddrGet (PPP_DRV_CTRL* pDrvCtrl, MULTI_TABLE* pTable);

/* network stack interface functions forward declarations */

LOCAL STATUS createIpInterface (PFW_PLUGIN_OBJ_STATE *state);
LOCAL STATUS deleteIpInterface (PFW_PLUGIN_OBJ_STATE *state);
LOCAL UINT32 pppLinkIdGet ( PFW_PLUGIN_OBJ_STATE * state);
LOCAL STATUS pppEndPollRxQueueSizeHandle (PFW_OBJ * pfw,
					  PFW_PARAMETER_OPERATION_TYPE type,
					  void * pProfileData,
					  char * value);


#ifdef INET
LOCAL STATUS ipInterfaceUp (PFW_PLUGIN_OBJ_STATE *state, char *srcAddr,
                            char *dstAddr);
LOCAL STATUS ipInterfaceDown (PFW_PLUGIN_OBJ_STATE *state, char *source,
                              char *destination);
LOCAL void bringUpIpInterface(INTERFACE_PARMS * pInterfaceParms, int * vsid);
LOCAL void bringDownIpInterface (INTERFACE_PARMS * pInterfaceParms,
                                 int * vsid);
LOCAL void pppEndRouteAdd (M_ROUTE_PARMS * pMRouteParms, int *vsid);
LOCAL void pppEndRouteDelete (M_ROUTE_PARMS * pMRouteParms, int * vsid);
LOCAL void pppEndSetIfMask(char *, unsigned long, int * vsid);
LOCAL STATUS ipRouteAdd (PFW_PLUGIN_OBJ_STATE *, char *, char *,
                         unsigned long, int , int);
LOCAL STATUS ipRouteDelete (PFW_PLUGIN_OBJ_STATE *, char *,
                            unsigned long, int , int);
LOCAL STATUS ipSetIfMask (PFW_PLUGIN_OBJ_STATE *, unsigned long);

LOCAL void ipDnsAddressGet (PFW_PLUGIN_OBJ_STATE *, char * primaryDnsAddress,
                            char * secondaryDnsAddress);
LOCAL void ipDnsAddressSet (PFW_PLUGIN_OBJ_STATE *, char * primaryDnsAddress,
                            char * secondaryDnsAddress);
#endif /* INET */


#ifdef INET6
/*
 * TODO: RFC 2472: IP Version 6 over PPP does not specify a mechanism
 *       to exchange information with the peer regarding global addresses
 *       or DNS server addresses.
 */
LOCAL STATUS ipv6InterfaceUp (PFW_PLUGIN_OBJ_STATE *state, char *srcAddr,
                              char *dstAddr);
LOCAL STATUS ipv6InterfaceDown (PFW_PLUGIN_OBJ_STATE *state, char *source,
                                char *destination);
LOCAL void bringUpIpv6Interface(IPV6_INTERFACE_PARMS * pInterfaceParms,
                                int * vsid);
LOCAL void bringDownIpv6Interface(IPV6_INTERFACE_PARMS * pInterfaceParms,
                                  int * vsid);
#endif /* INET6 */


/* RFC2233 handlers forward declarations */

LOCAL STATUS ifCounterUpdateWrap (PFW_PLUGIN_OBJ_STATE * state,UINT ctrId,
                                  ULONG incrAmount);
LOCAL STATUS ifVariableUpdateWrap (PFW_PLUGIN_OBJ_STATE * state,UINT varId,
                                   caddr_t pData);
LOCAL STATUS ifStackStatusSet (PFW_PLUGIN_OBJ_STATE * state,int rowStatus);

/* plug-in object functions  forward declarations */

LOCAL STATUS pppVsEndSend (PFW_PLUGIN_OBJ_STATE *, M_BLK_ID *);
LOCAL STATUS pppVsEndReceive (PFW_PLUGIN_OBJ_STATE *, M_BLK_ID *);
LOCAL STATUS pppVsEndStackAdd (PFW_PLUGIN_OBJ_STATE *,
                               PFW_PLUGIN_OBJ_CALLBACKS *);
LOCAL STATUS pppVsEndStackDelete (PFW_PLUGIN_OBJ_STATE *);
LOCAL STATUS pppVsEndStackDataConstruct (PFW_OBJ *, void * stackData,
                                       void * profileData);
LOCAL STATUS pppVsEndInterfaceBind (PFW_PLUGIN_OBJ * pluginObj);
LOCAL STATUS pppVsEndProfileDataConstruct (PFW_OBJ * pfw,void * pProfileData);


/* framework support functions forward declarations  */

LOCAL STATUS pppVsEndSendPathAcceptableProtocolsGet
    (PFW_PLUGIN_OBJ_STATE *state,ACCEPTABLE_PROTOCOLS_ARRAY **sendProtocols);
LOCAL STATUS pppVsEndRxPathAcceptableProtocolsGet
    (PFW_PLUGIN_OBJ_STATE *state,ACCEPTABLE_PROTOCOLS_ARRAY **recvProtocols);
LOCAL void pppEndRxProtoArrayDo (ACCEPTABLE_PROTOCOLS_ARRAY * pArray,
                                 USHORT protocol,END_RX_ARRAY_OPER operation);

LOCAL STATUS txBlockedEventHandler (PFW_PLUGIN_OBJ_STATE *, void *eventData);
LOCAL STATUS txUnblockedEventHandler (PFW_PLUGIN_OBJ_STATE *,void *eventData);


/* virtual stack support functions forward declarations  */

#ifdef VIRTUAL_STACK
LOCAL STATUS pppEndStackDataGetByStack (PFW_STACK_OBJ * pStackObj,
				        UINT32 * pStack);
LOCAL STATUS pppEndVsNameHandle (PFW_OBJ * pfw,
    PFW_PARAMETER_OPERATION_TYPE type, void * pProfileData, char * value);
LOCAL STATUS pppEndVsChange (PPP_VS_END_STACK_DATA * pEndStackData,
    VSID newVsid);
LOCAL STATUS pppVsidGetByState (PFW_PLUGIN_OBJ_STATE * state,VSID * pVsid);
LOCAL STATUS pppVsidSetByState (PFW_PLUGIN_OBJ_STATE * state,VSID vsid);
LOCAL STATUS pppEndVirtualStackSet (VSID vsid);
#endif /* VIRTUAL_STACK */


/* PMP support functions forward declarations  */

#ifdef PPP_END_PMP_CAPABLE
LOCAL UINT32 getRasAddrPoolId(PFW_PLUGIN_OBJ_STATE *state, UINT32 *dstIp);
LOCAL void pppRasPMPDupEndInfo(END_OBJ *srcEnd, END_OBJ *dstEnd);
LOCAL void pppRasPMPDupDrvInfo(PPP_DRV_CTRL *pSrcDrv, PPP_DRV_CTRL *pDstDrv);
LOCAL void pppRasPMPRemoveProtoInfo(PPP_DRV_CTRL *pDrvCtrl);
int pmpAddrResolvRtn( FUNCPTR ipArpCallBackRtn, struct mbuf* pMbuf,
                     struct sockaddr* dstIpAddr, struct ifnet* ifp,
                     struct rtentry* rt, char* dstBuff);

#endif /* PPP_END_PMP_CAPABLE */


/* IPv4/IPv6 Dual Stack support functions forward declarations  */

#if ((defined STACK_NAME) && (STACK_NAME == STACK_NAME_V4_V6))
int pppOutput(struct ifnet *ifp, struct mbuf *m,struct sockaddr *dst,
              struct rtentry *rt0);
int pppMultiResolveRtn (struct ifnet *ifp,	struct sockaddr **llsa,
                        struct sockaddr *sa);
int pppResolveRtn (FUNCPTR ipArpCallBackRtn, struct mbuf* pMbuf,
                   struct sockaddr* dstIpAddr, struct ifnet* ifp,
                   struct rtentry* rt, char* dstBuff);
STATUS pppResolveFuncsRegister (int protocol);
void pppResolveFuncsUnregister (int protocol);
#endif /* ((defined STACK_NAME) && (STACK_NAME == STACK_NAME_V4_V6)) */


/* locals */

LOCAL NET_FUNCS pppFuncTable =
    {
    (FUNCPTR)pppStart,          /* start func */
    (FUNCPTR)pppStop,           /* stop func */
    (FUNCPTR)pppUnload,         /* unload func */
    (FUNCPTR)pppIoctl,          /* ioctl func */
    (FUNCPTR)pppSend,           /* send func */
    (FUNCPTR)pppMCastAddrAdd,   /* mcast add func */
    (FUNCPTR)pppMCastAddrDel,   /* mcast delete func */
    (FUNCPTR)pppMCastAddrGet,   /* mcast get func */
    (FUNCPTR)pppSend,           /* poll send func;same as normal send */
    (FUNCPTR)pppEndPollReceive, /* polling receive func */
    pppAddressForm,             /* Addr form func */
    (FUNCPTR)pppPacketDataGet,  /* Packet data get func */
    (FUNCPTR)NULL,              /* packet addr get func */
    (FUNCPTR)pppBind            /* Info xchange b/n network
                                   service and n/w driver */
    };


/* PLUG-IN OBJECT FUNCTIONS */


/***************************************************************************
*
* pppVsEndComponentCreate - add PPP VS END component to framework
*
* This routine creates the PPP VS END plug-in object and adds it to the PPP
* framework. 
*
* RETURNS: OK or ERROR
*/

STATUS pppVsEndComponentCreate
   (
   PFW_OBJ *pfw
   )
   {
   PPP_VS_END_COMPONENT *pEndComponent;
   PFW_PLUGIN_OBJ *endPluginObj;

   if (pfw == NULL)
       {
       printf  ("pppVsEndComponentCreate: NULL framework pointer\n");
       return (ERROR);       
       }

   pEndComponent = (PPP_VS_END_COMPONENT *) pfwMalloc (pfw, 
				sizeof (PPP_VS_END_COMPONENT));

    if (pEndComponent == NULL)
        {
        printf ("pppEndInit - Unable to allocate memory of size %d \
                 bytes\n", (int) sizeof (PPP_VS_END_COMPONENT));
        return (ERROR);
        }

    bzero((char *)pEndComponent, sizeof (PPP_VS_END_COMPONENT));

    endPluginObj =  (PFW_PLUGIN_OBJ *)&(pEndComponent->component);

    pEndComponent->component.protocol = 0;
    pEndComponent->component.layerObj = pfwLayerObjGet (pfw,
                                       "INTERFACE_LAYER");

    strcpy (endPluginObj->name, "PPP_VS_END");
    endPluginObj->pfwObj = pfw;
    endPluginObj->profileDataSize = sizeof (PPP_VS_END_PROFILE_DATA);
    endPluginObj->stackDataSize = sizeof (PPP_VS_END_STACK_DATA);
    endPluginObj->profileDataConstruct = pppVsEndProfileDataConstruct;
    endPluginObj->profileDataDestruct = NULL;
    endPluginObj->profileDataCopy = NULL;
    endPluginObj->stackDataConstruct = pppVsEndStackDataConstruct;
    endPluginObj->stackDataDestruct = NULL;
    endPluginObj->receive = pppVsEndReceive;
    endPluginObj->send = pppVsEndSend;
    endPluginObj->stackAdd = pppVsEndStackAdd;
    endPluginObj->stackDelete = pppVsEndStackDelete;
    endPluginObj->interfaceBind = pppVsEndInterfaceBind;

    if (pfwComponentAdd (&pEndComponent->component) == ERROR)
        {
        printf ("pppVsEndComponentCreate: component could not be added to \
                 the framework\n");
        pfwFree (pEndComponent);
        return (ERROR);
        }

    /* Add parameters to framework */

    pfwParameterAdd (endPluginObj, "end_pollRxQueueSize",
                     pppEndPollRxQueueSizeHandle);

#ifdef VIRTUAL_STACK
    pfwParameterAdd (endPluginObj, "end_vsName", pppEndVsNameHandle);
#endif /* VIRTUAL_STACK */

    /*
     * publish PPP_INTERFACE_UP and PPP_INTERFACE_DOWN events that are raised
     * in response to administrative interface UP and DOWN events
     */

#ifdef INET
    if (pfwEventPublish (pfw,"PPP_INTERFACE_UP_EVENT") == NULL ||
        pfwEventPublish (pfw,"PPP_INTERFACE_DOWN_EVENT") == NULL)
        goto  pppVsEndComponentCreateFree;
#endif /* INET */

#ifdef INET6
    if (pfwEventPublish (pfw,"PPP_IPV6_INTERFACE_UP_EVENT") == NULL ||
        pfwEventPublish (pfw,"PPP_IPV6_INTERFACE_DOWN_EVENT") == NULL)
        goto  pppVsEndComponentCreateFree;
#endif /* INET6 */

    /*
     * PPP_SUB_LAYER_TX_BLOCKED event allows us to send END_ERR_BLOCKED
     * status if swamped.  PPP_SUB_LAYER_TX_UNBLOCKED allows us to call
     * muxTxRestart when we can send again
     */

    if (pfwEventPublish(pfw,"PPP_SUB_LAYER_TX_BLOCKED") == NULL ||
        pfwEventPublish(pfw,"PPP_SUB_LAYER_TX_UNBLOCKED") == NULL)
        goto  pppVsEndComponentCreateFree;

#ifdef PPP_END_PMP_CAPABLE
    if (muxAddrResFuncAdd (M2_ifType_pmp, ETHERTYPE_IP,
                           pmpAddrResolvRtn) == ERROR)
        goto  pppVsEndComponentCreateFree;
       
#endif /* PPP_END_PMP_CAPABLE */

#if ((defined STACK_NAME) && (STACK_NAME == STACK_NAME_V4_V6))
#ifdef INET    
    if (pppResolveFuncsRegister (ETHERTYPE_IP) == ERROR)
        goto  pppVsEndComponentCreateFree;
#endif /* INET */
#ifdef INET6
    if (pppResolveFuncsRegister (ETHERTYPE_IPV6) == ERROR)
        goto  pppVsEndComponentCreateFree;
#endif /* INET6 */
#endif /* ((defined STACK_NAME) && (STACK_NAME == STACK_NAME_V4_V6)) */

   return (OK);

pppVsEndComponentCreateFree:

   printf ("pppVsEndComponentCreate: could not create component\n");
   
   pppVsEndComponentDelete (pfw);

   return (ERROR);
   }


/***************************************************************************
*
* pppVsEndComponentDelete - delete the VS END component from the framework
*
* This routine frees the PPP VS END plug-in object allocated by 
* pppVsEndComponentCreate().  pfwComponentDelete will free allocated
* framework resources, if and only if, there are no references to this
* object from a stack or profile object in the framework.  This function
* is user-callable as part of the orderly process of deleting a framework,
* which is seldom necessary.
*
* RETURNS: OK or ERROR
*/

STATUS pppVsEndComponentDelete
    (
    PFW_OBJ *pfw
    )
    {
    PFW_COMPONENT_OBJ *pComponent;

    if (pfw == NULL)
       {
       printf ("pppVsEndComponentDelete: NULL framework pointer\n");
       return (ERROR);       
       }

    pComponent = pfwComponentObjGetByName (pfw, "PPP_VS_END");

    if (pComponent == NULL)
        return ERROR;

#ifdef PPP_END_PMP_CAPABLE
    muxAddrResFuncDel (M2_ifType_pmp, ETHERTYPE_IP);
#endif /* PPP_END_PMP_CAPABLE */

#if ((defined STACK_NAME) && (STACK_NAME == STACK_NAME_V4_V6))
#ifdef INET    
    pppResolveFuncsUnregister (ETHERTYPE_IP);
#endif /* INET */
#ifdef INET6
    pppResolveFuncsUnregister (ETHERTYPE_IPV6);
#endif /* INET6 */
#endif /* ((defined STACK_NAME) && (STACK_NAME == STACK_NAME_V4_V6)) */

    if (pfwComponentDelete (pComponent) == OK)
        {
        pfwFree (pComponent);
        return OK;
        }

    return (ERROR);
    }


/***************************************************************************
* pppVsEndInterfaceBind - bind interfaces PPP VS END implements
*
* NOMANUAL
*/

LOCAL STATUS pppVsEndInterfaceBind
    (
    PFW_PLUGIN_OBJ * pluginObj
    )
    {
    PPP_VS_END_COMPONENT * pComponent = (PPP_VS_END_COMPONENT *)pluginObj;
#ifdef INET
    PPP_IP_INTERFACE           *pppIpInterface;
    PPP_IP_ROUTES_INTERFACE    *pppIpRoutesInterface;
    PPP_IP_DNS_INTERFACE       *pppIpDnsInterface;
#endif /* INET */
#ifdef INET6
    PPP_IPV6_INTERFACE         *pppIpv6Interface;
#endif /* INET6 */
    COMPONENT_ACCEPTABLE_PROTOCOLS_INTERFACE
		    *componentAcceptableProtocolsInterface;
    PPP_LINK_ID_INTERFACE *pppLinkIdInterface;
    PFW_OBJ * pfw = pluginObj->pfwObj;
    int i;

    PPP_IF_IFX_TABLE_INTERFACE * pppIfIfXTableInterface;
    PPP_IF_STACK_TABLE_INTERFACE * pppIfStackTableInterface;

#ifdef VIRTUAL_STACK
    PPP_VSID_INTERFACE * pppVsidInterface;
#endif /* VIRTUAL_STACK */

#ifdef INET
    if ((i = pfwInterfaceRegister(pfw,"PPP_IP_INTERFACE")) > 0)
        {
        pppIpInterface = &pComponent->pppIpInterface;
        pppIpInterface->interfaceObj.id = i;
        pppIpInterface->interfaceObj.pluginObj = pluginObj;
        pppIpInterface->ipInterfaceDown = ipInterfaceDown;
        pppIpInterface->ipInterfaceUp = ipInterfaceUp;
        pfwInterfaceBind (&pppIpInterface->interfaceObj);
        }

    if ((i = pfwInterfaceRegister(pfw,"PPP_IP_ROUTES_INTERFACE")) > 0)
        {
        pppIpRoutesInterface = &pComponent->pppIpRoutesInterface;
        pppIpRoutesInterface->interfaceObj.id = i;
        pppIpRoutesInterface->interfaceObj.pluginObj = pluginObj;
        pppIpRoutesInterface->ipRouteAdd = ipRouteAdd;
        pppIpRoutesInterface->ipRouteDelete = ipRouteDelete;
        pppIpRoutesInterface->ipSetIfMask = ipSetIfMask;
        pfwInterfaceBind (&pppIpRoutesInterface->interfaceObj);
        }

    if ((i = pfwInterfaceRegister(pfw,"PPP_IP_DNS_INTERFACE")) > 0)
        {
        pppIpDnsInterface = &pComponent->pppIpDnsInterface;
        pppIpDnsInterface->interfaceObj.id = i;
        pppIpDnsInterface->interfaceObj.pluginObj = pluginObj;
        pppIpDnsInterface->ipDnsAddressSet = ipDnsAddressSet;
        pppIpDnsInterface->ipDnsAddressGet = ipDnsAddressGet;
        pfwInterfaceBind (&pppIpDnsInterface->interfaceObj);
        }
#endif /* INET */