database.c

vxworks下dhcpc,dhcpr,dhcps库源码

            free (acl);
            continue;
        }

        /* Store entry in hash table, keyed on relay agent IP address. */

        result = hash_ins (&relayhashtable, (char *) &acl->relay,
                           sizeof (struct in_addr), relayipcmp, &acl->relay, acl);
        if (result < 0) {
#ifdef DHCPS_DEBUG
            logMsg ("hash insertion failed in read_relay_db()", 0, 0, 0, 0, 0, 0);
#endif
            free (acl);
            break;
        }

        nrelay++;
    }

#ifdef DHCPS_DEBUG
    logMsg ("dhcps: read %d entries from relay agent database.\n", nrelay, 0, 0, 0, 0, 0);
#endif

    return;
}

/*******************************************************************************
*
* strtotime - parse lease expiration time
*
* This routine converts the lease expiration time stored in the binding
* database into the internal calendar time. That field has the following
* format:
*                "Wed Feb 19 14:17:39 1997"
*
* On generic VxWorks systems, the internal calendar time is the number of 
* seconds since system startup. For correct operation of DHCP, it should be 
* the number of seconds since some absolute base time, such as 00:00:00 GMT, 
* Jan. 1, 1970, which is the base value used on Unix systems. Adding this
* functionality to VxWorks requires BSP modifications. Without this feature, 
* rebooting the server automatically extends all leases. This behavior will 
* reduce protocol efficiency, since the server will not re-assign addresses 
* that (incorrectly) are recorded as still in use, but it will not cause 
* duplicate IP address assignment.
*
* RETURNS: Calendar time, or 0 if not available.
*
* ERRNO: N/A
*
* NOMANUAL
*/

static time_t strtotime (char *date_str /* String containing lease expiration time. */
    )
{
    struct tm tmval;
    char week[4];
    char month[4];
    int year = 0;
    int i = 0;
    struct map
    {
        char symbol[4];
        int code;
    };
    struct map week_list[7];
    struct map month_list[12];

    if (*date_str == '\0')
        return (0);

    /* Initialize days of week and months of year. */

    week_list[0].code = 0;
    strcpy (week_list[0].symbol, "Sun");
    week_list[1].code = 1;
    strcpy (week_list[1].symbol, "Mon");
    week_list[2].code = 2;
    strcpy (week_list[2].symbol, "Tue");
    week_list[3].code = 3;
    strcpy (week_list[3].symbol, "Wed");
    week_list[4].code = 4;
    strcpy (week_list[4].symbol, "Thu");
    week_list[5].code = 5;
    strcpy (week_list[5].symbol, "Fri");
    week_list[6].code = 6;
    strcpy (week_list[6].symbol, "Sat");

    month_list[0].code = 0;
    strcpy (month_list[0].symbol, "Jan");
    month_list[1].code = 1;
    strcpy (month_list[1].symbol, "Feb");
    month_list[2].code = 2;
    strcpy (month_list[2].symbol, "Mar");
    month_list[3].code = 3;
    strcpy (month_list[3].symbol, "Apr");
    month_list[4].code = 4;
    strcpy (month_list[4].symbol, "May");
    month_list[5].code = 5;
    strcpy (month_list[5].symbol, "Jun");
    month_list[6].code = 6;
    strcpy (month_list[6].symbol, "Jul");
    month_list[7].code = 7;
    strcpy (month_list[7].symbol, "Aug");
    month_list[8].code = 8;
    strcpy (month_list[8].symbol, "Sep");
    month_list[9].code = 9;
    strcpy (month_list[9].symbol, "Oct");
    month_list[10].code = 10;
    strcpy (month_list[10].symbol, "Nov");
    month_list[11].code = 11;
    strcpy (month_list[11].symbol, "Dec");

    bzero ((char *) &tmval, sizeof (tmval));
    bzero (week, sizeof (week));
    bzero (month, sizeof (month));

    /*
     * Parse date string into separate fields. Day of month, hour, 
     * minute, and second are in format used by mktime() below. 
     */

    sscanf (date_str, "%s %s %u %u:%u:%u %u", week, month, &(tmval.tm_mday),
            &(tmval.tm_hour), &(tmval.tm_min), &(tmval.tm_sec), &year);

    /* Adjust entry for base year. */

    tmval.tm_year = year - 1900;

    /* Store value for day of week. (Sunday = 0). */

    for (i = 0; i < 7; i++)
        if (strcmp (week_list[i].symbol, week) == 0)
            break;
    if (i < 7)
        tmval.tm_wday = week_list[i].code;
    else
        return (0);

    /* Store value for month of year. (January = 0, December = 11). */

    for (i = 0; i < 12; i++)
        if (strcmp (month_list[i].symbol, month) == 0)
            break;
    if (i < 12)
        tmval.tm_mon = month_list[i].code;
    else
        return (0);

    return (mktime (&tmval));
}

/*******************************************************************************
*
* get_ip - extract numbers in IP address format
*
* This routine extracts IP addresses and subnet masks (in dotted decimal 
* format) from the input string into the provided structure. It is used when 
* retrieving entries from the address pool and binding databases.
*
* RETURNS: OK if successful, or ERROR otherwise.
*
* ERRNO: N/A
*
* NOMANUAL
*/

static STATUS get_ip (char **src,   /* current location in input string */
                      struct in_addr *target    /* pointer to storage for extracted value */
    )
{
    if (prs_inaddr (src, &target->s_addr) != 0)
        return (ERROR);

    return (OK);
}

/*******************************************************************************
*
* resipcmp - verify IP addresses for address pool entries
*
* This routine compares a hash table key against the IP address of a address 
* pool entry. It is used when storing and retrieving lease descriptors with 
* the internal hash tables.
*
* RETURNS: TRUE if addresses match, or FALSE otherwise.
*
* ERRNO: N/A
*
* NOMANUAL
*/

int resipcmp (struct in_addr *key,  /* pointer to hash table key */
              struct dhcp_resource *rp  /* pointer to lease resource */
    )
{
    return (key->s_addr == rp->ip_addr.s_addr);
}

/*******************************************************************************
*
* relayipcmp - verify IP addresses for relay agent entries
*
* This routine compares a hash table key against the IP address of a relay
* agent. It is used when storing and retrieving relay agent entries in the 
* internal hash table.
*
* RETURNS: TRUE if addresses match, or FALSE otherwise.
*
* ERRNO: N/A
*
* NOMANUAL
*/

int relayipcmp (struct in_addr *key,    /* pointer to hash table key */
                struct relay_acl *aclp  /* pointer to relay agent entry */
    )
{
    return (key->s_addr == aclp->relay.s_addr);
}

/*******************************************************************************
*
* paramcidcmp - verify client identifiers for additional parameters
*
* This routine compares a hash table key against the client identifier 
* contained in a lease descriptor to verify matching types and values. It 
* also checks the recorded subnet against the actual subnet. It is used to
* verify client information when accessing the parameters hash table.
*
* RETURNS: TRUE if entries OK, or FALSE otherwise.
*
* ERRNO: N/A
*
* NOMANUAL
*/

int paramcidcmp (struct client_id *key, /* pointer to hash table key */
                 struct dhcp_resource *rp   /* pointer to lease descriptor */
    )
{
    return (rp != NULL && rp->binding != NULL &&
            key->idtype == rp->binding->cid.idtype &&
            key->idlen == rp->binding->cid.idlen &&
            bcmp (key->id, rp->binding->cid.id, key->idlen) == 0);
}

/*******************************************************************************
*
* bindcidcmp - verify client identifiers for active or offered leases
*
* This routine compares a hash table key against the client identifier 
* contained in a lease record to verify matching types and values. It also 
* checks the recorded subnet against the actual subnet. It is used to verify 
* client information when establishing or renewing leases in response to DHCP
* request messages.
*
* RETURNS: TRUE if entries OK, or FALSE otherwise.
*
* ERRNO: N/A
*
* NOMANUAL
*/

int bindcidcmp (struct client_id *key,  /* pointer to hash table key */
                struct dhcp_binding *bp /* pointer to lease record */
    )
{
    return (bp != NULL &&
            key->subnet.s_addr == bp->cid.subnet.s_addr &&
            key->idtype == bp->cid.idtype && key->idlen == bp->cid.idlen &&
            bcmp (key->id, bp->cid.id, key->idlen) == 0);
}

/*******************************************************************************
*
* set_default - provide values for mandatory configuration parameters
*
* This routine provides default values for fields in a lease descriptor if
* not specified by the administrator in the corresponding address pool entry. 
* It ensures that every lease descriptor includes a default and maximum lease
* length, and a subnet mask. Additionally, it makes entries which contain a 
* client identifier available for BOOTP clients, and resets the maximum lease 
* for all such entries to infinity.
*
* RETURNS: TRUE if entries OK, or FALSE otherwise.
*
* ERRNO: N/A
*
* NOMANUAL
*/

void set_default (struct dhcp_resource *rp  /* pointer to lease descriptor */
    )
{
    if (ISCLR (rp->valid, S_DEFAULT_LEASE)) {
        SETBIT (rp->valid, S_DEFAULT_LEASE);
        rp->default_lease = dhcps_dflt_lease;
    }

    if (ISCLR (rp->valid, S_MAX_LEASE)) {
        SETBIT (rp->valid, S_MAX_LEASE);
        rp->max_lease = dhcps_max_lease;
    }
    if (ISSET (rp->valid, S_CLIENT_ID)) {
        SETBIT (rp->valid, S_ALLOW_BOOTP);
        rp->allow_bootp = TRUE;
    }
    if (ISSET (rp->valid, S_ALLOW_BOOTP) && rp->allow_bootp == TRUE) {
        SETBIT (rp->valid, S_MAX_LEASE);
        rp->max_lease = 0xffffffff; /* infinity */
    }

    if (ISCLR (rp->valid, S_SUBNET_MASK)) {
        SETBIT (rp->valid, S_SUBNET_MASK);
        default_netmask (&rp->ip_addr, &rp->subnet_mask);
    }
    return;
}

/*******************************************************************************
*
* default_netmask - determine the subnet for an IP address
*
* This routine assigns a netmask for the given IP address based on the IP 
* class value. It is called if no netmask was specified in the corresponding 
* address pool entry. It makes no provision for subnetting. The DHCP server 
* will not issue an address to a client if it is not on the client's subnet. 
* Therefore, if subnetting is used, the netmask for each address pool entry 
* must be specified explicitly.
*
* RETURNS: N/A
*
* ERRNO: N/A
*
* NOMANUAL
*/

static void default_netmask (struct in_addr *ipaddr,    /* pointer to IP address */
                             struct in_addr *dfltnetmask    /* pointer to storage for extracted value */
    )
{
    int top = 0;

    top = ntohl (ipaddr->s_addr) >> 30;

    switch (top) {
    case 0:                    /* class A */
    case 1:                    /* class A */
        dfltnetmask->s_addr = htonl (0xff000000);
        break;
    case 2:                    /* class B */
        dfltnetmask->s_addr = htonl (0xffff0000);
        break;
    case 3:                    /* class C */
        dfltnetmask->s_addr = htonl (0xffffff00);
        break;
    default:
        dfltnetmask->s_addr = 0xffffffff;
        break;
    }
    return;
}

/*******************************************************************************
*
* proc_sname - extract the DHCP server name
*
* This routine sets the TFTP server name field of the lease descriptor to the
* value specified by a "snam" field in the address pool database. The field 
* is cleared when "snam@", specifying deletion, is encountered.
*
* RETURNS: 0, always.
*
* ERRNO: N/A
*
* NOMANUAL
*/

int proc_sname (int code,       /* resource code for address pool field */
                int optype,     /* operation type (addition or deletion) */
                char **symbol,  /* current location in input string */
                struct dhcp_resource *rp    /* pointer to lease descriptor */
    )
{
    char tmpstr[MAXSTRINGLEN];

    if (optype == OP_ADDITION) {
        get_string (symbol, tmpstr);
        if (strlen (tmpstr) > MAX_SNAME) {