#include <freeradius-devel/server/dependency.h>
#include <freeradius-devel/server/map_proc.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/radmin.h>
#include <freeradius-devel/server/state.h>
#include <freeradius-devel/server/virtual_servers.h>
#include <freeradius-devel/io/schedule.h>
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/radmin.h>
#include <freeradius-devel/util/dict.h>
rl_attempted_completion_over = 1;
- rad_assert(radmin_buffer != NULL);
- rad_assert(radmin_partial_line != NULL);
- rad_assert(radmin_partial_line >= radmin_buffer);
- rad_assert(radmin_partial_line < (radmin_buffer + 8192));
+ fr_assert(radmin_buffer != NULL);
+ fr_assert(radmin_partial_line != NULL);
+ fr_assert(radmin_partial_line >= radmin_buffer);
+ fr_assert(radmin_partial_line < (radmin_buffer + 8192));
offset = (radmin_partial_line - radmin_buffer);
while (true) {
char *line;
- rad_assert(context >= 0);
- rad_assert(context_offset[context] >= 0);
+ fr_assert(context >= 0);
+ fr_assert(context_offset[context] >= 0);
radmin_partial_line = radmin_buffer + context_offset[context];
line = readline(prompt);
if (stop) break;
if (!info->runnable) {
size_t len;
- rad_assert(argc > 0);
+ fr_assert(argc > 0);
len = strlen(line);
/*
{
CONF_ITEM *item;
- rad_assert(info->argc > 0);
+ fr_assert(info->argc > 0);
item = cf_reference_item(radmin_main_config->root_cs, radmin_main_config->root_cs,
info->box[0]->vb_strvalue);
CONF_ITEM *item;
CONF_PAIR *cp;
- rad_assert(info->argc > 0);
+ fr_assert(info->argc > 0);
item = cf_reference_item(radmin_main_config->root_cs, radmin_main_config->root_cs,
info->box[0]->vb_strvalue);
*/
if (result->error_to_data) data_used = strerror_concat(data, COMMAND_OUTPUT_MAX);
- rad_assert((size_t)data_used < COMMAND_OUTPUT_MAX);
+ fr_assert((size_t)data_used < COMMAND_OUTPUT_MAX);
data[data_used] = '\0'; /* Ensure the data buffer is \0 terminated */
if (data_used) {
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/map_proc.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/state.h>
#include <freeradius-devel/radius/defs.h>
client = client_afrom_cs(ctx, cs, NULL);
if (!client) {
PERROR("Failed creating test client");
- rad_assert(0);
+ fr_assert(0);
}
talloc_steal(client, cs);
- rad_assert(client);
+ fr_assert(client);
return client;
}
request->master_state = REQUEST_ACTIVE;
request->server_cs = virtual_server_find("default");
- rad_assert(request->server_cs != NULL);
+ fr_assert(request->server_cs != NULL);
request->config = main_config;
ERROR("Expected VALUE_PAIR pointer got \"%s\"", talloc_get_name(vp));
fr_log_talloc_report(vp);
- rad_assert(0);
+ fr_assert(0);
}
fr_log(&default_log, L_DBG, __FILE__, __LINE__, "%pP", vp);
ERROR("Expected VALUE_PAIR pointer got \"%s\"", talloc_get_name(vp));
fr_log_talloc_report(vp);
- rad_assert(0);
+ fr_assert(0);
}
fr_log(&default_log, L_DBG, __FILE__, __LINE__, "%pP", vp);
/*
* Simulate an authorize section
*/
- rad_assert(request->server_cs != NULL);
+ fr_assert(request->server_cs != NULL);
unlang = cf_section_find(request->server_cs, "recv", "Access-Request");
if (!unlang) {
REDEBUG("Failed to find 'recv Access-Request' section");
* Create a dummy event list
*/
el = fr_event_list_alloc(NULL, NULL, NULL);
- rad_assert(el != NULL);
+ fr_assert(el != NULL);
/*
* Simulate thread specific instantiation
*/
#include <freeradius-devel/curl/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/base.h>
#include <freeradius-devel/util/syserror.h>
CURL *candle = m->easy_handle;
CURLcode ret;
- rad_assert(candle);
+ fr_assert(candle);
mhandle->transfers--;
break;
default:
- rad_assert(0);
+ fr_assert(0);
return -1;
}
#define LOG_PREFIX "rlm_eap - "
#include <freeradius-devel/util/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/eap/base.h>
#include "types.h"
#include "attrs.h"
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/eap/base.h>
#include <freeradius-devel/eap/compose.h>
VALUE_PAIR *vp;
/* check input parameters */
- rad_assert((request != NULL) &&
+ fr_assert((request != NULL) &&
(chbind != NULL) &&
(chbind->request != NULL) &&
(chbind->response == NULL));
if (data_len) {
fr_cursor_t cursor;
- rad_assert(data_len <= talloc_array_length((uint8_t const *) chbind->request));
+ fr_assert(data_len <= talloc_array_length((uint8_t const *) chbind->request));
fr_cursor_init(&cursor, &fake->packet->vps);
while (data_len > 0) {
if (((eap_round->request->code == FR_EAP_CODE_REQUEST) ||
(eap_round->request->code == FR_EAP_CODE_RESPONSE)) &&
(eap_round->request->type.num == 0)) {
- rad_assert(eap_session->type >= FR_EAP_METHOD_MD5);
- rad_assert(eap_session->type < FR_EAP_METHOD_MAX);
+ fr_assert(eap_session->type >= FR_EAP_METHOD_MD5);
+ fr_assert(eap_session->type < FR_EAP_METHOD_MAX);
eap_round->request->type.num = eap_session->type;
}
* associated with the request, or it matches the one we're
* about to free.
*/
- rad_assert(!in_request || (*eap_session == in_request));
+ fr_assert(!in_request || (*eap_session == in_request));
}
#else
(void) request_data_get((*eap_session)->request, NULL, REQUEST_DATA_EAP_SESSION);
{
if (!*eap_session) return;
- rad_assert((*eap_session)->request);
+ fr_assert((*eap_session)->request);
(*eap_session)->request = NULL;
*eap_session = NULL;
}
if (!fr_cond_assert(eap_session->inst)) return NULL;
- rad_assert(!eap_session->request); /* If triggered, something didn't freeze the session */
+ fr_assert(!eap_session->request); /* If triggered, something didn't freeze the session */
eap_session->request = request;
eap_session->updated = request->packet->timestamp;
uint8_t *p;
size_t len = 1; /* Flags */
- rad_assert(request->parent); /* must be a subrequest */
+ fr_assert(request->parent); /* must be a subrequest */
/*
* First output the flags (for debugging)
default:
/* Should never enter here */
- rad_assert(0);
+ fr_assert(0);
break;
}
{
eap_tls_session_t *eap_tls_session = talloc_get_type_abort(eap_session->opaque, eap_tls_session_t);
- rad_assert(request->parent); /* must be a subrequest */
+ fr_assert(request->parent); /* must be a subrequest */
return eap_tls_compose(request, eap_session, EAP_TLS_START_SEND,
SET_START(eap_tls_session->base_flags), NULL, 0, 0);
eap_tls_session_t *eap_tls_session = talloc_get_type_abort(eap_session->opaque, eap_tls_session_t);
fr_tls_session_t *tls_session = eap_tls_session->tls_session;
- rad_assert(request->parent); /* must be a subrequest */
+ fr_assert(request->parent); /* must be a subrequest */
eap_session->finished = true;
eap_tls_session_t *eap_tls_session = talloc_get_type_abort(eap_session->opaque, eap_tls_session_t);
fr_tls_session_t *tls_session = eap_tls_session->tls_session;
- rad_assert(request->parent); /* must be a subrequest */
+ fr_assert(request->parent); /* must be a subrequest */
eap_session->finished = true;
{
eap_tls_session_t *eap_tls_session = talloc_get_type_abort(eap_session->opaque, eap_tls_session_t);
- rad_assert(request->parent); /* must be a subrequest */
+ fr_assert(request->parent); /* must be a subrequest */
RDEBUG2("ACKing Peer's TLS record fragment");
return eap_tls_compose(request, eap_session, EAP_TLS_ACK_SEND,
eap_tls_data_t *eap_tls_data;
size_t frag_len, header_len;
- rad_assert(request->parent); /* must be a subrequest */
+ fr_assert(request->parent); /* must be a subrequest */
/*
* All EAP-TLS packets must contain type and flags fields.
uint8_t *data;
size_t data_len;
- rad_assert(request->parent); /* must be a subrequest */
+ fr_assert(request->parent); /* must be a subrequest */
RDEBUG2("Continuing EAP-TLS");
eap_tls_session_t *eap_tls_session;
fr_tls_session_t *tls_session;
- rad_assert(request->parent); /* must be a subrequest */
+ fr_assert(request->parent); /* must be a subrequest */
/*
* This EAP session is associated with a TLS session
*
* @copyright 2003-2016 The FreeRADIUS server project
*/
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/dict.h>
#include <freeradius-devel/protocol/eap/aka-sim/dictionary.h>
#include <freeradius-devel/protocol/eap/aka-sim/rfc4187.h>
#include <freeradius-devel/util/base.h>
#include <freeradius-devel/util/sha1.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/tls/base.h>
return 0;
case -1:
- rad_assert(0); /* Should have been checked by encoder or decoder */
+ fr_assert(0); /* Should have been checked by encoder or decoder */
goto error;
}
}
#include <freeradius-devel/util/base.h>
#include <freeradius-devel/util/sha1.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/tls/base.h>
#include <freeradius-devel/io/test_point.h>
FR_PROTO_TRACE("Array attribute");
- rad_assert(parent->flags.array);
- rad_assert(attr_len >= 2); /* Should have been caught earlier */
+ fr_assert(parent->flags.array);
+ fr_assert(attr_len >= 2); /* Should have been caught earlier */
/*
* Arrays with fixed length members that
#ifdef __clang_analyzer__
if (!parent->parent) return -1; /* stupid static analyzers */
#endif
- rad_assert(parent->parent);
+ fr_assert(parent->parent);
/*
* Re-write the attribute to be "raw". It is
}
p += rcode;
- rad_assert(p <= end);
+ fr_assert(p <= end);
}
/*
#include <freeradius-devel/util/base.h>
#include <freeradius-devel/util/sha1.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/tls/base.h>
#include <freeradius-devel/io/test_point.h>
size_t element_len;
uint16_t actual_len;
fr_dict_attr_t const *da = da_stack->da[depth];
- rad_assert(da->flags.array);
+ fr_assert(da->flags.array);
p += 2;
value = p; /* Space for actual length */
return PAIR_ENCODE_FATAL_ERROR;
}
p += slen;
- rad_assert(p < end); /* We messed up a check somewhere in the encoder */
+ fr_assert(p < end); /* We messed up a check somewhere in the encoder */
}
eap_packet->type.length = p - buff;
break;
default:
- rad_assert(0);
+ fr_assert(0);
}
}
break;
default:
- rad_assert(0);
+ fr_assert(0);
}
}
break;
default:
- rad_assert(0);
+ fr_assert(0);
}
return 0;
break;
default:
- rad_assert(0);
+ fr_assert(0);
break;
}
break;
default:
- rad_assert(0);
+ fr_assert(0);
break;
}
break;
default:
- rad_assert(0);
+ fr_assert(0);
break;
}
switch (eap_aka_sim_session->type) {
default:
case FR_EAP_METHOD_SIM:
- rad_assert(0); /* EAP-SIM has its own Challenge state */
+ fr_assert(0); /* EAP-SIM has its own Challenge state */
break;
case FR_EAP_METHOD_AKA:
break;
default:
- rad_assert(0);
+ fr_assert(0);
break;
}
}
break;
}
- rad_assert(0);
+ fr_assert(0);
return RLM_MODULE_FAIL;
}
break;
}
- rad_assert(0);
+ fr_assert(0);
return RLM_MODULE_FAIL;
}
break;
case AKA_SIM_NO_ID_REQ: /* Should not happen */
- rad_assert(0);
+ fr_assert(0);
/* FALL-THROUGH */
case AKA_SIM_PERMANENT_ID_REQ:
break;
case AKA_SIM_NO_ID_REQ: /* Should not happen */
- rad_assert(0);
+ fr_assert(0);
/* FALL-THROUGH */
case AKA_SIM_PERMANENT_ID_REQ:
*/
static rlm_rcode_t common_eap_failure(UNUSED void *instance, UNUSED void *thread, UNUSED REQUEST *request)
{
- rad_assert(0); /* Should never actually be called */
+ fr_assert(0); /* Should never actually be called */
return RLM_MODULE_FAIL;
}
*/
static rlm_rcode_t common_eap_success(UNUSED void *instance, UNUSED void *thread, UNUSED REQUEST *request)
{
- rad_assert(0);
+ fr_assert(0);
return RLM_MODULE_FAIL;
}
break;
default:
- rad_assert(0);
+ fr_assert(0);
return RLM_MODULE_FAIL;
}
#include "base.h"
#include "attrs.h"
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
static int vector_opc_from_op(REQUEST *request, uint8_t const **out, uint8_t opc_buff[MILENAGE_OPC_SIZE],
VALUE_PAIR *list, uint8_t const ki[MILENAGE_KI_SIZE])
{
int ret;
- rad_assert(idx >= 0 && idx < 3);
- rad_assert((keys->vector_type == AKA_SIM_VECTOR_NONE) || (keys->vector_type == AKA_SIM_VECTOR_GSM));
+ fr_assert(idx >= 0 && idx < 3);
+ fr_assert((keys->vector_type == AKA_SIM_VECTOR_NONE) || (keys->vector_type == AKA_SIM_VECTOR_GSM));
switch (*src) {
default:
return 0;
default:
- rad_assert(0);
+ fr_assert(0);
return -1;
}
}
{
int ret;
- rad_assert((keys->vector_type == AKA_SIM_VECTOR_NONE) || (keys->vector_type == AKA_SIM_VECTOR_UMTS));
+ fr_assert((keys->vector_type == AKA_SIM_VECTOR_NONE) || (keys->vector_type == AKA_SIM_VECTOR_UMTS));
switch (*src) {
default:
#include <freeradius-devel/io/base.h>
#include <freeradius-devel/io/application.h>
#include <freeradius-devel/util/syserror.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
char const *fr_app_io_socket_name(TALLOC_CTX *ctx, fr_app_io_t const *app_io,
if (dst_ipaddr->af == AF_INET) {
strlcpy(dst_buf, "*", sizeof(dst_buf));
} else {
- rad_assert(dst_ipaddr->af == AF_INET6);
+ fr_assert(dst_ipaddr->af == AF_INET6);
strlcpy(dst_buf, "::", sizeof(dst_buf));
}
} else {
#include <freeradius-devel/io/channel.h>
#include <freeradius-devel/io/control.h>
#include <freeradius-devel/util/log.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#ifdef HAVE_STDATOMIC_H
# include <stdatomic.h>
requestor->stats.message_interval = RTT(requestor->stats.message_interval, message_interval);
}
- rad_assert(requestor->stats.last_write <= when);
+ fr_assert(requestor->stats.last_write <= when);
requestor->stats.last_write = when;
requestor->stats.outstanding++;
fr_channel_end_t *requestor;
fr_atomic_queue_t *aq;
- rad_assert(ch->end[TO_RESPONDER].recv != NULL);
+ fr_assert(ch->end[TO_RESPONDER].recv != NULL);
aq = ch->end[TO_REQUESTOR].aq;
requestor = &(ch->end[TO_RESPONDER]);
* we've received one more reply, and with the responders
* ACK.
*/
- rad_assert(requestor->stats.outstanding > 0);
- rad_assert(cd->live.sequence > requestor->ack);
- rad_assert(cd->live.sequence <= requestor->sequence); /* must have fewer replies than requests */
+ fr_assert(requestor->stats.outstanding > 0);
+ fr_assert(cd->live.sequence > requestor->ack);
+ fr_assert(cd->live.sequence <= requestor->sequence); /* must have fewer replies than requests */
requestor->stats.outstanding--;
requestor->ack = cd->live.sequence;
requestor->their_view_of_my_sequence = cd->live.ack;
- rad_assert(requestor->stats.last_read_other <= cd->m.when);
+ fr_assert(requestor->stats.last_read_other <= cd->m.when);
requestor->stats.last_read_other = cd->m.when;
ch->end[TO_RESPONDER].recv(ch->end[TO_RESPONDER].recv_uctx, ch, cd);
*/
if (!fr_atomic_queue_pop(aq, (void **) &cd)) return false;
- rad_assert(cd->live.sequence > responder->ack);
- rad_assert(cd->live.sequence >= responder->sequence); /* must have more requests than replies */
+ fr_assert(cd->live.sequence > responder->ack);
+ fr_assert(cd->live.sequence >= responder->sequence); /* must have more requests than replies */
responder->stats.outstanding++;
responder->ack = cd->live.sequence;
responder->their_view_of_my_sequence = cd->live.ack;
- rad_assert(responder->stats.last_read_other <= cd->m.when);
+ fr_assert(responder->stats.last_read_other <= cd->m.when);
responder->stats.last_read_other = cd->m.when;
ch->end[TO_REQUESTOR].recv(ch->end[TO_REQUESTOR].recv_uctx, ch, cd);
return -1;
}
- rad_assert(responder->stats.outstanding > 0);
+ fr_assert(responder->stats.outstanding > 0);
responder->stats.outstanding--;
responder->stats.packets++;
message_interval = when - responder->stats.last_write;
responder->stats.message_interval = RTT(responder->stats.message_interval, message_interval);
- rad_assert(responder->stats.last_write <= when);
+ fr_assert(responder->stats.last_write <= when);
responder->stats.last_write = when;
/*
* FIXME: make these limits configurable, or include
* predictions about packet processing time?
*/
- rad_assert(responder->their_view_of_my_sequence <= responder->sequence);
+ fr_assert(responder->their_view_of_my_sequence <= responder->sequence);
#if 0
if (((responder->sequence - their_view_of_my_sequence) <= 1000) &&
((when - responder->stats.last_read_other < SIGNAL_INTERVAL) ||
fr_channel_end_t *requestor;
fr_channel_t *ch;
- rad_assert(data_size == sizeof(cc));
+ fr_assert(data_size == sizeof(cc));
memcpy(&cc, data, data_size);
cs = cc.signal;
* The responder is sleeping or done. There are more
* packets available, so we signal it to wake up again.
*/
- rad_assert(ack <= requestor->sequence);
+ fr_assert(ack <= requestor->sequence);
#endif
/*
(void) fr_ring_buffer_start(rb, (uint8_t **) &m, &room);
if (room == 0) break;
- rad_assert(m != NULL);
- rad_assert(room >= sizeof(*m));
+ fr_assert(m != NULL);
+ fr_assert(room >= sizeof(*m));
- rad_assert(m->status != FR_CONTROL_MESSAGE_FREE);
+ fr_assert(m->status != FR_CONTROL_MESSAGE_FREE);
if (m->status != FR_CONTROL_MESSAGE_DONE) break;
if (!fr_atomic_queue_pop(aq, (void **) &m)) return 0;
- rad_assert(m->status == FR_CONTROL_MESSAGE_USED);
+ fr_assert(m->status == FR_CONTROL_MESSAGE_USED);
/*
* There isn't enough room to store the data, die.
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/base.h>
a = fr_heap_peek(c1->pending);
b = fr_heap_peek(c2->pending);
- rad_assert(a != NULL);
- rad_assert(b != NULL);
+ fr_assert(a != NULL);
+ fr_assert(b != NULL);
return pending_packet_cmp(a, b);
}
* the same client definition.
*/
if (a->client->connection) {
- rad_assert(a->client == b->client);
+ fr_assert(a->client == b->client);
/*
* Note that we pass the connection "client", as
return 0;
}
- rad_assert(!b->client->connection);
+ fr_assert(!b->client->connection);
/*
* Unconnected sockets must check src/dst ip/port.
}
pending = fr_heap_pop(client->pending);
- rad_assert(pending != NULL);
+ fr_assert(pending != NULL);
/*
* If the client has more packets pending, add it back to
(void) fr_heap_insert(thread->pending_clients, client);
}
- rad_assert(thread->num_pending_packets > 0);
+ fr_assert(thread->num_pending_packets > 0);
thread->num_pending_packets--;
return pending;
*/
if (!client->ht) return 0;
- rad_assert(client->use_connected);
+ fr_assert(client->use_connected);
pthread_mutex_lock(&client->mutex);
connections = fr_hash_table_num_elements(client->ht);
DEBUG("Failed to find proto_%s_%s", inst->app->name, inst->transport);
return NULL;
}
- rad_assert(dl_inst != NULL);
+ fr_assert(dl_inst != NULL);
} else {
dl_inst = talloc_init("nak");
}
case PR_CLIENT_INVALID:
case PR_CLIENT_NAK:
case PR_CLIENT_CONNECTED:
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
talloc_free(dl_inst);
return NULL;
}
/*
* Glue in the connection to the listener.
*/
- rad_assert(li->app_io == &fr_master_app_io);
+ fr_assert(li->app_io == &fr_master_app_io);
li->connected = true;
li->thread_instance = connection;
/*
* Instantiate the child, and open the socket.
*/
- rad_assert(inst->app_io->connection_set != NULL);
+ fr_assert(inst->app_io->connection_set != NULL);
if (inst->app_io->connection_set(connection->child, connection->address) < 0) {
DEBUG("Failed setting connection for socket.");
if (child) *child = ((fr_io_thread_t *)li->thread_instance)->child;
} else {
- rad_assert(connection != NULL);
+ fr_assert(connection != NULL);
*connection = li->thread_instance;
*inst = (*connection)->client->inst;
* because the packets are pending, track->reply MUST be
* NULL.
*/
- rad_assert(track->packets > 0);
+ fr_assert(track->packets > 0);
track->packets--;
/*
*/
if (track->packets == 0) {
if (track->client->inst->app_io->track_duplicates) {
- rad_assert(track->client->table != NULL);
+ fr_assert(track->client->table != NULL);
(void) rbtree_deletebydata(track->client->table, track);
}
*/
static int _client_live_free(fr_io_client_t *client)
{
- rad_assert(client->in_trie);
- rad_assert(!client->connection);
- rad_assert(fr_heap_num_elements(client->thread->alive_clients) > 0);
+ fr_assert(client->in_trie);
+ fr_assert(!client->connection);
+ fr_assert(fr_heap_num_elements(client->thread->alive_clients) > 0);
if (client->pending) TALLOC_FREE(client->pending);
}
if (pending) {
- rad_assert(buffer_len >= pending->buffer_len);
+ fr_assert(buffer_len >= pending->buffer_len);
track = pending->track;
/*
*/
if (connection &&
(connection->client->state == PR_CLIENT_PENDING)) {
- rad_assert(!connection->paused);
+ fr_assert(!connection->paused);
connection->paused = true;
(void) fr_event_filter_update(connection->el,
*/
if (!connection) {
client = fr_trie_lookup(thread->trie, &address.src_ipaddr.addr, address.src_ipaddr.prefix);
- rad_assert(!client || !client->connection);
+ fr_assert(!client || !client->connection);
} else {
client = connection->client;
/*
* We MUST be the master socket.
*/
- rad_assert(!connection);
+ fr_assert(!connection);
radclient = inst->app_io->client_find(thread->child, &address.src_ipaddr, inst->ipproto);
if (radclient) {
* Create the packet tracking table for this client.
*/
if (inst->app_io->track_duplicates) {
- rad_assert(inst->app_io->compare != NULL);
+ fr_assert(inst->app_io->compare != NULL);
MEM(client->table = rbtree_talloc_create(client, track_cmp, fr_io_track_t,
NULL, RBTREE_FLAG_NONE));
}
* per-client basis.
*/
if (client->use_connected) {
- rad_assert(client->state == PR_CLIENT_STATIC);
+ fr_assert(client->state == PR_CLIENT_STATIC);
(void) pthread_mutex_init(&client->mutex, NULL);
MEM(client->ht = fr_hash_table_create(client, connection_hash, connection_cmp, NULL));
}
have_client:
- rad_assert(client->state != PR_CLIENT_INVALID);
- rad_assert(client->state != PR_CLIENT_NAK);
+ fr_assert(client->state != PR_CLIENT_INVALID);
+ fr_assert(client->state != PR_CLIENT_NAK);
/*
* We've accepted a new connection. Go allocate it, and
* This must be the main UDP socket which creates
* connections.
*/
- rad_assert(inst->ipproto == IPPROTO_UDP);
+ fr_assert(inst->ipproto == IPPROTO_UDP);
/*
* We're using connected sockets, but this socket isn't
/*
* @todo future - what to do with duplicates?
*/
- rad_assert(!is_dup);
+ fr_assert(!is_dup);
/*
* Remember to restore this packet later.
connection = client->connection;
inst = client->inst;
- rad_assert(client->state != PR_CLIENT_STATIC);
+ fr_assert(client->state != PR_CLIENT_STATIC);
/*
* Called from the read or write functions with
if (!now) {
switch (client->state) {
case PR_CLIENT_CONNECTED:
- rad_assert(connection != NULL);
+ fr_assert(connection != NULL);
delay = inst->idle_timeout;
break;
break;
case PR_CLIENT_NAK:
- rad_assert(!connection);
+ fr_assert(!connection);
delay = inst->nak_lifetime;
break;
default:
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
return;
}
*/
if (client->state == PR_CLIENT_NAK) {
delete_client:
- rad_assert(packets == 0);
+ fr_assert(packets == 0);
/*
* It's a connected socket. Remove it from the
* dynamic client which has timed out, OR it's a
* "place-holder" client for connected sockets.
*/
- rad_assert(client->state == PR_CLIENT_PENDING);
+ fr_assert(client->state == PR_CLIENT_PENDING);
/*
* This is a dynamic client pending definition.
return;
}
- rad_assert(!connection);
- rad_assert(client->ht != NULL);
+ fr_assert(!connection);
+ fr_assert(client->ht != NULL);
/*
* Find out how many connections are using this
/*
* Delete the tracking entry.
*/
- rad_assert(track->packets > 0);
+ fr_assert(track->packets > 0);
track->packets--;
if (track->packets == 0) {
track->reply_len = 0;
}
- rad_assert(client->packets > 0);
+ fr_assert(client->packets > 0);
client->packets--;
/*
*/
if (client->state == PR_CLIENT_STATIC) return;
- rad_assert(client->state != PR_CLIENT_NAK);
- rad_assert(client->state != PR_CLIENT_PENDING);
+ fr_assert(client->state != PR_CLIENT_NAK);
+ fr_assert(client->state != PR_CLIENT_PENDING);
/*
* If necessary, call the client expiry timer to clean up
* packet, so we discard this one.
*/
if (track->timestamp != request_time) {
- rad_assert(track->packets > 0);
- rad_assert(client->packets > 0);
+ fr_assert(track->packets > 0);
+ fr_assert(client->packets > 0);
track->packets--;
client->packets--;
packets--;
return buffer_len;
}
- rad_assert(track->reply == NULL);
+ fr_assert(track->reply == NULL);
/*
* We have a NAK packet, or the request
packet_len = inst->app_io->write(child, track, request_time,
buffer, buffer_len, written);
if (packet_len > 0) {
- rad_assert(buffer_len == (size_t) packet_len);
+ fr_assert(buffer_len == (size_t) packet_len);
/*
* No need to stash the reply if we're
* not tracking duplicates.
*/
if (inst->app_io->track_duplicates) {
- rad_assert(!track->reply);
+ fr_assert(!track->reply);
MEM(track->reply = talloc_memdup(track, buffer, buffer_len));
track->reply_len = buffer_len;
}
* If there's a connected socket and no dynamic clients, then the
* client state is set to CONNECTED when the client is created.
*/
- rad_assert(inst->dynamic_clients);
+ fr_assert(inst->dynamic_clients);
/*
* The request has timed out trying to define the dynamic
client->state = PR_CLIENT_NAK;
TALLOC_FREE(client->pending);
if (client->table) TALLOC_FREE(client->table);
- rad_assert(client->packets == 0);
+ fr_assert(client->packets == 0);
/*
* If we're a connected UDP socket, allocate a
return buffer_len;
}
- rad_assert(buffer_len == sizeof(radclient));
+ fr_assert(buffer_len == sizeof(radclient));
memcpy(&radclient, buffer, sizeof(radclient));
/*
* Remove the pending client from the trie.
*/
- rad_assert(!connection);
+ fr_assert(!connection);
talloc_free(client);
return buffer_len;
}
* socket.
*/
if (connection) {
- rad_assert(connection != NULL);
- rad_assert(connection->client == client);
- rad_assert(client->connection != NULL);
+ fr_assert(connection != NULL);
+ fr_assert(connection->client == client);
+ fr_assert(client->connection != NULL);
client->state = PR_CLIENT_CONNECTED;
goto finish;
}
- rad_assert(connection == NULL);
- rad_assert(client->use_connected == false); /* we weren't sure until now */
+ fr_assert(connection == NULL);
+ fr_assert(client->use_connected == false); /* we weren't sure until now */
/*
* Disallow unsupported configurations.
* sockets. Go spawn it
*/
if (client->use_connected) {
- rad_assert(connection == NULL);
+ fr_assert(connection == NULL);
/*
fr_io_client_t, pending_id));
}
- rad_assert(client->pending_id < 0);
+ fr_assert(client->pending_id < 0);
(void) fr_heap_insert(thread->pending_clients, client);
finish:
return -1;
}
- rad_assert(inst->dynamic_submodule != NULL);
+ fr_assert(inst->dynamic_submodule != NULL);
/*
* Don't bootstrap the dynamic submodule. We're
get_inst(li, &inst, &thread, &connection, &child);
- rad_assert(child != NULL);
+ fr_assert(child != NULL);
return child->app_io->get_name(child);
}
{
fr_io_instance_t *inst = instance;
- rad_assert(inst->app_io != NULL);
+ fr_assert(inst->app_io != NULL);
if (inst->app_io->instantiate &&
(inst->app_io->instantiate(inst->app_io_instance,
MEM(trie = fr_trie_alloc(ctx));
num = talloc_array_length(allow);
- rad_assert(num > 0);
+ fr_assert(num > 0);
for (i = 0; i < num; i++) {
fr_ipaddr_t *network;
* No IO paths, so we don't initialize them.
*/
if (!inst->app_io) {
- rad_assert(!inst->dynamic_clients);
+ fr_assert(!inst->dynamic_clients);
return 0;
}
*/
int fr_message_done(fr_message_t *m)
{
- rad_assert(m->status != FR_MESSAGE_FREE);
- rad_assert(m->status != FR_MESSAGE_DONE);
+ fr_assert(m->status != FR_MESSAGE_FREE);
+ fr_assert(m->status != FR_MESSAGE_DONE);
/*
* Mark a message as freed. The originator will take
/*
* A catastrophic error.
*/
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
fr_strerror_printf("Failed marking message as done");
return -1;
(void) fr_ring_buffer_start(mr, (uint8_t **) &m, &size);
if (size == 0) break;
- rad_assert(m != NULL);
- rad_assert(size >= ms->message_size);
+ fr_assert(m != NULL);
+ fr_assert(size >= ms->message_size);
- rad_assert(m->status != FR_MESSAGE_FREE);
+ fr_assert(m->status != FR_MESSAGE_FREE);
if (m->status != FR_MESSAGE_DONE) break;
messages_cleaned++;
cleaned = fr_message_ring_gc(ms, ms->mr_array[i], max_to_clean - total_cleaned);
total_cleaned += cleaned;
- rad_assert(total_cleaned <= max_to_clean);
+ fr_assert(total_cleaned <= max_to_clean);
/*
* Stop when we've reached our GC limit.
* and free all smaller ones which are empty.
*/
for (i = ms->mr_max; i >= 0; i--) {
- rad_assert(ms->mr_array[i] != NULL);
+ fr_assert(ms->mr_array[i] != NULL);
if (arrays_used < 2) {
MPRINT("\tleaving entry %d alone\n", i);
*/
if (empty_slot < 0) continue;
- rad_assert(ms->mr_array[empty_slot] == NULL);
+ fr_assert(ms->mr_array[empty_slot] == NULL);
ms->mr_array[empty_slot] = ms->mr_array[i];
ms->mr_array[i] = NULL;
MPRINT("NUM RB ARRAYS NOW %d\n", ms->mr_max + 1);
for (i = 0; i <= ms->mr_max; i++) {
MPRINT("\t%d %p\n", i, ms->mr_array[i]);
- rad_assert(ms->mr_array[i] != NULL);
+ fr_assert(ms->mr_array[i] != NULL);
}
#endif
}
arrays_freed = 0;
MPRINT("TRYING TO FREE ARRAYS %d\n", ms->rb_max);
for (i = ms->rb_max; i >= 0; i--) {
- rad_assert(ms->rb_array[i] != NULL);
+ fr_assert(ms->rb_array[i] != NULL);
if (arrays_used < 2) {
MPRINT("\tleaving entry %d alone\n", i);
*/
if (empty_slot < 0) continue;
- rad_assert(ms->rb_array[empty_slot] == NULL);
+ fr_assert(ms->rb_array[empty_slot] == NULL);
ms->rb_array[empty_slot] = ms->rb_array[i];
ms->rb_array[i] = NULL;
MPRINT("NUM RB ARRAYS NOW %d\n", ms->rb_max + 1);
for (i = 0; i <= ms->rb_max; i++) {
MPRINT("\t%d %p\n", i, ms->rb_array[i]);
- rad_assert(ms->rb_array[i] != NULL);
+ fr_assert(ms->rb_array[i] != NULL);
}
#endif
}
for (i = 0; i < ms->rb_max; i++) {
size_t free_size;
- rad_assert(ms->rb_array[i] != NULL);
+ fr_assert(ms->rb_array[i] != NULL);
free_size = (fr_ring_buffer_size(ms->rb_array[i]) -
fr_ring_buffer_used(ms->rb_array[i]));
}
ms->rb_current = largest_free_slot;
- rad_assert(ms->rb_current >= 0);
- rad_assert(ms->rb_current <= ms->rb_max);
+ fr_assert(ms->rb_current >= 0);
+ fr_assert(ms->rb_current <= ms->rb_max);
}
/** Allocate a message from a message ring.
* And... we go through a bunch of hoops, all over again.
*/
m->rb = ms->rb_array[ms->rb_current];
- rad_assert(m->rb != NULL);
+ fr_assert(m->rb != NULL);
m->data = fr_ring_buffer_reserve(m->rb, m->rb_size);
if (m->data) return m;
* Try to allocate the packet from the newly current ring buffer.
*/
m->rb = ms->rb_array[ms->rb_current];
- rad_assert(m->rb != NULL);
+ fr_assert(m->rb != NULL);
m->data = fr_ring_buffer_reserve(m->rb, m->rb_size);
if (m->data) return m;
*/
for (i = ms->rb_max; i >= 0; i--) {
m->rb = ms->rb_array[i];
- rad_assert(m->rb != NULL);
+ fr_assert(m->rb != NULL);
m->data = fr_ring_buffer_reserve(m->rb, m->rb_size);
if (m->data) {
MPRINT("MOVED TO RING BUFFER %d\n", i);
if (!m) return NULL;
}
- rad_assert(m->status == FR_MESSAGE_USED);
- rad_assert(m->rb != NULL);
- rad_assert(m->data != NULL);
- rad_assert(m->data_size == 0);
- rad_assert(m->rb_size >= actual_packet_size);
+ fr_assert(m->status == FR_MESSAGE_USED);
+ fr_assert(m->rb != NULL);
+ fr_assert(m->data != NULL);
+ fr_assert(m->data_size == 0);
+ fr_assert(m->rb_size >= actual_packet_size);
p = fr_ring_buffer_alloc(m->rb, actual_packet_size);
- rad_assert(p != NULL);
+ fr_assert(p != NULL);
if (!p) {
fr_strerror_printf_push("Failed allocating from ring buffer");
return NULL;
}
- rad_assert(p == m->data);
+ fr_assert(p == m->data);
/*
* The caller can change m->data size to something a bit
/* m is NOT talloc'd */
- rad_assert(m->status == FR_MESSAGE_USED);
- rad_assert(m->rb != NULL);
- rad_assert(m->data != NULL);
- rad_assert(m->rb_size >= actual_packet_size);
+ fr_assert(m->status == FR_MESSAGE_USED);
+ fr_assert(m->rb != NULL);
+ fr_assert(m->data != NULL);
+ fr_assert(m->rb_size >= actual_packet_size);
p = fr_ring_buffer_alloc(m->rb, actual_packet_size);
- rad_assert(p != NULL);
+ fr_assert(p != NULL);
if (!p) {
fr_strerror_printf_push("Failed allocating from ring buffer");
return NULL;
}
- rad_assert(p == m->data);
+ fr_assert(p == m->data);
m_rb_size = m->rb_size; /* for ring buffer cleanups */
if (!m) return NULL;
}
- rad_assert(m->status == FR_MESSAGE_USED);
- rad_assert(m->rb != NULL);
- rad_assert(m->data != NULL);
- rad_assert(m->data_size == 0);
- rad_assert(m->rb_size >= actual_packet_size);
+ fr_assert(m->status == FR_MESSAGE_USED);
+ fr_assert(m->rb != NULL);
+ fr_assert(m->data != NULL);
+ fr_assert(m->data_size == 0);
+ fr_assert(m->rb_size >= actual_packet_size);
/*
* Align the address and the actual packet size.
aligned_size = MS_ALIGN(aligned_size);
p = fr_ring_buffer_alloc(m->rb, aligned_size);
- rad_assert(p != NULL);
+ fr_assert(p != NULL);
if (!p) {
fr_strerror_printf_push("Failed allocating from ring buffer");
return NULL;
}
- rad_assert(p == m->data);
- rad_assert((aligned_p + aligned_size) <= (m->data + m->rb_size));
+ fr_assert(p == m->data);
+ fr_assert((aligned_p + aligned_size) <= (m->data + m->rb_size));
/*
* Set the aligned pointer, the total aligned size, and
break;
case FR_CHANNEL_DATA_READY_REQUESTOR:
- rad_assert(ch != NULL);
+ fr_assert(ch != NULL);
while (fr_channel_recv_reply(ch));
break;
case FR_CHANNEL_DATA_READY_RESPONDER:
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
break;
case FR_CHANNEL_OPEN:
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
break;
case FR_CHANNEL_CLOSE:
cd = s->cd;
}
- rad_assert(cd->m.data != NULL);
- rad_assert(cd->m.rb_size >= 256);
+ fr_assert(cd->m.data != NULL);
+ fr_assert(cd->m.rb_size >= 256);
next_message:
/*
if (!next) {
PERROR("Failed reserving partial packet.");
// @todo - probably close the socket...
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
}
}
(void) talloc_get_type_abort(nr, fr_network_t);
- rad_assert(s->pending != NULL);
+ fr_assert(s->pending != NULL);
/*
* @todo - this code is much the same as in
cd = fr_heap_pop(s->waiting)) {
int rcode;
- rad_assert(li == cd->listen);
- rad_assert(cd->m.status == FR_MESSAGE_LOCALIZED);
+ fr_assert(li == cd->listen);
+ fr_assert(cd->m.status == FR_MESSAGE_LOCALIZED);
rcode = li->app_io->write(li, cd->packet_ctx,
cd->reply.request_time,
size_t size;
int num_messages;
- rad_assert(data_size == sizeof(s->listen));
+ fr_assert(data_size == sizeof(s->listen));
if (data_size != sizeof(s->listen)) return;
s = talloc_zero(nr, fr_network_socket_t);
- rad_assert(s != NULL);
+ fr_assert(s != NULL);
s->nr = nr;
memcpy(&s->listen, data, sizeof(s->listen));
fr_app_io_t const *app_io;
fr_event_vnode_func_t funcs = { .extend = fr_network_vnode_extend };
- rad_assert(data_size == sizeof(s->listen));
+ fr_assert(data_size == sizeof(s->listen));
if (data_size != sizeof(s->listen)) return;
s = talloc_zero(nr, fr_network_socket_t);
- rad_assert(s != NULL);
+ fr_assert(s != NULL);
s->nr = nr;
memcpy(&s->listen, data, sizeof(s->listen));
fr_worker_t *worker;
fr_network_worker_t *w;
- rad_assert(data_size == sizeof(worker));
+ fr_assert(data_size == sizeof(worker));
memcpy(&worker, data, data_size);
(void) talloc_get_type_abort(worker, fr_worker_t);
/*
* Run out of room to put workers!
*/
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
}
/** Handle a network control message callback for a packet sent to a socket
fr_network_inject_t my_inject;
fr_network_socket_t *s;
- rad_assert(data_size == sizeof(my_inject));
+ fr_assert(data_size == sizeof(my_inject));
memcpy(&my_inject, data, data_size);
s = rbtree_finddata(nr->sockets, &(fr_network_socket_t){ .listen = my_inject.listen });
continue;
}
- rad_assert(s->outstanding > 0);
+ fr_assert(s->outstanding > 0);
s->outstanding--;
/*
return;
}
- rad_assert(buff = 1);
+ fr_assert(buff = 1);
/*
* fr_network_stop() will signal the workers
#include <stdint.h>
#include <string.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/io/queue.h>
struct fr_queue_s {
* Simple block of used elements, copy it.
*/
if (fq->head > fq->tail) {
- rad_assert(fq->num == (fq->head - fq->tail));
+ fr_assert(fq->num == (fq->head - fq->tail));
memcpy(&nq->entry[0], &fq->entry[fq->tail], &fq->entry[fq->head] - &fq->entry[fq->tail]);
nq->head = fq->num;
nq->num = fq->num;
memcpy(&nq->entry[0], &fq->entry[fq->tail], &fq->entry[fq->size] - &fq->entry[fq->tail]);
nq->head = fq->size - fq->tail;
- rad_assert((nq->head + fq->head) == fq->num);
+ fr_assert((nq->head + fq->head) == fq->num);
memcpy(&nq->entry[nq->head], &fq->entry[0], &fq->entry[fq->head] - &fq->entry[0]);
nq->head = fq->num;
fq->entry[fq->head++] = data;
if (fq->head >= fq->size) fq->head = 0;
fq->num++;
- rad_assert(fq->num <= fq->size);
+ fr_assert(fq->num <= fq->size);
}
return room;
#include <freeradius-devel/io/ring_buffer.h>
#include <freeradius-devel/util/strerror.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <string.h>
/*
return NULL;
}
- rad_assert(rb->write_offset == rb->data_end);
+ fr_assert(rb->write_offset == rb->data_end);
/*
* Data fits at the end of the ring buffer.
return NULL;
}
- rad_assert(rb->write_offset == rb->data_end);
+ fr_assert(rb->write_offset == rb->data_end);
/*
* Data fits at the end of the ring buffer.
if (!size_to_free) return 0;
}
- rad_assert(rb->write_offset == rb->data_end);
+ fr_assert(rb->write_offset == rb->data_end);
block_size = rb->data_end - rb->data_start;
if (rb->write_offset < rb->data_start) {
size = rb->write_offset;
} else {
- rad_assert(rb->write_offset == rb->data_end);
+ fr_assert(rb->write_offset == rb->data_end);
size = 0;
}
goto done;
}
- rad_assert(sc->sn);
- rad_assert(fr_dlist_num_elements(&sc->workers) > 0);
+ fr_assert(sc->sn);
+ fr_assert(fr_dlist_num_elements(&sc->workers) > 0);
/*
* If the network thread is running, tell it to exit, and
extern "C" {
#endif
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/time.h>
typedef enum {
*/
#define ASSERT_ON_TIME_TRAVEL(_tt, _now) \
do { \
- rad_assert((_tt)->last_changed <= (_now)); \
- rad_assert((_tt)->started <= (_now)); \
- rad_assert((_tt)->ended <= (_now)); \
- rad_assert((_tt)->last_yielded <= (_now)); \
- rad_assert((_tt)->last_resumed <= (_now)); \
+ fr_assert((_tt)->last_changed <= (_now)); \
+ fr_assert((_tt)->started <= (_now)); \
+ fr_assert((_tt)->ended <= (_now)); \
+ fr_assert((_tt)->last_yielded <= (_now)); \
+ fr_assert((_tt)->last_resumed <= (_now)); \
} while(0);
/** Set the last time a tracked entity started in its list of parents
static inline CC_HINT(nonnull) void fr_time_tracking_start(fr_time_tracking_t *parent,
fr_time_tracking_t *tt, fr_time_t now)
{
- rad_assert(tt->state == FR_TIME_TRACKING_STOPPED);
- rad_assert(!tt->parent);
+ fr_assert(tt->state == FR_TIME_TRACKING_STOPPED);
+ fr_assert(!tt->parent);
ASSERT_ON_TIME_TRAVEL(tt, now);
{
fr_time_delta_t run_time;
- rad_assert(parent->parent = tt->parent);
+ fr_assert(parent->parent = tt->parent);
- rad_assert(tt->state == FR_TIME_TRACKING_RUNNING);
+ fr_assert(tt->state == FR_TIME_TRACKING_RUNNING);
run_time = now - tt->last_changed;
tt->last_changed = parent->started = now;
{
fr_time_delta_t run_time;
- rad_assert(tt->state == FR_TIME_TRACKING_RUNNING);
+ fr_assert(tt->state == FR_TIME_TRACKING_RUNNING);
run_time = now - tt->last_changed;
tt->last_changed = tt->parent->ended = now;
ASSERT_ON_TIME_TRAVEL(tt, now);
- rad_assert(tt->state == FR_TIME_TRACKING_RUNNING);
+ fr_assert(tt->state == FR_TIME_TRACKING_RUNNING);
tt->state = FR_TIME_TRACKING_YIELDED;
tt->last_yielded = tt->last_changed = now;
ASSERT_ON_TIME_TRAVEL(tt, now);
- rad_assert(tt->state == FR_TIME_TRACKING_YIELDED);
+ fr_assert(tt->state == FR_TIME_TRACKING_YIELDED);
tt->state = FR_TIME_TRACKING_RUNNING;
tt->last_resumed = tt->last_changed = now;
{
fr_time_delta_t run_time;
- rad_assert(tt->state == FR_TIME_TRACKING_RUNNING);
+ fr_assert(tt->state == FR_TIME_TRACKING_RUNNING);
ASSERT_ON_TIME_TRAVEL(tt, now);
tt->state = FR_TIME_TRACKING_STOPPED;
return;
case FR_CHANNEL_DATA_READY_REQUESTOR:
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
break;
case FR_CHANNEL_DATA_READY_RESPONDER:
- rad_assert(ch != NULL);
+ fr_assert(ch != NULL);
if (!fr_channel_recv_request(ch)) {
worker->was_sleeping = was_sleeping;
break;
case FR_CHANNEL_OPEN:
- rad_assert(ch != NULL);
+ fr_assert(ch != NULL);
ok = false;
for (i = 0; i < worker->max_channels; i++) {
- rad_assert(worker->channel[i] != ch);
+ fr_assert(worker->channel[i] != ch);
if (worker->channel[i] != NULL) continue;
ms = fr_message_set_create(worker, worker->message_set_size,
sizeof(fr_channel_data_t),
worker->ring_buffer_size);
- rad_assert(ms != NULL);
+ fr_assert(ms != NULL);
fr_channel_responder_uctx_add(ch, ms);
worker->num_channels++;
break;
case FR_CHANNEL_CLOSE:
- rad_assert(ch != NULL);
+ fr_assert(ch != NULL);
ok = false;
ms = fr_channel_responder_uctx_get(ch);
fr_channel_responder_ack_close(ch);
- rad_assert(ms != NULL);
+ fr_assert(ms != NULL);
fr_message_set_gc(ms);
talloc_free(ms);
worker->channel[i] = NULL;
- rad_assert(worker->num_channels > 0);
+ fr_assert(worker->num_channels > 0);
worker->num_channels--;
ok = true;
break;
}
ms = fr_channel_responder_uctx_get(ch);
- rad_assert(ms != NULL);
+ fr_assert(ms != NULL);
size = listen->app_io->default_reply_size;
if (!size) size = listen->app_io->default_message_size;
* Allocate a default message size.
*/
reply = (fr_channel_data_t *) fr_message_reserve(ms, size);
- rad_assert(reply != NULL);
+ fr_assert(reply != NULL);
/*
* Encode a NAK
/*
* If we're sending a reply, then it's no longer runnable.
*/
- rad_assert(request->runnable_id < 0);
+ fr_assert(request->runnable_id < 0);
/*
* If it's a fake request, or we're exiting, don't send a
* Allocate and send the reply.
*/
ch = request->async->channel;
- rad_assert(ch != NULL);
+ fr_assert(ch != NULL);
/*
* If the channel has been closed, but we haven't
}
ms = fr_channel_responder_uctx_get(ch);
- rad_assert(ms != NULL);
+ fr_assert(ms != NULL);
reply = (fr_channel_data_t *) fr_message_reserve(ms, size);
- rad_assert(reply != NULL);
+ fr_assert(reply != NULL);
/*
* Encode it, if required.
*
* This will ALWAYS return the same message as we put in.
*/
- rad_assert((size_t) slen <= reply->m.rb_size);
+ fr_assert((size_t) slen <= reply->m.rb_size);
(void) fr_message_alloc(ms, &reply->m, slen);
}
* The request is done. Track that.
*/
fr_time_tracking_end(&worker->predicted, &request->async->tracking, now);
- rad_assert(worker->num_active > 0);
+ fr_assert(worker->num_active > 0);
worker->num_active--;
/*
if (request->runnable_id >= 0) (void) fr_heap_extract(worker->runnable, request);
finished:
- rad_assert(request->time_order_id < 0);
- rad_assert(request->runnable_id < 0);
+ fr_assert(request->time_order_id < 0);
+ fr_assert(request->runnable_id < 0);
#ifndef NDEBUG
request->async->el = NULL;
MEM(request->packet = fr_radius_alloc(request, false));
request->packet->timestamp = cd->request.recv_time; /* Legacy - Remove once everything looks at request->async */
request->reply = fr_radius_alloc(request, false);
- rad_assert(request->reply != NULL);
+ fr_assert(request->reply != NULL);
request->async = talloc_zero(request, fr_async_t);
* Receive a message to the worker queue, and decode it
* to a request.
*/
- rad_assert(cd->listen != NULL);
+ fr_assert(cd->listen != NULL);
request->server_cs = cd->listen->server_cs;
/*
goto insert_new;
}
- rad_assert(old->async->listen == request->async->listen);
- rad_assert(old->async->channel == request->async->channel);
+ fr_assert(old->async->listen == request->async->listen);
+ fr_assert(old->async->channel == request->async->channel);
/*
* There's a new packet. Do we keep the old one,
RWARN("Got conflicting packet for request (%" PRIu64 "), telling old request to stop", old->number);
worker_stop_request(worker, old, now);
- rad_assert(worker->num_active > 0);
+ fr_assert(worker->num_active > 0);
worker->num_active--;
worker->stats.dropped++;
talloc_free(old);
* strict time priority. Once they are in the list, they
* are only removed when the request is done / free'd.
*/
- rad_assert(request->time_order_id < 0);
+ fr_assert(request->time_order_id < 0);
(void) fr_heap_insert(worker->time_order, request);
/*
fr_time_tracking_start(&worker->tracking, &request->async->tracking, now);
fr_time_tracking_yield(&request->async->tracking, now);
worker->num_active++;
- rad_assert(request->runnable_id < 0);
+ fr_assert(request->runnable_id < 0);
(void) fr_heap_insert(worker->runnable, request);
if (!worker->ev_cleanup) worker_max_request_timer(worker);
if (!request) return;
REQUEST_VERIFY(request);
- rad_assert(request->runnable_id < 0);
+ fr_assert(request->runnable_id < 0);
fr_time_tracking_resume(&request->async->tracking, now);
- rad_assert(request->parent == NULL);
- rad_assert(request->async->process != NULL);
- rad_assert(request->async->listen != NULL);
- rad_assert(request->runnable_id < 0); /* removed from the runnable heap */
+ fr_assert(request->parent == NULL);
+ fr_assert(request->async->process != NULL);
+ fr_assert(request->async->listen != NULL);
+ fr_assert(request->runnable_id < 0); /* removed from the runnable heap */
RDEBUG("Running request");
worker_stop_request(worker, request, now);
talloc_free(request);
}
- rad_assert(fr_heap_num_elements(worker->runnable) == 0);
+ fr_assert(fr_heap_num_elements(worker->runnable) == 0);
/*
* Signal the channels that we're closing.
(void) talloc_get_type_abort(worker, fr_worker_t);
(void) talloc_get_type_abort(worker->aq_control, fr_atomic_queue_t);
- rad_assert(worker->control != NULL);
+ fr_assert(worker->control != NULL);
(void) talloc_get_type_abort(worker->control, fr_control_t);
- rad_assert(worker->el != NULL);
+ fr_assert(worker->el != NULL);
(void) talloc_get_type_abort(worker->el, fr_event_list_t);
- rad_assert(worker->runnable != NULL);
+ fr_assert(worker->runnable != NULL);
(void) talloc_get_type_abort(worker->runnable, fr_heap_t);
- rad_assert(worker->dedup != NULL);
+ fr_assert(worker->dedup != NULL);
(void) talloc_get_type_abort(worker->dedup, rbtree_t);
for (i = 0; i < worker->max_channels; i++) {
* @copyright 2015 Network RADIUS SARL (legal@networkradius.com)
* @copyright 2015 The FreeRADIUS Server Project
*/
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "base.h"
#define SELECTOR_INDEX_UNSET INT32_MAX
{
struct array_list *array_obj; /* Because array_list is a global... */
- rad_assert(selector->slice[0] != SELECTOR_INDEX_UNSET);
+ fr_assert(selector->slice[0] != SELECTOR_INDEX_UNSET);
if (!fr_json_object_is_type(object, json_type_array)) return 0;
array_obj = json_object_get_array(object);
* Descending
*/
if (step < 0) for (i = start; (i > end) && (i >= 0); i += step) {
- rad_assert((i >= 0) && (i < (int32_t)(array_obj->length & INT32_MAX)));
+ fr_assert((i >= 0) && (i < (int32_t)(array_obj->length & INT32_MAX)));
ret = jpath_evaluate(ctx, tail, dst_type, dst_enumv,
array_obj->array[i], node->next);
if (ret < 0) return ret;
* Ascending
*/
} else for (i = start; (i < end) && (i < (int32_t)(array_obj->length & INT32_MAX)); i += step) {
- rad_assert((i >= 0) && (i < (int32_t)(array_obj->length & INT32_MAX)));
+ fr_assert((i >= 0) && (i < (int32_t)(array_obj->length & INT32_MAX)));
ret = jpath_evaluate(ctx, tail, dst_type, dst_enumv,
array_obj->array[i], node->next);
if (ret < 0) return ret;
break;
default:
- rad_assert(0);
+ fr_assert(0);
return -1;
}
return child_matched ? 1 : 0;
} else if (fr_json_object_is_type(object, json_type_object)) {
json_object_object_foreach(object, field_name, field_value) {
#ifndef NDEBUG
- rad_assert(field_name);
+ fr_assert(field_name);
#else
UNUSED_VAR(field_name);
#endif
*/
json_object_object_foreach(object, field_name, field_value) {
#ifndef NDEBUG
- rad_assert(field_name);
+ fr_assert(field_name);
#else
UNUSED_VAR(field_name);
#endif
case JPATH_SELECTOR_INVALID:
case JPATH_SELECTOR_ROOT:
case JPATH_SELECTOR_CURRENT:
- rad_assert(0);
+ fr_assert(0);
return -1; /* Not yet implemented */
}
break;
default:
- rad_assert(0);
+ fr_assert(0);
return -1;
}
break;
default:
- rad_assert(0); /* Not yet implemented */
+ fr_assert(0); /* Not yet implemented */
break;
}
p = talloc_strdup_append_buffer(p, "]");
break;
case JPATH_SELECTOR_INVALID:
- rad_assert(0);
+ fr_assert(0);
return NULL;
}
}
p += slen;
if (p == end) goto missing_terminator;
- rad_assert(p < end);
+ fr_assert(p < end);
/*
* Things that terminate a selector
}
p += slen;
if (p == end) return p - in; /* The end of string! */
- rad_assert(p < end);
+ fr_assert(p < end);
}
break;
}
p += slen;
if (p == end) return p - in; /* The end of string! */
- rad_assert(p < end);
+ fr_assert(p < end);
break;
default:
* @copyright 2015,2020 Network RADIUS SARL (legal@networkradius.com)
* @copyright 2015 The FreeRADIUS Server Project
*/
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "base.h"
fr_table_num_sorted_t const fr_json_format_table[] = {
fr_value_box_t vb_str;
int is_enum = 0;
- rad_assert(vp);
+ fr_assert(vp);
vb = &vp->data;
if (format && format->value.enum_as_int) {
is_enum = fr_pair_value_enum_box(&vb, vp);
- rad_assert(is_enum >= 0);
+ fr_assert(is_enum >= 0);
}
if (format && format->value.always_string) {
{
bool ret = true;
- rad_assert(format);
+ fr_assert(format);
switch (format->output_mode) {
case JSON_MODE_OBJECT:
}
/* If we get here, something has gone wrong */
- rad_assert(0);
+ fr_assert(0);
return false;
}
char buf[FR_DICT_ATTR_MAX_NAME_LEN + 32];
/* Check format and type */
- rad_assert(format);
- rad_assert(format->output_mode == JSON_MODE_OBJECT);
+ fr_assert(format);
+ fr_assert(format->output_mode == JSON_MODE_OBJECT);
MEM(obj = json_object_new_object());
json_type type;
/* Check format and type */
- rad_assert(format);
- rad_assert(format->output_mode == JSON_MODE_OBJECT_SIMPLE);
+ fr_assert(format);
+ fr_assert(format->output_mode == JSON_MODE_OBJECT_SIMPLE);
MEM(obj = json_object_new_object());
char buf[FR_DICT_ATTR_MAX_NAME_LEN + 32];
/* Check format and type */
- rad_assert(format);
- rad_assert(format->output_mode == JSON_MODE_ARRAY);
+ fr_assert(format);
+ fr_assert(format->output_mode == JSON_MODE_ARRAY);
MEM(obj = json_object_new_array());
struct json_object *obj;
/* Check format and type */
- rad_assert(format);
- rad_assert(format->output_mode == JSON_MODE_ARRAY_OF_VALUES);
+ fr_assert(format);
+ fr_assert(format->output_mode == JSON_MODE_ARRAY_OF_VALUES);
MEM(obj = json_object_new_array());
char buf[FR_DICT_ATTR_MAX_NAME_LEN + 32];
/* Check format and type */
- rad_assert(format);
- rad_assert(format->output_mode == JSON_MODE_ARRAY_OF_NAMES);
+ fr_assert(format);
+ fr_assert(format->output_mode == JSON_MODE_ARRAY_OF_NAMES);
MEM(obj = json_object_new_array());
break;
default:
/* This should never happen */
- rad_assert(0);
+ fr_assert(0);
}
MEM(p = json_object_to_json_string_ext(obj, JSON_C_TO_STRING_PLAIN));
USES_APPLE_DEPRECATED_API
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#define LOG_PREFIX "%s - "
#define LOG_PREFIX_ARGS handle_config->name
* Stupid messy API
*/
if (lib_errno != LDAP_SUCCESS) {
- rad_assert(!ctrls || !*ctrls);
+ fr_assert(!ctrls || !*ctrls);
ldap_get_option(conn->handle, LDAP_OPT_ERROR_NUMBER, &lib_errno);
}
int msgid = -1;
- rad_assert(*pconn && (*pconn)->handle);
+ fr_assert(*pconn && (*pconn)->handle);
#ifndef WITH_SASL
- rad_assert(!sasl || !sasl->mech);
+ fr_assert(!sasl || !sasl->mech);
#endif
if (DEBUG_ENABLED4 || (request && RDEBUG_ENABLED4)) {
NUM_ELEMENTS(our_clientctrls),
*pconn, serverctrls, clientctrls);
- rad_assert(*pconn && (*pconn)->handle);
+ fr_assert(*pconn && (*pconn)->handle);
if (DEBUG_ENABLED4 || (request && RDEBUG_ENABLED4)) {
fr_ldap_timeout_debug(request, *pconn, 0, __FUNCTION__);
NULL, NULL);
if (status != LDAP_PROC_SUCCESS) return LDAP_PROC_ERROR;
- rad_assert(*pconn);
+ fr_assert(*pconn);
(*pconn)->rebound = false;
}
NUM_ELEMENTS(our_clientctrls),
*pconn, serverctrls, clientctrls);
- rad_assert(*pconn && (*pconn)->handle);
+ fr_assert(*pconn && (*pconn)->handle);
if (DEBUG_ENABLED4 || (request && RDEBUG_ENABLED4)) fr_ldap_timeout_debug(request, *pconn, 0, __FUNCTION__);
NULL, NULL);
if (status != LDAP_PROC_SUCCESS) return LDAP_PROC_ERROR;
- rad_assert(*pconn);
+ fr_assert(*pconn);
(*pconn)->rebound = false;
}
NUM_ELEMENTS(our_clientctrls),
*pconn, serverctrls, clientctrls);
- rad_assert(*pconn && (*pconn)->handle);
+ fr_assert(*pconn && (*pconn)->handle);
if (RDEBUG_ENABLED4) fr_ldap_timeout_debug(request, *pconn, 0, __FUNCTION__);
return LDAP_PROC_ERROR;
}
- rad_assert(*pconn);
+ fr_assert(*pconn);
(*pconn)->rebound = false;
}
USES_APPLE_DEPRECATED_API
#include <freeradius-devel/ldap/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
/** Holds arguments for the bind operation
*
USES_APPLE_DEPRECATED_API
#include <freeradius-devel/ldap/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#if LDAP_SET_REBIND_PROC_ARGS == 3
/** Callback for OpenLDAP to rebind and chase referrals
conn->referred = true;
conn->rebound = true; /* not really, but oh well... */
- rad_assert(handle == conn->handle);
+ fr_assert(handle == conn->handle);
DEBUG("Rebinding to URL %s", url);
LDAP *handle = NULL;
int ldap_errno, ldap_version;
- rad_assert(config->server);
+ fr_assert(config->server);
#ifdef HAVE_LDAP_INITIALIZE
ldap_errno = ldap_initialize(&handle, config->server);
USES_APPLE_DEPRECATED_API
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/ldap/base.h>
/* NMAS error codes */
int err = 0;
BerElement *reply_ber = NULL;
- rad_assert(out != NULL);
- rad_assert(outlen != NULL);
+ fr_assert(out != NULL);
+ fr_assert(outlen != NULL);
if ((reply_ber = ber_init(reply_bv)) == NULL) {
err = NMAS_E_SYSTEM_RESOURCES;
USES_APPLE_DEPRECATED_API
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/ldap/base.h>
/** Callback for map_to_request
break;
default:
- rad_assert(0);
+ fr_assert(0);
}
*out = head;
USES_APPLE_DEPRECATED_API
#include <freeradius-devel/ldap/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <sasl/sasl.h>
/** Holds arguments for the bind operation
#define LOG_PREFIX "%s - "
#define LOG_PREFIX_ARGS handle_config->name
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/ldap/base.h>
USES_APPLE_DEPRECATED_API
#include <freeradius-devel/ldap/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
/** Holds arguments for the start_tls operation
*
*
*/
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/cf_parse.h>
#include <freeradius-devel/util/fifo.h>
{
char const *p;
- rad_assert(node->pending_addr.ipaddr.af);
+ fr_assert(node->pending_addr.ipaddr.af);
/*
* Write out the IP address and Port in string form
if (fr_inet_pton_port(&ipaddr, &port, p, redirect->len - (p - redirect->str), AF_UNSPEC, false, true) < 0) {
return FR_REDIS_CLUSTER_RCODE_BAD_INPUT;
}
- rad_assert(ipaddr.af);
+ fr_assert(ipaddr.af);
if (key_slot) *key_slot = key;
if (node_addr) {
do { \
int _ret; \
_ret = fr_inet_pton(&_addr.ipaddr, _map->element[0]->str, _map->element[0]->len, AF_UNSPEC, false, true);\
- rad_assert(_ret == 0);\
+ fr_assert(_ret == 0);\
_addr.port = _map->element[1]->integer; \
} while (0)
#else
rollback[r++] = (_node)->id; \
} while (0)
- rad_assert(reply->type == REDIS_REPLY_ARRAY);
+ fr_assert(reply->type == REDIS_REPLY_ARRAY);
memset(&rollback, 0, sizeof(rollback));
memset(active, 0, sizeof(active));
if (cluster->node[i].is_active) {
/* Sanity check for duplicates that are active */
found = rbtree_finddata(cluster->used_nodes, &cluster->node[i]);
- rad_assert(found);
- rad_assert(found->is_active);
- rad_assert(found->id == i);
+ fr_assert(found);
+ fr_assert(found->is_active);
+ fr_assert(found->id == i);
}
#endif
/*
* Sanity checks
*/
- rad_assert(((talloc_array_length(cluster->node) - 1) - rbtree_num_elements(cluster->used_nodes)) ==
+ fr_assert(((talloc_array_length(cluster->node) - 1) - rbtree_num_elements(cluster->used_nodes)) ==
fr_fifo_num_elements(cluster->free_nodes));
return FR_REDIS_CLUSTER_RCODE_SUCCESS;
cluster_nodes_live_t *live = uctx;
fr_redis_cluster_node_t *node = data;
- rad_assert(node->pool);
+ fr_assert(node->pool);
if (live->skip == node->id) return 0; /* Skip the dead node */
rbtree_walk(cluster->used_nodes, RBTREE_IN_ORDER, _cluster_pool_walk, live);
pthread_mutex_unlock(&cluster->mutex);
- rad_assert(live->next); /* There should be at least one */
+ fr_assert(live->next); /* There should be at least one */
if (live->next == 1) goto no_alts; /* Weird, but conceivable */
now = fr_time();
* to save memory...
*/
node = &cluster->node[live->node[pivot].id];
- rad_assert(live->node[pivot].id == node->id);
+ fr_assert(live->node[pivot].id == node->id);
RDEBUG2("Selected node %i (using random value %i)", node->id, find);
conn = fr_pool_connection_get(node->pool, request);
uint8_t first, i;
int used_nodes;
- rad_assert(cluster);
- rad_assert(state);
- rad_assert(conn);
+ fr_assert(cluster);
+ fr_assert(state);
+ fr_assert(conn);
memset(state, 0, sizeof(*state));
fr_redis_cluster_t *cluster, REQUEST *request,
fr_redis_rcode_t status, redisReply **reply)
{
- rad_assert(state && state->node && state->node->pool);
- rad_assert(conn && *conn);
+ fr_assert(state && state->node && state->node->pool);
+ fr_assert(conn && *conn);
if (*reply) fr_redis_reply_print(L_DBG_LVL_3, *reply, request, 0);
* trigger a cluster remap.
*/
case REDIS_RCODE_MOVE:
- rad_assert(*reply);
+ fr_assert(*reply);
if (*conn && (fr_redis_cluster_remap(request, cluster, *conn) != FR_REDIS_CLUSTER_RCODE_SUCCESS)) {
RDEBUG2("%s", fr_strerror());
pthread_mutex_unlock(&cluster->mutex);
hostname = inet_ntop(node_addr->ipaddr.af, &node_addr->ipaddr.addr, buffer, sizeof(buffer));
- rad_assert(hostname); /* addr.ipaddr is probably corrupt */;
+ fr_assert(hostname); /* addr.ipaddr is probably corrupt */;
fr_strerror_printf("No existing node found with address %s, port %i",
hostname, node_addr->port);
return -1;
/*
* Sanity checks
*/
- rad_assert(((talloc_array_length(cluster->node) - 1) - rbtree_num_elements(cluster->used_nodes)) ==
+ fr_assert(((talloc_array_length(cluster->node) - 1) - rbtree_num_elements(cluster->used_nodes)) ==
fr_fifo_num_elements(cluster->free_nodes));
pthread_mutex_unlock(&cluster->mutex);
int num_nodes;
fr_redis_cluster_t *cluster;
- rad_assert(triggers_enabled || !trigger_prefix);
- rad_assert(triggers_enabled || !trigger_args);
+ fr_assert(triggers_enabled || !trigger_prefix);
+ fr_assert(triggers_enabled || !trigger_args);
cluster = talloc_zero(NULL, fr_redis_cluster_t);
if (!cluster) {
*/
#include <freeradius-devel/redis/io.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <hiredis/async.h>
{
fr_redis_sqn_ignore_t *ignore;
- rad_assert(sqn <= h->rsp_sqn);
+ fr_assert(sqn <= h->rsp_sqn);
MEM(ignore = talloc_zero(h, fr_redis_sqn_ignore_t));
ignore->sqn = sqn;
fr_redis_sqn_t check = h->rsp_sqn++;
fr_redis_sqn_ignore_t *head;
- rad_assert(h->rsp_sqn <= h->req_sqn); /* Can't have more responses than requests */
+ fr_assert(h->rsp_sqn <= h->req_sqn); /* Can't have more responses than requests */
head = fr_dlist_head(&h->ignore);
if (!head || (head->sqn > check)) return true; /* First response to ignore is some time after this one */
- rad_assert(head->sqn == check);
+ fr_assert(head->sqn == check);
fr_dlist_remove(&h->ignore, head);
talloc_free(head);
}
case FR_TRUNK_CANCEL_REASON_NONE:
- rad_assert(0);
+ fr_assert(0);
return;
}
}
* @copyright 2011 TekSavvy Solutions (gabe@teksavvy.com)
*/
#include <freeradius-devel/redis/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
fr_table_num_sorted_t const redis_reply_types[] = {
{ "array", REDIS_REPLY_ARRAY },
break;
case REDIS_REPLY_ARRAY:
- rad_assert(0);
+ fr_assert(0);
}
if (fr_value_box_cast(ctx, out, dst_type, dst_enumv, &in) < 0) return -1;
size_t key_len;
size_t need;
- rad_assert(tmpl_is_attr(map->lhs));
- rad_assert(tmpl_is_data(map->rhs));
+ fr_assert(tmpl_is_attr(map->lhs));
+ fr_assert(tmpl_is_data(map->rhs));
key_len = tmpl_snprint(&need, key_buf, sizeof(key_buf), map->lhs);
if (need) {
fr_redis_rcode_t status = REDIS_RCODE_SUCCESS;
redisReply *reply = NULL;
- rad_assert(out_len >= (size_t)*pipelined);
+ fr_assert(out_len >= (size_t)*pipelined);
fr_strerror(); /* Clear any outstanding errors */
fr_redis_rcode_t status;
char *p, *q;
- rad_assert(out_len > 0);
+ fr_assert(out_len > 0);
out[0] = '\0';
reply = redisCommand(conn->handle, "INFO SERVER");
}
p = strchr(p, ':');
- rad_assert(p);
+ fr_assert(p);
p++;
q = strstr(p, "\r\n");
fr_box_time_delta(io_time),
(uint32_t)(stats->enqueued / ((float)io_time / NSEC)));
- rad_assert(fr_dlist_num_elements(completed) == stats->enqueued);
+ fr_assert(fr_dlist_num_elements(completed) == stats->enqueued);
}
static void _command_failed(REQUEST *request, fr_dlist_head_t *completed, void *rctx)
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/rcode.h>
#include <freeradius-devel/server/state.h>
#include <freeradius-devel/io/listen.h>
#ifdef __clang_analyzer__
if (!request->parent) return RLM_MODULE_FAIL;
#endif
- rad_assert(request->parent != NULL);
+ fr_assert(request->parent != NULL);
request->async = talloc_memdup(request, request->parent->async, sizeof(fr_async_t));
talloc_set_name_const(request->async, talloc_get_name(request->parent->async));
#include <freeradius-devel/server/cf_priv.h>
#include <freeradius-devel/server/log.h>
#include <freeradius-devel/server/cond.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/util.h>
#include <freeradius-devel/util/cursor.h>
CONF_SECTION *subcs1, *subcs2;
subcs1 = cf_item_to_section(ci);
- rad_assert(subcs1 != NULL);
+ fr_assert(subcs1 != NULL);
subcs2 = cf_section_find(cs, subcs1->name1, subcs1->name2);
if (subcs2) {
top = cf_root(cs);
tree = cf_data_value(cf_data_find(top, rbtree_t, "filename"));
- rad_assert(tree);
+ fr_assert(tree);
/*
* If we're including a wildcard directory, then ignore
cp = cf_item_to_pair(ci);
if (!cp->value || !cp->pass2) continue;
- rad_assert((cp->rhs_quote == T_BARE_WORD) ||
+ fr_assert((cp->rhs_quote == T_BARE_WORD) ||
(cp->rhs_quote == T_DOUBLE_QUOTED_STRING) ||
(cp->rhs_quote == T_BACK_QUOTED_STRING));
return -1;
}
- rad_assert(frame->braces > 0);
+ fr_assert(frame->braces > 0);
frame->braces--;
/*
* Reset which frame we're looking at.
*/
frame = &stack->frame[stack->depth];
- rad_assert(frame->type == CF_STACK_FILE);
+ fr_assert(frame->type == CF_STACK_FILE);
break;
#endif
} while (rcode == 1);
}
- rad_assert(frame->fp != NULL);
+ fr_assert(frame->fp != NULL);
/*
* See if EOF was unexpected.
#include <freeradius-devel/server/cf_parse.h>
#include <freeradius-devel/server/cf_priv.h>
#include <freeradius-devel/server/log.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/tmpl.h>
#include <freeradius-devel/util/inet.h>
return 0;
default:
- rad_assert(0);
+ fr_assert(0);
return -1;
}
}
cant_be_empty = (type & FR_TYPE_NOT_EMPTY);
tmpl = (type & FR_TYPE_TMPL);
- rad_assert(cp);
- rad_assert(!(type & FR_TYPE_ATTRIBUTE) || tmpl); /* Attribute flag only valid for templates */
- rad_assert((type & FR_TYPE_ON_READ) == 0);
+ fr_assert(cp);
+ fr_assert(!(type & FR_TYPE_ATTRIBUTE) || tmpl); /* Attribute flag only valid for templates */
+ fr_assert((type & FR_TYPE_ON_READ) == 0);
if (required) cant_be_empty = true; /* May want to review this in the future... */
* It's not an error parsing the configuration
* file.
*/
- rad_assert(type > FR_TYPE_INVALID);
- rad_assert(type < FR_TYPE_MAX);
+ fr_assert(type > FR_TYPE_INVALID);
+ fr_assert(type < FR_TYPE_MAX);
cf_log_err(cp, "type '%s' (%i) is not supported in the configuration files",
fr_table_str_by_value(fr_value_box_type_table, type, "?Unknown?"), type);
CONF_PAIR *cp;
char buffer[8192];
- rad_assert(dflt);
+ fr_assert(dflt);
type = FR_BASE_TYPE(type);
char const *dflt = rule->dflt;
FR_TOKEN dflt_quote = rule->quote;
- rad_assert(!(type & FR_TYPE_TMPL) || !dflt || (dflt_quote != T_INVALID)); /* We ALWAYS need a quoting type for templates */
+ fr_assert(!(type & FR_TYPE_TMPL) || !dflt || (dflt_quote != T_INVALID)); /* We ALWAYS need a quoting type for templates */
multi = (type & FR_TYPE_MULTI);
required = (type & FR_TYPE_REQUIRED);
break;
case FR_TYPE_VOID:
- rad_assert(rule->func);
+ fr_assert(rule->func);
array = (void **)talloc_zero_array(ctx, void *, count);
break;
uint8_t **array = NULL;
- rad_assert(type & FR_TYPE_SUBSECTION);
+ fr_assert(type & FR_TYPE_SUBSECTION);
subcs = cf_section_find(cs, rule->name, rule->ident2);
if (!subcs) return 0;
return 0;
}
- rad_assert(subcs_size);
+ fr_assert(subcs_size);
/*
* Handle the multi subsection case (which is harder)
case TMPL_TYPE_REGEX:
case TMPL_TYPE_REGEX_STRUCT:
case TMPL_TYPE_NULL:
- rad_assert(0);
+ fr_assert(0);
/* Don't add default */
}
cd = cf_data_find(CF_TO_ITEM(cs), CONF_PARSER, rule->name);
old = cf_data_value(cd);
- rad_assert(old != NULL);
+ fr_assert(old != NULL);
/*
* Shut up about duplicates.
#include <freeradius-devel/server/cf_priv.h>
#include <freeradius-devel/server/cf_util.h>
#include <freeradius-devel/server/log.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/cursor.h>
break;
case CONF_ITEM_PAIR:
- rad_assert((ident2 == NULL) || IS_WILDCARD(ident2));
+ fr_assert((ident2 == NULL) || IS_WILDCARD(ident2));
memset(&cp_find, 0, sizeof(cp_find));
cp_find.item.type = CONF_ITEM_PAIR;
break;
case CONF_ITEM_PAIR:
- rad_assert((ident2 == NULL) || IS_WILDCARD(ident2));
+ fr_assert((ident2 == NULL) || IS_WILDCARD(ident2));
memset(&cp_find, 0, sizeof(cp_find));
cp_find.item.type = CONF_ITEM_PAIR;
for (ci = prev->next;
ci && (_cf_ident1_cmp(ci, find) != 0);
ci = ci->next) {
- rad_assert(ci->next != ci);
+ fr_assert(ci->next != ci);
}
return ci;
fr_cursor_t to_merge;
CONF_ITEM *ci;
- rad_assert(parent != child);
+ fr_assert(parent != child);
if (!parent || !child) return;
in_ident1 = (rbtree_finddata(parent->ident1, child) == child);
if (in_ident1 && (!rbtree_deletebydata(parent->ident1, child))) {
- rad_assert(0);
+ fr_assert(0);
return NULL;
}
in_ident2 = (rbtree_finddata(parent->ident2, child) == child);
if (in_ident2 && (!rbtree_deletebydata(parent->ident2, child))) {
- rad_assert(0);
+ fr_assert(0);
return NULL;
}
if (ci == NULL) return NULL;
- rad_assert(ci->type == CONF_ITEM_PAIR);
+ fr_assert(ci->type == CONF_ITEM_PAIR);
memcpy(&out, &ci, sizeof(out));
return out;
if (ci == NULL) return NULL;
- rad_assert(ci->type == CONF_ITEM_SECTION);
+ fr_assert(ci->type == CONF_ITEM_SECTION);
memcpy(&out, &ci, sizeof(out));
return out;
if (ci == NULL) return NULL;
- rad_assert(ci->type == CONF_ITEM_DATA);
+ fr_assert(ci->type == CONF_ITEM_DATA);
memcpy(&out, &ci, sizeof(out));
return out;
break;
case CONF_ITEM_INVALID:
- rad_assert(0);
+ fr_assert(0);
}
}
{
CONF_PAIR *cp;
- rad_assert(fr_equality_op[op] || fr_assignment_op[op]);
+ fr_assert(fr_equality_op[op] || fr_assignment_op[op]);
if (!attr) return NULL;
cp = talloc_zero(parent, CONF_PAIR);
{
CONF_PAIR *new;
- rad_assert(parent);
- rad_assert(cp);
+ fr_assert(parent);
+ fr_assert(cp);
new = cf_pair_alloc(parent, cp->attr, cf_pair_value(cp), cp->op, cp->lhs_quote, cp->rhs_quote);
if (!new) return NULL;
#include <freeradius-devel/server/cf_parse.h>
#include <freeradius-devel/server/client.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/virtual_servers.h>
#include <freeradius-devel/server/cf_file.h>
#include <freeradius-devel/protocol/freeradius/freeradius.internal.h>
return clients->v4_udp;
}
- rad_assert(ipaddr->af == AF_INET6);
+ fr_assert(ipaddr->af == AF_INET6);
if (proto == IPPROTO_TCP) return clients->v6_tcp;
break;
default:
- rad_assert(0);
+ fr_assert(0);
}
fr_inet_ntop_prefix(buffer, sizeof(buffer), &client->ipaddr);
if (!clients) clients = root_clients;
- rad_assert(client->ipaddr.prefix <= 128);
+ fr_assert(client->ipaddr.prefix <= 128);
#ifdef WITH_TRIE
trie = clients_trie(clients, &client->ipaddr, client->proto);
#include <freeradius-devel/server/command.h>
#include <freeradius-devel/server/log.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/misc.h>
return -1;
}
- rad_assert(cmd->func == NULL);
+ fr_assert(cmd->func == NULL);
start = &(cmd->child);
}
* can probably allow it.
*/
if (!table->func) {
- rad_assert(table->help != NULL);
+ fr_assert(table->help != NULL);
/*
* Suppress duplicates.
cmd->name);
return -1;
}
- rad_assert(cmd->intermediate);
+ fr_assert(cmd->intermediate);
cmd->help = table->help;
cmd->read_only = table->read_only;
return 0;
/*
* Allocate cmd and insert it into the current point.
*/
- rad_assert(insert != NULL);
+ fr_assert(insert != NULL);
cmd = fr_command_alloc(talloc_ctx, insert, table->name);
}
* the next command at the current level.
*/
if (cmd->child) {
- rad_assert(stack->depth < CMD_MAX_ARGV);
+ fr_assert(stack->depth < CMD_MAX_ARGV);
info.parents[stack->depth] = cmd->name;
stack->depth++;
stack->entry[stack->depth] = cmd->child;
if (stack->depth == 0) {
if (!cmd) goto done;
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
}
/*
return count;
}
- rad_assert(argv->type == FR_TYPE_FIXED);
+ fr_assert(argv->type == FR_TYPE_FIXED);
/*
* Not a full match, but we're at the last
}
if (cmd->intermediate) {
- rad_assert(cmd->child != NULL);
+ fr_assert(cmd->child != NULL);
start = cmd->child;
continue;
}
*
* Skip the name
*/
- rad_assert(cmd->func != NULL);
+ fr_assert(cmd->func != NULL);
return fr_command_tab_expand_syntax(ctx, cmd, i + 1, info, max_expansions, expansions);
}
* be child commands under that hierarchy. In which
* case, show them as expansions.
*/
- rad_assert(i == info->argc);
- rad_assert(cmd->child != NULL);
+ fr_assert(i == info->argc);
+ fr_assert(cmd->child != NULL);
for (i = 0, cmd = cmd->child; (i < max_expansions) && (cmd != NULL); i++, cmd = cmd->next) {
expansions[i] = cmd->name;
fr_cmd_t *start, *cmd = NULL;
fr_cmd_info_t my_info;
- rad_assert(head->intermediate);
- rad_assert(head->child != NULL);
+ fr_assert(head->intermediate);
+ fr_assert(head->child != NULL);
start = head->child;
/*
* Wildcard '*' is at 'offset + 1'. Then the command to run is at 'offset + 2'.
*/
- rad_assert(info->argc >= (offset + 2));
+ fr_assert(info->argc >= (offset + 2));
/*
* Loop from "start", trying to find a matching command.
/*
* Leaf nodes must have a callback.
*/
- rad_assert(cmd->func != NULL);
+ fr_assert(cmd->func != NULL);
// @todo - add cmd->min_argc && cmd->max_argc, to track optional things, varargs, etc.
for (i = 0; i < info->argc; i++) {
cmd = info->cmd[i];
- rad_assert(cmd != NULL);
+ fr_assert(cmd != NULL);
if (cmd->added_name && (info->argv[i][0] == '*')) {
- rad_assert(i > 0);
+ fr_assert(i > 0);
for (; cmd != NULL; cmd = cmd->next) {
if (!cmd->live) continue;
/*
* Leaf nodes must have a callback.
*/
- rad_assert(cmd->func != NULL);
+ fr_assert(cmd->func != NULL);
// @todo - add cmd->min_argc && cmd->max_argc, to track optional things, varargs, etc.
if (!cmd) return NULL;
if (cmd->intermediate) {
- rad_assert(cmd->child != NULL);
+ fr_assert(cmd->child != NULL);
start = cmd->child;
continue;
}
if ((options & FR_COMMAND_OPTION_LIST_CHILD) != 0) {
if (!head->child) {
- rad_assert(head->func != NULL);
+ fr_assert(head->func != NULL);
// @todo - skip syntax_argv as necessary
fr_command_list_node(fp, head, 0, argv, options);
return;
TALLOC_CTX *ctx = NULL;
redo:
- rad_assert(argv->type != FR_TYPE_ALTERNATE_CHOICE);
+ fr_assert(argv->type != FR_TYPE_ALTERNATE_CHOICE);
/*
* Don't eat too many arguments.
*/
if ((start + used) >= argc) {
- rad_assert(argv != NULL);
+ fr_assert(argv != NULL);
/*
* Skip trailing optional pieces.
for (child = argv->child; child != NULL; child = child->next) {
fr_cmd_argv_t *sub;
- rad_assert(child->type == FR_TYPE_ALTERNATE_CHOICE);
- rad_assert(child->child != NULL);
+ fr_assert(child->type == FR_TYPE_ALTERNATE_CHOICE);
+ fr_assert(child->child != NULL);
sub = child->child;
rcode = fr_command_verify_argv(info, start + used, verify, argc, &sub, true);
goto no_match;
}
- rad_assert(type < FR_TYPE_FIXED);
+ fr_assert(type < FR_TYPE_FIXED);
/*
* Don't re-verify things we've already verified.
* An already-parsed data type. Skip it.
*/
if (argc < info->argc) {
- rad_assert(info->box[argc] != NULL);
+ fr_assert(info->box[argc] != NULL);
word = p;
argc++;
goto next;
for (child = argv->child; child != NULL; child = child->next) {
fr_cmd_argv_t *sub;
- rad_assert(child->type == FR_TYPE_ALTERNATE_CHOICE);
- rad_assert(child->child != NULL);
+ fr_assert(child->type == FR_TYPE_ALTERNATE_CHOICE);
+ fr_assert(child->child != NULL);
sub = child->child;
/*
*/
for (argc = 0; argc < info->argc; argc++) {
cmd = info->cmd[argc];
- rad_assert(cmd != NULL);
+ fr_assert(cmd != NULL);
fr_skip_whitespace(word);
* some special circumstances.
*/
if ((word[0] == '*') && isspace(word[1]) && cmd->added_name) {
- rad_assert(cmd->intermediate);
- rad_assert(cmd->child != NULL);
+ fr_assert(cmd->intermediate);
+ fr_assert(cmd->child != NULL);
info->argv[argc] = "*";
info->cmd[argc] = cmd;
}
if (cmd->intermediate) {
- rad_assert(cmd->child != NULL);
+ fr_assert(cmd->child != NULL);
info->argv[argc] = cmd->name;
info->cmd[argc] = cmd;
word = p;
return -1;
}
- rad_assert(cmd->func != NULL);
- rad_assert(cmd->child == NULL);
+ fr_assert(cmd->func != NULL);
+ fr_assert(cmd->child == NULL);
check_syntax:
/*
for (child = argv->child; child != NULL; child = child->next) {
fr_cmd_argv_t *sub;
- rad_assert(child->type == FR_TYPE_ALTERNATE_CHOICE);
- rad_assert(child->child != NULL);
+ fr_assert(child->type == FR_TYPE_ALTERNATE_CHOICE);
+ fr_assert(child->child != NULL);
sub = child->child;
count = expand_all(cmd, info, sub, count, max_expansions, expansions);
for (child = argv->child; child != NULL; child = child->next) {
fr_cmd_argv_t *sub;
- rad_assert(child->type == FR_TYPE_ALTERNATE_CHOICE);
- rad_assert(child->child != NULL);
+ fr_assert(child->type == FR_TYPE_ALTERNATE_CHOICE);
+ fr_assert(child->child != NULL);
sub = child->child;
count = expand_all(cmd, info, sub, count, max_expansions, expansions);
info->box[info->argc] = NULL;
info->argc++;
- rad_assert(count == 0);
+ fr_assert(count == 0);
rcode = cmd->tab_expand(NULL, cmd->ctx, info, max_expansions - count, expansions + count);
if (rcode < 0) return rcode;
fr_cmd_argv_t *sub;
char const *my_word = word;
- rad_assert(child->type == FR_TYPE_ALTERNATE_CHOICE);
- rad_assert(child->child != NULL);
+ fr_assert(child->type == FR_TYPE_ALTERNATE_CHOICE);
+ fr_assert(child->child != NULL);
sub = child->child;
/*
/*
* Expand this thing.
*/
- rad_assert(count == 0);
+ fr_assert(count == 0);
rcode = cmd->tab_expand(NULL, cmd->ctx, info, max_expansions - count, expansions + count);
if (rcode < 0) return rcode;
return count + rcode;
/*
* This should be the only remaining data type.
*/
- rad_assert(argv->type == FR_TYPE_FIXED);
+ fr_assert(argv->type == FR_TYPE_FIXED);
SKIP_NAME(argv->name);
}
if (cmd->intermediate) {
- rad_assert(cmd->child != NULL);
+ fr_assert(cmd->child != NULL);
word = p;
cmd = cmd->child;
if (cmd->intermediate) {
intermediate:
- rad_assert(cmd->child != NULL);
+ fr_assert(cmd->child != NULL);
word = p;
cmd = cmd->child;
continue;
#include <freeradius-devel/server/cond.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/paircmp.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/regex.h>
#include <ctype.h>
{
char const *p = string;
- rad_assert(p != NULL);
+ fr_assert(p != NULL);
if (*p == '\0') return false;
*/
case TMPL_TYPE_REGEX:
case TMPL_TYPE_REGEX_STRUCT:
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
/* FALL-THROUGH */
default:
VALUE_PAIR *vp;
EVAL_DEBUG("CMP WITH PAIRCOMPARE");
- rad_assert(tmpl_is_attr(map->lhs));
+ fr_assert(tmpl_is_attr(map->lhs));
MEM(vp = fr_pair_afrom_da(request, map->lhs->tmpl_da));
vp->op = c->data.map->op;
* Magic attribute is always the LHS.
*/
if (c->pass2_fixup == PASS2_PAIRCOMPARE) {
- rad_assert(!c->cast);
- rad_assert(tmpl_is_attr(map->lhs));
- rad_assert(!tmpl_is_attr(map->rhs) || !paircmp_find(map->rhs->tmpl_da)); /* expensive assert */
+ fr_assert(!c->cast);
+ fr_assert(tmpl_is_attr(map->lhs));
+ fr_assert(!tmpl_is_attr(map->rhs) || !paircmp_find(map->rhs->tmpl_da)); /* expensive assert */
cast = map->lhs->tmpl_da;
}
data.type = FR_TYPE_STRING;
- rad_assert(data.vb_strvalue);
+ fr_assert(data.vb_strvalue);
rhs = &data;
case TMPL_TYPE_UNKNOWN:
case TMPL_TYPE_ATTR_UNDEFINED:
case TMPL_TYPE_REGEX: /* Should now be a TMPL_TYPE_REGEX_STRUCT or TMPL_TYPE_XLAT_STRUCT */
- rad_assert(0);
+ fr_assert(0);
rcode = -1;
break;
}
*/
if ((c->pass2_fixup == PASS2_PAIRCOMPARE) && (map->op != T_OP_REG_EQ)) {
#ifndef NDEBUG
- rad_assert(paircmp_find(map->lhs->tmpl_da)); /* expensive assert */
+ fr_assert(paircmp_find(map->lhs->tmpl_da)); /* expensive assert */
#endif
rcode = cond_normalise_and_cmp(request, c, NULL);
break;
data.vb_strvalue = map->lhs->name;
data.datum.length = map->lhs->len;
}
- rad_assert(data.vb_strvalue);
+ fr_assert(data.vb_strvalue);
data.type = FR_TYPE_STRING;
rcode = cond_normalise_and_cmp(request, c, &data);
case TMPL_TYPE_UNKNOWN:
case TMPL_TYPE_REGEX: /* should now be a TMPL_TYPE_REGEX_STRUCT or TMPL_TYPE_XLAT_STRUCT */
case TMPL_TYPE_REGEX_STRUCT: /* not allowed as LHS */
- rad_assert(0);
+ fr_assert(0);
rcode = -1;
break;
}
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/cond_eval.h>
#include <freeradius-devel/server/cond.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <ctype.h>
switch (c->type) {
case COND_TYPE_EXISTS:
- rad_assert(c->data.vpt != NULL);
+ fr_assert(c->data.vpt != NULL);
if (c->cast) {
len = snprintf(p, end - p, "<%s>", fr_table_str_by_value(fr_value_box_type_table,
c->cast->type, "??"));
break;
case COND_TYPE_MAP:
- rad_assert(c->data.map != NULL);
+ fr_assert(c->data.map != NULL);
#if 0
*(p++) = '['; /* for extra-clear debugging */
#endif
break;
case COND_TYPE_CHILD:
- rad_assert(c->data.child != NULL);
+ fr_assert(c->data.child != NULL);
*(p++) = '(';
len = cond_snprint(need, p, (end - p) - 1, c->data.child); /* -1 for proceeding ')' */
if (*need) return len;
}
if (c->next_op == COND_NONE) {
- rad_assert(c->next == NULL);
+ fr_assert(c->next == NULL);
*p = '\0';
return p - out;
}
RETURN_IF_TRUNCATED(need, len, p, out, end);
} else {
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
}
c = c->next;
c = talloc_zero(ctx, fr_cond_t);
- rad_assert(c != NULL);
+ fr_assert(c != NULL);
lhs_type = rhs_type = T_INVALID;
fr_skip_whitespace(p);
return_P(fr_strerror());
}
- rad_assert(!tmpl_is_regex(c->data.vpt));
+ fr_assert(!tmpl_is_regex(c->data.vpt));
if (tmpl_define_unknown_attr(c->data.vpt) < 0) {
p = lhs - tlen;
* Got flags all the way to the end of the string
*/
case 0:
- rad_assert(flen >= 0);
+ fr_assert(flen >= 0);
slen += (size_t)flen;
break;
* Found non-flag, this is OK.
*/
case -1:
- rad_assert(flen <= 0);
+ fr_assert(flen <= 0);
fr_strerror(); /* Clear out the error buffer */
slen += (size_t)(-flen);
break;
case -2:
- rad_assert(flen <= 0);
+ fr_assert(flen <= 0);
p = rhs + rhs_len + 1;
p += (size_t)(-flen);
return_P("Duplicate flag");
tmpl_is_data(c->data.map->rhs)) {
int rcode;
- rad_assert(c->cast != NULL);
+ fr_assert(c->cast != NULL);
rcode = cond_eval_map(NULL, 0, 0, c);
TALLOC_FREE(c->data.map);
!c->pass2_fixup) {
int rcode;
- rad_assert(c->cast == NULL);
+ fr_assert(c->cast == NULL);
rcode = cond_eval_map(NULL, 0, 0, c);
if (rcode) {
/*
* This must have been parsed into TMPL_TYPE_DATA.
*/
- rad_assert(!tmpl_is_unparsed(c->data.map->rhs));
+ fr_assert(!tmpl_is_unparsed(c->data.map->rhs));
}
} while (0);
#include <freeradius-devel/server/connection.h>
#include <freeradius-devel/server/log.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/cond_eval.h>
#include <freeradius-devel/util/base.h>
* and shouldn't be possible because of
* deferred signal processing.
*/
- rad_assert(conn->next_watcher == NULL);
+ fr_assert(conn->next_watcher == NULL);
while ((conn->next_watcher = fr_dlist_next(list, conn->next_watcher))) {
fr_connection_watch_entry_t *entry = conn->next_watcher;
* is working correctly this state should never
* be entered if the connection is closed.
*/
- rad_assert(!conn->is_closed);
+ fr_assert(!conn->is_closed);
if (conn->close && !conn->is_closed) {
HANDLER_BEGIN(conn, conn->close);
DEBUG4("Calling close(el=%p, h=%p, uctx=%p)", conn->pub.el, conn->pub.h, conn->uctx);
fr_connection_state_t prev;
fr_connection_state_t ret = FR_CONNECTION_STATE_INIT;
- rad_assert(conn->pub.state != FR_CONNECTION_STATE_FAILED);
+ fr_assert(conn->pub.state != FR_CONNECTION_STATE_FAILED);
/*
* Explicit error occurred, delete the connection timer
break;
default:
- rad_assert(0);
+ fr_assert(0);
}
}
*/
static void connection_state_enter_halted(fr_connection_t *conn)
{
- rad_assert(conn->is_closed);
+ fr_assert(conn->is_closed);
switch (conn->pub.state) {
case FR_CONNECTION_STATE_FAILED: /* Init failure */
{
int ret;
- rad_assert(conn->pub.state == FR_CONNECTION_STATE_CONNECTING);
+ fr_assert(conn->pub.state == FR_CONNECTION_STATE_CONNECTING);
STATE_TRANSITION(FR_CONNECTION_STATE_CONNECTED);
*/
void fr_connection_signal_connected(fr_connection_t *conn)
{
- rad_assert(!conn->open); /* Use one or the other not both! */
+ fr_assert(!conn->open); /* Use one or the other not both! */
DEBUG2("Signalled connected from %s state",
fr_table_str_by_value(fr_connection_states, conn->pub.state, "<INVALID>"));
break;
case FR_CONNECTION_STATE_MAX:
- rad_assert(0);
+ fr_assert(0);
return;
}
}
case FR_CONNECTION_STATE_TIMEOUT:
case FR_CONNECTION_STATE_FAILED:
connection_state_enter_closed(conn);
- rad_assert(conn->is_closed);
+ fr_assert(conn->is_closed);
/* FALL-THROUGH */
case FR_CONNECTION_STATE_CLOSED:
break;
case FR_CONNECTION_STATE_MAX:
- rad_assert(0);
+ fr_assert(0);
return;
}
}
case FR_CONNECTION_STATE_TIMEOUT:
case FR_CONNECTION_STATE_FAILED:
connection_state_enter_closed(conn);
- rad_assert(conn->is_closed);
+ fr_assert(conn->is_closed);
connection_state_enter_halted(conn);
break;
case FR_CONNECTION_STATE_MAX:
- rad_assert(0);
+ fr_assert(0);
return;
}
}
break;
default:
- rad_assert(0);
+ fr_assert(0);
break;
}
size_t i;
fr_connection_t *conn;
- rad_assert(el);
+ fr_assert(el);
conn = talloc_zero(ctx, fr_connection_t);
if (!conn) return NULL;
#include <freeradius-devel/server/dl_module.h>
#include <freeradius-devel/server/log.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/cursor.h>
#include <freeradius-devel/util/dl.h>
#include <ctype.h>
#include <unistd.h>
-#define DL_INIT_CHECK rad_assert(dl_module_loader)
+#define DL_INIT_CHECK fr_assert(dl_module_loader)
/** Wrapper struct around dl_loader_t
*
{
dl_module_inst_t const *a = one, *b = two;
- rad_assert(a->data);
- rad_assert(b->data);
+ fr_assert(a->data);
+ fr_assert(b->data);
return (a->data > b->data) - (a->data < b->data);
}
{
dl_module_t const *a = one, *b = two;
- rad_assert(a->dl);
- rad_assert(b->dl);
+ fr_assert(a->dl);
+ fr_assert(b->dl);
return strcmp(a->dl->name, b->dl->name);
}
* destructor can find the dl_module_inst_t associated
* with the data.
*/
- rad_assert(dl_module_loader != NULL);
+ fr_assert(dl_module_loader != NULL);
rbtree_insert(dl_module_loader->inst_data_tree, dl_inst); /* Duplicates not possible */
talloc_set_destructor(data, _dl_module_instance_data_free);
/*
* Remove this instance from the tracking tree.
*/
- rad_assert(dl_module_loader != NULL);
+ fr_assert(dl_module_loader != NULL);
rbtree_deletebydata(dl_module_loader->inst_data_tree, dl_inst);
/*
RCSID("$Id$")
#include <freeradius-devel/server/exec.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/request.h>
#include <freeradius-devel/server/util.h>
* @copyright 2014 The FreeRADIUS server project
*/
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/exfile.h>
#include <freeradius-devel/util/misc.h>
fr_dict_attr_t const *da;
fr_cursor_t cursor;
- rad_assert(ef != NULL);
- rad_assert(name_suffix != NULL);
+ fr_assert(ef != NULL);
+ fr_assert(name_suffix != NULL);
if (!ef->trigger_prefix) return;
RCSID("$Id$")
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#ifdef HAVE_SYS_STAT_H
# include <sys/stat.h>
if (!fmt || !request || !request->packet) return;
- rad_assert(attr_module_failure_message);
+ fr_assert(attr_module_failure_message);
/*
* If we don't copy the original ap we get a segfault from vasprintf. This is apparently
#include <freeradius-devel/server/map_proc.h>
#include <freeradius-devel/server/modpriv.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/util.h>
#include <freeradius-devel/server/virtual_servers.h>
CONF_PAIR *cp = cf_item_to_pair(ci);
char const *value;
- rad_assert(main_config != NULL);
+ fr_assert(main_config != NULL);
value = cf_pair_value(cp);
if (value) {
main_config_t *config;
* Note that where possible, we do atomic switch-overs,
* to ensure that the pointers are always valid.
*/
- rad_assert(config->root_cs == NULL);
+ fr_assert(config->root_cs == NULL);
DEBUG2("%s: #### Loading Clients ####", config->name);
if (!client_list_parse_section(cs, 0, false)) goto failure;
#include <freeradius-devel/server/cf_parse.h>
#include <freeradius-devel/server/main_loop.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/state.h>
#include <freeradius-devel/server/trigger.h>
#include <freeradius-devel/server/util.h>
#include <freeradius-devel/server/exec.h>
#include <freeradius-devel/server/map.h>
#include <freeradius-devel/server/paircmp.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/misc.h>
#include <freeradius-devel/util/pair_cursor.h>
vp_tmpl_t *vpt;
fr_value_box_t cast;
- rad_assert(map != NULL);
+ fr_assert(map != NULL);
- rad_assert(map->lhs != NULL);
- rad_assert(tmpl_is_attr(map->lhs));
+ fr_assert(map->lhs != NULL);
+ fr_assert(tmpl_is_attr(map->lhs));
- rad_assert(map->rhs == NULL);
- rad_assert(rhs != NULL);
+ fr_assert(map->rhs == NULL);
+ fr_assert(rhs != NULL);
MAP_VERIFY(map);
}
cp = cf_item_to_pair(ci);
- rad_assert(cp != NULL);
+ fr_assert(cp != NULL);
if (map_afrom_cp(parent, &map, cp, &our_lhs_rules, rhs_rules) < 0) {
cf_log_err(ci, "Failed creating map from '%s = %s'",
MAP_VERIFY(map);
- rad_assert(map->rhs); /* Quite clang scan */
- rad_assert(tmpl_is_exec(map->rhs));
- rad_assert(tmpl_is_attr(map->lhs) || tmpl_is_list(map->lhs));
+ fr_assert(map->rhs); /* Quite clang scan */
+ fr_assert(tmpl_is_exec(map->rhs));
+ fr_assert(tmpl_is_attr(map->lhs) || tmpl_is_list(map->lhs));
/*
* We always put the request pairs into the environment
}
default:
- rad_assert(0);
+ fr_assert(0);
return -1;
}
}
if (!fr_cond_assert(original->lhs != NULL)) return -1;
if (!fr_cond_assert(original->rhs != NULL)) return -1;
- rad_assert(tmpl_is_list(original->lhs) ||
+ fr_assert(tmpl_is_list(original->lhs) ||
tmpl_is_attr(original->lhs) ||
tmpl_is_xlat_struct(original->lhs));
tmp_ctx = talloc_new(NULL);
- rad_assert(lhs_result && *lhs_result);
+ fr_assert(lhs_result && *lhs_result);
/*
* This should always be a noop, but included
TALLOC_FREE(*lhs_result);
goto error;
}
- rad_assert(tmpl_is_attr(mutated->lhs) || tmpl_is_list(mutated->lhs));
+ fr_assert(tmpl_is_attr(mutated->lhs) || tmpl_is_list(mutated->lhs));
}
break;
slen = tmpl_aexpand(request, &attr_str, request, mutated->lhs, NULL, NULL);
if (slen <= 0) {
RPEDEBUG("Left side expansion failed");
- rad_assert(!attr_str);
+ fr_assert(!attr_str);
goto error;
}
talloc_free(attr_str);
goto error;
}
- rad_assert(tmpl_is_attr(mutated->lhs) || tmpl_is_list(mutated->lhs));
+ fr_assert(tmpl_is_attr(mutated->lhs) || tmpl_is_list(mutated->lhs));
}
break;
default:
- rad_assert(0);
+ fr_assert(0);
break;
}
if (tmpl_is_unparsed(mutated->rhs)) {
fr_type_t type = mutated->lhs->tmpl_da->type;
- rad_assert(tmpl_is_attr(mutated->lhs));
- rad_assert(mutated->lhs->tmpl_da); /* We need to know which attribute to create */
+ fr_assert(tmpl_is_attr(mutated->lhs));
+ fr_assert(mutated->lhs->tmpl_da); /* We need to know which attribute to create */
n = list_mod_generic_afrom_map(ctx, original, mutated);
if (!n) goto error;
switch (mutated->rhs->type) {
case TMPL_TYPE_XLAT_STRUCT:
- rad_assert(mutated->rhs->tmpl_xlat != NULL);
+ fr_assert(mutated->rhs->tmpl_xlat != NULL);
/* FALL-THROUGH */
case TMPL_TYPE_XLAT:
fr_cursor_t from;
fr_value_box_t *vb, *n_vb;
- rad_assert(tmpl_is_attr(mutated->lhs));
- rad_assert(mutated->lhs->tmpl_da); /* We need to know which attribute to create */
+ fr_assert(tmpl_is_attr(mutated->lhs));
+ fr_assert(mutated->lhs->tmpl_da); /* We need to know which attribute to create */
/*
* Empty value - Try and cast an empty string
fr_value_box_t *n_vb;
int err;
- rad_assert(!rhs_result || !*rhs_result);
- rad_assert((tmpl_is_attr(mutated->lhs) && mutated->lhs->tmpl_da) ||
+ fr_assert(!rhs_result || !*rhs_result);
+ fr_assert((tmpl_is_attr(mutated->lhs) && mutated->lhs->tmpl_da) ||
(tmpl_is_list(mutated->lhs) && !mutated->lhs->tmpl_da));
/*
if (!n) goto error;
vp = fr_cursor_current(&from);
- rad_assert(vp); /* Should have errored out */
+ fr_assert(vp); /* Should have errored out */
do {
n_vb = fr_value_box_alloc_null(n->mod->rhs);
if (!n_vb) {
fr_cursor_t from;
fr_value_box_t *vb, *vb_head, *n_vb;
- rad_assert(!rhs_result || !*rhs_result);
- rad_assert(mutated->lhs->tmpl_da);
- rad_assert(tmpl_is_attr(mutated->lhs));
+ fr_assert(!rhs_result || !*rhs_result);
+ fr_assert(mutated->lhs->tmpl_da);
+ fr_assert(tmpl_is_attr(mutated->lhs));
n = list_mod_generic_afrom_map(ctx, original, mutated);
if (!n) goto error;
VALUE_PAIR *vp_head = NULL;
VALUE_PAIR *vp;
- rad_assert(!rhs_result || !*rhs_result);
+ fr_assert(!rhs_result || !*rhs_result);
n = list_mod_alloc(ctx);
if (!n) goto error;
goto finish;
default:
- rad_assert(0); /* Should have been caught at parse time */
+ fr_assert(0); /* Should have been caught at parse time */
goto error;
}
- rad_assert(head || !n);
+ fr_assert(head || !n);
/*
* FIXME: This is only required because
VALUE_PAIR *head = NULL;
fr_cursor_t cursor;
- rad_assert(vlm->mod);
+ fr_assert(vlm->mod);
/*
* Fast path...
if (!fr_cond_assert(map->lhs != NULL)) return;
if (!fr_cond_assert(map->rhs != NULL)) return;
- rad_assert(mod || tmpl_is_null(map->rhs));
+ fr_assert(mod || tmpl_is_null(map->rhs));
if (vb && (vb->type == FR_TYPE_STRING)) quote = "\"";
fr_cursor_t list;
MAP_VERIFY(map);
- rad_assert(vlm->mod);
+ fr_assert(vlm->mod);
/*
* Print debug information for the mods being applied
MAP_VERIFY(mod);
- rad_assert(mod->lhs != NULL);
- rad_assert(mod->rhs != NULL);
+ fr_assert(mod->lhs != NULL);
+ fr_assert(mod->rhs != NULL);
- rad_assert(tmpl_is_attr(mod->lhs) || tmpl_is_list(mod->lhs));
- rad_assert(((mod->op == T_OP_CMP_FALSE) && tmpl_is_null(mod->rhs)) ||
+ fr_assert(tmpl_is_attr(mod->lhs) || tmpl_is_list(mod->lhs));
+ fr_assert(((mod->op == T_OP_CMP_FALSE) && tmpl_is_null(mod->rhs)) ||
tmpl_is_data(mod->rhs));
/*
if (!fr_cond_assert(vp_list)) return -1;
parent = radius_list_ctx(context, mod->lhs->tmpl_list);
- rad_assert(parent);
+ fr_assert(parent);
/*
* The destination is a list (which is a completely different set of operations)
VALUE_PAIR *vp_from;
vp_from = map_list_mod_to_vps(parent, vlm);
- rad_assert(vp_from);
+ fr_assert(vp_from);
fr_cursor_init(&to, vp_list);
fr_cursor_tail(&to);
}
}
- rad_assert(!mod->next);
+ fr_assert(!mod->next);
/*
* Find the destination attribute. We leave with either
* being NULL (no attribute at that index).
*/
found = tmpl_cursor_init(NULL, &list, request, mod->lhs);
- rad_assert(!found || (mod->lhs->tmpl_da == found->da));
+ fr_assert(!found || (mod->lhs->tmpl_da == found->da));
/*
* The destination is an attribute
goto finish;
default:
- rad_assert(0); /* Should have been caught be the caller */
+ fr_assert(0); /* Should have been caught be the caller */
rcode = -1;
goto finish;
}
if (!fr_cond_assert(map->lhs != NULL)) return -1;
if (!fr_cond_assert(map->rhs != NULL)) return -1;
- rad_assert(tmpl_is_list(map->lhs) || tmpl_is_attr(map->lhs));
+ fr_assert(tmpl_is_list(map->lhs) || tmpl_is_attr(map->lhs));
/*
* Special case for !*, we don't need to parse RHS as this is a unary operator.
*/
switch (map->rhs->type) {
case TMPL_TYPE_XLAT_STRUCT:
- rad_assert(tmpl_is_attr(map->lhs));
- rad_assert(map->lhs->tmpl_da); /* We need to know which attribute to create */
- rad_assert(map->rhs->tmpl_xlat != NULL);
+ fr_assert(tmpl_is_attr(map->lhs));
+ fr_assert(map->lhs->tmpl_da); /* We need to know which attribute to create */
+ fr_assert(map->rhs->tmpl_xlat != NULL);
MEM(n = fr_pair_afrom_da(ctx, map->lhs->tmpl_da));
break;
case TMPL_TYPE_XLAT:
- rad_assert(tmpl_is_attr(map->lhs));
- rad_assert(map->lhs->tmpl_da); /* We need to know which attribute to create */
+ fr_assert(tmpl_is_attr(map->lhs));
+ fr_assert(map->lhs->tmpl_da); /* We need to know which attribute to create */
MEM(n = fr_pair_afrom_da(ctx, map->lhs->tmpl_da));
break;
case TMPL_TYPE_UNPARSED:
- rad_assert(tmpl_is_attr(map->lhs));
- rad_assert(map->lhs->tmpl_da); /* We need to know which attribute to create */
+ fr_assert(tmpl_is_attr(map->lhs));
+ fr_assert(map->lhs->tmpl_da); /* We need to know which attribute to create */
MEM(n = fr_pair_afrom_da(ctx, map->lhs->tmpl_da));
{
fr_cursor_t from;
- rad_assert((tmpl_is_attr(map->lhs) && map->lhs->tmpl_da) ||
+ fr_assert((tmpl_is_attr(map->lhs) && map->lhs->tmpl_da) ||
(tmpl_is_list(map->lhs) && !map->lhs->tmpl_da));
/*
vp = fr_cursor_remove(&from); /* advances cursor */
talloc_free(vp);
- rad_assert((n->vp_type != FR_TYPE_STRING) || (n->vp_strvalue != NULL));
+ fr_assert((n->vp_type != FR_TYPE_STRING) || (n->vp_strvalue != NULL));
n->op = map->op;
n->tag = map->lhs->tmpl_tag;
break;
case TMPL_TYPE_DATA:
- rad_assert(map->lhs->tmpl_da);
- rad_assert(tmpl_is_attr(map->lhs));
+ fr_assert(map->lhs->tmpl_da);
+ fr_assert(tmpl_is_attr(map->lhs));
MEM(n = fr_pair_afrom_da(ctx, map->lhs->tmpl_da));
return map_exec_to_vp(ctx, out, request, map);
default:
- rad_assert(0); /* Should have been caught at parse time */
+ fr_assert(0); /* Should have been caught at parse time */
error:
fr_pair_list_free(&vp);
vp_tmpl_t *exp_lhs;
MAP_VERIFY(map);
- rad_assert(map->lhs != NULL);
- rad_assert(map->rhs != NULL);
+ fr_assert(map->lhs != NULL);
+ fr_assert(map->rhs != NULL);
tmp_ctx = talloc_new(request);
slen = tmpl_aexpand(request, &attr_str, request, map->lhs, NULL, NULL);
if (slen <= 0) {
RPEDEBUG("Left side expansion failed");
- rad_assert(!attr_str);
+ fr_assert(!attr_str);
rcode = -1;
goto finish;
}
rcode = -1;
goto finish;
}
- rad_assert(tmpl_is_attr(exp_lhs) || tmpl_is_list(exp_lhs));
+ fr_assert(tmpl_is_attr(exp_lhs) || tmpl_is_list(exp_lhs));
memcpy(&exp_map, map, sizeof(exp_map));
exp_map.lhs = exp_lhs;
break;
default:
- rad_assert(0);
+ fr_assert(0);
break;
}
}
parent = radius_list_ctx(context, map->lhs->tmpl_list);
- rad_assert(parent);
+ fr_assert(parent);
/*
* The callback should either return -1 to signify operations error,
if (!tmpl_is_null(map->rhs)) {
rcode = func(parent, &head, request, map, ctx);
if (rcode < 0) {
- rad_assert(!head);
+ fr_assert(!head);
goto finish;
}
if (!head) {
switch (map->op) {
case T_OP_CMP_FALSE:
/* We don't need the src VPs (should just be 'ANY') */
- rad_assert(!head);
+ fr_assert(!head);
/* Clear the entire dst list */
fr_pair_list_free(list);
/* FALL-THROUGH */
case T_OP_EQ:
- rad_assert(tmpl_is_exec(map->rhs));
+ fr_assert(tmpl_is_exec(map->rhs));
/* FALL-THROUGH */
case T_OP_ADD:
} else {
dst = fr_pair_cursor_next_by_da(&dst_list, map->lhs->tmpl_da, map->lhs->tmpl_tag);
}
- rad_assert(!dst || (map->lhs->tmpl_da == dst->da));
+ fr_assert(!dst || (map->lhs->tmpl_da == dst->da));
/*
* The destination is an attribute
*/
case T_OP_CMP_FALSE:
/* We don't need the src VPs (should just be 'ANY') */
- rad_assert(!head);
+ fr_assert(!head);
if (!dst) goto finish;
/*
break;
default:
- rad_assert(0); /* Should have been caught be the caller */
+ fr_assert(0); /* Should have been caught be the caller */
rcode = -1;
goto finish;
}
update:
- rad_assert(!head);
+ fr_assert(!head);
finish:
talloc_free(tmp_ctx);
if (!fr_cond_assert(map->lhs != NULL)) return;
if (!fr_cond_assert(map->rhs != NULL)) return;
- rad_assert(vp || tmpl_is_null(map->rhs));
+ fr_assert(vp || tmpl_is_null(map->rhs));
switch (map->rhs->type) {
/*
};
#ifndef WITH_VERIFY_PTR
-# define MAP_VERIFY(_x) rad_assert((_x)->lhs)
+# define MAP_VERIFY(_x) fr_assert((_x)->lhs)
#else
# define MAP_VERIFY(_x) do { \
TMPL_VERIFY((_x)->lhs); \
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/map_proc_priv.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
static rbtree_t *map_proc_root = NULL;
{
map_proc_t *proc;
- rad_assert(name && name[0]);
+ fr_assert(name && name[0]);
if (!map_proc_root) {
map_proc_root = rbtree_talloc_create(NULL, map_proc_cmp, map_proc_t,
#include <freeradius-devel/server/map_proc.h>
#include <freeradius-devel/server/modpriv.h>
#include <freeradius-devel/server/map_proc.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#ifdef __cplusplus
extern "C" {
{
module_instance_t *mi = ctx;
- rad_assert(mi->dl_inst->conf != NULL);
+ fr_assert(mi->dl_inst->conf != NULL);
(void) cf_section_write(fp, mi->dl_inst->conf, 0);
for (k = 0; mi->module->method_names[k].name1 != NULL; k++) {
methods = &mi->module->method_names[k];
- rad_assert(methods->name1 != CF_IDENT_ANY); /* should have been caught above */
+ fr_assert(methods->name1 != CF_IDENT_ANY); /* should have been caught above */
if (strcmp(methods->name1, allowed->name) != 0) continue;
if (!mi) return NULL;
- rad_assert(mi->number < talloc_array_length(array));
+ fr_assert(mi->number < talloc_array_length(array));
return array[mi->number];
}
if (!mi) return NULL;
- rad_assert(mi->number < talloc_array_length(array));
+ fr_assert(mi->number < talloc_array_length(array));
return array[mi->number];
}
}
}
- rad_assert(mi->number < talloc_array_length(thread_inst_ctx->array));
+ fr_assert(mi->number < talloc_array_length(thread_inst_ctx->array));
thread_inst_ctx->array[mi->number] = ti;
return 0;
* ...because recursive code still makes
* my head hurt.
*/
- rad_assert((size_t)(p - (*out)) == (talloc_array_length(*out) - 1));
+ fr_assert((size_t)(p - (*out)) == (talloc_array_length(*out) - 1));
return (p - (*out));
talloc_free(inst_name);
return NULL;
}
- rad_assert(mi->dl_inst);
+ fr_assert(mi->dl_inst);
mi->name = talloc_typed_strdup(mi, inst_name);
talloc_free(inst_name); /* Avoid stealing */
RCSID("$Id$")
#include <freeradius-devel/server/paircmp.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/regex.h>
#include <freeradius-devel/server/request.h>
{
paircmp_t *c;
- rad_assert(da != NULL);
+ fr_assert(da != NULL);
paircmp_unregister(da, func);
RCSID("$Id$")
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/pairmove.h>
#include <freeradius-devel/protocol/radius/rfc2865.h>
continue;
}
- rad_assert(0 == 1); /* panic! */
+ fr_assert(0 == 1); /* panic! */
}
/*
*/
*last = append;
- rad_assert(request->packet != NULL);
+ fr_assert(request->packet != NULL);
talloc_free(to_list);
talloc_free(edited);
* Ensure this is only ever called with a
* string type attribute.
*/
- rad_assert(known_good->da->type == FR_TYPE_STRING);
+ fr_assert(known_good->da->type == FR_TYPE_STRING);
p = known_good->vp_strvalue;
end = p + known_good->vp_length;
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/modpriv.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/heap.h>
#include <freeradius-devel/util/misc.h>
static void connection_unlink(fr_pool_t *pool, fr_pool_connection_t *this)
{
if (this->prev) {
- rad_assert(pool->head != this);
+ fr_assert(pool->head != this);
this->prev->next = this->next;
} else {
- rad_assert(pool->head == this);
+ fr_assert(pool->head == this);
pool->head = this->next;
}
if (this->next) {
- rad_assert(pool->tail != this);
+ fr_assert(pool->tail != this);
this->next->prev = this->prev;
} else {
- rad_assert(pool->tail == this);
+ fr_assert(pool->tail == this);
pool->tail = this->prev;
}
*/
static void connection_link_head(fr_pool_t *pool, fr_pool_connection_t *this)
{
- rad_assert(pool != NULL);
- rad_assert(this != NULL);
- rad_assert(pool->head != this);
- rad_assert(pool->tail != this);
+ fr_assert(pool != NULL);
+ fr_assert(this != NULL);
+ fr_assert(pool->head != this);
+ fr_assert(pool->tail != this);
if (pool->head) {
pool->head->prev = this;
this->prev = NULL;
pool->head = this;
if (!pool->tail) {
- rad_assert(this->next == NULL);
+ fr_assert(this->next == NULL);
pool->tail = this;
} else {
- rad_assert(this->next != NULL);
+ fr_assert(this->next != NULL);
}
}
{
char name[128];
- rad_assert(pool != NULL);
- rad_assert(event != NULL);
+ fr_assert(pool != NULL);
+ fr_assert(event != NULL);
if (!pool->triggers_enabled) return;
pthread_t pthread_id;
pthread_id = pthread_self();
- rad_assert(pthread_equal(this->pthread_id, pthread_id) != 0);
+ fr_assert(pthread_equal(this->pthread_id, pthread_id) != 0);
#endif
- rad_assert(this->in_use == true);
+ fr_assert(this->in_use == true);
/* coverity[missing_unlock] */
return this;
}
fr_pool_connection_t *this;
void *conn;
- rad_assert(pool != NULL);
+ fr_assert(pool != NULL);
/*
* If we have NO connections, and we've previously failed
if ((pool->state.num == 0) && pool->state.pending && pool->state.last_failed) return NULL;
pthread_mutex_lock(&pool->mutex);
- rad_assert(pool->state.num <= pool->max);
+ fr_assert(pool->state.num <= pool->max);
/*
* Don't spawn too many connections at the same time.
pool->state.num++;
- rad_assert(pool->state.pending > 0);
+ fr_assert(pool->state.pending > 0);
pool->state.pending--;
/*
if (this->in_use) {
#ifdef PTHREAD_DEBUG
pthread_t pthread_id = pthread_self();
- rad_assert(pthread_equal(this->pthread_id, pthread_id) != 0);
+ fr_assert(pthread_equal(this->pthread_id, pthread_id) != 0);
#endif
this->in_use = false;
- rad_assert(pool->state.active != 0);
+ fr_assert(pool->state.active != 0);
pool->state.active--;
} else {
connection_unlink(pool, this);
- rad_assert(pool->state.num > 0);
+ fr_assert(pool->state.num > 0);
pool->state.num--;
talloc_free(this);
}
*/
static int connection_manage(fr_pool_t *pool, REQUEST *request, fr_pool_connection_t *this, time_t now)
{
- rad_assert(pool != NULL);
- rad_assert(this != NULL);
+ fr_assert(pool != NULL);
+ fr_assert(this != NULL);
/*
* Don't terminated in-use connections
fr_pool_trigger_exec(pool, NULL, "stop");
- rad_assert(pool->head == NULL);
- rad_assert(pool->tail == NULL);
- rad_assert(pool->state.num == 0);
+ fr_assert(pool->head == NULL);
+ fr_assert(pool->tail == NULL);
+ fr_assert(pool->state.num == 0);
pthread_mutex_destroy(&pool->mutex);
pthread_cond_destroy(&pool->done_spawn);
*/
fr_heap_insert(pool->heap, this);
- rad_assert(pool->state.active != 0);
+ fr_assert(pool->state.active != 0);
pool->state.active--;
ROPTIONAL(RDEBUG2, DEBUG2, "Released connection (%" PRIu64 ")", this->number);
/**
* $Id$
*
- * @file lib/server/rad_assert.h
+ * @file lib/server/fr_assert.h
* @brief Debug assertions, with logging.
*
* @copyright 2000,2001,2006 The FreeRADIUS server project
*/
-RCSIDH(rad_assert_h, "$Id$")
+RCSIDH(fr_assert_h, "$Id$")
#include <stdbool.h>
#include <freeradius-devel/util/debug.h>
#endif
#ifdef NDEBUG
-# define rad_assert(_expr)
+# define fr_assert(_expr)
#elif !defined(__clang_analyzer__)
-# define rad_assert(_expr) ((void) ((_expr) ? (void) 0 : (void) fr_assert_exit(__FILE__, __LINE__, #_expr)))
+# define fr_assert(_expr) ((void) ((_expr) ? (void) 0 : (void) fr_assert_exit(__FILE__, __LINE__, #_expr)))
#else
# include <assert.h>
-# define rad_assert assert
+# define fr_assert assert
#endif
-/** For systems with an old version libc, define static_assert.
- *
- */
-#ifndef static_assert
-# define static_assert _Static_assert
-# else
-# include <assert.h>
-#endif
+
#ifdef __cplusplus
}
#include <freeradius-devel/server/regex.h>
#include <freeradius-devel/server/request_data.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#ifdef HAVE_REGEX
if (!regmatch || ((*regmatch)->used == 0)) return;
- rad_assert(preg && *preg);
- rad_assert(regmatch);
+ fr_assert(preg && *preg);
+ fr_assert(regmatch);
DEBUG4("Adding %zu matches", (*regmatch)->used);
/*
* Sanity checks on the offsets
*/
- rad_assert(match_data[num].rm_eo <= (regoff_t)talloc_array_length(rc->regmatch->subject));
- rad_assert(match_data[num].rm_so <= (regoff_t)talloc_array_length(rc->regmatch->subject));
+ fr_assert(match_data[num].rm_eo <= (regoff_t)talloc_array_length(rc->regmatch->subject));
+ fr_assert(match_data[num].rm_so <= (regoff_t)talloc_array_length(rc->regmatch->subject));
start = rc->regmatch->subject + match_data[num].rm_so;
len = match_data[num].rm_eo - match_data[num].rm_so;
RCSID("$Id$")
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/base.h>
/** The thread local free list
*/
static int _request_free(REQUEST *request)
{
- rad_assert(!request->ev);
+ fr_assert(!request->ev);
/*
* Reinsert into the free list if it's not already
*/
state_ctx = request->state_ctx;
if (request->state_ctx) {
- rad_assert(!request->parent || (request->state_ctx != request->parent->state_ctx));
+ fr_assert(!request->parent || (request->state_ctx != request->parent->state_ctx));
talloc_free_children(request->state_ctx);
}
free_list = request_free_list;
* call fr_state_store_in_parent()
*/
if (request->state_ctx) {
- rad_assert(!request->parent || (request->state_ctx != request->parent->state_ctx));
+ fr_assert(!request->parent || (request->state_ctx != request->parent->state_ctx));
talloc_free(request->state_ctx);
}
{
REQUEST *request = fake->parent;
- rad_assert(request != NULL);
+ fr_assert(request != NULL);
/*
* Unlink the child from the parent.
fake->parent = NULL;
while (!request->backlog) {
- rad_assert(request->parent != NULL);
+ fr_assert(request->parent != NULL);
request = request->parent;
}
fr_log_talloc_report(packet);
if (parent) fr_log_talloc_report(parent);
- rad_assert(0);
+ fr_assert(0);
}
PACKET_VERIFY(packet);
(void) talloc_get_type_abort_const(request, REQUEST);
- rad_assert(request->magic == REQUEST_MAGIC);
+ fr_assert(request->magic == REQUEST_MAGIC);
if (talloc_get_size(request) != sizeof(REQUEST)) {
fprintf(stderr, "CONSISTENCY CHECK FAILED %s[%i]: expected REQUEST size of %zu bytes, got %zu bytes",
fr_pair_list_verify(file, line, request, request->control);
fr_pair_list_verify(file, line, request->state_ctx, request->state);
- rad_assert(request->server_cs != NULL);
+ fr_assert(request->server_cs != NULL);
if (request->packet) {
packet_verify(file, line, request, request->packet, "request");
if ((request->packet->code == FR_CODE_ACCESS_REQUEST) &&
(request->reply && !request->reply->code)) {
- rad_assert(request->state_ctx != NULL);
+ fr_assert(request->state_ctx != NULL);
}
}
if (request->reply) packet_verify(file, line, request, request->reply, "reply");
if (request->async) {
(void) talloc_get_type_abort(request->async, fr_async_t);
- rad_assert(talloc_parent(request->async) == request);
+ fr_assert(talloc_parent(request->async) == request);
}
while ((rd = fr_dlist_next(&request->data, rd))) {
(void) talloc_get_type_abort(rd, request_data_t);
if (request_data_persistable(rd)) {
- rad_assert(request->state_ctx);
- rad_assert(talloc_parent(rd) == request->state_ctx);
+ fr_assert(request->state_ctx);
+ fr_assert(talloc_parent(rd) == request->state_ctx);
} else {
- rad_assert(talloc_parent(rd) == request);
+ fr_assert(talloc_parent(rd) == request);
}
}
}
* the pointer must not be NULL when these various macros are used
* so we can add some sneaky asserts.
*/
-# define REQUEST_VERIFY(_x) rad_assert(_x)
+# define REQUEST_VERIFY(_x) fr_assert(_x)
#endif
*/
RCSID("$Id$")
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/request_data.h>
/** Per-request opaque data, added by modules
/*
* Request must have a state ctx
*/
- rad_assert(request);
- rad_assert(!persist || request->state_ctx);
- rad_assert(!persist ||
+ fr_assert(request);
+ fr_assert(!persist || request->state_ctx);
+ fr_assert(!persist ||
(talloc_parent(opaque) == request->state_ctx) ||
(talloc_parent(opaque) == talloc_null_ctx()));
- rad_assert(!free_on_parent || (talloc_parent(opaque) != request));
+ fr_assert(!free_on_parent || (talloc_parent(opaque) != request));
#ifndef TALLOC_GET_TYPE_ABORT_NOOP
if (type) opaque = _talloc_get_type_abort(opaque, type, __location__);
*/
if (!rd) {
if (persist) {
- rad_assert(request->state_ctx);
+ fr_assert(request->state_ctx);
rd = request_data_alloc(request->state_ctx);
} else {
rd = request_data_alloc(request);
RCSID("$Id$")
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/misc.h>
#include <freeradius-devel/util/proto.h>
static int snmp_value_serv_ident_get(TALLOC_CTX *ctx, fr_value_box_t *out, NDEBUG_UNUSED fr_snmp_map_t const *map,
UNUSED void *snmp_ctx)
{
- rad_assert(map->da->type == FR_TYPE_STRING);
+ fr_assert(map->da->type == FR_TYPE_STRING);
out->vb_strvalue = talloc_typed_asprintf(ctx, "FreeRADIUS %s", radiusd_version_short);
out->datum.length = talloc_array_length(out->vb_strvalue) - 1;
fr_time_t now;
fr_time_delta_t delta;
- rad_assert(map->da->type == FR_TYPE_UINT32);
+ fr_assert(map->da->type == FR_TYPE_UINT32);
now = fr_time();
delta = now - start_time;
fr_time_t now;
fr_time_delta_t delta;
- rad_assert(map->da->type == FR_TYPE_UINT32);
+ fr_assert(map->da->type == FR_TYPE_UINT32);
now = fr_time();
delta = now - reset_time;
static int snmp_config_reset_get(UNUSED TALLOC_CTX *ctx, fr_value_box_t *out, NDEBUG_UNUSED fr_snmp_map_t const *map,
UNUSED void *snmp_ctx)
{
- rad_assert(map->da->type == FR_TYPE_UINT32);
+ fr_assert(map->da->type == FR_TYPE_UINT32);
out->vb_uint32 = reset_state;
static int snmp_config_reset_set(NDEBUG_UNUSED fr_snmp_map_t const *map, UNUSED void *snmp_ctx, fr_value_box_t *in)
{
- rad_assert(map->da->type == FR_TYPE_UINT32);
+ fr_assert(map->da->type == FR_TYPE_UINT32);
switch (in->vb_uint32) {
case FR_RADIUS_AUTH_SERV_CONFIG_RESET_VALUE_RESET:
static int snmp_auth_stats_offset_get(UNUSED TALLOC_CTX *ctx, fr_value_box_t *out,
fr_snmp_map_t const *map, UNUSED void *snmp_ctx)
{
- rad_assert(map->da->type == FR_TYPE_UINT32);
+ fr_assert(map->da->type == FR_TYPE_UINT32);
out->vb_uint32 = *(uint32_t *)((uint8_t *)(&radius_auth_stats) + map->offset);
{
RADCLIENT *client;
- rad_assert(!snmp_ctx_in);
+ fr_assert(!snmp_ctx_in);
client = client_findbynumber(NULL, index_num - 1); /* Clients indexed from 0 */
if (!client) return 1; /* No more clients */
{
RADCLIENT *client = snmp_ctx;
- rad_assert(client);
+ fr_assert(client);
out->vb_uint32 = client->number + 1; /* Clients indexed from 0 */
{
RADCLIENT *client = snmp_ctx;
- rad_assert(client);
- rad_assert(map->da->type == FR_TYPE_IPV4_ADDR);
+ fr_assert(client);
+ fr_assert(map->da->type == FR_TYPE_IPV4_ADDR);
/*
* The old SNMP MIB only allowed access
RADCLIENT *client = snmp_ctx;
size_t len;
- rad_assert(client);
- rad_assert(map->da->type == FR_TYPE_STRING);
+ fr_assert(client);
+ fr_assert(map->da->type == FR_TYPE_STRING);
len = talloc_array_length(client->longname) - 1;
{
RADCLIENT *client = snmp_ctx;
- rad_assert(client);
- rad_assert(map->da->type == FR_TYPE_UINT32);
+ fr_assert(client);
+ fr_assert(map->da->type == FR_TYPE_UINT32);
out->vb_uint32 = *(uint32_t *)((uint8_t *)(&client->auth) + map->offset);
{
fr_snmp_map_t const *p = &map[1], *q = map[0].last, *m;
- rad_assert(p <= q);
+ fr_assert(p <= q);
/*
* Fast path...
*/
if (p == q) {
- rad_assert(p->da);
+ fr_assert(p->da);
if (p->da->attr == da->attr) return p;
return NULL;
return 0;
default:
- rad_assert(0);
+ fr_assert(0);
goto error;
}
}
fr_cursor_t *cursor,
fr_snmp_map_t const *map, void *snmp_ctx, unsigned int snmp_op)
{
- rad_assert(map);
+ fr_assert(map);
FR_PROTO_STACK_PRINT(da_stack, depth);
* Any attribute returned by fr_cursor_next_by_ancestor
* should have the SNMP root attribute as an ancestor.
*/
- rad_assert(da_stack.da[depth]);
- rad_assert(da_stack.da[depth] == attr_snmp_root);
+ fr_assert(da_stack.da[depth]);
+ fr_assert(da_stack.da[depth] == attr_snmp_root);
/*
* Operator attribute acts as a request delimiter
if (map[i].type == FR_FREERADIUS_SNMP_TYPE_OBJECT) {
int ret;
- rad_assert(map[i].child);
+ fr_assert(map[i].child);
map[i].da = fr_dict_attr_by_name(dict_snmp, map[i].name);
if (!map[i].da) {
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/state.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/dlist.h>
#include <freeradius-devel/util/md5.h>
for (vp = fr_cursor_init(&cursor, &entry->vps);
vp;
vp = fr_cursor_next(&cursor)) {
- rad_assert(entry->ctx == talloc_parent(vp));
+ fr_assert(entry->ctx == talloc_parent(vp));
}
}
TALLOC_CTX *old_ctx = NULL;
VALUE_PAIR *vp;
- rad_assert(request->state == NULL);
+ fr_assert(request->state == NULL);
/*
* No State, don't do anything.
}
if (request->state_ctx) old_ctx = request->state_ctx; /* Store for later freeing */
- rad_assert(entry->ctx);
+ fr_assert(entry->ctx);
request->seq_start = entry->seq_start;
request->state_ctx = entry->ctx;
return -1;
}
- rad_assert(entry->ctx == NULL);
- rad_assert(request->state_ctx);
+ fr_assert(entry->ctx == NULL);
+ fr_assert(request->state_ctx);
entry->seq_start = request->seq_start;
entry->ctx = request->state_ctx;
RCSID("$Id$")
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/misc.h>
#include <freeradius-devel/util/time.h>
/*
* Statistics are available ONLY on a "status" port.
*/
- rad_assert(request->packet->code == FR_CODE_STATUS_SERVER);
- rad_assert(request->listener->type == RAD_LISTEN_NONE);
+ fr_assert(request->packet->code == FR_CODE_STATUS_SERVER);
+ fr_assert(request->listener->type == RAD_LISTEN_NONE);
flag = fr_pair_find_by_num(request->packet->vps, VENDORPEC_FREERADIUS, FR_FREERADIUS_STATISTICS_TYPE, TAG_ANY);
if (!flag || (flag->vp_uint32 == 0)) return;
#endif
if (ema->window == 0) return;
- rad_assert(start <= end);
+ fr_assert(start <= end);
/*
* Initialize it.
RCSID("$Id$")
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/misc.h>
char const *q;
/* This should never be a NULL pointer */
- rad_assert(name);
+ fr_assert(name);
/*
* Try and determine the end of the token
case REQUEST_UNKNOWN:
default:
- rad_assert(0);
+ fr_assert(0);
return -1;
}
*/
vp_tmpl_t *tmpl_init(vp_tmpl_t *vpt, tmpl_type_t type, char const *name, ssize_t len, FR_TOKEN quote)
{
- rad_assert(vpt);
- rad_assert(type != TMPL_TYPE_UNKNOWN);
- rad_assert(type <= TMPL_TYPE_NULL);
+ fr_assert(vpt);
+ fr_assert(type != TMPL_TYPE_UNKNOWN);
+ fr_assert(type <= TMPL_TYPE_NULL);
memset(vpt, 0, sizeof(vp_tmpl_t));
vpt->type = type;
{
vp_tmpl_t *vpt;
- rad_assert(type != TMPL_TYPE_UNKNOWN);
- rad_assert(type <= TMPL_TYPE_NULL);
+ fr_assert(type != TMPL_TYPE_UNKNOWN);
+ fr_assert(type <= TMPL_TYPE_NULL);
#ifndef HAVE_REGEX
if ((type == TMPL_TYPE_REGEX) || (type == TMPL_TYPE_REGEX_STRUCT)) {
{
static char const name[] = "internal";
- rad_assert(da);
+ fr_assert(da);
tmpl_init(vpt, TMPL_TYPE_ATTR, name, sizeof(name), T_BARE_WORD);
vpt->tmpl_da = da;
break;
default:
- rad_assert(0);
+ fr_assert(0);
return 0; /* 0 is an error here too */
}
vpt->quote = type;
- rad_assert(slen >= 0);
+ fr_assert(slen >= 0);
TMPL_VERIFY(vpt);
*out = vpt;
{
TMPL_VERIFY(vpt);
- rad_assert(vpt != NULL);
- rad_assert(tmpl_is_unparsed(vpt) || tmpl_is_data(vpt));
+ fr_assert(vpt != NULL);
+ fr_assert(tmpl_is_unparsed(vpt) || tmpl_is_data(vpt));
switch (vpt->type) {
case TMPL_TYPE_UNPARSED:
break;
default:
- rad_assert(0);
+ fr_assert(0);
}
TMPL_VERIFY(vpt);
*/
void tmpl_cast_in_place_str(vp_tmpl_t *vpt)
{
- rad_assert(vpt != NULL);
- rad_assert(tmpl_is_unparsed(vpt));
+ fr_assert(vpt != NULL);
+ fr_assert(tmpl_is_unparsed(vpt));
vpt->tmpl_value.vb_strvalue = talloc_typed_strdup(vpt, vpt->name);
- rad_assert(vpt->tmpl_value.vb_strvalue != NULL);
+ fr_assert(vpt->tmpl_value.vb_strvalue != NULL);
vpt->type = TMPL_TYPE_DATA;
vpt->tmpl_value_type = FR_TYPE_STRING;
MEM(vp = fr_pair_afrom_da(request, cast));
if (tmpl_is_data(vpt)) {
VP_VERIFY(vp);
- rad_assert(vp->vp_type == vpt->tmpl_value_type);
+ fr_assert(vp->vp_type == vpt->tmpl_value_type);
fr_value_box_copy(vp, &vp->data, &vpt->tmpl_value);
*out = vp;
TMPL_VERIFY(vpt);
- rad_assert(!tmpl_is_list(vpt));
- rad_assert(!buff || (bufflen >= 2));
+ fr_assert(!tmpl_is_list(vpt));
+ fr_assert(!buff || (bufflen >= 2));
memset(&value_to_cast, 0, sizeof(value_to_cast));
memset(&value_from_cast, 0, sizeof(value_from_cast));
case TMPL_TYPE_REGEX:
case TMPL_TYPE_ATTR_UNDEFINED:
case TMPL_TYPE_REGEX_STRUCT:
- rad_assert(0);
+ fr_assert(0);
return -1;
}
value.datum.length = strlen(value.vb_strvalue);
value.type = FR_TYPE_STRING;
MEM(value.vb_strvalue = talloc_realloc(tmp_ctx, value.datum.ptr, char, value.datum.length + 1)); /* Trim */
- rad_assert(value.vb_strvalue[value.datum.length] == '\0');
+ fr_assert(value.vb_strvalue[value.datum.length] == '\0');
to_cast = &value;
break;
return -2;
}
- rad_assert(vp);
+ fr_assert(vp);
to_cast = &vp->data;
switch (to_cast->type) {
case FR_TYPE_STRING:
case FR_TYPE_OCTETS:
- rad_assert(to_cast->datum.ptr);
+ fr_assert(to_cast->datum.ptr);
needs_dup = true;
break;
switch (to_cast->type) {
case FR_TYPE_STRING:
case FR_TYPE_OCTETS:
- rad_assert(to_cast->datum.ptr);
+ fr_assert(to_cast->datum.ptr);
needs_dup = true;
break;
case TMPL_TYPE_REGEX:
case TMPL_TYPE_ATTR_UNDEFINED:
case TMPL_TYPE_REGEX_STRUCT:
- rad_assert(0);
+ fr_assert(0);
goto error;
}
}
default:
- rad_assert(0);
+ fr_assert(0);
}
return NULL;
TMPL_VERIFY(vpt);
- rad_assert(tmpl_is_attr(vpt) || tmpl_is_list(vpt));
+ fr_assert(tmpl_is_attr(vpt) || tmpl_is_list(vpt));
if (err) *err = 0;
int err;
- rad_assert(tmpl_is_attr(vpt) || tmpl_is_list(vpt));
+ fr_assert(tmpl_is_attr(vpt) || tmpl_is_list(vpt));
*out = NULL;
int err;
TMPL_VERIFY(vpt);
- rad_assert(tmpl_is_attr(vpt));
+ fr_assert(tmpl_is_attr(vpt));
*out = NULL;
*/
void tmpl_verify(char const *file, int line, vp_tmpl_t const *vpt)
{
- rad_assert(vpt);
+ fr_assert(vpt);
if (tmpl_is_unknown(vpt)) {
FR_FAULT_LOG("CONSISTENCY CHECK FAILED %s[%u]: vp_tmpl_t type was "
break;
case TMPL_TYPE_ATTR_UNDEFINED:
- rad_assert(vpt->tmpl_da == NULL);
+ fr_assert(vpt->tmpl_da == NULL);
break;
case TMPL_TYPE_ATTR:
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/cf_parse.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
/** Whether triggers are enabled globally
*
*/
#define REQUEST_EXTRACT_PARTIAL(_treq) \
do { \
- rad_assert((_treq)->pub.tconn->partial == treq); \
+ fr_assert((_treq)->pub.tconn->partial == treq); \
tconn->partial = NULL; \
} while (0)
*/
#define REQUEST_EXTRACT_CANCEL_PARTIAL(_treq) \
do { \
- rad_assert((_treq)->pub.tconn->cancel_partial == treq); \
+ fr_assert((_treq)->pub.tconn->cancel_partial == treq); \
tconn->cancel_partial = NULL; \
} while (0)
fr_trunk_request_t const *treq_a = talloc_get_type_abort_const(a, fr_trunk_request_t);
fr_trunk_request_t const *treq_b = talloc_get_type_abort_const(b, fr_trunk_request_t);
- rad_assert(treq_a->pub.trunk == treq_b->pub.trunk);
+ fr_assert(treq_a->pub.trunk == treq_b->pub.trunk);
return treq_a->pub.trunk->funcs.request_prioritise(treq_a->pub.preq, treq_b->pub.preq);
}
break;
default:
- rad_assert(0);
+ fr_assert(0);
break;
}
{
fr_trunk_t *trunk = treq->pub.trunk;
- rad_assert(tconn->pub.trunk == trunk);
- rad_assert(IS_SERVICEABLE(tconn));
+ fr_assert(tconn->pub.trunk == trunk);
+ fr_assert(IS_SERVICEABLE(tconn));
switch (treq->pub.state) {
case FR_TRUNK_REQUEST_STATE_INIT:
case FR_TRUNK_REQUEST_STATE_UNASSIGNED:
- rad_assert(!treq->pub.tconn);
+ fr_assert(!treq->pub.tconn);
break;
case FR_TRUNK_REQUEST_STATE_BACKLOG:
- rad_assert(!treq->pub.tconn);
+ fr_assert(!treq->pub.tconn);
REQUEST_EXTRACT_BACKLOG(treq);
break;
REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_PARTIAL);
}
- rad_assert(!tconn->partial);
+ fr_assert(!tconn->partial);
tconn->partial = treq;
REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_PARTIAL);
fr_trunk_t *trunk = treq->pub.trunk;
if (!fr_cond_assert(!tconn || (tconn->pub.trunk == trunk))) return;
- rad_assert(trunk->funcs.request_cancel_mux);
- rad_assert(treq->cancel_reason == FR_TRUNK_CANCEL_REASON_SIGNAL);
+ fr_assert(trunk->funcs.request_cancel_mux);
+ fr_assert(treq->cancel_reason == FR_TRUNK_CANCEL_REASON_SIGNAL);
switch (treq->pub.state) {
case FR_TRUNK_REQUEST_STATE_CANCEL: /* The only valid state cancel_sent can be reached from */
}
REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL);
- rad_assert(!tconn->partial);
+ fr_assert(!tconn->partial);
tconn->cancel_partial = treq;
}
fr_trunk_t *trunk = treq->pub.trunk;
if (!fr_cond_assert(!tconn || (tconn->pub.trunk == trunk))) return;
- rad_assert(trunk->funcs.request_cancel_mux);
- rad_assert(treq->cancel_reason == FR_TRUNK_CANCEL_REASON_SIGNAL);
+ fr_assert(trunk->funcs.request_cancel_mux);
+ fr_assert(treq->cancel_reason == FR_TRUNK_CANCEL_REASON_SIGNAL);
switch (treq->pub.state) {
case FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL:
/*
* Must *NOT* still be assigned to another connection
*/
- rad_assert(!treq->pub.tconn);
+ fr_assert(!treq->pub.tconn);
rcode = trunk_request_check_enqueue(&tconn, trunk, treq->pub.request);
switch (rcode) {
#define DEQUEUE_ALL(_src_list, _state) \
while ((treq = fr_dlist_head(_src_list))) { \
OVER_MAX_CHECK; \
- rad_assert(treq->pub.state == (_state)); \
+ fr_assert(treq->pub.state == (_state)); \
trunk_request_enter_unassigned(treq); \
fr_dlist_insert_tail(out, treq); \
}
OVER_MAX_CHECK;
treq = tconn->cancel_partial;
if (treq) {
- rad_assert(treq->pub.state == FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL);
+ fr_assert(treq->pub.state == FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL);
trunk_request_enter_unassigned(treq);
fr_dlist_insert_tail(out, treq);
}
if (states & FR_TRUNK_REQUEST_STATE_PENDING) {
while ((treq = fr_heap_peek(tconn->pending))) {
OVER_MAX_CHECK;
- rad_assert(treq->pub.state == FR_TRUNK_REQUEST_STATE_PENDING);
+ fr_assert(treq->pub.state == FR_TRUNK_REQUEST_STATE_PENDING);
trunk_request_enter_unassigned(treq);
fr_dlist_insert_tail(out, treq);
}
OVER_MAX_CHECK;
treq = tconn->partial;
if (treq) {
- rad_assert(treq->pub.state == FR_TRUNK_REQUEST_STATE_PARTIAL);
+ fr_assert(treq->pub.state == FR_TRUNK_REQUEST_STATE_PARTIAL);
/*
* Don't allow the connection to change state whilst
fr_connection_signals_pause(tconn->pub.conn);
while ((treq = fr_dlist_head(&tconn->sent))) {
OVER_MAX_CHECK;
- rad_assert(treq->pub.state == FR_TRUNK_REQUEST_STATE_SENT);
+ fr_assert(treq->pub.state == FR_TRUNK_REQUEST_STATE_SENT);
trunk_request_enter_cancel(treq, FR_TRUNK_CANCEL_REASON_MOVE);
trunk_request_enter_unassigned(treq);
break;
default:
- rad_assert(0);
+ fr_assert(0);
break;
}
treq = fr_dlist_head(&trunk->free_requests);
if (treq) {
fr_dlist_remove(&trunk->free_requests, treq);
- rad_assert(treq->pub.state == FR_TRUNK_REQUEST_STATE_INIT);
- rad_assert(treq->pub.trunk == trunk);
- rad_assert(treq->pub.tconn == NULL);
- rad_assert(treq->cancel_reason == FR_TRUNK_CANCEL_REASON_NONE);
- rad_assert(treq->last_freed > 0);
+ fr_assert(treq->pub.state == FR_TRUNK_REQUEST_STATE_INIT);
+ fr_assert(treq->pub.trunk == trunk);
+ fr_assert(treq->pub.tconn == NULL);
+ fr_assert(treq->cancel_reason == FR_TRUNK_CANCEL_REASON_NONE);
+ fr_assert(treq->last_freed > 0);
trunk->pub.req_alloc_reused++;
} else {
MEM(treq = talloc_pooled_object(trunk, fr_trunk_request_t,
case FR_TRUNK_CONN_CONNECTING:
trunk_connection_remove(tconn);
- rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0);
+ fr_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0);
break;
default:
* connecting state, it should have
* no requests associated with it.
*/
- rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0);
+ fr_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0);
fr_dlist_insert_head(&trunk->connecting, tconn); /* MUST remain a head insertion for reconnect logic */
CONN_STATE_TRANSITION(FR_TRUNK_CONN_CONNECTING, INFO);
* it should have no requests associated
* with it.
*/
- rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0);
+ fr_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0);
/*
* Set here, as the active state can
case FR_TRUNK_CONN_CONNECTING:
trunk_connection_remove(tconn);
- rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0);
+ fr_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0);
break;
case FR_TRUNK_CONN_INIT:
* connection. They should have all been
* moved off or failed.
*/
- rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0);
+ fr_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0);
/*
* Clear statistics and flags
* connection. They should have all been
* moved off or failed.
*/
- rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0);
+ fr_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0);
/*
* And free the connection...
*/
static int _trunk_connection_free(fr_trunk_connection_t *tconn)
{
- rad_assert(tconn->pub.state == FR_TRUNK_CONN_HALTED);
- rad_assert(!fr_dlist_entry_in_list(&tconn->entry)); /* Should not be in a list */
+ fr_assert(tconn->pub.state == FR_TRUNK_CONN_HALTED);
+ fr_assert(!fr_dlist_entry_in_list(&tconn->entry)); /* Should not be in a list */
/*
* Loop over all the requests we gathered
* that a call to trunk_requests_per_connnection
* was missed.
*/
- rad_assert(trunk->pub.last_above_target >= trunk->pub.last_below_target);
+ fr_assert(trunk->pub.last_above_target >= trunk->pub.last_below_target);
/*
* We don't consider 'draining' connections
* that a call to trunk_requests_per_connnection
* was missed.
*/
- rad_assert(trunk->pub.last_below_target > trunk->pub.last_above_target);
+ fr_assert(trunk->pub.last_below_target > trunk->pub.last_above_target);
if (!conn_count) {
DEBUG4("Not closing connection - No connections to close!");
continue;
case FR_TRUNK_ENQUEUE_NO_CAPACITY:
- rad_assert(fr_heap_num_elements(trunk->active) == 0);
+ fr_assert(fr_heap_num_elements(trunk->active) == 0);
return;
}
}
break;
default:
- rad_assert(0);
+ fr_assert(0);
break;
}
} while (slen >= 0);
break;
default:
- rad_assert(0);
+ fr_assert(0);
}
}
static size_t to_write;
ssize_t slen;
- rad_assert(fd == our_h[1]);
+ fr_assert(fd == our_h[1]);
while (true) {
slen = read(fd, buff, sizeof(buff));
RCSID("$Id$")
#include <freeradius-devel/server/log.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/users_file.h>
#include <freeradius-devel/util/misc.h>
/*
* Parse the check values
*/
- rad_assert(check_tmp == NULL);
- rad_assert(reply_tmp == NULL);
+ fr_assert(check_tmp == NULL);
+ fr_assert(reply_tmp == NULL);
parsecode = fr_pair_list_afrom_str(t, dict, ptr, &check_tmp);
if (parsecode == T_INVALID) {
RCSID("$Id$")
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/stats.h>
#include <freeradius-devel/server/util.h>
int rcode = 0;
CONF_SECTION *subcs = NULL;
- rad_assert(strcmp(cf_section_name1(server_cs), "server") == 0);
+ fr_assert(strcmp(cf_section_name1(server_cs), "server") == 0);
while ((subcs = cf_section_find_next(server_cs, subcs, subcs_name, CF_IDENT_ANY))) {
char const *name2;
size_t i, server_cnt = virtual_servers ? talloc_array_length(virtual_servers) : 0;
rbtree_t *vns_tree = cf_data_value(cf_data_find(virtual_server_root, rbtree_t, "vns_tree"));
- rad_assert(virtual_servers);
+ fr_assert(virtual_servers);
DEBUG2("#### Instantiating listeners ####");
for (j = 0; j < listen_cnt; j++) {
fr_virtual_listen_t *listen = listener[j];
- rad_assert(listen != NULL);
- rad_assert(listen->proto_module != NULL);
- rad_assert(listen->app != NULL);
+ fr_assert(listen != NULL);
+ fr_assert(listen->proto_module != NULL);
+ fr_assert(listen->app != NULL);
if (listen->app->instantiate &&
listen->app->instantiate(listen->proto_module->data, listen->proto_module->conf) < 0) {
for (j = 0; j < listen_cnt; j++) {
fr_virtual_listen_t *listen = listener[j];
- rad_assert(listen != NULL);
- rad_assert(listen->proto_module != NULL);
+ fr_assert(listen != NULL);
+ fr_assert(listen->proto_module != NULL);
(void) talloc_get_type_abort(listen, fr_virtual_listen_t);
{
size_t i, server_cnt = virtual_servers ? talloc_array_length(virtual_servers) : 0;
- rad_assert(virtual_servers);
+ fr_assert(virtual_servers);
DEBUG2("#### Opening listener interfaces ####");
for (j = 0; j < listen_cnt; j++) {
fr_virtual_listen_t *listen = listener[j];
- rad_assert(listen != NULL);
- rad_assert(listen->proto_module != NULL);
- rad_assert(listen->app != NULL);
+ fr_assert(listen != NULL);
+ fr_assert(listen->proto_module != NULL);
+ fr_assert(listen->app != NULL);
/*
* The socket is opened with app_instance,
rbtree_t *vns_tree;
fr_virtual_namespace_t *vns;
- rad_assert(virtual_server_root); /* Virtual server bootstrap must be called first */
+ fr_assert(virtual_server_root); /* Virtual server bootstrap must be called first */
MEM(vns = talloc_zero(NULL, fr_virtual_namespace_t));
vns->namespace = talloc_strdup(vns, namespace);
CONF_SECTION *subcs;
fr_dict_t const *dict_internal;
- rad_assert(request->server_cs != NULL);
+ fr_assert(request->server_cs != NULL);
/*
* Cache the old server_cs in case it was changed.
memset(&parse_rules, 0, sizeof(parse_rules));
parse_rules.dict_def = virtual_server_namespace(cf_section_name2(server));
- rad_assert(parse_rules.dict_def != NULL);
+ fr_assert(parse_rules.dict_def != NULL);
/*
* Instantiate the process modules
{
virtual_server_compile_t *old;
- rad_assert(server_section_name_tree != NULL);
+ fr_assert(server_section_name_tree != NULL);
old = rbtree_finddata(server_section_name_tree, entry);
if (old) return 0;
{
virtual_server_compile_t *entry;
- rad_assert(server_section_name_tree != NULL);
+ fr_assert(server_section_name_tree != NULL);
/*
* Look up the specific name first. That way we can
{
virtual_server_compile_t *entry;
- rad_assert(server_section_name_tree != NULL);
+ fr_assert(server_section_name_tree != NULL);
/*
* Look up the specific name first. That way we can
*
* @copyright 2003-2016 The FreeRADIUS server project
*/
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/dict.h>
#include <freeradius-devel/protocol/eap/sim/dictionary.h>
#include <freeradius-devel/protocol/eap/sim/rfc4187.h>
#include <freeradius-devel/util/base.h>
#include <freeradius-devel/util/sha1.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/tls/base.h>
RCSID("$Id$")
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "base.h"
/*
soh_tlv tlv;
int curr_shid =- 1, curr_shid_c =- 1, curr_hc =- 1;
- rad_assert(request->packet != NULL);
+ fr_assert(request->packet != NULL);
hdr.tlv_type = soh_pull_be_16(data); data += 2;
hdr.tlv_len = soh_pull_be_16(data); data += 2;
#include <openssl/conf.h>
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "base.h"
#include "attrs.h"
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/base.h>
#include "base.h"
* of the tls_session, as the fields aren't re-populated on
* resumption.
*/
- rad_assert(!tls_session->session_id);
- rad_assert(!tls_session->session_blob);
+ fr_assert(!tls_session->session_id);
+ fr_assert(!tls_session->session_blob);
key_len = fr_tls_cache_id(&key, sess);
if (key_len == 0) {
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/syserror.h>
#include "base.h"
#include <freeradius-devel/util/misc.h>
#include <freeradius-devel/util/syserror.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <openssl/rand.h>
#include <openssl/dh.h>
/*
* Conf parser should ensure they're both populated
*/
- rad_assert(chain->certificate_file && chain->private_key_file);
+ fr_assert(chain->certificate_file && chain->private_key_file);
/*
* Set the password (this should have been retrieved earlier)
break;
default:
- rad_assert(0);
+ fr_assert(0);
break;
}
break;
default:
- rad_assert(0);
+ fr_assert(0);
fclose(fp);
return -1;
}
#define LOG_PREFIX "tls - "
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "base.h"
#include "missing.h"
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/pair.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/misc.h>
goto error;
}
- rad_assert(issuer_cert);
+ fr_assert(issuer_cert);
ret = fr_tls_ocsp_check(request, ssl, server_store, issuer_cert, cert, conf, true);
switch (ret) {
goto skipped;
case 1:
- rad_assert(host && port && path);
+ fr_assert(host && port && path);
break;
}
}
#ifdef HAVE_OPENSSL_OCSP_H
#define LOG_PREFIX "tls - "
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/pair.h>
#include <freeradius-devel/util/misc.h>
old = SSL_get_ex_data(ssl, FR_TLS_EX_INDEX_REQUEST);
if (old) {
(void)talloc_get_type_abort(ssl, REQUEST);
- rad_assert(0);
+ fr_assert(0);
}
#endif
ret = SSL_set_ex_data(ssl, FR_TLS_EX_INDEX_REQUEST, request);
if (unlikely(ret == 0)) {
- rad_assert(0);
+ fr_assert(0);
return;
}
}
#endif
ret = SSL_set_ex_data(ssl, FR_TLS_EX_INDEX_REQUEST, NULL);
if (unlikely(ret == 0)) {
- rad_assert(0);
+ fr_assert(0);
return;
}
}
if (attr_index > 1) attr_index = 1;
request = (REQUEST *)SSL_get_ex_data(session->ssl, FR_TLS_EX_INDEX_REQUEST);
- rad_assert(request != NULL);
+ fr_assert(request != NULL);
identity = (char **)SSL_get_ex_data(session->ssl, FR_TLS_EX_INDEX_IDENTITY);
talloc_set_destructor(session, _fr_tls_session_free);
session->ctx = conf->ctx[(conf->ctx_count == 1) ? 0 : conf->ctx_next++ % conf->ctx_count]; /* mutex not needed */
- rad_assert(session->ctx);
+ fr_assert(session->ctx);
session->ssl = SSL_new(session->ctx);
if (!session->ssl) {
VALUE_PAIR *vp;
SSL_CTX *ssl_ctx;
- rad_assert(request != NULL);
- rad_assert(conf->ctx_count > 0);
+ fr_assert(request != NULL);
+ fr_assert(conf->ctx_count > 0);
RDEBUG2("Initiating new TLS session");
ssl_ctx = conf->ctx[(conf->ctx_count == 1) ? 0 : conf->ctx_next++ % conf->ctx_count]; /* mutex not needed */
- rad_assert(ssl_ctx);
+ fr_assert(ssl_ctx);
new_tls = SSL_new(ssl_ctx);
if (new_tls == NULL) {
* As the context ID must be <= 32, we digest the context
* data with sha256.
*/
- rad_assert(conf->session_id_name);
+ fr_assert(conf->session_id_name);
{
char *context_id;
EVP_MD_CTX *md_ctx;
#include <freeradius-devel/server/exec.h>
#include <freeradius-devel/server/pair.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/strerror.h>
#include <freeradius-devel/util/syserror.h>
*/
void unlang_register(int type, unlang_op_t *op)
{
- rad_assert(type < UNLANG_TYPE_MAX); /* Unlang max isn't a valid type */
+ fr_assert(type < UNLANG_TYPE_MAX); /* Unlang max isn't a valid type */
memcpy(&unlang_ops[type], op, sizeof(unlang_ops[type]));
}
vpt = *pvpt;
- rad_assert(tmpl_is_xlat(vpt) || tmpl_is_exec(vpt));
+ fr_assert(tmpl_is_xlat(vpt) || tmpl_is_exec(vpt));
slen = xlat_tokenize(vpt, &head, vpt->name, talloc_array_length(vpt->name) - 1, rules);
ssize_t slen;
regex_t *preg;
- rad_assert(tmpl_is_regex(vpt));
+ fr_assert(tmpl_is_regex(vpt));
/*
* It's a dynamic expansion. We can't expand the string,
{
fr_dict_attr_t const *da;
- rad_assert(tmpl_is_attr_undefined(vpt));
+ fr_assert(tmpl_is_attr_undefined(vpt));
if (fr_dict_attr_by_qualified_name(&da, rules->dict_def, vpt->tmpl_unknown_name, true) != FR_DICT_ATTR_OK) {
ssize_t slen;
/*
* Just in case someone adds a new fixup later.
*/
- rad_assert((c->pass2_fixup == PASS2_FIXUP_NONE) ||
+ fr_assert((c->pass2_fixup == PASS2_FIXUP_NONE) ||
(c->pass2_fixup == PASS2_PAIRCOMPARE));
/*
return false;
}
}
- rad_assert(!tmpl_is_regex(map->lhs));
+ fr_assert(!tmpl_is_regex(map->lhs));
#endif
/*
* Fix up the template.
*/
case COND_TYPE_EXISTS:
- rad_assert(!tmpl_is_regex(c->data.vpt));
+ fr_assert(!tmpl_is_regex(c->data.vpt));
return pass2_fixup_tmpl(c->ci, &c->data.vpt, unlang_ctx->rules, true);
/*
* Nothing else has pass2 fixups
*/
default:
- rad_assert(0);
+ fr_assert(0);
return false;
}
}
static bool pass2_fixup_update_map(vp_map_t *map, vp_tmpl_rules_t const *rules)
{
if (tmpl_is_xlat(map->lhs) || tmpl_is_exec(map->lhs)) {
- rad_assert(map->lhs->tmpl_xlat == NULL);
+ fr_assert(map->lhs->tmpl_xlat == NULL);
/*
* FIXME: compile to attribute && handle
if (map->rhs) {
if (tmpl_is_xlat(map->rhs) || tmpl_is_exec(map->rhs)) {
- rad_assert(map->rhs->tmpl_xlat == NULL);
+ fr_assert(map->rhs->tmpl_xlat == NULL);
/*
* FIXME: compile to attribute && handle
}
}
- rad_assert(!tmpl_is_regex(map->rhs));
+ fr_assert(!tmpl_is_regex(map->rhs));
if (tmpl_is_attr_undefined(map->rhs)) {
if (!pass2_fixup_undefined(map->ci, map->rhs, rules)) return false;
if (!g->children) {
g->children = g->tail = c;
} else {
- rad_assert(g->tail->next == NULL);
+ fr_assert(g->tail->next == NULL);
g->tail->next = c;
g->tail = c;
}
}
}
} else {
- rad_assert(0);
+ fr_assert(0);
}
}
}
f = unlang_generic_to_group(parent);
- rad_assert(f->vpt != NULL);
+ fr_assert(f->vpt != NULL);
/*
* Do type-specific checks on the case statement
*/
if (tmpl_is_unparsed(vpt) &&
tmpl_is_attr(f->vpt)) {
- rad_assert(f->vpt->tmpl_da != NULL);
+ fr_assert(f->vpt->tmpl_da != NULL);
if (tmpl_cast_in_place(vpt, f->vpt->tmpl_da->type, f->vpt->tmpl_da) < 0) {
cf_log_err(cs, "Invalid argument for case statement: %s",
* If we don't have a negative return code, we must have a vpt
* (mostly to quiet coverity).
*/
- rad_assert(vpt);
+ fr_assert(vpt);
if (!tmpl_is_attr(vpt) && !tmpl_is_list(vpt)) {
cf_log_err(cs, "MUST use attribute or list reference (not %s) in 'foreach'",
}
cond = cf_data_value(cf_data_find(cs, fr_cond_t, NULL));
- rad_assert(cond != NULL);
+ fr_assert(cond != NULL);
if (cond->type == COND_TYPE_FALSE) {
cf_log_debug_prefix(cs, "Skipping contents of '%s' as it is always 'false'",
return NULL;
}
- rad_assert(g->vpt != NULL);
+ fr_assert(g->vpt != NULL);
/*
* Fixup the templates
unlang_group_t *g;
g = unlang_generic_to_group(instruction);
- rad_assert(g->cond != NULL);
+ fr_assert(g->cond != NULL);
condition = cond_eval(request, *presult, 0, g->cond);
if (condition < 0) {
if (!vp) {
*presult = frame->result;
#ifndef NDEBUG
- rad_assert(foreach->indent == request->log.unlang_indent);
+ fr_assert(foreach->indent == request->log.unlang_indent);
#endif
return UNLANG_ACTION_CALCULATE_RESULT;
}
RDEBUG2("# looping with: Foreach-Variable-%d = %pV", foreach->depth, &vp->data);
#endif
- rad_assert(vp);
+ fr_assert(vp);
/*
* Add the vp to the request, so that
return UNLANG_ACTION_CALCULATE_RESULT;
}
- rad_assert(vps != NULL);
+ fr_assert(vps != NULL);
foreach->request = request;
foreach->depth = foreach_depth;
unlang_stack_t *stack = request->stack;
unlang_stack_frame_t *frame;
- rad_assert(instruction || top_frame);
+ fr_assert(instruction || top_frame);
#ifndef NDEBUG
if (DEBUG_ENABLED5) RDEBUG3("unlang_interpret_push called with instruction %s - args %s %s",
frame->instruction = instruction;
if (do_next_sibling) {
- rad_assert(instruction != NULL);
+ fr_assert(instruction != NULL);
frame->next = instruction->next;
}
/* else frame->next MUST be NULL */
/*
* Not allowed in frame uflags...
*/
- rad_assert(!(frame->uflags & UNWIND_FLAG_NO_CLEAR));
+ fr_assert(!(frame->uflags & UNWIND_FLAG_NO_CLEAR));
/*
* If we are unwinding the stack due to a break / return,
{
unlang_stack_frame_t *frame;
- rad_assert(stack->depth > 1);
+ fr_assert(stack->depth > 1);
frame = &stack->frame[stack->depth];
DUMP_STACK;
- rad_assert(instruction->debug_name != NULL); /* if this happens, all bets are off. */
+ fr_assert(instruction->debug_name != NULL); /* if this happens, all bets are off. */
REQUEST_VERIFY(request);
RDEBUG4("** [%i] %s >> %s", stack->depth, __FUNCTION__,
unlang_ops[instruction->type].name);
- rad_assert(frame->interpret != NULL);
+ fr_assert(frame->interpret != NULL);
action = frame->interpret(request, result);
RDEBUG4("** [%i] %s << %s (%d)", stack->depth, __FUNCTION__,
fr_table_str_by_value(unlang_action_table, action, "<INVALID>"), *priority);
- rad_assert(*priority >= -1);
- rad_assert(*priority <= MOD_PRIORITY_MAX);
+ fr_assert(*priority >= -1);
+ fr_assert(*priority <= MOD_PRIORITY_MAX);
switch (action) {
/*
* now continue at the deepest frame.
*/
case UNLANG_ACTION_PUSHED_CHILD:
- rad_assert(&stack->frame[stack->depth] > frame);
+ fr_assert(&stack->frame[stack->depth] > frame);
*result = frame->result;
return UNLANG_FRAME_ACTION_NEXT;
frame->result = *result;
frame->priority = *priority;
frame->next = NULL;
- rad_assert(stack->unwind != UNWIND_FLAG_NONE);
+ fr_assert(stack->unwind != UNWIND_FLAG_NONE);
return UNLANG_FRAME_ACTION_POP;
/*
return UNLANG_FRAME_ACTION_YIELD;
default:
- rad_assert(0);
+ fr_assert(0);
return UNLANG_FRAME_ACTION_YIELD;
}
*/
if (*result == RLM_MODULE_YIELD) goto yield;
- rad_assert(*result != RLM_MODULE_UNKNOWN);
+ fr_assert(*result != RLM_MODULE_UNKNOWN);
repeatable_clear(frame);
DUMP_STACK;
#endif
- rad_assert(!unlang_request_is_scheduled(request)); /* if we're running it, it can't be scheduled */
+ fr_assert(!unlang_request_is_scheduled(request)); /* if we're running it, it can't be scheduled */
RDEBUG4("** [%i] %s - interpreter entered", stack->depth, __FUNCTION__);
fr_table_str_by_value(unlang_frame_action_table, fa, "<INVALID>"));
switch (fa) {
case UNLANG_FRAME_ACTION_NEXT: /* Evaluate the current frame */
- rad_assert(stack->depth > 0);
- rad_assert(stack->depth < UNLANG_STACK_MAX);
+ fr_assert(stack->depth > 0);
+ fr_assert(stack->depth < UNLANG_STACK_MAX);
frame = &stack->frame[stack->depth];
fa = frame_eval(request, frame, &stack->result, &priority);
continue;
case UNLANG_FRAME_ACTION_YIELD:
- rad_assert(stack->result == RLM_MODULE_YIELD);
+ fr_assert(stack->result == RLM_MODULE_YIELD);
RDEBUG4("** [%i] %s - interpreter yielding", stack->depth, __FUNCTION__);
return stack->result;
}
el = fr_event_list_alloc(NULL, NULL, NULL);
if (!el) {
RPERROR("Failed creating temporary event loop");
- rad_assert(0); /* Cause debug builds to die */
+ fr_assert(0); /* Cause debug builds to die */
return RLM_MODULE_FAIL;
}
(void)talloc_get_type_abort(request, REQUEST); /* Check the request hasn't already been freed */
- rad_assert(stack->depth > 0);
+ fr_assert(stack->depth > 0);
/*
* Walk back up the stack, calling signal handlers
* are.
*/
while (request->parent) {
- rad_assert(!unlang_request_is_scheduled(request));
+ fr_assert(!unlang_request_is_scheduled(request));
request->runnable_id = -2; /* hack for now, see unlang_parallel_process() */
request = request->parent;
}
RDEBUG3("marking as resumable");
}
- rad_assert(request->backlog != NULL);
+ fr_assert(request->backlog != NULL);
fr_heap_insert(request->backlog, request);
}
}
g = (unlang_group_t const *) instruction;
- rad_assert(g->cs != NULL);
+ fr_assert(g->cs != NULL);
return snprintf(*out, outlen, "%d", cf_lineno(g->cs));
}
}
g = (unlang_group_t const *) instruction;
- rad_assert(g->cs != NULL);
+ fr_assert(g->cs != NULL);
return snprintf(*out, outlen, "%s", cf_filename(g->cs));
}
* process again.
*/
- rad_assert(instruction->type != UNLANG_TYPE_LOAD_BALANCE); /* this is never called again */
+ fr_assert(instruction->type != UNLANG_TYPE_LOAD_BALANCE); /* this is never called again */
/*
* If the current child says "return", then do
RCSID("$Id$")
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/map.h>
#include <freeradius-devel/unlang/xlat.h>
case UNLANG_UPDATE_MAP_INIT:
update_state->state = UNLANG_UPDATE_MAP_EXPANDED_LHS;
- rad_assert(!update_state->lhs_result); /* Should have been consumed */
- rad_assert(!update_state->rhs_result); /* Should have been consumed */
+ fr_assert(!update_state->lhs_result); /* Should have been consumed */
+ fr_assert(!update_state->rhs_result); /* Should have been consumed */
switch (map->lhs->type) {
default:
case TMPL_TYPE_REGEX:
case TMPL_TYPE_REGEX_STRUCT:
case TMPL_TYPE_XLAT:
- rad_assert(0);
+ fr_assert(0);
error:
TALLOC_FREE(frame->state);
case TMPL_TYPE_REGEX:
case TMPL_TYPE_REGEX_STRUCT:
case TMPL_TYPE_XLAT:
- rad_assert(0);
+ fr_assert(0);
goto error;
}
/* FALL-THROUGH */
case TMPL_TYPE_REGEX:
case TMPL_TYPE_REGEX_STRUCT:
case TMPL_TYPE_XLAT:
- rad_assert(0);
+ fr_assert(0);
goto error;
}
void *mutable_ctx;
void *mutable_inst;
- rad_assert(ev->fd == fd);
+ fr_assert(ev->fd == fd);
memcpy(&mutable_ctx, &ev->ctx, sizeof(mutable_ctx));
memcpy(&mutable_inst, &ev->inst, sizeof(mutable_inst));
unlang_frame_state_module_t *state = talloc_get_type_abort(frame->state,
unlang_frame_state_module_t);
- rad_assert(stack->depth > 0);
- rad_assert(frame->instruction->type == UNLANG_TYPE_MODULE);
+ fr_assert(stack->depth > 0);
+ fr_assert(frame->instruction->type == UNLANG_TYPE_MODULE);
sp = unlang_generic_to_module(frame->instruction);
ev = talloc_zero(request, unlang_module_event_t);
void *mutable_ctx;
void *mutable_inst;
- rad_assert(ev->fd == fd);
+ fr_assert(ev->fd == fd);
memcpy(&mutable_ctx, &ev->ctx, sizeof(mutable_ctx));
memcpy(&mutable_inst, &ev->inst, sizeof(mutable_inst));
void *mutable_ctx;
void *mutable_inst;
- rad_assert(ev->fd == fd);
+ fr_assert(ev->fd == fd);
memcpy(&mutable_ctx, &ev->ctx, sizeof(mutable_ctx));
memcpy(&mutable_inst, &ev->inst, sizeof(mutable_inst));
unlang_frame_state_module_t *state = talloc_get_type_abort(frame->state,
unlang_frame_state_module_t);
- rad_assert(stack->depth > 0);
+ fr_assert(stack->depth > 0);
- rad_assert(frame->instruction->type == UNLANG_TYPE_MODULE);
+ fr_assert(frame->instruction->type == UNLANG_TYPE_MODULE);
sp = unlang_generic_to_module(frame->instruction);
ev = talloc_zero(request, unlang_module_event_t);
MEM(state = talloc_zero(stack, unlang_frame_state_module_t));
state->presult = out;
state->thread = module_thread(module_instance);
- rad_assert(state->thread != NULL);
+ fr_assert(state->thread != NULL);
/*
* We need to have a unlang_module_t to push on the
unlang_t *instruction = frame->instruction;
unlang_module_t *sp;
- rad_assert(instruction->type == UNLANG_TYPE_MODULE);
+ fr_assert(instruction->type == UNLANG_TYPE_MODULE);
sp = unlang_generic_to_module(instruction);
/*
rlm_rcode_t rcode;
int stack_depth = stack->depth;
- rad_assert(state->resume != NULL);
+ fr_assert(state->resume != NULL);
/*
* Lock is noop unless instance->mutex is set.
if (rcode == RLM_MODULE_YIELD) {
if (stack_depth < stack->depth) return UNLANG_ACTION_PUSHED_CHILD;
- rad_assert(stack_depth == stack->depth);
+ fr_assert(stack_depth == stack->depth);
*presult = rcode;
return UNLANG_ACTION_YIELD;
}
* to dealing with it's parent.
*/
sp = unlang_generic_to_module(instruction);
- rad_assert(sp);
+ fr_assert(sp);
RDEBUG4("[%i] %s - %s (%s)", stack->depth, __FUNCTION__,
sp->module_instance->name, sp->module_instance->module->name);
*/
state->thread = module_thread(sp->module_instance);
state->presult = NULL;
- rad_assert(state->thread != NULL);
+ fr_assert(state->thread != NULL);
/*
* Return administratively configured return code
if (rcode == RLM_MODULE_YIELD) {
state->thread->active_callers++;
if (stack_depth < stack->depth) return UNLANG_ACTION_PUSHED_CHILD;
- rad_assert(stack_depth == stack->depth);
+ fr_assert(stack_depth == stack->depth);
*presult = rcode;
frame->interpret = unlang_module_resume;
return UNLANG_ACTION_YIELD;
}
done:
- rad_assert(unlang_indent == request->log.unlang_indent);
- rad_assert(rcode >= RLM_MODULE_REJECT);
- rad_assert(rcode < RLM_MODULE_NUMCODES);
+ fr_assert(unlang_indent == request->log.unlang_indent);
+ fr_assert(rcode >= RLM_MODULE_REJECT);
+ fr_assert(rcode < RLM_MODULE_NUMCODES);
/*
* The module is done. But, running it pushed one or
static inline unlang_module_t *unlang_generic_to_module(unlang_t *p)
{
- rad_assert(p->type == UNLANG_TYPE_MODULE);
+ fr_assert(p->type == UNLANG_TYPE_MODULE);
return talloc_get_type_abort(p, unlang_module_t);
}
*/
case CHILD_INIT:
RDEBUG3("parallel child %d is INIT", i);
- rad_assert(state->children[i].instruction != NULL);
+ fr_assert(state->children[i].instruction != NULL);
child = unlang_io_subrequest_alloc(request,
request->dict, state->detach);
child->packet->code = request->packet->code;
state->children[i].state = CHILD_DONE;
state->children[i].instruction = NULL;
- rad_assert(request->backlog != NULL);
+ fr_assert(request->backlog != NULL);
/*
* Detach the child, and insert
RDEBUG3("parallel child %s returns %s", state->children[i].child->name,
fr_table_str_by_value(mod_rcode_table, result, "<invalid>"));
- rad_assert(result < NUM_ELEMENTS(state->children[i].instruction->actions));
+ fr_assert(result < NUM_ELEMENTS(state->children[i].instruction->actions));
/*
* Re-run all of the logic from interpret.c
*/
if (child_state == CHILD_YIELDED) continue;
- rad_assert(child_state == CHILD_DONE);
+ fr_assert(child_state == CHILD_DONE);
break;
/*
* Not ready to run.
*/
case CHILD_YIELDED:
- rad_assert(state->children[i].child != NULL);
+ fr_assert(state->children[i].child != NULL);
if (state->children[i].child->runnable_id == -2) { /* see unlang_interpret_resumable() */
(void) fr_heap_extract(state->children[i].child->backlog,
goto runnable;
}
- rad_assert(state->children[i].instruction != NULL);
+ fr_assert(state->children[i].instruction != NULL);
RDEBUG3("parallel child %s is already YIELDED", state->children[i].child->name);
child_state = CHILD_YIELDED;
continue;
*/
case CHILD_DONE:
RDEBUG3("parallel child %d is already DONE", i);
- rad_assert(state->children[i].child == NULL);
- rad_assert(state->children[i].instruction == NULL);
+ fr_assert(state->children[i].child == NULL);
+ fr_assert(state->children[i].instruction == NULL);
continue;
}
return UNLANG_ACTION_YIELD;
}
- rad_assert(child_state == CHILD_DONE);
+ fr_assert(child_state == CHILD_DONE);
/*
* Clean up all of the child requests, because once we
for (i = 0; i < state->num_children; i++) {
switch (state->children[i].state) {
case CHILD_RUNNABLE:
- rad_assert(state->children[i].child->backlog == NULL);
- rad_assert(state->children[i].child->runnable_id < 0);
+ fr_assert(state->children[i].child->backlog == NULL);
+ fr_assert(state->children[i].child->runnable_id < 0);
/*
* Un-detached children are never in the
case CHILD_YIELDED:
REQUEST_VERIFY(state->children[i].child);
- rad_assert(state->children[i].child->runnable_id < 0);
+ fr_assert(state->children[i].child->runnable_id < 0);
/*
* Signal the child that it's going to be
case CHILD_RUNNABLE:
case CHILD_YIELDED:
- rad_assert(state->children[i].child != NULL);
+ fr_assert(state->children[i].child != NULL);
unlang_interpret_signal(state->children[i].child, action);
break;
}
* from the backlog.
*/
if (unlang_request_is_scheduled(request)) {
- rad_assert(request->backlog != NULL);
+ fr_assert(request->backlog != NULL);
(void) fr_heap_extract(request->backlog, request);
}
REQUEST *child = talloc_get_type_abort(state->child, REQUEST);
rlm_rcode_t rcode;
- rad_assert(child != NULL);
+ fr_assert(child != NULL);
rcode = unlang_interpret(child);
if (rcode != RLM_MODULE_YIELD) {
/*
* Mark the child as runnable.
*/
- rad_assert(request->parent == NULL);
+ fr_assert(request->parent == NULL);
if (fr_heap_insert(request->backlog, request) < 0) {
RPERROR("Failed inserting ourself into the backlog.");
return -1;
*/
RDEBUG2("detach");
- rad_assert(request->parent != NULL);
+ fr_assert(request->parent != NULL);
/*
* Get the PARENT's stack.
* The parent frame no longer has a child, and therefore
* can't be signaled.
*/
- rad_assert(parent_state->child == request);
+ fr_assert(parent_state->child == request);
parent_state->child = NULL;
frame->signal = NULL;
map.op = T_OP_CMP_EQ;
map.ci = cf_section_to_item(g->cs);
- rad_assert(g->vpt != NULL);
+ fr_assert(g->vpt != NULL);
null_case = found = NULL;
data.datum.ptr = NULL;
if (tmpl_is_attr(g->vpt) && (tmpl_find_vp(NULL, request, g->vpt) < 0)) {
find_null_case:
for (this = g->children; this; this = this->next) {
- rad_assert(this->type == UNLANG_TYPE_CASE);
+ fr_assert(this->type == UNLANG_TYPE_CASE);
h = unlang_generic_to_group(this);
if (h->vpt) continue;
* "case {...}" statement.
*/
for (this = g->children; this; this = this->next) {
- rad_assert(this->type == UNLANG_TYPE_CASE);
+ fr_assert(this->type == UNLANG_TYPE_CASE);
h = unlang_generic_to_group(this);
state->status = status;
- rad_assert(state->pid == 0);
- rad_assert(state->fd < 0);
- rad_assert(state->ev == NULL);
-
+ fr_assert(state->pid == 0);
+ fr_assert(state->fd < 0);
+ fr_assert(state->ev == NULL);
unlang_interpret_resumable(request);
}
return;
}
- rad_assert(p < end);
+ fr_assert(p < end);
state->ptr = p;
}
#include <freeradius-devel/server/cond_eval.h>
#include <freeradius-devel/server/map_proc.h>
#include <freeradius-devel/server/modpriv.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/base.h>
#include <freeradius-devel/io/listen.h>
*/
static inline unlang_group_t *unlang_generic_to_group(unlang_t *p)
{
- rad_assert((p->type > UNLANG_TYPE_MODULE) && (p->type <= UNLANG_TYPE_POLICY));
+ fr_assert((p->type > UNLANG_TYPE_MODULE) && (p->type <= UNLANG_TYPE_POLICY));
return (unlang_group_t *)p;
}
static inline unlang_tmpl_t *unlang_generic_to_tmpl(unlang_t *p)
{
- rad_assert(p->type == UNLANG_TYPE_TMPL);
+ fr_assert(p->type == UNLANG_TYPE_TMPL);
return talloc_get_type_abort(p, unlang_tmpl_t);
}
RCSID("$Id$")
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <ctype.h>
#include <freeradius-devel/unlang/xlat_priv.h>
unlang_xlat_event_t *ev;
unlang_frame_state_xlat_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_xlat_t);
- rad_assert(stack->depth > 0);
- rad_assert(frame->instruction->type == UNLANG_TYPE_XLAT);
+ fr_assert(stack->depth > 0);
+ fr_assert(frame->instruction->type == UNLANG_TYPE_XLAT);
ev = talloc_zero(request, unlang_xlat_event_t);
if (!ev) return -1;
switch (xa) {
case XLAT_ACTION_PUSH_CHILD:
- rad_assert(child);
+ fr_assert(child);
repeatable_set(frame);
return UNLANG_ACTION_CALCULATE_RESULT;
}
- rad_assert(0);
+ fr_assert(0);
*presult = RLM_MODULE_FAIL;
return UNLANG_ACTION_CALCULATE_RESULT;
}
unlang_frame_state_xlat_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_xlat_t);
xlat_action_t xa;
- rad_assert(state->resume != NULL);
+ fr_assert(state->resume != NULL);
xa = xlat_frame_eval_resume(state->ctx, &state->values,
state->resume, state->exp,
return UNLANG_ACTION_CALCULATE_RESULT;
case XLAT_ACTION_PUSH_CHILD:
- rad_assert(0);
+ fr_assert(0);
/* FALL-THROUGH */
case XLAT_ACTION_FAIL:
/* DON'T SET DEFAULT */
}
- rad_assert(0); /* Garbage xlat action */
+ fr_assert(0); /* Garbage xlat action */
*presult = RLM_MODULE_FAIL;
return UNLANG_ACTION_CALCULATE_RESULT;
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/cond.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/regex.h>
#include <freeradius-devel/unlang/xlat_priv.h>
char const *name;
xlat_t *xlat;
- rad_assert((*out == NULL) && (outlen == 0)); /* Caller must not have allocated buf */
- rad_assert(xr->type == XLAT_REDUNDANT);
+ fr_assert((*out == NULL) && (outlen == 0)); /* Caller must not have allocated buf */
+ fr_assert(xr->type == XLAT_REDUNDANT);
/*
* Pick the first xlat which succeeds
if (!cf_item_is_pair(ci)) continue;
name = cf_pair_attr(cf_item_to_pair(ci));
- rad_assert(name != NULL);
+ fr_assert(name != NULL);
xlat = xlat_func_find(name, -1);
if (!xlat) continue;
char const *name;
xlat_t *xlat;
- rad_assert((*out == NULL) && (outlen == 0)); /* Caller must not have allocated buf */
+ fr_assert((*out == NULL) && (outlen == 0)); /* Caller must not have allocated buf */
/*
* Choose a child at random.
if (xr->type == XLAT_LOAD_BALANCE) {
ssize_t slen;
name = cf_pair_attr(cf_item_to_pair(found));
- rad_assert(name != NULL);
+ fr_assert(name != NULL);
xlat = xlat_func_find(name, -1);
if (!xlat) return -1;
return slen;
}
- rad_assert(xr->type == XLAT_REDUNDANT_LOAD_BALANCE);
+ fr_assert(xr->type == XLAT_REDUNDANT_LOAD_BALANCE);
/*
* Try the random one we found. If it fails, keep going
ci = found;
do {
name = cf_pair_attr(cf_item_to_pair(ci));
- rad_assert(name != NULL);
+ fr_assert(name != NULL);
xlat = xlat_func_find(name, -1);
if (xlat) {
} else if (strcmp(name1, "load-balance") == 0) {
xr->type = XLAT_LOAD_BALANCE;
} else {
- rad_assert(0);
+ fr_assert(0);
}
xr->cs = cs;
break;
default:
- rad_assert(0);
+ fr_assert(0);
}
fr_cursor_append(&to_merge, nvp);
vp_tmpl_t *vpt;
char *to_pad = NULL;
- rad_assert(!*out);
+ fr_assert(!*out);
if (parse_pad(&vpt, &pad, &fill, request, fmt) <= 0) return 0;
return XLAT_ACTION_FAIL;
}
- rad_assert((size_t)elen <= alen);
+ fr_assert((size_t)elen <= alen);
MEM(vb = fr_value_box_alloc_null(ctx));
return XLAT_ACTION_FAIL;
}
- rad_assert(p);
+ fr_assert(p);
MEM(vb = fr_value_box_alloc_null(ctx));
fr_value_box_bstrsteal(vb, vb, NULL, p, false);
return XLAT_ACTION_FAIL;
}
- rad_assert(p);
+ fr_assert(p);
MEM(vb = fr_value_box_alloc_null(ctx));
fr_value_box_bstrsteal(vb, vb, NULL, p, false);
return XLAT_ACTION_FAIL;
}
- rad_assert(p);
+ fr_assert(p);
MEM(vb = fr_value_box_alloc_null(ctx));
fr_value_box_bstrsteal(vb, vb, NULL, p, false);
*/
p += slen;
- rad_assert(*p == ' ');
+ fr_assert(*p == ' ');
p++; /* Skip space */
rep = p;
talloc_free(vb);
return XLAT_ACTION_FAIL;
}
- rad_assert(vb->type != FR_TYPE_INVALID);
+ fr_assert(vb->type != FR_TYPE_INVALID);
fr_cursor_append(out, vb);
return XLAT_ACTION_DONE;
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/cond.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/regex.h>
#include <freeradius-devel/server/request.h>
#include <freeradius-devel/unlang/xlat_priv.h>
break;
default:
- rad_assert(0);
+ fr_assert(0);
return XLAT_ACTION_FAIL;
}
fr_cursor_t cursor;
- rad_assert(tmpl_is_attr(vpt) || tmpl_is_list(vpt));
+ fr_assert(tmpl_is_attr(vpt) || tmpl_is_list(vpt));
/*
* See if we're dealing with an attribute in the request
{
fr_cursor_t from;
- rad_assert(alternate);
+ fr_assert(alternate);
/*
* No result from the first child, try the alternate
(void) talloc_list_get_type_abort(*result, fr_value_box_t);
fr_cursor_init(&from, result);
fr_cursor_merge(out, &from);
- rad_assert(!*result);
+ fr_assert(!*result);
}
break;
XLAT_DEBUG("** [%i] %s(child) - continuing %%{%s ...}", unlang_interpret_stack_depth(request), __FUNCTION__,
node->fmt);
- rad_assert(*result != NULL);
+ fr_assert(*result != NULL);
(void) talloc_list_get_type_abort(*result, fr_value_box_t);
box = fr_value_box_alloc(ctx, FR_TYPE_GROUP, NULL, false);
fr_cursor_init(&from, &box);
fr_cursor_merge(out, &from);
- rad_assert(!box);
+ fr_assert(!box);
}
break;
default:
- rad_assert(0);
+ fr_assert(0);
return XLAT_ACTION_FAIL;
}
case XLAT_ALTERNATE:
XLAT_DEBUG("** [%i] %s(alternate) - %%{%%{%s}:-%%{%s}}", unlang_interpret_stack_depth(request),
__FUNCTION__, node->child->fmt, node->alternate->fmt);
- rad_assert(node->child != NULL);
- rad_assert(node->alternate != NULL);
+ fr_assert(node->child != NULL);
+ fr_assert(node->alternate != NULL);
*child = node->child;
xa = XLAT_ACTION_PUSH_CHILD;
case XLAT_ALTERNATE:
XLAT_DEBUG("%.*sxlat_aprint ALTERNATE", lvl, xlat_spaces);
- rad_assert(node->child != NULL);
- rad_assert(node->alternate != NULL);
+ fr_assert(node->child != NULL);
+ fr_assert(node->alternate != NULL);
/*
* Call xlat_process recursively. The child /
char *buff;
ssize_t len;
- rad_assert(node != NULL);
+ fr_assert(node != NULL);
len = xlat_process(ctx, &buff, request, node, escape, escape_ctx);
if ((len < 0) || !buff) {
- rad_assert(buff == NULL);
+ fr_assert(buff == NULL);
if (*out) **out = '\0';
return len;
}
ssize_t xlat_eval(char *out, size_t outlen, REQUEST *request,
char const *fmt, xlat_escape_t escape, void const *escape_ctx)
{
- rad_assert(done_init);
+ fr_assert(done_init);
return _xlat_eval(request, &out, outlen, request, fmt, escape, escape_ctx);
}
ssize_t xlat_eval_compiled(char *out, size_t outlen, REQUEST *request,
xlat_exp_t const *xlat, xlat_escape_t escape, void const *escape_ctx)
{
- rad_assert(done_init);
+ fr_assert(done_init);
return _xlat_eval_compiled(request, &out, outlen, request, xlat, escape, escape_ctx);
}
ssize_t xlat_aeval(TALLOC_CTX *ctx, char **out, REQUEST *request, char const *fmt,
xlat_escape_t escape, void const *escape_ctx)
{
- rad_assert(done_init);
+ fr_assert(done_init);
*out = NULL;
return _xlat_eval(ctx, out, 0, request, fmt, escape, escape_ctx);
ssize_t xlat_aeval_compiled(TALLOC_CTX *ctx, char **out, REQUEST *request,
xlat_exp_t const *xlat, xlat_escape_t escape, void const *escape_ctx)
{
- rad_assert(done_init);
+ fr_assert(done_init);
*out = NULL;
return _xlat_eval_compiled(ctx, out, 0, request, xlat, escape, escape_ctx);
MEM(my_argv = talloc_zero_array(ctx, char *, xlat->count + 1));
*argv = my_argv;
- rad_assert(done_init);
+ fr_assert(done_init);
for (i = 0, node = xlat; node != NULL; i++, node = node->next) {
my_argv[i] = NULL;
MEM(my_argv = talloc_zero_array(ctx, xlat_exp_t const *, xlat->count + 1));
*argv = my_argv;
- rad_assert(done_init);
+ fr_assert(done_init);
for (i = 0, node = xlat; node != NULL; i++, node = node->next) {
my_argv[i] = node->child;
int xlat_eval_init(void)
{
- rad_assert(!done_init);
+ fr_assert(!done_init);
if (fr_dict_autoload(xlat_eval_dict) < 0) {
PERROR("%s", __FUNCTION__);
RCSID("$Id$")
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/xlat_priv.h>
#include <freeradius-devel/io/schedule.h>
*/
static int _xlat_thread_inst_detach(xlat_thread_inst_t *thread_inst)
{
- rad_assert(thread_inst->node->type == XLAT_FUNC);
+ fr_assert(thread_inst->node->type == XLAT_FUNC);
if (thread_inst->node->xlat->thread_detach) {
(void) thread_inst->node->xlat->thread_detach(thread_inst->data, thread_inst->node->xlat->thread_uctx);
thread_inst->node = inst->node;
- rad_assert(inst->node->type == XLAT_FUNC);
- rad_assert(!inst->node->thread_inst); /* May be missing inst, but this is OK */
+ fr_assert(inst->node->type == XLAT_FUNC);
+ fr_assert(!inst->node->thread_inst); /* May be missing inst, but this is OK */
talloc_set_destructor(thread_inst, _xlat_thread_inst_detach);
if (inst->node->xlat->thread_inst_size) {
static int _xlat_inst_detach(xlat_inst_t *inst)
{
(void)talloc_get_type_abort_const(inst->node, xlat_exp_t);
- rad_assert(inst->node->type == XLAT_FUNC);
+ fr_assert(inst->node->type == XLAT_FUNC);
/*
* Remove permanent data from the instance tree.
(void)talloc_get_type_abort(node, xlat_exp_t);
- rad_assert(xlat_inst_tree); /* xlat_inst_init must have been called */
- rad_assert(node->type == XLAT_FUNC);
- rad_assert(!node->inst);
+ fr_assert(xlat_inst_tree); /* xlat_inst_init must have been called */
+ fr_assert(node->type == XLAT_FUNC);
+ fr_assert(!node->inst);
if (node->xlat->inst_size) {
MEM(inst = talloc_zero_pooled_object(node, xlat_inst_t, 1, node->xlat->inst_size));
*/
static int _xlat_instantiate_ephemeral_walker(xlat_exp_t *node, UNUSED void *uctx)
{
- rad_assert(!node->inst && !node->thread_inst);
+ fr_assert(!node->inst && !node->thread_inst);
node->inst = xlat_inst_alloc(node);
if (!node->inst) return -1;
{
xlat_thread_inst_t *found;
- rad_assert(xlat_thread_inst_tree);
- rad_assert(node->type == XLAT_FUNC);
+ fr_assert(xlat_thread_inst_tree);
+ fr_assert(node->type == XLAT_FUNC);
if (node->ephemeral) return node->thread_inst;
found = rbtree_finddata(xlat_thread_inst_tree, &(xlat_thread_inst_t){ .node = node });
- rad_assert(found);
+ fr_assert(found);
return found;
}
{
bool ret;
- rad_assert(node->type == XLAT_FUNC);
- rad_assert(!node->inst && !node->thread_inst);
+ fr_assert(node->type == XLAT_FUNC);
+ fr_assert(!node->inst && !node->thread_inst);
node->inst = xlat_inst_alloc(node);
if (!node->inst) return -1;
* If thread instantiate has been called, it's too late to
* bootstrap new xlats.
*/
- rad_assert(!xlat_thread_inst_tree);
+ fr_assert(!xlat_thread_inst_tree);
if (!xlat_inst_tree) xlat_instantiate_init();
RCSID("$Id$")
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/request.h>
#include <freeradius-devel/server/regex.h>
#include <freeradius-devel/unlang/xlat_priv.h>
char const *p = in;
xlat_exp_t *node;
- rad_assert(in[0] == '%');
- rad_assert(in[1] == '{');
- rad_assert(in[2] == '%');
- rad_assert(in[3] == '{');
+ fr_assert(in[0] == '%');
+ fr_assert(in[1] == '{');
+ fr_assert(in[2] == '%');
+ fr_assert(in[3] == '{');
XLAT_DEBUG("ALTERNATE <-- %s", in);
*/
if (inlen < 4) return 0;
- rad_assert(in[0] == '%');
- rad_assert(in[1] == '{');
+ fr_assert(in[0] == '%');
+ fr_assert(in[1] == '{');
p = in + 2;
end = in + inlen;
if (inlen < 2) return 0;
- rad_assert(in[0] == '%');
- rad_assert(in[1] == '{');
+ fr_assert(in[0] == '%');
+ fr_assert(in[1] == '{');
p = in + 2;
end = in + inlen;
if (inlen < 2) return 0;
- rad_assert(in[0] == '%');
- rad_assert(in[1] == '{');
+ fr_assert(in[0] == '%');
+ fr_assert(in[1] == '{');
if (rules) {
memcpy(&our_rules, rules, sizeof(our_rules));
if (inlen < 2) return 0;
- rad_assert(in[0] == '%');
- rad_assert(in[1] == '{');
+ fr_assert(in[0] == '%');
+ fr_assert(in[1] == '{');
/*
* %{%{...}:-bar}
case '[':
slen = xlat_tokenize_attribute(ctx, head, in, inlen, rules);
if (slen < 0) return slen;
- rad_assert(slen != 0);
+ fr_assert(slen != 0);
p += slen;
break;
}
p += slen;
- rad_assert(node->next != NULL);
+ fr_assert(node->next != NULL);
/*
* Short-circuit the recursive call.
* LITERAL " bar"
*/
slen = xlat_tokenize_literal(node->next, &(node->next->next), p, end - p, brace, rules);
- rad_assert(slen != 0);
+ fr_assert(slen != 0);
if (slen < 0) {
talloc_free(node);
return slen - (p - in);
* And recurse.
*/
slen = xlat_tokenize_literal(node->next, &(node->next->next), p, end - p, brace, rules);
- rad_assert(slen != 0);
+ fr_assert(slen != 0);
if (slen < 0) {
talloc_free(node);
return slen - (p - in);
static void xlat_tokenize_debug(REQUEST *request, xlat_exp_t const *node)
{
- rad_assert(node != NULL);
+ fr_assert(node != NULL);
RINDENT();
while (node) {
break;
case XLAT_ATTRIBUTE:
- rad_assert(node->attr->tmpl_da != NULL);
+ fr_assert(node->attr->tmpl_da != NULL);
RDEBUG3("attribute --> %s", node->attr->tmpl_da->name);
- rad_assert(node->child == NULL);
+ fr_assert(node->child == NULL);
if ((node->attr->tmpl_tag != TAG_ANY) || (node->attr->tmpl_num != NUM_ANY)) {
RDEBUG3("{");
break;
case XLAT_VIRTUAL:
- rad_assert(node->fmt != NULL);
+ fr_assert(node->fmt != NULL);
RDEBUG3("virtual --> %s", node->fmt);
break;
case XLAT_FUNC:
- rad_assert(node->xlat != NULL);
+ fr_assert(node->xlat != NULL);
RDEBUG3("xlat --> %s", node->xlat->name);
if (node->child) {
RDEBUG3("{");
* @param[in] ... Arguments for msg string.
* @return the value of cond.
*/
-bool fr_cond_assert_fail(char const *file, int line, char const *expr, char const *msg, ...)
+bool _fr_assert_fail(char const *file, int line, char const *expr, char const *msg, ...)
{
if (msg) {
char str[256]; /* Decent compilers won't allocate this unless fmt is !NULL... */
return false;
}
-/*
- * Logs an error message and aborts the program
+/** A fatal assertion which triggers the fault handler in debug builds or exits
*
+ * @param[in] file the assertion failed in.
+ * @param[in] line of the assertion in the file.
+ * @param[in] expr that was evaluated.
+ * @param[in] msg Message to print (may be NULL).
+ * @param[in] ... Arguments for msg string.
*/
-#ifndef NDEBUG
-bool fr_assert_exit(char const *file, unsigned int line, char const *expr)
-{
- FR_FAULT_LOG("ASSERT FAILED %s[%u]: %s", file, line, expr);
- fr_fault(SIGABRT);
- fr_exit_now(1);
-}
-#else
-bool fr_assert_exit(char const *file, unsigned int line, char const *expr)
+void _fr_assert_fatal(char const *file, int line, char const *expr, char const *msg, ...)
{
- FR_FAULT_LOG("ASSERT WOULD FAIL %s[%u]: %s", file, line, expr);
- return false;
-}
-#endif
-
+ if (msg) {
+ char str[256]; /* Decent compilers won't allocate this unless fmt is !NULL... */
+ va_list ap;
-/** Exit possibly printing a message about why we're exiting.
- *
- * @note Use the fr_exit(status) macro instead of calling this function directly.
- *
- * @param file where fr_exit() was called.
- * @param line where fr_exit() was called.
- * @param status we're exiting with.
- */
-#ifndef NDEBUG
-void NEVER_RETURNS _fr_exit(char const *file, int line, int status)
-{
- char const *error = fr_strerror();
+ va_start(ap, msg);
+ (void)vsnprintf(str, sizeof(str), msg, ap);
+ va_end(ap);
- if (error && *error && (status != 0)) {
- FR_FAULT_LOG("EXIT(%i) CALLED %s[%u]. Last error was: %s", status, file, line, error);
+ FR_FAULT_LOG("FATAL ASSERT %s[%u]: %s: %s", file, line, expr, str);
} else {
- FR_FAULT_LOG("EXIT(%i) CALLED %s[%u]", status, file, line);
+ FR_FAULT_LOG("FATAL ASSERT %s[%u]: %s", file, line, expr);
}
- fr_debug_break(false); /* If running under GDB we'll break here */
+#ifdef NDEBUG
+ _fr_exit_now(file, line, 128 + SIGABRT);
- exit(status);
-}
#else
-void NEVER_RETURNS _fr_exit(UNUSED char const *file, UNUSED int line, int status)
-{
- fr_debug_break(false); /* If running under GDB we'll break here */
-
- exit(status);
-}
+ fr_fault(SIGABRT);
+ _Exit(128 + SIGABRT); /* Don't hit the debugger twice */
#endif
+}
/** Exit possibly printing a message about why we're exiting.
*
- * @note Use the fr_exit_now(status) macro instead of calling this function directly.
+ * @note Use the fr_exit(status) macro instead of calling this function directly.
*
- * @param file where fr_exit_now() was called.
- * @param line where fr_exit_now() was called.
- * @param status we're exiting with.
+ * @param[in] file where fr_exit() was called.
+ * @param[in] line where fr_exit() was called.
+ * @param[in] status we're exiting with.
+ * @param[in] now Exit immediately.
*/
#ifndef NDEBUG
-void NEVER_RETURNS _fr_exit_now(char const *file, int line, int status)
+void NEVER_RETURNS _fr_exit(char const *file, int line, int status, bool now)
{
char const *error = fr_strerror();
if (error && *error && (status != 0)) {
- FR_FAULT_LOG("_EXIT(%i) CALLED %s[%u]. Last error was: %s", status, file, line, error);
+ FR_FAULT_LOG("%sEXIT(%i) CALLED %s[%u]. Last error was: %s", now ? "_" : "", status, file, line, error);
} else {
- FR_FAULT_LOG("_EXIT(%i) CALLED %s[%u]", status, file, line);
+ FR_FAULT_LOG("%sEXIT(%i) CALLED %s[%u]", now ? "_" : "", status, file, line);
}
- fr_debug_break(false); /* If running under GDB we'll break here */
+ if (status != EXIT_SUCCESS) fr_debug_break(false); /* If running under GDB we'll break here */
- _exit(status);
+ now ? _Exit(status) : exit(status);
}
#else
-void NEVER_RETURNS _fr_exit_now(UNUSED char const *file, UNUSED int line, int status)
+void NEVER_RETURNS _fr_exit(UNUSED char const *file, UNUSED int line, int status, bool now)
{
- fr_debug_break(false); /* If running under GDB we'll break here */
+ if (status != EXIT_SUCCESS) fr_debug_break(false); /* If running under GDB we'll break here */
- _exit(status);
+ now ? _Exit(status) : exit(status);
}
#endif
#ifdef NO_ASSERT
# define MEM(x) error "Use of MEM() not allowed in this source file. Deal with memory allocation failure gracefully"
#else
-# define MEM(x) do { if (!(x)) { fr_cond_assert_msg((x), "OUT OF MEMORY"); _fr_exit_now(__FILE__, __LINE__, EXIT_FAILURE); } } while (0)
+# define MEM(x) do { if (!(x)) { fr_cond_assert_msg((x), "OUT OF MEMORY"); _fr_exit(__FILE__, __LINE__, EXIT_FAILURE, true); } } while (0)
#endif
typedef enum {
typedef int (*fr_fault_cb_t)(int signum);
typedef struct fr_bt_marker fr_bt_marker_t;
-int fr_get_lsan_state(void);
-int fr_get_debug_state(void);
-void fr_debug_state_store(void);
-char const *fr_debug_state_to_msg(fr_debug_state_t state);
-void fr_debug_break(bool always);
-void backtrace_print(fr_fring_t *fring, void *obj);
-int fr_backtrace_do(fr_bt_marker_t *marker);
-fr_bt_marker_t *fr_backtrace_attach(fr_fring_t **fring, TALLOC_CTX *obj);
-
-void fr_panic_on_free(TALLOC_CTX *ctx);
-int fr_set_dumpable_init(void);
-int fr_set_dumpable(bool allow_core_dumps);
-int fr_reset_dumpable(void);
-int fr_log_talloc_report(TALLOC_CTX const *ctx);
-void fr_fault(int sig);
-void fr_talloc_fault_setup(void);
-void fr_disable_null_tracking_on_free(TALLOC_CTX *ctx);
-int fr_fault_setup(TALLOC_CTX *ctx, char const *cmd, char const *program);
-void fr_fault_set_cb(fr_fault_cb_t func);
-void fr_fault_set_log_fd(int fd);
-void fr_fault_log(char const *msg, ...) CC_HINT(format (printf, 1, 2));
-bool fr_cond_assert_fail(char const *file, int line, char const *expr, char const *msg, ...)
- CC_HINT(format (printf, 4, 5));
+int fr_get_lsan_state(void);
+
+int fr_get_debug_state(void);
+
+void fr_debug_state_store(void);
+
+char const *fr_debug_state_to_msg(fr_debug_state_t state);
+
+void fr_debug_break(bool always);
+
+void backtrace_print(fr_fring_t *fring, void *obj);
+
+int fr_backtrace_do(fr_bt_marker_t *marker);
+
+fr_bt_marker_t *fr_backtrace_attach(fr_fring_t **fring, TALLOC_CTX *obj);
+
+void fr_panic_on_free(TALLOC_CTX *ctx);
+
+int fr_set_dumpable_init(void);
+
+int fr_set_dumpable(bool allow_core_dumps);
+
+int fr_reset_dumpable(void);
+
+int fr_log_talloc_report(TALLOC_CTX const *ctx);
+
+void fr_fault(int sig);
+
+void fr_talloc_fault_setup(void);
+
+void fr_disable_null_tracking_on_free(TALLOC_CTX *ctx);
+
+int fr_fault_setup(TALLOC_CTX *ctx, char const *cmd, char const *program);
+
+void fr_fault_set_cb(fr_fault_cb_t func);
+
+void fr_fault_set_log_fd(int fd);
+
+void fr_fault_log(char const *msg, ...) CC_HINT(format (printf, 1, 2));
+
+/** @name Assertion support functions
+ * @{
+ */
+bool _fr_assert_fail(char const *file, int line, char const *expr, char const *msg, ...)
+ CC_HINT(format (printf, 4, 5));
+
+void NEVER_RETURNS _fr_assert_fatal(char const *file, int line, char const *expr, char const *msg, ...)
+ CC_HINT(format (printf, 4, 5));
+
+void NEVER_RETURNS _fr_exit(char const *file, int line, int status, bool now);
+/** @} */
+
+/** @name Assertion and exit macros
+ * @{
+ */
+
+/** For systems with an old version libc, define static_assert.
+ *
+ */
+#ifndef static_assert
+# define static_assert _Static_assert
+# else
+# include <assert.h>
+#endif
/** Calls panic_action ifndef NDEBUG, else logs error and evaluates to value of _x
*
*
* @param _x expression to test (should evaluate to true)
*/
-#define fr_cond_assert(_x) likely((bool)((_x) ? true : (fr_cond_assert_fail(__FILE__, __LINE__, #_x, NULL) && false)))
+#define fr_cond_assert(_x) likely((bool)((_x) ? true : (_fr_assert_fail(__FILE__, __LINE__, #_x, NULL) && false)))
-/** Calls panic_action ifndef NDEBUG, else logs error
+/** Calls panic_action ifndef NDEBUG, else logs error and evaluates to value of _x
*
- * @param[in] _msg to log.
- * @param[in] ... args.
+ * Should be wrapped in a condition, and if false, should cause function to return
+ * an error code. This allows control to return to the caller if a precondition is
+ * not satisfied and we're not debugging.
+ *
+ * Example:
+ @verbatim
+ if (!fr_cond_assert_msg(request, "Bad stuff happened: %s", fr_syserror(errno)))) return -1
+ @endverbatim
+ *
+ * @param _x expression to test (should evaluate to true)
+ * @param _fmt of message to log.
+ * @param ... fmt arguments.
*/
-#define fr_assert_fail(_msg, ...) fr_cond_assert_fail(__FILE__, __LINE__, "false", _msg, ## __VA_ARGS__)
+#define fr_cond_assert_msg(_x, _fmt, ...) likely((bool)((_x) ? true : (_fr_assert_fail(__FILE__, __LINE__, #_x, _fmt, ## __VA_ARGS__) && false)))
-/** Calls panic_action ifndef NDEBUG, else logs error and evaluates to value of _x
+/** Calls panic_action ifndef NDEBUG, else logs error and causes the server to exit immediately with code 134
+ *
+ * Example:
+ @verbatim
+ fr_fatal_assert(<extremely_unlikely_and_fatal_condition>);
+ @endverbatim
+ *
+ * @param _x expression to test (should evaluate to true)
+ */
+#define fr_fatal_assert(_x) (likely((bool)((_x)) || _fr_assert_exit(__FILE__, __LINE__, #_x, NULL))
+
+/** Calls panic_action ifndef NDEBUG, else logs error and causes the server to exit immediately with code 134
*
* Should be wrapped in a condition, and if false, should cause function to return
* an error code. This allows control to return to the caller if a precondition is
*
* Example:
@verbatim
- if (!fr_cond_assert_msg(request, "Bad stuff happened: %s", fr_syserror(errno)))) return -1
+ fr_fatal_assert(<extremely_unlikely_and_fatal_condition>);
@endverbatim
*
* @param _x expression to test (should evaluate to true)
* @param _fmt of message to log.
* @param ... fmt arguments.
*/
-#define fr_cond_assert_msg(_x, _fmt, ...) likely((bool)((_x) ? true : (fr_cond_assert_fail(__FILE__, __LINE__, #_x, _fmt, ## __VA_ARGS__) && false)))
+#define fr_fatal_assert_msg(_x) (likely((bool)((_x) || _fr_assert_fatal(__FILE__, __LINE__, #_x, _fmt, ## __VA_ARGS__))
-#ifndef NDEBUG
-bool fr_assert_exit(char const *file, unsigned int line, char const *expr) CC_HINT(noreturn);
+/** Calls panic_action ifndef NDEBUG, else logs error and causes the server to exit immediately with code 134
+ *
+ * @param[in] _msg to log.
+ * @param[in] ... args.
+ */
+#define fr_assert_fatal_fail(_msg, ...) _fr_assert_fatal(__FILE__, __LINE__, "false", _msg, ## __VA_ARGS__)
+
+#ifdef NDEBUG
+# define fr_assert(_x)
+#elif !defined(__clang_analyzer__)
+/** Calls panic_action ifndef NDEBUG, else logs error
+ *
+ * @param _x expression to test (should evaluate to true)
+ */
+# define fr_assert(_x) (likely((bool)(_x)) || _fr_assert_fail(__FILE__, __LINE__, #_x, NULL))
+/** Calls panic_action ifndef NDEBUG, else logs error
+ *
+ * @param[in] _msg to log.
+ * @param[in] ... args.
+ */
+#define fr_assert_fail(_msg, ...) _fr_assert_fail(__FILE__, __LINE__, "false", _msg, ## __VA_ARGS__)
#else
-bool fr_assert_exit(char const *file, unsigned int line, char const *expr);
+# include <assert.h>
+# define fr_assert assert
#endif
-void NEVER_RETURNS _fr_exit(char const *file, int line, int status);
-# define fr_exit(_x) _fr_exit(__FILE__, __LINE__, (_x))
+/** Exit, producing a log message in debug builds
+ *
+ * @param[in] _x code to exit with.
+ */
+# define fr_exit(_x) _fr_exit(__FILE__, __LINE__, (_x), false)
-void NEVER_RETURNS _fr_exit_now(char const *file, int line, int status);
-# define fr_exit_now(_x) _fr_exit_now(__FILE__, __LINE__, (_x))
+/** Exit without calling atexit() handlers, producing a log message in debug builds
+ *
+ * @param[in] _x code to exit with.
+ */
+# define fr_exit_now(_x) _fr_exit(__FILE__, __LINE__, (_x), true)
+/** @} */
void fr_sign_struct(void *ptr, size_t size, size_t offset);
void fr_verify_struct(void const *ptr, size_t size, size_t offset);
#include <freeradius-devel/server/dl_module.h>
#include <freeradius-devel/server/log.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/cursor.h>
#include <freeradius-devel/util/dl.h>
dl_symbol_init_t const *a = one, *b = two;
int ret;
- rad_assert(a && b);
+ fr_assert(a && b);
ret = ((void *)a->func > (void *)b->func) - ((void *)a->func < (void *)b->func);
if (ret != 0) return ret;
dl_symbol_free_t const *a = one, *b = two;
int ret;
- rad_assert(a && b);
+ fr_assert(a && b);
ret = ((void *)a->func > (void *)b->func) - ((void *)a->func < (void *)b->func);
if (ret != 0) return ret;
* functions associated with the file descriptor.
*/
} else {
- rad_assert(ef->is_registered == true);
+ fr_assert(ef->is_registered == true);
/*
* Take a copy of the current set of active
}
ev_p = ev->parent;
- rad_assert(*(ev->parent) == ev);
+ fr_assert(*(ev->parent) == ev);
*ev_p = NULL;
/*
} else {
memcpy(&ev, ev_p, sizeof(ev)); /* Not const to us */
- rad_assert(*ev_p == ev);
+ fr_assert(*ev_p == ev);
/*
* We can't disarm the linking context due to
callback = ev->callback;
memcpy(&uctx, &ev->uctx, sizeof(uctx));
- rad_assert(*ev->parent == ev);
+ fr_assert(*ev->parent == ev);
/*
* Delete the event before calling it.
if (el->events[i].ident == 0) continue;
user = talloc_get_type_abort((void *)el->events[i].ident, fr_event_user_t);
- rad_assert(user->ident == el->events[i].ident);
+ fr_assert(user->ident == el->events[i].ident);
user->callback(el->kq, &el->events[i], user->uctx);
}
pev = talloc_get_type_abort((void *)el->events[i].udata, fr_event_pid_t);
- rad_assert(pev->pid == (pid_t) el->events[i].ident);
- rad_assert((el->events[i].fflags & NOTE_EXIT) != 0);
+ fr_assert(pev->pid == (pid_t) el->events[i].ident);
+ fr_assert((el->events[i].fflags & NOTE_EXIT) != 0);
pid = pev->pid;
pev->pid = 0; /* so we won't hit kevent again when it's freed */
(void)fr_dlist_remove(&el->ev_to_add, ev);
if (unlikely(fr_heap_insert(el->times, ev) < 0)) {
talloc_free(ev);
- rad_assert(0); /* Die in debug builds */
+ fr_assert(0); /* Die in debug builds */
}
}
--- /dev/null
+/*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+/** Pair serialisation API
+ *
+ * @file src/lib/util/pair_print.c
+ *
+ * @copyright 2020 The FreeRADIUS server project
+ */
+
+char *fr_pair_type_asprint(TALLOC_CTX *ctx, fr_type_t type)
+{
+ switch (type) {
+ case FR_TYPE_STRING :
+ return talloc_typed_strdup(ctx, "_");
+
+ case FR_TYPE_UINT64:
+ case FR_TYPE_SIZE:
+ case FR_TYPE_INT32:
+ case FR_TYPE_UINT8:
+ case FR_TYPE_UINT16:
+ case FR_TYPE_UINT32:
+ case FR_TYPE_DATE:
+ return talloc_typed_strdup(ctx, "0");
+
+ case FR_TYPE_IPV4_ADDR:
+ return talloc_typed_strdup(ctx, "?.?.?.?");
+
+ case FR_TYPE_IPV4_PREFIX:
+ return talloc_typed_strdup(ctx, "?.?.?.?/?");
+
+ case FR_TYPE_IPV6_ADDR:
+ return talloc_typed_strdup(ctx, "[:?:]");
+
+ case FR_TYPE_IPV6_PREFIX:
+ return talloc_typed_strdup(ctx, "[:?:]/?");
+
+ case FR_TYPE_OCTETS:
+ return talloc_typed_strdup(ctx, "??");
+
+ case FR_TYPE_ETHERNET:
+ return talloc_typed_strdup(ctx, "??:??:??:??:??:??:??:??");
+
+#ifdef WITH_ASCEND_BINARY
+ case FR_TYPE_ABINARY:
+ return talloc_typed_strdup(ctx, "??");
+#endif
+
+ case FR_TYPE_GROUP:
+ return talloc_typed_strdup(ctx, "{ ? }");
+
+ default :
+ break;
+ }
+
+ return talloc_typed_strdup(ctx, "<UNKNOWN-TYPE>");
+}
+
+/** Print one attribute and value to a string
+ *
+ * Print a VALUE_PAIR in the format:
+@verbatim
+ <attribute_name>[:tag] <op> <value>
+@endverbatim
+ * to a string.
+ *
+ * @param out Where to write the string.
+ * @param outlen Length of output buffer.
+ * @param vp to print.
+ * @return
+ * - Length of data written to out.
+ * - value >= outlen on truncation.
+ */
+size_t fr_pair_snprint(char *out, size_t outlen, VALUE_PAIR const *vp)
+{
+ char const *token = NULL;
+ size_t len, freespace = outlen;
+
+ if (!out) return 0;
+
+ *out = '\0';
+ if (!vp || !vp->da) return 0;
+
+ VP_VERIFY(vp);
+
+ if ((vp->op > T_INVALID) && (vp->op < T_TOKEN_LAST)) {
+ token = fr_tokens[vp->op];
+ } else {
+ token = "<INVALID-TOKEN>";
+ }
+
+ if (vp->da->flags.has_tag && (vp->tag != 0) && (vp->tag != TAG_ANY)) {
+ len = snprintf(out, freespace, "%s:%d %s ", vp->da->name, vp->tag, token);
+ } else {
+ len = snprintf(out, freespace, "%s %s ", vp->da->name, token);
+ }
+
+ if (is_truncated(len, freespace)) return len;
+ out += len;
+ freespace -= len;
+
+ len = fr_pair_value_snprint(out, freespace, vp, '"');
+ if (is_truncated(len, freespace)) return (outlen - freespace) + len;
+ freespace -= len;
+
+ return (outlen - freespace);
+}
+
+/** Print one attribute and value to FP
+ *
+ * Complete string with '\\t' and '\\n' is written to buffer before printing to
+ * avoid issues when running with multiple threads.
+ *
+ * @param fp to output to.
+ * @param vp to print.
+ */
+void fr_pair_fprint(FILE *fp, VALUE_PAIR const *vp)
+{
+ char buf[1024];
+ char *p = buf;
+ size_t len;
+
+ if (!fp) return;
+ VP_VERIFY(vp);
+
+ *p++ = '\t';
+ len = fr_pair_snprint(p, sizeof(buf) - 1, vp);
+ if (!len) {
+ return;
+ }
+ p += len;
+
+ /*
+ * Deal with truncation gracefully
+ */
+ if (((size_t) (p - buf)) >= (sizeof(buf) - 2)) {
+ p = buf + (sizeof(buf) - 2);
+ }
+
+ *p++ = '\n';
+ *p = '\0';
+
+ fputs(buf, fp);
+}
+
+
+/** Print a list of attributes and enumv
+ *
+ * @param[in] log to output to.
+ * @param[in] vp to print.
+ * @param[in] file where the message originated
+ * @param[in] line where the message originated
+ */
+void _fr_pair_list_log(fr_log_t const *log, VALUE_PAIR const *vp, char const *file, int line)
+{
+ VALUE_PAIR *our_vp;
+ fr_cursor_t cursor;
+
+ memcpy(&our_vp, &vp, sizeof(vp)); /* const work-arounds */
+
+ for (vp = fr_cursor_init(&cursor, &our_vp); vp; vp = fr_cursor_next(&cursor)) {
+ fr_log(log, L_DBG, file, line, "\t%pP", vp);
+ }
+}
+
+/** Print one attribute and value to a string
+ *
+ * Print a VALUE_PAIR in the format:
+@verbatim
+ <attribute_name>[:tag] <op> <value>
+@endverbatim
+ * to a string.
+ *
+ * @param ctx to allocate string in.
+ * @param vp to print.
+ * @param[in] quote the quotation character
+ * @return a talloced buffer with the attribute operator and value.
+ */
+char *fr_pair_asprint(TALLOC_CTX *ctx, VALUE_PAIR const *vp, char quote)
+{
+ char const *token = NULL;
+ char *str, *value;
+
+ if (!vp || !vp->da) return 0;
+
+ VP_VERIFY(vp);
+
+ if ((vp->op > T_INVALID) && (vp->op < T_TOKEN_LAST)) {
+ token = fr_tokens[vp->op];
+ } else {
+ token = "<INVALID-TOKEN>";
+ }
+
+ value = fr_pair_value_asprint(ctx, vp, quote);
+
+ if (vp->da->flags.has_tag) {
+ if (quote && (vp->vp_type == FR_TYPE_STRING)) {
+ str = talloc_typed_asprintf(ctx, "%s:%d %s %c%s%c", vp->da->name, vp->tag, token, quote, value, quote);
+ } else {
+ str = talloc_typed_asprintf(ctx, "%s:%d %s %s", vp->da->name, vp->tag, token, value);
+ }
+ } else {
+ if (quote && (vp->vp_type == FR_TYPE_STRING)) {
+ str = talloc_typed_asprintf(ctx, "%s %s %c%s%c", vp->da->name, token, quote, value, quote);
+ } else {
+ str = talloc_typed_asprintf(ctx, "%s %s %s", vp->da->name, token, value);
+ }
+ }
+
+ talloc_free(value);
+
+ return str;
+}
+
+/** Print the attribute portion of a pair (only)
+ *
+ * @param[out] out Where to write the output attribute.
+ * @param[in] end of the output buffer.
+ * @param[in] vp to print the attribute name for.
+ * @return
+ * - >= 0 number of bytes written to out on success.
+ * - < 0 number of bytes we need to write out the value.
+ */
+static inline ssize_t fr_pair_snprint_attr(char * const out, char const * const end, VALUE_PAIR const *vp)
+{
+ char *p = out;
+ size_t len = strlen(vp->da->name);
+
+ RETURN_SLEN_IF_NO_SPACE(len, p, end);
+ memcpy(p, vp->da->name, len);
+ p += len;
+
+ if (vp->tag) {
+ size_t ret;
+
+ RETURN_SLEN_IF_NO_SPACE(1, p, end);
+ *p++ = ':';
+
+ ret = snprintf(p, end - p, "%u", vp->tag);
+ RETURN_SLEN_IF_TRUNCATED(ret, p, end);
+
+ p += ret;
+ }
+
+ return p - out;
+}
+
+/** Print a leaf attribute pair i.e. <attr> <op> <value>
+ *
+ * @param[out] out Where to write the output attribute.
+ * @param[in] end of the output buffer.
+ * @param[in] vp to print.
+ * @param[in] str_quote to use when printing quoted string values.
+ */
+static inline ssize_t fr_pair_snprintf_leaf(char * const out, char const * const end,
+ VALUE_PAIR const *vp, char str_quote)
+{
+ char *p = out;
+
+ if ((vp->op > T_INVALID) && (vp->op < T_TOKEN_LAST)) {
+ token = fr_tokens[vp->op];
+ } else {
+ token = "<INVALID-TOKEN>";
+ }
+
+ fr_value_box_snprint(out, )
+}
+
+
* For sys/time.h and time.h
*/
#include <freeradius-devel/missing.h>
-#include <freeradius-devel/server/rad_assert.h>
#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/dlist.h>
#include <sys/time.h>
{
uint128_t ret;
- rad_assert(bits < 128);
+ fr_assert(bits < 128);
if (bits > 64) {
ret.l = 0xffffffffffffffff;
*/
static inline uint128_t uint128_lshift(uint128_t num, uint8_t bits)
{
- rad_assert(bits < 128);
+ fr_assert(bits < 128);
if (bits >= 64) {
num.l = 0;
*/
static inline uint128_t uint128_rshift(uint128_t num, uint8_t bits)
{
- rad_assert(bits < 128);
+ fr_assert(bits < 128);
if (bits >= 64) {
num.h = 0;
#include <freeradius-devel/server/protocol.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/unlang/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/pcap.h>
#include <net/if_arp.h>
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/protocol.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/base.h>
{
bfd_auth_md5_t *md5 = &bfd->auth.md5;
- rad_assert(session->secret_len <= sizeof(md5->digest));
- rad_assert(md5->auth_len == sizeof(*md5));
+ fr_assert(session->secret_len <= sizeof(md5->digest));
+ fr_assert(md5->auth_len == sizeof(*md5));
memset(md5->digest, 0, sizeof(md5->digest));
memcpy(md5->digest, session->secret, session->secret_len);
fr_sha1_ctx ctx;
bfd_auth_sha1_t *sha1 = &bfd->auth.sha1;
- rad_assert(session->secret_len <= sizeof(sha1->digest));
- rad_assert(sha1->auth_len == sizeof(*sha1));
+ fr_assert(session->secret_len <= sizeof(sha1->digest));
+ fr_assert(sha1->auth_len == sizeof(*sha1));
memset(sha1->digest, 0, sizeof(sha1->digest));
memcpy(sha1->digest, session->secret, session->secret_len);
if (fr_event_timer_in(session, session->el, &session->ev_packet,
fr_time_delta_from_usec(interval),
bfd_send_packet, session) < 0) {
- rad_assert("Failed to insert event" == NULL);
+ fr_assert("Failed to insert event" == NULL);
}
return 0;
if (fr_event_timer_at(session, session->el, &session->ev_timeout,
now, bfd_detection_timeout, session) < 0) {
- rad_assert("Failed to insert event" == NULL);
+ fr_assert("Failed to insert event" == NULL);
}
}
!session->doing_poll) {
DEBUG("BFD %d warning: asked to start UP / UP ?",
session->number);
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
bfd_stop_control(session);
return 0;
}
* re-set the timers.
*/
if (!session->remote_demand_mode) {
- rad_assert(session->ev_timeout != NULL);
- rad_assert(session->ev_packet != NULL);
+ fr_assert(session->ev_timeout != NULL);
+ fr_assert(session->ev_packet != NULL);
session->doing_poll = 0;
bfd_stop_control(session);
*/
static int bfd_socket_send(UNUSED rad_listen_t *listener, UNUSED REQUEST *request)
{
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
return 0;
}
static int bfd_socket_encode(UNUSED rad_listen_t *listener, UNUSED REQUEST *request)
{
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
return 0;
}
static int bfd_socket_decode(UNUSED rad_listen_t *listener, UNUSED REQUEST *request)
{
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
return 0;
}
uint16_t listen_port;
fr_ipaddr_t ipaddr;
- rad_assert(sock != NULL);
+ fr_assert(sock != NULL);
if (bfd_parse_ip_port(cs, &ipaddr, &listen_port) < 0) {
return -1;
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/unlang/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "proto_control.h"
extern fr_app_t proto_control;
dl_module_inst_t *parent_inst;
// fr_dict_enum_t const *type_enum;
- rad_assert(listen_cs && (strcmp(cf_section_name1(listen_cs), "listen") == 0));
+ fr_assert(listen_cs && (strcmp(cf_section_name1(listen_cs), "listen") == 0));
parent_inst = cf_data_value(cf_data_find(listen_cs, dl_module_inst_t, "proto_control"));
- rad_assert(parent_inst);
+ fr_assert(parent_inst);
// inst = talloc_get_type_abort(parent_inst->data, proto_control_t);
if (!transport_cs) transport_cs = cf_section_alloc(listen_cs, listen_cs, name, NULL);
parent_inst = cf_data_value(cf_data_find(listen_cs, dl_module_inst_t, "proto_control"));
- rad_assert(parent_inst);
+ fr_assert(parent_inst);
/*
* Set the allowed codes so that we can compile them as
fr_io_address_t *address = track->address;
RADCLIENT const *client;
- rad_assert(data[0] < FR_RADIUS_MAX_PACKET_CODE);
+ fr_assert(data[0] < FR_RADIUS_MAX_PACKET_CODE);
/*
* Set the request dictionary so that we can do
}
client = address->radclient;
- rad_assert(client);
+ fr_assert(client);
/*
* Dynamic client stuff
if (client->dynamic && !client->active) {
RADCLIENT *new_client;
- rad_assert(buffer_len >= sizeof(client));
+ fr_assert(buffer_len >= sizeof(client));
/*
* Allocate the client. If that fails, send back a NAK.
return;
}
- rad_assert(inst->process != NULL);
+ fr_assert(inst->process != NULL);
request->async->process = inst->process;
}
* We will need this for dynamic clients and connected sockets.
*/
inst->io.dl_inst = dl_module_instance_by_data(inst);
- rad_assert(inst != NULL);
+ fr_assert(inst != NULL);
/*
* Bootstrap the master IO handler.
#include <freeradius-devel/io/application.h>
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/io/schedule.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "proto_control.h"
extern fr_app_io_t proto_control_tcp;
CONF_SECTION *server_cs;
CONF_ITEM *ci;
- rad_assert(!inst->connection);
+ fr_assert(!inst->connection);
li->fd = sockfd = fr_socket_server_tcp(&inst->ipaddr, &port, inst->port_name, true);
if (sockfd < 0) {
inst->sockfd = sockfd;
ci = cf_parent(inst->cs); /* listen { ... } */
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
ci = cf_parent(ci);
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
server_cs = cf_item_to_section(ci);
#include <freeradius-devel/radius/radius.h>
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/protocol.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/fopencookie.h>
#include <freeradius-devel/util/trie.h>
#include <netdb.h>
socklen_t socklen;
struct sockaddr_un salocal;
- rad_assert(path);
+ fr_assert(path);
euid = geteuid();
egid = getegid();
CONF_ITEM *ci;
CONF_SECTION *server_cs;
- rad_assert(!thread->connection);
+ fr_assert(!thread->connection);
if (inst->peercred) {
sockfd = fr_server_domain_socket_peercred(inst->filename, inst->uid, inst->gid);
li->fd = thread->sockfd = sockfd;
ci = cf_parent(inst->cs); /* listen { ... } */
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
ci = cf_parent(ci);
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
server_cs = cf_item_to_section(ci);
thread->radclient.src_ipaddr.af = AF_INET;
thread->radclient.server_cs = cf_item_to_section(cf_parent(cf_parent(inst->cs)));
- rad_assert(thread->radclient.server_cs != NULL);
+ fr_assert(thread->radclient.server_cs != NULL);
thread->radclient.server = cf_section_name2(thread->radclient.server_cs);
return 0;
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/io/schedule.h>
#include <freeradius-devel/io/application.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "proto_detail.h"
extern fr_app_t proto_detail;
fr_dict_attr_t const *attr_packet_type;
proto_detail_t *inst = parent;
- rad_assert(listen_cs && (strcmp(cf_section_name1(listen_cs), "listen") == 0));
+ fr_assert(listen_cs && (strcmp(cf_section_name1(listen_cs), "listen") == 0));
if (!inst->dict) {
cf_log_err(ci, "Please define 'dictionary' BEFORE 'type'");
inst->code = type_enum->value->vb_uint32;
parent_inst = cf_data_value(cf_data_find(listen_cs, dl_module_inst_t, "proto_detail"));
- rad_assert(parent_inst);
+ fr_assert(parent_inst);
/*
* Parent dl_module_inst_t added in virtual_servers.c (listen_parse)
if (!transport_cs) transport_cs = cf_section_alloc(listen_cs, listen_cs, name, NULL);
parent_inst = cf_data_value(cf_data_find(listen_cs, dl_module_inst_t, "proto_detail"));
- rad_assert(parent_inst);
+ fr_assert(parent_inst);
return dl_module_instance(ctx, out, transport_cs, parent_inst, name, DL_MODULE_TYPE_SUBMODULE);
}
return -1;
}
- rad_assert(li->app_io->get_name);
+ fr_assert(li->app_io->get_name);
li->name = li->app_io->get_name(li);
/*
transport_cs = cf_section_find(inst->cs, "work", NULL);
parent_inst = cf_data_value(cf_data_find(inst->cs, dl_module_inst_t, "proto_detail"));
- rad_assert(parent_inst);
+ fr_assert(parent_inst);
if (!transport_cs) {
transport_cs = cf_section_dup(inst->cs, inst->cs, inst->app_io_conf,
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/protocol.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/misc.h>
}
opened = true;
- rad_assert(li->app_io->get_name);
+ fr_assert(li->app_io->get_name);
li->name = li->app_io->get_name(li);
if (!fr_schedule_listen_add(inst->parent->sc, li)) {
goto delay;
}
- rad_assert(thread->vnode_fd < 0);
+ fr_assert(thread->vnode_fd < 0);
/*
* See if there is a "detail.work" file. If not, try to
* was.
*/
dl_inst = dl_module_instance_by_data(instance);
- rad_assert(dl_inst);
+ fr_assert(dl_inst);
#ifndef __linux__
/*
#include <freeradius-devel/unlang/base.h>
#include <freeradius-devel/util/dict.h>
#include <freeradius-devel/server/state.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/radius/radius.h>
#include "proto_detail.h"
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
/*
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
case RLM_MODULE_NOOP:
memset(&parse_rules, 0, sizeof(parse_rules));
parse_rules.dict_def = inst->dict;
- rad_assert(listen_cs);
+ fr_assert(listen_cs);
server_cs = cf_item_to_section(cf_parent(listen_cs));
- rad_assert(strcmp(cf_section_name1(server_cs), "server") == 0);
+ fr_assert(strcmp(cf_section_name1(server_cs), "server") == 0);
return virtual_server_compile_sections(server_cs, compile_list, &parse_rules, inst);
}
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/util/dlist.h>
#include <freeradius-devel/util/time.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "proto_detail.h"
#include <fcntl.h>
uint8_t *stopped_search;
off_t done_offset;
- rad_assert(*leftover < buffer_len);
- rad_assert(thread->fd >= 0);
+ fr_assert(*leftover < buffer_len);
+ fr_assert(thread->fd >= 0);
MPRINT("AT COUNT %d offset %ld", thread->count, (long) thread->read_offset);
* Don't over-write "leftover" bytes!
*/
if (*leftover) {
- rad_assert(thread->leftover == 0);
+ fr_assert(thread->leftover == 0);
if (!thread->leftover_buffer) MEM(thread->leftover_buffer = talloc_array(thread, uint8_t, buffer_len));
memcpy(thread->leftover_buffer, buffer, *leftover);
*leftover = 0;
}
- rad_assert(buffer_len >= track->packet_len);
+ fr_assert(buffer_len >= track->packet_len);
memcpy(buffer, track->packet, track->packet_len);
DEBUG("Retrying packet %d (retransmission %u)", track->id, track->retry.count);
* we have to check this ourselves.
*/
if (thread->outstanding >= inst->max_outstanding) {
- rad_assert(thread->paused);
+ fr_assert(thread->paused);
return 0;
}
* copy it back.
*/
if (thread->leftover) {
- rad_assert(*leftover == 0);
- rad_assert(thread->leftover < buffer_len);
+ fr_assert(*leftover == 0);
+ fr_assert(thread->leftover < buffer_len);
memcpy(buffer, thread->leftover_buffer, thread->leftover);
*leftover = thread->leftover;
* We didn't read any more data from the file,
* but there should be data left in the buffer.
*/
- rad_assert(*leftover > 0);
+ fr_assert(*leftover > 0);
end = buffer + *leftover;
}
* Note that all of the data MUST be printable, and raw
* LFs are forbidden in attribute contents.
*/
- rad_assert((buffer + thread->last_search) <= end);
+ fr_assert((buffer + thread->last_search) <= end);
MPRINT("Starting search from offset %ld", thread->last_search);
goto redo;
}
- rad_assert(*leftover == 0);
+ fr_assert(*leftover == 0);
goto done;
}
* If we're at EOF, mark us as "closing".
*/
if (thread->eof) {
- rad_assert(!thread->closing);
+ fr_assert(!thread->closing);
thread->closing = (*leftover == 0);
MPRINT("AT EOF, BUT CLOSING %d", thread->closing);
}
thread->paused = false;
}
- rad_assert(thread->fd >= 0);
+ fr_assert(thread->fd >= 0);
/*
* Seek to the START of the file, so that the FD will
if (buffer_len < 1) return -1;
- rad_assert(thread->outstanding > 0);
- rad_assert(thread->fd >= 0);
+ fr_assert(thread->outstanding > 0);
+ fr_assert(thread->fd >= 0);
if (!buffer[0]) {
if (track->retry.start == 0) {
thread->file_size = 1;
}
- rad_assert(thread->name == NULL);
- rad_assert(thread->filename_work != NULL);
+ fr_assert(thread->name == NULL);
+ fr_assert(thread->filename_work != NULL);
thread->name = talloc_typed_asprintf(thread, "proto_detail working file %s", thread->filename_work);
DEBUG("Listening on %s bound to virtual server %s",
* was.
*/
dl_inst = dl_module_instance_by_data(instance);
- rad_assert(dl_inst);
+ fr_assert(dl_inst);
inst->parent = talloc_get_type_abort(dl_inst->parent->data, proto_detail_t);
inst->cs = cs;
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/unlang/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "proto_dhcpv4.h"
extern fr_app_t proto_dhcpv4;
fr_dict_enum_t const *type_enum;
uint32_t code;
- rad_assert(listen_cs && (strcmp(cf_section_name1(listen_cs), "listen") == 0));
+ fr_assert(listen_cs && (strcmp(cf_section_name1(listen_cs), "listen") == 0));
/*
* Allow the process module to be specified by
}
parent_inst = cf_data_value(cf_data_find(listen_cs, dl_module_inst_t, "proto_dhcpv4"));
- rad_assert(parent_inst);
+ fr_assert(parent_inst);
/*
* Set the allowed codes so that we can compile them as
if (!transport_cs) transport_cs = cf_section_alloc(listen_cs, listen_cs, name, NULL);
parent_inst = cf_data_value(cf_data_find(listen_cs, dl_module_inst_t, "proto_dhcpv4"));
- rad_assert(parent_inst);
+ fr_assert(parent_inst);
/*
* Set the allowed codes so that we can compile them as
RADCLIENT const *client;
RADIUS_PACKET *packet = request->packet;
- rad_assert(data[0] < FR_RADIUS_MAX_PACKET_CODE);
+ fr_assert(data[0] < FR_RADIUS_MAX_PACKET_CODE);
/*
* Set the request dictionary so that we can do
}
client = address->radclient;
- rad_assert(client);
+ fr_assert(client);
/*
* Dynamic client stuff
if (client->dynamic && !client->active) {
RADCLIENT *new_client;
- rad_assert(buffer_len >= sizeof(client));
+ fr_assert(buffer_len >= sizeof(client));
/*
* Allocate the client. If that fails, send back a NAK.
dl_module_inst_t *type_submodule;
fr_io_track_t *track = request->async->packet_ctx;
- rad_assert(request->packet->code != 0);
- rad_assert(request->packet->code < FR_DHCP_MAX);
+ fr_assert(request->packet->code != 0);
+ fr_assert(request->packet->code < FR_DHCP_MAX);
request->server_cs = inst->io.server_cs;
{
proto_dhcpv4_t const *inst = talloc_get_type_abort_const(instance, proto_dhcpv4_t);
- rad_assert(buffer[0] > 0);
- rad_assert(buffer[0] < FR_RADIUS_MAX_PACKET_CODE);
+ fr_assert(buffer[0] > 0);
+ fr_assert(buffer[0] < FR_RADIUS_MAX_PACKET_CODE);
/*
* Disallowed packet
*/
inst->io.server_cs = cf_item_to_section(cf_parent(conf));
- rad_assert(dict_dhcpv4 != NULL);
- rad_assert(attr_message_type != NULL);
+ fr_assert(dict_dhcpv4 != NULL);
+ fr_assert(attr_message_type != NULL);
/*
* Bootstrap the app_process modules.
* We will need this for dynamic clients and connected sockets.
*/
inst->io.dl_inst = dl_module_instance_by_data(inst);
- rad_assert(inst != NULL);
+ fr_assert(inst != NULL);
/*
* Bootstrap the master IO handler.
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/unlang/base.h>
#include <freeradius-devel/util/dict.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/dhcpv4/dhcpv4.h>
#include <freeradius-devel/protocol/dhcpv4/rfc2131.h>
VALUE_PAIR *vp;
REQUEST_VERIFY(request);
- rad_assert(request->packet->code > 0);
- rad_assert(request->packet->code <= FR_DHCP_LEASE_QUERY);
+ fr_assert(request->packet->code > 0);
+ fr_assert(request->packet->code <= FR_DHCP_LEASE_QUERY);
switch (request->request_state) {
case REQUEST_INIT:
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
/*
* Allow the admin to explicitly set the reply
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
case RLM_MODULE_NOOP:
#include <freeradius-devel/io/application.h>
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/io/schedule.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/protocol/dhcpv4/freeradius.internal.h>
#include "proto_dhcpv4.h"
flags = UDP_FLAGS_CONNECTED * (thread->connection != NULL);
- rad_assert(track->reply_len == 0);
+ fr_assert(track->reply_len == 0);
/*
* Swap src/dst IP/port
thread->sockfd = sockfd;
ci = cf_parent(inst->cs); /* listen { ... } */
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
ci = cf_parent(ci);
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
server_cs = cf_item_to_section(ci);
}
ci = cf_parent(inst->cs); /* listen { ... } */
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
ci = cf_parent(ci);
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
server_cs = cf_item_to_section(ci);
#include <freeradius-devel/unlang/base.h>
#include <freeradius-devel/server/protocol.h>
#include <freeradius-devel/server/main_loop.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <sys/socket.h>
#include "sync.h"
static REQUEST *request_setup(UNUSED TALLOC_CTX *ctx, UNUSED rad_listen_t *listener, UNUSED RADIUS_PACKET *packet,
UNUSED RADCLIENT *client, UNUSED RAD_REQUEST_FUNP fun)
{
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
return NULL;
}
break;
default:
- rad_assert(0);
+ fr_assert(0);
return;
}
unlang = cf_section_find(request->server_cs, verb, state);
default:
break;
}
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
//request_delete(request);
break;
}
talloc_set_type(inst, proto_ldap_inst_t);
- rad_assert(inst->handle_config.server_str[0]);
+ fr_assert(inst->handle_config.server_str[0]);
inst->handle_config.name = talloc_typed_asprintf(inst, "proto_ldap_conn (%s)", listen->server);
memcpy(&inst->handle_config.server, &inst->handle_config.server_str[0], sizeof(inst->handle_config.server));
USES_APPLE_DEPRECATED_API
#include <freeradius-devel/ldap/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <lber.h>
#include "sync.h"
sync_states_t state = SYNC_STATE_INVALID;
bool new_cookie;
- rad_assert(sync->conn);
- rad_assert(sync);
- rad_assert(msg);
+ fr_assert(sync->conn);
+ fr_assert(sync);
+ fr_assert(msg);
if (!ctrls) {
missing_control:
ber_len_t len;
bool new_cookie;
- rad_assert(sync->conn);
- rad_assert(sync);
- rad_assert(msg);
+ fr_assert(sync->conn);
+ fr_assert(sync);
+ fr_assert(msg);
/*
* Should not happen with refreshAndPersist
tree = talloc_get_type_abort(conn->uctx, rbtree_t);
- rad_assert(conn);
+ fr_assert(conn);
/*
* Drain any messages outstanding on this connection
ret = ldap_result(conn->handle, LDAP_RES_ANY, LDAP_MSG_RECEIVED, &poll, &head);
switch (ret) {
case 0: /* timeout - shouldn't happen */
- rad_assert(0);
+ fr_assert(0);
case -1:
rcode = fr_ldap_error_check(NULL, conn, NULL, NULL);
rbtree_t *tree = talloc_get_type_abort(conn->uctx, rbtree_t);
sync_state_t find = { .msgid = sync->msgid };
- rad_assert(sync->conn->handle);
+ fr_assert(sync->conn->handle);
DEBUG3("Abandoning sync");
sync_state_t *sync;
rbtree_t *tree;
- rad_assert(conn);
- rad_assert(config);
+ fr_assert(conn);
+ fr_assert(config);
mode = config->persist ? LDAP_SYNC_REFRESH_AND_PERSIST : LDAP_SYNC_REFRESH_ONLY;
USES_APPLE_DEPRECATED_API
#include <freeradius-devel/ldap/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
typedef struct {
uint64_t id; //!< Bitfield ID.
#include <freeradius-devel/io/track.h>
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/io/schedule.h>
-#include <freeradius-devel/rad_assert.h>
+#include <freeradius-devel/fr_assert.h>
#include "proto_radius.h"
typedef struct {
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/unlang/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "proto_radius.h"
extern fr_app_t proto_radius;
fr_dict_enum_t const *type_enum;
uint32_t code;
- rad_assert(listen_cs && (strcmp(cf_section_name1(listen_cs), "listen") == 0));
+ fr_assert(listen_cs && (strcmp(cf_section_name1(listen_cs), "listen") == 0));
/*
* Allow the process module to be specified by
if (!name) goto invalid_type;
parent_inst = cf_data_value(cf_data_find(listen_cs, dl_module_inst_t, "proto_radius"));
- rad_assert(parent_inst);
+ fr_assert(parent_inst);
/*
* Set the allowed codes so that we can compile them as
transport_cs = cf_section_find(listen_cs, name, NULL);
parent_inst = cf_data_value(cf_data_find(listen_cs, dl_module_inst_t, "proto_radius"));
- rad_assert(parent_inst);
+ fr_assert(parent_inst);
/*
* Set the allowed codes so that we can compile them as
fr_io_address_t *address = track->address;
RADCLIENT const *client;
- rad_assert(data[0] < FR_RADIUS_MAX_PACKET_CODE);
+ fr_assert(data[0] < FR_RADIUS_MAX_PACKET_CODE);
/*
* Set the request dictionary so that we can do
fr_cursor_t cursor;
VALUE_PAIR *vp;
- rad_assert(client->dynamic);
+ fr_assert(client->dynamic);
for (vp = fr_cursor_init(&cursor, &request->packet->vps);
vp != NULL;
}
client = address->radclient;
- rad_assert(client);
+ fr_assert(client);
/*
* Dynamic client stuff
if (client->dynamic && !client->active) {
RADCLIENT *new_client;
- rad_assert(buffer_len >= sizeof(client));
+ fr_assert(buffer_len >= sizeof(client));
/*
* We don't accept the new client, so don't do
dl_module_inst_t *type_submodule;
fr_io_track_t *track = request->async->packet_ctx;
- rad_assert(request->packet->code != 0);
- rad_assert(request->packet->code <= FR_RADIUS_MAX_PACKET_CODE);
+ fr_assert(request->packet->code != 0);
+ fr_assert(request->packet->code <= FR_RADIUS_MAX_PACKET_CODE);
request->server_cs = inst->io.server_cs;
{
proto_radius_t const *inst = talloc_get_type_abort_const(instance, proto_radius_t);
- rad_assert(buffer[0] > 0);
- rad_assert(buffer[0] < FR_RADIUS_MAX_PACKET_CODE);
+ fr_assert(buffer[0] > 0);
+ fr_assert(buffer[0] < FR_RADIUS_MAX_PACKET_CODE);
/*
* Disallowed packet
* We will need this for dynamic clients and connected sockets.
*/
inst->io.dl_inst = dl_module_instance_by_data(inst);
- rad_assert(inst != NULL);
+ fr_assert(inst != NULL);
/*
* Bootstrap the master IO handler.
#include <freeradius-devel/radius/radius.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/protocol.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/base.h>
#include <freeradius-devel/util/dict.h>
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
/*
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
/*
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
case RLM_MODULE_NOOP:
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/pair.h>
#include <freeradius-devel/server/protocol.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/state.h>
#include <freeradius-devel/unlang/base.h>
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
case RLM_MODULE_NOOP:
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
/*
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
case RLM_MODULE_FAIL:
CONF_SECTION *listen_cs = cf_item_to_section(cf_parent(process_app_cs));
CONF_SECTION *server_cs;
- rad_assert(process_app_cs);
- rad_assert(listen_cs);
+ fr_assert(process_app_cs);
+ fr_assert(listen_cs);
server_cs = cf_item_to_section(cf_parent(listen_cs));
- rad_assert(strcmp(cf_section_name1(server_cs), "server") == 0);
+ fr_assert(strcmp(cf_section_name1(server_cs), "server") == 0);
if (virtual_server_section_attribute_define(server_cs, "authenticate", attr_auth_type) < 0) return -1;
#include <freeradius-devel/radius/radius.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/protocol.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/base.h>
#include <freeradius-devel/util/dict.h>
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
case RLM_MODULE_NOOP:
rerun_nak:
RDEBUG("Running 'send %s' from file %s", cf_section_name2(unlang), cf_filename(unlang));
unlang_interpret_push_section(request, unlang, RLM_MODULE_NOOP, UNLANG_TOP_FRAME);
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
request->request_state = REQUEST_SEND;
/* FALL-THROUGH */
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
/*
#include <freeradius-devel/radius/radius.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/protocol.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/base.h>
#include <freeradius-devel/util/dict.h>
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
case RLM_MODULE_OK:
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
case RLM_MODULE_NOOP:
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/io/schedule.h>
#include <freeradius-devel/io/load.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "proto_radius.h"
li->app_io_addr = fr_app_io_socket_addr(li, IPPROTO_UDP, &ipaddr, 0);
ci = cf_parent(inst->cs); /* listen { ... } */
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
ci = cf_parent(ci);
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
server_cs = cf_item_to_section(ci);
#include <freeradius-devel/radius/radius.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/protocol.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/base.h>
#include <freeradius-devel/util/dict.h>
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
case RLM_MODULE_OK:
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
case RLM_MODULE_NOOP:
#include <freeradius-devel/io/application.h>
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/io/schedule.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "proto_radius.h"
extern fr_app_io_t proto_radius_tcp;
/*
* We only write RADIUS packets.
*/
- rad_assert(buffer_len >= 20);
- rad_assert(written < buffer_len);
+ fr_assert(buffer_len >= 20);
+ fr_assert(written < buffer_len);
/*
* Only write replies if they're RADIUS packets.
CONF_SECTION *server_cs;
CONF_ITEM *ci;
- rad_assert(!thread->connection);
+ fr_assert(!thread->connection);
li->fd = sockfd = fr_socket_server_tcp(&inst->ipaddr, &port, inst->port_name, true);
if (sockfd < 0) {
thread->sockfd = sockfd;
ci = cf_parent(inst->cs); /* listen { ... } */
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
ci = cf_parent(ci);
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
server_cs = cf_item_to_section(ci);
#include <freeradius-devel/io/application.h>
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/io/schedule.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "proto_radius.h"
/*
* We only write RADIUS packets.
*/
- rad_assert(buffer_len >= 20);
+ fr_assert(buffer_len >= 20);
/*
* Only write replies if they're RADIUS packets.
thread->sockfd = sockfd;
ci = cf_parent(inst->cs); /* listen { ... } */
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
ci = cf_parent(ci);
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
server_cs = cf_item_to_section(ci);
}
ci = cf_parent(inst->cs); /* listen { ... } */
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
ci = cf_parent(ci);
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
server_cs = cf_item_to_section(ci);
#include <freeradius-devel/unlang/base.h>
#include <freeradius-devel/server/protocol.h>
#include <freeradius-devel/server/state.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/tacacs/tacacs.h>
static REQUEST *request_setup(UNUSED TALLOC_CTX *ctx, UNUSED rad_listen_t *listener, UNUSED RADIUS_PACKET *packet,
UNUSED RADCLIENT *client, UNUSED RAD_REQUEST_FUNP fun)
{
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
return NULL;
}
uint32_t session_id;
uint8_t buf[16] = { 0 }; /* FIXME state.c:sizeof(struct state_comp) */
- rad_assert(sizeof(request->listener) + sizeof(vp->vp_uint32) <= sizeof(buf)); //-V568
+ fr_assert(sizeof(request->listener) + sizeof(vp->vp_uint32) <= sizeof(buf)); //-V568
/* session_id is per TCP connection */
memcpy(&buf[0], &request->listener, sizeof(request->listener)); //-V568
if (rcode == RLM_MODULE_YIELD) return;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
case RLM_MODULE_NOOP:
if (rcode == RLM_MODULE_YIELD) return;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
/*
if (rcode == RLM_MODULE_YIELD) return;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
send_reply:
request->reply->timestamp = fr_time();
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/unlang/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/protocol/vmps/vmps.h>
fr_dict_enum_t const *type_enum;
uint32_t code;
- rad_assert(listen_cs && (strcmp(cf_section_name1(listen_cs), "listen") == 0));
+ fr_assert(listen_cs && (strcmp(cf_section_name1(listen_cs), "listen") == 0));
/*
* Allow the process module to be specified by
}
parent_inst = cf_data_value(cf_data_find(listen_cs, dl_module_inst_t, "proto_vmps"));
- rad_assert(parent_inst);
+ fr_assert(parent_inst);
/*
* Set the allowed codes so that we can compile them as
if (!transport_cs) transport_cs = cf_section_alloc(listen_cs, listen_cs, name, NULL);
parent_inst = cf_data_value(cf_data_find(listen_cs, dl_module_inst_t, "proto_vmps"));
- rad_assert(parent_inst);
+ fr_assert(parent_inst);
/*
* Set the allowed codes so that we can compile them as
RADCLIENT const *client;
RADIUS_PACKET *packet = request->packet;
- rad_assert(data[0] < FR_RADIUS_MAX_PACKET_CODE);
+ fr_assert(data[0] < FR_RADIUS_MAX_PACKET_CODE);
RHEXDUMP3(data, data_len, "proto_vmps decode packet");
}
client = address->radclient;
- rad_assert(client);
+ fr_assert(client);
/*
* Dynamic client stuff
if (client->dynamic && !client->active) {
RADCLIENT *new_client;
- rad_assert(buffer_len >= sizeof(client));
+ fr_assert(buffer_len >= sizeof(client));
/*
* Allocate the client. If that fails, send back a NAK.
dl_module_inst_t *type_submodule;
fr_io_track_t *track = request->async->packet_ctx;
- rad_assert(request->packet->code != 0);
- rad_assert(request->packet->code <= FR_VQP_MAX_CODE);
+ fr_assert(request->packet->code != 0);
+ fr_assert(request->packet->code <= FR_VQP_MAX_CODE);
request->server_cs = inst->io.server_cs;
*/
inst->io.server_cs = cf_item_to_section(cf_parent(conf));
- rad_assert(dict_vmps != NULL);
- rad_assert(attr_packet_type != NULL);
+ fr_assert(dict_vmps != NULL);
+ fr_assert(attr_packet_type != NULL);
/*
* Bootstrap the app_process modules.
* We will need this for dynamic clients and connected sockets.
*/
inst->io.dl_inst = dl_module_instance_by_data(inst);
- rad_assert(inst != NULL);
+ fr_assert(inst != NULL);
/*
* Bootstrap the master IO handler.
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/unlang/base.h>
#include <freeradius-devel/util/dict.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/vqp/vqp.h>
static fr_dict_t const *dict_freeradius;
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
case RLM_MODULE_OK:
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
case RLM_MODULE_NOOP:
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/unlang/base.h>
#include <freeradius-devel/util/dict.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/vqp/vqp.h>
#include <freeradius-devel/protocol/vmps/vmps.h>
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
case RLM_MODULE_NOOP:
if (rcode == RLM_MODULE_YIELD) return RLM_MODULE_YIELD;
- rad_assert(request->log.unlang_indent == 0);
+ fr_assert(request->log.unlang_indent == 0);
switch (rcode) {
case RLM_MODULE_NOOP:
#include <freeradius-devel/io/application.h>
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/io/schedule.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/protocol/vmps/vmps.h>
/*
* We only write VMPS packets.
*/
- rad_assert(buffer_len >= 8);
+ fr_assert(buffer_len >= 8);
/*
* Only write replies if they're VMPS packets.
thread->sockfd = sockfd;
ci = cf_parent(inst->cs); /* listen { ... } */
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
ci = cf_parent(ci);
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
server_cs = cf_item_to_section(ci);
}
ci = cf_parent(inst->cs); /* listen { ... } */
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
ci = cf_parent(ci);
- rad_assert(ci != NULL);
+ fr_assert(ci != NULL);
server_cs = cf_item_to_section(ci);
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/users_file.h>
#include <sys/stat.h>
* No entry matched. We didn't do anything.
*/
if (!found) {
- rad_assert(!output);
+ fr_assert(!output);
return RLM_MODULE_NOOP;
}
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "../../rlm_cache.h"
#include "../../serialize.h"
char buffer[256];
rlm_cache_config_t const *config = dl_module_parent_data_by_child_data(instance);
- rad_assert(config);
+ fr_assert(config);
snprintf(buffer, sizeof(buffer), "rlm_cache (%s)", config->name);
*/
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/util/heap.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "../../rlm_cache.h"
typedef struct {
rlm_cache_entry_t *c;
- rad_assert(driver->cache);
+ fr_assert(driver->cache);
/*
* Clear out old entries
rlm_cache_rbtree_t *driver = talloc_get_type_abort(instance, rlm_cache_rbtree_t);
rlm_cache_entry_t *my_c;
- rad_assert(handle == request);
+ fr_assert(handle == request);
if (!request) return CACHE_ERROR;
#define LOG_PREFIX "rlm_cache_redis - "
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "../../rlm_cache.h"
#include <freeradius-devel/redis/base.h>
char buffer[256];
rlm_cache_config_t const *config = dl_module_parent_data_by_child_data(instance);
- rad_assert(config);
+ fr_assert(config);
buffer[0] = '\0';
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/modpriv.h>
#include <freeradius-devel/server/dl_module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "rlm_cache.h"
*/
static int cache_reconnect(rlm_cache_handle_t **handle, rlm_cache_t const *inst, REQUEST *request)
{
- rad_assert(inst->driver->reconnect);
+ fr_assert(inst->driver->reconnect);
return inst->driver->reconnect(handle, &inst->config, inst->driver_inst->dl_inst->data, request);
}
REXDENT();
if (inst->config.stats) {
- rad_assert(request->packet != NULL);
+ fr_assert(request->packet != NULL);
MEM(pair_update_request(&vp, attr_cache_entry_hits) >= 0);
vp->vp_uint32 = c->hits;
}
VALUE_PAIR *to_cache = NULL;
fr_cursor_t cursor;
- rad_assert(map->lhs && map->rhs);
+ fr_assert(map->lhs && map->rhs);
/*
* Calling map_to_vp gives us exactly the same result,
goto do_rhs;
default:
- rad_assert(0);
+ fr_assert(0);
}
*last = c_map;
last = &(*last)->next;
rcode = cache_find(&c, inst, request, &handle, key, key_len);
if (rcode == RLM_MODULE_FAIL) goto finish;
- rad_assert(!inst->driver->acquire || handle);
+ fr_assert(!inst->driver->acquire || handle);
rcode = c ? RLM_MODULE_OK:
RLM_MODULE_NOTFOUND;
break;
default:
- rad_assert(0);
+ fr_assert(0);
}
- rad_assert(!inst->driver->acquire || handle);
+ fr_assert(!inst->driver->acquire || handle);
}
/*
*/
if (expire && ((exists == -1) || (exists == 1))) {
if (!insert) {
- rad_assert(!set_ttl);
+ fr_assert(!set_ttl);
switch (cache_expire(inst, request, &handle, key, key_len)) {
case RLM_MODULE_FAIL:
rcode = RLM_MODULE_FAIL;
break;
default:
- rad_assert(0);
+ fr_assert(0);
break;
}
/* If it previously existed, it doesn't now */
break;
default:
- rad_assert(0);
+ fr_assert(0);
}
- rad_assert(!inst->driver->acquire || handle);
+ fr_assert(!inst->driver->acquire || handle);
}
/*
* We can only alter the TTL on an entry if it exists.
*/
if (set_ttl && (exists == 1)) {
- rad_assert(c);
+ fr_assert(c);
c->expires = fr_time_to_unix_time(request->packet->timestamp) + fr_unix_time_from_sec(ttl);
goto finish;
default:
- rad_assert(0);
+ fr_assert(0);
}
}
break;
default:
- rad_assert(0);
+ fr_assert(0);
}
- rad_assert(!inst->driver->acquire || handle);
+ fr_assert(!inst->driver->acquire || handle);
goto finish;
}
/*
* Non optional fields and callbacks
*/
- rad_assert(inst->driver->name);
- rad_assert(inst->driver->find);
- rad_assert(inst->driver->insert);
- rad_assert(inst->driver->expire);
+ fr_assert(inst->driver->name);
+ fr_assert(inst->driver->find);
+ fr_assert(inst->driver->insert);
+ fr_assert(inst->driver->expire);
/*
* Register the cache xlat function
inst->cs = conf;
- rad_assert(inst->config.key);
+ fr_assert(inst->config.key);
if (inst->config.ttl == 0) {
cf_log_err(conf, "Must set 'ttl' to non-zero");
return -1;
}
inst->auth_type = fr_dict_enum_by_name(attr_auth_type, inst->name, -1);
- rad_assert(inst->auth_type);
+ fr_assert(inst->auth_type);
return 0;
}
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/tls/base.h>
#include <openssl/crypto.h>
fr_tls_log_error(request, "Failed finalising message digest");
return XLAT_ACTION_FAIL;
}
- rad_assert((size_t)digest_len == talloc_array_length(xt->digest_buff));
+ fr_assert((size_t)digest_len == talloc_array_length(xt->digest_buff));
/*
* Then sign the digest
fr_tls_log_error(request, "Failed finalising message digest");
return XLAT_ACTION_FAIL;
}
- rad_assert((size_t)digest_len == talloc_array_length(xt->digest_buff));
+ fr_assert((size_t)digest_len == talloc_array_length(xt->digest_buff));
/*
* Now check the signature matches what we expected
return 0;
default:
- rad_assert(0);
+ fr_assert(0);
return -1;
}
}
return cipher_rsa_thread_instantiate(conf, instance, el, thread);
case RLM_CIPHER_TYPE_INVALID:
- rad_assert(0);
+ fr_assert(0);
}
return 0;
* the value is unrecognised we've got an issue.
*/
default:
- rad_assert(0);
+ fr_assert(0);
return -1;
};
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/map_proc.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
/** Client field
*
fr_dict_attr_t const *da;
CONF_PAIR const *cp;
- rad_assert(ctx != NULL);
+ fr_assert(ctx != NULL);
fr_cursor_init(&cursor, &head);
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/map.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/base.h>
#include <freeradius-devel/json/base.h>
ssize_t slen;
/* assert packet as not null */
- rad_assert(request->packet != NULL);
+ fr_assert(request->packet != NULL);
/* attempt to build document key */
slen = tmpl_expand(&dockey, buffer, sizeof(buffer), request, inst->user_key, NULL, NULL);
ssize_t slen;
/* assert packet as not null */
- rad_assert(request->packet != NULL);
+ fr_assert(request->packet != NULL);
/* sanity check */
if ((vp = fr_pair_find_by_da(request->packet->vps, attr_acct_status_type, TAG_ANY)) == NULL) {
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/map_proc.h>
fr_cursor_t cursor;
fr_dict_attr_t const *da;
- rad_assert(ctx != NULL);
+ fr_assert(ctx != NULL);
fr_cursor_init(&cursor, &head);
/*
}
vp = fr_pair_afrom_da(ctx, da);
- rad_assert(vp);
+ fr_assert(vp);
if (fr_pair_value_from_str(vp, str, talloc_array_length(str) - 1, '\0', true) < 0) {
RWDEBUG("Failed parsing value \"%pV\" for attribute %s: %s", fr_box_strvalue_buffer(str),
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/unlang/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/map_proc.h>
#include <freeradius-devel/util/time.h>
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/exfile.h>
#include <ctype.h>
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
/** Xlat for %{attr_by_num:\<number\>}
*
* Check for proper format of the Digest-Attributes
*/
RDEBUG2("Checking for correctly formatted Digest-Attributes");
- rad_assert(attr_digest_attributes);
+ fr_assert(attr_digest_attributes);
first = fr_cursor_iter_by_da_init(&cursor, &request->packet->vps, attr_digest_attributes);
if (!first) return RLM_MODULE_NOOP;
return -1;
}
inst->auth_type = fr_dict_enum_by_name(attr_auth_type, inst->name, -1);
- rad_assert(inst->auth_type);
+ fr_assert(inst->auth_type);
return 0;
}
*/
case RLM_MODULE_REJECT:
case RLM_MODULE_DISALLOW:
- rad_assert(eap_session->this_round->request->code == FR_EAP_CODE_FAILURE);
+ fr_assert(eap_session->this_round->request->code == FR_EAP_CODE_FAILURE);
eap_session->this_round->request->code = FR_EAP_CODE_FAILURE;
break;
* Definitely shouldn't get this.
*/
case RLM_MODULE_YIELD:
- rad_assert(0);
+ fr_assert(0);
break;
default:
/*
* Session must have been thawed...
*/
- rad_assert(eap_session->request);
+ fr_assert(eap_session->request);
/*
* Don't trust anyone.
/*
* If any of these fail, we messed badly somewhere
*/
- rad_assert(next >= FR_EAP_METHOD_MD5);
- rad_assert(next < FR_EAP_METHOD_MAX);
- rad_assert(inst->methods[next].submodule);
+ fr_assert(next >= FR_EAP_METHOD_MD5);
+ fr_assert(next < FR_EAP_METHOD_MAX);
+ fr_assert(inst->methods[next].submodule);
eap_session->process = inst->methods[next].submodule->session_init;
eap_session->type = next;
VALUE_PAIR *username;
eap_session = eap_session_thaw(request);
- rad_assert(eap_session);
+ fr_assert(eap_session);
/*
* Grab the tunnel callbacks from the request.
return -1;
}
inst->auth_type = fr_dict_enum_by_name(attr_auth_type, inst->name, -1);
- rad_assert(inst->name);
+ fr_assert(inst->name);
/*
* Load and bootstrap the submodules now
#include <freeradius-devel/eap/base.h>
#include <freeradius-devel/eap_aka_sim/state_machine.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/compile.h>
#include <freeradius-devel/unlang/module.h>
#include <freeradius-devel/eap/base.h>
#include <freeradius-devel/eap_aka_sim/state_machine.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/compile.h>
#include <freeradius-devel/unlang/module.h>
#include <openssl/ssl.h>
#include <openssl/rand.h>
-#define RANDFILL(x) do { rad_assert(sizeof(x) % sizeof(uint32_t) == 0); for (size_t i = 0; i < sizeof(x); i += sizeof(uint32_t)) *((uint32_t *)&x[i]) = fr_rand(); } while(0)
+#define RANDFILL(x) do { fr_assert(sizeof(x) % sizeof(uint32_t) == 0); for (size_t i = 0; i < sizeof(x); i += sizeof(uint32_t)) *((uint32_t *)&x[i]) = fr_rand(); } while(0)
/**
* RFC 4851 section 5.1 - EAP-FAST Authentication Phase 1: Key Derivations
RDEBUG2("Deriving EAP-FAST keys");
- rad_assert(t->s_imck == NULL);
+ fr_assert(t->s_imck == NULL);
ksize = fr_tls_utils_keyblock_size_get(request, tls_session->ssl);
- rad_assert(ksize > 0);
+ fr_assert(ksize > 0);
buf = talloc_array(request, uint8_t, ksize + sizeof(*t->keyblock));
scratch = talloc_array(request, uint8_t, ksize + sizeof(*t->keyblock));
pac.key.hdr.type = htons(EAP_FAST_TLV_MANDATORY | attr_eap_fast_pac_key->attr);
pac.key.hdr.length = htons(sizeof(pac.key.data));
- rad_assert(sizeof(pac.key.data) % sizeof(uint32_t) == 0);
+ fr_assert(sizeof(pac.key.data) % sizeof(uint32_t) == 0);
RANDFILL(pac.key.data);
pac.info.lifetime.hdr.type = htons(attr_eap_fast_pac_info_pac_lifetime->attr);
RHEXDUMP3((uint8_t const *)&opaque_plaintext, sizeof(opaque_plaintext), "PAC-Opaque plaintext data section");
- rad_assert(PAC_A_ID_LENGTH <= EVP_GCM_TLS_TAG_LEN);
+ fr_assert(PAC_A_ID_LENGTH <= EVP_GCM_TLS_TAG_LEN);
memcpy(pac.opaque.aad, t->a_id, PAC_A_ID_LENGTH);
- rad_assert(RAND_bytes(pac.opaque.iv, sizeof(pac.opaque.iv)) != 0);
+ fr_assert(RAND_bytes(pac.opaque.iv, sizeof(pac.opaque.iv)) != 0);
dlen = eap_fast_encrypt((unsigned const char *)&opaque_plaintext, sizeof(opaque_plaintext),
t->a_id, PAC_A_ID_LENGTH, t->pac_opaque_key, pac.opaque.iv,
pac.opaque.data, pac.opaque.tag);
binding.received_version = EAP_FAST_VERSION; /* FIXME use the clients value */
binding.subtype = EAP_FAST_TLV_CRYPTO_BINDING_SUBTYPE_REQUEST;
- rad_assert(sizeof(binding.nonce) % sizeof(uint32_t) == 0);
+ fr_assert(sizeof(binding.nonce) % sizeof(uint32_t) == 0);
RANDFILL(binding.nonce);
binding.nonce[sizeof(binding.nonce) - 1] &= ~0x01; /* RFC 4851 section 4.2.8 */
RHEXDUMP3(binding.nonce, sizeof(binding.nonce), "NONCE");
eap_fast_tunnel_t *t = talloc_get_type_abort(tls_session->opaque, eap_fast_tunnel_t);
uint32_t present = 0;
- rad_assert(sizeof(present) * 8 > EAP_FAST_TLV_MAX);
+ fr_assert(sizeof(present) * 8 > EAP_FAST_TLV_MAX);
while (remaining > 0) {
if (remaining < 4) {
* Allocate a fake REQUEST structure.
*/
fake = request_alloc_fake(request, NULL);
- rad_assert(!fake->packet->vps);
+ fr_assert(!fake->packet->vps);
t = talloc_get_type_abort(tls_session->opaque, eap_fast_tunnel_t);
* an EAP-Identity, and pull it out of there.
*/
if (!t->username) {
- rad_assert(vp->da == attr_eap_message); /* cached from above */
+ fr_assert(vp->da == attr_eap_message); /* cached from above */
if ((vp->vp_length >= EAP_HEADER_LEN + 2) &&
(vp->vp_strvalue[0] == FR_EAP_CODE_RESPONSE) &&
/*
* Seed the proxy packet with the tunneled request.
*/
- rad_assert(!request->proxy);
+ fr_assert(!request->proxy);
/*
* FIXME: Actually proxy stuff
if (!eap_fast_verify(request, tls_session, data, data_len)) return FR_CODE_ACCESS_REJECT;
if (t->stage == EAP_FAST_TLS_SESSION_HANDSHAKE) {
- rad_assert(t->mode == EAP_FAST_UNKNOWN);
+ fr_assert(t->mode == EAP_FAST_UNKNOWN);
char buf[256];
if (strstr(SSL_CIPHER_description(SSL_get_current_cipher(tls_session->ssl),
return -1;
}
- rad_assert(PAC_A_ID_LENGTH == MD5_DIGEST_LENGTH);
+ fr_assert(PAC_A_ID_LENGTH == MD5_DIGEST_LENGTH);
fr_md5_calc(inst->a_id, (uint8_t const *)inst->authority_identity,
talloc_array_length(inst->authority_identity) - 1);
eap_fast_tunnel_t *t = talloc_get_type_abort(tls_session->opaque, eap_fast_tunnel_t);
uint8_t seed[2 * SSL3_RANDOM_SIZE];
- rad_assert(t->pac.key);
+ fr_assert(t->pac.key);
SSL_get_server_random(s, seed, SSL3_RANDOM_SIZE);
SSL_get_client_random(s, &seed[SSL3_RANDOM_SIZE], SSL3_RANDOM_SIZE);
char *value;
if (vp->da == attr_eap_fast_pac_info_pac_type) {
- rad_assert(t->pac.type == 0);
+ fr_assert(t->pac.type == 0);
t->pac.type = vp->vp_uint32;
} else if (vp->da == attr_eap_fast_pac_info_pac_lifetime) {
- rad_assert(t->pac.expires == 0);
+ fr_assert(t->pac.expires == 0);
t->pac.expires = vp->vp_uint32;
t->pac.expired = (vp->vp_uint32 <= time(NULL));
/*
* The original enum didn't match a specific TLV nesting level
*/
} else if (vp->da == attr_eap_fast_pac_key) {
- rad_assert(t->pac.key == NULL);
- rad_assert(vp->vp_length == PAC_KEY_LENGTH);
+ fr_assert(t->pac.key == NULL);
+ fr_assert(vp->vp_length == PAC_KEY_LENGTH);
t->pac.key = talloc_array(t, uint8_t, PAC_KEY_LENGTH);
- rad_assert(t->pac.key != NULL);
+ fr_assert(t->pac.key != NULL);
memcpy(t->pac.key, vp->vp_octets, PAC_KEY_LENGTH);
} else {
value = fr_pair_asprint(tls_session, vp, '"');
*/
case EAP_TLS_ESTABLISHED:
fr_tls_session_send(request, tls_session);
- rad_assert(tls_session->opaque != NULL);
+ fr_assert(tls_session->opaque != NULL);
break;
/*
#define LOG_PREFIX "rlm_eap_gtc - "
#include <freeradius-devel/eap/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/base.h>
static int auth_type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
if (reply->code < 3) {
eap_round->request->type.num = FR_EAP_METHOD_MD5;
- rad_assert(reply->length > 0);
+ fr_assert(reply->length > 0);
eap_round->request->type.data = talloc_array(eap_round->request,
uint8_t,
RCSID("$Id$")
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/md5.h>
#include "eap_md5.h"
/*
* Get the Cleartext-Password for this user.
*/
- rad_assert(eap_session->request != NULL);
+ fr_assert(eap_session->request != NULL);
known_good = password_find(&ephemeral, request, request->parent,
allowed_passwords, NUM_ELEMENTS(allowed_passwords),
MD5_PACKET *reply;
int i;
- rad_assert(eap_session != NULL);
+ fr_assert(eap_session != NULL);
/*
* Allocate an EAP-MD5 packet.
RCSID("$Id$")
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/base.h>
#include "eap_mschapv2.h"
REQUEST *request = eap_session->request;
data = talloc_get_type_abort(eap_session->opaque, mschapv2_opaque_t);
- rad_assert(request != NULL);
+ fr_assert(request != NULL);
RDEBUG2("Passing reply from proxy back into the tunnel %d", request->reply->code);
* Keep track of the challenge.
*/
data = talloc_zero(eap_session, mschapv2_opaque_t);
- rad_assert(data != NULL);
+ fr_assert(data != NULL);
/*
* We're at the stage where we're challenging the user.
*/
static int eap_peap_inner_from_pairs(REQUEST *request, fr_tls_session_t *tls_session, VALUE_PAIR *vp)
{
- rad_assert(vp != NULL);
+ fr_assert(vp != NULL);
VALUE_PAIR *this;
fr_cursor_t cursor;
case PEAP_STATUS_WAIT_FOR_SOH_RESPONSE:
fake = request_alloc_fake(request, NULL);
- rad_assert(!fake->packet->vps);
+ fr_assert(!fake->packet->vps);
eap_peap_soh_verify(fake, fake->packet, data, data_len);
setup_fake_request(request, fake, t);
}
/* save the SoH VPs */
- rad_assert(!t->soh_reply_vps);
+ fr_assert(!t->soh_reply_vps);
MEM(fr_pair_list_copy(t, &t->soh_reply_vps, fake->reply->vps) >= 0);
- rad_assert(!fake->reply->vps);
+ fr_assert(!fake->reply->vps);
TALLOC_FREE(fake);
if (t->session_resumption_state == PEAP_RESUMPTION_YES) {
}
fake = request_alloc_fake(request, NULL);
- rad_assert(!fake->packet->vps);
+ fr_assert(!fake->packet->vps);
switch (t->status) {
/*
size_t len;
uint8_t *q;
- rad_assert(t->username);
+ fr_assert(t->username);
len = t->username->vp_length + EAP_HEADER_LEN + 1;
t->status = PEAP_STATUS_PHASE2;
*/
if ((data[0] == FR_EAP_METHOD_IDENTITY) && (data_len > 1)) {
MEM(t->username = fr_pair_afrom_da(t, attr_user_name));
- rad_assert(t->username != NULL);
+ fr_assert(t->username != NULL);
t->username->vp_tainted = true;
fr_pair_value_bstrncpy(t->username, data + 1, data_len - 1);
pwd_hdr *hdr;
len = (session->out_len - session->out_pos) + sizeof(pwd_hdr);
- rad_assert(len > 0);
+ fr_assert(len > 0);
eap_round->request->code = FR_EAP_CODE_REQUEST;
eap_round->request->type.num = FR_EAP_METHOD_PWD;
eap_round->request->type.length = (len > session->mtu) ? session->mtu : len;
#include <freeradius-devel/eap/base.h>
#include <freeradius-devel/eap_aka_sim/state_machine.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/compile.h>
#include <freeradius-devel/unlang/module.h>
switch (SSL_SESSION_get_protocol_version(SSL_get_session(tls_session->ssl))) {
case SSL2_VERSION: /* Should never happen */
case SSL3_VERSION: /* Should never happen */
- rad_assert(0);
+ fr_assert(0);
return RLM_MODULE_INVALID;
case TLS1_VERSION:
}
} else {
server_cs = virtual_server_find(inst->virtual_server);
- rad_assert(server_cs);
+ fr_assert(server_cs);
}
section = cf_section_find(server_cs, "recv", "Access-Request");
fr_dict_attr_t const *attr_radius;
dict_radius = fr_dict_by_protocol_name("radius");
- rad_assert(dict_radius != NULL);
+ fr_assert(dict_radius != NULL);
attr_radius = fr_dict_root(dict_radius);
while (p < end) {
ttls_tunnel_t *t = tls_session->opaque;
- rad_assert(eap_session->request == request);
+ fr_assert(eap_session->request == request);
/*
* If the response packet was Access-Accept, then
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <ctype.h>
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
/*
* Define a structure for our module configuration.
static int rlm_example_cmp(UNUSED void *instance, REQUEST *request, UNUSED VALUE_PAIR *thing, VALUE_PAIR *check,
UNUSED VALUE_PAIR *check_pairs, UNUSED VALUE_PAIR **reply_pairs)
{
- rad_assert(check->vp_type == FR_TYPE_STRING);
+ fr_assert(check->vp_type == FR_TYPE_STRING);
RINFO("Example-Paircmp called with \"%pV\"", &check->data);
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
/*
* Define a structure for our module configuration.
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <ctype.h>
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/dhcpv4/dhcpv4.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/map_proc.h>
return -1;
}
- rad_assert(half >= 0);
+ fr_assert(half >= 0);
/*
* "option" has multiple parse possibilities, so we treat
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/map_proc.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/json/base.h>
#include <ctype.h>
slen = fr_jpath_parse(request, &head, fmt, strlen(fmt));
if (slen <= 0) {
- rad_assert(head == NULL);
+ fr_assert(head == NULL);
return snprintf(*out, outlen, "%zd:%s", -(slen), fr_strerror());
}
- rad_assert(talloc_get_type_abort(head, fr_jpath_node_t));
+ fr_assert(talloc_get_type_abort(head, fr_jpath_node_t));
jpath_str = fr_jpath_asprint(request, head);
ret = snprintf(*out, outlen, "%zu:%s", (size_t) slen, jpath_str);
return -1;
}
if (ret == 0) return 0;
- rad_assert(head);
+ fr_assert(head);
for (fr_cursor_init(&cursor, out), value = head;
value;
#define LOG_PREFIX "rlm_krb5 (%s) - "
#define LOG_PREFIX_ARGS inst->name
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/base.h>
#include "krb5.h"
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "krb5.h"
static const CONF_PARSER module_config[] = {
*/
static rlm_rcode_t krb5_process_error(rlm_krb5_t const *inst, REQUEST *request, rlm_krb5_handle_t *conn, int ret)
{
- rad_assert(ret != 0);
+ fr_assert(ret != 0);
if (!fr_cond_assert(inst)) return RLM_MODULE_FAIL;
if (!fr_cond_assert(conn)) return RLM_MODULE_FAIL; /* Silences warnings */
USES_APPLE_DEPRECATED_API
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <ctype.h>
#define LOG_PREFIX "rlm_ldap (%s) - "
DEBUG("Loading dynamic clients");
- rad_assert(inst->clientobj_base_dn);
+ fr_assert(inst->clientobj_base_dn);
count = cf_pair_count(map);
count++;
goto finish;
}
- rad_assert(conn);
+ fr_assert(conn);
conn->rebound = false;
}
goto finish;
}
- rad_assert(conn);
+ fr_assert(conn);
entry = ldap_first_entry(conn->handle, result);
if (!entry) {
int ldap_errno;
#define LOG_PREFIX "%s - "
#define LOG_PREFIX_ARGS handle_config->name
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "rlm_ldap.h"
conn = fr_pool_connection_get(inst->pool, request);
- rad_assert(!conn || conn->config);
+ fr_assert(!conn || conn->config);
#ifdef LDAP_CONTROL_X_SESSION_TRACKING
/*
USES_APPLE_DEPRECATED_API
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <ctype.h>
#define LOG_PREFIX "rlm_ldap (%s) - "
int is_dn, i, count;
- rad_assert(entry);
- rad_assert(attr);
+ fr_assert(entry);
+ fr_assert(attr);
/*
* Parse the membership information we got in the initial user query.
list = radius_list(request, PAIR_LIST_CONTROL);
list_ctx = radius_list_ctx(request, PAIR_LIST_CONTROL);
- rad_assert(list != NULL);
- rad_assert(list_ctx != NULL);
+ fr_assert(list != NULL);
+ fr_assert(list_ctx != NULL);
/*
* Simplifies freeing temporary values
VALUE_PAIR *vp;
char *dn;
- rad_assert(inst->groupobj_base_dn);
+ fr_assert(inst->groupobj_base_dn);
if (!inst->groupobj_membership_filter) {
RDEBUG2("Skipping caching group objects as directive 'group.membership_filter' is not set");
char filter[LDAP_MAX_FILTER_STR_LEN + 1];
int ret;
- rad_assert(inst->groupobj_base_dn);
+ fr_assert(inst->groupobj_base_dn);
switch (check->op) {
case T_OP_CMP_EQ:
continue;
}
- rad_assert(0);
+ fr_assert(0);
}
finish:
USES_APPLE_DEPRECATED_API
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "rlm_ldap.h"
goto free_socket;
}
- rad_assert(conn);
- rad_assert(result);
+ fr_assert(conn);
+ fr_assert(result);
entry = ldap_first_entry(conn->handle, result);
if (!entry) {
goto free_socket;
}
- rad_assert(conn);
- rad_assert(result);
+ fr_assert(conn);
+ fr_assert(result);
for (entry = ldap_first_entry(conn->handle, result);
entry;
fr_ldap_connection_t *conn = NULL;
char const *user_dn;
- rad_assert(inst->groupobj_base_dn);
+ fr_assert(inst->groupobj_base_dn);
RDEBUG2("Searching for user in group \"%pV\"", &check->data);
return 1;
}
- rad_assert(conn);
+ fr_assert(conn);
/*
* Check groupobj user membership
}
}
- rad_assert(conn);
+ fr_assert(conn);
/*
* Check userobj group membership
}
}
- rad_assert(conn);
+ fr_assert(conn);
finish:
if (conn) ldap_mod_conn_release(inst, request, conn);
char const *filter;
char filter_buff[LDAP_MAX_FILTER_STR_LEN];
- rad_assert(inst->profile_filter); /* We always have a default filter set */
+ fr_assert(inst->profile_filter); /* We always have a default filter set */
if (!dn || !*dn) return RLM_MODULE_OK;
return RLM_MODULE_FAIL;
}
- rad_assert(*pconn);
- rad_assert(result);
+ fr_assert(*pconn);
+ fr_assert(result);
entry = ldap_first_entry(handle, result);
if (!entry) {
char *p = path;
- rad_assert(section);
+ fr_assert(section);
/*
* Locate the update section were going to be using
break;
default:
- rad_assert(0);
+ fr_assert(0);
goto error;
}
USES_APPLE_DEPRECATED_API
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <ctype.h>
#define LOG_PREFIX "rlm_ldap (%s) - "
return NULL;
}
- rad_assert(*pconn);
+ fr_assert(*pconn);
(*pconn)->rebound = false;
}
return NULL;
}
- rad_assert(*pconn);
+ fr_assert(*pconn);
/*
* Forbid the use of unsorted search results that
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/exfile.h>
#ifdef HAVE_FCNTL_H
case LINELOG_DST_INVALID:
case LINELOG_DST_FILE:
case LINELOG_DST_SYSLOG:
- rad_assert(0);
+ fr_assert(0);
return NULL;
}
break;
case LINELOG_DST_INVALID:
- rad_assert(0);
+ fr_assert(0);
break;
}
exfile_close(inst->file.ef, request, fd);
/* Assert on the extra fatal errors */
- rad_assert((errno != EINVAL) && (errno != EFAULT));
+ fr_assert((errno != EINVAL) && (errno != EFAULT));
return RLM_MODULE_FAIL;
}
/* Assert on the extra fatal errors */
case EINVAL:
case EFAULT:
- rad_assert(0);
+ fr_assert(0);
/* FALL-THROUGH */
/* Normal errors that just cause the module to fail */
break;
#endif
case LINELOG_DST_INVALID:
- rad_assert(0);
+ fr_assert(0);
rcode = RLM_MODULE_FAIL;
break;
}
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/connection.h>
#ifdef HAVE_FCNTL_H
* If there are, investigate why we get them...
*/
default:
- rad_assert(0);
+ fr_assert(0);
}
}
}
* If there are, investigate why we get them...
*/
default:
- rad_assert(0);
+ fr_assert(0);
}
}
*/
case LOGTEE_DST_INVALID:
case LOGTEE_DST_FILE:
- rad_assert(0);
+ fr_assert(0);
return FR_CONNECTION_STATE_FAILED;
}
VALUE_PAIR *vp;
log_dst_t *dst;
- rad_assert(t->msg->vp_length == 0); /* Should have been cleared before returning */
+ fr_assert(t->msg->vp_length == 0); /* Should have been cleared before returning */
/*
* None of this should involve mallocs unless msg > 1k
break;
case LOGTEE_DST_INVALID:
- rad_assert(0);
+ fr_assert(0);
break;
}
#define LOG_PREFIX_ARGS inst->xlat_name
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "config.h"
#include "lua.h"
VALUE_PAIR *vp = NULL;
int index;
- rad_assert(lua_islightuserdata(L, lua_upvalueindex(1)));
+ fr_assert(lua_islightuserdata(L, lua_upvalueindex(1)));
da = lua_touserdata(L, lua_upvalueindex(1));
- rad_assert(da);
+ fr_assert(da);
/*
* @fixme Packet list should be light user data too at some point
* This function should only be called as a closure.
* As we control the upvalues, we should assert on errors.
*/
- rad_assert(lua_islightuserdata(L, lua_upvalueindex(1)));
+ fr_assert(lua_islightuserdata(L, lua_upvalueindex(1)));
da = lua_touserdata(L, lua_upvalueindex(1));
- rad_assert(da);
+ fr_assert(da);
delete = lua_isnil(L, -1);
* As we control the upvalues, we should assert on errors.
*/
- rad_assert(lua_isuserdata(L, lua_upvalueindex(1)));
+ fr_assert(lua_isuserdata(L, lua_upvalueindex(1)));
cursor = lua_touserdata(L, lua_upvalueindex(1));
- rad_assert(cursor);
+ fr_assert(cursor);
/* Packet list should be light user data too at some point... */
vp = fr_cursor_next(cursor);
* This function should only be called as a closure.
* As we control the upvalues, we should assert on errors.
*/
- rad_assert(lua_isuserdata(L, lua_upvalueindex(2)));
+ fr_assert(lua_isuserdata(L, lua_upvalueindex(2)));
da = lua_touserdata(L, lua_upvalueindex(2));
- rad_assert(da);
+ fr_assert(da);
cursor = (fr_cursor_t*) lua_newuserdata(L, sizeof(fr_cursor_t));
if (!cursor) {
fr_cursor_t *cursor;
VALUE_PAIR *vp;
- rad_assert(lua_isuserdata(L, lua_upvalueindex(1)));
+ fr_assert(lua_isuserdata(L, lua_upvalueindex(1)));
cursor = lua_touserdata(L, lua_upvalueindex(1));
- rad_assert(cursor);
+ fr_assert(cursor);
/* Packet list should be light user data too at some point... */
vp = fr_cursor_current(cursor);
#define LOG_PREFIX_ARGS inst->xlat_name
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/module.h>
#include "lua.h"
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/pairmove.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "rlm_mruby.h"
break;
case FR_TYPE_NON_VALUES:
- rad_assert(0);
+ fr_assert(0);
return -1;
}
RCSID("$Id$")
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <wbclient.h>
#include <core/ntstatus.h>
/*
* wb_username must be set for this function to be called
*/
- rad_assert(inst->wb_username);
+ fr_assert(inst->wb_username);
MEM(authparams = talloc_zero_pooled_object(NULL, struct wbcAuthUserParams, 2, 1024));
/*
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/md5.h>
#include <freeradius-devel/util/sha1.h>
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/md5.h>
#include <ctype.h>
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/password.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/md4.h>
#include <freeradius-devel/util/md5.h>
return 0;
}
- rad_assert(password->da == attr_nt_password);
+ fr_assert(password->da == attr_nt_password);
if (RDEBUG_ENABLED3) {
RDEBUG3("Found &control:%pP", password);
break;
default:
- rad_assert(0);
+ fr_assert(0);
break;
}
return -1;
}
inst->auth_type = fr_dict_enum_by_name(attr_auth_type, inst->name, -1);
- rad_assert(inst->auth_type);
+ fr_assert(inst->auth_type);
xlat_register(inst, inst->name, mschap_xlat, NULL, NULL, 0, XLAT_DEFAULT_BUF_LEN, true);
USES_APPLE_DEPRECATED_API
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <ctype.h>
#include <stdlib.h>
return -1;
}
inst->auth_type = fr_dict_enum_by_name(attr_auth_type, inst->name, -1);
- rad_assert(inst->auth_type);
+ fr_assert(inst->auth_type);
return 0;
}
#include <freeradius-devel/server/crypt.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/password.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/tls/base.h>
#include <freeradius-devel/util/base64.h>
#include <freeradius-devel/util/md5.h>
EVP_DigestFinal_ex(ctx, digest, &digest_len);
EVP_MD_CTX_destroy(ctx);
- rad_assert((size_t) digest_len == known_good->vp_length); /* This would be an OpenSSL bug... */
+ fr_assert((size_t) digest_len == known_good->vp_length); /* This would be an OpenSSL bug... */
if (fr_digest_cmp(digest, known_good->vp_octets, known_good->vp_length) != 0) {
REDEBUG("%s digest does not match \"known good\" digest", name);
EVP_DigestFinal_ex(ctx, digest, &digest_len);
EVP_MD_CTX_destroy(ctx);
- rad_assert((size_t) digest_len == min_len); /* This would be an OpenSSL bug... */
+ fr_assert((size_t) digest_len == min_len); /* This would be an OpenSSL bug... */
/*
* Only compare digest_len bytes, the rest is salt.
RDEBUG2("Comparing with \"known-good\" NT-Password");
- rad_assert(password->da == attr_user_password);
+ fr_assert(password->da == attr_user_password);
if (known_good->vp_length != MD4_DIGEST_LENGTH) {
REDEBUG("\"known good\" NT-Password has incorrect length, expected 16 got %zu", known_good->vp_length);
return RLM_MODULE_FAIL;
}
- rad_assert(known_good->da->attr < NUM_ELEMENTS(auth_func_table));
+ fr_assert(known_good->da->attr < NUM_ELEMENTS(auth_func_table));
auth_func = auth_func_table[known_good->da->attr];
- rad_assert(auth_func);
+ fr_assert(auth_func);
if (RDEBUG_ENABLED3) {
RDEBUG3("Comparing with \"known good\" %pP (%zu)", known_good, known_good->vp_length);
return -1;
}
inst->auth_type = fr_dict_enum_by_name(attr_auth_type, inst->name, -1);
- rad_assert(inst->auth_type);
+ fr_assert(inst->auth_type);
return 0;
}
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
struct mypasswd {
struct mypasswd *next;
fr_dict_attr_t const *da;
rlm_passwd_t *inst = instance;
- rad_assert(inst->filename && *inst->filename);
- rad_assert(inst->format && *inst->format);
+ fr_assert(inst->filename && *inst->filename);
+ fr_assert(inst->format && *inst->format);
if (inst->hash_size == 0) {
cf_log_err(conf, "Invalid value '0' for hash_size");
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#ifdef INADDR_ANY
# undef INADDR_ANY
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/pairmove.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/lsan.h>
#include <Python.h>
break;
case FR_TYPE_NON_VALUES:
- rad_assert(0);
+ fr_assert(0);
return -1;
}
NULL, /* m_free */
};
- rad_assert(inst && conf);
+ fr_assert(inst && conf);
module = PyModule_Create(&py_module_def);
if (!module) {
#define LOAD_INFO(_fmt, ...) fr_log(LOG_DST, L_INFO, __FILE__, __LINE__, "rlm_python - " _fmt, ## __VA_ARGS__)
#define LOAD_WARN(_fmt, ...) fr_log(LOG_DST, L_WARN, __FILE__, __LINE__, "rlm_python - " _fmt, ## __VA_ARGS__)
- rad_assert(!Py_IsInitialized());
+ fr_assert(!Py_IsInitialized());
LOAD_INFO("Python version: %s", Py_GetVersion());
dependency_version_number_add(NULL, "python", Py_GetVersion());
#if PY_VERSION_HEX < 0x03070000
PyEval_InitThreads(); /* This also grabs a lock (which we then need to release) */
#endif
- rad_assert(PyEval_ThreadsInitialized());
+ fr_assert(PyEval_ThreadsInitialized());
/*
* Set program name (i.e. the software calling the interpreter)
#include <freeradius-devel/io/application.h>
#include <freeradius-devel/server/modpriv.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/base.h>
#include <freeradius-devel/util/dlist.h>
/*
* Must be the RADIUS module
*/
- rad_assert(cs && (strcmp(cf_section_name1(cs), "radius") == 0));
+ fr_assert(cs && (strcmp(cf_section_name1(cs), "radius") == 0));
/*
* Allow the process module to be specified by
if (!transport_cs) transport_cs = cf_section_alloc(cs, cs, name, NULL);
parent_inst = cf_data_value(cf_data_find(cs, dl_module_inst_t, "rlm_radius"));
- rad_assert(parent_inst);
+ fr_assert(parent_inst);
return dl_module_instance(ctx, out, transport_cs, parent_inst, name, DL_MODULE_TYPE_SUBMODULE);
}
char const *name2;
vp_map_t *head = NULL;
- rad_assert(cf_item_is_section(ci));
+ fr_assert(cf_item_is_section(ci));
cs = cf_item_to_section(ci);
name2 = cf_section_name2(cs);
*/
rcode = inst->io->enqueue(&rctx, inst->io_instance, t->io_thread, request);
if (rcode != RLM_MODULE_YIELD) {
- rad_assert(rctx == NULL);
+ fr_assert(rctx == NULL);
return rcode;
}
}
num_types = talloc_array_length(inst->types);
- rad_assert(num_types > 0);
+ fr_assert(num_types > 0);
/*
* Allow for O(1) lookup later...
uint32_t code;
code = inst->types[i];
- rad_assert(code > 0);
- rad_assert(code < FR_RADIUS_MAX_PACKET_CODE);
+ fr_assert(code > 0);
+ fr_assert(code < FR_RADIUS_MAX_PACKET_CODE);
inst->allowed[code] = true;
}
- rad_assert(inst->status_check < FR_RADIUS_MAX_PACKET_CODE);
+ fr_assert(inst->status_check < FR_RADIUS_MAX_PACKET_CODE);
/*
* If we're replicating, we don't care if the other end
inst->io_instance = inst->io_submodule->data;
inst->io_conf = inst->io_submodule->conf;
- rad_assert(inst->io->thread_inst_size > 0);
- rad_assert(inst->io->bootstrap != NULL);
- rad_assert(inst->io->instantiate != NULL);
+ fr_assert(inst->io->thread_inst_size > 0);
+ fr_assert(inst->io->bootstrap != NULL);
+ fr_assert(inst->io->instantiate != NULL);
/*
* Get random Proxy-State identifier for this module.
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/missing.h>
#include <freeradius-devel/server/connection.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/unlang/base.h>
#include <freeradius-devel/util/heap.h>
#include <freeradius-devel/util/udp.h>
*/
static void status_check_reset(udp_handle_t *h, udp_request_t *u)
{
- rad_assert(u->status_check == true);
+ fr_assert(u->status_check == true);
h->status_checking = false;
u->num_replies = 0; /* Reset */
/*
* Connection must be in the connecting state when this fires
*/
- rad_assert(conn->state == FR_CONNECTION_STATE_CONNECTING);
+ fr_assert(conn->state == FR_CONNECTION_STATE_CONNECTING);
h = talloc_get_type_abort(conn->h, udp_handle_t);
/*
* Connection must be in the connecting state when this fires
*/
- rad_assert(conn->state == FR_CONNECTION_STATE_CONNECTING);
+ fr_assert(conn->state == FR_CONNECTION_STATE_CONNECTING);
h = talloc_get_type_abort(conn->h, udp_handle_t);
u = h->status_u;
return;
}
- rad_assert(0);
+ fr_assert(0);
}
/** Send the next status check packet
h->module_name, fr_packet_codes[u->code], u->id, u->packet_len, h->name, fr_syserror(errno));
goto fail;
}
- rad_assert((size_t)slen == u->packet_len);
+ fr_assert((size_t)slen == u->packet_len);
/*
* Switch to waiting on read and insert the event
*/
static int _udp_handle_free(udp_handle_t *h)
{
- rad_assert(h->fd >= 0);
+ fr_assert(h->fd >= 0);
if (h->status_u) fr_event_timer_delete(&h->status_u->ev);
#ifndef NDEBUG
radius_track_state_log(&default_log, L_ERR, __FILE__, __LINE__, h->tt, udp_tracking_entry_log);
#endif
- fr_cond_assert_fail(__FILE__, __LINE__, "0", "%u tracking entries still allocated at conn close",
- h->tt->num_requests);
+ fr_assert_fail(__FILE__, __LINE__, "0", "%u tracking entries still allocated at conn close",
+ h->tt->num_requests);
}
talloc_free(h);
int message_authenticator = u->require_ma * (RADIUS_MESSAGE_AUTHENTICATOR_LENGTH + 2);
int proxy_state = 6;
- rad_assert(inst->parent->allowed[u->code]);
- rad_assert(!u->packet);
+ fr_assert(inst->parent->allowed[u->code]);
+ fr_assert(!u->packet);
/*
* Try to retransmit, unless there are special
* We should have at mininum 64-byte packets, so don't
* bother doing run-time checks here.
*/
- rad_assert(u->packet_len >= (size_t) (RADIUS_HEADER_LENGTH + proxy_state + message_authenticator));
+ fr_assert(u->packet_len >= (size_t) (RADIUS_HEADER_LENGTH + proxy_state + message_authenticator));
/*
* Encode it, leaving room for Proxy-State and
fr_cursor_t cursor;
int count = 0;
- rad_assert((size_t) (packet_len + proxy_state) <= u->packet_len);
+ fr_assert((size_t) (packet_len + proxy_state) <= u->packet_len);
/*
* Count how many Proxy-State attributes have
* the buflen manipulation done above.
*/
if (message_authenticator) {
- rad_assert((size_t) (packet_len + message_authenticator) <= u->packet_len);
+ fr_assert((size_t) (packet_len + message_authenticator) <= u->packet_len);
msg = u->packet + packet_len;
* We're replicating, and don't care about the health of
* the home server, and this function should not be called.
*/
- rad_assert(!h->inst->replicate);
+ fr_assert(!h->inst->replicate);
/*
* If there's already a zombie check started, don't do
REQUEST *request = treq->request;
fr_trunk_connection_t *tconn = treq->tconn;
- rad_assert(treq->state == FR_TRUNK_REQUEST_STATE_SENT); /* No other states should be timing out */
- rad_assert(treq->preq); /* Must still have a protocol request */
- rad_assert(u->rr);
- rad_assert(tconn);
+ fr_assert(treq->state == FR_TRUNK_REQUEST_STATE_SENT); /* No other states should be timing out */
+ fr_assert(treq->preq); /* Must still have a protocol request */
+ fr_assert(u->rr);
+ fr_assert(tconn);
h = talloc_get_type_abort(treq->tconn->conn->h, udp_handle_t);
*/
if (!treq) break;
- rad_assert((treq->state == FR_TRUNK_REQUEST_STATE_PENDING) ||
+ fr_assert((treq->state == FR_TRUNK_REQUEST_STATE_PENDING) ||
(treq->state == FR_TRUNK_REQUEST_STATE_PARTIAL));
request = treq->request;
*/
if (!u->retry.start) {
(void) fr_retry_init(&u->retry, fr_time(), &h->inst->parent->retry[u->code]);
- rad_assert(u->retry.rt > 0);
- rad_assert(u->retry.next > 0);
+ fr_assert(u->retry.rt > 0);
+ fr_assert(u->retry.next > 0);
}
/*
* the REQUEUE signal was recevied.
*/
if (!u->packet || !u->can_retransmit) {
- rad_assert(!u->rr);
+ fr_assert(!u->rr);
if (unlikely(radius_track_entry_reserve(&u->rr, treq, h->tt, request, u->code, treq) < 0)) {
#ifndef NDEBUG
radius_track_state_log(&default_log, L_ERR, __FILE__, __LINE__,
h->tt, udp_tracking_entry_log);
#endif
- fr_cond_assert_fail(__FILE__, __LINE__, "0", "Tracking entry allocation failed");
+ fr_assert_fail(__FILE__, __LINE__, "0", "Tracking entry allocation failed");
fail:
fr_trunk_request_signal_fail(treq);
continue;
/*
* It's UDP so there should never be partial writes
*/
- rad_assert((size_t)h->mmsgvec[i].msg_len == h->mmsgvec[i].msg_hdr.msg_iov->iov_len);
+ fr_assert((size_t)h->mmsgvec[i].msg_len == h->mmsgvec[i].msg_hdr.msg_iov->iov_len);
- rad_assert(treq->state == FR_TRUNK_REQUEST_STATE_SENT);
+ fr_assert(treq->state == FR_TRUNK_REQUEST_STATE_SENT);
request = treq->request;
u = talloc_get_type_abort(treq->preq, udp_request_t);
*/
if (!treq) break;
- rad_assert((treq->state == FR_TRUNK_REQUEST_STATE_PENDING) ||
+ fr_assert((treq->state == FR_TRUNK_REQUEST_STATE_PENDING) ||
(treq->state == FR_TRUNK_REQUEST_STATE_PARTIAL));
request = treq->request;
/*
* It's UDP so there should never be partial writes
*/
- rad_assert((size_t)h->mmsgvec[i].msg_len == h->mmsgvec[i].msg_hdr.msg_iov->iov_len);
+ fr_assert((size_t)h->mmsgvec[i].msg_len == h->mmsgvec[i].msg_hdr.msg_iov->iov_len);
r->rcode = RLM_MODULE_OK;
fr_trunk_request_signal_complete(treq);
udp_request_t *u = talloc_get_type_abort(treq->preq, udp_request_t);
udp_result_t *r = talloc_get_type_abort(treq->rctx, udp_result_t);
- rad_assert(treq->preq == h->status_u);
- rad_assert(treq->rctx == h->status_r);
+ fr_assert(treq->preq == h->status_u);
+ fr_assert(treq->rctx == h->status_r);
r->treq = NULL;
treq = talloc_get_type_abort(rr->uctx, fr_trunk_request_t);
request = treq->request;
- rad_assert(request != NULL);
+ fr_assert(request != NULL);
u = talloc_get_type_abort(treq->preq, udp_request_t);
r = talloc_get_type_abort(treq->rctx, udp_result_t);
udp_result_t *r = talloc_get_type_abort(rctx, udp_result_t);
udp_request_t *u = talloc_get_type_abort(preq, udp_request_t);
- rad_assert(!u->rr && !u->packet && !u->extra && !u->ev); /* Dealt with by request_conn_release */
+ fr_assert(!u->rr && !u->packet && !u->extra && !u->ev); /* Dealt with by request_conn_release */
- rad_assert(state != FR_TRUNK_REQUEST_STATE_INIT);
+ fr_assert(state != FR_TRUNK_REQUEST_STATE_INIT);
if (u->status_check) return;
udp_result_t *r = talloc_get_type_abort(rctx, udp_result_t);
udp_request_t *u = talloc_get_type_abort(preq, udp_request_t);
- rad_assert(!u->rr && !u->packet && !u->extra && !u->ev); /* Dealt with by request_conn_release */
+ fr_assert(!u->rr && !u->packet && !u->extra && !u->ev); /* Dealt with by request_conn_release */
if (u->status_check) return;
{
udp_request_t *u = talloc_get_type_abort(preq_to_free, udp_request_t);
- rad_assert(!u->rr && !u->packet && !u->extra && !u->ev); /* Dealt with by request_conn_release */
+ fr_assert(!u->rr && !u->packet && !u->extra && !u->ev); /* Dealt with by request_conn_release */
/*
* Don't free status check requests.
{
if (u->ev) (void) fr_event_timer_delete(&u->ev);
- rad_assert(u->rr == NULL);
+ fr_assert(u->rr == NULL);
return 0;
}
udp_request_t *u;
fr_trunk_request_t *treq;
- rad_assert(request->packet->code > 0);
- rad_assert(request->packet->code < FR_RADIUS_MAX_PACKET_CODE);
+ fr_assert(request->packet->code > 0);
+ fr_assert(request->packet->code < FR_RADIUS_MAX_PACKET_CODE);
/*
* If configured, and we don't have any active
}
if (fr_trunk_request_enqueue(&treq, t->trunk, request, u, r) < 0) {
- rad_assert(!u->rr && !u->packet); /* Should not have been fed to the muxer */
+ fr_assert(!u->rr && !u->packet); /* Should not have been fed to the muxer */
fr_trunk_request_free(&treq); /* Return to the free list */
talloc_free(r);
return RLM_MODULE_FAIL;
#include <freeradius-devel/util/rbtree.h>
#include <freeradius-devel/io/application.h>
#include <freeradius-devel/util/dlist.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "track.h"
#include "rlm_radius.h"
retry:
te = fr_dlist_head(&tt->free_list);
if (te) {
- rad_assert(te->request == NULL);
+ fr_assert(te->request == NULL);
/*
* Mark it as used, and remove it from the free list.
te->request = NULL;
- rad_assert(tt->num_requests > 0);
+ fr_assert(tt->num_requests > 0);
tt->num_requests--;
/*
/*
* Delete it from the tracking subtree.
*/
- rad_assert(tt->subtree[te->id] != NULL);
+ fr_assert(tt->subtree[te->id] != NULL);
(void) rbtree_deletebydata(tt->subtree[te->id], te);
/*
{
radius_track_t *tt = te->tt;
- rad_assert(tt);
+ fr_assert(tt);
/*
* The authentication vector may have changed.
* @todo - gracefully handle fallback if the server screws up.
*/
if (!tt->use_authenticator) {
- rad_assert(te == &tt->id[te->id]);
+ fr_assert(te == &tt->id[te->id]);
return 0;
}
}
(void) talloc_get_type_abort(te, radius_track_entry_t);
- rad_assert(te->request != NULL);
+ fr_assert(te->request != NULL);
return te;
}
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/radutmp.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <fcntl.h>
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/modpriv.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/redis/base.h>
#include <freeradius-devel/redis/cluster.h>
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/modpriv.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/redis/base.h>
#include <freeradius-devel/redis/cluster.h>
fr_redis_rcode_t status;
ippool_rcode_t ret = IPPOOL_RCODE_SUCCESS;
- rad_assert(key_prefix);
- rad_assert(device_id);
+ fr_assert(key_prefix);
+ fr_assert(device_id);
now = fr_time_to_timeval(fr_time());
goto finish;
}
- rad_assert(reply);
+ fr_assert(reply);
if (reply->type != REDIS_REPLY_ARRAY) {
REDEBUG("Expected result to be array got \"%s\"",
fr_table_str_by_value(redis_reply_types, reply->type, "<UNKNOWN>"));
return RLM_MODULE_NOOP;
default:
- rad_assert(0);
+ fr_assert(0);
return RLM_MODULE_FAIL;
}
}
rlm_redis_ippool_t *inst = instance;
- rad_assert(tmpl_is_attr(inst->allocated_address_attr));
- rad_assert(subcs);
+ fr_assert(tmpl_is_attr(inst->allocated_address_attr));
+ fr_assert(subcs);
inst->cluster = fr_redis_cluster_alloc(inst, subcs, &inst->conf, true, NULL, NULL, NULL);
if (!inst->cluster) return -1;
RCSID("$Id$")
#include <freeradius-devel/util/base.h>
#include <freeradius-devel/server/cf_parse.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "base.h"
#include "cluster.h"
switch (ipaddr->af) {
default:
case AF_UNSPEC:
- rad_assert(0);
+ fr_assert(0);
return false;
case AF_INET6:
len = strlen(argv[1]);
MEM(arg = talloc_array(conf, uint8_t, len));
len = fr_value_str_unescape(arg, argv[1], len, '"');
- rad_assert(len);
+ fr_assert(len);
MEM(pool_arg = talloc_realloc(conf, arg, uint8_t, len));
}
len = strlen(argv[2]);
MEM(arg = talloc_array(conf, uint8_t, len));
len = fr_value_str_unescape(arg, argv[2], len, '"');
- rad_assert(len);
+ fr_assert(len);
MEM(range_arg = talloc_realloc(conf, arg, uint8_t, len));
}
if (driver_show_lease(&leases, conf->driver, p) < 0) {
exit(EXIT_FAILURE);
}
- rad_assert(leases);
+ fr_assert(leases);
len = talloc_array_length(leases);
INFO("Retrieved information for %zu address(es)/prefix(es)", len - 1);
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/modpriv.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/redis/base.h>
#include <freeradius-devel/redis/cluster.h>
* @copyright 2016 Arran Cudbard-Bell (a.cudbardb@freeradius.org)
*/
#include "rest.h"
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/unlang/base.h>
#include <string.h>
#include <time.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/util/base.h>
#include <freeradius-devel/server/pool.h>
/*
* If len > 0 then we must have these set.
*/
- rad_assert(data->start);
- rad_assert(data->p);
+ fr_assert(data->start);
+ fr_assert(data->p);
to_copy = data->len - (data->p - data->start);
len = to_copy > freespace ? freespace : to_copy;
size_t to_copy;
const char *encoded;
- rad_assert(freespace > 0);
+ fr_assert(freespace > 0);
if (ctx->state == READ_STATE_INIT) {
encoded = fr_json_afrom_pair_list(data, request->packet->vps, NULL);
ctx = radius_list_ctx(current, dst->tmpl_list);
da = dst->tmpl_da;
- rad_assert(vps);
+ fr_assert(vps);
RINDENT();
RDEBUG3("Type : %s", fr_table_str_by_value(fr_value_box_type_table, da->type, "<INVALID>"));
if (xlat_aeval(request, &expanded, request, value, NULL, NULL) < 0) goto skip;
- rad_assert(expanded);
+ fr_assert(expanded);
MEM(vp = fr_pair_afrom_da(ctx, da));
if (!vp) {
*/
q = NULL;
ctx->code = (int)strtoul(p, &q, 10);
- rad_assert(q == (p + 3)); /* We check this above */
+ fr_assert(q == (p + 3)); /* We check this above */
p = q;
/*
{
rlm_rest_curl_context_t *ctx = talloc_get_type_abort(randle->uctx, rlm_rest_curl_context_t);
- rad_assert(ctx->response.buffer || !ctx->response.used);
+ fr_assert(ctx->response.buffer || !ctx->response.used);
*out = ctx->response.buffer;
return ctx->response.used;
}
RDEBUG2("Content-Length will be %zu bytes", len);
- rad_assert((len == 0) || (talloc_array_length(uctx->body) >= (size_t)len));
+ fr_assert((len == 0) || (talloc_array_length(uctx->body) >= (size_t)len));
SET_OPTION(CURLOPT_POSTFIELDS, uctx->body);
SET_OPTION(CURLOPT_POSTFIELDSIZE, len);
char buffer[512];
- rad_assert(candle);
- rad_assert((!username && !password) || (username && password));
+ fr_assert(candle);
+ fr_assert((!username && !password) || (username && password));
buffer[(sizeof(buffer) - 1)] = '\0';
break;
default:
- rad_assert(0);
+ fr_assert(0);
break;
};
break;
default:
- rad_assert(0);
+ fr_assert(0);
};
/*
break;
default:
- rad_assert(0);
+ fr_assert(0);
}
return -1;
default:
- rad_assert(0);
+ fr_assert(0);
}
return ret;
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/pairmove.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/tls/base.h>
#include <freeradius-devel/unlang/base.h>
#include <freeradius-devel/util/table.h>
static int mod_load(void)
{
/* developer sanity */
- rad_assert((NUM_ELEMENTS(http_body_type_supported)) == REST_HTTP_BODY_NUM_ENTRIES);
+ fr_assert((NUM_ELEMENTS(http_body_type_supported)) == REST_HTTP_BODY_NUM_ENTRIES);
if (fr_curl_init() < 0) return -1;
if ((timestamp - session->timestamp) > inst->timer_limit) {
rbnode_t *node;
node = rbtree_find(inst->session_tree, session);
- rad_assert(node != NULL);
+ fr_assert(node != NULL);
rbtree_delete(inst->session_tree, node);
/*
SECURID_SESSION const *one = a;
SECURID_SESSION const *two = b;
- rad_assert(one != NULL);
- rad_assert(two != NULL);
+ fr_assert(one != NULL);
+ fr_assert(two != NULL);
rcode = fr_ipaddr_cmp(&one->src_ipaddr, &two->src_ipaddr);
if (rcode != 0) return rcode;
#pragma once
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "acexport.h"
#define LOG_PREFIX "rlm_sigtran - "
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/protocol/eap/aka-sim/dictionary.h>
#include <freeradius-devel/protocol/eap/aka-sim/dictionary.h>
#include <freeradius-devel/unlang/base.h>
{
int ret;
- rad_assert(ctrl_pipe[0] >= 0);
+ fr_assert(ctrl_pipe[0] >= 0);
pthread_mutex_lock(&ctrl_pipe_mutex);
ret = sigtran_client_do_transaction(ctrl_pipe[0], txn);
static void _sigtran_pipe_error(UNUSED fr_event_list_t *el, int fd, UNUSED int flags, int fd_errno, UNUSED void *uctx)
{
ERROR("worker - ctrl_pipe (%i) read failed : %s", fd, fr_syserror(fd_errno));
- rad_assert(0);
+ fr_assert(0);
}
/** Drain any data we received
txn = talloc_get_type_abort(ptr, sigtran_transaction_t);
if (txn->ctx.defunct) return; /* Request was stopped */
- rad_assert(txn->ctx.request);
+ fr_assert(txn->ctx.request);
unlang_interpret_resumable(txn->ctx.request); /* Continue processing */
}
return -1;
}
- rad_assert((req_pipe[0] >= 0) && (req_pipe[1] >= 0));
+ fr_assert((req_pipe[0] >= 0) && (req_pipe[1] >= 0));
txn = talloc_zero(NULL, sigtran_transaction_t);
txn->request.type = SIGTRAN_REQUEST_THREAD_REGISTER;
{
sigtran_transaction_t *txn = talloc_get_type_abort(rctx, sigtran_transaction_t);
rlm_rcode_t rcode;
- rad_assert(request == txn->ctx.request);
+ fr_assert(request == txn->ctx.request);
/*
* Process response
for (vec = res->vector; vec; vec = vec->next) {
switch (vec->type) {
case SIGTRAN_VECTOR_TYPE_SIM_TRIPLETS:
- rad_assert(vec->sim.rand);
- rad_assert(vec->sim.sres);
- rad_assert(vec->sim.kc);
+ fr_assert(vec->sim.rand);
+ fr_assert(vec->sim.sres);
+ fr_assert(vec->sim.kc);
RDEBUG2("SIM auth vector %i", i);
RINDENT();
break;
case SIGTRAN_VECTOR_TYPE_UMTS_QUINTUPLETS:
- rad_assert(vec->umts.rand);
- rad_assert(vec->umts.xres);
- rad_assert(vec->umts.ck);
- rad_assert(vec->umts.ik);
- rad_assert(vec->umts.authn);
+ fr_assert(vec->umts.rand);
+ fr_assert(vec->umts.xres);
+ fr_assert(vec->umts.ck);
+ fr_assert(vec->umts.ik);
+ fr_assert(vec->umts.authn);
RDEBUG2("UMTS auth vector %i", i);
RINDENT();
break;
default:
- rad_assert(0);
+ fr_assert(0);
/* FALL-THROUGH */
case SIGTRAN_RESPONSE_FAIL:
char *imsi;
size_t len;
- rad_assert((fd != ctrl_pipe[0]) && (fd != ctrl_pipe[1]));
+ fr_assert((fd != ctrl_pipe[0]) && (fd != ctrl_pipe[1]));
txn = talloc_zero(NULL, sigtran_transaction_t);
txn->request.type = SIGTRAN_REQUEST_MAP_SEND_AUTH_INFO;
#include <osmocom/core/talloc.h>
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/io/schedule.h>
#include <unistd.h>
#include <semaphore.h>
#endif
default:
- rad_assert(0);
+ fr_assert(0);
goto fatal_error;
}
{
TALLOC_CTX *ctx = talloc_init("sigtran_event_ctx");
- rad_assert((ctrl_pipe[0] < 0) && (ctrl_pipe[1] < 0)); /* Ensure only one instance exists */
+ fr_assert((ctrl_pipe[0] < 0) && (ctrl_pipe[1] < 0)); /* Ensure only one instance exists */
/*
* Patch in libosmo's logging system to ours
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "sigtran.h"
#include "attrs.h"
#include <osmocom/core/talloc.h>
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <osmocom/core/msgb.h>
#include <osmocom/core/utils.h>
struct mtp_m3ua_client_link *m3ua_client = talloc_get_type_abort(conn->mtp3_link->data,
struct mtp_m3ua_client_link);
- rad_assert(req->imsi);
+ fr_assert(req->imsi);
if (!mtp_m3ua_link_is_up(m3ua_client)) {
ERROR("Link not yet active, dropping the request");
}
if (!rbtree_deletebydata(txn_tree, found)) { /* Remove the outstanding transaction */
ERROR("Failed removing transaction");
- rad_assert(0);
+ fr_assert(0);
}
txn = talloc_get_type_abort(found, sigtran_transaction_t);
#include <osmocom/sccp/sccp.h>
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "sigtran.h"
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
/*
* The instance data for rlm_sometimes is the list of fake values we are
#define LOG_PREFIX "rlm_sql_cassandra - "
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <cassandra.h>
#define LOG_PREFIX "rlm_sql_db2 - "
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <sys/stat.h>
SQLSMALLINT rl;
rlm_sql_db2_conn_t *conn = handle->conn;
- rad_assert(conn);
- rad_assert(outlen > 0);
+ fr_assert(conn);
+ fr_assert(outlen > 0);
errbuff[0] = '\0';
SQLGetDiagRec(SQL_HANDLE_STMT, conn->stmt, 1, (SQLCHAR *) state, &err,
#define LOG_PREFIX "rlm_sql_firebird - "
#include "sql_fbapi.h"
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
/* Forward declarations */
{
rlm_sql_firebird_conn_t *conn = handle->conn;
- rad_assert(conn);
- rad_assert(outlen > 0);
+ fr_assert(conn);
+ fr_assert(outlen > 0);
if (!conn->error) return 0;
#define LOG_PREFIX "rlm_sql_freetds - "
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <sys/stat.h>
{
rlm_sql_freetds_conn_t *conn = handle->conn;
- rad_assert(conn && conn->db);
- rad_assert(outlen > 0);
+ fr_assert(conn && conn->db);
+ fr_assert(outlen > 0);
if (!conn->error) return 0;
#define LOG_PREFIX "rlm_sql_mysql - "
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <sys/stat.h>
char const *error;
size_t i = 0;
- rad_assert(conn && conn->sock);
- rad_assert(outlen > 0);
+ fr_assert(conn && conn->sock);
+ fr_assert(outlen > 0);
error = mysql_error(conn->sock);
break;
default:
- rad_assert(0);
+ fr_assert(0);
}
}
#define LOG_PREFIX "rlm_sql_oracle - "
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <sys/stat.h>
sb4 errcode = 0;
rlm_sql_oracle_conn_t *conn = handle->conn;
- rad_assert(conn);
+ fr_assert(conn);
out[0] = '\0';
char errbuff[512];
int ret;
- rad_assert(outlen > 0);
+ fr_assert(outlen > 0);
ret = sql_snprint_error(errbuff, sizeof(errbuff), handle, config);
if (ret < 0) return 0;
#define LOG_PREFIX "rlm_sql_postgresql - "
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <sys/stat.h>
char const *p, *q;
size_t i = 0;
- rad_assert(outlen > 0);
+ fr_assert(outlen > 0);
p = PQerrorMessage(conn->db);
while ((q = strchr(p, '\n'))) {
#define LOG_PREFIX "rlm_sql_sqlite - "
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <fcntl.h>
#include <sys/stat.h>
rlm_sql_sqlite_conn_t *conn = handle->conn;
char const *error;
- rad_assert(outlen > 0);
+ fr_assert(outlen > 0);
error = sqlite3_errmsg(conn->db);
if (!error) return 0;
#define LOG_PREFIX "rlm_sql_unixodbc - "
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <sqltypes.h>
#include "rlm_sql.h"
SQLINTEGER errnum = 0;
SQLSMALLINT length = 255;
- rad_assert(outlen > 0);
+ fr_assert(outlen > 0);
errbuff[0] = state[0] = '\0';
SQLError(conn->env, conn->dbc, conn->stmt, state, &errnum,
#include <freeradius-devel/server/map_proc.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/server/pairmove.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/table.h>
#include <sys/stat.h>
int field_index[MAX_SQL_FIELD_INDEX];
bool found_field = false; /* Did we find any matching fields in the result set ? */
- rad_assert(inst->driver->sql_fields); /* Should have been caught during validation... */
+ fr_assert(inst->driver->sql_fields); /* Should have been caught during validation... */
if (!*query) {
REDEBUG("Query cannot be (null)");
RERROR("Failed retrieving field names: %s", fr_table_str_by_value(sql_rcode_description_table, ret, "<INVALID>"));
goto error;
}
- rad_assert(fields);
+ fr_assert(fields);
field_cnt = talloc_array_length(fields);
if (RDEBUG_ENABLED3) for (j = 0; j < field_cnt; j++) RDEBUG3("Got field: %s", fields[j]);
char const *sqluser;
ssize_t len;
- rad_assert(request->packet != NULL);
+ fr_assert(request->packet != NULL);
if (username != NULL) {
sqluser = username;
char *expanded = NULL;
int rows;
- rad_assert(request->packet != NULL);
+ fr_assert(request->packet != NULL);
if (!inst->config->groupmemb_query) {
RWARN("Cannot do check groups when group_membership_query is not set");
RDEBUG2("User not found in any groups");
goto do_nothing;
}
- rad_assert(head);
+ fr_assert(head);
RDEBUG2("User found in the group table");
entry = head;
do {
next:
- rad_assert(entry != NULL);
+ fr_assert(entry != NULL);
fr_pair_value_strcpy(sql_group, entry->name);
if (inst->config->authorize_group_check_query) {
continue;
}
- rad_assert(reply_tmp != NULL); /* coverity, among others */
+ fr_assert(reply_tmp != NULL); /* coverity, among others */
*do_fall_through = fall_through(reply_tmp);
RDEBUG2("Group \"%s\": Merging reply items", entry->name);
}
inst->driver = (rlm_sql_driver_t const *)inst->driver_inst->module->common;
- rad_assert(!inst->driver->inst_size || inst->driver_inst->data);
+ fr_assert(!inst->driver->inst_size || inst->driver_inst->data);
/*
* Call the driver's instantiate function (if set)
char *expanded = NULL;
- rad_assert(request->packet != NULL);
- rad_assert(request->reply != NULL);
+ fr_assert(request->packet != NULL);
+ fr_assert(request->reply != NULL);
if (!inst->config->authorize_check_query && !inst->config->authorize_reply_query &&
!inst->config->read_groups && !inst->config->read_profiles) {
char *p = path;
char *expanded = NULL;
- rad_assert(section);
+ fr_assert(section);
if (section->reference[0] != '.') *p++ = '.';
case RLM_SQL_ALT_QUERY:
goto next;
}
- rad_assert(handle);
+ fr_assert(handle);
/*
* We need to have updated something for the query to have been
#define LOG_PREFIX_ARGS inst->name
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <sys/file.h>
#include <sys/stat.h>
ret = (inst->driver->sql_fetch_row)(out, *handle, inst->config);
switch (ret) {
case RLM_SQL_OK:
- rad_assert(*out != NULL);
+ fr_assert(*out != NULL);
return ret;
case RLM_SQL_NO_MORE_ROWS:
- rad_assert(*out == NULL);
+ fr_assert(*out == NULL);
return ret;
default:
int i, count;
/* Caller should check they have a valid handle */
- rad_assert(*handle);
+ fr_assert(*handle);
/* There's no query to run, return an error */
if (query[0] == '\0') {
int i, count;
/* Caller should check they have a valid handle */
- rad_assert(*handle);
+ fr_assert(*handle);
/* There's no query to run, return an error */
if (query[0] == '\0') {
int rows = 0;
sql_rcode_t rcode;
- rad_assert(request);
+ fr_assert(request);
rcode = rlm_sql_select_query(inst, request, handle, query);
if (rcode != RLM_SQL_OK) return -1; /* error handled by rlm_sql_select_query */
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <ctype.h>
if (len == 0) *sCurrentTime = '\0';
tm->tm_sec = tm->tm_min = 0;
- rad_assert(inst->reset != NULL);
+ fr_assert(inst->reset != NULL);
if (isdigit((int) inst->reset[0])){
len = strlen(inst->reset);
if (len == 0) *sCurrentTime = '\0';
tm->tm_sec = tm->tm_min = 0;
- rad_assert(inst->reset != NULL);
+ fr_assert(inst->reset != NULL);
if (isdigit((int) inst->reset[0])){
len = strlen(inst->reset);
rlm_sqlcounter_t *inst = instance;
time_t now;
- rad_assert(inst->query && *inst->query);
+ fr_assert(inst->query && *inst->query);
now = time(NULL);
inst->reset_time = 0;
/*
* Create a new attribute for the counter.
*/
- rad_assert(inst->paircmp_attr);
- rad_assert(inst->limit_attr);
+ fr_assert(inst->paircmp_attr);
+ fr_assert(inst->limit_attr);
memset(&flags, 0, sizeof(flags));
if (tmpl_define_undefined_attr(fr_dict_unconst(dict_freeradius), inst->paircmp_attr, FR_TYPE_UINT64, &flags) < 0) {
#define LOG_PREFIX_ARGS inst->sql_instance_name
#include <rlm_sql.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <ctype.h>
#include <freeradius-devel/server/module.h>
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/util/dlist.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/protocol/radius/freeradius.h>
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
/*
* Define a structure for our module configuration.
static int rlm_test_cmp(UNUSED void *instance, REQUEST *request, UNUSED VALUE_PAIR *thing, VALUE_PAIR *check,
UNUSED VALUE_PAIR *check_pairs, UNUSED VALUE_PAIR **reply_pairs)
{
- rad_assert(check->vp_type == FR_TYPE_STRING);
+ fr_assert(check->vp_type == FR_TYPE_STRING);
RINFO("Test-Paircmp called with \"%pV\"", &check->data);
DEBUG4("unbound event %p - Adding flags %i (current %i, new %i)", ev, flags, ev->events, new);
- rad_assert(!ev->active); /* must not be active */
+ fr_assert(!ev->active); /* must not be active */
ev->events = new;
}
unbound_io_event_t *ev = talloc_get_type_abort(ub_ev, unbound_io_event_t);
short new = ev->events & ~flags;
- rad_assert(!ev->active); /* must not be active */
+ fr_assert(!ev->active); /* must not be active */
DEBUG4("unbound event %p - Removing flags %i (current %i, new %i)", ev, flags, ev->events, new);
{
unbound_io_event_t *ev = talloc_get_type_abort(ub_ev, unbound_io_event_t);
- rad_assert(!ev->active); /* must not be active */
+ fr_assert(!ev->active); /* must not be active */
if (fd == ev->fd) return;
{
unbound_io_event_t *ev = talloc_get_type_abort(uctx, unbound_io_event_t);
- rad_assert(ev->active); /* must be active */
+ fr_assert(ev->active); /* must be active */
DEBUG4("unbound event %p - Timeout", ev);
{
unbound_io_event_t *ev = talloc_get_type_abort(uctx, unbound_io_event_t);
- rad_assert(ev->active); /* must be active */
+ fr_assert(ev->active); /* must be active */
DEBUG4("unbound event %p - FD %i now readable", ev, fd);
{
unbound_io_event_t *ev = talloc_get_type_abort(uctx, unbound_io_event_t);
- rad_assert(ev->active); /* must be active */
+ fr_assert(ev->active); /* must be active */
DEBUG4("unbound event %p - FD %i now writable", ev, fd);
{
unbound_io_event_t *ev = talloc_get_type_abort(uctx, unbound_io_event_t);
- rad_assert(ev->active); /* must be active */
+ fr_assert(ev->active); /* must be active */
DEBUG4("unbound event %p - FD %i errored: %s", ev, fd, fr_syserror(fd_errno));
{
unbound_io_event_t *ev = talloc_get_type_abort(ub_ev, unbound_io_event_t);
- rad_assert(!ev->active); /* must not be active */
+ fr_assert(!ev->active); /* must not be active */
/*
* File descriptor event
*/
if ((ev->events & UB_EV_READ) && (ev->events & UB_EV_WRITE)) {
- rad_assert(ev->fd >= 0); /* File descriptor must valid */
+ fr_assert(ev->fd >= 0); /* File descriptor must valid */
DEBUG4("unbound event %p - Registered for read+write events on FD %i", ev, ev->fd);
return -1;
}
} else if (ev->events & UB_EV_READ) {
- rad_assert(ev->fd >= 0); /* File descriptor must valid */
+ fr_assert(ev->fd >= 0); /* File descriptor must valid */
DEBUG4("unbound event %p - Registered for read+error events on FD %i", ev, ev->fd);
return -1;
}
} else if (ev->events & UB_EV_WRITE) {
- rad_assert(ev->fd >= 0); /* File descriptor must valid */
+ fr_assert(ev->fd >= 0); /* File descriptor must valid */
DEBUG4("unbound event %p - Registered for write+error events on FD %i", ev, ev->fd);
int ret = 0;
fr_time_delta_t timeout;
- rad_assert(ev->events & UB_EV_TIMEOUT);
+ fr_assert(ev->events & UB_EV_TIMEOUT);
if (ev->cb != cb) {
DEBUG4("unbound event %p - New callback %p (old callback was %p)",
{
unbound_io_event_t *ev = talloc_get_type_abort(ub_ev, unbound_io_event_t);
- rad_assert(ev->events & UB_EV_TIMEOUT);
+ fr_assert(ev->events & UB_EV_TIMEOUT);
DEBUG4("unbound event %p - Disarming timeout", ev);
RCSID("$Id$")
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <wbclient.h>
#include <core/ntstatus.h>
/*
* wb_username must be set for this function to be called
*/
- rad_assert(inst->wb_username);
+ fr_assert(inst->wb_username);
/*
* Get the username and domain from the configuration
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include "rlm_winbind.h"
#include "auth_wbclient_pap.h"
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/log.h>
#include <freeradius-devel/util/md5.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/protocol/tacacs/dictionary.h>
#include "tacacs.h"
switch (pkt->hdr.type) {
default:
- rad_assert(0); /* Should have been caught above */
+ fr_assert(0); /* Should have been caught above */
return false;
case TAC_PLUS_AUTHEN:
size_t packet_len;
/* borrow vector to bring in the header for later talloc */
- rad_assert(sizeof(fr_tacacs_packet_hdr_t) <= RADIUS_AUTH_VECTOR_LENGTH);
+ fr_assert(sizeof(fr_tacacs_packet_hdr_t) <= RADIUS_AUTH_VECTOR_LENGTH);
/*
* Only read enough data to get the TACACS+ header.
return 0;
}
- rad_assert(packet->data_len == sizeof(fr_tacacs_packet_hdr_t));
+ fr_assert(packet->data_len == sizeof(fr_tacacs_packet_hdr_t));
/*
* We now have the full packet header. Let's go
return -1;
}
- rad_assert(tacacs_packet_verify(packet, false) == true);
+ fr_assert(tacacs_packet_verify(packet, false) == true);
if (tacacs_xor(packet, secret, secret_len) < 0) {
fr_strerror_printf("Failed encryption of TACACS reply: %s", fr_syserror(errno));
#include <freeradius-devel/util/net.h>
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/log.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/protocol/tacacs/dictionary.h>
#include "tacacs.h"
#include <freeradius-devel/util/net.h>
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/log.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/protocol/tacacs/dictionary.h>
#include "tacacs.h"
goto fail;
cook:
- rad_assert(length_hdr + length_body < TACACS_MAX_PACKET_SIZE);
+ fr_assert(length_hdr + length_body < TACACS_MAX_PACKET_SIZE);
pkt->hdr.length = htonl(length_hdr - sizeof(fr_tacacs_packet_hdr_t) + length_body);
if (field.data) {
switch (pkt->hdr.type) {
default:
- rad_assert(0);
+ fr_assert(0);
break;
case TAC_PLUS_AUTHEN:
#include <stdint.h>
#include <string.h>
#include <sys/time.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#ifdef HAVE_GETOPT_H
# include <getopt.h>
#include <freeradius-devel/io/channel.h>
#include <freeradius-devel/io/control.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/syserror.h>
#ifdef HAVE_GETOPT_H
for (i = 0; i < num_to_send; i++) {
cd = (fr_channel_data_t *) fr_message_alloc(ms, NULL, 100);
- rad_assert(cd != NULL);
+ fr_assert(cd != NULL);
num_outstanding++;
num_messages++;
if (rcode < 0) {
fprintf(stderr, "Failed sending request: %s\n", fr_syserror(errno));
}
- rad_assert(rcode == 0);
+ fr_assert(rcode == 0);
if (reply) {
num_replies++;
num_outstanding--;
}
MPRINT1("Master waiting on events.\n");
- rad_assert(num_messages <= max_messages);
+ fr_assert(num_messages <= max_messages);
num_events = kevent(kq_master, NULL, 0, events, MAX_KEVENTS, NULL);
MPRINT1("Master kevent returned %d\n", num_events);
data_size = fr_control_message_pop(aq_master, &id, data, sizeof(data));
if (!data_size) break;
- rad_assert(id == FR_CONTROL_ID_CHANNEL);
+ fr_assert(id == FR_CONTROL_ID_CHANNEL);
ce = fr_channel_service_message(now, &new_channel, data, data_size);
MPRINT1("Master got channel event %d\n", ce);
switch (ce) {
case FR_CHANNEL_DATA_READY_REQUESTOR:
MPRINT1("Master got data ready signal\n");
- rad_assert(new_channel == channel);
+ fr_assert(new_channel == channel);
reply = fr_channel_recv_reply(channel);
if (!reply) {
case FR_CHANNEL_CLOSE:
MPRINT1("Master received close signal\n");
- rad_assert(new_channel == channel);
- rad_assert(signaled_close == true);
+ fr_assert(new_channel == channel);
+ fr_assert(signaled_close == true);
running = false;
break;
/*
* Not written yet!
*/
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
break;
} /* switch over signal returned */
} /* drain the control plane */
*/
rcode = fr_message_set_messages_used(ms);
MPRINT2("Master messages used = %d\n", rcode);
- rad_assert(rcode == 0);
+ fr_assert(rcode == 0);
talloc_free(ctx);
data_size = fr_control_message_pop(aq_worker, &id, data, sizeof(data));
if (!data_size) break;
- rad_assert(id == FR_CONTROL_ID_CHANNEL);
+ fr_assert(id == FR_CONTROL_ID_CHANNEL);
ce = fr_channel_service_message(now, &new_channel, data, data_size);
MPRINT1("\tWorker got channel event %d\n", ce);
case FR_CHANNEL_OPEN:
MPRINT1("\tWorker received a new channel\n");
- rad_assert(new_channel == channel);
+ fr_assert(new_channel == channel);
break;
case FR_CHANNEL_CLOSE:
MPRINT1("\tWorker requested to close the channel.\n");
- rad_assert(new_channel == channel);
+ fr_assert(new_channel == channel);
running = false;
/*
case FR_CHANNEL_DATA_READY_RESPONDER:
MPRINT1("\tWorker got data ready signal\n");
- rad_assert(new_channel == channel);
+ fr_assert(new_channel == channel);
cd = fr_channel_recv_request(channel);
if (!cd) {
worker_messages++;
- rad_assert(cd->m.data != NULL);
+ fr_assert(cd->m.data != NULL);
memcpy(&message_id, cd->m.data, sizeof(message_id));
MPRINT1("\tWorker got message %d (says %d)\n", worker_messages, message_id);
reply = (fr_channel_data_t *) fr_message_alloc(ms, NULL, 100);
- rad_assert(reply != NULL);
+ fr_assert(reply != NULL);
reply->m.when = fr_time();
fr_message_done(&cd->m);
if (rcode < 0) {
fprintf(stderr, "Failed sending reply: %s\n", fr_syserror(errno));
}
- rad_assert(rcode == 0);
+ fr_assert(rcode == 0);
}
break;
case FR_CHANNEL_NOOP:
MPRINT1("\tWorker got NOOP\n");
- rad_assert(new_channel == channel);
+ fr_assert(new_channel == channel);
break;
default:
/*
* Not written yet!
*/
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
break;
} /* switch over signals */
#endif
kq_master = kqueue();
- rad_assert(kq_master >= 0);
+ fr_assert(kq_master >= 0);
kq_worker = kqueue();
- rad_assert(kq_worker >= 0);
+ fr_assert(kq_worker >= 0);
aq_master = fr_atomic_queue_create(autofree, max_control_plane);
- rad_assert(aq_master != NULL);
+ fr_assert(aq_master != NULL);
aq_worker = fr_atomic_queue_create(autofree, max_control_plane);
- rad_assert(aq_worker != NULL);
+ fr_assert(aq_worker != NULL);
control_master = fr_control_create(autofree, kq_master, aq_master, 1024);
- rad_assert(control_master != NULL);
+ fr_assert(control_master != NULL);
control_worker = fr_control_create(autofree, kq_worker, aq_worker, 1025);
- rad_assert(control_worker != NULL);
+ fr_assert(control_worker != NULL);
channel = fr_channel_create(autofree, control_master, control_worker, false);
if (!channel) {
#include <freeradius-devel/io/control.h>
#include <freeradius-devel/util/time.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/syserror.h>
#include <sys/event.h>
exit(EXIT_FAILURE);
}
- rad_assert(data_size == sizeof(m));
- rad_assert(id == FR_CONTROL_ID_CHANNEL);
+ fr_assert(data_size == sizeof(m));
+ fr_assert(id == FR_CONTROL_ID_CHANNEL);
MPRINT1("Master got message %zu.\n", m.counter);
- rad_assert(m.header == CONTROL_MAGIC);
+ fr_assert(m.header == CONTROL_MAGIC);
if (m.counter == (max_messages - 1)) goto do_exit;
}
#endif
kq = kqueue();
- rad_assert(kq >= 0);
+ fr_assert(kq >= 0);
aq = fr_atomic_queue_create(autofree, aq_size);
- rad_assert(aq != NULL);
+ fr_assert(aq != NULL);
control = fr_control_create(autofree, kq, aq, 1024);
if (!control) {
RCSID("$Id$")
#include <freeradius-devel/io/message.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/hash.h>
#include <freeradius-devel/util/syserror.h>
* We can't allocated the entire array, and we can't
* over-fill the array.
*/
- rad_assert((size_t) my_alloc_size < MY_ARRAY_SIZE);
+ fr_assert((size_t) my_alloc_size < MY_ARRAY_SIZE);
MPRINT2("BLOCK ALLOC %d\n", my_alloc_size);
array[index] = hash;
m = fr_message_reserve(ms, reserve_size);
- rad_assert(m != NULL);
+ fr_assert(m != NULL);
messages[index] = (fr_test_t *) fr_message_alloc(ms, m, hash);
- rad_assert(messages[index] == (void *) m);
+ fr_assert(messages[index] == (void *) m);
if (touch_memory) {
size_t j;
if (debug_lvl > 1) printf("%08x\t", hash);
- rad_assert(m->status == FR_MESSAGE_USED);
+ fr_assert(m->status == FR_MESSAGE_USED);
used += hash;
-// rad_assert(fr_ring_buffer_used(rb) == used);
+// fr_assert(fr_ring_buffer_used(rb) == used);
}
*end += my_alloc_size;
{
int i;
- rad_assert(my_alloc_size < MY_ARRAY_SIZE);
+ fr_assert(my_alloc_size < MY_ARRAY_SIZE);
MPRINT2("BLOCK FREE %d\n", my_alloc_size);
m = &messages[index]->m;
- rad_assert(m->status == FR_MESSAGE_USED);
+ fr_assert(m->status == FR_MESSAGE_USED);
rcode = fr_message_done(m);
#ifndef NDEBUG
- rad_assert(rcode == 0);
+ fr_assert(rcode == 0);
#else
if (rcode != 0) exit(EXIT_FAILURE);
#endif
if (*start > MY_ARRAY_SIZE) {
*start -= MY_ARRAY_SIZE;
*end -= MY_ARRAY_SIZE;
- rad_assert(*start <= *end);
- rad_assert(*start < MY_ARRAY_SIZE);
+ fr_assert(*start <= *end);
+ fr_assert(*start < MY_ARRAY_SIZE);
}
}
my_alloc_size = end - start;
free_blocks(ms, &seed, &start, &end);
- rad_assert(used == 0);
+ fr_assert(used == 0);
for (i = 0; i < MY_ARRAY_SIZE; i++) {
- rad_assert(messages[i] == NULL);
+ fr_assert(messages[i] == NULL);
}
if (debug_lvl) {
* After the garbage collection, all messages marked "done" MUST also be marked "free".
*/
rcode = fr_message_set_messages_used(ms);
- rad_assert(rcode == 0);
+ fr_assert(rcode == 0);
return rcode;
}
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/io/worker.h>
#include <freeradius-devel/radius/defs.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/base.h>
#include <freeradius-devel/util/inet.h>
#include <freeradius-devel/util/log.h>
* Create the KQ and associated sockets.
*/
kq_master = kqueue();
- rad_assert(kq_master >= 0);
+ fr_assert(kq_master >= 0);
aq_master = fr_atomic_queue_create(ctx, max_control_plane);
- rad_assert(aq_master != NULL);
+ fr_assert(aq_master != NULL);
control_master = fr_control_create(ctx, kq_master, aq_master, 1024);
- rad_assert(control_master != NULL);
+ fr_assert(control_master != NULL);
sockfd = fr_socket_server_udp(&my_ipaddr, &my_port, NULL, true);
if (sockfd < 0) {
*/
MPRINT1("Master creating channel to worker %d.\n", num_workers);
workers[i].ch = fr_worker_channel_create(workers[i].worker, ctx, control_master);
- rad_assert(workers[i].ch != NULL);
+ fr_assert(workers[i].ch != NULL);
(void) fr_channel_master_ctx_add(workers[i].ch, &workers[i]);
break;
}
- rad_assert(events[i].filter == EVFILT_READ);
+ fr_assert(events[i].filter == EVFILT_READ);
cd = (fr_channel_data_t *) fr_message_reserve(ms, 4096);
- rad_assert(cd != NULL);
+ fr_assert(cd != NULL);
packet_ctx = talloc(ctx, fr_radius_packet_ctx_t);
- rad_assert(packet_ctx != NULL);
+ fr_assert(packet_ctx != NULL);
packet_ctx->salen = sizeof(packet_ctx->src);
cd->priority = 0;
which_worker++;
if (which_worker >= num_workers) which_worker = 0;
- rad_assert(rcode == 0);
+ fr_assert(rcode == 0);
if (reply) send_reply(sockfd, reply);
}
data_size = fr_control_message_pop(aq_master, &id, data, sizeof(data));
if (!data_size) break;
- rad_assert(id == FR_CONTROL_ID_CHANNEL);
+ fr_assert(id == FR_CONTROL_ID_CHANNEL);
ce = fr_channel_service_message(now, &ch, data, data_size);
MPRINT1("Master got channel event %d\n", ce);
case FR_CHANNEL_CLOSE:
sw = fr_channel_master_ctx_get(ch);
- rad_assert(sw != NULL);
+ fr_assert(sw != NULL);
MPRINT1("Master received close ack signal for worker %d\n", sw->id);
/*
* Not written yet!
*/
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
break;
} /* switch over signal returned */
} /* drain the control plane */
*/
rcode = fr_message_set_messages_used(ms);
MPRINT2("Master messages used = %d\n", rcode);
- rad_assert(rcode == 0);
+ fr_assert(rcode == 0);
close(sockfd);
}
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/io/schedule.h>
#include <freeradius-devel/radius/defs.h>
-#include <freeradius-devel/server/rad_assert.h>
-#include <freeradius-devel/util/base.h>
#include <freeradius-devel/util/debug.h>
+#include <freeradius-devel/util/base.h>
#include <freeradius-devel/util/inet.h>
#include <freeradius-devel/util/md5.h>
#include <freeradius-devel/util/syserror.h>
RCSID("$Id$")
#include <freeradius-devel/io/ring_buffer.h>
-#include <freeradius-devel/server/rad_assert.h>
#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/hash.h>
#include <freeradius-devel/util/syserror.h>
if (debug_lvl > 1) printf("%08x\t", hash);
used += hash;
- rad_assert(fr_ring_buffer_used(rb) == used);
+ fr_assert(fr_ring_buffer_used(rb) == used);
}
*end += ALLOC_SIZE;
if (!fr_cond_assert(rcode == 0)) exit(EXIT_FAILURE);
used -= array[index];
- rad_assert(fr_ring_buffer_used(rb) == used);
+ fr_assert(fr_ring_buffer_used(rb) == used);
array[index] = 0;
data[index] = NULL;
free_blocks(rb, &seed, &start, &end);
- rad_assert(used == 0);
- rad_assert(fr_ring_buffer_used(rb) == used);
+ fr_assert(used == 0);
+ fr_assert(fr_ring_buffer_used(rb) == used);
exit(EXIT_SUCCESS);
}
#include <freeradius-devel/io/schedule.h>
#include <freeradius-devel/util/time.h>
#include <freeradius-devel/radius/defs.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/inet.h>
#include <freeradius-devel/util/md5.h>
#include <freeradius-devel/util/syserror.h>
#include <freeradius-devel/io/control.h>
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/io/worker.h>
-#include <freeradius-devel/server/rad_assert.h>
+#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/syserror.h>
#ifdef HAVE_GETOPT_H
*/
MPRINT1("Master creating channel to worker %d.\n", num_workers);
workers[i].ch = fr_worker_channel_create(workers[i].worker, ctx, control_master);
- rad_assert(workers[i].ch != NULL);
+ fr_assert(workers[i].ch != NULL);
(void) fr_channel_master_ctx_add(workers[i].ch, &workers[i]);
for (i = 0; i < num_to_send; i++) {
cd = (fr_channel_data_t *) fr_message_alloc(ms, NULL, 100);
- rad_assert(cd != NULL);
+ fr_assert(cd != NULL);
num_outstanding++;
num_messages++;
which_worker++;
if (which_worker >= num_workers) which_worker = 0;
- rad_assert(rcode == 0);
+ fr_assert(rcode == 0);
if (reply) {
num_replies++;
num_outstanding--;
}
MPRINT1("Master waiting on events.\n");
- rad_assert(num_messages <= max_messages);
+ fr_assert(num_messages <= max_messages);
num_events = kevent(kq_master, NULL, 0, events, MAX_KEVENTS, NULL);
MPRINT1("Master kevent returned %d\n", num_events);
data_size = fr_control_message_pop(aq_master, &id, data, sizeof(data));
if (!data_size) break;
- rad_assert(id == FR_CONTROL_ID_CHANNEL);
+ fr_assert(id == FR_CONTROL_ID_CHANNEL);
ce = fr_channel_service_message(now, &ch, data, data_size);
MPRINT1("Master got channel event %d\n", ce);
case FR_CHANNEL_CLOSE:
sw = fr_channel_master_ctx_get(ch);
- rad_assert(sw != NULL);
+ fr_assert(sw != NULL);
MPRINT1("Master received close signal for worker %d\n", sw->id);
- rad_assert(signaled_close == true);
+ fr_assert(signaled_close == true);
(void) pthread_kill(sw->pthread_id, SIGTERM);
running = false;
/*
* Not written yet!
*/
- rad_assert(0 == 1);
+ fr_assert(0 == 1);
break;
} /* switch over signal returned */
} /* drain the control plane */
*/
rcode = fr_message_set_messages_used(ms);
MPRINT2("Master messages used = %d\n", rcode);
- rad_assert(rcode == 0);
+ fr_assert(rcode == 0);
talloc_free(ctx);
#endif
kq_master = kqueue();
- rad_assert(kq_master >= 0);
+ fr_assert(kq_master >= 0);
aq_master = fr_atomic_queue_create(autofree, max_control_plane);
- rad_assert(aq_master != NULL);
+ fr_assert(aq_master != NULL);
control_master = fr_control_create(autofree, kq_master, aq_master, 1024);
- rad_assert(control_master != NULL);
+ fr_assert(control_master != NULL);
signal(SIGTERM, sig_ignore);
projects / thirdparty / freeradius-server.git / commitdiff
