rlm_dhcp.c

Go to the documentation of this file.

/*
 *   This program is is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or (at
 *   your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

/**
 * $Id: 3260f2e68b17b6fdf57eabfc809e1526354f9e1b $
 * @file rlm_dhcp.c
 * @brief Will contain dhcp listener code.
 *
 * @copyright 2012  The FreeRADIUS server project
 */
RCSID("$Id: 3260f2e68b17b6fdf57eabfc809e1526354f9e1b $")

#include <freeradius-devel/libradius.h>

#include <freeradius-devel/radiusd.h>
#include <freeradius-devel/modules.h>
#include <freeradius-devel/dhcp.h>

#include <ctype.h>

#define PW_DHCP_PARAMETER_REQUEST_LIST 55

/*
 *      Define a structure for our module configuration.
 *
 *      These variables do not need to be in a structure, but it's
 *      a lot cleaner to do so, and a pointer to the structure can
 *      be used as the instance handle.
 */
typedef struct rlm_dhcp_t {
        int nothing;
} rlm_dhcp_t;


/*
 *      Allow single attribute values to be retrieved from the dhcp.
 */
static ssize_t dhcp_options_xlat(char **out, size_t outlen,
                                 UNUSED void const *mod_inst, UNUSED void const *xlat_inst,
                                 REQUEST *request, char const *fmt)
{
        vp_cursor_t     cursor, src_cursor;
        vp_tmpl_t       src;
        VALUE_PAIR      *vp, *head = NULL;
        int             decoded = 0;
        ssize_t         slen;

        while (isspace((int) *fmt)) fmt++;

        slen = tmpl_from_attr_str(&src, fmt, REQUEST_CURRENT, PAIR_LIST_REQUEST, false, false);
        if (slen <= 0) {
                REMARKER(fmt, slen, fr_strerror());
        error:
                return -1;
        }

        if (src.type != TMPL_TYPE_ATTR) {
                REDEBUG("dhcp_options cannot operate on a %s", fr_int2str(tmpl_names, src.type, "<INVALID>"));
                goto error;
        }

        if (src.tmpl_da->type != PW_TYPE_OCTETS) {
                REDEBUG("dhcp_options got a %s attribute needed octets",
                        fr_int2str(dict_attr_types, src.tmpl_da->type, "<INVALID>"));
                goto error;
        }

        fr_cursor_init(&cursor, &head);

        for (vp = tmpl_cursor_init(NULL, &src_cursor, request, &src);
             vp;
             vp = tmpl_cursor_next(&src_cursor, &src)) {
                uint8_t const   *p = vp->vp_octets, *end = p + vp->vp_length;
                size_t          len;
                VALUE_PAIR      *vps = NULL;
                vp_cursor_t     options_cursor;

                fr_cursor_init(&options_cursor, &vps);
                /*
                 *      Loop over all the options data
                 */
                while (p < end) {
                        len = fr_dhcp_decode_option(request->packet, &options_cursor,
                                                    fr_dict_root(fr_dict_internal), p, end - p, NULL);
                        if (len <= 0) {
                                RWDEBUG("DHCP option decoding failed: %s", fr_strerror());
                                fr_pair_list_free(&head);
                                goto error;
                        }
                        p += len;
                }
                fr_cursor_merge(&cursor, vps);
        }

        for (vp = fr_cursor_first(&cursor);
             vp;
             vp = fr_cursor_next(&cursor)) {
                rdebug_pair(L_DBG_LVL_2, request, vp, "dhcp_options: ");
                decoded++;
        }

        fr_pair_list_move(request->packet, &(request->packet->vps), &head);

        /* Free any unmoved pairs */
        fr_pair_list_free(&head);

        snprintf(*out, outlen, "%i", decoded);

        return strlen(*out);
}

static ssize_t dhcp_xlat(char **out, size_t outlen,
                         UNUSED void const *mod_inst, UNUSED void const *xlat_inst,
                         REQUEST *request, char const *fmt)
{
        vp_cursor_t cursor;
        VALUE_PAIR *vp;
        uint8_t binbuf[255];
        ssize_t len;

        while (isspace((int) *fmt)) fmt++;

        if ((radius_copy_vp(request, &vp, request, fmt) < 0) || !vp) return 0;
        fr_cursor_init(&cursor, &vp);

        len = fr_dhcp_encode_option(binbuf, sizeof(binbuf), &cursor, NULL);
        talloc_free(vp);
        if (len <= 0) {
                REDEBUG("DHCP option encoding failed: %s", fr_strerror());

                return -1;
        }

        if ((size_t)((len * 2) + 1) > outlen) {
                REDEBUG("DHCP option encoding failed: Output buffer exhausted, needed %zd bytes, have %zd bytes",
                        (len * 2) + 1, outlen);

                return -1;
        }

        return fr_bin2hex(*out, binbuf, len);
}


/*
 *      Instantiate the module.
 */
static int mod_bootstrap(UNUSED CONF_SECTION *conf, void *instance)
{
        rlm_dhcp_t *inst = instance;
        fr_dict_attr_t const *da;

        xlat_register(inst, "dhcp_options", dhcp_options_xlat, NULL, NULL, 0, XLAT_DEFAULT_BUF_LEN);
        xlat_register(inst, "dhcp", dhcp_xlat, NULL, NULL, 0, XLAT_DEFAULT_BUF_LEN);

        /*
         *      Fixup dictionary entry for DHCP-Paramter-Request-List adding all the options
         */
        da = fr_dict_attr_by_num(NULL, DHCP_MAGIC_VENDOR, PW_DHCP_PARAMETER_REQUEST_LIST);
        if (da) {
                fr_dict_attr_t const *value;
                int i;

                /* No padding or termination options */
                DEBUG3("Adding values for %s", da->name);
                for (i = 1; i < 255; i++) {
                        value = fr_dict_attr_by_num(NULL, DHCP_MAGIC_VENDOR, i);
                        if (!value) {
                                DEBUG3("No DHCP RFC space attribute at %i", i);
                                continue;
                        }

                        DEBUG3("Adding %s value %i %s", da->name, i, value->name);
                        if (fr_dict_enum_add(NULL, da->name, value->name, i) < 0) {
                                DEBUG3("Failed adding value: %s", fr_strerror());
                        }
                }
        }

        return 0;
}


/*
 *      The module name should be the only globally exported symbol.
 *      That is, everything else should be 'static'.
 *
 *      If the module needs to temporarily modify it's instantiation
 *      data, the type should be changed to RLM_TYPE_THREAD_UNSAFE.
 *      The server will then take care of ensuring that the module
 *      is single-threaded.
 */
extern module_t rlm_dhcp;
module_t rlm_dhcp = {
        .magic          = RLM_MODULE_INIT,
        .name           = "dhcp",
        .inst_size      = sizeof(rlm_dhcp_t),
        .bootstrap      = mod_bootstrap,
};