void opt_test_copy_default(void **state)
{
int ret;
TALLOC_CTX *mem_ctx;
struct dp_option *opts;
struct dp_opt_blob b;
mem_ctx = talloc_new(global_talloc_context);
assert_non_null(mem_ctx);
ret = dp_copy_defaults(mem_ctx, test_def_opts, OPT_NUM_OPTS, &opts);
assert_int_equal(ret, EOK);
assert_defaults(opts);
/* Test that copy_defaults would still copy defaults even if we
* change the values
*/
ret = dp_opt_set_string(opts, OPT_STRING_NODEFAULT, "str1");
assert_int_equal(ret, EOK);
ret = dp_opt_set_string(opts, OPT_STRING_DEFAULT, "str2");
assert_int_equal(ret, EOK);
b.data = discard_const_p(uint8_t, "blob1");
b.length = strlen("blob1");
ret = dp_opt_set_blob(opts, OPT_BLOB_NODEFAULT, b);
assert_int_equal(ret, EOK);
ret = dp_opt_set_blob(opts, OPT_BLOB_DEFAULT, b);
b.data = discard_const_p(uint8_t, "blob2");
b.length = strlen("blob2");
assert_int_equal(ret, EOK);
ret = dp_opt_set_int(opts, OPT_INT_NODEFAULT, 456);
assert_int_equal(ret, EOK);
ret = dp_opt_set_int(opts, OPT_INT_DEFAULT, 789);
assert_int_equal(ret, EOK);
ret = dp_opt_set_bool(opts, OPT_BOOL_TRUE, false);
assert_int_equal(ret, EOK);
ret = dp_opt_set_bool(opts, OPT_BOOL_FALSE, true);
assert_int_equal(ret, EOK);
talloc_free(opts);
ret = dp_copy_defaults(mem_ctx, test_def_opts, OPT_NUM_OPTS, &opts);
assert_int_equal(ret, EOK);
assert_defaults(opts);
}
void opt_test_copy_options(void **state)
{
int ret;
TALLOC_CTX *mem_ctx;
struct dp_option *opts;
char *s;
struct dp_opt_blob b;
int i;
bool bo;
mem_ctx = talloc_new(global_talloc_context);
assert_non_null(mem_ctx);
ret = dp_copy_options(mem_ctx, test_def_opts, OPT_NUM_OPTS, &opts);
assert_int_equal(ret, EOK);
assert_int_equal(ret, EOK);
ret = dp_opt_set_string(opts, OPT_STRING_NODEFAULT, "str1");
assert_int_equal(ret, EOK);
b.data = discard_const_p(uint8_t, "blob1");
b.length = strlen("blob1");
ret = dp_opt_set_blob(opts, OPT_BLOB_NODEFAULT, b);
assert_int_equal(ret, EOK);
ret = dp_opt_set_int(opts, OPT_INT_NODEFAULT, 456);
assert_int_equal(ret, EOK);
ret = dp_opt_set_bool(opts, OPT_BOOL_TRUE, false);
assert_int_equal(ret, EOK);
/* Test that options set to an explicit value retain
* the value and even options with default value
* do not return the default unless explicitly set
*/
s = dp_opt_get_string(opts, OPT_STRING_NODEFAULT);
assert_string_equal(s, "str1");
s = dp_opt_get_string(opts, OPT_STRING_DEFAULT);
assert_null(s);
b = dp_opt_get_blob(opts, OPT_BLOB_NODEFAULT);
assert_non_null(b.data);
assert_int_equal(b.length, strlen("blob1"));
assert_memory_equal(b.data, "blob1", strlen("blob1"));
b = dp_opt_get_blob(opts, OPT_BLOB_DEFAULT);
assert_null(b.data);
assert_int_equal(b.length, 0);
i = dp_opt_get_int(opts, OPT_INT_NODEFAULT);
assert_int_equal(i, 456);
i = dp_opt_get_int(opts, OPT_INT_DEFAULT);
assert_int_equal(i, 0);
bo = dp_opt_get_bool(opts, OPT_BOOL_TRUE);
assert_false(bo == true);
}
static void set_nondefault_int(struct dp_option *opts)
{
int ret;
ret = dp_opt_set_int(opts, OPT_INT_NODEFAULT, 456);
assert_int_equal(ret, EOK);
}
static int sdap_sudo_setup_periodical_refresh(struct sdap_sudo_ctx *sudo_ctx)
{
struct sdap_id_ctx *id_ctx = sudo_ctx->id_ctx;
time_t smart_default;
time_t smart_interval;
time_t full_interval;
time_t last_full;
time_t delay;
int ret;
smart_interval = dp_opt_get_int(id_ctx->opts->basic,
SDAP_SUDO_SMART_REFRESH_INTERVAL);
full_interval = dp_opt_get_int(id_ctx->opts->basic,
SDAP_SUDO_FULL_REFRESH_INTERVAL);
if (smart_interval == 0 && full_interval == 0) {
smart_default = id_ctx->opts->basic[SDAP_SUDO_SMART_REFRESH_INTERVAL].def_val.number;
DEBUG(SSSDBG_MINOR_FAILURE, "At least one periodical update has to be "
"enabled. Setting smart refresh interval to default value (%ld).\n",
smart_default);
ret = dp_opt_set_int(id_ctx->opts->basic,
SDAP_SUDO_SMART_REFRESH_INTERVAL,
smart_default);
if (ret != EOK) {
return ret;
}
}
if (full_interval <= smart_interval) {
DEBUG(SSSDBG_MINOR_FAILURE, "Full refresh interval has to be greater"
"than smart refresh interval. Periodical full refresh will be "
"disabled.\n");
ret = dp_opt_set_int(id_ctx->opts->basic,
SDAP_SUDO_FULL_REFRESH_INTERVAL,
0);
if (ret != EOK) {
return ret;
}
}
ret = sysdb_sudo_get_last_full_refresh(id_ctx->be->domain,
&last_full);
if (ret != EOK) {
return ret;
}
if (last_full == 0) {
/* If this is the first startup, we need to kick off
* an refresh immediately, to close a window where
* clients requesting sudo information won't get an
* immediate reply with no entries
*/
delay = 0;
} else {
/* At least one update has previously run,
* so clients will get cached data.
* We will delay the refresh so we don't slow
* down the startup process if this is happening
* during system boot.
*/
/* delay at least by 10s */
delay = 10;
}
ret = sdap_sudo_schedule_refresh(sudo_ctx, sudo_ctx,
SDAP_SUDO_REFRESH_FULL,
sdap_sudo_periodical_first_refresh_done,
delay, full_interval, NULL);
if (ret != EOK) {
DEBUG(SSSDBG_OP_FAILURE, "Unable to schedule full refresh of sudo "
"rules! Periodical updates will not work!\n");
return ret;
}
return EOK;
}
static int sdap_sudo_setup_periodical_refresh(struct sdap_sudo_ctx *sudo_ctx)
{
struct sdap_id_ctx *id_ctx = sudo_ctx->id_ctx;
struct tevent_req *req;
time_t smart_default;
time_t smart_interval;
time_t full_interval;
time_t last_full;
struct timeval tv;
int ret;
smart_interval = dp_opt_get_int(id_ctx->opts->basic,
SDAP_SUDO_SMART_REFRESH_INTERVAL);
full_interval = dp_opt_get_int(id_ctx->opts->basic,
SDAP_SUDO_FULL_REFRESH_INTERVAL);
if (smart_interval == 0 && full_interval == 0) {
smart_default = id_ctx->opts->basic[SDAP_SUDO_SMART_REFRESH_INTERVAL].def_val.number;
DEBUG(SSSDBG_MINOR_FAILURE, ("At least one periodical update has to be "
"enabled. Setting smart refresh interval to default value (%d).\n",
smart_default));
ret = dp_opt_set_int(id_ctx->opts->basic,
SDAP_SUDO_SMART_REFRESH_INTERVAL,
smart_default);
if (ret != EOK) {
return ret;
}
}
if (full_interval <= smart_interval) {
DEBUG(SSSDBG_MINOR_FAILURE, ("Full refresh interval has to be greater"
"than smart refresh interval. Periodical full refresh will be "
"disabled.\n"));
ret = dp_opt_set_int(id_ctx->opts->basic,
SDAP_SUDO_FULL_REFRESH_INTERVAL,
0);
if (ret != EOK) {
return ret;
}
}
ret = sysdb_sudo_get_last_full_refresh(id_ctx->be->sysdb, &last_full);
if (ret != EOK) {
return ret;
}
if (last_full == 0) {
/* If this is the first startup, we need to kick off
* an refresh immediately, to close a window where
* clients requesting sudo information won't get an
* immediate reply with no entries
*/
tv = tevent_timeval_current();
} else {
/* At least one update has previously run,
* so clients will get cached data.
* We will delay the refresh so we don't slow
* down the startup process if this is happening
* during system boot.
*/
/* delay at least by 10s */
tv = tevent_timeval_current_ofs(10, 0);
}
req = sdap_sudo_timer_send(sudo_ctx, id_ctx->be->ev, sudo_ctx,
tv, full_interval,
sdap_sudo_full_refresh_send);
if (req == NULL) {
DEBUG(SSSDBG_OP_FAILURE, ("Unable to schedule full refresh of sudo "
"rules! Periodical updates will not work!\n"));
return ENOMEM;
}
tevent_req_set_callback(req, sdap_sudo_periodical_first_refresh_done,
sudo_ctx);
DEBUG(SSSDBG_TRACE_FUNC, ("Full refresh scheduled at: %lld\n",
(long long)tv.tv_sec));
return EOK;
}
