test_utils.c revision 059904af2d20debcb8ffe1c6f45b996c2c57574e
af84459fbf938e508fd10b01cb8d699c79083813takashi/*
af84459fbf938e508fd10b01cb8d699c79083813takashi Authors:
af84459fbf938e508fd10b01cb8d699c79083813takashi Sumit Bose <sbose@redhat.com>
af84459fbf938e508fd10b01cb8d699c79083813takashi
af84459fbf938e508fd10b01cb8d699c79083813takashi Copyright (C) 2013 Red Hat
af84459fbf938e508fd10b01cb8d699c79083813takashi
af84459fbf938e508fd10b01cb8d699c79083813takashi SSSD tests: Tests for utility functions
fed47023e9be04c612b5f6d4a5ee2b8e7c587181rbowen
af84459fbf938e508fd10b01cb8d699c79083813takashi This program is free software; you can redistribute it and/or modify
af84459fbf938e508fd10b01cb8d699c79083813takashi it under the terms of the GNU General Public License as published by
af84459fbf938e508fd10b01cb8d699c79083813takashi the Free Software Foundation; either version 3 of the License, or
af84459fbf938e508fd10b01cb8d699c79083813takashi (at your option) any later version.
af84459fbf938e508fd10b01cb8d699c79083813takashi
af84459fbf938e508fd10b01cb8d699c79083813takashi This program is distributed in the hope that it will be useful,
3f08db06526d6901aa08c110b5bc7dde6bc39905nd but WITHOUT ANY WARRANTY; without even the implied warranty of
af84459fbf938e508fd10b01cb8d699c79083813takashi MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
af84459fbf938e508fd10b01cb8d699c79083813takashi GNU General Public License for more details.
af84459fbf938e508fd10b01cb8d699c79083813takashi
3f08db06526d6901aa08c110b5bc7dde6bc39905nd You should have received a copy of the GNU General Public License
af84459fbf938e508fd10b01cb8d699c79083813takashi along with this program. If not, see <http://www.gnu.org/licenses/>.
af84459fbf938e508fd10b01cb8d699c79083813takashi*/
f086b4b402fa9a2fefc7dda85de2a3cc1cd0a654rjung
af84459fbf938e508fd10b01cb8d699c79083813takashi#define _GNU_SOURCE
af84459fbf938e508fd10b01cb8d699c79083813takashi#include <stdio.h>
af84459fbf938e508fd10b01cb8d699c79083813takashi#include <popt.h>
af84459fbf938e508fd10b01cb8d699c79083813takashi
af84459fbf938e508fd10b01cb8d699c79083813takashi#include "tests/cmocka/common_mock.h"
3c13a815670b54d1c17bf02954f7d2b066cde95cnd#include "util/sss_nss.h"
3c13a815670b54d1c17bf02954f7d2b066cde95cnd#include "test_utils.h"
2d39a41e98476f5235b7c37ce745a4aa0904b1cbrbowen
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe#define TESTS_PATH "tp_" BASE_FILE_STEM
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe#define TEST_CONF_DB "test_utils_conf.ldb"
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe#define TEST_DOM_NAME "utils_test.ldb"
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe#define DOM_COUNT 10
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe#define DOMNAME_TMPL "name_%zu.dom"
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe#define FLATNAME_TMPL "name_%zu"
fed47023e9be04c612b5f6d4a5ee2b8e7c587181rbowen#define SID_TMPL "S-1-5-21-1-2-%zu"
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe#define MACRO_EXPAND(tok) #tok
af84459fbf938e508fd10b01cb8d699c79083813takashi#define STR(tok) MACRO_EXPAND(tok)
af84459fbf938e508fd10b01cb8d699c79083813takashi
af84459fbf938e508fd10b01cb8d699c79083813takashi#define USERNAME "sssduser"
af84459fbf938e508fd10b01cb8d699c79083813takashi#define UID 1234
af84459fbf938e508fd10b01cb8d699c79083813takashi#define DOMAIN "sssddomain"
af84459fbf938e508fd10b01cb8d699c79083813takashi#define ORIGINAL_HOME "/home/user"
af84459fbf938e508fd10b01cb8d699c79083813takashi#define FLATNAME "flatname"
af84459fbf938e508fd10b01cb8d699c79083813takashi#define HOMEDIR_SUBSTR "/mnt/home"
fed47023e9be04c612b5f6d4a5ee2b8e7c587181rbowen
af84459fbf938e508fd10b01cb8d699c79083813takashi#define DUMMY "dummy"
af84459fbf938e508fd10b01cb8d699c79083813takashi#define DUMMY2 "dummy2"
af84459fbf938e508fd10b01cb8d699c79083813takashi
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowestruct dom_list_test_ctx {
af84459fbf938e508fd10b01cb8d699c79083813takashi size_t dom_count;
3c13a815670b54d1c17bf02954f7d2b066cde95cnd struct sss_domain_info *dom_list;
af84459fbf938e508fd10b01cb8d699c79083813takashi};
af84459fbf938e508fd10b01cb8d699c79083813takashi
fed47023e9be04c612b5f6d4a5ee2b8e7c587181rbowen
af84459fbf938e508fd10b01cb8d699c79083813takashistatic int setup_dom_list(void **state)
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe{
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe struct dom_list_test_ctx *test_ctx;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe struct sss_domain_info *dom = NULL;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe size_t c;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_true(leak_check_setup());
9a58dc6a2b26ec128b1270cf48810e705f1a90dbsf
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe test_ctx = talloc_zero(global_talloc_context, struct dom_list_test_ctx);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(test_ctx);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
fed47023e9be04c612b5f6d4a5ee2b8e7c587181rbowen test_ctx->dom_count = DOM_COUNT;
78f97ce162b66a0dbfd7af4dcd9984f162569b04minfrin
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe for (c = 0; c < test_ctx->dom_count; c++) {
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom = talloc_zero(test_ctx, struct sss_domain_info);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(dom);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom->name = talloc_asprintf(dom, DOMNAME_TMPL, c);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(dom->name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom->flat_name = talloc_asprintf(dom, FLATNAME_TMPL, c);
fed47023e9be04c612b5f6d4a5ee2b8e7c587181rbowen assert_non_null(dom->flat_name);
fed47023e9be04c612b5f6d4a5ee2b8e7c587181rbowen
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom->domain_id = talloc_asprintf(dom, SID_TMPL, c);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(dom->domain_id);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe DLIST_ADD(test_ctx->dom_list, dom);
4bebf996eb7002ebfe897d46a0e0572390604a77nd }
4bebf996eb7002ebfe897d46a0e0572390604a77nd
4bebf996eb7002ebfe897d46a0e0572390604a77nd check_leaks_push(test_ctx);
4bebf996eb7002ebfe897d46a0e0572390604a77nd *state = test_ctx;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe return 0;
4bebf996eb7002ebfe897d46a0e0572390604a77nd}
9534272616b71aaea50aeec4162e749a96aebd7fsf
4bebf996eb7002ebfe897d46a0e0572390604a77ndstatic int teardown_dom_list(void **state)
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe{
af84459fbf938e508fd10b01cb8d699c79083813takashi struct dom_list_test_ctx *test_ctx = talloc_get_type(*state,
af84459fbf938e508fd10b01cb8d699c79083813takashi struct dom_list_test_ctx);
af84459fbf938e508fd10b01cb8d699c79083813takashi if (test_ctx == NULL) {
af84459fbf938e508fd10b01cb8d699c79083813takashi DEBUG(SSSDBG_CRIT_FAILURE, "Type mismatch\n");
af84459fbf938e508fd10b01cb8d699c79083813takashi return 1;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe }
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
fed47023e9be04c612b5f6d4a5ee2b8e7c587181rbowen assert_true(check_leaks_pop(test_ctx) == true);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe talloc_free(test_ctx);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_true(leak_check_teardown());
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe return 0;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe}
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowevoid test_find_domain_by_name_null(void **state)
fed47023e9be04c612b5f6d4a5ee2b8e7c587181rbowen{
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe struct dom_list_test_ctx *test_ctx = talloc_get_type(*state,
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe struct dom_list_test_ctx);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe struct sss_domain_info *dom;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom = find_domain_by_name(NULL, NULL, false);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_null(dom);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom = find_domain_by_name(test_ctx->dom_list, NULL, false);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_null(dom);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom = find_domain_by_name(NULL, "test", false);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_null(dom);
fed47023e9be04c612b5f6d4a5ee2b8e7c587181rbowen}
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowevoid test_find_domain_by_name(void **state)
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe{
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe struct dom_list_test_ctx *test_ctx = talloc_get_type(*state,
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe struct dom_list_test_ctx);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe struct sss_domain_info *dom;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe size_t c;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe char *name;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe char *flat_name;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe char *sid;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe for (c = 0; c < test_ctx->dom_count; c++) {
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe name = talloc_asprintf(global_talloc_context, DOMNAME_TMPL, c);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe flat_name = talloc_asprintf(global_talloc_context, FLATNAME_TMPL, c);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(flat_name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe sid = talloc_asprintf(global_talloc_context, SID_TMPL, c);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(sid);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom = find_domain_by_name(test_ctx->dom_list, name, false);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(dom);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(name, dom->name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(flat_name, dom->flat_name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(sid, dom->domain_id);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom = find_domain_by_name(test_ctx->dom_list, name, true);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(dom);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(name, dom->name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(flat_name, dom->flat_name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(sid, dom->domain_id);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom = find_domain_by_name(test_ctx->dom_list, flat_name, true);
f039cf01b271a31e317d5b84f24cb135f1c1b6d7nd assert_non_null(dom);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(name, dom->name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(flat_name, dom->flat_name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(sid, dom->domain_id);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom = find_domain_by_name(test_ctx->dom_list, flat_name, false);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_null(dom);
f039cf01b271a31e317d5b84f24cb135f1c1b6d7nd
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe talloc_free(name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe talloc_free(flat_name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe talloc_free(sid);
f039cf01b271a31e317d5b84f24cb135f1c1b6d7nd }
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe}
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
af84459fbf938e508fd10b01cb8d699c79083813takashivoid test_find_domain_by_name_missing_flat_name(void **state)
af84459fbf938e508fd10b01cb8d699c79083813takashi{
2d39a41e98476f5235b7c37ce745a4aa0904b1cbrbowen struct dom_list_test_ctx *test_ctx = talloc_get_type(*state,
fed47023e9be04c612b5f6d4a5ee2b8e7c587181rbowen struct dom_list_test_ctx);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe struct sss_domain_info *dom;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe size_t c;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe char *name;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe char *flat_name;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe char *sid;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe size_t mis;
c8c717fafa0a09ed13469a603a178921b851dd22igalic
c8c717fafa0a09ed13469a603a178921b851dd22igalic mis = test_ctx->dom_count/2;
b7f8d802ecaed65eada1fc31472d06d8460d5528igalic assert_true((mis >= 1 && mis < test_ctx->dom_count));
b7f8d802ecaed65eada1fc31472d06d8460d5528igalic
b7f8d802ecaed65eada1fc31472d06d8460d5528igalic dom = test_ctx->dom_list;
b7f8d802ecaed65eada1fc31472d06d8460d5528igalic for (c = 0; c < mis; c++) {
b7f8d802ecaed65eada1fc31472d06d8460d5528igalic assert_non_null(dom);
b7f8d802ecaed65eada1fc31472d06d8460d5528igalic dom = dom->next;
b7f8d802ecaed65eada1fc31472d06d8460d5528igalic }
b7f8d802ecaed65eada1fc31472d06d8460d5528igalic assert_non_null(dom);
b7f8d802ecaed65eada1fc31472d06d8460d5528igalic dom->flat_name = NULL;
7c7e501f542451bf7225b23cb299ee4228bfe15dgryzor
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe for (c = 0; c < test_ctx->dom_count; c++) {
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe name = talloc_asprintf(global_talloc_context, DOMNAME_TMPL, c);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe flat_name = talloc_asprintf(global_talloc_context, FLATNAME_TMPL, c);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(flat_name);
c8c717fafa0a09ed13469a603a178921b851dd22igalic
7c7e501f542451bf7225b23cb299ee4228bfe15dgryzor sid = talloc_asprintf(global_talloc_context, SID_TMPL, c);
4bebf996eb7002ebfe897d46a0e0572390604a77nd assert_non_null(sid);
4bebf996eb7002ebfe897d46a0e0572390604a77nd
4bebf996eb7002ebfe897d46a0e0572390604a77nd dom = find_domain_by_name(test_ctx->dom_list, name, true);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(dom);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(name, dom->name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe if (c == mis - 1) {
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_null(dom->flat_name);
8559a67073808d84d85bb5dd552d4247caafe709sf } else {
8559a67073808d84d85bb5dd552d4247caafe709sf assert_string_equal(flat_name, dom->flat_name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe }
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(sid, dom->domain_id);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom = find_domain_by_name(test_ctx->dom_list, name, false);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(dom);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(name, dom->name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe if (c == mis - 1) {
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_null(dom->flat_name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe } else {
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(flat_name, dom->flat_name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe }
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(sid, dom->domain_id);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom = find_domain_by_name(test_ctx->dom_list, flat_name, true);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe if (c == mis - 1) {
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_null(dom);
8559a67073808d84d85bb5dd552d4247caafe709sf } else {
fed47023e9be04c612b5f6d4a5ee2b8e7c587181rbowen assert_non_null(dom);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(name, dom->name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(flat_name, dom->flat_name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(sid, dom->domain_id);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe }
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom = find_domain_by_name(test_ctx->dom_list, flat_name, false);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_null(dom);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
8559a67073808d84d85bb5dd552d4247caafe709sf talloc_free(name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe talloc_free(flat_name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe talloc_free(sid);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe }
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe}
c8c717fafa0a09ed13469a603a178921b851dd22igalic
c8c717fafa0a09ed13469a603a178921b851dd22igalicvoid test_find_domain_by_name_disabled(void **state)
8559a67073808d84d85bb5dd552d4247caafe709sf{
c8c717fafa0a09ed13469a603a178921b851dd22igalic struct dom_list_test_ctx *test_ctx = talloc_get_type(*state,
c8c717fafa0a09ed13469a603a178921b851dd22igalic struct dom_list_test_ctx);
c8c717fafa0a09ed13469a603a178921b851dd22igalic struct sss_domain_info *dom;
8559a67073808d84d85bb5dd552d4247caafe709sf size_t c;
8559a67073808d84d85bb5dd552d4247caafe709sf char *name;
8559a67073808d84d85bb5dd552d4247caafe709sf char *flat_name;
8559a67073808d84d85bb5dd552d4247caafe709sf char *sid;
8559a67073808d84d85bb5dd552d4247caafe709sf size_t mis;
8559a67073808d84d85bb5dd552d4247caafe709sf
8559a67073808d84d85bb5dd552d4247caafe709sf mis = test_ctx->dom_count/2;
8559a67073808d84d85bb5dd552d4247caafe709sf assert_true((mis >= 1 && mis < test_ctx->dom_count));
8559a67073808d84d85bb5dd552d4247caafe709sf
8559a67073808d84d85bb5dd552d4247caafe709sf dom = test_ctx->dom_list;
8559a67073808d84d85bb5dd552d4247caafe709sf for (c = 0; c < mis; c++) {
8559a67073808d84d85bb5dd552d4247caafe709sf assert_non_null(dom);
8559a67073808d84d85bb5dd552d4247caafe709sf dom = dom->next;
8559a67073808d84d85bb5dd552d4247caafe709sf }
8559a67073808d84d85bb5dd552d4247caafe709sf assert_non_null(dom);
8559a67073808d84d85bb5dd552d4247caafe709sf sss_domain_set_state(dom, DOM_DISABLED);
8559a67073808d84d85bb5dd552d4247caafe709sf
8559a67073808d84d85bb5dd552d4247caafe709sf for (c = 0; c < test_ctx->dom_count; c++) {
8559a67073808d84d85bb5dd552d4247caafe709sf name = talloc_asprintf(global_talloc_context, DOMNAME_TMPL, c);
8559a67073808d84d85bb5dd552d4247caafe709sf assert_non_null(name);
8559a67073808d84d85bb5dd552d4247caafe709sf
8559a67073808d84d85bb5dd552d4247caafe709sf flat_name = talloc_asprintf(global_talloc_context, FLATNAME_TMPL, c);
8559a67073808d84d85bb5dd552d4247caafe709sf assert_non_null(flat_name);
8559a67073808d84d85bb5dd552d4247caafe709sf
9a58dc6a2b26ec128b1270cf48810e705f1a90dbsf sid = talloc_asprintf(global_talloc_context, SID_TMPL, c);
4bebf996eb7002ebfe897d46a0e0572390604a77nd assert_non_null(sid);
4bebf996eb7002ebfe897d46a0e0572390604a77nd
4bebf996eb7002ebfe897d46a0e0572390604a77nd dom = find_domain_by_name(test_ctx->dom_list, name, true);
4bebf996eb7002ebfe897d46a0e0572390604a77nd if (c == mis - 1) {
4bebf996eb7002ebfe897d46a0e0572390604a77nd assert_null(dom);
4bebf996eb7002ebfe897d46a0e0572390604a77nd } else {
4bebf996eb7002ebfe897d46a0e0572390604a77nd assert_non_null(dom);
4bebf996eb7002ebfe897d46a0e0572390604a77nd assert_string_equal(name, dom->name);
4bebf996eb7002ebfe897d46a0e0572390604a77nd assert_string_equal(flat_name, dom->flat_name);
4bebf996eb7002ebfe897d46a0e0572390604a77nd assert_string_equal(sid, dom->domain_id);
4bebf996eb7002ebfe897d46a0e0572390604a77nd }
4bebf996eb7002ebfe897d46a0e0572390604a77nd
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom = find_domain_by_name(test_ctx->dom_list, name, false);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe if (c == mis - 1) {
af84459fbf938e508fd10b01cb8d699c79083813takashi assert_null(dom);
af84459fbf938e508fd10b01cb8d699c79083813takashi } else {
af84459fbf938e508fd10b01cb8d699c79083813takashi assert_non_null(dom);
af84459fbf938e508fd10b01cb8d699c79083813takashi assert_string_equal(name, dom->name);
af84459fbf938e508fd10b01cb8d699c79083813takashi assert_string_equal(flat_name, dom->flat_name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(sid, dom->domain_id);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe }
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom = find_domain_by_name(test_ctx->dom_list, flat_name, true);
8e9c6d6438af1ccb46adaa60d34caa3ac98f3851igalic if (c == mis - 1) {
8e9c6d6438af1ccb46adaa60d34caa3ac98f3851igalic assert_null(dom);
8e9c6d6438af1ccb46adaa60d34caa3ac98f3851igalic } else {
8e9c6d6438af1ccb46adaa60d34caa3ac98f3851igalic assert_non_null(dom);
9534272616b71aaea50aeec4162e749a96aebd7fsf assert_string_equal(name, dom->name);
7159c12b7697fe9f5ab3a533cc6dfc3d57803053igalic assert_string_equal(flat_name, dom->flat_name);
7159c12b7697fe9f5ab3a533cc6dfc3d57803053igalic assert_string_equal(sid, dom->domain_id);
7159c12b7697fe9f5ab3a533cc6dfc3d57803053igalic }
7159c12b7697fe9f5ab3a533cc6dfc3d57803053igalic
7159c12b7697fe9f5ab3a533cc6dfc3d57803053igalic dom = find_domain_by_name(test_ctx->dom_list, flat_name, false);
8e9c6d6438af1ccb46adaa60d34caa3ac98f3851igalic assert_null(dom);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe talloc_free(name);
1d45c1463a8bc69bab1c07a4729269ec7333e713rbowen talloc_free(flat_name);
1d45c1463a8bc69bab1c07a4729269ec7333e713rbowen talloc_free(sid);
1d45c1463a8bc69bab1c07a4729269ec7333e713rbowen }
1d45c1463a8bc69bab1c07a4729269ec7333e713rbowen}
1d45c1463a8bc69bab1c07a4729269ec7333e713rbowen
1d45c1463a8bc69bab1c07a4729269ec7333e713rbowenvoid test_find_domain_by_sid_null(void **state)
1d45c1463a8bc69bab1c07a4729269ec7333e713rbowen{
1d45c1463a8bc69bab1c07a4729269ec7333e713rbowen struct dom_list_test_ctx *test_ctx = talloc_get_type(*state,
1d45c1463a8bc69bab1c07a4729269ec7333e713rbowen struct dom_list_test_ctx);
1d45c1463a8bc69bab1c07a4729269ec7333e713rbowen struct sss_domain_info *dom;
1d45c1463a8bc69bab1c07a4729269ec7333e713rbowen
4126704c4950bfd46d32ad54e3b106ac6d868a73sf dom = find_domain_by_sid(NULL, NULL);
4126704c4950bfd46d32ad54e3b106ac6d868a73sf assert_null(dom);
4126704c4950bfd46d32ad54e3b106ac6d868a73sf
4126704c4950bfd46d32ad54e3b106ac6d868a73sf dom = find_domain_by_sid(test_ctx->dom_list, NULL);
4126704c4950bfd46d32ad54e3b106ac6d868a73sf assert_null(dom);
4126704c4950bfd46d32ad54e3b106ac6d868a73sf
4126704c4950bfd46d32ad54e3b106ac6d868a73sf dom = find_domain_by_sid(NULL, "S-1-5-21-1-2-3");
4126704c4950bfd46d32ad54e3b106ac6d868a73sf assert_null(dom);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe}
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
af84459fbf938e508fd10b01cb8d699c79083813takashivoid test_find_domain_by_sid(void **state)
af84459fbf938e508fd10b01cb8d699c79083813takashi{
af84459fbf938e508fd10b01cb8d699c79083813takashi struct dom_list_test_ctx *test_ctx = talloc_get_type(*state,
af84459fbf938e508fd10b01cb8d699c79083813takashi struct dom_list_test_ctx);
af84459fbf938e508fd10b01cb8d699c79083813takashi struct sss_domain_info *dom;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe size_t c;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe char *name;
af84459fbf938e508fd10b01cb8d699c79083813takashi char *flat_name;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe char *sid;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe for (c = 0; c < test_ctx->dom_count; c++) {
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe name = talloc_asprintf(global_talloc_context, DOMNAME_TMPL, c);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe flat_name = talloc_asprintf(global_talloc_context, FLATNAME_TMPL, c);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(flat_name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe sid = talloc_asprintf(global_talloc_context, SID_TMPL, c);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(sid);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom = find_domain_by_sid(test_ctx->dom_list, sid);
c8c717fafa0a09ed13469a603a178921b851dd22igalic assert_non_null(dom);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(name, dom->name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(flat_name, dom->flat_name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_string_equal(sid, dom->domain_id);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe talloc_free(name);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe talloc_free(flat_name);
c8c717fafa0a09ed13469a603a178921b851dd22igalic talloc_free(sid);
c8c717fafa0a09ed13469a603a178921b851dd22igalic }
c8c717fafa0a09ed13469a603a178921b851dd22igalic}
c8c717fafa0a09ed13469a603a178921b851dd22igalic
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowevoid test_find_domain_by_sid_missing_sid(void **state)
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe{
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe struct dom_list_test_ctx *test_ctx = talloc_get_type(*state,
7e9c796f2dc0dba993a817b3a58cfd56b4e511edwrowe struct dom_list_test_ctx);
7e9c796f2dc0dba993a817b3a58cfd56b4e511edwrowe struct sss_domain_info *dom;
7e9c796f2dc0dba993a817b3a58cfd56b4e511edwrowe size_t c;
7e9c796f2dc0dba993a817b3a58cfd56b4e511edwrowe char *name;
7e9c796f2dc0dba993a817b3a58cfd56b4e511edwrowe char *flat_name;
c8c717fafa0a09ed13469a603a178921b851dd22igalic char *sid;
c8c717fafa0a09ed13469a603a178921b851dd22igalic size_t mis;
7e9c796f2dc0dba993a817b3a58cfd56b4e511edwrowe
7e9c796f2dc0dba993a817b3a58cfd56b4e511edwrowe mis = test_ctx->dom_count/2;
c8c717fafa0a09ed13469a603a178921b851dd22igalic assert_true((mis >= 1 && mis < test_ctx->dom_count));
c8c717fafa0a09ed13469a603a178921b851dd22igalic
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom = test_ctx->dom_list;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe for (c = 0; c < mis; c++) {
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(dom);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom = dom->next;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe }
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe assert_non_null(dom);
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe dom->domain_id = NULL;
cd34a6fbf0a2619544a72eadb73f309370bf6682wrowe
af84459fbf938e508fd10b01cb8d699c79083813takashi for (c = 0; c < test_ctx->dom_count; c++) {
af84459fbf938e508fd10b01cb8d699c79083813takashi name = talloc_asprintf(global_talloc_context, DOMNAME_TMPL, c);
af84459fbf938e508fd10b01cb8d699c79083813takashi assert_non_null(name);
af84459fbf938e508fd10b01cb8d699c79083813takashi
f086b4b402fa9a2fefc7dda85de2a3cc1cd0a654rjung flat_name = talloc_asprintf(global_talloc_context, FLATNAME_TMPL, c);
af84459fbf938e508fd10b01cb8d699c79083813takashi assert_non_null(flat_name);
5effc8b39fae5cd169d17f342bfc265705840014rbowen
af84459fbf938e508fd10b01cb8d699c79083813takashi sid = talloc_asprintf(global_talloc_context, SID_TMPL, c);
af84459fbf938e508fd10b01cb8d699c79083813takashi assert_non_null(sid);
dom = find_domain_by_sid(test_ctx->dom_list, sid);
if (c == mis - 1) {
assert_null(dom);
} else {
assert_non_null(dom);
assert_string_equal(name, dom->name);
assert_string_equal(flat_name, dom->flat_name);
assert_string_equal(sid, dom->domain_id);
}
talloc_free(name);
talloc_free(flat_name);
talloc_free(sid);
}
}
void test_find_domain_by_sid_disabled(void **state)
{
struct dom_list_test_ctx *test_ctx = talloc_get_type(*state,
struct dom_list_test_ctx);
struct sss_domain_info *dom;
size_t c;
char *name;
char *flat_name;
char *sid;
size_t mis;
mis = test_ctx->dom_count/2;
assert_true((mis >= 1 && mis < test_ctx->dom_count));
dom = test_ctx->dom_list;
for (c = 0; c < mis; c++) {
assert_non_null(dom);
dom = dom->next;
}
assert_non_null(dom);
sss_domain_set_state(dom, DOM_DISABLED);
for (c = 0; c < test_ctx->dom_count; c++) {
name = talloc_asprintf(global_talloc_context, DOMNAME_TMPL, c);
assert_non_null(name);
flat_name = talloc_asprintf(global_talloc_context, FLATNAME_TMPL, c);
assert_non_null(flat_name);
sid = talloc_asprintf(global_talloc_context, SID_TMPL, c);
assert_non_null(sid);
dom = find_domain_by_sid(test_ctx->dom_list, sid);
if (c == mis - 1) {
assert_null(dom);
} else {
assert_non_null(dom);
assert_string_equal(name, dom->name);
assert_string_equal(flat_name, dom->flat_name);
assert_string_equal(sid, dom->domain_id);
}
talloc_free(name);
talloc_free(flat_name);
talloc_free(sid);
}
}
/*
* dom1 -> sub1a
* |
* dom2 -> sub2a -> sub2b
*
*/
static int setup_dom_tree(void **state)
{
struct dom_list_test_ctx *test_ctx;
struct sss_domain_info *head = NULL;
struct sss_domain_info *dom = NULL;
assert_true(leak_check_setup());
test_ctx = talloc_zero(global_talloc_context, struct dom_list_test_ctx);
assert_non_null(test_ctx);
dom = named_domain(test_ctx, "dom1", NULL);
assert_non_null(dom);
head = dom;
dom = named_domain(test_ctx, "sub1a", head);
assert_non_null(dom);
head->subdomains = dom;
dom = named_domain(test_ctx, "dom2", NULL);
assert_non_null(dom);
head->next = dom;
dom = named_domain(test_ctx, "sub2a", head->next);
assert_non_null(dom);
head->next->subdomains = dom;
dom = named_domain(test_ctx, "sub2b", head->next);
assert_non_null(dom);
head->next->subdomains->next = dom;
test_ctx->dom_count = 2;
test_ctx->dom_list = head;
check_leaks_push(test_ctx);
*state = test_ctx;
return 0;
}
static int teardown_dom_tree(void **state)
{
struct dom_list_test_ctx *test_ctx = talloc_get_type(*state,
struct dom_list_test_ctx);
if (test_ctx == NULL) {
DEBUG(SSSDBG_CRIT_FAILURE, "Type mismatch\n");
return 1;
}
assert_true(check_leaks_pop(test_ctx));
talloc_free(test_ctx);
assert_true(leak_check_teardown());
return 0;
}
static void test_get_next_domain(void **state)
{
struct dom_list_test_ctx *test_ctx = talloc_get_type(*state,
struct dom_list_test_ctx);
struct sss_domain_info *dom = NULL;
dom = get_next_domain(test_ctx->dom_list, 0);
assert_non_null(dom);
assert_string_equal(dom->name, "dom2");
dom = get_next_domain(dom, 0);
assert_null(dom);
}
static void test_get_next_domain_descend(void **state)
{
struct dom_list_test_ctx *test_ctx = talloc_get_type(*state,
struct dom_list_test_ctx);
struct sss_domain_info *dom = NULL;
dom = get_next_domain(test_ctx->dom_list, SSS_GND_DESCEND);
assert_non_null(dom);
assert_string_equal(dom->name, "sub1a");
dom = get_next_domain(dom, SSS_GND_DESCEND);
assert_non_null(dom);
assert_string_equal(dom->name, "dom2");
dom = get_next_domain(dom, SSS_GND_DESCEND);
assert_non_null(dom);
assert_string_equal(dom->name, "sub2a");
dom = get_next_domain(dom, SSS_GND_DESCEND);
assert_non_null(dom);
assert_string_equal(dom->name, "sub2b");
dom = get_next_domain(dom, 0);
assert_null(dom);
}
static void test_get_next_domain_disabled(void **state)
{
struct dom_list_test_ctx *test_ctx = talloc_get_type(*state,
struct dom_list_test_ctx);
struct sss_domain_info *dom = NULL;
for (dom = test_ctx->dom_list; dom;
dom = get_next_domain(dom, SSS_GND_DESCEND)) {
sss_domain_set_state(dom, DOM_DISABLED);
}
dom = get_next_domain(test_ctx->dom_list, SSS_GND_DESCEND);
assert_null(dom);
}
static void test_get_next_domain_flags(void **state)
{
struct dom_list_test_ctx *test_ctx = talloc_get_type(*state,
struct dom_list_test_ctx);
struct sss_domain_info *dom = NULL;
uint32_t gnd_flags;
/* No flags; all doms enabled */
gnd_flags = 0;
dom = get_next_domain(test_ctx->dom_list, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "dom2");
dom = get_next_domain(dom, gnd_flags);
assert_null(dom);
/* Descend flag onlyl; all doms enabled */
gnd_flags = SSS_GND_DESCEND;
dom = get_next_domain(test_ctx->dom_list, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "sub1a");
dom = get_next_domain(dom, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "dom2");
dom = get_next_domain(dom, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "sub2a");
dom = get_next_domain(dom, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "sub2b");
dom = get_next_domain(dom, gnd_flags);
assert_null(dom);
/* Incl. disabled flag only; all doms enabled */
gnd_flags = SSS_GND_INCLUDE_DISABLED;
dom = get_next_domain(test_ctx->dom_list, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "dom2");
dom = get_next_domain(dom, gnd_flags);
assert_null(dom);
/* Descend and inculude disabled; all doms enabled */
gnd_flags = SSS_GND_DESCEND | SSS_GND_INCLUDE_DISABLED;
dom = get_next_domain(test_ctx->dom_list, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "sub1a");
dom = get_next_domain(dom, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "dom2");
dom = get_next_domain(dom, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "sub2a");
dom = get_next_domain(dom, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "sub2b");
dom = get_next_domain(dom, gnd_flags);
assert_null(dom);
/* Now disable dom2 and sub2a */
dom = find_domain_by_name(test_ctx->dom_list, "dom2", false);
assert_non_null(dom);
sss_domain_set_state(dom, DOM_DISABLED);
dom = find_domain_by_name(test_ctx->dom_list, "sub2a", false);
assert_non_null(dom);
sss_domain_set_state(dom, DOM_DISABLED);
/* No flags; dom2 and sub2a disabled */
gnd_flags = 0;
dom = get_next_domain(test_ctx->dom_list, gnd_flags);
assert_null(dom);
/* Descend flag onlyl; dom2 and sub2a disabled */
gnd_flags = SSS_GND_DESCEND;
dom = get_next_domain(test_ctx->dom_list, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "sub1a");
dom = get_next_domain(dom, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "sub2b");
dom = get_next_domain(dom, gnd_flags);
assert_null(dom);
/* Incl. disabled flag only; dom2 and sub2a disabled */
gnd_flags = SSS_GND_INCLUDE_DISABLED;
dom = get_next_domain(test_ctx->dom_list, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "dom2");
dom = get_next_domain(dom, gnd_flags);
assert_null(dom);
/* Descend and inculude disabled; dom2 and sub2a disabled */
gnd_flags = SSS_GND_DESCEND | SSS_GND_INCLUDE_DISABLED;
dom = get_next_domain(test_ctx->dom_list, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "sub1a");
dom = get_next_domain(dom, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "dom2");
dom = get_next_domain(dom, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "sub2a");
dom = get_next_domain(dom, gnd_flags);
assert_non_null(dom);
assert_string_equal(dom->name, "sub2b");
dom = get_next_domain(dom, gnd_flags);
assert_null(dom);
}
struct name_init_test_ctx {
struct confdb_ctx *confdb;
};
#define GLOBAL_FULL_NAME_FORMAT "%1$s@%2$s"
#define GLOBAL_RE_EXPRESSION "(?P<name>[^@]+)@?(?P<domain>[^@]*$)"
#define TEST_DOMAIN_NAME "test.dom"
#define DOMAIN_FULL_NAME_FORMAT "%3$s\\%1$s"
#define DOMAIN_RE_EXPRESSION "(((?P<domain>[^\\\\]+)\\\\(?P<name>.+$))|" \
"((?P<name>[^@]+)@(?P<domain>.+$))|" \
"(^(?P<name>[^@\\\\]+)$))"
static int confdb_test_setup(void **state)
{
struct name_init_test_ctx *test_ctx;
char *conf_db = NULL;
char *dompath = NULL;
int ret;
const char *val[2];
val[1] = NULL;
assert_true(leak_check_setup());
test_ctx = talloc_zero(global_talloc_context, struct name_init_test_ctx);
assert_non_null(test_ctx);
conf_db = talloc_asprintf(test_ctx, "%s/%s", TESTS_PATH, TEST_CONF_DB);
assert_non_null(conf_db);
ret = confdb_init(test_ctx, &test_ctx->confdb, conf_db);
assert_int_equal(ret, EOK);
talloc_free(conf_db);
val[0] = TEST_DOMAIN_NAME;
ret = confdb_add_param(test_ctx->confdb, true,
"config/sssd", "domains", val);
assert_int_equal(ret, EOK);
val[0] = GLOBAL_FULL_NAME_FORMAT;
ret = confdb_add_param(test_ctx->confdb, true,
"config/sssd", "full_name_format", val);
assert_int_equal(ret, EOK);
val[0] = GLOBAL_RE_EXPRESSION;
ret = confdb_add_param(test_ctx->confdb, true,
"config/sssd", "re_expression", val);
assert_int_equal(ret, EOK);
dompath = talloc_asprintf(test_ctx, "config/domain/%s", TEST_DOMAIN_NAME);
assert_non_null(dompath);
val[0] = "ldap";
ret = confdb_add_param(test_ctx->confdb, true,
dompath, "id_provider", val);
assert_int_equal(ret, EOK);
val[0] = DOMAIN_FULL_NAME_FORMAT;
ret = confdb_add_param(test_ctx->confdb, true,
dompath, "full_name_format", val);
assert_int_equal(ret, EOK);
val[0] = DOMAIN_RE_EXPRESSION;
ret = confdb_add_param(test_ctx->confdb, true,
dompath, "re_expression", val);
assert_int_equal(ret, EOK);
talloc_free(dompath);
check_leaks_push(test_ctx);
*state = test_ctx;
return 0;
}
static int confdb_test_teardown(void **state)
{
struct name_init_test_ctx *test_ctx;
test_ctx = talloc_get_type(*state, struct name_init_test_ctx);
assert_true(check_leaks_pop(test_ctx) == true);
talloc_free(test_ctx);
assert_true(leak_check_teardown());
return 0;
}
void test_sss_names_init(void **state)
{
struct name_init_test_ctx *test_ctx;
struct sss_names_ctx *names_ctx;
int ret;
test_ctx = talloc_get_type(*state, struct name_init_test_ctx);
ret = sss_names_init(test_ctx, test_ctx->confdb, NULL, &names_ctx);
assert_int_equal(ret, EOK);
assert_non_null(names_ctx);
assert_string_equal(names_ctx->re_pattern, GLOBAL_RE_EXPRESSION);
assert_string_equal(names_ctx->fq_fmt, GLOBAL_FULL_NAME_FORMAT);
talloc_free(names_ctx);
ret = sss_names_init(test_ctx, test_ctx->confdb, TEST_DOMAIN_NAME,
&names_ctx);
assert_int_equal(ret, EOK);
assert_non_null(names_ctx);
assert_string_equal(names_ctx->re_pattern, DOMAIN_RE_EXPRESSION);
assert_string_equal(names_ctx->fq_fmt, DOMAIN_FULL_NAME_FORMAT);
talloc_free(names_ctx);
}
void test_well_known_sid_to_name(void **state)
{
int ret;
const char *name;
const char *dom;
ret = well_known_sid_to_name(NULL, NULL, NULL);
assert_int_equal(ret, EINVAL);
ret = well_known_sid_to_name("abc", &dom, &name);
assert_int_equal(ret, EINVAL);
ret = well_known_sid_to_name("S-1", &dom, &name);
assert_int_equal(ret, EINVAL);
ret = well_known_sid_to_name("S-1-", &dom, &name);
assert_int_equal(ret, EINVAL);
ret = well_known_sid_to_name("S-1-0", &dom, &name);
assert_int_equal(ret, EINVAL);
ret = well_known_sid_to_name("S-1-0-", &dom, &name);
assert_int_equal(ret, EINVAL);
ret = well_known_sid_to_name("S-1-0-0", &dom, &name);
assert_int_equal(ret, EOK);
assert_string_equal(dom, "NULL AUTHORITY");
assert_string_equal(name, "NULL SID");
ret = well_known_sid_to_name("S-1-0-0-", &dom, &name);
assert_int_equal(ret, EINVAL);
ret = well_known_sid_to_name("S-1-5", &dom, &name);
assert_int_equal(ret, EINVAL);
ret = well_known_sid_to_name("S-1-5-", &dom, &name);
assert_int_equal(ret, EINVAL);
ret = well_known_sid_to_name("S-1-5-6", &dom, &name);
assert_int_equal(ret, EOK);
assert_string_equal(dom, "NT AUTHORITY");
assert_string_equal(name, "SERVICE");
ret = well_known_sid_to_name("S-1-5-6-", &dom, &name);
assert_int_equal(ret, EINVAL);
ret = well_known_sid_to_name("S-1-5-21", &dom, &name);
assert_int_equal(ret, EINVAL);
ret = well_known_sid_to_name("S-1-5-21-", &dom, &name);
assert_int_equal(ret, ENOENT);
ret = well_known_sid_to_name("S-1-5-21-abc", &dom, &name);
assert_int_equal(ret, ENOENT);
ret = well_known_sid_to_name("S-1-5-32", &dom, &name);
assert_int_equal(ret, EINVAL);
ret = well_known_sid_to_name("S-1-5-32-", &dom, &name);
assert_int_equal(ret, EINVAL);
ret = well_known_sid_to_name("S-1-5-32-551", &dom, &name);
assert_int_equal(ret, EOK);
assert_string_equal(dom, "BUILTIN");
assert_string_equal(name, "Backup Operators");
ret = well_known_sid_to_name("S-1-5-32-551-", &dom, &name);
assert_int_equal(ret, EINVAL);
}
void test_name_to_well_known_sid(void **state)
{
int ret;
const char *sid;
ret = name_to_well_known_sid(NULL, NULL, NULL);
assert_int_equal(ret, EINVAL);
ret = name_to_well_known_sid("abc", "def", &sid);
assert_int_equal(ret, ENOENT);
ret = name_to_well_known_sid("", "def", &sid);
assert_int_equal(ret, ENOENT);
ret = name_to_well_known_sid("BUILTIN", "def", &sid);
assert_int_equal(ret, EINVAL);
ret = name_to_well_known_sid("NT AUTHORITY", "def", &sid);
assert_int_equal(ret, EINVAL);
ret = name_to_well_known_sid("LOCAL AUTHORITY", "LOCAL", &sid);
assert_int_equal(ret, EOK);
assert_string_equal(sid, "S-1-2-0");
ret = name_to_well_known_sid(NULL, "LOCAL", &sid);
assert_int_equal(ret, EINVAL);
ret = name_to_well_known_sid("BUILTIN", "Cryptographic Operators", &sid);
assert_int_equal(ret, EOK);
assert_string_equal(sid, "S-1-5-32-569");
ret = name_to_well_known_sid("NT AUTHORITY", "DIALUP", &sid);
assert_int_equal(ret, EOK);
assert_string_equal(sid, "S-1-5-1");
}
#define TEST_SANITIZE_INPUT "TestUser@Test.Domain"
#define TEST_SANITIZE_LC_INPUT "testuser@test.domain"
void test_sss_filter_sanitize_for_dom(void **state)
{
struct dom_list_test_ctx *test_ctx;
int ret;
char *sanitized;
char *lc_sanitized;
struct sss_domain_info *dom;
test_ctx = talloc_get_type(*state, struct dom_list_test_ctx);
dom = test_ctx->dom_list;
dom->case_sensitive = true;
ret = sss_filter_sanitize_for_dom(test_ctx, TEST_SANITIZE_INPUT, dom,
&sanitized, &lc_sanitized);
assert_int_equal(ret, EOK);
assert_string_equal(sanitized, TEST_SANITIZE_INPUT);
assert_string_equal(lc_sanitized, TEST_SANITIZE_INPUT);
talloc_free(sanitized);
talloc_free(lc_sanitized);
dom->case_sensitive = false;
ret = sss_filter_sanitize_for_dom(test_ctx, TEST_SANITIZE_INPUT, dom,
&sanitized, &lc_sanitized);
assert_int_equal(ret, EOK);
assert_string_equal(sanitized, TEST_SANITIZE_INPUT);
assert_string_equal(lc_sanitized, TEST_SANITIZE_LC_INPUT);
talloc_free(sanitized);
talloc_free(lc_sanitized);
}
void check_expanded_value(TALLOC_CTX *tmp_ctx,
struct sss_nss_homedir_ctx *homedir_ctx,
const char *template, const char *exp_val)
{
char *homedir;
homedir = expand_homedir_template(tmp_ctx, template, false, homedir_ctx);
if (exp_val != NULL) {
assert_string_equal(homedir, exp_val);
} else {
assert_null(homedir);
}
talloc_free(homedir);
}
static int setup_homedir_ctx(void **state)
{
struct sss_nss_homedir_ctx *homedir_ctx;
assert_true(leak_check_setup());
homedir_ctx= talloc_zero(global_talloc_context,
struct sss_nss_homedir_ctx);
assert_non_null(homedir_ctx);
homedir_ctx->username = sss_create_internal_fqname(homedir_ctx,
USERNAME, DOMAIN);
if (homedir_ctx->username == NULL) {
talloc_free(homedir_ctx);
return 1;
}
homedir_ctx->uid = UID;
homedir_ctx->original = ORIGINAL_HOME;
homedir_ctx->domain = DOMAIN;
homedir_ctx->flatname = FLATNAME;
homedir_ctx->config_homedir_substr = HOMEDIR_SUBSTR;
check_leaks_push(homedir_ctx);
*state = homedir_ctx;
return 0;
}
static int teardown_homedir_ctx(void **state)
{
struct sss_nss_homedir_ctx *homedir_ctx = talloc_get_type(*state,
struct sss_nss_homedir_ctx);
if (homedir_ctx == NULL) {
DEBUG(SSSDBG_CRIT_FAILURE, "Type mismatch\n");
return 1;
}
assert_true(check_leaks_pop(homedir_ctx) == true);
talloc_free(homedir_ctx);
assert_true(leak_check_teardown());
return 0;
}
void test_expand_homedir_template_NULL(void **state)
{
TALLOC_CTX *tmp_ctx;
char *homedir;
struct sss_nss_homedir_ctx *homedir_ctx;
/* following format strings requires data in homedir_ctx */
const char *format_strings[] = { "%u", "%U", "%d", "%f", "%F", "%H",
NULL };
int i;
tmp_ctx = talloc_new(NULL);
assert_non_null(tmp_ctx);
homedir_ctx = talloc_zero(tmp_ctx, struct sss_nss_homedir_ctx);
assert_non_null(homedir_ctx);
homedir = expand_homedir_template(tmp_ctx, NULL, false, NULL);
assert_null(homedir);
homedir = expand_homedir_template(tmp_ctx, "template", false, NULL);
assert_null(homedir);
/* missing data in homedir_ctx */
check_expanded_value(tmp_ctx, homedir_ctx, "%%", "%");
check_expanded_value(tmp_ctx, homedir_ctx, "%o", "");
for (i = 0; format_strings[i] != NULL; ++i) {
check_expanded_value(tmp_ctx, homedir_ctx, format_strings[i], NULL);
}
/* flatname requires domain and username */
homedir_ctx->username = DUMMY;
check_expanded_value(tmp_ctx, homedir_ctx, "%f", NULL);
homedir_ctx->username = NULL;
homedir_ctx->domain = DUMMY;
check_expanded_value(tmp_ctx, homedir_ctx, "%f", NULL);
/* test unknown format string */
check_expanded_value(tmp_ctx, homedir_ctx, "%x", NULL);
/* test malformed format string */
check_expanded_value(tmp_ctx, homedir_ctx, "%", NULL);
talloc_free(tmp_ctx);
}
void test_expand_homedir_template(void **state)
{
struct sss_nss_homedir_ctx *homedir_ctx = talloc_get_type(*state,
struct sss_nss_homedir_ctx);
TALLOC_CTX *tmp_ctx;
tmp_ctx = talloc_new(NULL);
assert_non_null(tmp_ctx);
/* string without template */
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY, DUMMY);
check_expanded_value(tmp_ctx, homedir_ctx, "%u", USERNAME);
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY"%u", DUMMY USERNAME);
check_expanded_value(tmp_ctx, homedir_ctx, "%u"DUMMY, USERNAME DUMMY);
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY"%u"DUMMY2,
DUMMY USERNAME DUMMY2);
check_expanded_value(tmp_ctx, homedir_ctx, "%U", STR(UID));
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY"%U", DUMMY STR(UID));
check_expanded_value(tmp_ctx, homedir_ctx, "%U"DUMMY, STR(UID) DUMMY);
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY"%U"DUMMY2,
DUMMY STR(UID) DUMMY2);
check_expanded_value(tmp_ctx, homedir_ctx, "%d", DOMAIN);
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY"%d", DUMMY DOMAIN);
check_expanded_value(tmp_ctx, homedir_ctx, "%d"DUMMY, DOMAIN DUMMY);
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY"%d"DUMMY2,
DUMMY DOMAIN DUMMY2);
check_expanded_value(tmp_ctx, homedir_ctx, "%f", USERNAME"@"DOMAIN);
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY"%f",
DUMMY USERNAME"@"DOMAIN);
check_expanded_value(tmp_ctx, homedir_ctx, "%f"DUMMY,
USERNAME"@"DOMAIN DUMMY);
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY"%f"DUMMY2,
DUMMY USERNAME"@"DOMAIN DUMMY2);
check_expanded_value(tmp_ctx, homedir_ctx, "%o", ORIGINAL_HOME);
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY"%o", DUMMY ORIGINAL_HOME);
check_expanded_value(tmp_ctx, homedir_ctx, "%o"DUMMY, ORIGINAL_HOME DUMMY);
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY"%o"DUMMY2,
DUMMY ORIGINAL_HOME DUMMY2);
check_expanded_value(tmp_ctx, homedir_ctx, "%F", FLATNAME);
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY"%F", DUMMY FLATNAME);
check_expanded_value(tmp_ctx, homedir_ctx, "%F"DUMMY, FLATNAME DUMMY);
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY"%F"DUMMY2,
DUMMY FLATNAME DUMMY2);
check_expanded_value(tmp_ctx, homedir_ctx, "%H", HOMEDIR_SUBSTR);
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY"%H",
DUMMY HOMEDIR_SUBSTR);
check_expanded_value(tmp_ctx, homedir_ctx, "%H"DUMMY,
HOMEDIR_SUBSTR DUMMY);
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY"%H"DUMMY2,
DUMMY HOMEDIR_SUBSTR DUMMY2);
check_expanded_value(tmp_ctx, homedir_ctx, "%%", "%");
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY"%%", DUMMY"%");
check_expanded_value(tmp_ctx, homedir_ctx, "%%"DUMMY, "%"DUMMY);
check_expanded_value(tmp_ctx, homedir_ctx, DUMMY"%%"DUMMY2,
DUMMY"%"DUMMY2);
/* test all format strings */
check_expanded_value(tmp_ctx, homedir_ctx,
DUMMY"/%u/%U/%d/%f/%o/%F/%%/%H/"DUMMY2,
DUMMY"/"USERNAME"/" STR(UID) "/"DOMAIN"/"
USERNAME"@"DOMAIN"/"ORIGINAL_HOME"/"FLATNAME"/%/"
HOMEDIR_SUBSTR"/"DUMMY2);
talloc_free(tmp_ctx);
}
static int setup_leak_tests(void **state)
{
assert_true(leak_check_setup());
return 0;
}
static int teardown_leak_tests(void **state)
{
assert_true(leak_check_teardown());
return 0;
}
void test_add_strings_lists(void **state)
{
const char *l1[] = {"a", "b", "c", NULL};
const char *l2[] = {"1", "2", "3", NULL};
char **res;
int ret;
size_t c;
size_t d;
ret = add_strings_lists(global_talloc_context, NULL, NULL, true, &res);
assert_int_equal(ret, EOK);
assert_non_null(res);
assert_null(res[0]);
talloc_free(res);
ret = add_strings_lists(global_talloc_context, NULL, NULL, false, &res);
assert_int_equal(ret, EOK);
assert_non_null(res);
assert_null(res[0]);
talloc_free(res);
ret = add_strings_lists(global_talloc_context, l1, NULL, false, &res);
assert_int_equal(ret, EOK);
assert_non_null(res);
for (c = 0; l1[c] != NULL; c++) {
/* 'copy_strings' is 'false', pointers must be equal */
assert_int_equal(memcmp(&l1[c], &res[c], sizeof(char *)), 0);
}
assert_null(res[c]);
talloc_free(res);
ret = add_strings_lists(global_talloc_context, l1, NULL, true, &res);
assert_int_equal(ret, EOK);
assert_non_null(res);
for (c = 0; l1[c] != NULL; c++) {
/* 'copy_strings' is 'true', pointers must be different, but strings
* must be equal */
assert_int_not_equal(memcmp(&l1[c], &res[c], sizeof(char *)), 0);
assert_string_equal(l1[c], res[c]);
}
assert_null(res[c]);
talloc_free(res);
ret = add_strings_lists(global_talloc_context, NULL, l1, false, &res);
assert_int_equal(ret, EOK);
assert_non_null(res);
for (c = 0; l1[c] != NULL; c++) {
/* 'copy_strings' is 'false', pointers must be equal */
assert_int_equal(memcmp(&l1[c], &res[c], sizeof(char *)), 0);
}
assert_null(res[c]);
talloc_free(res);
ret = add_strings_lists(global_talloc_context, NULL, l1, true, &res);
assert_int_equal(ret, EOK);
assert_non_null(res);
for (c = 0; l1[c] != NULL; c++) {
/* 'copy_strings' is 'true', pointers must be different, but strings
* must be equal */
assert_int_not_equal(memcmp(&l1[c], &res[c], sizeof(char *)), 0);
assert_string_equal(l1[c], res[c]);
}
assert_null(res[c]);
talloc_free(res);
ret = add_strings_lists(global_talloc_context, l1, l2, false, &res);
assert_int_equal(ret, EOK);
assert_non_null(res);
for (c = 0; l1[c] != NULL; c++) {
/* 'copy_strings' is 'false', pointers must be equal */
assert_int_equal(memcmp(&l1[c], &res[c], sizeof(char *)), 0);
}
for (d = 0; l2[d] != NULL; d++) {
assert_int_equal(memcmp(&l2[d], &res[c+d], sizeof(char *)), 0);
}
assert_null(res[c+d]);
talloc_free(res);
ret = add_strings_lists(global_talloc_context, l1, l2, true, &res);
assert_int_equal(ret, EOK);
assert_non_null(res);
for (c = 0; l1[c] != NULL; c++) {
/* 'copy_strings' is 'true', pointers must be different, but strings
* must be equal */
assert_int_not_equal(memcmp(&l1[c], &res[c], sizeof(char *)), 0);
assert_string_equal(l1[c], res[c]);
}
for (d = 0; l2[d] != NULL; d++) {
assert_int_not_equal(memcmp(&l2[d], &res[c+d], sizeof(char *)), 0);
assert_string_equal(l2[d], res[c+d]);
}
assert_null(res[c+d]);
talloc_free(res);
}
void test_sss_write_krb5_conf_snippet(void **state)
{
int ret;
char buf[PATH_MAX];
char *cwd;
char *path;
char *file;
char *file_krb5_libdefaults;
ret = sss_write_krb5_conf_snippet(NULL, false);
assert_int_equal(ret, EINVAL);
ret = sss_write_krb5_conf_snippet("abc", false);
assert_int_equal(ret, EINVAL);
ret = sss_write_krb5_conf_snippet("", false);
assert_int_equal(ret, EOK);
ret = sss_write_krb5_conf_snippet("none", false);
assert_int_equal(ret, EOK);
cwd = getcwd(buf, PATH_MAX);
assert_non_null(cwd);
ret = asprintf(&path, "%s/%s", cwd, TESTS_PATH);
assert_true(ret > 0);
ret = asprintf(&file, "%s/%s/localauth_plugin", cwd, TESTS_PATH);
assert_true(ret > 0);
ret = asprintf(&file_krb5_libdefaults,
"%s/%s/krb5_libdefaults", cwd, TESTS_PATH);
assert_true(ret > 0);
ret = sss_write_krb5_conf_snippet(path, true);
assert_int_equal(ret, EOK);
/* Check if writing a second time will work as well */
ret = sss_write_krb5_conf_snippet(path, true);
assert_int_equal(ret, EOK);
#ifdef HAVE_KRB5_LOCALAUTH_PLUGIN
ret = unlink(file);
assert_int_equal(ret, EOK);
#endif
ret = unlink(file_krb5_libdefaults);
assert_int_equal(ret, EOK);
free(file);
free(file_krb5_libdefaults);
free(path);
}
struct unique_file_test_ctx {
char *filename;
};
static int unique_file_test_setup(void **state)
{
struct unique_file_test_ctx *test_ctx;
assert_true(leak_check_setup());
test_ctx = talloc_zero(global_talloc_context, struct unique_file_test_ctx);
assert_non_null(test_ctx);
test_ctx->filename = talloc_strdup(test_ctx, "test_unique_file_XXXXXX");
assert_non_null(test_ctx);
*state = test_ctx;
return 0;
}
static int unique_file_test_teardown(void **state)
{
struct unique_file_test_ctx *test_ctx;
errno_t ret;
test_ctx = talloc_get_type(*state, struct unique_file_test_ctx);
errno = 0;
ret = unlink(test_ctx->filename);
if (ret != 0 && errno != ENOENT) {
fail();
}
talloc_free(test_ctx);
assert_true(leak_check_teardown());
return 0;
}
static void assert_destructor(TALLOC_CTX *owner,
struct unique_file_test_ctx *test_ctx)
{
int fd;
errno_t ret;
char *check_filename;
/* Test that the destructor works */
if (owner == NULL) {
return;
}
check_filename = talloc_strdup(test_ctx, test_ctx->filename);
assert_non_null(check_filename);
talloc_free(owner);
ret = check_and_open_readonly(test_ctx->filename, &fd,
geteuid(), getegid(),
(S_IRUSR | S_IWUSR | S_IFREG), 0);
close(fd);
assert_int_not_equal(ret, EOK);
}
static void sss_unique_file_test(struct unique_file_test_ctx *test_ctx,
bool test_destructor)
{
int fd;
errno_t ret;
struct stat sb;
TALLOC_CTX *owner = NULL;
if (test_destructor) {
owner = talloc_new(test_ctx);
assert_non_null(owner);
}
fd = sss_unique_file(owner, test_ctx->filename, &ret);
assert_int_not_equal(fd, -1);
assert_int_equal(ret, EOK);
ret = check_fd(fd, geteuid(), getegid(),
(S_IRUSR | S_IWUSR | S_IFREG), 0, &sb);
close(fd);
assert_int_equal(ret, EOK);
assert_destructor(owner, test_ctx);
}
static void test_sss_unique_file(void **state)
{
struct unique_file_test_ctx *test_ctx;
test_ctx = talloc_get_type(*state, struct unique_file_test_ctx);
sss_unique_file_test(test_ctx, false);
}
static void test_sss_unique_file_destruct(void **state)
{
struct unique_file_test_ctx *test_ctx;
test_ctx = talloc_get_type(*state, struct unique_file_test_ctx);
sss_unique_file_test(test_ctx, true);
}
static void test_sss_unique_file_neg(void **state)
{
int fd;
errno_t ret;
fd = sss_unique_file(NULL, discard_const("badpattern"), &ret);
assert_int_equal(fd, -1);
assert_int_equal(ret, EINVAL);
}
static void sss_unique_filename_test(struct unique_file_test_ctx *test_ctx,
bool test_destructor)
{
int fd;
errno_t ret;
char *tmp_filename;
TALLOC_CTX *owner = NULL;
tmp_filename = talloc_strdup(test_ctx, test_ctx->filename);
assert_non_null(tmp_filename);
if (test_destructor) {
owner = talloc_new(test_ctx);
assert_non_null(owner);
}
ret = sss_unique_filename(owner, test_ctx->filename);
assert_int_equal(ret, EOK);
assert_int_equal(strncmp(test_ctx->filename,
tmp_filename,
strlen(tmp_filename) - sizeof("XXXXXX")),
0);
ret = check_and_open_readonly(test_ctx->filename, &fd,
geteuid(), getegid(),
(S_IRUSR | S_IWUSR | S_IFREG), 0);
close(fd);
assert_int_equal(ret, EOK);
assert_destructor(owner, test_ctx);
}
static void test_sss_unique_filename(void **state)
{
struct unique_file_test_ctx *test_ctx;
test_ctx = talloc_get_type(*state, struct unique_file_test_ctx);
sss_unique_filename_test(test_ctx, false);
}
static void test_sss_unique_filename_destruct(void **state)
{
struct unique_file_test_ctx *test_ctx;
test_ctx = talloc_get_type(*state, struct unique_file_test_ctx);
sss_unique_filename_test(test_ctx, true);
}
static void test_parse_cert_verify_opts(void **state)
{
int ret;
struct cert_verify_opts *cv_opts;
ret = parse_cert_verify_opts(global_talloc_context, NULL, &cv_opts);
assert_int_equal(ret, EOK);
assert_true(cv_opts->do_verification);
assert_true(cv_opts->do_ocsp);
assert_null(cv_opts->ocsp_default_responder);
assert_null(cv_opts->ocsp_default_responder_signing_cert);
talloc_free(cv_opts);
ret = parse_cert_verify_opts(global_talloc_context, "wedfkwefjk", &cv_opts);
assert_int_equal(ret, EOK);
assert_true(cv_opts->do_verification);
assert_true(cv_opts->do_ocsp);
assert_null(cv_opts->ocsp_default_responder);
assert_null(cv_opts->ocsp_default_responder_signing_cert);
talloc_free(cv_opts);
ret = parse_cert_verify_opts(global_talloc_context, "no_ocsp", &cv_opts);
assert_int_equal(ret, EOK);
assert_true(cv_opts->do_verification);
assert_false(cv_opts->do_ocsp);
assert_null(cv_opts->ocsp_default_responder);
assert_null(cv_opts->ocsp_default_responder_signing_cert);
talloc_free(cv_opts);
ret = parse_cert_verify_opts(global_talloc_context, "no_verification",
&cv_opts);
assert_int_equal(ret, EOK);
assert_false(cv_opts->do_verification);
assert_true(cv_opts->do_ocsp);
assert_null(cv_opts->ocsp_default_responder);
assert_null(cv_opts->ocsp_default_responder_signing_cert);
talloc_free(cv_opts);
ret = parse_cert_verify_opts(global_talloc_context,
"no_ocsp,no_verification", &cv_opts);
assert_int_equal(ret, EOK);
assert_false(cv_opts->do_verification);
assert_false(cv_opts->do_ocsp);
assert_null(cv_opts->ocsp_default_responder);
assert_null(cv_opts->ocsp_default_responder_signing_cert);
talloc_free(cv_opts);
ret = parse_cert_verify_opts(global_talloc_context,
"ocsp_default_responder=", &cv_opts);
assert_int_equal(ret, EINVAL);
ret = parse_cert_verify_opts(global_talloc_context,
"ocsp_default_responder_signing_cert=",
&cv_opts);
assert_int_equal(ret, EINVAL);
ret = parse_cert_verify_opts(global_talloc_context,
"ocsp_default_responder=abc", &cv_opts);
assert_int_equal(ret, EINVAL);
ret = parse_cert_verify_opts(global_talloc_context,
"ocsp_default_responder_signing_cert=def",
&cv_opts);
assert_int_equal(ret, EINVAL);
ret = parse_cert_verify_opts(global_talloc_context,
"ocsp_default_responder=abc,"
"ocsp_default_responder_signing_cert=def",
&cv_opts);
assert_int_equal(ret, EOK);
assert_true(cv_opts->do_verification);
assert_true(cv_opts->do_ocsp);
assert_string_equal(cv_opts->ocsp_default_responder, "abc");
assert_string_equal(cv_opts->ocsp_default_responder_signing_cert, "def");
talloc_free(cv_opts);
}
static void assert_parse_fqname(const char *fqname,
const char *exp_shortname,
const char *exp_domname)
{
errno_t ret;
char *shortname = NULL;
char *domname = NULL;
check_leaks_push(global_talloc_context);
ret = sss_parse_internal_fqname(global_talloc_context, fqname,
exp_shortname ? &shortname : NULL,
exp_domname ? &domname : NULL);
assert_int_equal(ret, EOK);
if (exp_shortname) {
assert_string_equal(shortname, exp_shortname);
}
if (exp_domname) {
assert_string_equal(domname, exp_domname);
}
talloc_free(shortname);
talloc_free(domname);
assert_true(check_leaks_pop(global_talloc_context) == true);
}
static void assert_fqname_unparseable(const char *fqname, errno_t retval)
{
errno_t ret;
char *shortname = NULL;
char *domname = NULL;
check_leaks_push(global_talloc_context);
ret = sss_parse_internal_fqname(global_talloc_context, fqname,
&shortname, &domname);
assert_int_equal(ret, retval);
assert_null(shortname);
assert_null(domname);
assert_true(check_leaks_pop(global_talloc_context) == true);
}
static void test_sss_parse_internal_fqname(void **state)
{
assert_parse_fqname("foo@bar", "foo", "bar");
assert_parse_fqname("foo@bar", NULL, "bar");
assert_parse_fqname("foo@bar", "foo", NULL);
assert_parse_fqname("foo@bar", NULL, NULL);
assert_parse_fqname("foo@bar@baz", "foo@bar", "baz");
assert_fqname_unparseable("foo", ERR_WRONG_NAME_FORMAT);
assert_fqname_unparseable("foo@", ERR_WRONG_NAME_FORMAT);
assert_fqname_unparseable("@", ERR_WRONG_NAME_FORMAT);
assert_fqname_unparseable("@bar", ERR_WRONG_NAME_FORMAT);
assert_fqname_unparseable(NULL, EINVAL);
}
static void test_sss_create_internal_fqname(void **state)
{
char *fqname = NULL;
check_leaks_push(global_talloc_context);
fqname = sss_create_internal_fqname(global_talloc_context, "foo", "bar");
assert_string_equal(fqname, "foo@bar");
talloc_zfree(fqname);
fqname = sss_create_internal_fqname(global_talloc_context, "foo", "BAR");
assert_string_equal(fqname, "foo@bar");
talloc_zfree(fqname);
fqname = sss_create_internal_fqname(global_talloc_context, "foo", NULL);
assert_null(fqname);
fqname = sss_create_internal_fqname(global_talloc_context, NULL, "bar");
assert_null(fqname);
fqname = sss_create_internal_fqname(global_talloc_context, NULL, NULL);
assert_null(fqname);
assert_true(check_leaks_pop(global_talloc_context) == true);
}
static void test_sss_create_internal_fqname_list(void **state)
{
char **fqlist = NULL;
const char *in_list1[] = { "aaa", "bbb", NULL };
check_leaks_push(global_talloc_context);
fqlist = sss_create_internal_fqname_list(global_talloc_context,
in_list1, "DOM");
assert_string_equal(fqlist[0], "aaa@dom");
assert_string_equal(fqlist[1], "bbb@dom");
assert_null(fqlist[2]);
talloc_zfree(fqlist);
fqlist = sss_create_internal_fqname_list(global_talloc_context,
in_list1, NULL);
assert_null(fqlist);
fqlist = sss_create_internal_fqname_list(global_talloc_context,
NULL, "DOM");
assert_null(fqlist);
fqlist = sss_create_internal_fqname_list(global_talloc_context,
NULL, NULL);
assert_null(fqlist);
assert_true(check_leaks_pop(global_talloc_context) == true);
}
static void test_sss_output_name(void **state)
{
char *outname;
char *fqname;
check_leaks_push(global_talloc_context);
fqname = sss_create_internal_fqname(global_talloc_context,
"Foo Bar", "DOM");
assert_non_null(fqname);
outname = sss_output_name(global_talloc_context, fqname, true, 0);
assert_non_null(outname);
assert_string_equal(outname, "Foo Bar");
talloc_zfree(outname);
outname = sss_output_name(global_talloc_context, fqname, false, 0);
assert_non_null(outname);
assert_string_equal(outname, "foo bar");
talloc_zfree(outname);
outname = sss_output_name(global_talloc_context, fqname, false, '-');
assert_non_null(outname);
assert_string_equal(outname, "foo-bar");
talloc_zfree(outname);
talloc_free(fqname);
assert_true(check_leaks_pop(global_talloc_context) == true);
}
int main(int argc, const char *argv[])
{
poptContext pc;
int opt;
int rv;
struct poptOption long_options[] = {
POPT_AUTOHELP
SSSD_DEBUG_OPTS
POPT_TABLEEND
};
const struct CMUnitTest tests[] = {
cmocka_unit_test_setup_teardown(test_find_domain_by_sid_null,
setup_dom_list, teardown_dom_list),
cmocka_unit_test_setup_teardown(test_find_domain_by_sid,
setup_dom_list, teardown_dom_list),
cmocka_unit_test_setup_teardown(test_find_domain_by_sid_missing_sid,
setup_dom_list, teardown_dom_list),
cmocka_unit_test_setup_teardown(test_find_domain_by_sid_disabled,
setup_dom_list, teardown_dom_list),
cmocka_unit_test_setup_teardown(test_find_domain_by_name_null,
setup_dom_list, teardown_dom_list),
cmocka_unit_test_setup_teardown(test_find_domain_by_name,
setup_dom_list, teardown_dom_list),
cmocka_unit_test_setup_teardown(test_find_domain_by_name_missing_flat_name,
setup_dom_list, teardown_dom_list),
cmocka_unit_test_setup_teardown(test_find_domain_by_name_disabled,
setup_dom_list, teardown_dom_list),
cmocka_unit_test_setup_teardown(test_sss_names_init,
confdb_test_setup,
confdb_test_teardown),
cmocka_unit_test_setup_teardown(test_get_next_domain,
setup_dom_tree, teardown_dom_tree),
cmocka_unit_test_setup_teardown(test_get_next_domain_descend,
setup_dom_tree, teardown_dom_tree),
cmocka_unit_test_setup_teardown(test_get_next_domain_disabled,
setup_dom_tree, teardown_dom_tree),
cmocka_unit_test_setup_teardown(test_get_next_domain_flags,
setup_dom_tree, teardown_dom_tree),
cmocka_unit_test(test_well_known_sid_to_name),
cmocka_unit_test(test_name_to_well_known_sid),
cmocka_unit_test_setup_teardown(test_sss_filter_sanitize_for_dom,
setup_dom_list,
teardown_dom_list),
cmocka_unit_test(test_expand_homedir_template_NULL),
cmocka_unit_test_setup_teardown(test_expand_homedir_template,
setup_homedir_ctx,
teardown_homedir_ctx),
cmocka_unit_test(test_textual_public_key),
cmocka_unit_test(test_replace_whitespaces),
cmocka_unit_test(test_reverse_replace_whitespaces),
cmocka_unit_test(test_guid_blob_to_string_buf),
cmocka_unit_test(test_get_last_x_chars),
cmocka_unit_test(test_concatenate_string_array),
cmocka_unit_test_setup_teardown(test_add_strings_lists,
setup_leak_tests,
teardown_leak_tests),
cmocka_unit_test(test_sss_write_krb5_conf_snippet),
cmocka_unit_test_setup_teardown(test_sss_unique_file,
unique_file_test_setup,
unique_file_test_teardown),
cmocka_unit_test_setup_teardown(test_sss_unique_file_destruct,
unique_file_test_setup,
unique_file_test_teardown),
cmocka_unit_test(test_sss_unique_file_neg),
cmocka_unit_test_setup_teardown(test_sss_unique_filename,
unique_file_test_setup,
unique_file_test_teardown),
cmocka_unit_test_setup_teardown(test_sss_unique_filename_destruct,
unique_file_test_setup,
unique_file_test_teardown),
cmocka_unit_test_setup_teardown(test_parse_cert_verify_opts,
setup_leak_tests,
teardown_leak_tests),
cmocka_unit_test_setup_teardown(test_sss_parse_internal_fqname,
setup_leak_tests,
teardown_leak_tests),
cmocka_unit_test_setup_teardown(test_sss_create_internal_fqname,
setup_leak_tests,
teardown_leak_tests),
cmocka_unit_test_setup_teardown(test_sss_create_internal_fqname_list,
setup_leak_tests,
teardown_leak_tests),
cmocka_unit_test_setup_teardown(test_sss_output_name,
setup_leak_tests,
teardown_leak_tests),
};
/* Set debug level to invalid value so we can deside if -d 0 was used. */
debug_level = SSSDBG_INVALID;
pc = poptGetContext(argv[0], argc, argv, long_options, 0);
while((opt = poptGetNextOpt(pc)) != -1) {
switch(opt) {
default:
fprintf(stderr, "\nInvalid option %s: %s\n\n",
poptBadOption(pc, 0), poptStrerror(opt));
poptPrintUsage(pc, stderr, 0);
return 1;
}
}
poptFreeContext(pc);
DEBUG_CLI_INIT(debug_level);
/* Even though normally the tests should clean up after themselves
* they might not after a failed run. Remove the old db to be sure */
tests_set_cwd();
test_dom_suite_cleanup(TESTS_PATH, TEST_CONF_DB, TEST_DOM_NAME);
test_dom_suite_setup(TESTS_PATH);
rv = cmocka_run_group_tests(tests, NULL, NULL);
if (rv == 0) {
test_dom_suite_cleanup(TESTS_PATH, TEST_CONF_DB, TEST_DOM_NAME);
}
return rv;
}