config2.c

/*
 * Copyright (C) 2026 Nikos Mavrogiannopoulos
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


 
#include <config.h>
#include <includes.h>
#include <radcli/radcli.h>
#include <radcli/radcli2.h>
#include <options.h>
#include "util.h"

radcli_ctx *radcli_ctx_new(unsigned flags)
{
        rc_handle *rh;
 
        if (flags & ~(unsigned)RADCLI_CTX_NO_BUILTIN_DICT)
                return NULL;
 
        rh = radcli2_priv_new();
        if (rh == NULL)
                return NULL;
 
        /* radcli2_priv_config_init() already destroys rh and returns NULL on failure */
        rh = radcli2_priv_config_init(rh);
        if (rh == NULL)
                return NULL;
 
        if (!(flags & RADCLI_CTX_NO_BUILTIN_DICT) &&
            radcli2_priv_load_builtin_dict(rh) != 0) {
                radcli2_priv_destroy(rh);
                return NULL;
        }
 
        return rh;
}

radcli_ctx *radcli_ctx_read_config(const char *filename, unsigned flags)
{
        if (flags & ~(unsigned)RADCLI_CTX_NO_BUILTIN_DICT)
                return NULL;
 
        return radcli2_priv_read_config(filename, !!(flags & RADCLI_CTX_NO_BUILTIN_DICT));
}

int radcli_ctx_read_dictionary(radcli_ctx *ctx, const char *path)
{
        return radcli2_priv_read_dictionary(ctx, path);
}

int radcli_ctx_read_dictionary_from_buffer(radcli_ctx *ctx, const char *buf, size_t size)
{
        return radcli2_priv_read_dictionary_from_buffer(ctx, buf, size);
}

int radcli_ctx_apply(radcli_ctx *ctx)
{
        return radcli2_priv_apply_config(ctx);
}

void radcli_ctx_free(radcli_ctx *ctx)
{
        if (ctx != NULL)
                radcli2_priv_destroy(ctx);
}
 
/* radcli_opt_id (radcli2.h) shares its ordinal position with rc_option_id,
 * both generated from RC_OPTION_TABLE (radcli-defs.h) -- so
 * ctx->config_options[opt] is the same OPTION radcli2_priv_add_config(ctx, "the
 * option's name", ...) would look up by string. */
/*- Look up opt's OPTION table entry for ctx.
 *
 * @param ctx a context from radcli_ctx_new() or radcli_ctx_read_config().
 * @param opt the option to look up.
 * @return the option's OPTION entry, or NULL if ctx is NULL, has no
 * option table, or opt is out of range.
 -*/
static const OPTION *radcli_opt_lookup(const radcli_ctx *ctx, radcli_opt_id opt)
{
        if (ctx == NULL || ctx->config_options == NULL || (unsigned)opt >= OPT_COUNT)
                return NULL;
        return &ctx->config_options[opt];
}
 
/* radcli2.h's set_opt_* enforce a stricter contract than radcli2_priv_add_config():
 * every option, including authserver/acctserver, may be set at most once --
 * a second call fails instead of silently overwriting (RADCLI_OPT_TYPE_STR/RADCLI_OPT_TYPE_INT, which
 * radcli2_priv_add_config() itself does not actually guard against: option->status is
 * checked but never set) or accumulating into a multi-server list (RADCLI_OPT_TYPE_SRV).
 * This is what makes the new API's "one server per context" design
 * (radcli_request_new(), REQ-NET2-INIT-003) an enforced invariant instead
 * of an unenforced convention. Only applies to this typed setter path --
 * radcli_ctx_read_config() is a direct alias of radcli2_priv_read_config()
 * (REQ-CONFIG2-INIT-002) and keeps that function's existing behavior. */
/*- Report whether o already carries a value set by a previous typed setter
 * call.
 *
 * @param o the option to check.
 * @return nonzero if o is already set (or, for RADCLI_OPT_TYPE_SRV, already has a
 * configured server), zero otherwise.
 -*/
static int radcli_opt_already_set(const OPTION *o)
{
        if (o->val == NULL)
                return 0;
        if (o->type & RADCLI_OPT_TYPE_SRV)
                /* radcli2_priv_config_init() pre-allocates an empty SERVER struct for
                 * authserver/acctserver, so a non-NULL val alone does not mean
                 * a server was actually configured yet. */
                return ((SERVER *)o->val)->max > 0;
        return 1;
}

int radcli_ctx_set_opt_str(radcli_ctx *ctx, radcli_opt_id opt, const char *val)
{
        const OPTION *o = radcli_opt_lookup(ctx, opt);
 
        if (o == NULL || !(o->type & (RADCLI_OPT_TYPE_STR | RADCLI_OPT_TYPE_SRV)))
                return -1;
 
        if (radcli_opt_already_set(o)) {
                rc_log(LOG_ERR, "radcli_ctx_set_opt_str: %s is already set", o->name);
                return -1;
        }
 
        if ((o->type & RADCLI_OPT_TYPE_SRV) && val != NULL && strpbrk(val, ", \t") != NULL) {
                /* The new API carries exactly one server per role
                 * (REQ-NET2-INIT-003) -- reject a comma/whitespace-separated
                 * multi-host value in one call, the same as a second call
                 * naming another host would be rejected above. */
                rc_log(LOG_ERR, "radcli_ctx_set_opt_str: %s must name a single "
                                "server, not a list", o->name);
                return -1;
        }
 
        return radcli2_priv_add_config(ctx, o->name, val, "radcli_ctx_set_opt_str", 0);
}

int radcli_ctx_set_opt_int(radcli_ctx *ctx, radcli_opt_id opt, long val)
{
        const OPTION *o = radcli_opt_lookup(ctx, opt);
        char buf[32];
 
        if (o == NULL || !(o->type & RADCLI_OPT_TYPE_INT))
                return -1;
 
        if (radcli_opt_already_set(o)) {
                rc_log(LOG_ERR, "radcli_ctx_set_opt_int: %s is already set", o->name);
                return -1;
        }
 
        snprintf(buf, sizeof(buf), "%ld", val);
        return radcli2_priv_add_config(ctx, o->name, buf, "radcli_ctx_set_opt_int", 0);
}

const char *radcli_ctx_get_opt_str(const radcli_ctx *ctx, radcli_opt_id opt)
{
        const OPTION *o = radcli_opt_lookup(ctx, opt);
 
        if (o == NULL || !(o->type & RADCLI_OPT_TYPE_STR))
                return NULL;
        return (const char *)o->val;
}

int radcli_ctx_get_opt_int(const radcli_ctx *ctx, radcli_opt_id opt, long *out)
{
        const OPTION *o = radcli_opt_lookup(ctx, opt);
 
        if (o == NULL || !(o->type & RADCLI_OPT_TYPE_INT) || out == NULL || o->val == NULL)
                return -1;
 
        *out = *((int *)o->val);
        return 0;
}
 
/* The new API is single-server-per-context, so only the first
 * (only) entry of the SERVER list named by optname needs a secret. */
/*- Set secret on the first entry of the SERVER list named by optname.
 *
 * @param ctx a context whose optname server is already configured.
 * @param optname "authserver" or "acctserver".
 * @param secret the shared secret to copy onto that server entry.
 * @return 0 on success, -1 if that server type has not been configured
 * yet or the secret could not be duplicated.
 -*/
static int radcli_set_one_secret(radcli_ctx *ctx, const char *optname, const char *secret)
{
        SERVER *serv = radcli2_priv_conf_srv(ctx, optname);
        char *dup;
 
        if (serv == NULL || serv->max == 0)
                return -1;
 
        dup = strdup(secret);
        if (dup == NULL)
                return -1;
 
        free(serv->secret[0]);
        serv->secret[0] = dup;
        return 0;
}

int radcli_ctx_set_secret(radcli_ctx *ctx, unsigned target_mask, const char *secret)
{
        int ret = 0;
 
        if (ctx == NULL || secret == NULL || target_mask == 0 ||
            (target_mask & ~(unsigned)(RADCLI_SECRET_AUTH | RADCLI_SECRET_ACCT)))
                return -1;
 
        if (target_mask & RADCLI_SECRET_AUTH)
                ret |= radcli_set_one_secret(ctx, "authserver", secret);
        if (target_mask & RADCLI_SECRET_ACCT)
                ret |= radcli_set_one_secret(ctx, "acctserver", secret);
 
        return ret == 0 ? 0 : -1;
}

int radcli_ctx_set_tls_psk(radcli_ctx *ctx,
                            const void *identity, size_t identity_len,
                            const uint8_t *key, size_t keylen)
{
        char *id_copy;
        void *key_copy;
 
        if (ctx == NULL || identity == NULL || key == NULL || keylen == 0)
                return -1;
 
        id_copy = malloc(identity_len + 1);
        if (id_copy == NULL)
                return -1;
        memcpy(id_copy, identity, identity_len);
        id_copy[identity_len] = '\0';
 
        key_copy = malloc(keylen);
        if (key_copy == NULL) {
                free(id_copy);
                return -1;
        }
        memcpy(key_copy, key, keylen);
 
        free(ctx->tls_psk_identity);
        free(ctx->tls_psk_key);
        ctx->tls_psk_identity = id_copy;
        ctx->tls_psk_key = key_copy;
        ctx->tls_psk_key_len = keylen;
 
        return 0;
}

 /*
 * Local Variables:
 * c-basic-offset:8
 * c-style: whitesmith
 * End:
 */