dhcpccommonlib.c

VXWORKS源代码

    pMbuf = bcopy_to_mbufs (pData, size, 0, pIf, NONE);
    if (pMbuf == NULL)
        return (ERROR);

    if (broadcastFlag)
        pMbuf->mBlkHdr.mFlags |= M_BCAST;

    level = splnet ();
    result = pIf->if_output (pIf, pMbuf, (struct sockaddr *)pDest, NULL);
    splx (level);

    if (result)
        return (ERROR);

    return (OK);
    }

/*******************************************************************************
*
* dhcpcRead - handle all incoming DHCP messages
*
* This routine monitors all active BPF devices for new DHCP messages and
* signals the lease monitor task when a valid message arrives. It is the
* entry point for the data retrieval task created during the library
* initialization and should only be called internally.
*
* RETURNS: N/A
*
* ERRNO: N/A
*
* NOMANUAL
*/

void dhcpcRead (void)
    {
    STATUS 	result;

    EVENT_DATA 	newEvent;
    int key;

    char * 	pMsgData = NULL;

    BOOL 	dataFlag;
    fd_set 	readFds;
    int 	fileNum = 0;
    int 	maxFileNum;
    int 	slot = 0; 	/* Current buffer for holding messages. */
    int 	maxSlot = 10; 	/* Matches size of event ring. */
    int 	loop;
    int 	bufSize = 0;
    struct bpf_hdr * 	pMsgHdr;
    int 	msglen;
    int 	curlen;
    int 	totlen; 	/* Amount of data in BPF buffer. */
    struct timeval timeout;

    timeout.tv_sec = timeout.tv_usec = 0;
 
    FOREVER
        {
        /*
         * Wait until a message arrives or a new DHCP session is available.
         * The dhcpcInit() routine forces the read task to rebuild the list
         * of active devices by sending an empty message to the selected DHCP
         * client port so that the select routine exits.
         */

        FD_ZERO (&readFds);
        maxFileNum = 0;

        if (!_dhcpcBootFlag)
            {
            /*
             * Runtime DHCP sessions monitor a UDP socket bound to the
             * DHCP port to read and discard messages which were already
             * processed through the Berkeley Packet Filters. This socket
             * also allows the read loop to restart when a new DHCP session
             * begins. The boot time DHCP session is unable to use any
             * sockets since no fully configured devices exist.
             */
            
            FD_SET (dhcpcDataSock, &readFds);
            maxFileNum = dhcpcDataSock;
            }

        /* Create list of active BPF devices for monitoring. */

        for (loop = 0; loop < dhcpcMaxLeases; loop++)
            {
            if (dhcpcLeaseList [loop] != NULL &&
                    dhcpcLeaseList [loop]->initFlag)
                {
                fileNum = dhcpcLeaseList [loop]->ifData.bpfDev;

                FD_SET (fileNum, &readFds);

                if (fileNum > maxFileNum)
                    maxFileNum = fileNum;
                }
            }

        /*
         * No BPF devices will be active until a lease session starts
         * which uses an interface without an assigned IP address.
         */

        maxFileNum++;     /* Adjust maximum for select() routine. */

        /*
         * Check for an incoming DHCP message. None may be available
         * if a new session started.
         */

        result = select (maxFileNum, &readFds, NULL, NULL, NULL);
        if (result <= 0)
            continue;

        /*
         * Ignore the message if the current buffer is full. That
         * condition indicates an overflow of the message "ring".
         */

        if (dhcpcMessageList [slot].writeFlag == FALSE)
            continue;

        dhcpcMessageList [slot].writeFlag = FALSE;

        pMsgData = dhcpcMessageList [slot].msgBuffer;

        if (!_dhcpcBootFlag)
            {
            /*
             * For runtime DHCP sessions, read and discard any DHCP
             * messages which reach the socket layer. An (empty)
             * DHCP message is sent to the loopback address when a
             * new session begins. This operation also removes
             * messages which were already handled by the Berkeley
             * Packet Filter, but also reach the socket layer if
             * any device is configured with an IP address. Creating
             * a socket to receive them prevents the transmission of
             * ICMP errors.
             */

            dataFlag = FD_ISSET (dhcpcDataSock, &readFds);
            if (dataFlag)
                {
                read (dhcpcDataSock, pMsgData, dhcpcBufSize);
                dhcpcMessageList [slot].writeFlag = TRUE;
                continue;
                }
            }

        /* Read the first available DHCP message. */

        for (loop = 0; loop < dhcpcMaxLeases; loop++)
            {
            if (dhcpcLeaseList [loop]->initFlag)
                {
                fileNum = dhcpcLeaseList [loop]->ifData.bpfDev;
                dataFlag = FD_ISSET (fileNum, &readFds);
                if (dataFlag)
                    {
                    /*
                     * Any users must read an entire BPF buffer. The size
                     * is set during the initialization for each lease.
                     */

                    bufSize = dhcpcLeaseList [loop]->ifData.bufSize;
                    break;
                    }
                }
            }

        if (loop == dhcpcMaxLeases)
            {
            /* No DHCP sessions are using the BPF devices. */

            continue;
            }
 
        /*
         * Ignore any read errors. The DHCP protocol is designed to handle
         * any problems with false arrival notifications or invalid messages.
         */

        totlen = read (fileNum, pMsgData, bufSize);

        /* Signal lease monitor for each DHCP message in the BPF buffer. */

        newEvent.source = DHCP_AUTO_EVENT;
        newEvent.type = DHCP_MSG_ARRIVED;
        newEvent.leaseId = dhcpcLeaseList [loop];
        newEvent.slot = slot;

        msglen = curlen = 0;
        pMsgHdr = (struct bpf_hdr *)pMsgData;

        while (curlen < totlen)
            {
            msglen = BPF_WORDALIGN(pMsgHdr->bh_hdrlen + pMsgHdr->bh_caplen);
            curlen += msglen;

            /* Set the pointer to skip the BPF and link level headers. */

            newEvent.pMsg = pMsgData + pMsgHdr->bh_hdrlen +
                                pMsgHdr->bh_linklen;

            if (curlen < totlen)
                newEvent.lastFlag = FALSE;
            else
                newEvent.lastFlag = TRUE;

            /* Lock interrupts to prevent conflicts with timeout thread. */

            key = intLock ();
            rngBufPut (dhcpcEventRing, (char *) &newEvent, sizeof(newEvent));
            intUnlock (key);

            semGive (dhcpcEventSem);

            pMsgData = pMsgData + msglen;
            pMsgHdr = (struct bpf_hdr *)pMsgData;
            }

        /* Advance to next element in message ring. */

        slot = (slot + 1) % maxSlot;
        }
    }

/*******************************************************************************
*
* dhcpcOptionSet - add an option to the option request list
*
* This routine specifies which options the lease indicated by the <pCookie>
* parameter will request from a server.  The <option> parameter specifies an 
* option tag as defined in RFC 2132.  See the dhcp/dhcp.h include file for a
* listing of defined aliases for the available option tags. This routine will
* not accept the following <option> values, which are either used by the
* server for control purposes or only supplied by the client:
*
*     _DHCP_PAD_TAG
*     _DHCP_REQUEST_IPADDR_TAG 
*     _DHCP_LEASE_TIME_TAG  
*     _DHCP_OPT_OVERLOAD_TAG
*     _DHCP_MSGTYPE_TAG
*     _DHCP_SERVER_ID_TAG
*     _DHCP_REQ_LIST_TAG 
*     _DHCP_ERRMSG_TAG 
*     _DHCP_MAXMSGSIZE_TAG
*     _DHCP_CLASS_ID_TAG 
*     _DHCP_CLIENT_ID_TAG 
*     _DHCP_END_TAG
*
* This routine also will not accept <option> values 62 or 63, which are not
* currently defined.
*
* The maximum length of the option field in a DHCP message depends on the
* MTU size of the associated interface and the maximum DHCP message size set
* during the DHCP library initialization. Both the option request list and
* the options sent by the client through the dhcpcOptionAdd() routine share
* that field. Options which exceed the limit will not be stored.
*
* NOTE: The boot program automatically requests all options necessary for
* default target configuration. This routine is only necessary to support
* special circumstances in which additional options are required. Any
* options requested in that case may be retrieved after the runtime image
* has started.
* 
* NOTE: The DHCP specification forbids changing the option request list after
* a lease has been established.  Therefore, this routine must not be used
* after the dhcpcBind() call (in a runtime image) or the dhcpcBootBind() call
* (for a boot image).  Changing the request list at that point could have
* unpredictable results.
*
* NOTE: Options are added directly to outgoing DHCP messages, and numeric
* options (e.g. lease duration time) are expected to be provided in network
* byte order. Care must be taken on little-endian hosts to insure that
* numeric arguments are properly byte-swapped before being passed to this
* routine.
*
* RETURNS: OK if the option was set successfully, or ERROR if the option
* is invalid or storage failed.
*
* ERRNO: S_dhcpcLib_BAD_OPTION, S_dhcpcLib_OPTION_NOT_STORED
*
*/

STATUS dhcpcOptionSet
    (
    void * 	pCookie, 	/* identifier returned by dhcpcInit() */
    int 	option		/* RFC 2132 tag of desired option */
    )
    {
    LEASE_DATA *	 	pLeaseData;
    struct dhcp_reqspec * 	pReqSpec;
    struct dhcpcOpts * 		pOptList;

    int msglen = 0; 	/* Length of DHCP message after inserting option */

    /*
     * Use the cookie to access the lease-specific data structures.  For now,
     * just typecast the cookie.  This translation could be replaced with a more
     * sophisticated lookup at some point.
     */

    pLeaseData = (LEASE_DATA *)pCookie;
    pReqSpec = &pLeaseData->leaseReqSpec;

    /* Check for restricted or undefined options. */

    switch (option)
        {
        case _DHCP_PAD_TAG: 		/* fall-through */
        case _DHCP_REQUEST_IPADDR_TAG: 	/* fall-through */
        case _DHCP_LEASE_TIME_TAG: 	/* fall-through */
        case _DHCP_OPT_OVERLOAD_TAG: 	/* fall-through */
        case _DHCP_MSGTYPE_TAG: 	/* fall-through */
        case _DHCP_SERVER_ID_TAG: 	/* fall-through */
        case _DHCP_REQ_LIST_TAG: 	/* fall-through */
        case _DHCP_ERRMSG_TAG: 		/* fall-through */
        case _DHCP_MAXMSGSIZE_TAG: 	/* fall-through */
        case _DHCP_CLASS_ID_TAG: 	/* fall-through */
        case _DHCP_CLIENT_ID_TAG: 	/* fall-through */
        case _DHCP_END_TAG:
            errno = S_dhcpcLib_BAD_OPTION;
            return (ERROR);
            break;
        default:
            break;
        }

    if (option == 62 || option == 63)
        {
        errno = S_dhcpcLib_BAD_OPTION;
        return (ERROR);
        }
        
    if (option < 0 || option > _DHCP_LAST_OPTION)
        {
        errno = S_dhcpcLib_BAD_OPTION;
        return (ERROR);
        }

    /*
     * Verify that the option won't exceed the MTU size for a message.
     * Start with an initial length equal to the UDP and IP headers and
     * the fixed-length portion of a DHCP message.
     */

    msglen = UDPHL + IPHL + (DFLTDHCPLEN - DFLTOPTLEN);

    /* Include size of existing options and option request list. */

    pOptList = pReqSpec->pOptList;

    if (pOptList)
        msglen += pReqSpec->pOptList->optlen;

    msglen += (pReqSpec->reqlist.len + 1);

    /*
     * Include space for required magic cookie (4 bytes), message
     * type option (3 bytes), maximum message size (4 bytes), and
     * server identifier option (6 bytes).
     */

    msglen += 17;

    /* Include space for required requested IP address option (6 bytes). */

    msglen += 6;