}
if (info->argc >= 2) {
- memcpy(&filename, &info->argv[1], sizeof(filename)); /* const issues */
+ filename = UNCONST(char *, info->argv[1]);
} else {
filename = getenv("FR_PROFILE_FILENAME");
}
#define STRINGIFY(x) XSTRINGIFY(x)
#define JOINSTR(x,y) XSTRINGIFY(x ## y)
-/*
- * Helpers for initialising arrays
- * of string literals.
+/** Helper for initialising arrays of string literals.
*/
#define L(_str) { _str, sizeof(_str) - 1 }
+/** Comparison macro for integers
+ *
+ */
+#define CMP(_a, _b) (((_a) > (_b)) - ((_a) < (_b)))
+
+/** Remove const qualification from a pointer
+ *
+ * @param[in] _type The non-const version of the type.
+ * @param[in] _ptr to de-const.
+ */
+#define UNCONST(_type, _ptr) ((_type)((uintptr_t)(_ptr)))
+
/*
* HEX concatenation macros
*/
# define DIAG_PUSH() DIAG_PRAGMA(push)
# define DIAG_POP() DIAG_PRAGMA(pop)
#else
+# define DIAG_UNKNOWN_PRAGMAS
# define DIAG_OFF(_x)
# define DIAG_ON(_x)
# define DIAG_PUSH()
cf_data_walk_ctx_t *cd_ctx = uctx;
CONF_DATA *cd = data;
CONF_ITEM *ci = data;
- void *mutable;
int ret;
/*
if ((cd->type != cd_ctx->type) && (strcmp(cd->type, cd_ctx->type) != 0)) return 0;
- memcpy(&mutable, &cd->data, sizeof(data));
- ret = cd_ctx->cb(mutable, cd_ctx->ctx);
+ ret = cd_ctx->cb(UNCONST(void *, cd->data), cd_ctx->ctx);
return ret;
}
*/
dl_module_inst_t const *dl_module_instance_by_data(void const *data)
{
- void *mutable;
-
DL_INIT_CHECK;
- memcpy(&mutable, &data, sizeof(mutable));
-
if (dl_inst_cache.data == data) return dl_inst_cache.inst;
- return rbtree_finddata(dl_module_loader->inst_data_tree, &(dl_module_inst_t){ .data = mutable });
+ return rbtree_finddata(dl_module_loader->inst_data_tree, &(dl_module_inst_t){ .data = UNCONST(void *, data) });
}
/** Lookup instance name via instance data
module_instance_t *module_by_data(void const *data)
{
module_instance_t *mi;
- void *mutable;
-
- memcpy(&mutable, &data, sizeof(mutable));
mi = rbtree_finddata(module_instance_data_tree,
&(module_instance_t){
- .dl_inst = &(dl_module_inst_t){ .data = mutable },
+ .dl_inst = &(dl_module_inst_t){ .data = UNCONST(void *, data) },
});
if (!mi) return NULL;
DEBUG2("Initialising connection pool");
- {
- CONF_SECTION *mutable;
-
- memcpy(&mutable, &cs, sizeof(mutable));
-
- if (cf_section_rules_push(mutable, pool_config) < 0) goto error;
- if (cf_section_parse(pool, pool, mutable) < 0) {
- PERROR("Configuration parsing failed");
- goto error;
- }
+ if (cf_section_rules_push(UNCONST(CONF_SECTION *, cs), pool_config) < 0) goto error;
+ if (cf_section_parse(pool, pool, UNCONST(CONF_SECTION *, cs)) < 0) {
+ PERROR("Configuration parsing failed");
+ goto error;
}
/*
if (str && escape) {
size_t len;
char *escaped;
- void *mutable;
len = talloc_array_length(str) * 3;
escaped = talloc_array(ctx, char, len);
-
- memcpy(&mutable, &escape_ctx, sizeof(mutable));
- escape(request, escaped, len, str, mutable);
+ escape(request, escaped, len, str, UNCONST(void *, escape_ctx));
talloc_free(str);
str = escaped;
}
if (dict_protocol_add(dict) < 0) goto error;
- memcpy(&mutable, &dict->root, sizeof(mutable));
-
+ mutable = UNCONST(fr_dict_attr_t *, dict->root);
if (!type_size) {
mutable->flags.type_size = dict->default_type_size;
mutable->flags.length = dict->default_type_length;
return -1;
}
- memcpy(&mutable, &dv, sizeof(mutable));
-
+ mutable = UNCONST(fr_dict_vendor_t *, dv);
mutable->type = type;
mutable->length = length;
mutable->flags = continuation;
* with the structure size/
*/
if (ctx->stack[ctx->stack_depth].struct_size <= 255) {
- fr_dict_attr_t *mutable;
-
- memcpy(&mutable, &da, sizeof(mutable));
- mutable->flags.length = ctx->stack[ctx->stack_depth].struct_size;
+ UNCONST(fr_dict_attr_t *, da)->flags.length = ctx->stack[ctx->stack_depth].struct_size;
} /* else length 0 means "unknown / variable size / too large */
} else {
fr_assert(da->type == FR_TYPE_TLV);
fr_dict_attr_t const *vsa_da;
fr_dict_attr_t const *vendor_da;
fr_dict_attr_t *new;
- fr_dict_attr_t *mutable;
if (argc < 2) {
fr_strerror_const_push("Invalid BEGIN-VENDOR entry");
vsa_da, argv[1], vendor->pen, FR_TYPE_VENDOR, &flags);
if (unlikely(!new)) goto error;
- memcpy(&mutable, &vsa_da, sizeof(mutable));
- if (dict_attr_child_add(mutable, new) < 0) {
+ if (dict_attr_child_add(UNCONST(fr_dict_attr_t *, vsa_da), new) < 0) {
talloc_free(new);
goto error;
}
- if (dict_attr_add_to_namespace(ctx->dict, mutable, new) < 0) {
+ if (dict_attr_add_to_namespace(ctx->dict, UNCONST(fr_dict_attr_t *, vsa_da), new) < 0) {
talloc_free(new);
goto error;
}
* container.
*/
if (unknown->type == FR_TYPE_VENDOR) {
- fr_dict_attr_t *mutable, *n;
+ fr_dict_attr_t *n;
if (dict_vendor_add(dict, unknown->name, unknown->attr) < 0) return NULL;
/*
* Setup parenting for the attribute
*/
- memcpy(&mutable, &unknown->parent, sizeof(mutable));
- if (dict_attr_child_add(mutable, n) < 0) return NULL;
+ if (dict_attr_child_add(UNCONST(fr_dict_attr_t *, unknown->parent), n) < 0) return NULL;
return n;
}
{
fr_dict_attr_t *n;
fr_dict_attr_t const *old;
- fr_dict_attr_t *mutable;
fr_dict_attr_flags_t our_flags = *flags;
if (unlikely(dict->read_only)) {
return -1;
}
- /*
- * Setup parenting for the attribute
- */
- memcpy(&mutable, &parent, sizeof(mutable));
-
/*
* Add in by number
*/
- if (dict_attr_child_add(mutable, n) < 0) goto error;
+ if (dict_attr_child_add(UNCONST(fr_dict_attr_t *, parent), n) < 0) goto error;
/*
* If it's a group attribute, the default
/*
* Mark the attribute up as having an enumv
*/
- {
- fr_dict_attr_t *mutable;
-
- memcpy(&mutable, &da, sizeof(mutable));
-
- mutable->flags.has_value = 1;
- }
+ UNCONST(fr_dict_attr_t *, da)->flags.has_value = 1;
return 0;
}
*/
fr_dict_t *fr_dict_unconst(fr_dict_t const *dict)
{
- fr_dict_t *mutable;
-
if (unlikely(dict->read_only)) {
fr_strerror_printf("%s dictionary has been marked as read only", fr_dict_root(dict)->name);
return NULL;
}
-
- memcpy(&mutable, &dict, sizeof(dict));
- return mutable;
+ return UNCONST(fr_dict_t *, dict);
}
/** Coerce to non-const
*/
fr_dict_attr_t *fr_dict_attr_unconst(fr_dict_attr_t const *da)
{
- fr_dict_attr_t *mutable;
fr_dict_t *dict;
dict = dict_by_da(da);
return NULL;
}
- memcpy(&mutable, &da, sizeof(da));
- return mutable;
+ return UNCONST(fr_dict_attr_t *, da);
}
fr_dict_t const *fr_dict_internal(void)
bool rbtree_insert(rbtree_t *tree, void const *data)
{
- void *mutable;
-
- if (unlikely(tree->being_freed)) return NULL;
-
- memcpy(&mutable, &data, sizeof(mutable));
-
- if (rbtree_insert_node(tree, mutable)) return true;
+ if (rbtree_insert_node(tree, UNCONST(void *, data))) return true;
return false;
}
static int fr_trie_user_cb(fr_trie_t *trie, fr_trie_callback_t *cb, int keylen, UNUSED bool more)
{
fr_trie_user_t *user;
- void *data;
if (!trie || (trie->type != FR_TRIE_USER)) return 0;
user = (fr_trie_user_t *) trie;
- memcpy(&data, &user->data, sizeof(data)); /* const issues */
/*
* Call the user function with the key, key length, and data.
*/
- if (cb->user_callback(cb->ctx, cb->start, keylen, data) < 0) {
+ if (cb->user_callback(cb->ctx, cb->start, keylen, UNCONST(void *, user->data)) < 0) {
return -1;
}
int fr_trie_walk(fr_trie_t *ft, void *ctx, fr_trie_walk_t callback)
{
- fr_trie_callback_t my_cb;
uint8_t buffer[MAX_KEY_BYTES + 1];
-
- my_cb.start = buffer;
- my_cb.end = buffer + sizeof(buffer);
- my_cb.callback = fr_trie_user_cb;
- my_cb.user_callback = callback;
- my_cb.ctx = ctx;
+ fr_trie_callback_t my_cb = {
+ .start = buffer,
+ .end = buffer + sizeof(buffer),
+ .callback = fr_trie_user_cb,
+ .user_callback = callback,
+ .ctx = ctx
+ };
memset(buffer, 0, sizeof(buffer));
{
size_t len;
char *str;
- char *mutable;
if (!fr_cond_assert(vb->type == FR_TYPE_STRING)) return -1;
len = strlen(vb->vb_strvalue);
-
- memcpy(&mutable, &vb->vb_strvalue, sizeof(mutable));
- str = talloc_realloc(ctx, mutable, char, len + 1);
+ str = talloc_realloc(ctx, UNCONST(char *, &vb->vb_strvalue), char, len + 1);
if (!str) {
fr_strerror_const("Failed re-allocing string buffer");
return -1;
*/
int fr_value_box_mem_append(TALLOC_CTX *ctx, fr_value_box_t *dst, uint8_t const *src, size_t len, bool tainted)
{
- uint8_t *ptr, *nptr;
+ uint8_t *nptr;
size_t nlen;
if (len == 0) return 0;
return -1;
}
- memcpy(&ptr, &dst->datum.ptr, sizeof(ptr)); /* defeat const */
- if (!fr_cond_assert(ptr)) return -1;
+ if (!fr_cond_assert(dst->datum.ptr)) return -1;
- if (talloc_reference_count(ptr) > 0) {
+ if (talloc_reference_count(dst->datum.ptr) > 0) {
fr_strerror_printf("%s: Boxed value has too many references", __FUNCTION__);
return -1;
}
nlen = dst->vb_length + len;
- nptr = talloc_realloc(ctx, ptr, uint8_t, dst->vb_length + len);
+ nptr = talloc_realloc(ctx, dst->datum.ptr, uint8_t, dst->vb_length + len);
if (!nptr) {
fr_strerror_printf("%s: Realloc of %s array from %zu to %zu bytes failed",
- __FUNCTION__, talloc_get_name(ptr), talloc_array_length(ptr), nlen);
+ __FUNCTION__,
+ talloc_get_name(dst->datum.ptr), talloc_array_length(dst->datum.ptr), nlen);
return -1;
}
- ptr = nptr;
- memcpy(ptr + dst->vb_length, src, len); /* Copy data into the realloced buffer */
+ memcpy(nptr + dst->vb_length, src, len); /* Copy data into the realloced buffer */
dst->tainted = dst->tainted || tainted;
- dst->datum.ptr = ptr;
+ dst->datum.ptr = nptr;
dst->vb_length += len;
return 0;
* @param[in] now current time.
* @param[in] user_ctx Sync config.
*/
-static void proto_ldap_sync_reinit(fr_event_list_t *el, fr_time_t now, void *user_ctx)
+static void proto_ldap_sync_reinit(fr_event_list_t *el, fr_time_t now, void const *user_ctx)
{
- sync_config_t *config = talloc_get_type_abort(user_ctx, sync_config_t);
+ sync_config_t const *config = talloc_get_type_abort_const(user_ctx, sync_config_t);
proto_ldap_inst_t *inst = talloc_get_type_abort(config->user_ctx, proto_ldap_inst_t);
/*
{
rad_listen_t *listen = talloc_get_type_abort(user_ctx, rad_listen_t);
proto_ldap_inst_t *inst = talloc_get_type_abort(listen->data, proto_ldap_inst_t);;
- void *ctx;
sync_state_destroy(conn, sync_id); /* Destroy the old state */
DEBUG2("Refresh required");
- memcpy(&ctx, &config, sizeof(ctx));
- proto_ldap_sync_reinit(inst->el, fr_time(), ctx);
+ proto_ldap_sync_reinit(inst->el, fr_time(), user_ctx);
return 0;
}
/*
* Schedule sync reinit, but don't perform it immediately.
*/
- memcpy(&ctx, &config, sizeof(ctx));
if (fr_event_timer_in(inst, inst->el, &inst->sync_retry_ev,
inst->sync_retry_interval,
- proto_ldap_sync_reinit, ctx) < 0) {
+ proto_ldap_sync_reinit, config) < 0) {
FATAL("Failed inserting event: %s", fr_strerror());
}
return 1;
/*
* Schedule conn reinit, but don't perform it immediately
*/
- memcpy(&ctx, &config, sizeof(ctx));
if (fr_event_timer_in(inst, inst->el, &inst->conn_retry_ev,
inst->conn_retry_interval,
proto_ldap_connection_init, listen) < 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));
+ inst->handle_config.server = UNCONST(char *, inst->handle_config.server_str);
/*
* Convert scope strings to enumerated constants
cache_status_t status;
rlm_cache_rbtree_t *driver = talloc_get_type_abort(instance, rlm_cache_rbtree_t);
- rlm_cache_entry_t *my_c;
fr_assert(handle == request);
if (!request) return CACHE_ERROR;
- memcpy(&my_c, &c, sizeof(my_c));
-
/*
* Allow overwriting
*/
- if (!rbtree_insert(driver->cache, my_c)) {
+ if (!rbtree_insert(driver->cache, c)) {
status = cache_entry_expire(config, instance, request, handle, c->key, c->key_len);
if ((status != CACHE_OK) && !fr_cond_assert(0)) return CACHE_ERROR;
- if (!rbtree_insert(driver->cache, my_c)) {
+ if (!rbtree_insert(driver->cache, c)) {
RERROR("Failed adding entry");
return CACHE_ERROR;
}
}
- if (fr_heap_insert(driver->heap, my_c) < 0) {
- rbtree_deletebydata(driver->cache, my_c);
+ if (fr_heap_insert(driver->heap, UNCONST(rlm_cache_entry_t *, c)) < 0) {
+ rbtree_deletebydata(driver->cache, c);
RERROR("Failed adding entry to expiry heap");
return CACHE_ERROR;
char const *filename;
cipher_rsa_t *rsa_inst = talloc_get_type_abort(ctx, cipher_rsa_t); /* Yeah this is a bit hacky */
EVP_PKEY *pkey;
- void *pass;
int pkey_type;
filename = cf_pair_value(cf_item_to_pair(ci));
return -1;
}
- memcpy(&pass, &rsa_inst->private_key_password, sizeof(pass));
-
- pkey = PEM_read_PrivateKey(fp, (EVP_PKEY **)out, _get_private_key_password, pass);
+ pkey = PEM_read_PrivateKey(fp, (EVP_PKEY **)out, _get_private_key_password,
+ UNCONST(void *, rsa_inst->private_key_password));
fclose(fp);
if (!pkey) {
return -1;
}
- for (map = maps;
- map != NULL;
- map = map->next) {
- map_t *unconst_map;
-
- memcpy(&unconst_map, &map, sizeof(map));
-
+ for (map = maps; map != NULL; map = map->next) {
/*
* This function doesn't change the map, so it's OK.
*/
- if (csv_map_verify(unconst_map, mod_inst) < 0) return -1;
+ if (csv_map_verify(UNCONST(map_t *, map), mod_inst) < 0) return -1;
}
return 0;
goto finish;
}
} else {
- memcpy(&field_name, &map->rhs->name, sizeof(field_name)); /* const */
+ field_name = UNCONST(char *, map->rhs->name);
}
field = fieldname2offset(inst, field_name, NULL);
# ifdef HAVE_KRB5_FREE_ERROR_MESSAGE
krb5_free_error_message(context, msg);
# elif defined(HAVE_KRB5_FREE_ERROR_STRING)
- {
- char *free;
-
- memcpy(&free, &msg, sizeof(free));
- krb5_free_error_string(context, free);
- }
+ krb5_free_error_string(context, UNCONST(char *, msg));
# else
# error "No way to free error strings, missing krb5_free_error_message() and krb5_free_error_string()"
# endif
krb5_principal client = NULL; /* actually a pointer value */
krb5_creds init_creds;
- char *nonconst_password; /* compiler warnings */
fr_pair_t *password;
password = fr_pair_find_by_da(&request->request_pairs, attr_user_password);
/*
* Retrieve the TGT from the TGS/KDC and check we can decrypt it.
*/
- memcpy(&nonconst_password, &password->vp_strvalue, sizeof(nonconst_password));
RDEBUG2("Retrieving and decrypting TGT");
- ret = krb5_get_init_creds_password(conn->context, &init_creds, client, nonconst_password,
+ ret = krb5_get_init_creds_password(conn->context, &init_creds, client, UNCONST(char *, password->vp_strvalue),
NULL, NULL, 0, NULL, inst->gic_options);
if (ret) {
rcode = krb5_process_error(inst, request, conn, ret);
int ldap_errno;
char const *url;
- char const **attrs;
LDAPControl *server_ctrls[] = { NULL, NULL };
conn = mod_conn_get(inst, request);
if (!conn) goto free_urldesc;
- memcpy(&attrs, &ldap_url->lud_attrs, sizeof(attrs));
-
if (fr_ldap_parse_url_extensions(&server_ctrls[0], request, conn, ldap_url->lud_exts) < 0) goto free_socket;
status = fr_ldap_search(&result, request, &conn, ldap_url->lud_dn, ldap_url->lud_scope,
- ldap_url->lud_filter, attrs, server_ctrls, NULL);
+ ldap_url->lud_filter, UNCONST(char **, ldap_url->lua_attr), server_ctrls, NULL);
#ifdef HAVE_LDAP_CREATE_SORT_CONTROL
if (server_ctrls[0]) ldap_control_free(server_ctrls[0]);
if (inst->userobj_sort_by) {
LDAPSortKey **keys;
int ret;
- char *p;
-
- memcpy(&p, &inst->userobj_sort_by, sizeof(p));
- ret = ldap_create_sort_keylist(&keys, p);
+ ret = ldap_create_sort_keylist(&keys, UNCONST(char *, inst->userobj_sort_by));
if (ret != LDAP_SUCCESS) {
cf_log_err(conf, "Invalid user.sort_by value \"%s\": %s",
inst->userobj_sort_by, ldap_err2string(ret));
*/
static int _lua_pair_accessor_init(lua_State *L)
{
- request_t *request = fr_lua_util_get_request();
+ request_t *request = fr_lua_util_get_request();
char const *attr;
fr_dict_attr_t const *da;
fr_dict_attr_t *up;
REDEBUG("Unknown or invalid attribute name \"%s\"", attr);
return -1;
}
- memcpy(&up, &da, sizeof(up));
+ up = UNCONST(fr_dict_attr_t *, da);
/*
* Add the pairs method to the main table, this allows
MEM(path = talloc_asprintf_append_buffer(path, "%s:", inst->python_path));
}
if (inst->python_path_include_conf_dir) {
- char const *imutable;
- char *mutable;
-
- imutable = cf_filename(conf);
- memcpy(&mutable, &imutable, sizeof(mutable));
-
- MEM(path = talloc_asprintf_append_buffer(path, "%s:", dirname(mutable)));
+ MEM(path = talloc_asprintf_append_buffer(path, "%s:", dirname(UNCONST(char *, cf_filename(conf)))));
}
if (inst->python_path_include_default) {
MEM(path = talloc_asprintf_append_buffer(path, "%s:", default_path));
/* Not suported ? */
SQLSetConnectAttr(conn->dbc_handle, SQL_ATTR_LOGIN_TIMEOUT, &timeout_ms, SQL_IS_UINTEGER);
#endif
+
/*
- * The db2 API doesn't qualify arguments as const even when they should be.
+ * We probably want to use SQLDriverConnect, which connects
+ * to a remote server.
+ *
+ * http://www.ibm.com/support/knowledgecenter/SSEPGG_10.5.0/com.ibm.db2.luw.apdv.cli.doc/doc/r0000584.html
+ * http://stackoverflow.com/questions/27167070/connection-string-to-a-remote-db2-db-in-another-server
+ *
+ * And probably synthesise the retarded connection string ourselves,
+ * probably via config file expansions:
+ *
+ * Driver={IBM DB2 ODBC Driver};Database=testDb;Hostname=remoteHostName.com;UID=username;PWD=mypasswd;PORT=50000
*/
- {
- SQLCHAR *server, *login, *password;
-
- memcpy(&server, &config->sql_server, sizeof(server));
- memcpy(&login, &config->sql_login, sizeof(login));
- memcpy(&password, &config->sql_password, sizeof(password));
-
- /*
- * We probably want to use SQLDriverConnect, which connects
- * to a remote server.
- *
- * http://www.ibm.com/support/knowledgecenter/SSEPGG_10.5.0/com.ibm.db2.luw.apdv.cli.doc/doc/r0000584.html
- * http://stackoverflow.com/questions/27167070/connection-string-to-a-remote-db2-db-in-another-server
- *
- * And probably synthesis the retarded connection string ourselves,
- * probably via config file expansions:
- *
- * Driver={IBM DB2 ODBC Driver};Database=testDb;Hostname=remoteHostName.com;UID=username;PWD=mypasswd;PORT=50000
- */
- row = SQLConnect(conn->dbc_handle,
- server, SQL_NTS,
- login, SQL_NTS,
- password, SQL_NTS);
- }
-
+ row = SQLConnect(conn->dbc_handle,
+ UNCONST(SQLCHAR *, config->sql_server), SQL_NTS,
+ UNCONST(SQLCHAR *, config->sql_login), SQL_NTS,
+ UNCONST(SQLCHAR *, config->sql_password), SQL_NTS);
if (row != SQL_SUCCESS) {
ERROR("could not connect to DB2 server %s", config->sql_server);
* Set User and Password properties for the db
*/
{
- CS_VOID *login, *password;
- CS_CHAR *server;
char database[128];
- memcpy(&login, &config->sql_login, sizeof(login));
- if (ct_con_props(conn->db, CS_SET, CS_USERNAME, login, strlen(config->sql_login), NULL) != CS_SUCCEED) {
+ if (ct_con_props(conn->db, CS_SET, CS_USERNAME,
+ UNCONST(CS_VOID *, config->sql_login), strlen(config->sql_login), NULL) != CS_SUCCEED) {
ERROR("unable to set username for db");
goto error;
}
- memcpy(&password, &config->sql_password, sizeof(password));
if (ct_con_props(conn->db, CS_SET, CS_PASSWORD,
- password, strlen(config->sql_password), NULL) != CS_SUCCEED) {
+ UNCONST(CS_VOID *, config->sql_password), strlen(config->sql_password), NULL) != CS_SUCCEED) {
ERROR("unable to set password for db");
goto error;
/*
* Connect to the database
*/
- memcpy(&server, &config->sql_server, sizeof(server));
- if (ct_connect(conn->db, server, strlen(config->sql_server)) != CS_SUCCEED) {
+ if (ct_connect(conn->db, UNCONST(CS_CHAR *, config->sql_server), strlen(config->sql_server)) != CS_SUCCEED) {
ERROR("unable to establish db to symbolic servername %s",
config->sql_server);
static sql_rcode_t sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char const *query)
{
- int status;
- rlm_sql_oracle_conn_t *conn = handle->conn;
-
- OraText *oracle_query;
-
- memcpy(&oracle_query, &query, sizeof(oracle_query));
+ int status;
+ rlm_sql_oracle_conn_t *conn = handle->conn;
if (!conn->ctx) {
ERROR("Socket not connected");
return RLM_SQL_RECONNECT;
}
- if (OCIStmtPrepare(conn->query, conn->error, oracle_query, strlen(query),
+ if (OCIStmtPrepare(conn->query, conn->error, UNCONST(OraText *, query), strlen(query),
OCI_NTV_SYNTAX, OCI_DEFAULT)) {
ERROR("prepare failed in sql_query");
sb2 *ind;
- OraText *oracle_query;
-
rlm_sql_oracle_conn_t *conn = handle->conn;
- memcpy(&oracle_query, &query, sizeof(oracle_query));
-
- if (OCIStmtPrepare(conn->query, conn->error, oracle_query, strlen(query), OCI_NTV_SYNTAX,
+ if (OCIStmtPrepare(conn->query, conn->error, UNCONST(OraText *, query), strlen(query), OCI_NTV_SYNTAX,
OCI_DEFAULT)) {
ERROR("prepare failed in sql_select_query");
SQLSetConnectAttr(conn->dbc, SQL_ATTR_LOGIN_TIMEOUT, &timeout_ms, SQL_IS_UINTEGER);
/* 3. Connect to the datasource */
- {
- SQLCHAR *odbc_server, *odbc_login, *odbc_password;
-
- memcpy(&odbc_server, &config->sql_server, sizeof(odbc_server));
- memcpy(&odbc_login, &config->sql_login, sizeof(odbc_login));
- memcpy(&odbc_password, &config->sql_password, sizeof(odbc_password));
- err_handle = SQLConnect(conn->dbc,
- odbc_server, strlen(config->sql_server),
- odbc_login, strlen(config->sql_login),
- odbc_password, strlen(config->sql_password));
- }
+ err_handle = SQLConnect(conn->dbc,
+ UNCONST(SQLCHAR *, config->sql_server), strlen(config->sql_server),
+ UNCONST(SQLCHAR *, config->sql_login), strlen(config->sql_login),
+ UNCONST(SQLCHAR *, config->sql_password), strlen(config->sql_password));
if (sql_check_error(err_handle, handle, config)) {
ERROR("Connection failed");
int state;
/* Executing query */
- {
- SQLCHAR *odbc_query;
-
- memcpy(&odbc_query, &query, sizeof(odbc_query));
- err_handle = SQLExecDirect(conn->stmt, odbc_query, strlen(query));
- }
+ err_handle = SQLExecDirect(conn->stmt, UNCONST(SQLCHAR *, query), strlen(query));
if ((state = sql_check_error(err_handle, handle, config))) {
if(state == RLM_SQL_RECONNECT) {
DEBUG("rlm_sql will attempt to reconnect");
if (res) goto error;
/* Now load the config file, which can override gleaned settings. */
- {
- char *file;
-
- memcpy(&file, &inst->filename, sizeof(file));
- res = ub_ctx_config(inst->ub, file);
- if (res) goto error;
- }
+ res = ub_ctx_config(inst->ub, UNCONST(char *, inst->filename));
+ if (res) goto error;
if (unbound_log_init(inst, &inst->u_log, inst->ub) < 0) goto error;
int talloc_const_free(void const *ptr)
{
- void *tmp;
if (!ptr) return 0;
-
- memcpy(&tmp, &ptr, sizeof(tmp));
- return talloc_free(tmp);
+ return talloc_free(UNCONST(void *, ptr));
}
/**********************************************************************/
int talloc_const_free(void const *ptr)
{
- void *tmp;
if (!ptr) return 0;
-
- memcpy(&tmp, &ptr, sizeof(tmp));
- return talloc_free(tmp);
+ return talloc_free(UNCONST(void *, ptr));
}
/**********************************************************************/
int talloc_const_free(void const *ptr)
{
- void *tmp;
if (!ptr) return 0;
-
- memcpy(&tmp, &ptr, sizeof(tmp));
- return talloc_free(tmp);
+ return talloc_free(UNCONST(void *, ptr));
}
/**********************************************************************/
int talloc_const_free(void const *ptr)
{
- void *tmp;
if (!ptr) return 0;
-
- memcpy(&tmp, &ptr, sizeof(tmp));
- return talloc_free(tmp);
+ return talloc_free(UNCONST(void *, ptr));
}
/**********************************************************************/
int talloc_const_free(void const *ptr)
{
- void *tmp;
if (!ptr) return 0;
-
- memcpy(&tmp, &ptr, sizeof(tmp));
- return talloc_free(tmp);
+ return talloc_free(UNCONST(void *, ptr));
}
/**********************************************************************/
int talloc_const_free(void const *ptr)
{
- void *tmp;
if (!ptr) return 0;
-
- memcpy(&tmp, &ptr, sizeof(tmp));
- return talloc_free(tmp);
+ return talloc_free(UNCONST(void *, ptr));
}
/**********************************************************************/
projects / thirdparty / freeradius-server.git / commitdiff
