dhcpclib.c

the vxworks system kernel souce packeg.there may be something you need .

     */

    if (bsdFlag)
        pLeaseData->ifData.haddr.htype = ETHER;
    else
        pLeaseData->ifData.haddr.htype = dhcpConvert (pIf->if_type);

    pLeaseData->ifData.haddr.hlen = pIf->if_addrlen;

    if (pLeaseData->ifData.haddr.hlen > MAX_HLEN)
        pLeaseData->ifData.haddr.hlen = MAX_HLEN;

    bcopy ( (char *) ( (struct arpcom *)pIf)->ac_enaddr,
           (char *)&pLeaseData->ifData.haddr.haddr, 
           pLeaseData->ifData.haddr.hlen); 

    /*
     * Set the maximum message length based on the MTU size and the
     * maximum message/buffer size specified during initialization.
     */

    pReqSpec->maxlen = maxSize;

    /* set duration of client's wait for multiple offers */

    pReqSpec->waitsecs = dhcpcOfferTimeout; 

    pReqSpec->reqlist.len = 0;    /* No options requested yet.  */

    /*
     * If executing with startup lease, or if automatic configuration is
     * requested, initialize request list with tags for options required 
     * by all network interfaces, using RFC 1533 tag values.
     */

    if (pLeaseData->autoConfig || pLeaseData->leaseType == DHCP_AUTOMATIC)
        {
        pReqSpec->reqlist.list [pReqSpec->reqlist.len++] =
                                                        _DHCP_SUBNET_MASK_TAG;
        pReqSpec->reqlist.list [pReqSpec->reqlist.len++] =
                                                        _DHCP_BRDCAST_ADDR_TAG;
        }

    /*
     * For now, create a separate watchdog timer for each lease.  Eventually,
     * a single watchdog timer will suffice for all leases, when combined
     * with a sorted queue containing relative firing times.  This enhancement
     * can wait.
     */

    /* Create event timer for state machine.  */

    pLeaseData->timer = wdCreate ();
    if (pLeaseData->timer == NULL)
        {
        free (pLeaseData);
        close (bpfDev);
        errno = S_dhcpcLib_MEM_ERROR;
        return (NULL);
        }

    /* Create signalling semaphore for completion of negotiation process.  */

    pLeaseData->leaseSem = semBCreate (SEM_Q_FIFO, SEM_EMPTY);
    if (pLeaseData->leaseSem == NULL)
        {
        wdDelete (pLeaseData->timer);
        free (pLeaseData);
        close (bpfDev);
        errno = S_dhcpcLib_MEM_ERROR;
        return (NULL);
        }

    /* 
     * Manual leases will not reset the network interface unless specifically
     * requested to do so.  This lease type is replaced with DHCP_AUTOMATIC for 
     * the lease established during system startup.  The parameters for
     * an automatic lease are always applied to the underlying interface.
     */

    pLeaseData->leaseType = DHCP_MANUAL;

    pLeaseData->initFlag = TRUE;

    /* Store the lease-specific data in the global list.  */

    dhcpcLeaseList [offset] = pLeaseData;

    /* Notify the DHCP read task that a new session is available. */

    send (dhcpcSignalSock, dhcpcSignalData, dhcpcSignalSize, 0);

    return (pCookie);
    }

/*******************************************************************************
*
* dhcpcEventHookAdd - add a routine to handle configuration parameters
*
* This routine installs a hook routine to handle changes in the configuration
* parameters provided for the lease indicated by <pCookie>.  The hook provides 
* an alternate configuration method for DHCP leases and uses the following 
* interface:
* .CS
* void dhcpcEventHookRtn
*     (
*     int 	leaseEvent,	/@ new or expired parameters @/
*     void * 	pCookie 	/@ lease identifier from dhcpcInit() @/
*     )
* .CE
*
* The routine is called with the <leaseEvent> parameter set to DHCPC_LEASE_NEW
* whenever a lease is successfully established.  The DHCPC_LEASE_NEW event
* does not occur when a lease is renewed by the same DHCP server, since the
* parameters do not change in that case.  However, it does occur if the 
* client rebinds to a different DHCP server.  The DHCPC_LEASE_INVALID event
* indicates that the configuration parameters for the corresponding lease may
* no longer be used.  That event occurs when a lease expires or a renewal
* or verification attempt fails, and coincides with re-entry into the initial 
* state of the negotiation process.
*
* If the lease initialization specified automatic configuration of the
* corresponding network interface, any installed hook routine will be invoked
* after the new address information is applied.
*
* RETURNS: OK if notification hook added, or ERROR otherwise.
*
* ERRNO: S_dhcpcLib_BAD_COOKIE, S_dhcpcLib_NOT_INITIALIZED
*/

STATUS dhcpcEventHookAdd
    (
    void * 	pCookie, 	/* identifier returned by dhcpcInit() */
    FUNCPTR 	pEventHook	/* routine to handle lease parameters */
    )
    {
    LEASE_DATA * 	pLeaseData;
    int offset;

    /*
     * 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;

    for (offset = 0; offset < dhcpcMaxLeases; offset++)
        if (dhcpcLeaseList [offset] != NULL &&
                dhcpcLeaseList [offset] == pLeaseData)
            break;

    if (offset == dhcpcMaxLeases)
        {
        errno = S_dhcpcLib_BAD_COOKIE;
        return (ERROR);
        }

    if (!dhcpcInitialized || !pLeaseData->initFlag)
        {
        errno = S_dhcpcLib_NOT_INITIALIZED;
        return (ERROR);
        }

    /* Assign the event notification hook.  */

    pLeaseData->eventHookRtn = pEventHook;

    return (OK);
    }

/*******************************************************************************
*
* dhcpcEventHookDelete - remove the configuration parameters handler
*
* This routine removes the hook routine that handled changes in the 
* configuration parameters for the lease indicated by <pCookie>.
* If the lease initialization specified automatic configuration of the
* corresponding network interface, the assigned address could change
* without warning after this routine is executed.
*
* RETURNS: OK if notification hook removed, or ERROR otherwise.
*
* ERRNO: S_dhcpcLib_BAD_COOKIE, S_dhcpcLib_NOT_INITIALIZED
* 
*/

STATUS dhcpcEventHookDelete
    (
    void * 	pCookie 	/* identifier returned by dhcpcInit() */
    )
    {
    LEASE_DATA * 	pLeaseData;
    int offset;

    /*
     * 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;

    for (offset = 0; offset < dhcpcMaxLeases; offset++)
        if (dhcpcLeaseList [offset] != NULL &&
                dhcpcLeaseList [offset] == pLeaseData)
            break;

    if (offset == dhcpcMaxLeases)
        {
        errno = S_dhcpcLib_BAD_COOKIE;
        return (ERROR);
        }

    if (!dhcpcInitialized || !pLeaseData->initFlag)
        {
        errno = S_dhcpcLib_NOT_INITIALIZED;
        return (ERROR);
        }

    /* Remove the event notification hook. */

    pLeaseData->eventHookRtn = NULL;

    return (OK);
    }

/*******************************************************************************
*
* dhcpcCacheHookAdd - add a routine to store and retrieve lease data
*
* This routine adds a hook routine that is called at the bound state
* (to store the lease data) and during the INIT_REBOOT state (to re-use the
* parameters if the lease is still active).  The calling sequence of the 
* input hook routine is:
* .CS
* STATUS dhcpcCacheHookRtn
*     (
*     int command,			/@ requested cache operation @/
*     unsigned long *pTimeStamp,	/@ lease timestamp data @/
*     int *pDataLen,			/@ length of data to access @/
*     char *pBuffer			/@ pointer to data buffer @/
*     )
*
* .CE
* The hook routine should return OK if the requested operation is completed
* successfully, or ERROR otherwise.  All the supplied pointers reference memory 
* locations that are reused upon return from the hook.  The hook routine 
* must copy the data elsewhere.
*
* NOTE
* The setting of the cache hook routine during a dhcpcInit() call is
* recorded and used by the resulting lease throughout its lifetime.
* Since the hook routine is intended to store a single lease record,
* a separate hook routine should be specified before the dhcpcInit()
* call for each lease which will re-use its parameters across reboots.
*
* IMPLEMENTATION
* The <command> parameter specifies one of the following operations:
* .IP DHCP_CACHE_WRITE 25
* Save the indicated data.  The write operation must preserve the value
* referenced by <pTimeStamp> and the contents of <pBuffer>.  The <pDataLen> 
* parameter indicates the number of bytes in that buffer.
* .IP DHCP_CACHE_READ 
* Restore the saved data.  The read operation must copy the data from the
* most recent write operation into the location indicated by <pBuffer>,
* set the contents of <pDataLen> to the amount of data provided, and store 
* the corresponding timestamp value in <pTimeStamp>.
* .IP
* The read operation has very specific requirements.  On entry, the value 
* referenced by <pDataLen> indicates the maximum buffer size available at
* <pBuffer>.  If the amount of data stored by the previous write exceeds this 
* value, the operation must return ERROR.  A read must also return ERROR if the 
* saved timestamp value is 0.  Finally, the read operation must return ERROR if 
* it is unable to retrieve all the data stored by the write operation or if the
* previous write was unsuccessful.
* .IP DHCP_CACHE_ERASE 
* Ignore all stored data.  Following this operation, subsequent read operations
* must return ERROR until new data is written.  All parameters except 
* <command> are NULL.
* .LP
*
* RETURNS: OK, always.
*
* ERRNO: N/A
*/

STATUS dhcpcCacheHookAdd
    (
    FUNCPTR 	pCacheHookRtn 	/* routine to store/retrieve lease data */
    )
    {
    dhcpcCacheHookRtn = pCacheHookRtn;
    return (OK);
    }

/*******************************************************************************
*
* dhcpcCacheHookDelete - delete a lease data storage routine
*
* This routine deletes the hook used to store lease data, preventing
* re-use of the configuration parameters across system reboots for
* all subsequent lease attempts.  Currently active leases will continue
* to use the routine specified before the lease initialization.
*
* RETURNS: OK, always.
*
* ERRNO: N/A
*/

STATUS dhcpcCacheHookDelete (void)
    {
    dhcpcCacheHookRtn = NULL;
    return (OK);
    }

/*******************************************************************************
*
* dhcpcBind - obtain a set of network configuration parameters with DHCP
*
* This routine initiates a DHCP negotiation according to the process described 
* in RFC 1541.  The <pCookie> argument contains the return value of an earlier 
* dhcpcInit() call and is used to identify a particular lease.
*
* The <syncFlag> parameter specifies whether the DHCP negotiation started by 
* this routine will execute synchronously or asynchronously.  An asynchronous 
* execution will return after starting the DHCP negotiation, but a synchronous 
* execution will only return once the negotiation process completes.
*
* When a new lease is established, any event hook provided for the lease
* will be called to process the configuration parameters.  The hook is also 
* called when the lease expires or the negotiation process fails.  The results 
* of an asynchronous DHCP negotiation are not available unless an event hook 
* is installed.
*
* If automatic configuration of the underlying network interface was specified
* during the lease initialization, this routine will prevent all higher-level 
* protocols from accessing the underlying network interface used during the 
* initial lease negotiation until that process is complete.  In addition, any 
* addressing information obtained will be applied to that network interface, 
* which will remain disabled if the initial negotiation fails.  Finally, the
* interface will be disabled if the lease expires.
*
* NOTE
* If the DHCP client is used to obtain the VxWorks boot parameters, this 
* routine is called automatically during system startup using the automatic 
* reconfiguration.  Therefore, any calls to this routine which use the network 
* boot device for message transfer when the DHCP client was used at boot time 
* must not request automatic reconfiguration during initialization.  Otherwise, 
* the resulting lease settings will conflict with the configuration maintained 
* by the lease established during system startup. 
*
* RETURNS: OK if routine completes, or ERROR otherwise.
*
* ERRNO: S_dhcpcLib_BAD_COOKIE, S_dhcpcLib_NOT_INITIALIZED, 
*        S_dhcpcLib_BAD_OPTION, S_dhcpcLib_BAD_DEVICE
* 
*/

STATUS dhcpcBind 
    (
    void * 	pCookie, 	/* identifier returned by dhcpcInit() */
    BOOL 	syncFlag 	/* synchronous or asynchronous execution */
    )
    {
    int 		offset;
    STATUS		result = OK;
    LEASE_DATA * 	pLeaseData = NULL;
    struct dhcpcOpts * 	pOptList;
    char * 		pOptions;
    struct ifreq 	ifr;

    /*
     * 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;

    for (offset = 0; offset < dhcpcMaxLeases; offset++)
        if (dhcpcLeaseList [offset] != NULL &&
                dhcpcLeaseList [offset] == pLeaseData)