radcli2.h

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

 
#ifndef RADCLI2_H
#define RADCLI2_H
 
#include <stdint.h>
#include <stddef.h>
#include <netinet/in.h>
#include <poll.h> /* struct pollfd, radcli_ctx_get_poll() */
#include <radcli/radcli-defs.h>
 
/* *INDENT-OFF* */
#ifdef __cplusplus
extern "C" {
#endif
/* *INDENT-ON* */


struct rc_conf;
typedef struct rc_conf radcli_ctx;

typedef enum radcli_opt_id {
#define RADCLI_OPT_ENTRY(id, name, type) RADCLI_##id,
        RC_OPTION_TABLE
#undef RADCLI_OPT_ENTRY
        RADCLI_OPT_COUNT
} radcli_opt_id;

typedef enum radcli_ctx_flags {
        RADCLI_CTX_NO_BUILTIN_DICT = 1 << 0 
} radcli_ctx_flags;
 
radcli_ctx *radcli_ctx_new(unsigned flags);
 
radcli_ctx *radcli_ctx_read_config(const char *filename, unsigned flags);
 
int radcli_ctx_set_opt_str(radcli_ctx *ctx, radcli_opt_id opt, const char *val);
 
int radcli_ctx_set_opt_int(radcli_ctx *ctx, radcli_opt_id opt, long val);
 
const char *radcli_ctx_get_opt_str(const radcli_ctx *ctx, radcli_opt_id opt);
 
int radcli_ctx_get_opt_int(const radcli_ctx *ctx, radcli_opt_id opt, long *out);
 
int radcli_ctx_apply(radcli_ctx *ctx);
 
int radcli_ctx_read_dictionary(radcli_ctx *ctx, const char *path);
 
int radcli_ctx_read_dictionary_from_buffer(radcli_ctx *ctx, const char *buf, size_t size);

typedef enum radcli_secret_target {
        RADCLI_SECRET_AUTH = 1 << 0, 
        RADCLI_SECRET_ACCT = 1 << 1  
} radcli_secret_target;
 
int radcli_ctx_set_secret(radcli_ctx *ctx, unsigned target_mask, const char *secret);
 
int radcli_ctx_set_tls_psk(radcli_ctx *ctx,
                            const void *identity, size_t identity_len,
                            const uint8_t *key, size_t keylen);
 
void radcli_ctx_free(radcli_ctx *ctx);



typedef enum radcli_attr_type {
        RADCLI_TYPE_STRING = 0,     
        RADCLI_TYPE_INTEGER = 1,    
        RADCLI_TYPE_IPADDR = 2,     
        RADCLI_TYPE_DATE = 3,       
        RADCLI_TYPE_IPV6ADDR = 4,   
        RADCLI_TYPE_IPV6PREFIX = 5, 
        RADCLI_TYPE_INTEGER64 = 6,  
        RADCLI_TYPE_IPV4PREFIX = 7, 
        RADCLI_TYPE_TEXT = 8,       
        RADCLI_TYPE_IFID = 9        
} radcli_attr_type;

struct radcli_attr_def_st;
typedef struct radcli_attr_def_st radcli_attr_def;
 
const radcli_attr_def *radcli_dict_lookup(const radcli_ctx *ctx, const char *name);
 
const radcli_attr_def *radcli_dict_lookup_oid(const radcli_ctx *ctx, const char *oid);
 
const radcli_attr_def *radcli_dict_lookup_num(const radcli_ctx *ctx, uint32_t attrid, uint32_t vendor);
 
const char *radcli_attr_def_name(const radcli_attr_def *def);
 
radcli_attr_type radcli_attr_def_type(const radcli_attr_def *def);
 
int radcli_attr_def_oid(const radcli_attr_def *def, char *buf, size_t buflen);
 
int radcli_dict_lookup_value(const radcli_ctx *ctx, const radcli_attr_def *def,
                              const char *name, uint32_t *out);



struct radcli_avp_st;
typedef struct radcli_avp_st radcli_avp;

struct radcli_avp_list_st;
typedef struct radcli_avp_list_st radcli_avp_list;
 
radcli_avp_list *radcli_avp_list_new(void);
 
void radcli_avp_list_free(radcli_avp_list *list);
 
int radcli_avp_add_bytes(radcli_avp_list *list, const radcli_attr_def *def, const void *value, size_t len);
 
int radcli_avp_add_str(radcli_avp_list *list, const radcli_attr_def *def, const char *value);
 
int radcli_avp_add_uint32(radcli_avp_list *list, const radcli_attr_def *def, uint32_t value);
 
int radcli_avp_add_uint64(radcli_avp_list *list, const radcli_attr_def *def, uint64_t value);
 
int radcli_avp_add_ip4(radcli_avp_list *list, const radcli_attr_def *def, struct in_addr value);
 
int radcli_avp_add_ip6(radcli_avp_list *list, const radcli_attr_def *def,
                        const struct in6_addr *value, unsigned prefix);
 
int radcli_avp_add_ip4prefix(radcli_avp_list *list, const radcli_attr_def *def,
                              struct in_addr value, unsigned prefix);

 
int radcli_avp_add_bytes_by_num(radcli_avp_list *list, const radcli_ctx *ctx,
                                 uint32_t attrid, uint32_t vendor,
                                 const void *value, size_t len);
 
int radcli_avp_add_str_by_num(radcli_avp_list *list, const radcli_ctx *ctx,
                               uint32_t attrid, uint32_t vendor, const char *value);
 
int radcli_avp_add_uint32_by_num(radcli_avp_list *list, const radcli_ctx *ctx,
                                  uint32_t attrid, uint32_t vendor, uint32_t value);
 
int radcli_avp_add_uint64_by_num(radcli_avp_list *list, const radcli_ctx *ctx,
                                  uint32_t attrid, uint32_t vendor, uint64_t value);
 
int radcli_avp_add_ip4_by_num(radcli_avp_list *list, const radcli_ctx *ctx,
                                  uint32_t attrid, uint32_t vendor, struct in_addr value);
 
int radcli_avp_add_ip6_by_num(radcli_avp_list *list, const radcli_ctx *ctx,
                               uint32_t attrid, uint32_t vendor,
                               const struct in6_addr *value, unsigned prefix);
 
int radcli_avp_add_ip4prefix_by_num(radcli_avp_list *list, const radcli_ctx *ctx,
                                     uint32_t attrid, uint32_t vendor,
                                     struct in_addr value, unsigned prefix);

 
int radcli_avp_add_username(radcli_avp_list *list, const radcli_ctx *ctx,
                             const char *username, const char *realm);
 
const radcli_avp *radcli_avp_get(const radcli_avp_list *list, const radcli_attr_def *def, unsigned idx);

typedef struct {
        const radcli_avp_list *list;
        const radcli_avp *cur;
} radcli_avp_iter;
 
radcli_avp_iter radcli_avp_list_iter(const radcli_avp_list *list);
 
const radcli_avp *radcli_avp_iter_next(radcli_avp_iter *it);
 
const radcli_attr_def *radcli_avp_def(const radcli_avp *a);
 
int radcli_avp_get_uint32(const radcli_avp *a, uint32_t *out);
 
int radcli_avp_get_uint64(const radcli_avp *a, uint64_t *out);
 
int radcli_avp_get_ip6(const radcli_avp *a, struct in6_addr *out, unsigned *prefix);
 
int radcli_avp_get_ip4prefix(const radcli_avp *a, struct in_addr *out, unsigned *prefix);
 
int radcli_avp_get_bytes(const radcli_avp *a, const void **out, size_t *len);
 
const char *radcli_avp_get_cstr(const radcli_avp *a);

 
const radcli_avp *radcli_avp_get_by_num(const radcli_avp_list *list, const radcli_ctx *ctx,
                                         uint32_t attrid, uint32_t vendor, unsigned idx);
 
int radcli_avp_get_uint32_by_num(const radcli_avp_list *list, const radcli_ctx *ctx,
                                  uint32_t attrid, uint32_t vendor, uint32_t *out);
 
int radcli_avp_get_uint64_by_num(const radcli_avp_list *list, const radcli_ctx *ctx,
                                  uint32_t attrid, uint32_t vendor, uint64_t *out);
 
int radcli_avp_get_ip6_by_num(const radcli_avp_list *list, const radcli_ctx *ctx,
                               uint32_t attrid, uint32_t vendor,
                               struct in6_addr *out, unsigned *prefix);
 
int radcli_avp_get_ip4prefix_by_num(const radcli_avp_list *list, const radcli_ctx *ctx,
                                     uint32_t attrid, uint32_t vendor,
                                     struct in_addr *out, unsigned *prefix);
 
int radcli_avp_get_bytes_by_num(const radcli_avp_list *list, const radcli_ctx *ctx,
                                 uint32_t attrid, uint32_t vendor,
                                 const void **out, size_t *len);
 
const char *radcli_avp_get_cstr_by_num(const radcli_avp_list *list, const radcli_ctx *ctx,
                                        uint32_t attrid, uint32_t vendor);


 
int radcli_avp_concat_str(char *buf, size_t buflen, const radcli_avp_list *list,
                           const radcli_attr_def *def, const char *sep);
 
int radcli_avp_concat_str_by_num(char *buf, size_t buflen, const radcli_avp_list *list,
                                  const radcli_ctx *ctx, uint32_t attrid, uint32_t vendor,
                                  const char *sep);

 
int radcli_avp_list_error(const radcli_avp_list *list);
 
int radcli_avp_add_gigawords64(radcli_ctx *ctx, radcli_avp_list *list,
                             const radcli_attr_def *octets, uint64_t value);
 
int radcli_avp_get_gigawords64(const radcli_ctx *ctx, const radcli_avp_list *list,
                             const radcli_attr_def *octets, uint64_t *out);
 
int radcli_avp_add_gigawords64_by_num(radcli_ctx *ctx, radcli_avp_list *list,
                                       uint32_t attrid, uint32_t vendor, uint64_t value);
 
int radcli_avp_get_gigawords64_by_num(const radcli_ctx *ctx, const radcli_avp_list *list,
                                       uint32_t attrid, uint32_t vendor, uint64_t *out);

 


typedef enum radcli_code {
        RADCLI_CODE_ACCESS_REQUEST = 1,
        RADCLI_CODE_ACCESS_ACCEPT = 2,
        RADCLI_CODE_ACCESS_REJECT = 3,
        RADCLI_CODE_ACCOUNTING_REQUEST = 4,
        RADCLI_CODE_ACCOUNTING_RESPONSE = 5,
        RADCLI_CODE_ACCESS_CHALLENGE = 11,
        /* RFC 5176 SS3: Dynamic Authorization. The legacy rc_standard_codes
         * enum (radcli.h) is not extended -- these belong to the new API
         * only, since radcli.h's request/reply path never handles them. */
        RADCLI_DISCONNECT_REQUEST = 40,
        RADCLI_DISCONNECT_ACK = 41,
        RADCLI_DISCONNECT_NAK = 42,
        RADCLI_COA_REQUEST = 43,
        RADCLI_COA_ACK = 44,
        RADCLI_COA_NAK = 45
} radcli_code;

typedef enum radcli_error_cause {
        RADCLI_ERROR_RESIDUAL_SESSION_CONTEXT_REMOVED = 201,
        RADCLI_ERROR_INVALID_EAP_PACKET = 202,
        RADCLI_ERROR_UNSUPPORTED_ATTRIBUTE = 401,
        RADCLI_ERROR_MISSING_ATTRIBUTE = 402,
        RADCLI_ERROR_NAS_IDENTIFICATION_MISMATCH = 403,
        RADCLI_ERROR_INVALID_REQUEST = 404,
        RADCLI_ERROR_UNSUPPORTED_SERVICE = 405,
        RADCLI_ERROR_UNSUPPORTED_EXTENSION = 406,
        RADCLI_ERROR_INVALID_ATTRIBUTE_VALUE = 407,
        RADCLI_ERROR_ADMINISTRATIVELY_PROHIBITED = 501,
        RADCLI_ERROR_REQUEST_NOT_ROUTABLE = 502,
        RADCLI_ERROR_SESSION_CONTEXT_NOT_FOUND = 503,
        RADCLI_ERROR_SESSION_CONTEXT_NOT_REMOVABLE = 504,
        RADCLI_ERROR_OTHER_PROXY_PROCESSING_ERROR = 505,
        RADCLI_ERROR_RESOURCES_UNAVAILABLE = 506,
        RADCLI_ERROR_REQUEST_INITIATED = 507,
        RADCLI_ERROR_MULTIPLE_SESSION_SELECTION_UNSUPPORTED = 508,
        RADCLI_ERROR_LOCATION_INFO_REQUIRED = 509,
        RADCLI_ERROR_RESPONSE_TOO_BIG = 601
} radcli_error_cause;

typedef enum radcli_result {
        RADCLI_OK = 0,        
        RADCLI_ERROR = -1,    
        RADCLI_TIMEOUT = -2,  
        RADCLI_AGAIN = -3
} radcli_result;

struct radcli_request_st;
typedef struct radcli_request_st radcli_request;

typedef enum radcli_request_flags {
        RADCLI_REQUEST_NONE = 0,
        RADCLI_REQUEST_SENDONLY = 1 << 0
} radcli_request_flags;
 
radcli_request *radcli_request_new(radcli_ctx *ctx, radcli_code code, const radcli_avp_list *send);
 
int radcli_request_perform(radcli_request *r, unsigned flags);
 
/* Poll-driven async progress for a request sent with RADCLI_REQUEST_SENDONLY:
 * drive it to completion via radcli_ctx_get_poll()/radcli_ctx_dispatch()
 * (lib/dae.c) -- r shares ctx's own descriptor(s), there is no per-request
 * accessor -- then read the outcome here; see lib/request.c's doc comment
 * for the full contract and a usage example. */
int radcli_request_done(radcli_request *r);
 
radcli_code radcli_request_code(const radcli_request *r);
 
const radcli_avp_list *radcli_request_attrs(const radcli_request *r);
 
const char *radcli_request_server(const radcli_request *r);
 
void radcli_request_free(radcli_request *r);
 
int radcli_aaa(radcli_ctx *ctx, radcli_code code, const radcli_avp_list *send,
               radcli_code *out_code, radcli_avp_list **out_attrs);



typedef struct radcli_dae_st radcli_dae;

typedef struct radcli_dae_request_st radcli_dae_request;

typedef void (*radcli_dae_handler)(radcli_dae_request *req, void *user);
 
radcli_code radcli_dae_req_code(const radcli_dae_request *req);
 
const radcli_avp_list *radcli_dae_req_attrs(const radcli_dae_request *req);
 
const char *radcli_dae_req_session_id(const radcli_dae_request *req);
 
const char *radcli_dae_req_user_name(const radcli_dae_request *req);
 
int radcli_dae_req_framed_ip(const radcli_dae_request *req, struct sockaddr_storage *out);
 
int radcli_dae_req_nas_port(const radcli_dae_request *req, uint32_t *out);
 
int radcli_dae_reply(radcli_dae_request *req, int ack);
 
int radcli_dae_reply_error(radcli_dae_request *req, uint32_t error_cause);
 
int radcli_dae_reply_to_buffer(radcli_dae_request *req, int ack, uint32_t error_cause,
                               void *buf, size_t *len);
 
void radcli_dae_request_free(radcli_dae_request *req);

#define RADCLI_DAE_NEW 0
#define RADCLI_DAE_DUPLICATE 1
 
int radcli_dae_process(radcli_dae *dae, const void *buf, size_t len,
                       const struct sockaddr *from, socklen_t fromlen,
                       radcli_dae_request **req);

typedef enum radcli_dae_flags {
        RADCLI_DAE_NO_NAS_CHECK = 1 << 0 
} radcli_dae_flags;
 
radcli_dae *radcli_dae_new(radcli_ctx *ctx, unsigned flags);
 
void radcli_dae_set_handler(radcli_dae *dae, radcli_dae_handler cb, void *user);
 
int radcli_dae_start(radcli_dae *dae);
 
void radcli_dae_free(radcli_dae *dae);

#define RADCLI_CTX_MAX_POLLFDS 2
 
int radcli_ctx_get_poll(radcli_ctx *ctx, struct pollfd *pfds, size_t max_pfds,
                        size_t *nfds, int *timeout_ms);
 
int radcli_ctx_dispatch(radcli_ctx *ctx);

 






 
/* *INDENT-OFF* */
#ifdef __cplusplus
}
#endif
/* *INDENT-ON* */
 
#endif /* RADCLI2_H */