source4/dsdb/samdb/ldb_modules/tests/test_group_audit.c

   1 /*
   2    Unit tests for the dsdb group auditing code in group_audit.c
   3
   4    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2018
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include <stdarg.h>
  21 #include <stddef.h>
  22 #include <setjmp.h>
  23 #include <unistd.h>
  24 #include <cmocka.h>
  25
  26 int ldb_group_audit_log_module_init(const char *version);
  27 #include "../group_audit.c"
  28
  29 #include "lib/ldb/include/ldb_private.h"
  30 #include <regex.h>
  31
  32 /*
  33  * Mock version of dsdb_search_one
  34  */
  35 struct ldb_dn *g_basedn = NULL;
  36 enum ldb_scope g_scope;
  37 const char * const *g_attrs = NULL;
  38 uint32_t g_dsdb_flags;
  39 const char *g_exp_fmt;
  40 const char *g_dn = NULL;
  41 int g_status = LDB_SUCCESS;
  42
  43 int dsdb_search_one(struct ldb_context *ldb,
  44                     TALLOC_CTX *mem_ctx,
  45                     struct ldb_message **msg,
  46                     struct ldb_dn *basedn,
  47                     enum ldb_scope scope,
  48                     const char * const *attrs,
  49                     uint32_t dsdb_flags,
  50                     const char *exp_fmt, ...) _PRINTF_ATTRIBUTE(8, 9)
  51 {
  52         struct ldb_dn *dn = ldb_dn_new(mem_ctx, ldb, g_dn);
  53         struct ldb_message *m = talloc_zero(mem_ctx, struct ldb_message);
  54         m->dn = dn;
  55         *msg = m;
  56
  57         g_basedn = basedn;
  58         g_scope = scope;
  59         g_attrs = attrs;
  60         g_dsdb_flags = dsdb_flags;
  61         g_exp_fmt = exp_fmt;
  62
  63         return g_status;
  64 }
  65
  66 /*
  67  * Mock version of audit_log_json
  68  */
  69
  70 #define MAX_EXPECTED_MESSAGES 16
  71 static struct json_object messages[MAX_EXPECTED_MESSAGES];
  72 static size_t messages_sent = 0;
  73
  74 void audit_message_send(
  75         struct imessaging_context *msg_ctx,
  76         const char *server_name,
  77         uint32_t message_type,
  78         struct json_object *message)
  79 {
  80         messages[messages_sent].root = json_deep_copy(message->root);
  81         messages[messages_sent].valid = message->valid;
  82         messages_sent++;
  83 }
  84
  85 #define check_group_change_message(m, u, a)\
  86         _check_group_change_message(m, u, a, __FILE__, __LINE__);
  87 /*
  88  * declare the internal cmocka cm_print_error so that we can output messages
  89  * in sub unit format
  90  */
  91 void cm_print_error(const char * const format, ...);
  92
  93 /*
  94  * Validate a group change JSON audit message
  95  *
  96  * It should contain 3 elements.
  97  * Have a type of "groupChange"
  98  * Have a groupChange element
  99  *
 100  * The group change element should have 10 elements.
 101  *
 102  * There should be a user element matching the expected value
 103  * There should be an action matching the expected value
 104  */
 105 static void _check_group_change_message(
 106         const int message,
 107         const char *user,
 108         const char *action,
 109         const char *file,
 110         const int line)
 111 {
 112         struct json_object json;
 113         json_t *audit = NULL;
 114         json_t *v = NULL;
 115         const char* value;
 116         json = messages[message];
 117
 118         /*
 119          * Validate the root JSON element
 120          * check the number of elements
 121          */
 122         if (json_object_size(json.root) != 3) {
 123                 cm_print_error(
 124                     "Unexpected number of elements in root %zu != %d\n",
 125                     json_object_size(json.root),
 126                     3);
 127                 _fail(file, line);
 128         }
 129
 130         /*
 131          * Check the type element
 132          */
 133         v = json_object_get(json.root, "type");
 134         if (v == NULL) {
 135                 cm_print_error( "No \"type\" element\n");
 136                 _fail(file, line);
 137         }
 138
 139         value = json_string_value(v);
 140         if (strncmp("groupChange", value, strlen("groupChange") != 0)) {
 141                 cm_print_error(
 142                     "Unexpected type \"%s\" != \"groupChange\"\n",
 143                     value);
 144                 _fail(file, line);
 145         }
 146
 147
 148         audit = json_object_get(json.root, "groupChange");
 149         if (audit == NULL) {
 150                 cm_print_error("No groupChange element\n");
 151                 _fail(file, line);
 152         }
 153
 154         /*
 155          * Validate the groupChange element
 156          */
 157         if (json_object_size(audit) != 10) {
 158                 cm_print_error(
 159                     "Unexpected number of elements in groupChange "
 160                     "%zu != %d\n",
 161                     json_object_size(audit),
 162                     10);
 163                 _fail(file, line);
 164         }
 165         /*
 166          * Validate the user element
 167          */
 168         v = json_object_get(audit, "user");
 169         if (v == NULL) {
 170                 cm_print_error( "No user element\n");
 171                 _fail(file, line);
 172         }
 173
 174         value = json_string_value(v);
 175         if (strncmp(user, value, strlen(user) != 0)) {
 176                 cm_print_error(
 177                     "Unexpected user name \"%s\" != \"%s\"\n",
 178                     value,
 179                     user);
 180                 _fail(file, line);
 181         }
 182
 183         /*
 184          * Validate the action element
 185          */
 186         v = json_object_get(audit, "action");
 187         if (v == NULL) {
 188                 cm_print_error( "No action element\n");
 189                 _fail(file, line);
 190         }
 191
 192         value = json_string_value(v);
 193         if (strncmp(action, value, strlen(action) != 0)) {
 194                 print_error(
 195                     "Unexpected action \"%s\" != \"%s\"\n",
 196                     value,
 197                     action);
 198                 _fail(file, line);
 199         }
 200 }
 201
 202 #define check_timestamp(b, t)\
 203         _check_timestamp(b, t, __FILE__, __LINE__);
 204 /*
 205  * Test helper to check ISO 8601 timestamps for validity
 206  */
 207 static void _check_timestamp(
 208         time_t before,
 209         const char *timestamp,
 210         const char *file,
 211         const int line)
 212 {
 213         int rc;
 214         int usec, tz;
 215         char c[2];
 216         struct tm tm;
 217         time_t after;
 218         time_t actual;
 219
 220
 221         after = time(NULL);
 222
 223         /*
 224          * Convert the ISO 8601 timestamp into a time_t
 225          * Note for convenience we ignore the value of the microsecond
 226          * part of the time stamp.
 227          */
 228         rc = sscanf(
 229                 timestamp,
 230                 "%4d-%2d-%2dT%2d:%2d:%2d.%6d%1c%4d",
 231                 &tm.tm_year,
 232                 &tm.tm_mon,
 233                 &tm.tm_mday,
 234                 &tm.tm_hour,
 235                 &tm.tm_min,
 236                 &tm.tm_sec,
 237                 &usec,
 238                 c,
 239                 &tz);
 240         assert_int_equal(9, rc);
 241         tm.tm_year = tm.tm_year - 1900;
 242         tm.tm_mon = tm.tm_mon - 1;
 243         tm.tm_isdst = -1;
 244         actual = mktime(&tm);
 245
 246         /*
 247          * The time stamp should be before <= actual <= after
 248          */
 249         if (difftime(actual, before) < 0) {
 250                 char buffer[40];
 251                 strftime(buffer,
 252                          sizeof(buffer)-1,
 253                          "%Y-%m-%dT%T",
 254                          localtime(&before));
 255                 cm_print_error(
 256                     "time stamp \"%s\" is before start time \"%s\"\n",
 257                     timestamp,
 258                     buffer);
 259                 _fail(file, line);
 260         }
 261         if (difftime(after, actual) < 0) {
 262                 char buffer[40];
 263                 strftime(buffer,
 264                          sizeof(buffer)-1,
 265                          "%Y-%m-%dT%T",
 266                          localtime(&after));
 267                 cm_print_error(
 268                     "time stamp \"%s\" is after finish time \"%s\"\n",
 269                     timestamp,
 270                     buffer);
 271                 _fail(file, line);
 272         }
 273 }
 274
 275 #define check_version(v, m, n)\
 276         _check_version(v, m, n, __FILE__, __LINE__);
 277 /*
 278  * Test helper to validate a version object.
 279  */
 280 static void _check_version(
 281         struct json_t *version,
 282         int major,
 283         int minor,
 284         const char* file,
 285         const int line)
 286 {
 287         struct json_t *v = NULL;
 288         int value;
 289
 290         if (!json_is_object(version)) {
 291                 cm_print_error("version is not a JSON object\n");
 292                 _fail(file, line);
 293         }
 294
 295         if (json_object_size(version) != 2) {
 296                 cm_print_error(
 297                     "Unexpected number of elements in version %zu != %d\n",
 298                     json_object_size(version),
 299                     2);
 300                 _fail(file, line);
 301         }
 302
 303         /*
 304          * Validate the major version number element
 305          */
 306         v = json_object_get(version, "major");
 307         if (v == NULL) {
 308                 cm_print_error( "No major element\n");
 309                 _fail(file, line);
 310         }
 311
 312         value = json_integer_value(v);
 313         if (value != major) {
 314                 print_error(
 315                     "Unexpected major version number \"%d\" != \"%d\"\n",
 316                     value,
 317                     major);
 318                 _fail(file, line);
 319         }
 320
 321         /*
 322          * Validate the minor version number element
 323          */
 324         v = json_object_get(version, "minor");
 325         if (v == NULL) {
 326                 cm_print_error( "No minor element\n");
 327                 _fail(file, line);
 328         }
 329
 330         value = json_integer_value(v);
 331         if (value != minor) {
 332                 print_error(
 333                     "Unexpected minor version number \"%d\" != \"%d\"\n",
 334                     value,
 335                     minor);
 336                 _fail(file, line);
 337         }
 338 }
 339
 340 /*
 341  * Test helper to insert a transaction_id into a request.
 342  */
 343 static void add_transaction_id(struct ldb_request *req, const char *id)
 344 {
 345         struct GUID guid;
 346         struct dsdb_control_transaction_identifier *transaction_id = NULL;
 347
 348         transaction_id = talloc_zero(
 349                 req,
 350                 struct dsdb_control_transaction_identifier);
 351         assert_non_null(transaction_id);
 352         GUID_from_string(id, &guid);
 353         transaction_id->transaction_guid = guid;
 354         ldb_request_add_control(
 355                 req,
 356                 DSDB_CONTROL_TRANSACTION_IDENTIFIER_OID,
 357                 false,
 358                 transaction_id);
 359 }
 360
 361 /*
 362  * Test helper to add a session id and user SID
 363  */
 364 static void add_session_data(
 365         TALLOC_CTX *ctx,
 366         struct ldb_context *ldb,
 367         const char *session,
 368         const char *user_sid)
 369 {
 370         struct auth_session_info *sess = NULL;
 371         struct security_token *token = NULL;
 372         struct dom_sid *sid = NULL;
 373         struct GUID session_id;
 374         bool ok;
 375
 376         sess = talloc_zero(ctx, struct auth_session_info);
 377         token = talloc_zero(ctx, struct security_token);
 378         sid = talloc_zero(ctx, struct dom_sid);
 379         ok = string_to_sid(sid, user_sid);
 380         assert_true(ok);
 381         token->sids = sid;
 382         sess->security_token = token;
 383         GUID_from_string(session, &session_id);
 384         sess->unique_session_token = session_id;
 385         ldb_set_opaque(ldb, DSDB_SESSION_INFO, sess);
 386 }
 387
 388 static void test_get_transaction_id(void **state)
 389 {
 390         struct ldb_request *req = NULL;
 391         struct GUID *guid;
 392         const char * const ID = "7130cb06-2062-6a1b-409e-3514c26b1773";
 393         char *guid_str = NULL;
 394         struct GUID_txt_buf guid_buff;
 395
 396
 397         TALLOC_CTX *ctx = talloc_new(NULL);
 398
 399
 400         /*
 401          * No transaction id, should return a zero guid
 402          */
 403         req = talloc_zero(ctx, struct ldb_request);
 404         guid = get_transaction_id(req);
 405         assert_null(guid);
 406         TALLOC_FREE(req);
 407
 408         /*
 409          * And now test with the transaction_id set
 410          */
 411         req = talloc_zero(ctx, struct ldb_request);
 412         assert_non_null(req);
 413         add_transaction_id(req, ID);
 414
 415         guid = get_transaction_id(req);
 416         guid_str = GUID_buf_string(guid, &guid_buff);
 417         assert_string_equal(ID, guid_str);
 418         TALLOC_FREE(req);
 419
 420         TALLOC_FREE(ctx);
 421 }
 422
 423 static void test_audit_group_hr(void **state)
 424 {
 425         struct ldb_context *ldb = NULL;
 426         struct ldb_module  *module = NULL;
 427         struct ldb_request *req = NULL;
 428
 429         struct tsocket_address *ts = NULL;
 430
 431         const char *const SID = "S-1-5-21-2470180966-3899876309-2637894779";
 432         const char * const SESSION = "7130cb06-2062-6a1b-409e-3514c26b1773";
 433
 434         struct GUID transaction_id;
 435         const char *const TRANSACTION = "7130cb06-2062-6a1b-409e-3514c26b1773";
 436
 437
 438         char *line = NULL;
 439         const char *rs = NULL;
 440         regex_t regex;
 441         int ret;
 442
 443
 444         TALLOC_CTX *ctx = talloc_new(NULL);
 445
 446         ldb = ldb_init(ctx, NULL);
 447
 448         GUID_from_string(TRANSACTION, &transaction_id);
 449
 450         module = talloc_zero(ctx, struct ldb_module);
 451         module->ldb = ldb;
 452
 453         tsocket_address_inet_from_strings(ctx, "ip", "127.0.0.1", 0, &ts);
 454         ldb_set_opaque(ldb, "remoteAddress", ts);
 455
 456         add_session_data(ctx, ldb, SESSION, SID);
 457
 458         req = talloc_zero(ctx, struct ldb_request);
 459         req->operation =  LDB_ADD;
 460         add_transaction_id(req, TRANSACTION);
 461
 462         line = audit_group_human_readable(
 463                 ctx,
 464                 module,
 465                 req,
 466                 "the-action",
 467                 "the-user-name",
 468                 "the-group-name",
 469                 LDB_ERR_OPERATIONS_ERROR);
 470         assert_non_null(line);
 471
 472         rs =    "\\[the-action\\] at \\["
 473                 "[^]]*"
 474                 "\\] status \\[Operations error\\] "
 475                 "Remote host \\[ipv4:127.0.0.1:0\\] "
 476                 "SID \\[S-1-5-21-2470180966-3899876309-2637894779\\] "
 477                 "Group \\[the-group-name\\] "
 478                 "User \\[the-user-name\\]";
 479
 480         ret = regcomp(&regex, rs, 0);
 481         assert_int_equal(0, ret);
 482
 483         ret = regexec(&regex, line, 0, NULL, 0);
 484         assert_int_equal(0, ret);
 485
 486         regfree(&regex);
 487         TALLOC_FREE(ctx);
 488
 489 }
 490
 491 /*
 492  * test get_parsed_dns
 493  * For this test we assume Valgrind or Address Sanitizer will detect any over
 494  * runs. Also we don't care that the values are DN's only that the value in the
 495  * element is copied to the parsed_dns.
 496  */
 497 static void test_get_parsed_dns(void **state)
 498 {
 499         struct ldb_message_element *el = NULL;
 500         struct parsed_dn *dns = NULL;
 501
 502         TALLOC_CTX *ctx = talloc_new(NULL);
 503
 504         el = talloc_zero(ctx, struct ldb_message_element);
 505
 506         /*
 507          * empty element, zero dns
 508          */
 509         dns = get_parsed_dns(ctx, el);
 510         assert_null(dns);
 511
 512         /*
 513          * one entry
 514          */
 515         el->num_values = 1;
 516         el->values = talloc_zero_array(ctx, DATA_BLOB, 1);
 517         el->values[0] = data_blob_string_const("The first value");
 518
 519         dns = get_parsed_dns(ctx, el);
 520
 521         assert_ptr_equal(el->values[0].data, dns[0].v->data);
 522         assert_int_equal(el->values[0].length, dns[0].v->length);
 523
 524         TALLOC_FREE(dns);
 525         TALLOC_FREE(el);
 526
 527
 528         /*
 529          * Multiple values
 530          */
 531         el = talloc_zero(ctx, struct ldb_message_element);
 532         el->num_values = 2;
 533         el->values = talloc_zero_array(ctx, DATA_BLOB, 2);
 534         el->values[0] = data_blob_string_const("The first value");
 535         el->values[0] = data_blob_string_const("The second value");
 536
 537         dns = get_parsed_dns(ctx, el);
 538
 539         assert_ptr_equal(el->values[0].data, dns[0].v->data);
 540         assert_int_equal(el->values[0].length, dns[0].v->length);
 541
 542         assert_ptr_equal(el->values[1].data, dns[1].v->data);
 543         assert_int_equal(el->values[1].length, dns[1].v->length);
 544
 545         TALLOC_FREE(ctx);
 546 }
 547
 548 static void test_dn_compare(void **state)
 549 {
 550
 551         struct ldb_context *ldb = NULL;
 552         struct parsed_dn *a;
 553         DATA_BLOB ab;
 554
 555         struct parsed_dn *b;
 556         DATA_BLOB bb;
 557
 558         int res;
 559
 560         TALLOC_CTX *ctx = talloc_new(NULL);
 561         const struct GUID *ZERO_GUID = talloc_zero(ctx, struct GUID);
 562
 563         ldb = ldb_init(ctx, NULL);
 564         ldb_register_samba_handlers(ldb);
 565
 566
 567         /*
 568          * Identical binary DN's
 569          */
 570         ab = data_blob_string_const(
 571                 "<GUID=fbee08fd-6f75-4bd4-af3f-e4f063a6379e>;"
 572                 "OU=Domain Controllers,DC=ad,DC=testing,DC=samba,DC=org");
 573         a = talloc_zero(ctx, struct parsed_dn);
 574         a->v = &ab;
 575
 576         bb = data_blob_string_const(
 577                 "<GUID=fbee08fd-6f75-4bd4-af3f-e4f063a6379e>;"
 578                 "OU=Domain Controllers,DC=ad,DC=testing,DC=samba,DC=org");
 579         b = talloc_zero(ctx, struct parsed_dn);
 580         b->v = &bb;
 581
 582         res = dn_compare(ctx, ldb, a, b);
 583         assert_int_equal(BINARY_EQUAL, res);
 584         /*
 585          * DN's should not have been parsed
 586          */
 587         assert_null(a->dsdb_dn);
 588         assert_memory_equal(ZERO_GUID, &a->guid, sizeof(struct GUID));
 589         assert_null(b->dsdb_dn);
 590         assert_memory_equal(ZERO_GUID, &b->guid, sizeof(struct GUID));
 591
 592         TALLOC_FREE(a);
 593         TALLOC_FREE(b);
 594
 595         /*
 596          * differing binary DN's but equal GUID's
 597          */
 598         ab = data_blob_string_const(
 599                 "<GUID=efdc91e5-5a5a-493e-9606-166ed0c2651e>;"
 600                 "OU=Domain Controllers,DC=ad,DC=testing,DC=samba,DC=com");
 601         a = talloc_zero(ctx, struct parsed_dn);
 602         a->v = &ab;
 603
 604         bb = data_blob_string_const(
 605                 "<GUID=efdc91e5-5a5a-493e-9606-166ed0c2651e>;"
 606                 "OU=Domain Controllers,DC=ad,DC=testing,DC=samba,DC=org");
 607         b = talloc_zero(ctx, struct parsed_dn);
 608         b->v = &bb;
 609
 610         res = dn_compare(ctx, ldb, a, b);
 611         assert_int_equal(EQUAL, res);
 612         /*
 613          * DN's should have been parsed
 614          */
 615         assert_non_null(a->dsdb_dn);
 616         assert_memory_not_equal(ZERO_GUID, &a->guid, sizeof(struct GUID));
 617         assert_non_null(b->dsdb_dn);
 618         assert_memory_not_equal(ZERO_GUID, &b->guid, sizeof(struct GUID));
 619
 620         TALLOC_FREE(a);
 621         TALLOC_FREE(b);
 622
 623         /*
 624          * differing binary DN's but and second guid greater
 625          */
 626         ab = data_blob_string_const(
 627                 "<GUID=efdc91e5-5a5a-493e-9606-166ed0c2651d>;"
 628                 "OU=Domain Controllers,DC=ad,DC=testing,DC=samba,DC=com");
 629         a = talloc_zero(ctx, struct parsed_dn);
 630         a->v = &ab;
 631
 632         bb = data_blob_string_const(
 633                 "<GUID=efdc91e5-5a5a-493e-9606-166ed0c2651e>;"
 634                 "OU=Domain Controllers,DC=ad,DC=testing,DC=samba,DC=org");
 635         b = talloc_zero(ctx, struct parsed_dn);
 636         b->v = &bb;
 637
 638         res = dn_compare(ctx, ldb, a, b);
 639         assert_int_equal(LESS_THAN, res);
 640         /*
 641          * DN's should have been parsed
 642          */
 643         assert_non_null(a->dsdb_dn);
 644         assert_memory_not_equal(ZERO_GUID, &a->guid, sizeof(struct GUID));
 645         assert_non_null(b->dsdb_dn);
 646         assert_memory_not_equal(ZERO_GUID, &b->guid, sizeof(struct GUID));
 647
 648         TALLOC_FREE(a);
 649         TALLOC_FREE(b);
 650
 651         /*
 652          * differing binary DN's but and second guid less
 653          */
 654         ab = data_blob_string_const(
 655                 "<GUID=efdc91e5-5a5a-493e-9606-166ed0c2651d>;"
 656                 "OU=Domain Controllers,DC=ad,DC=testing,DC=samba,DC=com");
 657         a = talloc_zero(ctx, struct parsed_dn);
 658         a->v = &ab;
 659
 660         bb = data_blob_string_const(
 661                 "<GUID=efdc91e5-5a5a-493e-9606-166ed0c2651c>;"
 662                 "OU=Domain Controllers,DC=ad,DC=testing,DC=samba,DC=org");
 663         b = talloc_zero(ctx, struct parsed_dn);
 664         b->v = &bb;
 665
 666         res = dn_compare(ctx, ldb, a, b);
 667         assert_int_equal(GREATER_THAN, res);
 668         /*
 669          * DN's should have been parsed
 670          */
 671         assert_non_null(a->dsdb_dn);
 672         assert_memory_not_equal(ZERO_GUID, &a->guid, sizeof(struct GUID));
 673         assert_non_null(b->dsdb_dn);
 674         assert_memory_not_equal(ZERO_GUID, &b->guid, sizeof(struct GUID));
 675
 676         TALLOC_FREE(a);
 677         TALLOC_FREE(b);
 678
 679         TALLOC_FREE(ctx);
 680 }
 681
 682 static void test_get_primary_group_dn(void **state)
 683 {
 684
 685         struct ldb_context *ldb = NULL;
 686         struct ldb_module *module = NULL;
 687         const uint32_t RID = 71;
 688         struct dom_sid sid;
 689         const char *SID = "S-1-5-21-2470180966-3899876309-2637894779";
 690         const char *DN = "OU=Things,DC=ad,DC=testing,DC=samba,DC=org";
 691         const char *dn;
 692
 693         TALLOC_CTX *ctx = talloc_new(NULL);
 694
 695         ldb = ldb_init(ctx, NULL);
 696         ldb_register_samba_handlers(ldb);
 697
 698         module = talloc_zero(ctx, struct ldb_module);
 699         module->ldb = ldb;
 700
 701         /*
 702          * Pass an empty dom sid this will cause dom_sid_split_rid to fail;
 703          * assign to sid.num_auths to suppress a valgrind warning.
 704          */
 705         sid.num_auths = 0;
 706         dn = get_primary_group_dn(ctx, module, &sid, RID);
 707         assert_null(dn);
 708
 709         /*
 710          * A valid dom sid
 711          */
 712         assert_true(string_to_sid(&sid, SID));
 713         g_dn = DN;
 714         dn = get_primary_group_dn(ctx, module, &sid, RID);
 715         assert_non_null(dn);
 716         assert_string_equal(DN, dn);
 717         assert_int_equal(LDB_SCOPE_BASE, g_scope);
 718         assert_int_equal(0, g_dsdb_flags);
 719         assert_null(g_attrs);
 720         assert_null(g_exp_fmt);
 721         assert_string_equal
 722                 ("<SID=S-1-5-21-2470180966-3899876309-71>",
 723                 ldb_dn_get_extended_linearized(ctx, g_basedn, 1));
 724
 725         /*
 726          * Test dsdb search failure
 727          */
 728         g_status = LDB_ERR_NO_SUCH_OBJECT;
 729         dn = get_primary_group_dn(ctx, module, &sid, RID);
 730         assert_null(dn);
 731
 732         TALLOC_FREE(ldb);
 733         TALLOC_FREE(ctx);
 734 }
 735
 736 static void test_audit_group_json(void **state)
 737 {
 738         struct ldb_context *ldb = NULL;
 739         struct ldb_module  *module = NULL;
 740         struct ldb_request *req = NULL;
 741
 742         struct tsocket_address *ts = NULL;
 743
 744         const char *const SID = "S-1-5-21-2470180966-3899876309-2637894779";
 745         const char * const SESSION = "7130cb06-2062-6a1b-409e-3514c26b1773";
 746
 747         struct GUID transaction_id;
 748         const char *const TRANSACTION = "7130cb06-2062-6a1b-409e-3514c26b1773";
 749
 750
 751         struct json_object json;
 752         json_t *audit = NULL;
 753         json_t *v = NULL;
 754         json_t *o = NULL;
 755         time_t before;
 756
 757
 758         TALLOC_CTX *ctx = talloc_new(NULL);
 759
 760         ldb = ldb_init(ctx, NULL);
 761
 762         GUID_from_string(TRANSACTION, &transaction_id);
 763
 764         module = talloc_zero(ctx, struct ldb_module);
 765         module->ldb = ldb;
 766
 767         tsocket_address_inet_from_strings(ctx, "ip", "127.0.0.1", 0, &ts);
 768         ldb_set_opaque(ldb, "remoteAddress", ts);
 769
 770         add_session_data(ctx, ldb, SESSION, SID);
 771
 772         req = talloc_zero(ctx, struct ldb_request);
 773         req->operation =  LDB_ADD;
 774         add_transaction_id(req, TRANSACTION);
 775
 776         before = time(NULL);
 777         json = audit_group_json(
 778                 module,
 779                 req,
 780                 "the-action",
 781                 "the-user-name",
 782                 "the-group-name",
 783                 LDB_ERR_OPERATIONS_ERROR);
 784         assert_int_equal(3, json_object_size(json.root));
 785
 786         v = json_object_get(json.root, "type");
 787         assert_non_null(v);
 788         assert_string_equal("groupChange", json_string_value(v));
 789
 790         v = json_object_get(json.root, "timestamp");
 791         assert_non_null(v);
 792         assert_true(json_is_string(v));
 793         check_timestamp(before, json_string_value(v));
 794
 795         audit = json_object_get(json.root, "groupChange");
 796         assert_non_null(audit);
 797         assert_true(json_is_object(audit));
 798         assert_int_equal(10, json_object_size(audit));
 799
 800         o = json_object_get(audit, "version");
 801         assert_non_null(o);
 802         check_version(o, AUDIT_MAJOR, AUDIT_MINOR);
 803
 804         v = json_object_get(audit, "statusCode");
 805         assert_non_null(v);
 806         assert_true(json_is_integer(v));
 807         assert_int_equal(LDB_ERR_OPERATIONS_ERROR, json_integer_value(v));
 808
 809         v = json_object_get(audit, "status");
 810         assert_non_null(v);
 811         assert_true(json_is_string(v));
 812         assert_string_equal("Operations error", json_string_value(v));
 813
 814         v = json_object_get(audit, "user");
 815         assert_non_null(v);
 816         assert_true(json_is_string(v));
 817         assert_string_equal("the-user-name", json_string_value(v));
 818
 819         v = json_object_get(audit, "group");
 820         assert_non_null(v);
 821         assert_true(json_is_string(v));
 822         assert_string_equal("the-group-name", json_string_value(v));
 823
 824         v = json_object_get(audit, "action");
 825         assert_non_null(v);
 826         assert_true(json_is_string(v));
 827         assert_string_equal("the-action", json_string_value(v));
 828
 829         json_free(&json);
 830         TALLOC_FREE(ctx);
 831 }
 832
 833 static void setup_ldb(
 834         TALLOC_CTX *ctx,
 835         struct ldb_context **ldb,
 836         struct ldb_module **module,
 837         const char *ip,
 838         const char *session,
 839         const char *sid)
 840 {
 841         struct tsocket_address *ts = NULL;
 842         struct audit_context *context = NULL;
 843
 844         *ldb = ldb_init(ctx, NULL);
 845         ldb_register_samba_handlers(*ldb);
 846
 847
 848         *module = talloc_zero(ctx, struct ldb_module);
 849         (*module)->ldb = *ldb;
 850
 851         context = talloc_zero(*module, struct audit_context);
 852         context->send_events = true;
 853         context->msg_ctx = (struct imessaging_context *) 0x01;
 854
 855         ldb_module_set_private(*module, context);
 856
 857         tsocket_address_inet_from_strings(ctx, "ip", "127.0.0.1", 0, &ts);
 858         ldb_set_opaque(*ldb, "remoteAddress", ts);
 859
 860         add_session_data(ctx, *ldb, session, sid);
 861 }
 862
 863 /*
 864  * Test the removal of a user from a group.
 865  *
 866  * The new element contains one group member
 867  * The old element contains two group member
 868  *
 869  * Expect to see the removed entry logged.
 870  *
 871  * This test confirms bug 13664
 872  * https://bugzilla.samba.org/show_bug.cgi?id=13664
 873  */
 874 static void test_log_membership_changes_removed(void **state)
 875 {
 876         struct ldb_context *ldb = NULL;
 877         struct ldb_module  *module = NULL;
 878         const char * const SID = "S-1-5-21-2470180966-3899876309-2637894779";
 879         const char * const SESSION = "7130cb06-2062-6a1b-409e-3514c26b1773";
 880         const char * const TRANSACTION = "7130cb06-2062-6a1b-409e-3514c26b1773";
 881         const char * const IP = "127.0.0.1";
 882         struct ldb_request *req = NULL;
 883         struct ldb_message_element *new_el = NULL;
 884         struct ldb_message_element *old_el = NULL;
 885         int status = 0;
 886         TALLOC_CTX *ctx = talloc_new(NULL);
 887
 888         setup_ldb(ctx, &ldb, &module, IP, SESSION, SID);
 889
 890         /*
 891          * Build the ldb_request
 892          */
 893         req = talloc_zero(ctx, struct ldb_request);
 894         req->operation =  LDB_ADD;
 895         add_transaction_id(req, TRANSACTION);
 896
 897         /*
 898          * Populate the new elements, containing one entry.
 899          * Indicating that one element has been removed
 900          */
 901         new_el = talloc_zero(ctx, struct ldb_message_element);
 902         new_el->num_values = 1;
 903         new_el->values = talloc_zero_array(ctx, DATA_BLOB, 1);
 904         new_el->values[0] = data_blob_string_const(
 905                 "<GUID=081519b5-a709-44a0-bc95-dd4bfe809bf8>;"
 906                 "CN=testuser131953,CN=Users,DC=addom,DC=samba,"
 907                 "DC=example,DC=com");
 908
 909         /*
 910          * Populate the old elements, with two elements
 911          * The first is the same as the one in new elements.
 912          */
 913         old_el = talloc_zero(ctx, struct ldb_message_element);
 914         old_el->num_values = 2;
 915         old_el->values = talloc_zero_array(ctx, DATA_BLOB, 2);
 916         old_el->values[0] = data_blob_string_const(
 917                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681b>;"
 918                 "cn=grpadttstuser01,cn=users,DC=addom,"
 919                 "DC=samba,DC=example,DC=com");
 920         old_el->values[1] = data_blob_string_const(
 921                 "<GUID=081519b5-a709-44a0-bc95-dd4bfe809bf8>;"
 922                 "CN=testuser131953,CN=Users,DC=addom,DC=samba,"
 923                 "DC=example,DC=com");
 924
 925         /*
 926          * call log_membership_changes
 927          */
 928         messages_sent = 0;
 929         log_membership_changes(module, req, new_el, old_el, status);
 930
 931         /*
 932          * Check the results
 933          */
 934         assert_int_equal(1, messages_sent);
 935
 936         check_group_change_message(
 937             0,
 938             "cn=grpadttstuser01,cn=users,DC=addom,DC=samba,DC=example,DC=com",
 939             "Removed");
 940
 941         /*
 942          * Clean up
 943          */
 944         json_free(&messages[0]);
 945         TALLOC_FREE(ctx);
 946 }
 947
 948 /* test log_membership_changes
 949  *
 950  * old contains 2 user dn's
 951  * new contains 0 user dn's
 952  *
 953  * Expect to see both dn's logged as deleted.
 954  */
 955 static void test_log_membership_changes_remove_all(void **state)
 956 {
 957         struct ldb_context *ldb = NULL;
 958         struct ldb_module  *module = NULL;
 959         const char * const SID = "S-1-5-21-2470180966-3899876309-2637894779";
 960         const char * const SESSION = "7130cb06-2062-6a1b-409e-3514c26b1773";
 961         const char * const TRANSACTION = "7130cb06-2062-6a1b-409e-3514c26b1773";
 962         const char * const IP = "127.0.0.1";
 963         struct ldb_request *req = NULL;
 964         struct ldb_message_element *new_el = NULL;
 965         struct ldb_message_element *old_el = NULL;
 966         int status = 0;
 967         TALLOC_CTX *ctx = talloc_new(NULL);
 968
 969         setup_ldb(ctx, &ldb, &module, IP, SESSION, SID);
 970
 971         /*
 972          * Build the ldb_request
 973          */
 974         req = talloc_zero(ctx, struct ldb_request);
 975         req->operation =  LDB_ADD;
 976         add_transaction_id(req, TRANSACTION);
 977
 978         /*
 979          * Populate the new elements, containing no entries.
 980          * Indicating that all elements have been removed
 981          */
 982         new_el = talloc_zero(ctx, struct ldb_message_element);
 983         new_el->num_values = 0;
 984         new_el->values = NULL;
 985
 986         /*
 987          * Populate the old elements, with two elements
 988          */
 989         old_el = talloc_zero(ctx, struct ldb_message_element);
 990         old_el->num_values = 2;
 991         old_el->values = talloc_zero_array(ctx, DATA_BLOB, 2);
 992         old_el->values[0] = data_blob_string_const(
 993                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681b>;"
 994                 "cn=grpadttstuser01,cn=users,DC=addom,"
 995                 "DC=samba,DC=example,DC=com");
 996         old_el->values[1] = data_blob_string_const(
 997                 "<GUID=081519b5-a709-44a0-bc95-dd4bfe809bf8>;"
 998                 "CN=testuser131953,CN=Users,DC=addom,DC=samba,"
 999                 "DC=example,DC=com");
1000
1001         /*
1002          * call log_membership_changes
1003          */
1004         messages_sent = 0;
1005         log_membership_changes( module, req, new_el, old_el, status);
1006
1007         /*
1008          * Check the results
1009          */
1010         assert_int_equal(2, messages_sent);
1011
1012         check_group_change_message(
1013             0,
1014             "cn=grpadttstuser01,cn=users,DC=addom,DC=samba,DC=example,DC=com",
1015             "Removed");
1016
1017         check_group_change_message(
1018             1,
1019             "CN=testuser131953,CN=Users,DC=addom,DC=samba,DC=example,DC=com",
1020             "Removed");
1021
1022         /*
1023          * Clean up
1024          */
1025         json_free(&messages[0]);
1026         json_free(&messages[1]);
1027         TALLOC_FREE(ctx);
1028 }
1029
1030 /* test log_membership_changes
1031  *
1032  * Add an entry.
1033  *
1034  * Old entries contains a single user dn
1035  * New entries contains 2 user dn's, one matching the dn in old entries
1036  *
1037  * Should see a single new entry logged.
1038  */
1039 static void test_log_membership_changes_added(void **state)
1040 {
1041         struct ldb_context *ldb = NULL;
1042         struct ldb_module  *module = NULL;
1043         const char * const SID = "S-1-5-21-2470180966-3899876309-2637894779";
1044         const char * const SESSION = "7130cb06-2062-6a1b-409e-3514c26b1773";
1045         const char * const TRANSACTION = "7130cb06-2062-6a1b-409e-3514c26b1773";
1046         const char * const IP = "127.0.0.1";
1047         struct ldb_request *req = NULL;
1048         struct ldb_message_element *new_el = NULL;
1049         struct ldb_message_element *old_el = NULL;
1050         int status = 0;
1051         TALLOC_CTX *ctx = talloc_new(NULL);
1052
1053         setup_ldb(ctx, &ldb, &module, IP, SESSION, SID);
1054
1055         /*
1056          * Build the ldb_request
1057          */
1058         req = talloc_zero(ctx, struct ldb_request);
1059         req->operation =  LDB_ADD;
1060         add_transaction_id(req, TRANSACTION);
1061
1062         /*
1063          * Populate the old elements adding a single entry.
1064          */
1065         old_el = talloc_zero(ctx, struct ldb_message_element);
1066         old_el->num_values = 1;
1067         old_el->values = talloc_zero_array(ctx, DATA_BLOB, 1);
1068         old_el->values[0] = data_blob_string_const(
1069                 "<GUID=081519b5-a709-44a0-bc95-dd4bfe809bf8>;"
1070                 "CN=testuser131953,CN=Users,DC=addom,DC=samba,"
1071                 "DC=example,DC=com");
1072
1073         /*
1074          * Populate the new elements adding two entries. One matches the entry
1075          * in old elements. We expect to see the other element logged as Added
1076          */
1077         new_el = talloc_zero(ctx, struct ldb_message_element);
1078         new_el->num_values = 2;
1079         new_el->values = talloc_zero_array(ctx, DATA_BLOB, 2);
1080         new_el->values[0] = data_blob_string_const(
1081                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681b>;"
1082                 "cn=grpadttstuser01,cn=users,DC=addom,"
1083                 "DC=samba,DC=example,DC=com");
1084         new_el->values[1] = data_blob_string_const(
1085                 "<GUID=081519b5-a709-44a0-bc95-dd4bfe809bf8>;"
1086                 "CN=testuser131953,CN=Users,DC=addom,DC=samba,"
1087                 "DC=example,DC=com");
1088
1089         /*
1090          * call log_membership_changes
1091          */
1092         messages_sent = 0;
1093         log_membership_changes( module, req, new_el, old_el, status);
1094
1095         /*
1096          * Check the results
1097          */
1098         assert_int_equal(1, messages_sent);
1099
1100         check_group_change_message(
1101             0,
1102             "cn=grpadttstuser01,cn=users,DC=addom,DC=samba,DC=example,DC=com",
1103             "Added");
1104
1105         /*
1106          * Clean up
1107          */
1108         json_free(&messages[0]);
1109         TALLOC_FREE(ctx);
1110 }
1111
1112 /*
1113  * test log_membership_changes.
1114  *
1115  * Old entries is empty
1116  * New entries contains 2 user dn's
1117  *
1118  * Expect to see log messages for two added users
1119  */
1120 static void test_log_membership_changes_add_to_empty(void **state)
1121 {
1122         struct ldb_context *ldb = NULL;
1123         struct ldb_module  *module = NULL;
1124         const char * const SID = "S-1-5-21-2470180966-3899876309-2637894779";
1125         const char * const SESSION = "7130cb06-2062-6a1b-409e-3514c26b1773";
1126         const char * const TRANSACTION = "7130cb06-2062-6a1b-409e-3514c26b1773";
1127         const char * const IP = "127.0.0.1";
1128         struct ldb_request *req = NULL;
1129         struct ldb_message_element *new_el = NULL;
1130         struct ldb_message_element *old_el = NULL;
1131         int status = 0;
1132         TALLOC_CTX *ctx = talloc_new(NULL);
1133
1134         /*
1135          * Set up the ldb and module structures
1136          */
1137         setup_ldb(ctx, &ldb, &module, IP, SESSION, SID);
1138
1139         /*
1140          * Build the request structure
1141          */
1142         req = talloc_zero(ctx, struct ldb_request);
1143         req->operation =  LDB_ADD;
1144         add_transaction_id(req, TRANSACTION);
1145
1146         /*
1147          * Build the element containing the old values
1148          */
1149         old_el = talloc_zero(ctx, struct ldb_message_element);
1150         old_el->num_values = 0;
1151         old_el->values = NULL;
1152
1153         /*
1154          * Build the element containing the new values
1155          */
1156         new_el = talloc_zero(ctx, struct ldb_message_element);
1157         new_el->num_values = 2;
1158         new_el->values = talloc_zero_array(ctx, DATA_BLOB, 2);
1159         new_el->values[0] = data_blob_string_const(
1160                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681b>;"
1161                 "cn=grpadttstuser01,cn=users,DC=addom,"
1162                 "DC=samba,DC=example,DC=com");
1163         new_el->values[1] = data_blob_string_const(
1164                 "<GUID=081519b5-a709-44a0-bc95-dd4bfe809bf8>;"
1165                 "CN=testuser131953,CN=Users,DC=addom,DC=samba,"
1166                 "DC=example,DC=com");
1167
1168         /*
1169          * Run log membership changes
1170          */
1171         messages_sent = 0;
1172         log_membership_changes( module, req, new_el, old_el, status);
1173         assert_int_equal(2, messages_sent);
1174
1175         check_group_change_message(
1176             0,
1177             "cn=grpadttstuser01,cn=users,DC=addom,DC=samba,DC=example,DC=com",
1178             "Added");
1179
1180         check_group_change_message(
1181             1,
1182             "CN=testuser131953,CN=Users,DC=addom,DC=samba,DC=example,DC=com",
1183             "Added");
1184
1185         json_free(&messages[0]);
1186         json_free(&messages[1]);
1187         TALLOC_FREE(ctx);
1188 }
1189
1190 /* test log_membership_changes
1191  *
1192  * Test Replication Meta Data flag handling.
1193  *
1194  * 4 entries in old and new entries with their RMD_FLAGS set as below:
1195  *    old   new
1196  * 1)  0     0    Not logged
1197  * 2)  1     1    Both deleted, no change not logged
1198  * 3)  0     1    New tagged as deleted, log as deleted
1199  * 4)  1     0    Has been undeleted, log as an add
1200  *
1201  * Should see a single new entry logged.
1202  */
1203 static void test_log_membership_changes_rmd_flags(void **state)
1204 {
1205         struct ldb_context *ldb = NULL;
1206         struct ldb_module  *module = NULL;
1207         const char * const SID = "S-1-5-21-2470180966-3899876309-2637894779";
1208         const char * const SESSION = "7130cb06-2062-6a1b-409e-3514c26b1773";
1209         const char * const TRANSACTION = "7130cb06-2062-6a1b-409e-3514c26b1773";
1210         const char * const IP = "127.0.0.1";
1211         struct ldb_request *req = NULL;
1212         struct ldb_message_element *new_el = NULL;
1213         struct ldb_message_element *old_el = NULL;
1214         int status = 0;
1215         TALLOC_CTX *ctx = talloc_new(NULL);
1216
1217         setup_ldb(ctx, &ldb, &module, IP, SESSION, SID);
1218
1219         /*
1220          * Build the ldb_request
1221          */
1222         req = talloc_zero(ctx, struct ldb_request);
1223         req->operation =  LDB_ADD;
1224         add_transaction_id(req, TRANSACTION);
1225
1226         /*
1227          * Populate the old elements.
1228          */
1229         old_el = talloc_zero(ctx, struct ldb_message_element);
1230         old_el->num_values = 4;
1231         old_el->values = talloc_zero_array(ctx, DATA_BLOB, 4);
1232         old_el->values[0] = data_blob_string_const(
1233                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681b>;"
1234                 "<RMD_FLAGS=0>;"
1235                 "cn=grpadttstuser01,cn=users,DC=addom,"
1236                 "DC=samba,DC=example,DC=com");
1237         old_el->values[1] = data_blob_string_const(
1238                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681c>;"
1239                 "<RMD_FLAGS=1>;"
1240                 "cn=grpadttstuser02,cn=users,DC=addom,"
1241                 "DC=samba,DC=example,DC=com");
1242         old_el->values[2] = data_blob_string_const(
1243                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681d>;"
1244                 "<RMD_FLAGS=0>;"
1245                 "cn=grpadttstuser03,cn=users,DC=addom,"
1246                 "DC=samba,DC=example,DC=com");
1247         old_el->values[3] = data_blob_string_const(
1248                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681e>;"
1249                 "<RMD_FLAGS=1>;"
1250                 "cn=grpadttstuser04,cn=users,DC=addom,"
1251                 "DC=samba,DC=example,DC=com");
1252
1253         /*
1254          * Populate the new elements.
1255          */
1256         new_el = talloc_zero(ctx, struct ldb_message_element);
1257         new_el->num_values = 4;
1258         new_el->values = talloc_zero_array(ctx, DATA_BLOB, 4);
1259         new_el->values[0] = data_blob_string_const(
1260                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681b>;"
1261                 "<RMD_FLAGS=0>;"
1262                 "cn=grpadttstuser01,cn=users,DC=addom,"
1263                 "DC=samba,DC=example,DC=com");
1264         new_el->values[1] = data_blob_string_const(
1265                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681c>;"
1266                 "<RMD_FLAGS=1>;"
1267                 "cn=grpadttstuser02,cn=users,DC=addom,"
1268                 "DC=samba,DC=example,DC=com");
1269         new_el->values[2] = data_blob_string_const(
1270                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681d>;"
1271                 "<RMD_FLAGS=1>;"
1272                 "cn=grpadttstuser03,cn=users,DC=addom,"
1273                 "DC=samba,DC=example,DC=com");
1274         new_el->values[3] = data_blob_string_const(
1275                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681e>;"
1276                 "<RMD_FLAGS=0>;"
1277                 "cn=grpadttstuser04,cn=users,DC=addom,"
1278                 "DC=samba,DC=example,DC=com");
1279
1280         /*
1281          * call log_membership_changes
1282          */
1283         messages_sent = 0;
1284         log_membership_changes( module, req, new_el, old_el, status);
1285
1286         /*
1287          * Check the results
1288          */
1289         assert_int_equal(2, messages_sent);
1290
1291         check_group_change_message(
1292             0,
1293             "cn=grpadttstuser03,cn=users,DC=addom,DC=samba,DC=example,DC=com",
1294             "Removed");
1295         check_group_change_message(
1296             1,
1297             "cn=grpadttstuser04,cn=users,DC=addom,DC=samba,DC=example,DC=com",
1298             "Added");
1299
1300         /*
1301          * Clean up
1302          */
1303         json_free(&messages[0]);
1304         json_free(&messages[1]);
1305         TALLOC_FREE(ctx);
1306 }
1307
1308 /*
1309  * Note: to run under valgrind us:
1310  *       valgrind --suppressions=test_group_audit.valgrind bin/test_group_audit
1311  *       This suppresses the errors generated because the ldb_modules are not
1312  *       de-registered.
1313  *
1314  */
1315 int main(void) {
1316         const struct CMUnitTest tests[] = {
1317                 cmocka_unit_test(test_audit_group_json),
1318                 cmocka_unit_test(test_get_transaction_id),
1319                 cmocka_unit_test(test_audit_group_hr),
1320                 cmocka_unit_test(test_get_parsed_dns),
1321                 cmocka_unit_test(test_dn_compare),
1322                 cmocka_unit_test(test_get_primary_group_dn),
1323                 cmocka_unit_test(test_log_membership_changes_removed),
1324                 cmocka_unit_test(test_log_membership_changes_remove_all),
1325                 cmocka_unit_test(test_log_membership_changes_added),
1326                 cmocka_unit_test(test_log_membership_changes_add_to_empty),
1327                 cmocka_unit_test(test_log_membership_changes_rmd_flags),
1328         };
1329
1330         cmocka_set_message_output(CM_OUTPUT_SUBUNIT);
1331         return cmocka_run_group_tests(tests, NULL, NULL);
1332 }