source4/torture/nbt/winsreplication.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    WINS replication testing
   5
   6    Copyright (C) Andrew Tridgell 2005
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "libcli/nbt/libnbt.h"
  25 #include "libcli/wrepl/winsrepl.h"
  26 #include "lib/events/events.h"
  27 #include "lib/socket/socket.h"
  28 #include "system/time.h"
  29
  30 #define CHECK_STATUS(status, correct) do { \
  31         if (!NT_STATUS_EQUAL(status, correct)) { \
  32                 printf("(%s) Incorrect status %s - should be %s\n", \
  33                        __location__, nt_errstr(status), nt_errstr(correct)); \
  34                 ret = False; \
  35                 goto done; \
  36         }} while (0)
  37
  38 #define CHECK_VALUE(v, correct) do { \
  39         if ((v) != (correct)) { \
  40                 printf("(%s) Incorrect value %s=%d - should be %d\n", \
  41                        __location__, #v, v, correct); \
  42                 ret = False; \
  43                 goto done; \
  44         }} while (0)
  45
  46 #define CHECK_VALUE_UINT64(v, correct) do { \
  47         if ((v) != (correct)) { \
  48                 printf("(%s) Incorrect value %s=%llu - should be %llu\n", \
  49                        __location__, #v, v, correct); \
  50                 ret = False; \
  51                 goto done; \
  52         }} while (0)
  53
  54 #define CHECK_VALUE_STRING(v, correct) do { \
  55         if ( ((!v) && (correct)) || \
  56              ((v) && (!correct)) || \
  57              ((v) && (correct) && strcmp(v,correct) != 0)) { \
  58                 printf("(%s) Incorrect value %s='%s' - should be '%s'\n", \
  59                        __location__, #v, v, correct); \
  60                 ret = False; \
  61                 goto done; \
  62         }} while (0)
  63
  64 #define _NBT_NAME(n,t,s) {\
  65         .name   = n,\
  66         .type   = t,\
  67         .scope  = s\
  68 }
  69
  70 static const char *wrepl_name_type_string(enum wrepl_name_type type)
  71 {
  72         switch (type) {
  73         case WREPL_TYPE_UNIQUE: return "UNIQUE";
  74         case WREPL_TYPE_GROUP: return "GROUP";
  75         case WREPL_TYPE_SGROUP: return "SGROUP";
  76         case WREPL_TYPE_MHOMED: return "MHOMED";
  77         }
  78         return "UNKNOWN_TYPE";
  79 }
  80
  81 static const char *wrepl_name_state_string(enum wrepl_name_state state)
  82 {
  83         switch (state) {
  84         case WREPL_STATE_ACTIVE: return "ACTIVE";
  85         case WREPL_STATE_RELEASED: return "RELEASED";
  86         case WREPL_STATE_TOMBSTONE: return "TOMBSTONE";
  87         case WREPL_STATE_RESERVED: return "RESERVED";
  88         }
  89         return "UNKNOWN_STATE";
  90 }
  91
  92 /*
  93   test how assoc_ctx's are only usable on the connection
  94   they are created on.
  95 */
  96 static BOOL test_assoc_ctx1(TALLOC_CTX *mem_ctx, const char *address)
  97 {
  98         BOOL ret = True;
  99         struct wrepl_request *req;
 100         struct wrepl_socket *wrepl_socket1;
 101         struct wrepl_associate associate1;
 102         struct wrepl_socket *wrepl_socket2;
 103         struct wrepl_associate associate2;
 104         struct wrepl_pull_table pull_table;
 105         struct wrepl_packet *rep_packet;
 106         struct wrepl_associate_stop assoc_stop;
 107         NTSTATUS status;
 108
 109         if (!lp_parm_bool(-1, "torture", "dangerous", False)) {
 110                 printf("winsrepl: cross connection assoc_ctx usage disabled - enable dangerous tests to use\n");
 111                 return True;
 112         }
 113
 114         printf("Test if assoc_ctx is only valid on the conection it was created on\n");
 115
 116         wrepl_socket1 = wrepl_socket_init(mem_ctx, NULL);
 117         wrepl_socket2 = wrepl_socket_init(mem_ctx, NULL);
 118
 119         printf("Setup 2 wrepl connections\n");
 120         status = wrepl_connect(wrepl_socket1, NULL, address);
 121         CHECK_STATUS(status, NT_STATUS_OK);
 122
 123         status = wrepl_connect(wrepl_socket2, NULL, address);
 124         CHECK_STATUS(status, NT_STATUS_OK);
 125
 126         printf("Send a start association request (conn1)\n");
 127         status = wrepl_associate(wrepl_socket1, &associate1);
 128         CHECK_STATUS(status, NT_STATUS_OK);
 129
 130         printf("association context (conn1): 0x%x\n", associate1.out.assoc_ctx);
 131
 132         printf("Send a start association request (conn2)\n");
 133         status = wrepl_associate(wrepl_socket2, &associate2);
 134         CHECK_STATUS(status, NT_STATUS_OK);
 135
 136         printf("association context (conn2): 0x%x\n", associate2.out.assoc_ctx);
 137
 138         printf("Send a replication table query, with assoc 1 (conn2), the anwser should be on conn1\n");
 139         pull_table.in.assoc_ctx = associate1.out.assoc_ctx;
 140         req = wrepl_pull_table_send(wrepl_socket2, &pull_table);
 141         req->send_only = True;
 142         status = wrepl_request_recv(req, mem_ctx, &rep_packet);
 143         CHECK_STATUS(status, NT_STATUS_OK);
 144
 145         printf("Send a association request (conn2), to make sure the last request was ignored\n");
 146         status = wrepl_associate(wrepl_socket2, &associate2);
 147         CHECK_STATUS(status, NT_STATUS_OK);
 148
 149         printf("Send a replication table query, with invalid assoc (conn1), receive answer from conn2\n");
 150         pull_table.in.assoc_ctx = 0;
 151         req = wrepl_pull_table_send(wrepl_socket1, &pull_table);
 152         status = wrepl_request_recv(req, mem_ctx, &rep_packet);
 153         CHECK_STATUS(status, NT_STATUS_OK);
 154
 155         printf("Send a association request (conn1), to make sure the last request was handled correct\n");
 156         status = wrepl_associate(wrepl_socket1, &associate2);
 157         CHECK_STATUS(status, NT_STATUS_OK);
 158
 159         assoc_stop.in.assoc_ctx = associate1.out.assoc_ctx;
 160         assoc_stop.in.reason    = 4;
 161         printf("Send a association stop request (conn1), reson: %u\n", assoc_stop.in.reason);
 162         status = wrepl_associate_stop(wrepl_socket1, &assoc_stop);
 163         CHECK_STATUS(status, NT_STATUS_END_OF_FILE);
 164
 165         assoc_stop.in.assoc_ctx = associate2.out.assoc_ctx;
 166         assoc_stop.in.reason    = 0;
 167         printf("Send a association stop request (conn2), reson: %u\n", assoc_stop.in.reason);
 168         status = wrepl_associate_stop(wrepl_socket2, &assoc_stop);
 169         CHECK_STATUS(status, NT_STATUS_OK);
 170
 171 done:
 172         printf("Close 2 wrepl connections\n");
 173         talloc_free(wrepl_socket1);
 174         talloc_free(wrepl_socket2);
 175         return ret;
 176 }
 177
 178 /*
 179   test if we always get back the same assoc_ctx
 180 */
 181 static BOOL test_assoc_ctx2(TALLOC_CTX *mem_ctx, const char *address)
 182 {
 183         BOOL ret = True;
 184         struct wrepl_socket *wrepl_socket;
 185         struct wrepl_associate associate;
 186         uint32_t assoc_ctx1;
 187         NTSTATUS status;
 188
 189         printf("Test if we always get back the same assoc_ctx\n");
 190
 191         wrepl_socket = wrepl_socket_init(mem_ctx, NULL);
 192
 193         printf("Setup wrepl connections\n");
 194         status = wrepl_connect(wrepl_socket, NULL, address);
 195         CHECK_STATUS(status, NT_STATUS_OK);
 196
 197
 198         printf("Send 1st start association request\n");
 199         status = wrepl_associate(wrepl_socket, &associate);
 200         CHECK_STATUS(status, NT_STATUS_OK);
 201         assoc_ctx1 = associate.out.assoc_ctx;
 202         printf("1st association context: 0x%x\n", associate.out.assoc_ctx);
 203
 204         printf("Send 2nd start association request\n");
 205         status = wrepl_associate(wrepl_socket, &associate);
 206         CHECK_VALUE(associate.out.assoc_ctx, assoc_ctx1);
 207         CHECK_STATUS(status, NT_STATUS_OK);
 208         printf("2nd association context: 0x%x\n", associate.out.assoc_ctx);
 209
 210         printf("Send 3rd start association request\n");
 211         status = wrepl_associate(wrepl_socket, &associate);
 212         CHECK_VALUE(associate.out.assoc_ctx, assoc_ctx1);
 213         CHECK_STATUS(status, NT_STATUS_OK);
 214         printf("3rd association context: 0x%x\n", associate.out.assoc_ctx);
 215
 216 done:
 217         printf("Close wrepl connections\n");
 218         talloc_free(wrepl_socket);
 219         return ret;
 220 }
 221
 222
 223 /*
 224   display a replication entry
 225 */
 226 static void display_entry(TALLOC_CTX *mem_ctx, struct wrepl_name *name)
 227 {
 228         int i;
 229
 230         printf("%s\n", nbt_name_string(mem_ctx, &name->name));
 231         printf("\tTYPE:%u STATE:%u NODE:%u STATIC:%u VERSION_ID: %llu\n",
 232                 name->type, name->state, name->node, name->is_static, name->version_id);
 233         printf("\tRAW_FLAGS: 0x%08X OWNER: %-15s\n",
 234                 name->raw_flags, name->owner);
 235         for (i=0;i<name->num_addresses;i++) {
 236                 printf("\tADDR: %-15s OWNER: %-15s\n",
 237                         name->addresses[i].address, name->addresses[i].owner);
 238         }
 239 }
 240
 241 /*
 242   test a full replication dump from a WINS server
 243 */
 244 static BOOL test_wins_replication(TALLOC_CTX *mem_ctx, const char *address)
 245 {
 246         BOOL ret = True;
 247         struct wrepl_socket *wrepl_socket;
 248         NTSTATUS status;
 249         int i, j;
 250         struct wrepl_associate associate;
 251         struct wrepl_pull_table pull_table;
 252         struct wrepl_pull_names pull_names;
 253
 254         printf("Test one pull replication cycle\n");
 255
 256         wrepl_socket = wrepl_socket_init(mem_ctx, NULL);
 257
 258         printf("Setup wrepl connections\n");
 259         status = wrepl_connect(wrepl_socket, NULL, address);
 260         CHECK_STATUS(status, NT_STATUS_OK);
 261
 262         printf("Send a start association request\n");
 263
 264         status = wrepl_associate(wrepl_socket, &associate);
 265         CHECK_STATUS(status, NT_STATUS_OK);
 266
 267         printf("association context: 0x%x\n", associate.out.assoc_ctx);
 268
 269         printf("Send a replication table query\n");
 270         pull_table.in.assoc_ctx = associate.out.assoc_ctx;
 271
 272         status = wrepl_pull_table(wrepl_socket, mem_ctx, &pull_table);
 273         if (NT_STATUS_EQUAL(NT_STATUS_NETWORK_ACCESS_DENIED,status)) {
 274                 struct wrepl_packet packet;
 275                 struct wrepl_request *req;
 276
 277                 ZERO_STRUCT(packet);
 278                 packet.opcode                      = WREPL_OPCODE_BITS;
 279                 packet.assoc_ctx                   = associate.out.assoc_ctx;
 280                 packet.mess_type                   = WREPL_STOP_ASSOCIATION;
 281                 packet.message.stop.reason         = 0;
 282
 283                 req = wrepl_request_send(wrepl_socket, &packet);
 284                 talloc_free(req);
 285
 286                 printf("failed - We are not a valid pull partner for the server\n");
 287                 ret = False;
 288                 goto done;
 289         }
 290         CHECK_STATUS(status, NT_STATUS_OK);
 291
 292         printf("Found %d replication partners\n", pull_table.out.num_partners);
 293
 294         for (i=0;i<pull_table.out.num_partners;i++) {
 295                 struct wrepl_wins_owner *partner = &pull_table.out.partners[i];
 296                 printf("%s   max_version=%6llu   min_version=%6llu type=%d\n",
 297                        partner->address,
 298                        partner->max_version,
 299                        partner->min_version,
 300                        partner->type);
 301
 302                 pull_names.in.assoc_ctx = associate.out.assoc_ctx;
 303                 pull_names.in.partner = *partner;
 304
 305                 status = wrepl_pull_names(wrepl_socket, mem_ctx, &pull_names);
 306                 CHECK_STATUS(status, NT_STATUS_OK);
 307
 308                 printf("Received %d names\n", pull_names.out.num_names);
 309
 310                 for (j=0;j<pull_names.out.num_names;j++) {
 311                         display_entry(mem_ctx, &pull_names.out.names[j]);
 312                 }
 313         }
 314
 315 done:
 316         printf("Close wrepl connections\n");
 317         talloc_free(wrepl_socket);
 318         return ret;
 319 }
 320
 321 struct test_wrepl_conflict_conn {
 322         const char *address;
 323         struct wrepl_socket *pull;
 324         uint32_t pull_assoc;
 325
 326 #define TEST_OWNER_A_ADDRESS "127.65.65.1"
 327 #define TEST_ADDRESS_A_PREFIX "127.0.65"
 328 #define TEST_OWNER_B_ADDRESS "127.66.66.1"
 329 #define TEST_ADDRESS_B_PREFIX "127.0.66"
 330
 331         struct wrepl_wins_owner a, b, c;
 332
 333         const char *myaddr;
 334         struct nbt_name_socket *nbtsock;
 335
 336         struct nbt_name_socket *nbtsock_srv;
 337
 338         uint32_t addresses_1_num;
 339         struct wrepl_ip *addresses_1;
 340 };
 341
 342 static const struct wrepl_ip addresses_A_1[] = {
 343         {
 344         .owner  = TEST_OWNER_A_ADDRESS,
 345         .ip     = TEST_ADDRESS_A_PREFIX".1"
 346         }
 347 };
 348 static const struct wrepl_ip addresses_A_2[] = {
 349         {
 350         .owner  = TEST_OWNER_A_ADDRESS,
 351         .ip     = TEST_ADDRESS_A_PREFIX".2"
 352         }
 353 };
 354 static const struct wrepl_ip addresses_A_3_4[] = {
 355         {
 356         .owner  = TEST_OWNER_A_ADDRESS,
 357         .ip     = TEST_ADDRESS_A_PREFIX".3"
 358         },
 359         {
 360         .owner  = TEST_OWNER_A_ADDRESS,
 361         .ip     = TEST_ADDRESS_A_PREFIX".4"
 362         }
 363 };
 364
 365 static const struct wrepl_ip addresses_B_1[] = {
 366         {
 367         .owner  = TEST_OWNER_B_ADDRESS,
 368         .ip     = TEST_ADDRESS_B_PREFIX".1"
 369         }
 370 };
 371 static const struct wrepl_ip addresses_B_2[] = {
 372         {
 373         .owner  = TEST_OWNER_B_ADDRESS,
 374         .ip     = TEST_ADDRESS_B_PREFIX".2"
 375         }
 376 };
 377 static const struct wrepl_ip addresses_B_3_4[] = {
 378         {
 379         .owner  = TEST_OWNER_B_ADDRESS,
 380         .ip     = TEST_ADDRESS_B_PREFIX".3"
 381         },
 382         {
 383         .owner  = TEST_OWNER_B_ADDRESS,
 384         .ip     = TEST_ADDRESS_B_PREFIX".4"
 385         }
 386 };
 387
 388 static struct test_wrepl_conflict_conn *test_create_conflict_ctx(TALLOC_CTX *mem_ctx,
 389                                                                  const char *address)
 390 {
 391         struct test_wrepl_conflict_conn *ctx;
 392         struct wrepl_associate associate;
 393         struct wrepl_pull_table pull_table;
 394         NTSTATUS status;
 395         uint32_t i;
 396
 397         ctx = talloc_zero(mem_ctx, struct test_wrepl_conflict_conn);
 398         if (!ctx) return NULL;
 399
 400         ctx->address    = address;
 401         ctx->pull       = wrepl_socket_init(ctx, NULL);
 402         if (!ctx->pull) return NULL;
 403
 404         printf("Setup wrepl conflict pull connection\n");
 405         status = wrepl_connect(ctx->pull, NULL, ctx->address);
 406         if (!NT_STATUS_IS_OK(status)) return NULL;
 407
 408         status = wrepl_associate(ctx->pull, &associate);
 409         if (!NT_STATUS_IS_OK(status)) return NULL;
 410
 411         ctx->pull_assoc = associate.out.assoc_ctx;
 412
 413         ctx->a.address          = TEST_OWNER_A_ADDRESS;
 414         ctx->a.max_version      = 0;
 415         ctx->a.min_version      = 0;
 416         ctx->a.type             = 1;
 417
 418         ctx->b.address          = TEST_OWNER_B_ADDRESS;
 419         ctx->b.max_version      = 0;
 420         ctx->b.min_version      = 0;
 421         ctx->b.type             = 1;
 422
 423         ctx->c.address          = address;
 424         ctx->c.max_version      = 0;
 425         ctx->c.min_version      = 0;
 426         ctx->c.type             = 1;
 427
 428         pull_table.in.assoc_ctx = ctx->pull_assoc;
 429         status = wrepl_pull_table(ctx->pull, ctx->pull, &pull_table);
 430         if (!NT_STATUS_IS_OK(status)) return NULL;
 431
 432         for (i=0; i < pull_table.out.num_partners; i++) {
 433                 if (strcmp(TEST_OWNER_A_ADDRESS,pull_table.out.partners[i].address)==0) {
 434                         ctx->a.max_version      = pull_table.out.partners[i].max_version;
 435                         ctx->a.min_version      = pull_table.out.partners[i].min_version;
 436                 }
 437                 if (strcmp(TEST_OWNER_B_ADDRESS,pull_table.out.partners[i].address)==0) {
 438                         ctx->b.max_version      = pull_table.out.partners[i].max_version;
 439                         ctx->b.min_version      = pull_table.out.partners[i].min_version;
 440                 }
 441                 if (strcmp(address,pull_table.out.partners[i].address)==0) {
 442                         ctx->c.max_version      = pull_table.out.partners[i].max_version;
 443                         ctx->c.min_version      = pull_table.out.partners[i].min_version;
 444                 }
 445         }
 446
 447         talloc_free(pull_table.out.partners);
 448
 449         ctx->myaddr = talloc_strdup(mem_ctx, iface_best_ip(address));
 450         if (!ctx->myaddr) return NULL;
 451
 452         ctx->nbtsock = nbt_name_socket_init(ctx, NULL);
 453         if (!ctx->nbtsock) return NULL;
 454
 455         status = socket_listen(ctx->nbtsock->sock, ctx->myaddr, 0, 0, 0);
 456         if (!NT_STATUS_IS_OK(status)) return NULL;
 457
 458         ctx->nbtsock_srv = nbt_name_socket_init(ctx, NULL);
 459         if (!ctx->nbtsock_srv) return NULL;
 460
 461         status = socket_listen(ctx->nbtsock_srv->sock, ctx->myaddr, lp_nbt_port(), 0, 0);
 462         if (!NT_STATUS_IS_OK(status)) {
 463                 talloc_free(ctx->nbtsock_srv);
 464                 ctx->nbtsock_srv = NULL;
 465         }
 466
 467         ctx->addresses_1_num = 1;
 468         ctx->addresses_1 = talloc_array(ctx, struct wrepl_ip, ctx->addresses_1_num);
 469         if (!ctx->addresses_1) return NULL;
 470         ctx->addresses_1[0].owner       = ctx->c.address;
 471         ctx->addresses_1[0].ip          = ctx->myaddr;
 472
 473         return ctx;
 474 }
 475
 476 static BOOL test_wrepl_update_one(struct test_wrepl_conflict_conn *ctx,
 477                                   const struct wrepl_wins_owner *owner,
 478                                   const struct wrepl_wins_name *name)
 479 {
 480         BOOL ret = True;
 481         struct wrepl_socket *wrepl_socket;
 482         struct wrepl_associate associate;
 483         struct wrepl_packet update_packet, repl_send;
 484         struct wrepl_table *update;
 485         struct wrepl_wins_owner wrepl_wins_owners[1];
 486         struct wrepl_packet *repl_recv;
 487         struct wrepl_wins_owner *send_request;
 488         struct wrepl_send_reply *send_reply;
 489         struct wrepl_wins_name wrepl_wins_names[1];
 490         uint32_t assoc_ctx;
 491         NTSTATUS status;
 492
 493         wrepl_socket = wrepl_socket_init(ctx, NULL);
 494
 495         status = wrepl_connect(wrepl_socket, NULL, ctx->address);
 496         CHECK_STATUS(status, NT_STATUS_OK);
 497
 498         status = wrepl_associate(wrepl_socket, &associate);
 499         CHECK_STATUS(status, NT_STATUS_OK);
 500         assoc_ctx = associate.out.assoc_ctx;
 501
 502         /* now send a WREPL_REPL_UPDATE message */
 503         ZERO_STRUCT(update_packet);
 504         update_packet.opcode                    = WREPL_OPCODE_BITS;
 505         update_packet.assoc_ctx                 = assoc_ctx;
 506         update_packet.mess_type                 = WREPL_REPLICATION;
 507         update_packet.message.replication.command       = WREPL_REPL_UPDATE;
 508         update  = &update_packet.message.replication.info.table;
 509
 510         update->partner_count   = ARRAY_SIZE(wrepl_wins_owners);
 511         update->partners        = wrepl_wins_owners;
 512         update->initiator       = "0.0.0.0";
 513
 514         wrepl_wins_owners[0]    = *owner;
 515
 516         status = wrepl_request(wrepl_socket, wrepl_socket,
 517                                &update_packet, &repl_recv);
 518         CHECK_STATUS(status, NT_STATUS_OK);
 519         CHECK_VALUE(repl_recv->mess_type, WREPL_REPLICATION);
 520         CHECK_VALUE(repl_recv->message.replication.command, WREPL_REPL_SEND_REQUEST);
 521         send_request = &repl_recv->message.replication.info.owner;
 522
 523         ZERO_STRUCT(repl_send);
 524         repl_send.opcode                        = WREPL_OPCODE_BITS;
 525         repl_send.assoc_ctx                     = assoc_ctx;
 526         repl_send.mess_type                     = WREPL_REPLICATION;
 527         repl_send.message.replication.command   = WREPL_REPL_SEND_REPLY;
 528         send_reply = &repl_send.message.replication.info.reply;
 529
 530         send_reply->num_names   = ARRAY_SIZE(wrepl_wins_names);
 531         send_reply->names       = wrepl_wins_names;
 532
 533         wrepl_wins_names[0]     = *name;
 534
 535         status = wrepl_request(wrepl_socket, wrepl_socket,
 536                                &repl_send, &repl_recv);
 537         CHECK_STATUS(status, NT_STATUS_OK);
 538         CHECK_VALUE(repl_recv->mess_type, WREPL_STOP_ASSOCIATION);
 539         CHECK_VALUE(repl_recv->message.stop.reason, 0);
 540
 541 done:
 542         talloc_free(wrepl_socket);
 543         return ret;
 544 }
 545
 546 #if 0
 547 static BOOL test_wrepl_update_two(struct test_wrepl_conflict_conn *ctx,
 548                                   const struct wrepl_wins_owner *owner,
 549                                   const struct wrepl_wins_name *name1,
 550                                   const struct wrepl_wins_name *name2)
 551 {
 552         BOOL ret = True;
 553         struct wrepl_socket *wrepl_socket;
 554         struct wrepl_associate associate;
 555         struct wrepl_packet update_packet, repl_send;
 556         struct wrepl_table *update;
 557         struct wrepl_wins_owner wrepl_wins_owners[1];
 558         struct wrepl_packet *repl_recv;
 559         struct wrepl_wins_owner *send_request;
 560         struct wrepl_send_reply *send_reply;
 561         struct wrepl_wins_name wrepl_wins_names[2];
 562         uint32_t assoc_ctx;
 563         NTSTATUS status;
 564
 565         wrepl_socket = wrepl_socket_init(ctx, NULL);
 566
 567         status = wrepl_connect(wrepl_socket, NULL, ctx->address);
 568         CHECK_STATUS(status, NT_STATUS_OK);
 569
 570         status = wrepl_associate(wrepl_socket, &associate);
 571         CHECK_STATUS(status, NT_STATUS_OK);
 572         assoc_ctx = associate.out.assoc_ctx;
 573
 574         /* now send a WREPL_REPL_UPDATE message */
 575         ZERO_STRUCT(update_packet);
 576         update_packet.opcode                    = WREPL_OPCODE_BITS;
 577         update_packet.assoc_ctx                 = assoc_ctx;
 578         update_packet.mess_type                 = WREPL_REPLICATION;
 579         update_packet.message.replication.command       = WREPL_REPL_UPDATE;
 580         update  = &update_packet.message.replication.info.table;
 581
 582         update->partner_count   = ARRAY_SIZE(wrepl_wins_owners);
 583         update->partners        = wrepl_wins_owners;
 584         update->initiator       = "0.0.0.0";
 585
 586         wrepl_wins_owners[0]    = *owner;
 587
 588         status = wrepl_request(wrepl_socket, wrepl_socket,
 589                                &update_packet, &repl_recv);
 590         CHECK_STATUS(status, NT_STATUS_OK);
 591         CHECK_VALUE(repl_recv->mess_type, WREPL_REPLICATION);
 592         CHECK_VALUE(repl_recv->message.replication.command, WREPL_REPL_SEND_REQUEST);
 593         send_request = &repl_recv->message.replication.info.owner;
 594
 595         ZERO_STRUCT(repl_send);
 596         repl_send.opcode                        = WREPL_OPCODE_BITS;
 597         repl_send.assoc_ctx                     = assoc_ctx;
 598         repl_send.mess_type                     = WREPL_REPLICATION;
 599         repl_send.message.replication.command   = WREPL_REPL_SEND_REPLY;
 600         send_reply = &repl_send.message.replication.info.reply;
 601
 602         send_reply->num_names   = ARRAY_SIZE(wrepl_wins_names);
 603         send_reply->names       = wrepl_wins_names;
 604
 605         wrepl_wins_names[0]     = *name1;
 606         wrepl_wins_names[1]     = *name2;
 607
 608         status = wrepl_request(wrepl_socket, wrepl_socket,
 609                                &repl_send, &repl_recv);
 610         CHECK_STATUS(status, NT_STATUS_OK);
 611         CHECK_VALUE(repl_recv->mess_type, WREPL_STOP_ASSOCIATION);
 612         CHECK_VALUE(repl_recv->message.stop.reason, 0);
 613
 614 done:
 615         talloc_free(wrepl_socket);
 616         return ret;
 617 }
 618 #endif
 619
 620 static BOOL test_wrepl_is_applied(struct test_wrepl_conflict_conn *ctx,
 621                                   const struct wrepl_wins_owner *owner,
 622                                   const struct wrepl_wins_name *name,
 623                                   BOOL expected)
 624 {
 625         BOOL ret = True;
 626         NTSTATUS status;
 627         struct wrepl_pull_names pull_names;
 628         struct wrepl_name *names;
 629
 630         pull_names.in.assoc_ctx = ctx->pull_assoc;
 631         pull_names.in.partner   = *owner;
 632         pull_names.in.partner.min_version = pull_names.in.partner.max_version;
 633
 634         status = wrepl_pull_names(ctx->pull, ctx->pull, &pull_names);
 635         CHECK_STATUS(status, NT_STATUS_OK);
 636         CHECK_VALUE(pull_names.out.num_names, (expected?1:0));
 637
 638         names = pull_names.out.names;
 639
 640         if (expected) {
 641                 uint32_t flags = WREPL_NAME_FLAGS(names[0].type,
 642                                                   names[0].state,
 643                                                   names[0].node,
 644                                                   names[0].is_static);
 645                 CHECK_VALUE(names[0].name.type, name->name->type);
 646                 CHECK_VALUE_STRING(names[0].name.name, name->name->name);
 647                 CHECK_VALUE_STRING(names[0].name.scope, name->name->scope);
 648                 CHECK_VALUE(flags, name->flags);
 649                 CHECK_VALUE_UINT64(names[0].version_id, name->id);
 650
 651                 if (flags & 2) {
 652                         CHECK_VALUE(names[0].num_addresses,
 653                                     name->addresses.addresses.num_ips);
 654                 } else {
 655                         CHECK_VALUE(names[0].num_addresses, 1);
 656                         CHECK_VALUE_STRING(names[0].addresses[0].address,
 657                                            name->addresses.ip);
 658                 }
 659         }
 660 done:
 661         talloc_free(pull_names.out.names);
 662         return ret;
 663 }
 664
 665 static BOOL test_wrepl_is_merged(struct test_wrepl_conflict_conn *ctx,
 666                                  const struct wrepl_wins_name *name1,
 667                                  const struct wrepl_wins_name *name2)
 668 {
 669         return True;
 670 #if 0
 671         BOOL ret = True;
 672         NTSTATUS status;
 673         struct wrepl_pull_names pull_names;
 674         struct wrepl_name *names;
 675         uint32_t num_ips;
 676
 677         pull_names.in.assoc_ctx = ctx->pull_assoc;
 678         pull_names.in.partner   = ctx->c;
 679         pull_names.in.partner.min_version = ctx->c.max_version-1;
 680
 681         status = wrepl_pull_names(ctx->pull, ctx->pull, &pull_names);
 682         CHECK_STATUS(status, NT_STATUS_OK);
 683         CHECK_VALUE(pull_names.out.num_names, 1);
 684
 685         names = pull_names.out.names;
 686
 687         num_ips = name1->addresses.addresses.num_ips + name2->addresses.addresses.num_ips;
 688
 689         CHECK_VALUE(names[0].name.type, name1->name->type);
 690         CHECK_VALUE_STRING(names[0].name.name, name1->name->name);
 691         CHECK_VALUE_STRING(names[0].name.scope, name1->name->scope);
 692         CHECK_VALUE(names[0].type, WREPL_TYPE_SGROUP);
 693         CHECK_VALUE(names[0].state, (num_ips>0?WREPL_STATE_ACTIVE:WREPL_STATE_RELEASED));
 694         CHECK_VALUE_UINT64(names[0].version_id, ctx->c.max_version);
 695
 696         CHECK_VALUE(names[0].num_addresses,
 697                     name1->addresses.addresses.num_ips+
 698                     name2->addresses.addresses.num_ips);
 699 done:
 700         talloc_free(pull_names.out.names);
 701         return ret;
 702 #endif
 703 }
 704
 705 static BOOL test_conflict_same_owner(struct test_wrepl_conflict_conn *ctx)
 706 {
 707         BOOL ret = True;
 708         struct nbt_name name;
 709         struct wrepl_wins_name wins_name1;
 710         struct wrepl_wins_name wins_name2;
 711         struct wrepl_wins_name *wins_name_tmp;
 712         struct wrepl_wins_name *wins_name_last;
 713         struct wrepl_wins_name *wins_name_cur;
 714         uint32_t i,j;
 715         uint8_t types[] = { 0x00, 0x1C };
 716         struct {
 717                 enum wrepl_name_type type;
 718                 enum wrepl_name_state state;
 719                 enum wrepl_name_node node;
 720                 BOOL is_static;
 721                 uint32_t num_ips;
 722                 const struct wrepl_ip *ips;
 723         } records[] = {
 724                 {
 725                 .type           = WREPL_TYPE_GROUP,
 726                 .state          = WREPL_STATE_ACTIVE,
 727                 .node           = WREPL_NODE_B,
 728                 .is_static      = False,
 729                 .num_ips        = ARRAY_SIZE(addresses_A_1),
 730                 .ips            = addresses_A_1,
 731                 },{
 732                 .type           = WREPL_TYPE_UNIQUE,
 733                 .state          = WREPL_STATE_ACTIVE,
 734                 .node           = WREPL_NODE_B,
 735                 .is_static      = False,
 736                 .num_ips        = ARRAY_SIZE(addresses_A_1),
 737                 .ips            = addresses_A_1,
 738                 },{
 739                 .type           = WREPL_TYPE_UNIQUE,
 740                 .state          = WREPL_STATE_ACTIVE,
 741                 .node           = WREPL_NODE_B,
 742                 .is_static      = False,
 743                 .num_ips        = ARRAY_SIZE(addresses_A_2),
 744                 .ips            = addresses_A_2,
 745                 },{
 746                 .type           = WREPL_TYPE_UNIQUE,
 747                 .state          = WREPL_STATE_ACTIVE,
 748                 .node           = WREPL_NODE_B,
 749                 .is_static      = True,
 750                 .num_ips        = ARRAY_SIZE(addresses_A_1),
 751                 .ips            = addresses_A_1,
 752                 },{
 753                 .type           = WREPL_TYPE_UNIQUE,
 754                 .state          = WREPL_STATE_ACTIVE,
 755                 .node           = WREPL_NODE_B,
 756                 .is_static      = False,
 757                 .num_ips        = ARRAY_SIZE(addresses_A_2),
 758                 .ips            = addresses_A_2,
 759                 },{
 760                 .type           = WREPL_TYPE_SGROUP,
 761                 .state          = WREPL_STATE_TOMBSTONE,
 762                 .node           = WREPL_NODE_B,
 763                 .is_static      = False,
 764                 .num_ips        = ARRAY_SIZE(addresses_A_2),
 765                 .ips            = addresses_A_2,
 766                 },{
 767                 .type           = WREPL_TYPE_MHOMED,
 768                 .state          = WREPL_STATE_TOMBSTONE,
 769                 .node           = WREPL_NODE_B,
 770                 .is_static      = False,
 771                 .num_ips        = ARRAY_SIZE(addresses_A_1),
 772                 .ips            = addresses_A_1,
 773                 },{
 774                 .type           = WREPL_TYPE_MHOMED,
 775                 .state          = WREPL_STATE_RELEASED,
 776                 .node           = WREPL_NODE_B,
 777                 .is_static      = False,
 778                 .num_ips        = ARRAY_SIZE(addresses_A_2),
 779                 .ips            = addresses_A_2,
 780                 },{
 781                 .type           = WREPL_TYPE_SGROUP,
 782                 .state          = WREPL_STATE_ACTIVE,
 783                 .node           = WREPL_NODE_B,
 784                 .is_static      = False,
 785                 .num_ips        = ARRAY_SIZE(addresses_A_1),
 786                 .ips            = addresses_A_1,
 787                 },{
 788                 .type           = WREPL_TYPE_SGROUP,
 789                 .state          = WREPL_STATE_ACTIVE,
 790                 .node           = WREPL_NODE_B,
 791                 .is_static      = False,
 792                 .num_ips        = ARRAY_SIZE(addresses_A_3_4),
 793                 .ips            = addresses_A_3_4,
 794                 },{
 795                 .type           = WREPL_TYPE_SGROUP,
 796                 .state          = WREPL_STATE_TOMBSTONE,
 797                 .node           = WREPL_NODE_B,
 798                 .is_static      = False,
 799                 .num_ips        = ARRAY_SIZE(addresses_B_3_4),
 800                 .ips            = addresses_B_3_4,
 801                 },{
 802                 /* the last one should always be a unique,tomstone record! */
 803                 .type           = WREPL_TYPE_UNIQUE,
 804                 .state          = WREPL_STATE_TOMBSTONE,
 805                 .node           = WREPL_NODE_B,
 806                 .is_static      = False,
 807                 .num_ips        = ARRAY_SIZE(addresses_A_1),
 808                 .ips            = addresses_A_1,
 809                 }
 810         };
 811
 812         if (!ctx) return False;
 813
 814         name.name       = "_SAME_OWNER_A";
 815         name.type       = 0;
 816         name.scope      = NULL;
 817
 818         wins_name_tmp   = NULL;
 819         wins_name_last  = &wins_name2;
 820         wins_name_cur   = &wins_name1;
 821
 822         for (j=0; ret && j < ARRAY_SIZE(types); j++) {
 823                 name.type = types[j];
 824                 printf("Test Replica Conflicts with same owner[%s] for %s\n",
 825                         nbt_name_string(ctx, &name), ctx->a.address);
 826
 827                 for(i=0; ret && i < ARRAY_SIZE(records); i++) {
 828                         wins_name_tmp   = wins_name_last;
 829                         wins_name_last  = wins_name_cur;
 830                         wins_name_cur   = wins_name_tmp;
 831
 832                         if (i > 0) {
 833                                 printf("%s,%s%s vs. %s,%s%s with %s ip(s) => %s\n",
 834                                         wrepl_name_type_string(records[i-1].type),
 835                                         wrepl_name_state_string(records[i-1].state),
 836                                         (records[i-1].is_static?",static":""),
 837                                         wrepl_name_type_string(records[i].type),
 838                                         wrepl_name_state_string(records[i].state),
 839                                         (records[i].is_static?",static":""),
 840                                         (records[i-1].ips==records[i].ips?"same":"different"),
 841                                         "REPLACE");
 842                         }
 843
 844                         wins_name_cur->name     = &name;
 845                         wins_name_cur->flags    = WREPL_NAME_FLAGS(records[i].type,
 846                                                                    records[i].state,
 847                                                                    records[i].node,
 848                                                                    records[i].is_static);
 849                         wins_name_cur->id       = ++ctx->a.max_version;
 850                         if (wins_name_cur->flags & 2) {
 851                                 wins_name_cur->addresses.addresses.num_ips = records[i].num_ips;
 852                                 wins_name_cur->addresses.addresses.ips     = discard_const(records[i].ips);
 853                         } else {
 854                                 wins_name_cur->addresses.ip = records[i].ips[0].ip;
 855                         }
 856                         wins_name_cur->unknown  = "255.255.255.255";
 857
 858                         ret &= test_wrepl_update_one(ctx, &ctx->a,wins_name_cur);
 859                         if (records[i].state == WREPL_STATE_RELEASED) {
 860                                 ret &= test_wrepl_is_applied(ctx, &ctx->a, wins_name_last, False);
 861                                 ret &= test_wrepl_is_applied(ctx, &ctx->a, wins_name_cur, False);
 862                         } else {
 863                                 ret &= test_wrepl_is_applied(ctx, &ctx->a, wins_name_cur, True);
 864                         }
 865
 866                         /* the first one is a cleanup run */
 867                         if (!ret && i == 0) ret = True;
 868
 869                         if (!ret) {
 870                                 printf("conflict handled wrong or record[%u]: %s\n", i, __location__);
 871                                 return ret;
 872                         }
 873                 }
 874         }
 875         return ret;
 876 }
 877
 878 static BOOL test_conflict_different_owner(struct test_wrepl_conflict_conn *ctx)
 879 {
 880         BOOL ret = True;
 881         struct wrepl_wins_name wins_name1;
 882         struct wrepl_wins_name wins_name2;
 883         struct wrepl_wins_name *wins_name_r1;
 884         struct wrepl_wins_name *wins_name_r2;
 885         uint32_t i;
 886         struct {
 887                 const char *line; /* just better debugging */
 888                 struct nbt_name name;
 889                 BOOL extra; /* not the worst case, this is an extra test */
 890                 BOOL cleanup;
 891                 struct {
 892                         struct wrepl_wins_owner *owner;
 893                         enum wrepl_name_type type;
 894                         enum wrepl_name_state state;
 895                         enum wrepl_name_node node;
 896                         BOOL is_static;
 897                         uint32_t num_ips;
 898                         const struct wrepl_ip *ips;
 899                         BOOL apply_expected;
 900                         BOOL merge_expected;
 901                 } r1, r2;
 902         } records[] = {
 903         /*
 904          * NOTE: the first record and the last applied one
 905          *       needs to be from the same owner,
 906          *       to not conflict in the next smbtorture run!!!
 907          */
 908         {
 909                 .line   = __location__,
 910                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
 911                 .cleanup= True,
 912                 .r1     = {
 913                         .owner          = &ctx->b,
 914                         .type           = WREPL_TYPE_UNIQUE,
 915                         .state          = WREPL_STATE_TOMBSTONE,
 916                         .node           = WREPL_NODE_B,
 917                         .is_static      = False,
 918                         .num_ips        = ARRAY_SIZE(addresses_B_1),
 919                         .ips            = addresses_B_1,
 920                         .apply_expected = True /* ignored */
 921                 },
 922                 .r2     = {
 923                         .owner          = &ctx->a,
 924                         .type           = WREPL_TYPE_UNIQUE,
 925                         .state          = WREPL_STATE_TOMBSTONE,
 926                         .node           = WREPL_NODE_B,
 927                         .is_static      = False,
 928                         .num_ips        = ARRAY_SIZE(addresses_A_1),
 929                         .ips            = addresses_A_1,
 930                         .apply_expected = True /* ignored */
 931                 }
 932         },
 933
 934 /*
 935  * unique vs unique section
 936  */
 937         /*
 938          * unique,active vs. unique,active
 939          * => should be replaced
 940          */
 941         {
 942                 .line   = __location__,
 943                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
 944                 .r1     = {
 945                         .owner          = &ctx->a,
 946                         .type           = WREPL_TYPE_UNIQUE,
 947                         .state          = WREPL_STATE_ACTIVE,
 948                         .node           = WREPL_NODE_B,
 949                         .is_static      = False,
 950                         .num_ips        = ARRAY_SIZE(addresses_A_1),
 951                         .ips            = addresses_A_1,
 952                         .apply_expected = True
 953                 },
 954                 .r2     = {
 955                         .owner          = &ctx->b,
 956                         .type           = WREPL_TYPE_UNIQUE,
 957                         .state          = WREPL_STATE_ACTIVE,
 958                         .node           = WREPL_NODE_B,
 959                         .is_static      = False,
 960                         .num_ips        = ARRAY_SIZE(addresses_B_1),
 961                         .ips            = addresses_B_1,
 962                         .apply_expected = True
 963                 }
 964         },
 965
 966         /*
 967          * unique,active vs. unique,tombstone
 968          * => should NOT be replaced
 969          */
 970         {
 971                 .line   = __location__,
 972                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
 973                 .r1     = {
 974                         .owner          = &ctx->b,
 975                         .type           = WREPL_TYPE_UNIQUE,
 976                         .state          = WREPL_STATE_ACTIVE,
 977                         .node           = WREPL_NODE_B,
 978                         .is_static      = False,
 979                         .num_ips        = ARRAY_SIZE(addresses_B_1),
 980                         .ips            = addresses_B_1,
 981                         .apply_expected = True
 982                 },
 983                 .r2     = {
 984                         .owner          = &ctx->a,
 985                         .type           = WREPL_TYPE_UNIQUE,
 986                         .state          = WREPL_STATE_TOMBSTONE,
 987                         .node           = WREPL_NODE_B,
 988                         .is_static      = False,
 989                         .num_ips        = ARRAY_SIZE(addresses_B_1),
 990                         .ips            = addresses_B_1,
 991                         .apply_expected = False
 992                 }
 993         },
 994
 995         /*
 996          * unique,released vs. unique,active
 997          * => should be replaced
 998          */
 999         {
1000                 .line   = __location__,
1001                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1002                 .r1     = {
1003                         .owner          = &ctx->b,
1004                         .type           = WREPL_TYPE_UNIQUE,
1005                         .state          = WREPL_STATE_RELEASED,
1006                         .node           = WREPL_NODE_B,
1007                         .is_static      = False,
1008                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1009                         .ips            = addresses_B_1,
1010                         .apply_expected = False
1011                 },
1012                 .r2     = {
1013                         .owner          = &ctx->a,
1014                         .type           = WREPL_TYPE_UNIQUE,
1015                         .state          = WREPL_STATE_ACTIVE,
1016                         .node           = WREPL_NODE_B,
1017                         .is_static      = False,
1018                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1019                         .ips            = addresses_A_1,
1020                         .apply_expected = True
1021                 }
1022         },
1023
1024         /*
1025          * unique,released vs. unique,tombstone
1026          * => should be replaced
1027          */
1028         {
1029                 .line   = __location__,
1030                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1031                 .r1     = {
1032                         .owner          = &ctx->a,
1033                         .type           = WREPL_TYPE_UNIQUE,
1034                         .state          = WREPL_STATE_RELEASED,
1035                         .node           = WREPL_NODE_B,
1036                         .is_static      = False,
1037                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1038                         .ips            = addresses_A_1,
1039                         .apply_expected = False
1040                 },
1041                 .r2     = {
1042                         .owner          = &ctx->b,
1043                         .type           = WREPL_TYPE_UNIQUE,
1044                         .state          = WREPL_STATE_TOMBSTONE,
1045                         .node           = WREPL_NODE_B,
1046                         .is_static      = False,
1047                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1048                         .ips            = addresses_B_1,
1049                         .apply_expected = True
1050                 }
1051         },
1052
1053         /*
1054          * unique,tombstone vs. unique,active
1055          * => should be replaced
1056          */
1057         {
1058                 .line   = __location__,
1059                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1060                 .r1     = {
1061                         .owner          = &ctx->b,
1062                         .type           = WREPL_TYPE_UNIQUE,
1063                         .state          = WREPL_STATE_TOMBSTONE,
1064                         .node           = WREPL_NODE_B,
1065                         .is_static      = False,
1066                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1067                         .ips            = addresses_B_1,
1068                         .apply_expected = True
1069                 },
1070                 .r2     = {
1071                         .owner          = &ctx->a,
1072                         .type           = WREPL_TYPE_UNIQUE,
1073                         .state          = WREPL_STATE_ACTIVE,
1074                         .node           = WREPL_NODE_B,
1075                         .is_static      = False,
1076                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1077                         .ips            = addresses_A_1,
1078                         .apply_expected = True
1079                 }
1080         },
1081
1082         /*
1083          * unique,tombstone vs. unique,tombstone
1084          * => should be replaced
1085          */
1086         {
1087                 .line   = __location__,
1088                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1089                 .r1     = {
1090                         .owner          = &ctx->a,
1091                         .type           = WREPL_TYPE_UNIQUE,
1092                         .state          = WREPL_STATE_TOMBSTONE,
1093                         .node           = WREPL_NODE_B,
1094                         .is_static      = False,
1095                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1096                         .ips            = addresses_A_1,
1097                         .apply_expected = True
1098                 },
1099                 .r2     = {
1100                         .owner          = &ctx->b,
1101                         .type           = WREPL_TYPE_UNIQUE,
1102                         .state          = WREPL_STATE_TOMBSTONE,
1103                         .node           = WREPL_NODE_B,
1104                         .is_static      = False,
1105                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1106                         .ips            = addresses_B_1,
1107                         .apply_expected = True
1108                 }
1109         },
1110
1111
1112 /*
1113  * unique vs normal groups section,
1114  */
1115         /*
1116          * unique,active vs. group,active
1117          * => should be replaced
1118          */
1119         {
1120                 .line   = __location__,
1121                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1122                 .r1     = {
1123                         .owner          = &ctx->b,
1124                         .type           = WREPL_TYPE_UNIQUE,
1125                         .state          = WREPL_STATE_ACTIVE,
1126                         .node           = WREPL_NODE_B,
1127                         .is_static      = False,
1128                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1129                         .ips            = addresses_B_1,
1130                         .apply_expected = True
1131                 },
1132                 .r2     = {
1133                         .owner          = &ctx->a,
1134                         .type           = WREPL_TYPE_GROUP,
1135                         .state          = WREPL_STATE_ACTIVE,
1136                         .node           = WREPL_NODE_B,
1137                         .is_static      = False,
1138                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1139                         .ips            = addresses_A_1,
1140                         .apply_expected = True
1141                 }
1142         },
1143
1144         /*
1145          * unique,active vs. group,tombstone
1146          * => should NOT be replaced
1147          */
1148         {
1149                 .line   = __location__,
1150                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1151                 .r1     = {
1152                         .owner          = &ctx->a,
1153                         .type           = WREPL_TYPE_UNIQUE,
1154                         .state          = WREPL_STATE_ACTIVE,
1155                         .node           = WREPL_NODE_B,
1156                         .is_static      = False,
1157                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1158                         .ips            = addresses_A_1,
1159                         .apply_expected = True
1160                 },
1161                 .r2     = {
1162                         .owner          = &ctx->b,
1163                         .type           = WREPL_TYPE_GROUP,
1164                         .state          = WREPL_STATE_TOMBSTONE,
1165                         .node           = WREPL_NODE_B,
1166                         .is_static      = False,
1167                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1168                         .ips            = addresses_A_1,
1169                         .apply_expected = False
1170                 }
1171         },
1172
1173         /*
1174          * unique,released vs. group,active
1175          * => should be replaced
1176          */
1177         {
1178                 .line   = __location__,
1179                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1180                 .r1     = {
1181                         .owner          = &ctx->a,
1182                         .type           = WREPL_TYPE_UNIQUE,
1183                         .state          = WREPL_STATE_RELEASED,
1184                         .node           = WREPL_NODE_B,
1185                         .is_static      = False,
1186                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1187                         .ips            = addresses_A_1,
1188                         .apply_expected = False
1189                 },
1190                 .r2     = {
1191                         .owner          = &ctx->b,
1192                         .type           = WREPL_TYPE_GROUP,
1193                         .state          = WREPL_STATE_ACTIVE,
1194                         .node           = WREPL_NODE_B,
1195                         .is_static      = False,
1196                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1197                         .ips            = addresses_B_1,
1198                         .apply_expected = True
1199                 }
1200         },
1201
1202         /*
1203          * unique,released vs. group,tombstone
1204          * => should be replaced
1205          */
1206         {
1207                 .line   = __location__,
1208                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1209                 .r1     = {
1210                         .owner          = &ctx->b,
1211                         .type           = WREPL_TYPE_UNIQUE,
1212                         .state          = WREPL_STATE_RELEASED,
1213                         .node           = WREPL_NODE_B,
1214                         .is_static      = False,
1215                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1216                         .ips            = addresses_B_1,
1217                         .apply_expected = False
1218                 },
1219                 .r2     = {
1220                         .owner          = &ctx->a,
1221                         .type           = WREPL_TYPE_GROUP,
1222                         .state          = WREPL_STATE_TOMBSTONE,
1223                         .node           = WREPL_NODE_B,
1224                         .is_static      = False,
1225                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1226                         .ips            = addresses_A_1,
1227                         .apply_expected = True
1228                 }
1229         },
1230
1231         /*
1232          * unique,tombstone vs. group,active
1233          * => should be replaced
1234          */
1235         {
1236                 .line   = __location__,
1237                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1238                 .r1     = {
1239                         .owner          = &ctx->a,
1240                         .type           = WREPL_TYPE_UNIQUE,
1241                         .state          = WREPL_STATE_TOMBSTONE,
1242                         .node           = WREPL_NODE_B,
1243                         .is_static      = False,
1244                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1245                         .ips            = addresses_A_1,
1246                         .apply_expected = True
1247                 },
1248                 .r2     = {
1249                         .owner          = &ctx->b,
1250                         .type           = WREPL_TYPE_GROUP,
1251                         .state          = WREPL_STATE_ACTIVE,
1252                         .node           = WREPL_NODE_B,
1253                         .is_static      = False,
1254                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1255                         .ips            = addresses_B_1,
1256                         .apply_expected = True
1257                 }
1258         },
1259
1260         /*
1261          * unique,tombstone vs. group,tombstone
1262          * => should be replaced
1263          */
1264         {
1265                 .line   = __location__,
1266                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1267                 .r1     = {
1268                         .owner          = &ctx->b,
1269                         .type           = WREPL_TYPE_UNIQUE,
1270                         .state          = WREPL_STATE_TOMBSTONE,
1271                         .node           = WREPL_NODE_B,
1272                         .is_static      = False,
1273                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1274                         .ips            = addresses_B_1,
1275                         .apply_expected = True
1276                 },
1277                 .r2     = {
1278                         .owner          = &ctx->a,
1279                         .type           = WREPL_TYPE_GROUP,
1280                         .state          = WREPL_STATE_TOMBSTONE,
1281                         .node           = WREPL_NODE_B,
1282                         .is_static      = False,
1283                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1284                         .ips            = addresses_A_1,
1285                         .apply_expected = True
1286                 }
1287         },
1288
1289 /*
1290  * unique vs special groups section,
1291  */
1292         /*
1293          * unique,active vs. sgroup,active
1294          * => should NOT be replaced
1295          */
1296         {
1297                 .line   = __location__,
1298                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1299                 .r1     = {
1300                         .owner          = &ctx->a,
1301                         .type           = WREPL_TYPE_UNIQUE,
1302                         .state          = WREPL_STATE_ACTIVE,
1303                         .node           = WREPL_NODE_B,
1304                         .is_static      = False,
1305                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1306                         .ips            = addresses_A_1,
1307                         .apply_expected = True
1308                 },
1309                 .r2     = {
1310                         .owner          = &ctx->b,
1311                         .type           = WREPL_TYPE_SGROUP,
1312                         .state          = WREPL_STATE_ACTIVE,
1313                         .node           = WREPL_NODE_B,
1314                         .is_static      = False,
1315                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1316                         .ips            = addresses_A_1,
1317                         .apply_expected = False
1318                 }
1319         },
1320
1321         /*
1322          * unique,active vs. sgroup,tombstone
1323          * => should NOT be replaced
1324          */
1325         {
1326                 .line   = __location__,
1327                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1328                 .r1     = {
1329                         .owner          = &ctx->a,
1330                         .type           = WREPL_TYPE_UNIQUE,
1331                         .state          = WREPL_STATE_ACTIVE,
1332                         .node           = WREPL_NODE_B,
1333                         .is_static      = False,
1334                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1335                         .ips            = addresses_A_1,
1336                         .apply_expected = True
1337                 },
1338                 .r2     = {
1339                         .owner          = &ctx->b,
1340                         .type           = WREPL_TYPE_SGROUP,
1341                         .state          = WREPL_STATE_TOMBSTONE,
1342                         .node           = WREPL_NODE_B,
1343                         .is_static      = False,
1344                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1345                         .ips            = addresses_A_1,
1346                         .apply_expected = False
1347                 }
1348         },
1349
1350         /*
1351          * unique,released vs. sgroup,active
1352          * => should be replaced
1353          */
1354         {
1355                 .line   = __location__,
1356                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1357                 .r1     = {
1358                         .owner          = &ctx->a,
1359                         .type           = WREPL_TYPE_UNIQUE,
1360                         .state          = WREPL_STATE_RELEASED,
1361                         .node           = WREPL_NODE_B,
1362                         .is_static      = False,
1363                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1364                         .ips            = addresses_A_1,
1365                         .apply_expected = False
1366                 },
1367                 .r2     = {
1368                         .owner          = &ctx->b,
1369                         .type           = WREPL_TYPE_SGROUP,
1370                         .state          = WREPL_STATE_ACTIVE,
1371                         .node           = WREPL_NODE_B,
1372                         .is_static      = False,
1373                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
1374                         .ips            = addresses_B_3_4,
1375                         .apply_expected = True
1376                 }
1377         },
1378
1379         /*
1380          * unique,released vs. sgroup,tombstone
1381          * => should be replaced
1382          */
1383         {
1384                 .line   = __location__,
1385                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1386                 .r1     = {
1387                         .owner          = &ctx->b,
1388                         .type           = WREPL_TYPE_UNIQUE,
1389                         .state          = WREPL_STATE_RELEASED,
1390                         .node           = WREPL_NODE_B,
1391                         .is_static      = False,
1392                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1393                         .ips            = addresses_B_1,
1394                         .apply_expected = False
1395                 },
1396                 .r2     = {
1397                         .owner          = &ctx->a,
1398                         .type           = WREPL_TYPE_SGROUP,
1399                         .state          = WREPL_STATE_TOMBSTONE,
1400                         .node           = WREPL_NODE_B,
1401                         .is_static      = False,
1402                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
1403                         .ips            = addresses_A_3_4,
1404                         .apply_expected = True
1405                 }
1406         },
1407
1408         /*
1409          * unique,tombstone vs. sgroup,active
1410          * => should be replaced
1411          */
1412         {
1413                 .line   = __location__,
1414                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1415                 .r1     = {
1416                         .owner          = &ctx->a,
1417                         .type           = WREPL_TYPE_UNIQUE,
1418                         .state          = WREPL_STATE_TOMBSTONE,
1419                         .node           = WREPL_NODE_B,
1420                         .is_static      = False,
1421                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1422                         .ips            = addresses_A_1,
1423                         .apply_expected = True
1424                 },
1425                 .r2     = {
1426                         .owner          = &ctx->b,
1427                         .type           = WREPL_TYPE_SGROUP,
1428                         .state          = WREPL_STATE_ACTIVE,
1429                         .node           = WREPL_NODE_B,
1430                         .is_static      = False,
1431                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
1432                         .ips            = addresses_B_3_4,
1433                         .apply_expected = True
1434                 }
1435         },
1436
1437         /*
1438          * unique,tombstone vs. sgroup,tombstone
1439          * => should be replaced
1440          */
1441         {
1442                 .line   = __location__,
1443                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1444                 .r1     = {
1445                         .owner          = &ctx->b,
1446                         .type           = WREPL_TYPE_UNIQUE,
1447                         .state          = WREPL_STATE_TOMBSTONE,
1448                         .node           = WREPL_NODE_B,
1449                         .is_static      = False,
1450                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1451                         .ips            = addresses_B_1,
1452                         .apply_expected = True
1453                 },
1454                 .r2     = {
1455                         .owner          = &ctx->a,
1456                         .type           = WREPL_TYPE_SGROUP,
1457                         .state          = WREPL_STATE_TOMBSTONE,
1458                         .node           = WREPL_NODE_B,
1459                         .is_static      = False,
1460                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
1461                         .ips            = addresses_A_3_4,
1462                         .apply_expected = True
1463                 }
1464         },
1465
1466 /*
1467  * unique vs multi homed section,
1468  */
1469         /*
1470          * unique,active vs. mhomed,active
1471          * => should be replaced
1472          */
1473         {
1474                 .line   = __location__,
1475                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1476                 .r1     = {
1477                         .owner          = &ctx->a,
1478                         .type           = WREPL_TYPE_UNIQUE,
1479                         .state          = WREPL_STATE_ACTIVE,
1480                         .node           = WREPL_NODE_B,
1481                         .is_static      = False,
1482                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1483                         .ips            = addresses_A_1,
1484                         .apply_expected = True
1485                 },
1486                 .r2     = {
1487                         .owner          = &ctx->b,
1488                         .type           = WREPL_TYPE_MHOMED,
1489                         .state          = WREPL_STATE_ACTIVE,
1490                         .node           = WREPL_NODE_B,
1491                         .is_static      = False,
1492                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
1493                         .ips            = addresses_B_3_4,
1494                         .apply_expected = True
1495                 }
1496         },
1497
1498         /*
1499          * unique,active vs. mhomed,tombstone
1500          * => should NOT be replaced
1501          */
1502         {
1503                 .line   = __location__,
1504                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1505                 .r1     = {
1506                         .owner          = &ctx->b,
1507                         .type           = WREPL_TYPE_UNIQUE,
1508                         .state          = WREPL_STATE_ACTIVE,
1509                         .node           = WREPL_NODE_B,
1510                         .is_static      = False,
1511                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
1512                         .ips            = addresses_B_3_4,
1513                         .apply_expected = True
1514                 },
1515                 .r2     = {
1516                         .owner          = &ctx->a,
1517                         .type           = WREPL_TYPE_MHOMED,
1518                         .state          = WREPL_STATE_TOMBSTONE,
1519                         .node           = WREPL_NODE_B,
1520                         .is_static      = False,
1521                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
1522                         .ips            = addresses_B_3_4,
1523                         .apply_expected = False
1524                 }
1525         },
1526
1527         /*
1528          * unique,released vs. mhomed,active
1529          * => should be replaced
1530          */
1531         {
1532                 .line   = __location__,
1533                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1534                 .r1     = {
1535                         .owner          = &ctx->b,
1536                         .type           = WREPL_TYPE_UNIQUE,
1537                         .state          = WREPL_STATE_RELEASED,
1538                         .node           = WREPL_NODE_B,
1539                         .is_static      = False,
1540                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1541                         .ips            = addresses_B_1,
1542                         .apply_expected = False
1543                 },
1544                 .r2     = {
1545                         .owner          = &ctx->a,
1546                         .type           = WREPL_TYPE_MHOMED,
1547                         .state          = WREPL_STATE_ACTIVE,
1548                         .node           = WREPL_NODE_B,
1549                         .is_static      = False,
1550                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
1551                         .ips            = addresses_A_3_4,
1552                         .apply_expected = True
1553                 }
1554         },
1555
1556         /*
1557          * unique,released vs. mhomed,tombstone
1558          * => should be replaced
1559          */
1560         {
1561                 .line   = __location__,
1562                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1563                 .r1     = {
1564                         .owner          = &ctx->a,
1565                         .type           = WREPL_TYPE_UNIQUE,
1566                         .state          = WREPL_STATE_RELEASED,
1567                         .node           = WREPL_NODE_B,
1568                         .is_static      = False,
1569                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1570                         .ips            = addresses_A_1,
1571                         .apply_expected = False
1572                 },
1573                 .r2     = {
1574                         .owner          = &ctx->b,
1575                         .type           = WREPL_TYPE_MHOMED,
1576                         .state          = WREPL_STATE_TOMBSTONE,
1577                         .node           = WREPL_NODE_B,
1578                         .is_static      = False,
1579                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
1580                         .ips            = addresses_B_3_4,
1581                         .apply_expected = True
1582                 }
1583         },
1584
1585         /*
1586          * unique,tombstone vs. mhomed,active
1587          * => should be replaced
1588          */
1589         {
1590                 .line   = __location__,
1591                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1592                 .r1     = {
1593                         .owner          = &ctx->b,
1594                         .type           = WREPL_TYPE_UNIQUE,
1595                         .state          = WREPL_STATE_TOMBSTONE,
1596                         .node           = WREPL_NODE_B,
1597                         .is_static      = False,
1598                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1599                         .ips            = addresses_B_1,
1600                         .apply_expected = True
1601                 },
1602                 .r2     = {
1603                         .owner          = &ctx->a,
1604                         .type           = WREPL_TYPE_MHOMED,
1605                         .state          = WREPL_STATE_ACTIVE,
1606                         .node           = WREPL_NODE_B,
1607                         .is_static      = False,
1608                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
1609                         .ips            = addresses_A_3_4,
1610                         .apply_expected = True
1611                 }
1612         },
1613
1614         /*
1615          * unique,tombstone vs. mhomed,tombstone
1616          * => should be replaced
1617          */
1618         {
1619                 .line   = __location__,
1620                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1621                 .r1     = {
1622                         .owner          = &ctx->a,
1623                         .type           = WREPL_TYPE_UNIQUE,
1624                         .state          = WREPL_STATE_TOMBSTONE,
1625                         .node           = WREPL_NODE_B,
1626                         .is_static      = False,
1627                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1628                         .ips            = addresses_A_1,
1629                         .apply_expected = True
1630                 },
1631                 .r2     = {
1632                         .owner          = &ctx->b,
1633                         .type           = WREPL_TYPE_MHOMED,
1634                         .state          = WREPL_STATE_TOMBSTONE,
1635                         .node           = WREPL_NODE_B,
1636                         .is_static      = False,
1637                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
1638                         .ips            = addresses_B_3_4,
1639                         .apply_expected = True
1640                 }
1641         },
1642
1643 /*
1644  * normal groups vs unique section,
1645  */
1646         /*
1647          * group,active vs. unique,active
1648          * => should NOT be replaced
1649          */
1650         {
1651                 .line   = __location__,
1652                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1653                 .r1     = {
1654                         .owner          = &ctx->a,
1655                         .type           = WREPL_TYPE_GROUP,
1656                         .state          = WREPL_STATE_ACTIVE,
1657                         .node           = WREPL_NODE_B,
1658                         .is_static      = False,
1659                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1660                         .ips            = addresses_A_1,
1661                         .apply_expected = True
1662                 },
1663                 .r2     = {
1664                         .owner          = &ctx->b,
1665                         .type           = WREPL_TYPE_UNIQUE,
1666                         .state          = WREPL_STATE_ACTIVE,
1667                         .node           = WREPL_NODE_B,
1668                         .is_static      = False,
1669                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1670                         .ips            = addresses_A_1,
1671                         .apply_expected = False
1672                 }
1673         },
1674
1675         /*
1676          * group,active vs. unique,tombstone
1677          * => should NOT be replaced
1678          */
1679         {
1680                 .line   = __location__,
1681                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1682                 .r1     = {
1683                         .owner          = &ctx->a,
1684                         .type           = WREPL_TYPE_GROUP,
1685                         .state          = WREPL_STATE_ACTIVE,
1686                         .node           = WREPL_NODE_B,
1687                         .is_static      = False,
1688                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1689                         .ips            = addresses_A_1,
1690                         .apply_expected = True
1691                 },
1692                 .r2     = {
1693                         .owner          = &ctx->b,
1694                         .type           = WREPL_TYPE_UNIQUE,
1695                         .state          = WREPL_STATE_TOMBSTONE,
1696                         .node           = WREPL_NODE_B,
1697                         .is_static      = False,
1698                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1699                         .ips            = addresses_A_1,
1700                         .apply_expected = False
1701                 }
1702         },
1703
1704         /*
1705          * group,released vs. unique,active
1706          * => should NOT be replaced
1707          */
1708         {
1709                 .line   = __location__,
1710                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1711                 .r1     = {
1712                         .owner          = &ctx->a,
1713                         .type           = WREPL_TYPE_GROUP,
1714                         .state          = WREPL_STATE_RELEASED,
1715                         .node           = WREPL_NODE_B,
1716                         .is_static      = False,
1717                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1718                         .ips            = addresses_A_1,
1719                         .apply_expected = False
1720                 },
1721                 .r2     = {
1722                         .owner          = &ctx->b,
1723                         .type           = WREPL_TYPE_UNIQUE,
1724                         .state          = WREPL_STATE_ACTIVE,
1725                         .node           = WREPL_NODE_B,
1726                         .is_static      = False,
1727                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1728                         .ips            = addresses_A_1,
1729                         .apply_expected = False
1730                 }
1731         },
1732
1733         /*
1734          * group,released vs. unique,tombstone
1735          * => should NOT be replaced
1736          */
1737         {
1738                 .line   = __location__,
1739                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1740                 .r1     = {
1741                         .owner          = &ctx->a,
1742                         .type           = WREPL_TYPE_GROUP,
1743                         .state          = WREPL_STATE_RELEASED,
1744                         .node           = WREPL_NODE_B,
1745                         .is_static      = False,
1746                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1747                         .ips            = addresses_A_1,
1748                         .apply_expected = False
1749                 },
1750                 .r2     = {
1751                         .owner          = &ctx->b,
1752                         .type           = WREPL_TYPE_UNIQUE,
1753                         .state          = WREPL_STATE_TOMBSTONE,
1754                         .node           = WREPL_NODE_B,
1755                         .is_static      = False,
1756                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1757                         .ips            = addresses_A_1,
1758                         .apply_expected = False
1759                 }
1760         },
1761
1762         /*
1763          * group,tombstone vs. unique,active
1764          * => should NOT be replaced
1765          */
1766         {
1767                 .line   = __location__,
1768                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1769                 .r1     = {
1770                         .owner          = &ctx->a,
1771                         .type           = WREPL_TYPE_GROUP,
1772                         .state          = WREPL_STATE_TOMBSTONE,
1773                         .node           = WREPL_NODE_B,
1774                         .is_static      = False,
1775                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1776                         .ips            = addresses_A_1,
1777                         .apply_expected = True
1778                 },
1779                 .r2     = {
1780                         .owner          = &ctx->b,
1781                         .type           = WREPL_TYPE_UNIQUE,
1782                         .state          = WREPL_STATE_ACTIVE,
1783                         .node           = WREPL_NODE_B,
1784                         .is_static      = False,
1785                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1786                         .ips            = addresses_A_1,
1787                         .apply_expected = False
1788                 }
1789         },
1790
1791         /*
1792          * group,tombstone vs. unique,tombstone
1793          * => should NOT be replaced
1794          */
1795         {
1796                 .line   = __location__,
1797                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1798                 .r1     = {
1799                         .owner          = &ctx->a,
1800                         .type           = WREPL_TYPE_GROUP,
1801                         .state          = WREPL_STATE_TOMBSTONE,
1802                         .node           = WREPL_NODE_B,
1803                         .is_static      = False,
1804                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1805                         .ips            = addresses_A_1,
1806                         .apply_expected = True
1807                 },
1808                 .r2     = {
1809                         .owner          = &ctx->b,
1810                         .type           = WREPL_TYPE_UNIQUE,
1811                         .state          = WREPL_STATE_TOMBSTONE,
1812                         .node           = WREPL_NODE_B,
1813                         .is_static      = False,
1814                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1815                         .ips            = addresses_A_1,
1816                         .apply_expected = False
1817                 }
1818         },
1819
1820 /*
1821  * normal groups vs normal groups section,
1822  */
1823         /*
1824          * group,active vs. group,active
1825          * => should NOT be replaced
1826          */
1827         {
1828                 .line   = __location__,
1829                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1830                 .r1     = {
1831                         .owner          = &ctx->a,
1832                         .type           = WREPL_TYPE_GROUP,
1833                         .state          = WREPL_STATE_ACTIVE,
1834                         .node           = WREPL_NODE_B,
1835                         .is_static      = False,
1836                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1837                         .ips            = addresses_A_1,
1838                         .apply_expected = True
1839                 },
1840                 .r2     = {
1841                         .owner          = &ctx->b,
1842                         .type           = WREPL_TYPE_GROUP,
1843                         .state          = WREPL_STATE_ACTIVE,
1844                         .node           = WREPL_NODE_B,
1845                         .is_static      = False,
1846                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1847                         .ips            = addresses_A_1,
1848                         .apply_expected = False
1849                 }
1850         },
1851
1852         /*
1853          * group,active vs. group,tombstone
1854          * => should NOT be replaced
1855          */
1856         {
1857                 .line   = __location__,
1858                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1859                 .r1     = {
1860                         .owner          = &ctx->a,
1861                         .type           = WREPL_TYPE_GROUP,
1862                         .state          = WREPL_STATE_ACTIVE,
1863                         .node           = WREPL_NODE_B,
1864                         .is_static      = False,
1865                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1866                         .ips            = addresses_A_1,
1867                         .apply_expected = True
1868                 },
1869                 .r2     = {
1870                         .owner          = &ctx->b,
1871                         .type           = WREPL_TYPE_GROUP,
1872                         .state          = WREPL_STATE_TOMBSTONE,
1873                         .node           = WREPL_NODE_B,
1874                         .is_static      = False,
1875                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1876                         .ips            = addresses_A_1,
1877                         .apply_expected = False
1878                 }
1879         },
1880
1881         /*
1882          * group,released vs. group,active
1883          * => should be replaced
1884          */
1885         {
1886                 .line   = __location__,
1887                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1888                 .r1     = {
1889                         .owner          = &ctx->a,
1890                         .type           = WREPL_TYPE_GROUP,
1891                         .state          = WREPL_STATE_RELEASED,
1892                         .node           = WREPL_NODE_B,
1893                         .is_static      = False,
1894                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1895                         .ips            = addresses_A_1,
1896                         .apply_expected = False
1897                 },
1898                 .r2     = {
1899                         .owner          = &ctx->b,
1900                         .type           = WREPL_TYPE_GROUP,
1901                         .state          = WREPL_STATE_ACTIVE,
1902                         .node           = WREPL_NODE_B,
1903                         .is_static      = False,
1904                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1905                         .ips            = addresses_B_1,
1906                         .apply_expected = True
1907                 }
1908         },
1909
1910         /*
1911          * group,released vs. group,tombstone
1912          * => should be replaced
1913          */
1914         {
1915                 .line   = __location__,
1916                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1917                 .r1     = {
1918                         .owner          = &ctx->a,
1919                         .type           = WREPL_TYPE_GROUP,
1920                         .state          = WREPL_STATE_RELEASED,
1921                         .node           = WREPL_NODE_B,
1922                         .is_static      = False,
1923                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1924                         .ips            = addresses_A_1,
1925                         .apply_expected = False
1926                 },
1927                 .r2     = {
1928                         .owner          = &ctx->b,
1929                         .type           = WREPL_TYPE_GROUP,
1930                         .state          = WREPL_STATE_TOMBSTONE,
1931                         .node           = WREPL_NODE_B,
1932                         .is_static      = False,
1933                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1934                         .ips            = addresses_B_1,
1935                         .apply_expected = True
1936                 }
1937         },
1938
1939         /*
1940          * group,tombstone vs. group,active
1941          * => should be replaced
1942          */
1943         {
1944                 .line   = __location__,
1945                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1946                 .r1     = {
1947                         .owner          = &ctx->b,
1948                         .type           = WREPL_TYPE_GROUP,
1949                         .state          = WREPL_STATE_TOMBSTONE,
1950                         .node           = WREPL_NODE_B,
1951                         .is_static      = False,
1952                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1953                         .ips            = addresses_B_1,
1954                         .apply_expected = True
1955                 },
1956                 .r2     = {
1957                         .owner          = &ctx->a,
1958                         .type           = WREPL_TYPE_GROUP,
1959                         .state          = WREPL_STATE_ACTIVE,
1960                         .node           = WREPL_NODE_B,
1961                         .is_static      = False,
1962                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1963                         .ips            = addresses_A_1,
1964                         .apply_expected = True
1965                 }
1966         },
1967
1968         /*
1969          * group,tombstone vs. group,tombstone
1970          * => should be replaced
1971          */
1972         {
1973                 .line   = __location__,
1974                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1975                 .r1     = {
1976                         .owner          = &ctx->a,
1977                         .type           = WREPL_TYPE_GROUP,
1978                         .state          = WREPL_STATE_TOMBSTONE,
1979                         .node           = WREPL_NODE_B,
1980                         .is_static      = False,
1981                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1982                         .ips            = addresses_A_1,
1983                         .apply_expected = True
1984                 },
1985                 .r2     = {
1986                         .owner          = &ctx->b,
1987                         .type           = WREPL_TYPE_GROUP,
1988                         .state          = WREPL_STATE_TOMBSTONE,
1989                         .node           = WREPL_NODE_B,
1990                         .is_static      = False,
1991                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1992                         .ips            = addresses_B_1,
1993                         .apply_expected = True
1994                 }
1995         },
1996
1997 /*
1998  * normal groups vs special groups section,
1999  */
2000         /*
2001          * group,active vs. sgroup,active
2002          * => should NOT be replaced
2003          */
2004         {
2005                 .line   = __location__,
2006                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2007                 .r1     = {
2008                         .owner          = &ctx->b,
2009                         .type           = WREPL_TYPE_GROUP,
2010                         .state          = WREPL_STATE_ACTIVE,
2011                         .node           = WREPL_NODE_B,
2012                         .is_static      = False,
2013                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2014                         .ips            = addresses_B_1,
2015                         .apply_expected = True
2016                 },
2017                 .r2     = {
2018                         .owner          = &ctx->a,
2019                         .type           = WREPL_TYPE_SGROUP,
2020                         .state          = WREPL_STATE_ACTIVE,
2021                         .node           = WREPL_NODE_B,
2022                         .is_static      = False,
2023                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2024                         .ips            = addresses_B_1,
2025                         .apply_expected = False
2026                 }
2027         },
2028
2029         /*
2030          * group,active vs. sgroup,tombstone
2031          * => should NOT be replaced
2032          */
2033         {
2034                 .line   = __location__,
2035                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2036                 .r1     = {
2037                         .owner          = &ctx->b,
2038                         .type           = WREPL_TYPE_GROUP,
2039                         .state          = WREPL_STATE_ACTIVE,
2040                         .node           = WREPL_NODE_B,
2041                         .is_static      = False,
2042                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2043                         .ips            = addresses_B_1,
2044                         .apply_expected = True
2045                 },
2046                 .r2     = {
2047                         .owner          = &ctx->a,
2048                         .type           = WREPL_TYPE_SGROUP,
2049                         .state          = WREPL_STATE_TOMBSTONE,
2050                         .node           = WREPL_NODE_B,
2051                         .is_static      = False,
2052                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2053                         .ips            = addresses_B_1,
2054                         .apply_expected = False
2055                 }
2056         },
2057
2058         /*
2059          * group,released vs. sgroup,active
2060          * => should be replaced
2061          */
2062         {
2063                 .line   = __location__,
2064                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2065                 .r1     = {
2066                         .owner          = &ctx->a,
2067                         .type           = WREPL_TYPE_GROUP,
2068                         .state          = WREPL_STATE_RELEASED,
2069                         .node           = WREPL_NODE_B,
2070                         .is_static      = False,
2071                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2072                         .ips            = addresses_A_1,
2073                         .apply_expected = False
2074                 },
2075                 .r2     = {
2076                         .owner          = &ctx->b,
2077                         .type           = WREPL_TYPE_SGROUP,
2078                         .state          = WREPL_STATE_ACTIVE,
2079                         .node           = WREPL_NODE_B,
2080                         .is_static      = False,
2081                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2082                         .ips            = addresses_B_1,
2083                         .apply_expected = True
2084                 }
2085         },
2086
2087         /*
2088          * group,released vs. sgroup,tombstone
2089          * => should NOT be replaced
2090          */
2091         {
2092                 .line   = __location__,
2093                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2094                 .r1     = {
2095                         .owner          = &ctx->b,
2096                         .type           = WREPL_TYPE_GROUP,
2097                         .state          = WREPL_STATE_RELEASED,
2098                         .node           = WREPL_NODE_B,
2099                         .is_static      = False,
2100                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2101                         .ips            = addresses_B_1,
2102                         .apply_expected = False
2103                 },
2104                 .r2     = {
2105                         .owner          = &ctx->a,
2106                         .type           = WREPL_TYPE_SGROUP,
2107                         .state          = WREPL_STATE_TOMBSTONE,
2108                         .node           = WREPL_NODE_B,
2109                         .is_static      = False,
2110                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2111                         .ips            = addresses_B_1,
2112                         .apply_expected = False
2113                 }
2114         },
2115
2116         /*
2117          * group,tombstone vs. sgroup,active
2118          * => should be replaced
2119          */
2120         {
2121                 .line   = __location__,
2122                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2123                 .r1     = {
2124                         .owner          = &ctx->b,
2125                         .type           = WREPL_TYPE_GROUP,
2126                         .state          = WREPL_STATE_TOMBSTONE,
2127                         .node           = WREPL_NODE_B,
2128                         .is_static      = False,
2129                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2130                         .ips            = addresses_B_1,
2131                         .apply_expected = True
2132                 },
2133                 .r2     = {
2134                         .owner          = &ctx->a,
2135                         .type           = WREPL_TYPE_SGROUP,
2136                         .state          = WREPL_STATE_ACTIVE,
2137                         .node           = WREPL_NODE_B,
2138                         .is_static      = False,
2139                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2140                         .ips            = addresses_A_1,
2141                         .apply_expected = True
2142                 }
2143         },
2144
2145         /*
2146          * group,tombstone vs. sgroup,tombstone
2147          * => should be replaced
2148          */
2149         {
2150                 .line   = __location__,
2151                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2152                 .r1     = {
2153                         .owner          = &ctx->a,
2154                         .type           = WREPL_TYPE_GROUP,
2155                         .state          = WREPL_STATE_TOMBSTONE,
2156                         .node           = WREPL_NODE_B,
2157                         .is_static      = False,
2158                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2159                         .ips            = addresses_A_1,
2160                         .apply_expected = True
2161                 },
2162                 .r2     = {
2163                         .owner          = &ctx->b,
2164                         .type           = WREPL_TYPE_SGROUP,
2165                         .state          = WREPL_STATE_TOMBSTONE,
2166                         .node           = WREPL_NODE_B,
2167                         .is_static      = False,
2168                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2169                         .ips            = addresses_B_1,
2170                         .apply_expected = True
2171                 }
2172         },
2173
2174 /*
2175  * normal groups vs multi homed section,
2176  */
2177         /*
2178          * group,active vs. mhomed,active
2179          * => should NOT be replaced
2180          */
2181         {
2182                 .line   = __location__,
2183                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2184                 .r1     = {
2185                         .owner          = &ctx->b,
2186                         .type           = WREPL_TYPE_GROUP,
2187                         .state          = WREPL_STATE_ACTIVE,
2188                         .node           = WREPL_NODE_B,
2189                         .is_static      = False,
2190                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2191                         .ips            = addresses_B_1,
2192                         .apply_expected = True
2193                 },
2194                 .r2     = {
2195                         .owner          = &ctx->a,
2196                         .type           = WREPL_TYPE_MHOMED,
2197                         .state          = WREPL_STATE_ACTIVE,
2198                         .node           = WREPL_NODE_B,
2199                         .is_static      = False,
2200                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2201                         .ips            = addresses_B_1,
2202                         .apply_expected = False
2203                 }
2204         },
2205
2206         /*
2207          * group,active vs. mhomed,tombstone
2208          * => should NOT be replaced
2209          */
2210         {
2211                 .line   = __location__,
2212                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2213                 .r1     = {
2214                         .owner          = &ctx->b,
2215                         .type           = WREPL_TYPE_GROUP,
2216                         .state          = WREPL_STATE_ACTIVE,
2217                         .node           = WREPL_NODE_B,
2218                         .is_static      = False,
2219                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2220                         .ips            = addresses_B_1,
2221                         .apply_expected = True
2222                 },
2223                 .r2     = {
2224                         .owner          = &ctx->a,
2225                         .type           = WREPL_TYPE_MHOMED,
2226                         .state          = WREPL_STATE_TOMBSTONE,
2227                         .node           = WREPL_NODE_B,
2228                         .is_static      = False,
2229                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2230                         .ips            = addresses_B_1,
2231                         .apply_expected = False
2232                 }
2233         },
2234
2235         /*
2236          * group,released vs. mhomed,active
2237          * => should NOT be replaced
2238          */
2239         {
2240                 .line   = __location__,
2241                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2242                 .r1     = {
2243                         .owner          = &ctx->b,
2244                         .type           = WREPL_TYPE_GROUP,
2245                         .state          = WREPL_STATE_RELEASED,
2246                         .node           = WREPL_NODE_B,
2247                         .is_static      = False,
2248                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2249                         .ips            = addresses_B_1,
2250                         .apply_expected = False
2251                 },
2252                 .r2     = {
2253                         .owner          = &ctx->a,
2254                         .type           = WREPL_TYPE_MHOMED,
2255                         .state          = WREPL_STATE_ACTIVE,
2256                         .node           = WREPL_NODE_B,
2257                         .is_static      = False,
2258                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2259                         .ips            = addresses_B_1,
2260                         .apply_expected = False
2261                 }
2262         },
2263
2264         /*
2265          * group,released vs. mhomed,tombstone
2266          * => should NOT be replaced
2267          */
2268         {
2269                 .line   = __location__,
2270                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2271                 .r1     = {
2272                         .owner          = &ctx->b,
2273                         .type           = WREPL_TYPE_GROUP,
2274                         .state          = WREPL_STATE_RELEASED,
2275                         .node           = WREPL_NODE_B,
2276                         .is_static      = False,
2277                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2278                         .ips            = addresses_B_1,
2279                         .apply_expected = False
2280                 },
2281                 .r2     = {
2282                         .owner          = &ctx->a,
2283                         .type           = WREPL_TYPE_MHOMED,
2284                         .state          = WREPL_STATE_TOMBSTONE,
2285                         .node           = WREPL_NODE_B,
2286                         .is_static      = False,
2287                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2288                         .ips            = addresses_B_1,
2289                         .apply_expected = False
2290                 }
2291         },
2292
2293         /*
2294          * group,tombstone vs. mhomed,active
2295          * => should be replaced
2296          */
2297         {
2298                 .line   = __location__,
2299                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2300                 .r1     = {
2301                         .owner          = &ctx->b,
2302                         .type           = WREPL_TYPE_GROUP,
2303                         .state          = WREPL_STATE_TOMBSTONE,
2304                         .node           = WREPL_NODE_B,
2305                         .is_static      = False,
2306                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2307                         .ips            = addresses_B_1,
2308                         .apply_expected = True
2309                 },
2310                 .r2     = {
2311                         .owner          = &ctx->a,
2312                         .type           = WREPL_TYPE_MHOMED,
2313                         .state          = WREPL_STATE_ACTIVE,
2314                         .node           = WREPL_NODE_B,
2315                         .is_static      = False,
2316                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2317                         .ips            = addresses_A_1,
2318                         .apply_expected = True
2319                 }
2320         },
2321
2322         /*
2323          * group,tombstone vs. mhomed,tombstone
2324          * => should be replaced
2325          */
2326         {
2327                 .line   = __location__,
2328                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2329                 .r1     = {
2330                         .owner          = &ctx->a,
2331                         .type           = WREPL_TYPE_GROUP,
2332                         .state          = WREPL_STATE_TOMBSTONE,
2333                         .node           = WREPL_NODE_B,
2334                         .is_static      = False,
2335                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2336                         .ips            = addresses_A_1,
2337                         .apply_expected = True
2338                 },
2339                 .r2     = {
2340                         .owner          = &ctx->b,
2341                         .type           = WREPL_TYPE_MHOMED,
2342                         .state          = WREPL_STATE_TOMBSTONE,
2343                         .node           = WREPL_NODE_B,
2344                         .is_static      = False,
2345                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2346                         .ips            = addresses_B_1,
2347                         .apply_expected = True
2348                 }
2349         },
2350
2351 /*
2352  * special groups vs unique section,
2353  */
2354         /*
2355          * sgroup,active vs. unique,active
2356          * => should NOT be replaced
2357          */
2358         {
2359                 .line   = __location__,
2360                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2361                 .r1     = {
2362                         .owner          = &ctx->b,
2363                         .type           = WREPL_TYPE_SGROUP,
2364                         .state          = WREPL_STATE_ACTIVE,
2365                         .node           = WREPL_NODE_B,
2366                         .is_static      = False,
2367                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2368                         .ips            = addresses_B_1,
2369                         .apply_expected = True
2370                 },
2371                 .r2     = {
2372                         .owner          = &ctx->a,
2373                         .type           = WREPL_TYPE_UNIQUE,
2374                         .state          = WREPL_STATE_ACTIVE,
2375                         .node           = WREPL_NODE_B,
2376                         .is_static      = False,
2377                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2378                         .ips            = addresses_B_1,
2379                         .apply_expected = False
2380                 }
2381         },
2382
2383         /*
2384          * sgroup,active vs. unique,tombstone
2385          * => should NOT be replaced
2386          */
2387         {
2388                 .line   = __location__,
2389                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2390                 .r1     = {
2391                         .owner          = &ctx->b,
2392                         .type           = WREPL_TYPE_SGROUP,
2393                         .state          = WREPL_STATE_ACTIVE,
2394                         .node           = WREPL_NODE_B,
2395                         .is_static      = False,
2396                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2397                         .ips            = addresses_B_1,
2398                         .apply_expected = True
2399                 },
2400                 .r2     = {
2401                         .owner          = &ctx->a,
2402                         .type           = WREPL_TYPE_UNIQUE,
2403                         .state          = WREPL_STATE_TOMBSTONE,
2404                         .node           = WREPL_NODE_B,
2405                         .is_static      = False,
2406                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2407                         .ips            = addresses_B_1,
2408                         .apply_expected = False
2409                 }
2410         },
2411
2412         /*
2413          * sgroup,released vs. unique,active
2414          * => should be replaced
2415          */
2416         {
2417                 .line   = __location__,
2418                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2419                 .r1     = {
2420                         .owner          = &ctx->b,
2421                         .type           = WREPL_TYPE_SGROUP,
2422                         .state          = WREPL_STATE_RELEASED,
2423                         .node           = WREPL_NODE_B,
2424                         .is_static      = False,
2425                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2426                         .ips            = addresses_B_1,
2427                         .apply_expected = False
2428                 },
2429                 .r2     = {
2430                         .owner          = &ctx->a,
2431                         .type           = WREPL_TYPE_UNIQUE,
2432                         .state          = WREPL_STATE_ACTIVE,
2433                         .node           = WREPL_NODE_B,
2434                         .is_static      = False,
2435                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2436                         .ips            = addresses_A_1,
2437                         .apply_expected = True
2438                 }
2439         },
2440
2441         /*
2442          * sgroup,released vs. unique,tombstone
2443          * => should be replaced
2444          */
2445         {
2446                 .line   = __location__,
2447                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2448                 .r1     = {
2449                         .owner          = &ctx->a,
2450                         .type           = WREPL_TYPE_SGROUP,
2451                         .state          = WREPL_STATE_RELEASED,
2452                         .node           = WREPL_NODE_B,
2453                         .is_static      = False,
2454                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2455                         .ips            = addresses_A_1,
2456                         .apply_expected = False
2457                 },
2458                 .r2     = {
2459                         .owner          = &ctx->b,
2460                         .type           = WREPL_TYPE_UNIQUE,
2461                         .state          = WREPL_STATE_TOMBSTONE,
2462                         .node           = WREPL_NODE_B,
2463                         .is_static      = False,
2464                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2465                         .ips            = addresses_B_1,
2466                         .apply_expected = True
2467                 }
2468         },
2469
2470         /*
2471          * sgroup,tombstone vs. unique,active
2472          * => should be replaced
2473          */
2474         {
2475                 .line   = __location__,
2476                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2477                 .r1     = {
2478                         .owner          = &ctx->a,
2479                         .type           = WREPL_TYPE_SGROUP,
2480                         .state          = WREPL_STATE_TOMBSTONE,
2481                         .node           = WREPL_NODE_B,
2482                         .is_static      = False,
2483                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2484                         .ips            = addresses_A_1,
2485                         .apply_expected = True
2486                 },
2487                 .r2     = {
2488                         .owner          = &ctx->b,
2489                         .type           = WREPL_TYPE_UNIQUE,
2490                         .state          = WREPL_STATE_ACTIVE,
2491                         .node           = WREPL_NODE_B,
2492                         .is_static      = False,
2493                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2494                         .ips            = addresses_B_1,
2495                         .apply_expected = True
2496                 }
2497         },
2498
2499         /*
2500          * sgroup,tombstone vs. unique,tombstone
2501          * => should be replaced
2502          */
2503         {
2504                 .line   = __location__,
2505                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2506                 .r1     = {
2507                         .owner          = &ctx->b,
2508                         .type           = WREPL_TYPE_SGROUP,
2509                         .state          = WREPL_STATE_TOMBSTONE,
2510                         .node           = WREPL_NODE_B,
2511                         .is_static      = False,
2512                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2513                         .ips            = addresses_B_1,
2514                         .apply_expected = True
2515                 },
2516                 .r2     = {
2517                         .owner          = &ctx->a,
2518                         .type           = WREPL_TYPE_UNIQUE,
2519                         .state          = WREPL_STATE_TOMBSTONE,
2520                         .node           = WREPL_NODE_B,
2521                         .is_static      = False,
2522                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2523                         .ips            = addresses_A_1,
2524                         .apply_expected = True
2525                 }
2526         },
2527
2528 /*
2529  * special groups vs normal group section,
2530  */
2531         /*
2532          * sgroup,active vs. group,active
2533          * => should NOT be replaced
2534          */
2535         {
2536                 .line   = __location__,
2537                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2538                 .r1     = {
2539                         .owner          = &ctx->a,
2540                         .type           = WREPL_TYPE_SGROUP,
2541                         .state          = WREPL_STATE_ACTIVE,
2542                         .node           = WREPL_NODE_B,
2543                         .is_static      = False,
2544                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2545                         .ips            = addresses_A_1,
2546                         .apply_expected = True
2547                 },
2548                 .r2     = {
2549                         .owner          = &ctx->b,
2550                         .type           = WREPL_TYPE_GROUP,
2551                         .state          = WREPL_STATE_ACTIVE,
2552                         .node           = WREPL_NODE_B,
2553                         .is_static      = False,
2554                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2555                         .ips            = addresses_A_1,
2556                         .apply_expected = False
2557                 }
2558         },
2559
2560         /*
2561          * sgroup,active vs. group,tombstone
2562          * => should NOT be replaced
2563          */
2564         {
2565                 .line   = __location__,
2566                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2567                 .r1     = {
2568                         .owner          = &ctx->a,
2569                         .type           = WREPL_TYPE_SGROUP,
2570                         .state          = WREPL_STATE_ACTIVE,
2571                         .node           = WREPL_NODE_B,
2572                         .is_static      = False,
2573                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2574                         .ips            = addresses_A_1,
2575                         .apply_expected = True
2576                 },
2577                 .r2     = {
2578                         .owner          = &ctx->b,
2579                         .type           = WREPL_TYPE_GROUP,
2580                         .state          = WREPL_STATE_TOMBSTONE,
2581                         .node           = WREPL_NODE_B,
2582                         .is_static      = False,
2583                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2584                         .ips            = addresses_A_1,
2585                         .apply_expected = False
2586                 }
2587         },
2588
2589         /*
2590          * sgroup,released vs. group,active
2591          * => should be replaced
2592          */
2593         {
2594                 .line   = __location__,
2595                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2596                 .r1     = {
2597                         .owner          = &ctx->a,
2598                         .type           = WREPL_TYPE_SGROUP,
2599                         .state          = WREPL_STATE_RELEASED,
2600                         .node           = WREPL_NODE_B,
2601                         .is_static      = False,
2602                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2603                         .ips            = addresses_A_1,
2604                         .apply_expected = False
2605                 },
2606                 .r2     = {
2607                         .owner          = &ctx->b,
2608                         .type           = WREPL_TYPE_GROUP,
2609                         .state          = WREPL_STATE_ACTIVE,
2610                         .node           = WREPL_NODE_B,
2611                         .is_static      = False,
2612                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2613                         .ips            = addresses_B_1,
2614                         .apply_expected = True
2615                 }
2616         },
2617
2618         /*
2619          * sgroup,released vs. group,tombstone
2620          * => should be replaced
2621          */
2622         {
2623                 .line   = __location__,
2624                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2625                 .r1     = {
2626                         .owner          = &ctx->b,
2627                         .type           = WREPL_TYPE_SGROUP,
2628                         .state          = WREPL_STATE_RELEASED,
2629                         .node           = WREPL_NODE_B,
2630                         .is_static      = False,
2631                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2632                         .ips            = addresses_B_1,
2633                         .apply_expected = False
2634                 },
2635                 .r2     = {
2636                         .owner          = &ctx->a,
2637                         .type           = WREPL_TYPE_GROUP,
2638                         .state          = WREPL_STATE_TOMBSTONE,
2639                         .node           = WREPL_NODE_B,
2640                         .is_static      = False,
2641                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2642                         .ips            = addresses_A_1,
2643                         .apply_expected = True
2644                 }
2645         },
2646
2647         /*
2648          * sgroup,tombstone vs. group,active
2649          * => should NOT be replaced
2650          */
2651         {
2652                 .line   = __location__,
2653                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2654                 .r1     = {
2655                         .owner          = &ctx->a,
2656                         .type           = WREPL_TYPE_SGROUP,
2657                         .state          = WREPL_STATE_TOMBSTONE,
2658                         .node           = WREPL_NODE_B,
2659                         .is_static      = False,
2660                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2661                         .ips            = addresses_A_1,
2662                         .apply_expected = True
2663                 },
2664                 .r2     = {
2665                         .owner          = &ctx->b,
2666                         .type           = WREPL_TYPE_GROUP,
2667                         .state          = WREPL_STATE_ACTIVE,
2668                         .node           = WREPL_NODE_B,
2669                         .is_static      = False,
2670                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2671                         .ips            = addresses_B_1,
2672                         .apply_expected = True
2673                 }
2674         },
2675
2676         /*
2677          * sgroup,tombstone vs. group,tombstone
2678          * => should NOT be replaced
2679          */
2680         {
2681                 .line   = __location__,
2682                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2683                 .r1     = {
2684                         .owner          = &ctx->b,
2685                         .type           = WREPL_TYPE_SGROUP,
2686                         .state          = WREPL_STATE_TOMBSTONE,
2687                         .node           = WREPL_NODE_B,
2688                         .is_static      = False,
2689                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2690                         .ips            = addresses_B_1,
2691                         .apply_expected = True
2692                 },
2693                 .r2     = {
2694                         .owner          = &ctx->a,
2695                         .type           = WREPL_TYPE_GROUP,
2696                         .state          = WREPL_STATE_TOMBSTONE,
2697                         .node           = WREPL_NODE_B,
2698                         .is_static      = False,
2699                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2700                         .ips            = addresses_A_1,
2701                         .apply_expected = True
2702                 }
2703         },
2704
2705 /*
2706  * special groups vs multi homed section,
2707  */
2708         /*
2709          * sgroup,active vs. mhomed,active
2710          * => should NOT be replaced
2711          */
2712         {
2713                 .line   = __location__,
2714                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2715                 .r1     = {
2716                         .owner          = &ctx->a,
2717                         .type           = WREPL_TYPE_SGROUP,
2718                         .state          = WREPL_STATE_ACTIVE,
2719                         .node           = WREPL_NODE_B,
2720                         .is_static      = False,
2721                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2722                         .ips            = addresses_A_1,
2723                         .apply_expected = True
2724                 },
2725                 .r2     = {
2726                         .owner          = &ctx->b,
2727                         .type           = WREPL_TYPE_MHOMED,
2728                         .state          = WREPL_STATE_ACTIVE,
2729                         .node           = WREPL_NODE_B,
2730                         .is_static      = False,
2731                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2732                         .ips            = addresses_A_1,
2733                         .apply_expected = False
2734                 }
2735         },
2736
2737         /*
2738          * sgroup,active vs. mhomed,tombstone
2739          * => should NOT be replaced
2740          */
2741         {
2742                 .line   = __location__,
2743                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2744                 .r1     = {
2745                         .owner          = &ctx->a,
2746                         .type           = WREPL_TYPE_SGROUP,
2747                         .state          = WREPL_STATE_ACTIVE,
2748                         .node           = WREPL_NODE_B,
2749                         .is_static      = False,
2750                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2751                         .ips            = addresses_A_1,
2752                         .apply_expected = True
2753                 },
2754                 .r2     = {
2755                         .owner          = &ctx->b,
2756                         .type           = WREPL_TYPE_MHOMED,
2757                         .state          = WREPL_STATE_TOMBSTONE,
2758                         .node           = WREPL_NODE_B,
2759                         .is_static      = False,
2760                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2761                         .ips            = addresses_A_1,
2762                         .apply_expected = False
2763                 }
2764         },
2765
2766         /*
2767          * sgroup,released vs. mhomed,active
2768          * => should be replaced
2769          */
2770         {
2771                 .line   = __location__,
2772                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2773                 .r1     = {
2774                         .owner          = &ctx->a,
2775                         .type           = WREPL_TYPE_SGROUP,
2776                         .state          = WREPL_STATE_RELEASED,
2777                         .node           = WREPL_NODE_B,
2778                         .is_static      = False,
2779                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2780                         .ips            = addresses_A_1,
2781                         .apply_expected = False
2782                 },
2783                 .r2     = {
2784                         .owner          = &ctx->b,
2785                         .type           = WREPL_TYPE_MHOMED,
2786                         .state          = WREPL_STATE_ACTIVE,
2787                         .node           = WREPL_NODE_B,
2788                         .is_static      = False,
2789                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2790                         .ips            = addresses_B_1,
2791                         .apply_expected = True
2792                 }
2793         },
2794
2795         /*
2796          * sgroup,released vs. mhomed,tombstone
2797          * => should be replaced
2798          */
2799         {
2800                 .line   = __location__,
2801                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2802                 .r1     = {
2803                         .owner          = &ctx->b,
2804                         .type           = WREPL_TYPE_SGROUP,
2805                         .state          = WREPL_STATE_RELEASED,
2806                         .node           = WREPL_NODE_B,
2807                         .is_static      = False,
2808                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2809                         .ips            = addresses_B_1,
2810                         .apply_expected = False
2811                 },
2812                 .r2     = {
2813                         .owner          = &ctx->a,
2814                         .type           = WREPL_TYPE_MHOMED,
2815                         .state          = WREPL_STATE_TOMBSTONE,
2816                         .node           = WREPL_NODE_B,
2817                         .is_static      = False,
2818                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2819                         .ips            = addresses_A_1,
2820                         .apply_expected = True
2821                 }
2822         },
2823
2824         /*
2825          * sgroup,tombstone vs. mhomed,active
2826          * => should be replaced
2827          */
2828         {
2829                 .line   = __location__,
2830                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2831                 .r1     = {
2832                         .owner          = &ctx->a,
2833                         .type           = WREPL_TYPE_SGROUP,
2834                         .state          = WREPL_STATE_TOMBSTONE,
2835                         .node           = WREPL_NODE_B,
2836                         .is_static      = False,
2837                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2838                         .ips            = addresses_A_1,
2839                         .apply_expected = True
2840                 },
2841                 .r2     = {
2842                         .owner          = &ctx->b,
2843                         .type           = WREPL_TYPE_MHOMED,
2844                         .state          = WREPL_STATE_ACTIVE,
2845                         .node           = WREPL_NODE_B,
2846                         .is_static      = False,
2847                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2848                         .ips            = addresses_B_1,
2849                         .apply_expected = True
2850                 }
2851         },
2852
2853         /*
2854          * sgroup,tombstone vs. mhomed,tombstone
2855          * => should be replaced
2856          */
2857         {
2858                 .line   = __location__,
2859                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2860                 .r1     = {
2861                         .owner          = &ctx->b,
2862                         .type           = WREPL_TYPE_SGROUP,
2863                         .state          = WREPL_STATE_TOMBSTONE,
2864                         .node           = WREPL_NODE_B,
2865                         .is_static      = False,
2866                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2867                         .ips            = addresses_B_1,
2868                         .apply_expected = True
2869                 },
2870                 .r2     = {
2871                         .owner          = &ctx->a,
2872                         .type           = WREPL_TYPE_MHOMED,
2873                         .state          = WREPL_STATE_TOMBSTONE,
2874                         .node           = WREPL_NODE_B,
2875                         .is_static      = False,
2876                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2877                         .ips            = addresses_A_1,
2878                         .apply_expected = True
2879                 }
2880         },
2881
2882 /*
2883  * multi homed vs. unique section,
2884  */
2885         /*
2886          * mhomed,active vs. unique,active
2887          * => should be replaced
2888          */
2889         {
2890                 .line   = __location__,
2891                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2892                 .r1     = {
2893                         .owner          = &ctx->a,
2894                         .type           = WREPL_TYPE_MHOMED,
2895                         .state          = WREPL_STATE_ACTIVE,
2896                         .node           = WREPL_NODE_B,
2897                         .is_static      = False,
2898                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
2899                         .ips            = addresses_A_3_4,
2900                         .apply_expected = True
2901                 },
2902                 .r2     = {
2903                         .owner          = &ctx->b,
2904                         .type           = WREPL_TYPE_UNIQUE,
2905                         .state          = WREPL_STATE_ACTIVE,
2906                         .node           = WREPL_NODE_B,
2907                         .is_static      = False,
2908                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2909                         .ips            = addresses_B_1,
2910                         .apply_expected = True
2911                 }
2912         },
2913
2914         /*
2915          * mhomed,active vs. unique,tombstone
2916          * => should NOT be replaced
2917          */
2918         {
2919                 .line   = __location__,
2920                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2921                 .r1     = {
2922                         .owner          = &ctx->b,
2923                         .type           = WREPL_TYPE_MHOMED,
2924                         .state          = WREPL_STATE_ACTIVE,
2925                         .node           = WREPL_NODE_B,
2926                         .is_static      = False,
2927                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2928                         .ips            = addresses_B_1,
2929                         .apply_expected = True
2930                 },
2931                 .r2     = {
2932                         .owner          = &ctx->a,
2933                         .type           = WREPL_TYPE_UNIQUE,
2934                         .state          = WREPL_STATE_TOMBSTONE,
2935                         .node           = WREPL_NODE_B,
2936                         .is_static      = False,
2937                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2938                         .ips            = addresses_B_1,
2939                         .apply_expected = False
2940                 }
2941         },
2942
2943         /*
2944          * mhomed,released vs. unique,active
2945          * => should be replaced
2946          */
2947         {
2948                 .line   = __location__,
2949                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2950                 .r1     = {
2951                         .owner          = &ctx->a,
2952                         .type           = WREPL_TYPE_MHOMED,
2953                         .state          = WREPL_STATE_RELEASED,
2954                         .node           = WREPL_NODE_B,
2955                         .is_static      = False,
2956                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2957                         .ips            = addresses_A_1,
2958                         .apply_expected = False
2959                 },
2960                 .r2     = {
2961                         .owner          = &ctx->b,
2962                         .type           = WREPL_TYPE_UNIQUE,
2963                         .state          = WREPL_STATE_ACTIVE,
2964                         .node           = WREPL_NODE_B,
2965                         .is_static      = False,
2966                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2967                         .ips            = addresses_B_1,
2968                         .apply_expected = True
2969                 }
2970         },
2971
2972         /*
2973          * mhomed,released vs. uinique,tombstone
2974          * => should be replaced
2975          */
2976         {
2977                 .line   = __location__,
2978                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2979                 .r1     = {
2980                         .owner          = &ctx->b,
2981                         .type           = WREPL_TYPE_MHOMED,
2982                         .state          = WREPL_STATE_RELEASED,
2983                         .node           = WREPL_NODE_B,
2984                         .is_static      = False,
2985                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2986                         .ips            = addresses_B_1,
2987                         .apply_expected = False
2988                 },
2989                 .r2     = {
2990                         .owner          = &ctx->a,
2991                         .type           = WREPL_TYPE_UNIQUE,
2992                         .state          = WREPL_STATE_TOMBSTONE,
2993                         .node           = WREPL_NODE_B,
2994                         .is_static      = False,
2995                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2996                         .ips            = addresses_A_1,
2997                         .apply_expected = True
2998                 }
2999         },
3000
3001         /*
3002          * mhomed,tombstone vs. unique,active
3003          * => should be replaced
3004          */
3005         {
3006                 .line   = __location__,
3007                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3008                 .r1     = {
3009                         .owner          = &ctx->a,
3010                         .type           = WREPL_TYPE_MHOMED,
3011                         .state          = WREPL_STATE_TOMBSTONE,
3012                         .node           = WREPL_NODE_B,
3013                         .is_static      = False,
3014                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3015                         .ips            = addresses_A_1,
3016                         .apply_expected = True
3017                 },
3018                 .r2     = {
3019                         .owner          = &ctx->b,
3020                         .type           = WREPL_TYPE_UNIQUE,
3021                         .state          = WREPL_STATE_ACTIVE,
3022                         .node           = WREPL_NODE_B,
3023                         .is_static      = False,
3024                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3025                         .ips            = addresses_B_1,
3026                         .apply_expected = True
3027                 }
3028         },
3029
3030         /*
3031          * mhomed,tombstone vs. uinique,tombstone
3032          * => should be replaced
3033          */
3034         {
3035                 .line   = __location__,
3036                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3037                 .r1     = {
3038                         .owner          = &ctx->b,
3039                         .type           = WREPL_TYPE_MHOMED,
3040                         .state          = WREPL_STATE_TOMBSTONE,
3041                         .node           = WREPL_NODE_B,
3042                         .is_static      = False,
3043                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3044                         .ips            = addresses_B_1,
3045                         .apply_expected = True
3046                 },
3047                 .r2     = {
3048                         .owner          = &ctx->a,
3049                         .type           = WREPL_TYPE_UNIQUE,
3050                         .state          = WREPL_STATE_TOMBSTONE,
3051                         .node           = WREPL_NODE_B,
3052                         .is_static      = False,
3053                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3054                         .ips            = addresses_A_1,
3055                         .apply_expected = True
3056                 }
3057         },
3058
3059 /*
3060  * multi homed vs. normal group section,
3061  */
3062         /*
3063          * mhomed,active vs. group,active
3064          * => should be replaced
3065          */
3066         {
3067                 .line   = __location__,
3068                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3069                 .r1     = {
3070                         .owner          = &ctx->a,
3071                         .type           = WREPL_TYPE_MHOMED,
3072                         .state          = WREPL_STATE_ACTIVE,
3073                         .node           = WREPL_NODE_B,
3074                         .is_static      = False,
3075                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3076                         .ips            = addresses_A_1,
3077                         .apply_expected = True
3078                 },
3079                 .r2     = {
3080                         .owner          = &ctx->b,
3081                         .type           = WREPL_TYPE_GROUP,
3082                         .state          = WREPL_STATE_ACTIVE,
3083                         .node           = WREPL_NODE_B,
3084                         .is_static      = False,
3085                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3086                         .ips            = addresses_B_1,
3087                         .apply_expected = True
3088                 }
3089         },
3090
3091         /*
3092          * mhomed,active vs. group,tombstone
3093          * => should NOT be replaced
3094          */
3095         {
3096                 .line   = __location__,
3097                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3098                 .r1     = {
3099                         .owner          = &ctx->b,
3100                         .type           = WREPL_TYPE_MHOMED,
3101                         .state          = WREPL_STATE_ACTIVE,
3102                         .node           = WREPL_NODE_B,
3103                         .is_static      = False,
3104                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3105                         .ips            = addresses_B_1,
3106                         .apply_expected = True
3107                 },
3108                 .r2     = {
3109                         .owner          = &ctx->a,
3110                         .type           = WREPL_TYPE_GROUP,
3111                         .state          = WREPL_STATE_TOMBSTONE,
3112                         .node           = WREPL_NODE_B,
3113                         .is_static      = False,
3114                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3115                         .ips            = addresses_B_1,
3116                         .apply_expected = False
3117                 }
3118         },
3119
3120         /*
3121          * mhomed,released vs. group,active
3122          * => should be replaced
3123          */
3124         {
3125                 .line   = __location__,
3126                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3127                 .r1     = {
3128                         .owner          = &ctx->b,
3129                         .type           = WREPL_TYPE_MHOMED,
3130                         .state          = WREPL_STATE_RELEASED,
3131                         .node           = WREPL_NODE_B,
3132                         .is_static      = False,
3133                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3134                         .ips            = addresses_B_1,
3135                         .apply_expected = False
3136                 },
3137                 .r2     = {
3138                         .owner          = &ctx->a,
3139                         .type           = WREPL_TYPE_GROUP,
3140                         .state          = WREPL_STATE_ACTIVE,
3141                         .node           = WREPL_NODE_B,
3142                         .is_static      = False,
3143                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3144                         .ips            = addresses_A_1,
3145                         .apply_expected = True
3146                 }
3147         },
3148
3149         /*
3150          * mhomed,released vs. group,tombstone
3151          * => should be replaced
3152          */
3153         {
3154                 .line   = __location__,
3155                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3156                 .r1     = {
3157                         .owner          = &ctx->a,
3158                         .type           = WREPL_TYPE_MHOMED,
3159                         .state          = WREPL_STATE_RELEASED,
3160                         .node           = WREPL_NODE_B,
3161                         .is_static      = False,
3162                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3163                         .ips            = addresses_A_1,
3164                         .apply_expected = False
3165                 },
3166                 .r2     = {
3167                         .owner          = &ctx->b,
3168                         .type           = WREPL_TYPE_GROUP,
3169                         .state          = WREPL_STATE_TOMBSTONE,
3170                         .node           = WREPL_NODE_B,
3171                         .is_static      = False,
3172                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3173                         .ips            = addresses_B_1,
3174                         .apply_expected = True
3175                 }
3176         },
3177
3178         /*
3179          * mhomed,tombstone vs. group,active
3180          * => should be replaced
3181          */
3182         {
3183                 .line   = __location__,
3184                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3185                 .r1     = {
3186                         .owner          = &ctx->b,
3187                         .type           = WREPL_TYPE_MHOMED,
3188                         .state          = WREPL_STATE_TOMBSTONE,
3189                         .node           = WREPL_NODE_B,
3190                         .is_static      = False,
3191                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3192                         .ips            = addresses_B_1,
3193                         .apply_expected = True
3194                 },
3195                 .r2     = {
3196                         .owner          = &ctx->a,
3197                         .type           = WREPL_TYPE_GROUP,
3198                         .state          = WREPL_STATE_ACTIVE,
3199                         .node           = WREPL_NODE_B,
3200                         .is_static      = False,
3201                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3202                         .ips            = addresses_A_1,
3203                         .apply_expected = True
3204                 }
3205         },
3206
3207         /*
3208          * mhomed,tombstone vs. group,tombstone
3209          * => should be replaced
3210          */
3211         {
3212                 .line   = __location__,
3213                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3214                 .r1     = {
3215                         .owner          = &ctx->a,
3216                         .type           = WREPL_TYPE_MHOMED,
3217                         .state          = WREPL_STATE_TOMBSTONE,
3218                         .node           = WREPL_NODE_B,
3219                         .is_static      = False,
3220                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3221                         .ips            = addresses_A_1,
3222                         .apply_expected = True
3223                 },
3224                 .r2     = {
3225                         .owner          = &ctx->b,
3226                         .type           = WREPL_TYPE_GROUP,
3227                         .state          = WREPL_STATE_TOMBSTONE,
3228                         .node           = WREPL_NODE_B,
3229                         .is_static      = False,
3230                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3231                         .ips            = addresses_B_1,
3232                         .apply_expected = True
3233                 }
3234         },
3235
3236 /*
3237  * multi homed vs. special group section,
3238  */
3239         /*
3240          * mhomed,active vs. sgroup,active
3241          * => should NOT be replaced
3242          */
3243         {
3244                 .line   = __location__,
3245                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3246                 .r1     = {
3247                         .owner          = &ctx->a,
3248                         .type           = WREPL_TYPE_MHOMED,
3249                         .state          = WREPL_STATE_ACTIVE,
3250                         .node           = WREPL_NODE_B,
3251                         .is_static      = False,
3252                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3253                         .ips            = addresses_A_1,
3254                         .apply_expected = True
3255                 },
3256                 .r2     = {
3257                         .owner          = &ctx->b,
3258                         .type           = WREPL_TYPE_SGROUP,
3259                         .state          = WREPL_STATE_ACTIVE,
3260                         .node           = WREPL_NODE_B,
3261                         .is_static      = False,
3262                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3263                         .ips            = addresses_A_1,
3264                         .apply_expected = False
3265                 }
3266         },
3267
3268         /*
3269          * mhomed,active vs. sgroup,tombstone
3270          * => should NOT be replaced
3271          */
3272         {
3273                 .line   = __location__,
3274                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3275                 .r1     = {
3276                         .owner          = &ctx->a,
3277                         .type           = WREPL_TYPE_MHOMED,
3278                         .state          = WREPL_STATE_ACTIVE,
3279                         .node           = WREPL_NODE_B,
3280                         .is_static      = False,
3281                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3282                         .ips            = addresses_A_1,
3283                         .apply_expected = True
3284                 },
3285                 .r2     = {
3286                         .owner          = &ctx->b,
3287                         .type           = WREPL_TYPE_SGROUP,
3288                         .state          = WREPL_STATE_TOMBSTONE,
3289                         .node           = WREPL_NODE_B,
3290                         .is_static      = False,
3291                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3292                         .ips            = addresses_A_1,
3293                         .apply_expected = False
3294                 }
3295         },
3296
3297         /*
3298          * mhomed,released vs. sgroup,active
3299          * => should be replaced
3300          */
3301         {
3302                 .line   = __location__,
3303                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3304                 .r1     = {
3305                         .owner          = &ctx->a,
3306                         .type           = WREPL_TYPE_MHOMED,
3307                         .state          = WREPL_STATE_RELEASED,
3308                         .node           = WREPL_NODE_B,
3309                         .is_static      = False,
3310                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3311                         .ips            = addresses_A_1,
3312                         .apply_expected = False
3313                 },
3314                 .r2     = {
3315                         .owner          = &ctx->b,
3316                         .type           = WREPL_TYPE_SGROUP,
3317                         .state          = WREPL_STATE_ACTIVE,
3318                         .node           = WREPL_NODE_B,
3319                         .is_static      = False,
3320                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3321                         .ips            = addresses_B_1,
3322                         .apply_expected = True
3323                 }
3324         },
3325
3326         /*
3327          * mhomed,released vs. sgroup,tombstone
3328          * => should be replaced
3329          */
3330         {
3331                 .line   = __location__,
3332                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3333                 .r1     = {
3334                         .owner          = &ctx->b,
3335                         .type           = WREPL_TYPE_MHOMED,
3336                         .state          = WREPL_STATE_RELEASED,
3337                         .node           = WREPL_NODE_B,
3338                         .is_static      = False,
3339                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3340                         .ips            = addresses_B_1,
3341                         .apply_expected = False
3342                 },
3343                 .r2     = {
3344                         .owner          = &ctx->a,
3345                         .type           = WREPL_TYPE_SGROUP,
3346                         .state          = WREPL_STATE_TOMBSTONE,
3347                         .node           = WREPL_NODE_B,
3348                         .is_static      = False,
3349                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3350                         .ips            = addresses_A_1,
3351                         .apply_expected = True
3352                 }
3353         },
3354
3355         /*
3356          * mhomed,tombstone vs. sgroup,active
3357          * => should be replaced
3358          */
3359         {
3360                 .line   = __location__,
3361                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3362                 .r1     = {
3363                         .owner          = &ctx->a,
3364                         .type           = WREPL_TYPE_MHOMED,
3365                         .state          = WREPL_STATE_TOMBSTONE,
3366                         .node           = WREPL_NODE_B,
3367                         .is_static      = False,
3368                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3369                         .ips            = addresses_A_1,
3370                         .apply_expected = True
3371                 },
3372                 .r2     = {
3373                         .owner          = &ctx->b,
3374                         .type           = WREPL_TYPE_SGROUP,
3375                         .state          = WREPL_STATE_ACTIVE,
3376                         .node           = WREPL_NODE_B,
3377                         .is_static      = False,
3378                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3379                         .ips            = addresses_B_1,
3380                         .apply_expected = True
3381                 }
3382         },
3383
3384         /*
3385          * mhomed,tombstone vs. sgroup,tombstone
3386          * => should be replaced
3387          */
3388         {
3389                 .line   = __location__,
3390                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3391                 .r1     = {
3392                         .owner          = &ctx->b,
3393                         .type           = WREPL_TYPE_MHOMED,
3394                         .state          = WREPL_STATE_TOMBSTONE,
3395                         .node           = WREPL_NODE_B,
3396                         .is_static      = False,
3397                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3398                         .ips            = addresses_B_1,
3399                         .apply_expected = True
3400                 },
3401                 .r2     = {
3402                         .owner          = &ctx->a,
3403                         .type           = WREPL_TYPE_SGROUP,
3404                         .state          = WREPL_STATE_TOMBSTONE,
3405                         .node           = WREPL_NODE_B,
3406                         .is_static      = False,
3407                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3408                         .ips            = addresses_A_1,
3409                         .apply_expected = True
3410                 }
3411         },
3412
3413 /*
3414  * multi homed vs. mlti homed section,
3415  */
3416         /*
3417          * mhomed,active vs. mhomed,active
3418          * => should be replaced
3419          */
3420         {
3421                 .line   = __location__,
3422                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3423                 .r1     = {
3424                         .owner          = &ctx->a,
3425                         .type           = WREPL_TYPE_MHOMED,
3426                         .state          = WREPL_STATE_ACTIVE,
3427                         .node           = WREPL_NODE_B,
3428                         .is_static      = False,
3429                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
3430                         .ips            = addresses_A_3_4,
3431                         .apply_expected = True
3432                 },
3433                 .r2     = {
3434                         .owner          = &ctx->b,
3435                         .type           = WREPL_TYPE_MHOMED,
3436                         .state          = WREPL_STATE_ACTIVE,
3437                         .node           = WREPL_NODE_B,
3438                         .is_static      = False,
3439                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
3440                         .ips            = addresses_B_3_4,
3441                         .apply_expected = True
3442                 }
3443         },
3444
3445         /*
3446          * mhomed,active vs. mhomed,tombstone
3447          * => should NOT be replaced
3448          */
3449         {
3450                 .line   = __location__,
3451                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3452                 .r1     = {
3453                         .owner          = &ctx->b,
3454                         .type           = WREPL_TYPE_MHOMED,
3455                         .state          = WREPL_STATE_ACTIVE,
3456                         .node           = WREPL_NODE_B,
3457                         .is_static      = False,
3458                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
3459                         .ips            = addresses_B_3_4,
3460                         .apply_expected = True
3461                 },
3462                 .r2     = {
3463                         .owner          = &ctx->a,
3464                         .type           = WREPL_TYPE_MHOMED,
3465                         .state          = WREPL_STATE_TOMBSTONE,
3466                         .node           = WREPL_NODE_B,
3467                         .is_static      = False,
3468                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
3469                         .ips            = addresses_B_3_4,
3470                         .apply_expected = False
3471                 }
3472         },
3473
3474         /*
3475          * mhomed,released vs. mhomed,active
3476          * => should be replaced
3477          */
3478         {
3479                 .line   = __location__,
3480                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3481                 .r1     = {
3482                         .owner          = &ctx->b,
3483                         .type           = WREPL_TYPE_MHOMED,
3484                         .state          = WREPL_STATE_RELEASED,
3485                         .node           = WREPL_NODE_B,
3486                         .is_static      = False,
3487                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
3488                         .ips            = addresses_B_3_4,
3489                         .apply_expected = False
3490                 },
3491                 .r2     = {
3492                         .owner          = &ctx->a,
3493                         .type           = WREPL_TYPE_MHOMED,
3494                         .state          = WREPL_STATE_ACTIVE,
3495                         .node           = WREPL_NODE_B,
3496                         .is_static      = False,
3497                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
3498                         .ips            = addresses_A_3_4,
3499                         .apply_expected = True
3500                 }
3501         },
3502
3503         /*
3504          * mhomed,released vs. mhomed,tombstone
3505          * => should be replaced
3506          */
3507         {
3508                 .line   = __location__,
3509                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3510                 .r1     = {
3511                         .owner          = &ctx->a,
3512                         .type           = WREPL_TYPE_MHOMED,
3513                         .state          = WREPL_STATE_RELEASED,
3514                         .node           = WREPL_NODE_B,
3515                         .is_static      = False,
3516                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
3517                         .ips            = addresses_A_3_4,
3518                         .apply_expected = False
3519                 },
3520                 .r2     = {
3521                         .owner          = &ctx->b,
3522                         .type           = WREPL_TYPE_MHOMED,
3523                         .state          = WREPL_STATE_TOMBSTONE,
3524                         .node           = WREPL_NODE_B,
3525                         .is_static      = False,
3526                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
3527                         .ips            = addresses_B_3_4,
3528                         .apply_expected = True
3529                 }
3530         },
3531
3532         /*
3533          * mhomed,tombstone vs. mhomed,active
3534          * => should be replaced
3535          */
3536         {
3537                 .line   = __location__,
3538                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3539                 .r1     = {
3540                         .owner          = &ctx->b,
3541                         .type           = WREPL_TYPE_MHOMED,
3542                         .state          = WREPL_STATE_TOMBSTONE,
3543                         .node           = WREPL_NODE_B,
3544                         .is_static      = False,
3545                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
3546                         .ips            = addresses_B_3_4,
3547                         .apply_expected = True
3548                 },
3549                 .r2     = {
3550                         .owner          = &ctx->a,
3551                         .type           = WREPL_TYPE_MHOMED,
3552                         .state          = WREPL_STATE_ACTIVE,
3553                         .node           = WREPL_NODE_B,
3554                         .is_static      = False,
3555                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
3556                         .ips            = addresses_A_3_4,
3557                         .apply_expected = True
3558                 }
3559         },
3560
3561         /*
3562          * mhomed,tombstone vs. mhomed,tombstone
3563          * => should be replaced
3564          */
3565         {
3566                 .line   = __location__,
3567                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3568                 .r1     = {
3569                         .owner          = &ctx->a,
3570                         .type           = WREPL_TYPE_MHOMED,
3571                         .state          = WREPL_STATE_TOMBSTONE,
3572                         .node           = WREPL_NODE_B,
3573                         .is_static      = False,
3574                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
3575                         .ips            = addresses_A_3_4,
3576                         .apply_expected = True
3577                 },
3578                 .r2     = {
3579                         .owner          = &ctx->b,
3580                         .type           = WREPL_TYPE_MHOMED,
3581                         .state          = WREPL_STATE_TOMBSTONE,
3582                         .node           = WREPL_NODE_B,
3583                         .is_static      = False,
3584                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
3585                         .ips            = addresses_B_3_4,
3586                         .apply_expected = True
3587                 }
3588         },
3589
3590 #if 0
3591 /*
3592  * special group vs special group section,
3593  */
3594         /*
3595          * sgroup,active vs. sgroup,active
3596          * => should be merged
3597          */
3598         {
3599                 .line   = __location__,
3600                 .name   = _NBT_NAME("_DIFF_OWNER_SG", 0x00, NULL),
3601                 .extra  = True,
3602                 .r1     = {
3603                         .owner          = &ctx->a,
3604                         .type           = WREPL_TYPE_SGROUP,
3605                         .state          = WREPL_STATE_ACTIVE,
3606                         .node           = WREPL_NODE_B,
3607                         .is_static      = False,
3608                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
3609                         .ips            = addresses_A_3_4,
3610                         .apply_expected = True,
3611                 },
3612                 .r2     = {
3613                         .owner          = &ctx->b,
3614                         .type           = WREPL_TYPE_SGROUP,
3615                         .state          = WREPL_STATE_ACTIVE,
3616                         .node           = WREPL_NODE_B,
3617                         .is_static      = False,
3618                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
3619                         .ips            = addresses_B_3_4,
3620                         .apply_expected = False,
3621                         .merge_expected = True
3622                 }
3623         },
3624         {
3625                 .line   = __location__,
3626                 .name   = _NBT_NAME("_DIFF_OWNER_SG", 0x00, NULL),
3627                 .cleanup= True,
3628                 .r1     = {
3629                         .owner          = &ctx->a,
3630                         .type           = WREPL_TYPE_SGROUP,
3631                         .state          = WREPL_STATE_ACTIVE,
3632                         .node           = WREPL_NODE_B,
3633                         .is_static      = False,
3634                         .num_ips        = 0,
3635                         .ips            = NULL,
3636                         .apply_expected = False
3637                 },
3638                 .r2     = {
3639                         .owner          = &ctx->b,
3640                         .type           = WREPL_TYPE_SGROUP,
3641                         .state          = WREPL_STATE_ACTIVE,
3642                         .node           = WREPL_NODE_B,
3643                         .is_static      = False,
3644                         .num_ips        = 0,
3645                         .ips            = NULL,
3646                         .apply_expected = False,
3647                         .merge_expected = False
3648                 }
3649         },
3650         {
3651                 .line   = __location__,
3652                 .name   = _NBT_NAME("_DIFF_OWNER_SG", 0x00, NULL),
3653                 .cleanup= True,
3654                 .r1     = {
3655                         .owner          = &ctx->a,
3656                         .type           = WREPL_TYPE_SGROUP,
3657                         .state          = WREPL_STATE_ACTIVE,
3658                         .node           = WREPL_NODE_B,
3659                         .is_static      = False,
3660                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3661                         .ips            = addresses_A_1,
3662                         .apply_expected = True
3663                 },
3664                 .r2     = {
3665                         .owner          = &ctx->a,
3666                         .type           = WREPL_TYPE_UNIQUE,
3667                         .state          = WREPL_STATE_TOMBSTONE,
3668                         .node           = WREPL_NODE_B,
3669                         .is_static      = False,
3670                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3671                         .ips            = addresses_A_1,
3672                         .apply_expected = True
3673                 }
3674         },
3675 #endif
3676         /*
3677          * This should be the last record in this array,
3678          * we need to make sure the we leave a tombstoned unique entry
3679          * owned by OWNER_A
3680          */
3681         {
3682                 .line   = __location__,
3683                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3684                 .cleanup= True,
3685                 .r1     = {
3686                         .owner          = &ctx->b,
3687                         .type           = WREPL_TYPE_UNIQUE,
3688                         .state          = WREPL_STATE_TOMBSTONE,
3689                         .node           = WREPL_NODE_B,
3690                         .is_static      = False,
3691                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3692                         .ips            = addresses_A_1,
3693                         .apply_expected = True
3694                 },
3695                 .r2     = {
3696                         .owner          = &ctx->a,
3697                         .type           = WREPL_TYPE_UNIQUE,
3698                         .state          = WREPL_STATE_TOMBSTONE,
3699                         .node           = WREPL_NODE_B,
3700                         .is_static      = False,
3701                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3702                         .ips            = addresses_A_1,
3703                         .apply_expected = True
3704                 }
3705         }}; /* do not add entries here, this should be the last record! */
3706
3707         if (!ctx) return False;
3708
3709         wins_name_r1    = &wins_name1;
3710         wins_name_r2    = &wins_name2;
3711
3712         printf("Test Replica Conflicts with different owners\n");
3713
3714         for(i=0; ret && i < ARRAY_SIZE(records); i++) {
3715
3716                 if (!records[i].extra && !records[i].cleanup) {
3717                         /* we should test the worst cases */
3718                         if (records[i].r2.apply_expected && records[i].r1.ips==records[i].r2.ips) {
3719                                 printf("(%s) Programmer error, invalid record[%u]: %s\n",
3720                                         __location__, i, records[i].line);
3721                                 return False;
3722                         } else if (!records[i].r2.apply_expected && records[i].r1.ips!=records[i].r2.ips) {
3723                                 printf("(%s) Programmer error, invalid record[%u]: %s\n",
3724                                         __location__, i, records[i].line);
3725                                 return False;
3726                         }
3727                 }
3728
3729                 if (!records[i].cleanup) {
3730                         const char *expected;
3731                         const char *ips;
3732
3733                         if (records[i].r2.merge_expected) {
3734                                 expected = "MERGE";
3735                         } else if (records[i].r2.apply_expected) {
3736                                 expected = "REPLACE";
3737                         } else {
3738                                 expected = "NOT REPLACE";
3739                         }
3740
3741                         if (!records[i].r1.ips && !records[i].r2.ips) {
3742                                 ips = "no";
3743                         } else if (records[i].r1.ips==records[i].r2.ips) {
3744                                 ips = "same";
3745                         } else {
3746                                 ips = "different";
3747                         }
3748
3749                         printf("%s,%s%s vs. %s,%s%s with %s ip(s) => %s\n",
3750                                 wrepl_name_type_string(records[i].r1.type),
3751                                 wrepl_name_state_string(records[i].r1.state),
3752                                 (records[i].r1.is_static?",static":""),
3753                                 wrepl_name_type_string(records[i].r2.type),
3754                                 wrepl_name_state_string(records[i].r2.state),
3755                                 (records[i].r2.is_static?",static":""),
3756                                 ips, expected);
3757                 }
3758
3759                 /*
3760                  * Setup R1
3761                  */
3762                 wins_name_r1->name      = &records[i].name;
3763                 wins_name_r1->flags     = WREPL_NAME_FLAGS(records[i].r1.type,
3764                                                            records[i].r1.state,
3765                                                            records[i].r1.node,
3766                                                            records[i].r1.is_static);
3767                 wins_name_r1->id        = ++records[i].r1.owner->max_version;
3768                 if (wins_name_r1->flags & 2) {
3769                         wins_name_r1->addresses.addresses.num_ips = records[i].r1.num_ips;
3770                         wins_name_r1->addresses.addresses.ips     = discard_const(records[i].r1.ips);
3771                 } else {
3772                         wins_name_r1->addresses.ip = records[i].r1.ips[0].ip;
3773                 }
3774                 wins_name_r1->unknown   = "255.255.255.255";
3775
3776                 /* now apply R1 */
3777                 ret &= test_wrepl_update_one(ctx, records[i].r1.owner, wins_name_r1);
3778                 ret &= test_wrepl_is_applied(ctx, records[i].r1.owner,
3779                                              wins_name_r1, records[i].r1.apply_expected);
3780
3781                 /*
3782                  * Setup R2
3783                  */
3784                 wins_name_r2->name      = &records[i].name;
3785                 wins_name_r2->flags     = WREPL_NAME_FLAGS(records[i].r2.type,
3786                                                            records[i].r2.state,
3787                                                            records[i].r2.node,
3788                                                            records[i].r2.is_static);
3789                 wins_name_r2->id        = ++records[i].r2.owner->max_version;
3790                 if (wins_name_r2->flags & 2) {
3791                         wins_name_r2->addresses.addresses.num_ips = records[i].r2.num_ips;
3792                         wins_name_r2->addresses.addresses.ips     = discard_const(records[i].r2.ips);
3793                 } else {
3794                         wins_name_r2->addresses.ip = records[i].r2.ips[0].ip;
3795                 }
3796                 wins_name_r2->unknown   = "255.255.255.255";
3797
3798                 /* now apply R2 */
3799                 ret &= test_wrepl_update_one(ctx, records[i].r2.owner, wins_name_r2);
3800                 if (records[i].r1.state == WREPL_STATE_RELEASED) {
3801                         ret &= test_wrepl_is_applied(ctx, records[i].r1.owner,
3802                                                      wins_name_r1, False);
3803                 } else if (records[i].r2.merge_expected) {
3804                         ret &= test_wrepl_is_merged(ctx, wins_name_r1, wins_name_r2);
3805                 } else if (records[i].r1.owner != records[i].r2.owner) {
3806                         BOOL _expected;
3807                         _expected = (records[i].r1.apply_expected && !records[i].r2.apply_expected);
3808                         ret &= test_wrepl_is_applied(ctx, records[i].r1.owner,
3809                                                      wins_name_r1, _expected);
3810                 }
3811                 if (records[i].r2.state == WREPL_STATE_RELEASED) {
3812                         ret &= test_wrepl_is_applied(ctx, records[i].r2.owner,
3813                                                      wins_name_r2, False);
3814                 } else if (!records[i].r2.merge_expected) {
3815                         ret &= test_wrepl_is_applied(ctx, records[i].r2.owner,
3816                                                      wins_name_r2, records[i].r2.apply_expected);
3817                 }
3818
3819                 /* the first one is a cleanup run */
3820                 if (!ret && i == 0) ret = True;
3821
3822                 if (!ret) {
3823                         printf("conflict handled wrong or record[%u]: %s\n", i, records[i].line);
3824                         return ret;
3825                 }
3826         }
3827
3828         return ret;
3829 }
3830
3831 static BOOL test_conflict_owned_released_vs_replica(struct test_wrepl_conflict_conn *ctx)
3832 {
3833         BOOL ret = True;
3834         NTSTATUS status;
3835         struct wrepl_wins_name wins_name_;
3836         struct wrepl_wins_name *wins_name = &wins_name_;
3837         struct nbt_name_register name_register_;
3838         struct nbt_name_register *name_register = &name_register_;
3839         struct nbt_name_release release_;
3840         struct nbt_name_release *release = &release_;
3841         uint32_t i;
3842         struct {
3843                 const char *line; /* just better debugging */
3844                 struct nbt_name name;
3845                 struct {
3846                         uint32_t nb_flags;
3847                         BOOL mhomed;
3848                         uint32_t num_ips;
3849                         const struct wrepl_ip *ips;
3850                         BOOL apply_expected;
3851                 } wins;
3852                 struct {
3853                         enum wrepl_name_type type;
3854                         enum wrepl_name_state state;
3855                         enum wrepl_name_node node;
3856                         BOOL is_static;
3857                         uint32_t num_ips;
3858                         const struct wrepl_ip *ips;
3859                         BOOL apply_expected;
3860                 } replica;
3861         } records[] = {
3862 /*
3863  * unique vs. unique section
3864  */
3865         /*
3866          * unique,released vs. unique,active with same ip(s)
3867          */
3868         {
3869                 .line   = __location__,
3870                 .name   = _NBT_NAME("_UR_UA_SI", 0x00, NULL),
3871                 .wins   = {
3872                         .nb_flags       = 0,
3873                         .mhomed         = False,
3874                         .num_ips        = ctx->addresses_1_num,
3875                         .ips            = ctx->addresses_1,
3876                         .apply_expected = True
3877                 },
3878                 .replica= {
3879                         .type           = WREPL_TYPE_UNIQUE,
3880                         .state          = WREPL_STATE_ACTIVE,
3881                         .node           = WREPL_NODE_B,
3882                         .is_static      = False,
3883                         .num_ips        = ctx->addresses_1_num,
3884                         .ips            = ctx->addresses_1,
3885                         .apply_expected = True
3886                 },
3887         },
3888         /*
3889          * unique,released vs. unique,active with different ip(s)
3890          */
3891         {
3892                 .line   = __location__,
3893                 .name   = _NBT_NAME("_UR_UA_DI", 0x00, NULL),
3894                 .wins   = {
3895                         .nb_flags       = 0,
3896                         .mhomed         = False,
3897                         .num_ips        = ctx->addresses_1_num,
3898                         .ips            = ctx->addresses_1,
3899                         .apply_expected = True
3900                 },
3901                 .replica= {
3902                         .type           = WREPL_TYPE_UNIQUE,
3903                         .state          = WREPL_STATE_ACTIVE,
3904                         .node           = WREPL_NODE_B,
3905                         .is_static      = False,
3906                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3907                         .ips            = addresses_B_1,
3908                         .apply_expected = True
3909                 },
3910         },
3911         /*
3912          * unique,released vs. unique,tombstone with same ip(s)
3913          */
3914         {
3915                 .line   = __location__,
3916                 .name   = _NBT_NAME("_UR_UT_SI", 0x00, NULL),
3917                 .wins   = {
3918                         .nb_flags       = 0,
3919                         .mhomed         = False,
3920                         .num_ips        = ctx->addresses_1_num,
3921                         .ips            = ctx->addresses_1,
3922                         .apply_expected = True
3923                 },
3924                 .replica= {
3925                         .type           = WREPL_TYPE_UNIQUE,
3926                         .state          = WREPL_STATE_TOMBSTONE,
3927                         .node           = WREPL_NODE_B,
3928                         .is_static      = False,
3929                         .num_ips        = ctx->addresses_1_num,
3930                         .ips            = ctx->addresses_1,
3931                         .apply_expected = True
3932                 },
3933         },
3934         /*
3935          * unique,released vs. unique,tombstone with different ip(s)
3936          */
3937         {
3938                 .line   = __location__,
3939                 .name   = _NBT_NAME("_UR_UT_DI", 0x00, NULL),
3940                 .wins   = {
3941                         .nb_flags       = 0,
3942                         .mhomed         = False,
3943                         .num_ips        = ctx->addresses_1_num,
3944                         .ips            = ctx->addresses_1,
3945                         .apply_expected = True
3946                 },
3947                 .replica= {
3948                         .type           = WREPL_TYPE_UNIQUE,
3949                         .state          = WREPL_STATE_TOMBSTONE,
3950                         .node           = WREPL_NODE_B,
3951                         .is_static      = False,
3952                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3953                         .ips            = addresses_B_1,
3954                         .apply_expected = True
3955                 },
3956         },
3957 /*
3958  * unique vs. group section
3959  */
3960         /*
3961          * unique,released vs. group,active with same ip(s)
3962          */
3963         {
3964                 .line   = __location__,
3965                 .name   = _NBT_NAME("_UR_GA_SI", 0x00, NULL),
3966                 .wins   = {
3967                         .nb_flags       = 0,
3968                         .mhomed         = False,
3969                         .num_ips        = ctx->addresses_1_num,
3970                         .ips            = ctx->addresses_1,
3971                         .apply_expected = True
3972                 },
3973                 .replica= {
3974                         .type           = WREPL_TYPE_GROUP,
3975                         .state          = WREPL_STATE_ACTIVE,
3976                         .node           = WREPL_NODE_B,
3977                         .is_static      = False,
3978                         .num_ips        = ctx->addresses_1_num,
3979                         .ips            = ctx->addresses_1,
3980                         .apply_expected = True
3981                 },
3982         },
3983         /*
3984          * unique,released vs. group,active with different ip(s)
3985          */
3986         {
3987                 .line   = __location__,
3988                 .name   = _NBT_NAME("_UR_GA_DI", 0x00, NULL),
3989                 .wins   = {
3990                         .nb_flags       = 0,
3991                         .mhomed         = False,
3992                         .num_ips        = ctx->addresses_1_num,
3993                         .ips            = ctx->addresses_1,
3994                         .apply_expected = True
3995                 },
3996                 .replica= {
3997                         .type           = WREPL_TYPE_GROUP,
3998                         .state          = WREPL_STATE_ACTIVE,
3999                         .node           = WREPL_NODE_B,
4000                         .is_static      = False,
4001                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4002                         .ips            = addresses_B_1,
4003                         .apply_expected = True
4004                 },
4005         },
4006         /*
4007          * unique,released vs. group,tombstone with same ip(s)
4008          */
4009         {
4010                 .line   = __location__,
4011                 .name   = _NBT_NAME("_UR_GT_SI", 0x00, NULL),
4012                 .wins   = {
4013                         .nb_flags       = 0,
4014                         .mhomed         = False,
4015                         .num_ips        = ctx->addresses_1_num,
4016                         .ips            = ctx->addresses_1,
4017                         .apply_expected = True
4018                 },
4019                 .replica= {
4020                         .type           = WREPL_TYPE_GROUP,
4021                         .state          = WREPL_STATE_TOMBSTONE,
4022                         .node           = WREPL_NODE_B,
4023                         .is_static      = False,
4024                         .num_ips        = ctx->addresses_1_num,
4025                         .ips            = ctx->addresses_1,
4026                         .apply_expected = True
4027                 },
4028         },
4029         /*
4030          * unique,released vs. group,tombstone with different ip(s)
4031          */
4032         {
4033                 .line   = __location__,
4034                 .name   = _NBT_NAME("_UR_GT_DI", 0x00, NULL),
4035                 .wins   = {
4036                         .nb_flags       = 0,
4037                         .mhomed         = False,
4038                         .num_ips        = ctx->addresses_1_num,
4039                         .ips            = ctx->addresses_1,
4040                         .apply_expected = True
4041                 },
4042                 .replica= {
4043                         .type           = WREPL_TYPE_GROUP,
4044                         .state          = WREPL_STATE_TOMBSTONE,
4045                         .node           = WREPL_NODE_B,
4046                         .is_static      = False,
4047                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4048                         .ips            = addresses_B_1,
4049                         .apply_expected = True
4050                 },
4051         },
4052 /*
4053  * unique vs. special group section
4054  */
4055         /*
4056          * unique,released vs. sgroup,active with same ip(s)
4057          */
4058         {
4059                 .line   = __location__,
4060                 .name   = _NBT_NAME("_UR_SA_SI", 0x00, NULL),
4061                 .wins   = {
4062                         .nb_flags       = 0,
4063                         .mhomed         = False,
4064                         .num_ips        = ctx->addresses_1_num,
4065                         .ips            = ctx->addresses_1,
4066                         .apply_expected = True
4067                 },
4068                 .replica= {
4069                         .type           = WREPL_TYPE_SGROUP,
4070                         .state          = WREPL_STATE_ACTIVE,
4071                         .node           = WREPL_NODE_B,
4072                         .is_static      = False,
4073                         .num_ips        = ctx->addresses_1_num,
4074                         .ips            = ctx->addresses_1,
4075                         .apply_expected = True
4076                 },
4077         },
4078         /*
4079          * unique,released vs. sgroup,active with different ip(s)
4080          */
4081         {
4082                 .line   = __location__,
4083                 .name   = _NBT_NAME("_UR_SA_DI", 0x00, NULL),
4084                 .wins   = {
4085                         .nb_flags       = 0,
4086                         .mhomed         = False,
4087                         .num_ips        = ctx->addresses_1_num,
4088                         .ips            = ctx->addresses_1,
4089                         .apply_expected = True
4090                 },
4091                 .replica= {
4092                         .type           = WREPL_TYPE_SGROUP,
4093                         .state          = WREPL_STATE_ACTIVE,
4094                         .node           = WREPL_NODE_B,
4095                         .is_static      = False,
4096                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4097                         .ips            = addresses_B_1,
4098                         .apply_expected = True
4099                 },
4100         },
4101         /*
4102          * unique,released vs. sgroup,tombstone with same ip(s)
4103          */
4104         {
4105                 .line   = __location__,
4106                 .name   = _NBT_NAME("_UR_ST_SI", 0x00, NULL),
4107                 .wins   = {
4108                         .nb_flags       = 0,
4109                         .mhomed         = False,
4110                         .num_ips        = ctx->addresses_1_num,
4111                         .ips            = ctx->addresses_1,
4112                         .apply_expected = True
4113                 },
4114                 .replica= {
4115                         .type           = WREPL_TYPE_SGROUP,
4116                         .state          = WREPL_STATE_TOMBSTONE,
4117                         .node           = WREPL_NODE_B,
4118                         .is_static      = False,
4119                         .num_ips        = ctx->addresses_1_num,
4120                         .ips            = ctx->addresses_1,
4121                         .apply_expected = True
4122                 },
4123         },
4124         /*
4125          * unique,released vs. sgroup,tombstone with different ip(s)
4126          */
4127         {
4128                 .line   = __location__,
4129                 .name   = _NBT_NAME("_UR_ST_DI", 0x00, NULL),
4130                 .wins   = {
4131                         .nb_flags       = 0,
4132                         .mhomed         = False,
4133                         .num_ips        = ctx->addresses_1_num,
4134                         .ips            = ctx->addresses_1,
4135                         .apply_expected = True
4136                 },
4137                 .replica= {
4138                         .type           = WREPL_TYPE_SGROUP,
4139                         .state          = WREPL_STATE_TOMBSTONE,
4140                         .node           = WREPL_NODE_B,
4141                         .is_static      = False,
4142                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4143                         .ips            = addresses_B_1,
4144                         .apply_expected = True
4145                 },
4146         },
4147 /*
4148  * unique vs. multi homed section
4149  */
4150         /*
4151          * unique,released vs. mhomed,active with same ip(s)
4152          */
4153         {
4154                 .line   = __location__,
4155                 .name   = _NBT_NAME("_UR_MA_SI", 0x00, NULL),
4156                 .wins   = {
4157                         .nb_flags       = 0,
4158                         .mhomed         = False,
4159                         .num_ips        = ctx->addresses_1_num,
4160                         .ips            = ctx->addresses_1,
4161                         .apply_expected = True
4162                 },
4163                 .replica= {
4164                         .type           = WREPL_TYPE_MHOMED,
4165                         .state          = WREPL_STATE_ACTIVE,
4166                         .node           = WREPL_NODE_B,
4167                         .is_static      = False,
4168                         .num_ips        = ctx->addresses_1_num,
4169                         .ips            = ctx->addresses_1,
4170                         .apply_expected = True
4171                 },
4172         },
4173         /*
4174          * unique,released vs. mhomed,active with different ip(s)
4175          */
4176         {
4177                 .line   = __location__,
4178                 .name   = _NBT_NAME("_UR_MA_DI", 0x00, NULL),
4179                 .wins   = {
4180                         .nb_flags       = 0,
4181                         .mhomed         = False,
4182                         .num_ips        = ctx->addresses_1_num,
4183                         .ips            = ctx->addresses_1,
4184                         .apply_expected = True
4185                 },
4186                 .replica= {
4187                         .type           = WREPL_TYPE_MHOMED,
4188                         .state          = WREPL_STATE_ACTIVE,
4189                         .node           = WREPL_NODE_B,
4190                         .is_static      = False,
4191                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4192                         .ips            = addresses_B_1,
4193                         .apply_expected = True
4194                 },
4195         },
4196         /*
4197          * unique,released vs. mhomed,tombstone with same ip(s)
4198          */
4199         {
4200                 .line   = __location__,
4201                 .name   = _NBT_NAME("_UR_MT_SI", 0x00, NULL),
4202                 .wins   = {
4203                         .nb_flags       = 0,
4204                         .mhomed         = False,
4205                         .num_ips        = ctx->addresses_1_num,
4206                         .ips            = ctx->addresses_1,
4207                         .apply_expected = True
4208                 },
4209                 .replica= {
4210                         .type           = WREPL_TYPE_MHOMED,
4211                         .state          = WREPL_STATE_TOMBSTONE,
4212                         .node           = WREPL_NODE_B,
4213                         .is_static      = False,
4214                         .num_ips        = ctx->addresses_1_num,
4215                         .ips            = ctx->addresses_1,
4216                         .apply_expected = True
4217                 },
4218         },
4219         /*
4220          * unique,released vs. mhomed,tombstone with different ip(s)
4221          */
4222         {
4223                 .line   = __location__,
4224                 .name   = _NBT_NAME("_UR_MT_DI", 0x00, NULL),
4225                 .wins   = {
4226                         .nb_flags       = 0,
4227                         .mhomed         = False,
4228                         .num_ips        = ctx->addresses_1_num,
4229                         .ips            = ctx->addresses_1,
4230                         .apply_expected = True
4231                 },
4232                 .replica= {
4233                         .type           = WREPL_TYPE_MHOMED,
4234                         .state          = WREPL_STATE_TOMBSTONE,
4235                         .node           = WREPL_NODE_B,
4236                         .is_static      = False,
4237                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4238                         .ips            = addresses_B_1,
4239                         .apply_expected = True
4240                 },
4241         },
4242 /*
4243  * group vs. unique section
4244  */
4245         /*
4246          * group,released vs. unique,active with same ip(s)
4247          */
4248         {
4249                 .line   = __location__,
4250                 .name   = _NBT_NAME("_GR_UA_SI", 0x00, NULL),
4251                 .wins   = {
4252                         .nb_flags       = NBT_NM_GROUP,
4253                         .mhomed         = False,
4254                         .num_ips        = ctx->addresses_1_num,
4255                         .ips            = ctx->addresses_1,
4256                         .apply_expected = True
4257                 },
4258                 .replica= {
4259                         .type           = WREPL_TYPE_UNIQUE,
4260                         .state          = WREPL_STATE_ACTIVE,
4261                         .node           = WREPL_NODE_B,
4262                         .is_static      = False,
4263                         .num_ips        = ctx->addresses_1_num,
4264                         .ips            = ctx->addresses_1,
4265                         .apply_expected = False
4266                 },
4267         },
4268         /*
4269          * group,released vs. unique,active with different ip(s)
4270          */
4271         {
4272                 .line   = __location__,
4273                 .name   = _NBT_NAME("_GR_UA_DI", 0x00, NULL),
4274                 .wins   = {
4275                         .nb_flags       = NBT_NM_GROUP,
4276                         .mhomed         = False,
4277                         .num_ips        = ctx->addresses_1_num,
4278                         .ips            = ctx->addresses_1,
4279                         .apply_expected = True
4280                 },
4281                 .replica= {
4282                         .type           = WREPL_TYPE_UNIQUE,
4283                         .state          = WREPL_STATE_ACTIVE,
4284                         .node           = WREPL_NODE_B,
4285                         .is_static      = False,
4286                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4287                         .ips            = addresses_B_1,
4288                         .apply_expected = False
4289                 },
4290         },
4291         /*
4292          * group,released vs. unique,tombstone with same ip(s)
4293          */
4294         {
4295                 .line   = __location__,
4296                 .name   = _NBT_NAME("_GR_UT_SI", 0x00, NULL),
4297                 .wins   = {
4298                         .nb_flags       = NBT_NM_GROUP,
4299                         .mhomed         = False,
4300                         .num_ips        = ctx->addresses_1_num,
4301                         .ips            = ctx->addresses_1,
4302                         .apply_expected = True
4303                 },
4304                 .replica= {
4305                         .type           = WREPL_TYPE_UNIQUE,
4306                         .state          = WREPL_STATE_TOMBSTONE,
4307                         .node           = WREPL_NODE_B,
4308                         .is_static      = False,
4309                         .num_ips        = ctx->addresses_1_num,
4310                         .ips            = ctx->addresses_1,
4311                         .apply_expected = False
4312                 },
4313         },
4314         /*
4315          * group,released vs. unique,tombstone with different ip(s)
4316          */
4317         {
4318                 .line   = __location__,
4319                 .name   = _NBT_NAME("_GR_UT_DI", 0x00, NULL),
4320                 .wins   = {
4321                         .nb_flags       = NBT_NM_GROUP,
4322                         .mhomed         = False,
4323                         .num_ips        = ctx->addresses_1_num,
4324                         .ips            = ctx->addresses_1,
4325                         .apply_expected = True
4326                 },
4327                 .replica= {
4328                         .type           = WREPL_TYPE_UNIQUE,
4329                         .state          = WREPL_STATE_TOMBSTONE,
4330                         .node           = WREPL_NODE_B,
4331                         .is_static      = False,
4332                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4333                         .ips            = addresses_B_1,
4334                         .apply_expected = False
4335                 },
4336         },
4337 /*
4338  * group vs. group section
4339  */
4340         /*
4341          * group,released vs. group,active with same ip(s)
4342          */
4343         {
4344                 .line   = __location__,
4345                 .name   = _NBT_NAME("_GR_GA_SI", 0x00, NULL),
4346                 .wins   = {
4347                         .nb_flags       = NBT_NM_GROUP,
4348                         .mhomed         = False,
4349                         .num_ips        = ctx->addresses_1_num,
4350                         .ips            = ctx->addresses_1,
4351                         .apply_expected = True
4352                 },
4353                 .replica= {
4354                         .type           = WREPL_TYPE_GROUP,
4355                         .state          = WREPL_STATE_ACTIVE,
4356                         .node           = WREPL_NODE_B,
4357                         .is_static      = False,
4358                         .num_ips        = ctx->addresses_1_num,
4359                         .ips            = ctx->addresses_1,
4360                         .apply_expected = True
4361                 },
4362         },
4363         /*
4364          * group,released vs. group,active with different ip(s)
4365          */
4366         {
4367                 .line   = __location__,
4368                 .name   = _NBT_NAME("_GR_GA_DI", 0x00, NULL),
4369                 .wins   = {
4370                         .nb_flags       = NBT_NM_GROUP,
4371                         .mhomed         = False,
4372                         .num_ips        = ctx->addresses_1_num,
4373                         .ips            = ctx->addresses_1,
4374                         .apply_expected = True
4375                 },
4376                 .replica= {
4377                         .type           = WREPL_TYPE_GROUP,
4378                         .state          = WREPL_STATE_ACTIVE,
4379                         .node           = WREPL_NODE_B,
4380                         .is_static      = False,
4381                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4382                         .ips            = addresses_B_1,
4383                         .apply_expected = True
4384                 },
4385         },
4386         /*
4387          * group,released vs. group,tombstone with same ip(s)
4388          */
4389         {
4390                 .line   = __location__,
4391                 .name   = _NBT_NAME("_GR_GT_SI", 0x00, NULL),
4392                 .wins   = {
4393                         .nb_flags       = NBT_NM_GROUP,
4394                         .mhomed         = False,
4395                         .num_ips        = ctx->addresses_1_num,
4396                         .ips            = ctx->addresses_1,
4397                         .apply_expected = True
4398                 },
4399                 .replica= {
4400                         .type           = WREPL_TYPE_GROUP,
4401                         .state          = WREPL_STATE_TOMBSTONE,
4402                         .node           = WREPL_NODE_B,
4403                         .is_static      = False,
4404                         .num_ips        = ctx->addresses_1_num,
4405                         .ips            = ctx->addresses_1,
4406                         .apply_expected = True
4407                 },
4408         },
4409         /*
4410          * group,released vs. group,tombstone with different ip(s)
4411          */
4412         {
4413                 .line   = __location__,
4414                 .name   = _NBT_NAME("_GR_GT_DI", 0x00, NULL),
4415                 .wins   = {
4416                         .nb_flags       = NBT_NM_GROUP,
4417                         .mhomed         = False,
4418                         .num_ips        = ctx->addresses_1_num,
4419                         .ips            = ctx->addresses_1,
4420                         .apply_expected = True
4421                 },
4422                 .replica= {
4423                         .type           = WREPL_TYPE_GROUP,
4424                         .state          = WREPL_STATE_TOMBSTONE,
4425                         .node           = WREPL_NODE_B,
4426                         .is_static      = False,
4427                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4428                         .ips            = addresses_B_1,
4429                         .apply_expected = True
4430                 },
4431         },
4432 /*
4433  * group vs. special group section
4434  */
4435         /*
4436          * group,released vs. sgroup,active with same ip(s)
4437          */
4438         {
4439                 .line   = __location__,
4440                 .name   = _NBT_NAME("_GR_SA_SI", 0x00, NULL),
4441                 .wins   = {
4442                         .nb_flags       = NBT_NM_GROUP,
4443                         .mhomed         = False,
4444                         .num_ips        = ctx->addresses_1_num,
4445                         .ips            = ctx->addresses_1,
4446                         .apply_expected = True
4447                 },
4448                 .replica= {
4449                         .type           = WREPL_TYPE_SGROUP,
4450                         .state          = WREPL_STATE_ACTIVE,
4451                         .node           = WREPL_NODE_B,
4452                         .is_static      = False,
4453                         .num_ips        = ctx->addresses_1_num,
4454                         .ips            = ctx->addresses_1,
4455                         .apply_expected = False
4456                 },
4457         },
4458         /*
4459          * group,released vs. sgroup,active with different ip(s)
4460          */
4461         {
4462                 .line   = __location__,
4463                 .name   = _NBT_NAME("_GR_SA_DI", 0x00, NULL),
4464                 .wins   = {
4465                         .nb_flags       = NBT_NM_GROUP,
4466                         .mhomed         = False,
4467                         .num_ips        = ctx->addresses_1_num,
4468                         .ips            = ctx->addresses_1,
4469                         .apply_expected = True
4470                 },
4471                 .replica= {
4472                         .type           = WREPL_TYPE_SGROUP,
4473                         .state          = WREPL_STATE_ACTIVE,
4474                         .node           = WREPL_NODE_B,
4475                         .is_static      = False,
4476                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4477                         .ips            = addresses_B_1,
4478                         .apply_expected = False
4479                 },
4480         },
4481         /*
4482          * group,released vs. sgroup,tombstone with same ip(s)
4483          */
4484         {
4485                 .line   = __location__,
4486                 .name   = _NBT_NAME("_GR_ST_SI", 0x00, NULL),
4487                 .wins   = {
4488                         .nb_flags       = NBT_NM_GROUP,
4489                         .mhomed         = False,
4490                         .num_ips        = ctx->addresses_1_num,
4491                         .ips            = ctx->addresses_1,
4492                         .apply_expected = True
4493                 },
4494                 .replica= {
4495                         .type           = WREPL_TYPE_SGROUP,
4496                         .state          = WREPL_STATE_TOMBSTONE,
4497                         .node           = WREPL_NODE_B,
4498                         .is_static      = False,
4499                         .num_ips        = ctx->addresses_1_num,
4500                         .ips            = ctx->addresses_1,
4501                         .apply_expected = False
4502                 },
4503         },
4504         /*
4505          * group,released vs. sgroup,tombstone with different ip(s)
4506          */
4507         {
4508                 .line   = __location__,
4509                 .name   = _NBT_NAME("_GR_ST_DI", 0x00, NULL),
4510                 .wins   = {
4511                         .nb_flags       = NBT_NM_GROUP,
4512                         .mhomed         = False,
4513                         .num_ips        = ctx->addresses_1_num,
4514                         .ips            = ctx->addresses_1,
4515                         .apply_expected = True
4516                 },
4517                 .replica= {
4518                         .type           = WREPL_TYPE_SGROUP,
4519                         .state          = WREPL_STATE_TOMBSTONE,
4520                         .node           = WREPL_NODE_B,
4521                         .is_static      = False,
4522                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4523                         .ips            = addresses_B_1,
4524                         .apply_expected = False
4525                 },
4526         },
4527 /*
4528  * group vs. multi homed section
4529  */
4530         /*
4531          * group,released vs. mhomed,active with same ip(s)
4532          */
4533         {
4534                 .line   = __location__,
4535                 .name   = _NBT_NAME("_GR_MA_SI", 0x00, NULL),
4536                 .wins   = {
4537                         .nb_flags       = NBT_NM_GROUP,
4538                         .mhomed         = False,
4539                         .num_ips        = ctx->addresses_1_num,
4540                         .ips            = ctx->addresses_1,
4541                         .apply_expected = True
4542                 },
4543                 .replica= {
4544                         .type           = WREPL_TYPE_MHOMED,
4545                         .state          = WREPL_STATE_ACTIVE,
4546                         .node           = WREPL_NODE_B,
4547                         .is_static      = False,
4548                         .num_ips        = ctx->addresses_1_num,
4549                         .ips            = ctx->addresses_1,
4550                         .apply_expected = False
4551                 },
4552         },
4553         /*
4554          * group,released vs. mhomed,active with different ip(s)
4555          */
4556         {
4557                 .line   = __location__,
4558                 .name   = _NBT_NAME("_GR_MA_DI", 0x00, NULL),
4559                 .wins   = {
4560                         .nb_flags       = NBT_NM_GROUP,
4561                         .mhomed         = False,
4562                         .num_ips        = ctx->addresses_1_num,
4563                         .ips            = ctx->addresses_1,
4564                         .apply_expected = True
4565                 },
4566                 .replica= {
4567                         .type           = WREPL_TYPE_MHOMED,
4568                         .state          = WREPL_STATE_ACTIVE,
4569                         .node           = WREPL_NODE_B,
4570                         .is_static      = False,
4571                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4572                         .ips            = addresses_B_1,
4573                         .apply_expected = False
4574                 },
4575         },
4576         /*
4577          * group,released vs. mhomed,tombstone with same ip(s)
4578          */
4579         {
4580                 .line   = __location__,
4581                 .name   = _NBT_NAME("_GR_MT_SI", 0x00, NULL),
4582                 .wins   = {
4583                         .nb_flags       = NBT_NM_GROUP,
4584                         .mhomed         = False,
4585                         .num_ips        = ctx->addresses_1_num,
4586                         .ips            = ctx->addresses_1,
4587                         .apply_expected = True
4588                 },
4589                 .replica= {
4590                         .type           = WREPL_TYPE_MHOMED,
4591                         .state          = WREPL_STATE_TOMBSTONE,
4592                         .node           = WREPL_NODE_B,
4593                         .is_static      = False,
4594                         .num_ips        = ctx->addresses_1_num,
4595                         .ips            = ctx->addresses_1,
4596                         .apply_expected = False
4597                 },
4598         },
4599         /*
4600          * group,released vs. mhomed,tombstone with different ip(s)
4601          */
4602         {
4603                 .line   = __location__,
4604                 .name   = _NBT_NAME("_GR_MT_DI", 0x00, NULL),
4605                 .wins   = {
4606                         .nb_flags       = NBT_NM_GROUP,
4607                         .mhomed         = False,
4608                         .num_ips        = ctx->addresses_1_num,
4609                         .ips            = ctx->addresses_1,
4610                         .apply_expected = True
4611                 },
4612                 .replica= {
4613                         .type           = WREPL_TYPE_MHOMED,
4614                         .state          = WREPL_STATE_TOMBSTONE,
4615                         .node           = WREPL_NODE_B,
4616                         .is_static      = False,
4617                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4618                         .ips            = addresses_B_1,
4619                         .apply_expected = False
4620                 },
4621         },
4622 /*
4623  * special group vs. unique section
4624  */
4625         /*
4626          * sgroup,released vs. unique,active with same ip(s)
4627          */
4628         {
4629                 .line   = __location__,
4630                 .name   = _NBT_NAME("_SR_UA_SI", 0x1C, NULL),
4631                 .wins   = {
4632                         .nb_flags       = NBT_NM_GROUP,
4633                         .mhomed         = False,
4634                         .num_ips        = ctx->addresses_1_num,
4635                         .ips            = ctx->addresses_1,
4636                         .apply_expected = True
4637                 },
4638                 .replica= {
4639                         .type           = WREPL_TYPE_UNIQUE,
4640                         .state          = WREPL_STATE_ACTIVE,
4641                         .node           = WREPL_NODE_B,
4642                         .is_static      = False,
4643                         .num_ips        = ctx->addresses_1_num,
4644                         .ips            = ctx->addresses_1,
4645                         .apply_expected = True
4646                 },
4647         },
4648         /*
4649          * sgroup,released vs. unique,active with different ip(s)
4650          */
4651         {
4652                 .line   = __location__,
4653                 .name   = _NBT_NAME("_SR_UA_DI", 0x1C, NULL),
4654                 .wins   = {
4655                         .nb_flags       = NBT_NM_GROUP,
4656                         .mhomed         = False,
4657                         .num_ips        = ctx->addresses_1_num,
4658                         .ips            = ctx->addresses_1,
4659                         .apply_expected = True
4660                 },
4661                 .replica= {
4662                         .type           = WREPL_TYPE_UNIQUE,
4663                         .state          = WREPL_STATE_ACTIVE,
4664                         .node           = WREPL_NODE_B,
4665                         .is_static      = False,
4666                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4667                         .ips            = addresses_B_1,
4668                         .apply_expected = True
4669                 },
4670         },
4671         /*
4672          * sgroup,released vs. unique,tombstone with same ip(s)
4673          */
4674         {
4675                 .line   = __location__,
4676                 .name   = _NBT_NAME("_SR_UT_SI", 0x1C, NULL),
4677                 .wins   = {
4678                         .nb_flags       = NBT_NM_GROUP,
4679                         .mhomed         = False,
4680                         .num_ips        = ctx->addresses_1_num,
4681                         .ips            = ctx->addresses_1,
4682                         .apply_expected = True
4683                 },
4684                 .replica= {
4685                         .type           = WREPL_TYPE_UNIQUE,
4686                         .state          = WREPL_STATE_TOMBSTONE,
4687                         .node           = WREPL_NODE_B,
4688                         .is_static      = False,
4689                         .num_ips        = ctx->addresses_1_num,
4690                         .ips            = ctx->addresses_1,
4691                         .apply_expected = True
4692                 },
4693         },
4694         /*
4695          * sgroup,released vs. unique,tombstone with different ip(s)
4696          */
4697         {
4698                 .line   = __location__,
4699                 .name   = _NBT_NAME("_SR_UT_DI", 0x1C, NULL),
4700                 .wins   = {
4701                         .nb_flags       = NBT_NM_GROUP,
4702                         .mhomed         = False,
4703                         .num_ips        = ctx->addresses_1_num,
4704                         .ips            = ctx->addresses_1,
4705                         .apply_expected = True
4706                 },
4707                 .replica= {
4708                         .type           = WREPL_TYPE_UNIQUE,
4709                         .state          = WREPL_STATE_TOMBSTONE,
4710                         .node           = WREPL_NODE_B,
4711                         .is_static      = False,
4712                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4713                         .ips            = addresses_B_1,
4714                         .apply_expected = True
4715                 },
4716         },
4717 /*
4718  * special group vs. group section
4719  */
4720         /*
4721          * sgroup,released vs. group,active with same ip(s)
4722          */
4723         {
4724                 .line   = __location__,
4725                 .name   = _NBT_NAME("_SR_GA_SI", 0x1C, NULL),
4726                 .wins   = {
4727                         .nb_flags       = NBT_NM_GROUP,
4728                         .mhomed         = False,
4729                         .num_ips        = ctx->addresses_1_num,
4730                         .ips            = ctx->addresses_1,
4731                         .apply_expected = True
4732                 },
4733                 .replica= {
4734                         .type           = WREPL_TYPE_GROUP,
4735                         .state          = WREPL_STATE_ACTIVE,
4736                         .node           = WREPL_NODE_B,
4737                         .is_static      = False,
4738                         .num_ips        = ctx->addresses_1_num,
4739                         .ips            = ctx->addresses_1,
4740                         .apply_expected = True
4741                 },
4742         },
4743         /*
4744          * sgroup,released vs. group,active with different ip(s)
4745          */
4746         {
4747                 .line   = __location__,
4748                 .name   = _NBT_NAME("_SR_GA_DI", 0x1C, NULL),
4749                 .wins   = {
4750                         .nb_flags       = NBT_NM_GROUP,
4751                         .mhomed         = False,
4752                         .num_ips        = ctx->addresses_1_num,
4753                         .ips            = ctx->addresses_1,
4754                         .apply_expected = True
4755                 },
4756                 .replica= {
4757                         .type           = WREPL_TYPE_GROUP,
4758                         .state          = WREPL_STATE_ACTIVE,
4759                         .node           = WREPL_NODE_B,
4760                         .is_static      = False,
4761                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4762                         .ips            = addresses_B_1,
4763                         .apply_expected = True
4764                 },
4765         },
4766         /*
4767          * sgroup,released vs. group,tombstone with same ip(s)
4768          */
4769         {
4770                 .line   = __location__,
4771                 .name   = _NBT_NAME("_SR_GT_SI", 0x1C, NULL),
4772                 .wins   = {
4773                         .nb_flags       = NBT_NM_GROUP,
4774                         .mhomed         = False,
4775                         .num_ips        = ctx->addresses_1_num,
4776                         .ips            = ctx->addresses_1,
4777                         .apply_expected = True
4778                 },
4779                 .replica= {
4780                         .type           = WREPL_TYPE_GROUP,
4781                         .state          = WREPL_STATE_TOMBSTONE,
4782                         .node           = WREPL_NODE_B,
4783                         .is_static      = False,
4784                         .num_ips        = ctx->addresses_1_num,
4785                         .ips            = ctx->addresses_1,
4786                         .apply_expected = True
4787                 },
4788         },
4789         /*
4790          * sgroup,released vs. group,tombstone with different ip(s)
4791          */
4792         {
4793                 .line   = __location__,
4794                 .name   = _NBT_NAME("_SR_GT_DI", 0x1C, NULL),
4795                 .wins   = {
4796                         .nb_flags       = NBT_NM_GROUP,
4797                         .mhomed         = False,
4798                         .num_ips        = ctx->addresses_1_num,
4799                         .ips            = ctx->addresses_1,
4800                         .apply_expected = True
4801                 },
4802                 .replica= {
4803                         .type           = WREPL_TYPE_GROUP,
4804                         .state          = WREPL_STATE_TOMBSTONE,
4805                         .node           = WREPL_NODE_B,
4806                         .is_static      = False,
4807                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4808                         .ips            = addresses_B_1,
4809                         .apply_expected = True
4810                 },
4811         },
4812 /*
4813  * special group vs. special group section
4814  */
4815         /*
4816          * sgroup,released vs. sgroup,active with same ip(s)
4817          */
4818         {
4819                 .line   = __location__,
4820                 .name   = _NBT_NAME("_SR_SA_SI", 0x1C, NULL),
4821                 .wins   = {
4822                         .nb_flags       = NBT_NM_GROUP,
4823                         .mhomed         = False,
4824                         .num_ips        = ctx->addresses_1_num,
4825                         .ips            = ctx->addresses_1,
4826                         .apply_expected = True
4827                 },
4828                 .replica= {
4829                         .type           = WREPL_TYPE_SGROUP,
4830                         .state          = WREPL_STATE_ACTIVE,
4831                         .node           = WREPL_NODE_B,
4832                         .is_static      = False,
4833                         .num_ips        = ctx->addresses_1_num,
4834                         .ips            = ctx->addresses_1,
4835                         .apply_expected = True
4836                 },
4837         },
4838         /*
4839          * sgroup,released vs. sgroup,active with different ip(s)
4840          */
4841         {
4842                 .line   = __location__,
4843                 .name   = _NBT_NAME("_SR_SA_DI", 0x1C, NULL),
4844                 .wins   = {
4845                         .nb_flags       = NBT_NM_GROUP,
4846                         .mhomed         = False,
4847                         .num_ips        = ctx->addresses_1_num,
4848                         .ips            = ctx->addresses_1,
4849                         .apply_expected = True
4850                 },
4851                 .replica= {
4852                         .type           = WREPL_TYPE_SGROUP,
4853                         .state          = WREPL_STATE_ACTIVE,
4854                         .node           = WREPL_NODE_B,
4855                         .is_static      = False,
4856                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4857                         .ips            = addresses_B_1,
4858                         .apply_expected = True
4859                 },
4860         },
4861         /*
4862          * sgroup,released vs. sgroup,tombstone with same ip(s)
4863          */
4864         {
4865                 .line   = __location__,
4866                 .name   = _NBT_NAME("_SR_ST_SI", 0x1C, NULL),
4867                 .wins   = {
4868                         .nb_flags       = NBT_NM_GROUP,
4869                         .mhomed         = False,
4870                         .num_ips        = ctx->addresses_1_num,
4871                         .ips            = ctx->addresses_1,
4872                         .apply_expected = True
4873                 },
4874                 .replica= {
4875                         .type           = WREPL_TYPE_SGROUP,
4876                         .state          = WREPL_STATE_TOMBSTONE,
4877                         .node           = WREPL_NODE_B,
4878                         .is_static      = False,
4879                         .num_ips        = ctx->addresses_1_num,
4880                         .ips            = ctx->addresses_1,
4881                         .apply_expected = True
4882                 },
4883         },
4884         /*
4885          * sgroup,released vs. sgroup,tombstone with different ip(s)
4886          */
4887         {
4888                 .line   = __location__,
4889                 .name   = _NBT_NAME("_SR_ST_DI", 0x1C, NULL),
4890                 .wins   = {
4891                         .nb_flags       = NBT_NM_GROUP,
4892                         .mhomed         = False,
4893                         .num_ips        = ctx->addresses_1_num,
4894                         .ips            = ctx->addresses_1,
4895                         .apply_expected = True
4896                 },
4897                 .replica= {
4898                         .type           = WREPL_TYPE_SGROUP,
4899                         .state          = WREPL_STATE_TOMBSTONE,
4900                         .node           = WREPL_NODE_B,
4901                         .is_static      = False,
4902                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4903                         .ips            = addresses_B_1,
4904                         .apply_expected = True
4905                 },
4906         },
4907 /*
4908  * special group vs. multi homed section
4909  */
4910         /*
4911          * sgroup,released vs. mhomed,active with same ip(s)
4912          */
4913         {
4914                 .line   = __location__,
4915                 .name   = _NBT_NAME("_SR_MA_SI", 0x1C, NULL),
4916                 .wins   = {
4917                         .nb_flags       = NBT_NM_GROUP,
4918                         .mhomed         = False,
4919                         .num_ips        = ctx->addresses_1_num,
4920                         .ips            = ctx->addresses_1,
4921                         .apply_expected = True
4922                 },
4923                 .replica= {
4924                         .type           = WREPL_TYPE_MHOMED,
4925                         .state          = WREPL_STATE_ACTIVE,
4926                         .node           = WREPL_NODE_B,
4927                         .is_static      = False,
4928                         .num_ips        = ctx->addresses_1_num,
4929                         .ips            = ctx->addresses_1,
4930                         .apply_expected = True
4931                 },
4932         },
4933         /*
4934          * sgroup,released vs. mhomed,active with different ip(s)
4935          */
4936         {
4937                 .line   = __location__,
4938                 .name   = _NBT_NAME("_SR_MA_DI", 0x1C, NULL),
4939                 .wins   = {
4940                         .nb_flags       = NBT_NM_GROUP,
4941                         .mhomed         = False,
4942                         .num_ips        = ctx->addresses_1_num,
4943                         .ips            = ctx->addresses_1,
4944                         .apply_expected = True
4945                 },
4946                 .replica= {
4947                         .type           = WREPL_TYPE_MHOMED,
4948                         .state          = WREPL_STATE_ACTIVE,
4949                         .node           = WREPL_NODE_B,
4950                         .is_static      = False,
4951                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4952                         .ips            = addresses_B_1,
4953                         .apply_expected = True
4954                 },
4955         },
4956         /*
4957          * sgroup,released vs. mhomed,tombstone with same ip(s)
4958          */
4959         {
4960                 .line   = __location__,
4961                 .name   = _NBT_NAME("_SR_MT_SI", 0x1C, NULL),
4962                 .wins   = {
4963                         .nb_flags       = NBT_NM_GROUP,
4964                         .mhomed         = False,
4965                         .num_ips        = ctx->addresses_1_num,
4966                         .ips            = ctx->addresses_1,
4967                         .apply_expected = True
4968                 },
4969                 .replica= {
4970                         .type           = WREPL_TYPE_MHOMED,
4971                         .state          = WREPL_STATE_TOMBSTONE,
4972                         .node           = WREPL_NODE_B,
4973                         .is_static      = False,
4974                         .num_ips        = ctx->addresses_1_num,
4975                         .ips            = ctx->addresses_1,
4976                         .apply_expected = True
4977                 },
4978         },
4979         /*
4980          * sgroup,released vs. mhomed,tombstone with different ip(s)
4981          */
4982         {
4983                 .line   = __location__,
4984                 .name   = _NBT_NAME("_SR_MT_DI", 0x1C, NULL),
4985                 .wins   = {
4986                         .nb_flags       = NBT_NM_GROUP,
4987                         .mhomed         = False,
4988                         .num_ips        = ctx->addresses_1_num,
4989                         .ips            = ctx->addresses_1,
4990                         .apply_expected = True
4991                 },
4992                 .replica= {
4993                         .type           = WREPL_TYPE_MHOMED,
4994                         .state          = WREPL_STATE_TOMBSTONE,
4995                         .node           = WREPL_NODE_B,
4996                         .is_static      = False,
4997                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4998                         .ips            = addresses_B_1,
4999                         .apply_expected = True
5000                 },
5001         },
5002 /*
5003  * multi homed vs. unique section
5004  */
5005         /*
5006          * mhomed,released vs. unique,active with same ip(s)
5007          */
5008         {
5009                 .line   = __location__,
5010                 .name   = _NBT_NAME("_MR_UA_SI", 0x00, NULL),
5011                 .wins   = {
5012                         .nb_flags       = 0,
5013                         .mhomed         = True,
5014                         .num_ips        = ctx->addresses_1_num,
5015                         .ips            = ctx->addresses_1,
5016                         .apply_expected = True
5017                 },
5018                 .replica= {
5019                         .type           = WREPL_TYPE_UNIQUE,
5020                         .state          = WREPL_STATE_ACTIVE,
5021                         .node           = WREPL_NODE_B,
5022                         .is_static      = False,
5023                         .num_ips        = ctx->addresses_1_num,
5024                         .ips            = ctx->addresses_1,
5025                         .apply_expected = True
5026                 },
5027         },
5028         /*
5029          * mhomed,released vs. unique,active with different ip(s)
5030          */
5031         {
5032                 .line   = __location__,
5033                 .name   = _NBT_NAME("_MR_UA_DI", 0x00, NULL),
5034                 .wins   = {
5035                         .nb_flags       = 0,
5036                         .mhomed         = True,
5037                         .num_ips        = ctx->addresses_1_num,
5038                         .ips            = ctx->addresses_1,
5039                         .apply_expected = True
5040                 },
5041                 .replica= {
5042                         .type           = WREPL_TYPE_UNIQUE,
5043                         .state          = WREPL_STATE_ACTIVE,
5044                         .node           = WREPL_NODE_B,
5045                         .is_static      = False,
5046                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5047                         .ips            = addresses_B_1,
5048                         .apply_expected = True
5049                 },
5050         },
5051         /*
5052          * mhomed,released vs. unique,tombstone with same ip(s)
5053          */
5054         {
5055                 .line   = __location__,
5056                 .name   = _NBT_NAME("_MR_UT_SI", 0x00, NULL),
5057                 .wins   = {
5058                         .nb_flags       = 0,
5059                         .mhomed         = True,
5060                         .num_ips        = ctx->addresses_1_num,
5061                         .ips            = ctx->addresses_1,
5062                         .apply_expected = True
5063                 },
5064                 .replica= {
5065                         .type           = WREPL_TYPE_UNIQUE,
5066                         .state          = WREPL_STATE_TOMBSTONE,
5067                         .node           = WREPL_NODE_B,
5068                         .is_static      = False,
5069                         .num_ips        = ctx->addresses_1_num,
5070                         .ips            = ctx->addresses_1,
5071                         .apply_expected = True
5072                 },
5073         },
5074         /*
5075          * mhomed,released vs. unique,tombstone with different ip(s)
5076          */
5077         {
5078                 .line   = __location__,
5079                 .name   = _NBT_NAME("_MR_UT_DI", 0x00, NULL),
5080                 .wins   = {
5081                         .nb_flags       = 0,
5082                         .mhomed         = True,
5083                         .num_ips        = ctx->addresses_1_num,
5084                         .ips            = ctx->addresses_1,
5085                         .apply_expected = True
5086                 },
5087                 .replica= {
5088                         .type           = WREPL_TYPE_UNIQUE,
5089                         .state          = WREPL_STATE_TOMBSTONE,
5090                         .node           = WREPL_NODE_B,
5091                         .is_static      = False,
5092                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5093                         .ips            = addresses_B_1,
5094                         .apply_expected = True
5095                 },
5096         },
5097 /*
5098  * multi homed vs. group section
5099  */
5100         /*
5101          * mhomed,released vs. group,active with same ip(s)
5102          */
5103         {
5104                 .line   = __location__,
5105                 .name   = _NBT_NAME("_MR_GA_SI", 0x00, NULL),
5106                 .wins   = {
5107                         .nb_flags       = 0,
5108                         .mhomed         = True,
5109                         .num_ips        = ctx->addresses_1_num,
5110                         .ips            = ctx->addresses_1,
5111                         .apply_expected = True
5112                 },
5113                 .replica= {
5114                         .type           = WREPL_TYPE_GROUP,
5115                         .state          = WREPL_STATE_ACTIVE,
5116                         .node           = WREPL_NODE_B,
5117                         .is_static      = False,
5118                         .num_ips        = ctx->addresses_1_num,
5119                         .ips            = ctx->addresses_1,
5120                         .apply_expected = True
5121                 },
5122         },
5123         /*
5124          * mhomed,released vs. group,active with different ip(s)
5125          */
5126         {
5127                 .line   = __location__,
5128                 .name   = _NBT_NAME("_MR_GA_DI", 0x00, NULL),
5129                 .wins   = {
5130                         .nb_flags       = 0,
5131                         .mhomed         = True,
5132                         .num_ips        = ctx->addresses_1_num,
5133                         .ips            = ctx->addresses_1,
5134                         .apply_expected = True
5135                 },
5136                 .replica= {
5137                         .type           = WREPL_TYPE_GROUP,
5138                         .state          = WREPL_STATE_ACTIVE,
5139                         .node           = WREPL_NODE_B,
5140                         .is_static      = False,
5141                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5142                         .ips            = addresses_B_1,
5143                         .apply_expected = True
5144                 },
5145         },
5146         /*
5147          * mhomed,released vs. group,tombstone with same ip(s)
5148          */
5149         {
5150                 .line   = __location__,
5151                 .name   = _NBT_NAME("_MR_GT_SI", 0x00, NULL),
5152                 .wins   = {
5153                         .nb_flags       = 0,
5154                         .mhomed         = True,
5155                         .num_ips        = ctx->addresses_1_num,
5156                         .ips            = ctx->addresses_1,
5157                         .apply_expected = True
5158                 },
5159                 .replica= {
5160                         .type           = WREPL_TYPE_GROUP,
5161                         .state          = WREPL_STATE_TOMBSTONE,
5162                         .node           = WREPL_NODE_B,
5163                         .is_static      = False,
5164                         .num_ips        = ctx->addresses_1_num,
5165                         .ips            = ctx->addresses_1,
5166                         .apply_expected = True
5167                 },
5168         },
5169         /*
5170          * mhomed,released vs. group,tombstone with different ip(s)
5171          */
5172         {
5173                 .line   = __location__,
5174                 .name   = _NBT_NAME("_MR_GT_DI", 0x00, NULL),
5175                 .wins   = {
5176                         .nb_flags       = 0,
5177                         .mhomed         = True,
5178                         .num_ips        = ctx->addresses_1_num,
5179                         .ips            = ctx->addresses_1,
5180                         .apply_expected = True
5181                 },
5182                 .replica= {
5183                         .type           = WREPL_TYPE_GROUP,
5184                         .state          = WREPL_STATE_TOMBSTONE,
5185                         .node           = WREPL_NODE_B,
5186                         .is_static      = False,
5187                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5188                         .ips            = addresses_B_1,
5189                         .apply_expected = True
5190                 },
5191         },
5192 /*
5193  * multi homed vs. special group section
5194  */
5195         /*
5196          * mhomed,released vs. sgroup,active with same ip(s)
5197          */
5198         {
5199                 .line   = __location__,
5200                 .name   = _NBT_NAME("_MR_SA_SI", 0x00, NULL),
5201                 .wins   = {
5202                         .nb_flags       = 0,
5203                         .mhomed         = True,
5204                         .num_ips        = ctx->addresses_1_num,
5205                         .ips            = ctx->addresses_1,
5206                         .apply_expected = True
5207                 },
5208                 .replica= {
5209                         .type           = WREPL_TYPE_SGROUP,
5210                         .state          = WREPL_STATE_ACTIVE,
5211                         .node           = WREPL_NODE_B,
5212                         .is_static      = False,
5213                         .num_ips        = ctx->addresses_1_num,
5214                         .ips            = ctx->addresses_1,
5215                         .apply_expected = True
5216                 },
5217         },
5218         /*
5219          * mhomed,released vs. sgroup,active with different ip(s)
5220          */
5221         {
5222                 .line   = __location__,
5223                 .name   = _NBT_NAME("_MR_SA_DI", 0x00, NULL),
5224                 .wins   = {
5225                         .nb_flags       = 0,
5226                         .mhomed         = True,
5227                         .num_ips        = ctx->addresses_1_num,
5228                         .ips            = ctx->addresses_1,
5229                         .apply_expected = True
5230                 },
5231                 .replica= {
5232                         .type           = WREPL_TYPE_SGROUP,
5233                         .state          = WREPL_STATE_ACTIVE,
5234                         .node           = WREPL_NODE_B,
5235                         .is_static      = False,
5236                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5237                         .ips            = addresses_B_1,
5238                         .apply_expected = True
5239                 },
5240         },
5241         /*
5242          * mhomed,released vs. sgroup,tombstone with same ip(s)
5243          */
5244         {
5245                 .line   = __location__,
5246                 .name   = _NBT_NAME("_MR_ST_SI", 0x00, NULL),
5247                 .wins   = {
5248                         .nb_flags       = 0,
5249                         .mhomed         = True,
5250                         .num_ips        = ctx->addresses_1_num,
5251                         .ips            = ctx->addresses_1,
5252                         .apply_expected = True
5253                 },
5254                 .replica= {
5255                         .type           = WREPL_TYPE_SGROUP,
5256                         .state          = WREPL_STATE_TOMBSTONE,
5257                         .node           = WREPL_NODE_B,
5258                         .is_static      = False,
5259                         .num_ips        = ctx->addresses_1_num,
5260                         .ips            = ctx->addresses_1,
5261                         .apply_expected = True
5262                 },
5263         },
5264         /*
5265          * mhomed,released vs. sgroup,tombstone with different ip(s)
5266          */
5267         {
5268                 .line   = __location__,
5269                 .name   = _NBT_NAME("_MR_ST_DI", 0x00, NULL),
5270                 .wins   = {
5271                         .nb_flags       = 0,
5272                         .mhomed         = True,
5273                         .num_ips        = ctx->addresses_1_num,
5274                         .ips            = ctx->addresses_1,
5275                         .apply_expected = True
5276                 },
5277                 .replica= {
5278                         .type           = WREPL_TYPE_SGROUP,
5279                         .state          = WREPL_STATE_TOMBSTONE,
5280                         .node           = WREPL_NODE_B,
5281                         .is_static      = False,
5282                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5283                         .ips            = addresses_B_1,
5284                         .apply_expected = True
5285                 },
5286         },
5287 /*
5288  * multi homed vs. multi homed section
5289  */
5290         /*
5291          * mhomed,released vs. mhomed,active with same ip(s)
5292          */
5293         {
5294                 .line   = __location__,
5295                 .name   = _NBT_NAME("_MR_MA_SI", 0x00, NULL),
5296                 .wins   = {
5297                         .nb_flags       = 0,
5298                         .mhomed         = True,
5299                         .num_ips        = ctx->addresses_1_num,
5300                         .ips            = ctx->addresses_1,
5301                         .apply_expected = True
5302                 },
5303                 .replica= {
5304                         .type           = WREPL_TYPE_MHOMED,
5305                         .state          = WREPL_STATE_ACTIVE,
5306                         .node           = WREPL_NODE_B,
5307                         .is_static      = False,
5308                         .num_ips        = ctx->addresses_1_num,
5309                         .ips            = ctx->addresses_1,
5310                         .apply_expected = True
5311                 },
5312         },
5313         /*
5314          * mhomed,released vs. mhomed,active with different ip(s)
5315          */
5316         {
5317                 .line   = __location__,
5318                 .name   = _NBT_NAME("_MR_MA_DI", 0x00, NULL),
5319                 .wins   = {
5320                         .nb_flags       = 0,
5321                         .mhomed         = True,
5322                         .num_ips        = ctx->addresses_1_num,
5323                         .ips            = ctx->addresses_1,
5324                         .apply_expected = True
5325                 },
5326                 .replica= {
5327                         .type           = WREPL_TYPE_MHOMED,
5328                         .state          = WREPL_STATE_ACTIVE,
5329                         .node           = WREPL_NODE_B,
5330                         .is_static      = False,
5331                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5332                         .ips            = addresses_B_1,
5333                         .apply_expected = True
5334                 },
5335         },
5336         /*
5337          * mhomed,released vs. mhomed,tombstone with same ip(s)
5338          */
5339         {
5340                 .line   = __location__,
5341                 .name   = _NBT_NAME("_MR_MT_SI", 0x00, NULL),
5342                 .wins   = {
5343                         .nb_flags       = 0,
5344                         .mhomed         = True,
5345                         .num_ips        = ctx->addresses_1_num,
5346                         .ips            = ctx->addresses_1,
5347                         .apply_expected = True
5348                 },
5349                 .replica= {
5350                         .type           = WREPL_TYPE_MHOMED,
5351                         .state          = WREPL_STATE_TOMBSTONE,
5352                         .node           = WREPL_NODE_B,
5353                         .is_static      = False,
5354                         .num_ips        = ctx->addresses_1_num,
5355                         .ips            = ctx->addresses_1,
5356                         .apply_expected = True
5357                 },
5358         },
5359         /*
5360          * mhomed,released vs. mhomed,tombstone with different ip(s)
5361          */
5362         {
5363                 .line   = __location__,
5364                 .name   = _NBT_NAME("_MR_MT_DI", 0x00, NULL),
5365                 .wins   = {
5366                         .nb_flags       = 0,
5367                         .mhomed         = True,
5368                         .num_ips        = ctx->addresses_1_num,
5369                         .ips            = ctx->addresses_1,
5370                         .apply_expected = True
5371                 },
5372                 .replica= {
5373                         .type           = WREPL_TYPE_MHOMED,
5374                         .state          = WREPL_STATE_TOMBSTONE,
5375                         .node           = WREPL_NODE_B,
5376                         .is_static      = False,
5377                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5378                         .ips            = addresses_B_1,
5379                         .apply_expected = True
5380                 },
5381         },
5382         };
5383
5384         if (!ctx) return False;
5385
5386         printf("Test Replica records vs. owned released records\n");
5387
5388         for(i=0; ret && i < ARRAY_SIZE(records); i++) {
5389                 printf("%s => %s\n", nbt_name_string(ctx, &records[i].name),
5390                         (records[i].replica.apply_expected?"REPLACE":"NOT REPLACE"));
5391
5392                 /*
5393                  * Setup Register
5394                  */
5395                 name_register->in.name          = records[i].name;
5396                 name_register->in.dest_addr     = ctx->address;
5397                 name_register->in.address       = records[i].wins.ips[0].ip;
5398                 name_register->in.nb_flags      = records[i].wins.nb_flags;
5399                 name_register->in.register_demand= False;
5400                 name_register->in.broadcast     = False;
5401                 name_register->in.multi_homed   = records[i].wins.mhomed;
5402                 name_register->in.ttl           = 300000;
5403                 name_register->in.timeout       = 70;
5404                 name_register->in.retries       = 0;
5405
5406                 status = nbt_name_register(ctx->nbtsock, ctx, name_register);
5407                 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
5408                         printf("No response from %s for name register\n", ctx->address);
5409                         ret = False;
5410                 }
5411                 if (!NT_STATUS_IS_OK(status)) {
5412                         printf("Bad response from %s for name register - %s\n",
5413                                ctx->address, nt_errstr(status));
5414                         ret = False;
5415                 }
5416                 CHECK_VALUE(name_register->out.rcode, 0);
5417                 CHECK_VALUE_STRING(name_register->out.reply_from, ctx->address);
5418                 CHECK_VALUE(name_register->out.name.type, records[i].name.type);
5419                 CHECK_VALUE_STRING(name_register->out.name.name, records[i].name.name);
5420                 CHECK_VALUE_STRING(name_register->out.name.scope, records[i].name.scope);
5421                 CHECK_VALUE_STRING(name_register->out.reply_addr, records[i].wins.ips[0].ip);
5422
5423                 /* release the record */
5424                 release->in.name        = records[i].name;
5425                 release->in.dest_addr   = ctx->address;
5426                 release->in.address     = records[i].wins.ips[0].ip;
5427                 release->in.nb_flags    = records[i].wins.nb_flags;
5428                 release->in.broadcast   = False;
5429                 release->in.timeout     = 30;
5430                 release->in.retries     = 0;
5431
5432                 status = nbt_name_release(ctx->nbtsock, ctx, release);
5433                 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
5434                         printf("No response from %s for name release\n", ctx->address);
5435                         return False;
5436                 }
5437                 if (!NT_STATUS_IS_OK(status)) {
5438                         printf("Bad response from %s for name query - %s\n",
5439                                ctx->address, nt_errstr(status));
5440                         return False;
5441                 }
5442                 CHECK_VALUE(release->out.rcode, 0);
5443
5444                 /*
5445                  * Setup Replica
5446                  */
5447                 wins_name->name         = &records[i].name;
5448                 wins_name->flags        = WREPL_NAME_FLAGS(records[i].replica.type,
5449                                                            records[i].replica.state,
5450                                                            records[i].replica.node,
5451                                                            records[i].replica.is_static);
5452                 wins_name->id           = ++ctx->b.max_version;
5453                 if (wins_name->flags & 2) {
5454                         wins_name->addresses.addresses.num_ips = records[i].replica.num_ips;
5455                         wins_name->addresses.addresses.ips     = discard_const(records[i].replica.ips);
5456                 } else {
5457                         wins_name->addresses.ip = records[i].replica.ips[0].ip;
5458                 }
5459                 wins_name->unknown      = "255.255.255.255";
5460
5461                 ret &= test_wrepl_update_one(ctx, &ctx->b, wins_name);
5462                 ret &= test_wrepl_is_applied(ctx, &ctx->b, wins_name,
5463                                              records[i].replica.apply_expected);
5464
5465                 if (records[i].replica.apply_expected) {
5466                         wins_name->name         = &records[i].name;
5467                         wins_name->flags        = WREPL_NAME_FLAGS(WREPL_TYPE_UNIQUE,
5468                                                                    WREPL_STATE_TOMBSTONE,
5469                                                                    WREPL_NODE_B, False);
5470                         wins_name->id           = ++ctx->b.max_version;
5471                         wins_name->addresses.ip = addresses_B_1[0].ip;
5472                         wins_name->unknown      = "255.255.255.255";
5473
5474                         ret &= test_wrepl_update_one(ctx, &ctx->b, wins_name);
5475                         ret &= test_wrepl_is_applied(ctx, &ctx->b, wins_name, True);
5476                 } else {
5477                         release->in.name        = records[i].name;
5478                         release->in.dest_addr   = ctx->address;
5479                         release->in.address     = records[i].wins.ips[0].ip;
5480                         release->in.nb_flags    = records[i].wins.nb_flags;
5481                         release->in.broadcast   = False;
5482                         release->in.timeout     = 30;
5483                         release->in.retries     = 0;
5484
5485                         status = nbt_name_release(ctx->nbtsock, ctx, release);
5486                         if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
5487                                 printf("No response from %s for name release\n", ctx->address);
5488                                 return False;
5489                         }
5490                         if (!NT_STATUS_IS_OK(status)) {
5491                                 printf("Bad response from %s for name query - %s\n",
5492                                        ctx->address, nt_errstr(status));
5493                                 return False;
5494                         }
5495                         CHECK_VALUE(release->out.rcode, 0);
5496                 }
5497 done:
5498                 if (!ret) {
5499                         printf("conflict handled wrong or record[%u]: %s\n", i, records[i].line);
5500                         return ret;
5501                 }
5502         }
5503
5504         return ret;
5505 }
5506
5507 struct test_conflict_owned_active_vs_replica_struct {
5508         const char *line; /* just better debugging */
5509         struct nbt_name name;
5510         struct {
5511                 uint32_t nb_flags;
5512                 BOOL mhomed;
5513                 uint32_t num_ips;
5514                 const struct wrepl_ip *ips;
5515                 BOOL apply_expected;
5516         } wins;
5517         struct {
5518                 uint32_t timeout;
5519                 BOOL positive;
5520                 BOOL expect_release;
5521                 BOOL ret;
5522         } defend;
5523         struct {
5524                 enum wrepl_name_type type;
5525                 enum wrepl_name_state state;
5526                 enum wrepl_name_node node;
5527                 BOOL is_static;
5528                 uint32_t num_ips;
5529                 const struct wrepl_ip *ips;
5530                 BOOL apply_expected;
5531         } replica;
5532 };
5533
5534 static void test_conflict_owned_active_vs_replica_handler(struct nbt_name_socket *nbtsock,
5535                                                           struct nbt_name_packet *req_packet,
5536                                                           const struct nbt_peer_socket *src);
5537
5538 static BOOL test_conflict_owned_active_vs_replica(struct test_wrepl_conflict_conn *ctx)
5539 {
5540         BOOL ret = True;
5541         NTSTATUS status;
5542         struct wrepl_wins_name wins_name_;
5543         struct wrepl_wins_name *wins_name = &wins_name_;
5544         struct nbt_name_register name_register_;
5545         struct nbt_name_register *name_register = &name_register_;
5546         struct nbt_name_release release_;
5547         struct nbt_name_release *release = &release_;
5548         uint32_t i;
5549         struct test_conflict_owned_active_vs_replica_struct records[] = {
5550 /*
5551  * unique vs. unique section
5552  */
5553         /*
5554          * unique,active vs. unique,active with same ip(s), unchecked
5555          */
5556         {
5557                 .line   = __location__,
5558                 .name   = _NBT_NAME("_UA_UA_SI_U", 0x00, NULL),
5559                 .wins   = {
5560                         .nb_flags       = 0,
5561                         .mhomed         = False,
5562                         .num_ips        = ctx->addresses_1_num,
5563                         .ips            = ctx->addresses_1,
5564                         .apply_expected = True
5565                 },
5566                 .defend = {
5567                         .timeout        = 0,
5568                 },
5569                 .replica= {
5570                         .type           = WREPL_TYPE_UNIQUE,
5571                         .state          = WREPL_STATE_ACTIVE,
5572                         .node           = WREPL_NODE_B,
5573                         .is_static      = False,
5574                         .num_ips        = ctx->addresses_1_num,
5575                         .ips            = ctx->addresses_1,
5576                         .apply_expected = True
5577                 },
5578         },
5579         /*
5580          * unique,active vs. unique,active with different ip(s), positive response
5581          */
5582         {
5583                 .line   = __location__,
5584                 .name   = _NBT_NAME("_UA_UA_DI_P", 0x00, NULL),
5585                 .wins   = {
5586                         .nb_flags       = 0,
5587                         .mhomed         = False,
5588                         .num_ips        = ctx->addresses_1_num,
5589                         .ips            = ctx->addresses_1,
5590                         .apply_expected = True
5591                 },
5592                 .defend = {
5593                         .timeout        = 10,
5594                         .positive       = True,
5595                 },
5596                 .replica= {
5597                         .type           = WREPL_TYPE_UNIQUE,
5598                         .state          = WREPL_STATE_ACTIVE,
5599                         .node           = WREPL_NODE_B,
5600                         .is_static      = False,
5601                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5602                         .ips            = addresses_B_1,
5603                         .apply_expected = False
5604                 },
5605         },
5606         /*
5607          * unique,active vs. unique,active with different ip(s), negative response
5608          */
5609         {
5610                 .line   = __location__,
5611                 .name   = _NBT_NAME("_UA_UA_DI_N", 0x00, NULL),
5612                 .wins   = {
5613                         .nb_flags       = 0,
5614                         .mhomed         = False,
5615                         .num_ips        = ctx->addresses_1_num,
5616                         .ips            = ctx->addresses_1,
5617                         .apply_expected = True
5618                 },
5619                 .defend = {
5620                         .timeout        = 10,
5621                         .positive       = False,
5622                 },
5623                 .replica= {
5624                         .type           = WREPL_TYPE_UNIQUE,
5625                         .state          = WREPL_STATE_ACTIVE,
5626                         .node           = WREPL_NODE_B,
5627                         .is_static      = False,
5628                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5629                         .ips            = addresses_B_1,
5630                         .apply_expected = True
5631                 },
5632         },
5633         /*
5634          * unique,active vs. unique,tombstone with same ip(s), unchecked
5635          */
5636         {
5637                 .line   = __location__,
5638                 .name   = _NBT_NAME("_UA_UT_SI_U", 0x00, NULL),
5639                 .wins   = {
5640                         .nb_flags       = 0,
5641                         .mhomed         = False,
5642                         .num_ips        = ctx->addresses_1_num,
5643                         .ips            = ctx->addresses_1,
5644                         .apply_expected = True
5645                 },
5646                 .defend = {
5647                         .timeout        = 0,
5648                 },
5649                 .replica= {
5650                         .type           = WREPL_TYPE_UNIQUE,
5651                         .state          = WREPL_STATE_TOMBSTONE,
5652                         .node           = WREPL_NODE_B,
5653                         .is_static      = False,
5654                         .num_ips        = ctx->addresses_1_num,
5655                         .ips            = ctx->addresses_1,
5656                         .apply_expected = False
5657                 },
5658         },
5659         /*
5660          * unique,active vs. unique,tombstone with different ip(s), unchecked
5661          */
5662         {
5663                 .line   = __location__,
5664                 .name   = _NBT_NAME("_UA_UT_DI_U", 0x00, NULL),
5665                 .wins   = {
5666                         .nb_flags       = 0,
5667                         .mhomed         = False,
5668                         .num_ips        = ctx->addresses_1_num,
5669                         .ips            = ctx->addresses_1,
5670                         .apply_expected = True
5671                 },
5672                 .defend = {
5673                         .timeout        = 0,
5674                 },
5675                 .replica= {
5676                         .type           = WREPL_TYPE_UNIQUE,
5677                         .state          = WREPL_STATE_TOMBSTONE,
5678                         .node           = WREPL_NODE_B,
5679                         .is_static      = False,
5680                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5681                         .ips            = addresses_B_1,
5682                         .apply_expected = False
5683                 },
5684         },
5685 /*
5686  * unique vs. group section
5687  */
5688         /*
5689          * unique,active vs. group,active with same ip(s), release expected
5690          */
5691         {
5692                 .line   = __location__,
5693                 .name   = _NBT_NAME("_UA_GA_SI_R", 0x00, NULL),
5694                 .wins   = {
5695                         .nb_flags       = 0,
5696                         .mhomed         = False,
5697                         .num_ips        = ctx->addresses_1_num,
5698                         .ips            = ctx->addresses_1,
5699                         .apply_expected = True
5700                 },
5701                 .defend = {
5702                         .timeout        = 10,
5703                         .expect_release = True,
5704                 },
5705                 .replica= {
5706                         .type           = WREPL_TYPE_GROUP,
5707                         .state          = WREPL_STATE_ACTIVE,
5708                         .node           = WREPL_NODE_B,
5709                         .is_static      = False,
5710                         .num_ips        = ctx->addresses_1_num,
5711                         .ips            = ctx->addresses_1,
5712                         .apply_expected = True
5713                 },
5714         },
5715         /*
5716          * unique,active vs. group,active with different ip(s), release expected
5717          */
5718         {
5719                 .line   = __location__,
5720                 .name   = _NBT_NAME("_UA_GA_DI_R", 0x00, NULL),
5721                 .wins   = {
5722                         .nb_flags       = 0,
5723                         .mhomed         = False,
5724                         .num_ips        = ctx->addresses_1_num,
5725                         .ips            = ctx->addresses_1,
5726                         .apply_expected = True
5727                 },
5728                 .defend = {
5729                         .timeout        = 10,
5730                         .expect_release = True,
5731                 },
5732                 .replica= {
5733                         .type           = WREPL_TYPE_GROUP,
5734                         .state          = WREPL_STATE_ACTIVE,
5735                         .node           = WREPL_NODE_B,
5736                         .is_static      = False,
5737                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5738                         .ips            = addresses_B_1,
5739                         .apply_expected = True
5740                 },
5741         },
5742         /*
5743          * unique,active vs. group,tombstone with same ip(s), unchecked
5744          */
5745         {
5746                 .line   = __location__,
5747                 .name   = _NBT_NAME("_UA_GT_SI_U", 0x00, NULL),
5748                 .wins   = {
5749                         .nb_flags       = 0,
5750                         .mhomed         = False,
5751                         .num_ips        = ctx->addresses_1_num,
5752                         .ips            = ctx->addresses_1,
5753                         .apply_expected = True
5754                 },
5755                 .defend = {
5756                         .timeout        = 0,
5757                 },
5758                 .replica= {
5759                         .type           = WREPL_TYPE_GROUP,
5760                         .state          = WREPL_STATE_TOMBSTONE,
5761                         .node           = WREPL_NODE_B,
5762                         .is_static      = False,
5763                         .num_ips        = ctx->addresses_1_num,
5764                         .ips            = ctx->addresses_1,
5765                         .apply_expected = False
5766                 },
5767         },
5768         /*
5769          * unique,active vs. group,tombstone with different ip(s), unchecked
5770          */
5771         {
5772                 .line   = __location__,
5773                 .name   = _NBT_NAME("_UA_GT_DI_U", 0x00, NULL),
5774                 .wins   = {
5775                         .nb_flags       = 0,
5776                         .mhomed         = False,
5777                         .num_ips        = ctx->addresses_1_num,
5778                         .ips            = ctx->addresses_1,
5779                         .apply_expected = True
5780                 },
5781                 .defend = {
5782                         .timeout        = 0,
5783                 },
5784                 .replica= {
5785                         .type           = WREPL_TYPE_GROUP,
5786                         .state          = WREPL_STATE_TOMBSTONE,
5787                         .node           = WREPL_NODE_B,
5788                         .is_static      = False,
5789                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5790                         .ips            = addresses_B_1,
5791                         .apply_expected = False
5792                 },
5793         },
5794 /*
5795  * unique vs. special group section
5796  */
5797         /*
5798          * unique,active vs. sgroup,active with same ip(s), release expected
5799          */
5800         {
5801                 .line   = __location__,
5802                 .name   = _NBT_NAME("_UA_SA_SI_R", 0x00, NULL),
5803                 .wins   = {
5804                         .nb_flags       = 0,
5805                         .mhomed         = False,
5806                         .num_ips        = ctx->addresses_1_num,
5807                         .ips            = ctx->addresses_1,
5808                         .apply_expected = True
5809                 },
5810                 .defend = {
5811                         .timeout        = 10,
5812                         .expect_release = True,
5813                 },
5814                 .replica= {
5815                         .type           = WREPL_TYPE_SGROUP,
5816                         .state          = WREPL_STATE_ACTIVE,
5817                         .node           = WREPL_NODE_B,
5818                         .is_static      = False,
5819                         .num_ips        = ctx->addresses_1_num,
5820                         .ips            = ctx->addresses_1,
5821                         .apply_expected = True
5822                 },
5823         },
5824         /*
5825          * unique,active vs. group,active with different ip(s), release expected
5826          */
5827         {
5828                 .line   = __location__,
5829                 .name   = _NBT_NAME("_UA_SA_DI_R", 0x00, NULL),
5830                 .wins   = {
5831                         .nb_flags       = 0,
5832                         .mhomed         = False,
5833                         .num_ips        = ctx->addresses_1_num,
5834                         .ips            = ctx->addresses_1,
5835                         .apply_expected = True
5836                 },
5837                 .defend = {
5838                         .timeout        = 10,
5839                         .expect_release = True,
5840                 },
5841                 .replica= {
5842                         .type           = WREPL_TYPE_SGROUP,
5843                         .state          = WREPL_STATE_ACTIVE,
5844                         .node           = WREPL_NODE_B,
5845                         .is_static      = False,
5846                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5847                         .ips            = addresses_B_1,
5848                         .apply_expected = True
5849                 },
5850         },
5851         /*
5852          * unique,active vs. sgroup,tombstone with same ip(s), unchecked
5853          */
5854         {
5855                 .line   = __location__,
5856                 .name   = _NBT_NAME("_UA_ST_SI_U", 0x00, NULL),
5857                 .wins   = {
5858                         .nb_flags       = 0,
5859                         .mhomed         = False,
5860                         .num_ips        = ctx->addresses_1_num,
5861                         .ips            = ctx->addresses_1,
5862                         .apply_expected = True
5863                 },
5864                 .defend = {
5865                         .timeout        = 0,
5866                 },
5867                 .replica= {
5868                         .type           = WREPL_TYPE_SGROUP,
5869                         .state          = WREPL_STATE_TOMBSTONE,
5870                         .node           = WREPL_NODE_B,
5871                         .is_static      = False,
5872                         .num_ips        = ctx->addresses_1_num,
5873                         .ips            = ctx->addresses_1,
5874                         .apply_expected = False
5875                 },
5876         },
5877         /*
5878          * unique,active vs. sgroup,tombstone with different ip(s), unchecked
5879          */
5880         {
5881                 .line   = __location__,
5882                 .name   = _NBT_NAME("_UA_ST_DI_U", 0x00, NULL),
5883                 .wins   = {
5884                         .nb_flags       = 0,
5885                         .mhomed         = False,
5886                         .num_ips        = ctx->addresses_1_num,
5887                         .ips            = ctx->addresses_1,
5888                         .apply_expected = True
5889                 },
5890                 .defend = {
5891                         .timeout        = 0,
5892                 },
5893                 .replica= {
5894                         .type           = WREPL_TYPE_SGROUP,
5895                         .state          = WREPL_STATE_TOMBSTONE,
5896                         .node           = WREPL_NODE_B,
5897                         .is_static      = False,
5898                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5899                         .ips            = addresses_B_1,
5900                         .apply_expected = False
5901                 },
5902         },
5903 /*
5904  * unique vs. multi homed section
5905  */
5906         /*
5907          * unique,active vs. mhomed,active with same ip(s), unchecked
5908          */
5909         {
5910                 .line   = __location__,
5911                 .name   = _NBT_NAME("_UA_MA_SI_U", 0x00, NULL),
5912                 .wins   = {
5913                         .nb_flags       = 0,
5914                         .mhomed         = False,
5915                         .num_ips        = ctx->addresses_1_num,
5916                         .ips            = ctx->addresses_1,
5917                         .apply_expected = True
5918                 },
5919                 .defend = {
5920                         .timeout        = 0,
5921                 },
5922                 .replica= {
5923                         .type           = WREPL_TYPE_MHOMED,
5924                         .state          = WREPL_STATE_ACTIVE,
5925                         .node           = WREPL_NODE_B,
5926                         .is_static      = False,
5927                         .num_ips        = ctx->addresses_1_num,
5928                         .ips            = ctx->addresses_1,
5929                         .apply_expected = True
5930                 },
5931         },
5932         /*
5933          * unique,active vs. mhomed,active with different ip(s), positive response
5934          */
5935         {
5936                 .line   = __location__,
5937                 .name   = _NBT_NAME("_UA_MA_DI_P", 0x00, NULL),
5938                 .wins   = {
5939                         .nb_flags       = 0,
5940                         .mhomed         = False,
5941                         .num_ips        = ctx->addresses_1_num,
5942                         .ips            = ctx->addresses_1,
5943                         .apply_expected = True
5944                 },
5945                 .defend = {
5946                         .timeout        = 10,
5947                         .positive       = True,
5948                 },
5949                 .replica= {
5950                         .type           = WREPL_TYPE_MHOMED,
5951                         .state          = WREPL_STATE_ACTIVE,
5952                         .node           = WREPL_NODE_B,
5953                         .is_static      = False,
5954                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5955                         .ips            = addresses_B_1,
5956                         .apply_expected = False
5957                 },
5958         },
5959         /*
5960          * unique,active vs. mhomed,active with different ip(s), negative response
5961          */
5962         {
5963                 .line   = __location__,
5964                 .name   = _NBT_NAME("_UA_MA_DI_N", 0x00, NULL),
5965                 .wins   = {
5966                         .nb_flags       = 0,
5967                         .mhomed         = False,
5968                         .num_ips        = ctx->addresses_1_num,
5969                         .ips            = ctx->addresses_1,
5970                         .apply_expected = True
5971                 },
5972                 .defend = {
5973                         .timeout        = 10,
5974                         .positive       = False,
5975                 },
5976                 .replica= {
5977                         .type           = WREPL_TYPE_MHOMED,
5978                         .state          = WREPL_STATE_ACTIVE,
5979                         .node           = WREPL_NODE_B,
5980                         .is_static      = False,
5981                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5982                         .ips            = addresses_B_1,
5983                         .apply_expected = True
5984                 },
5985         },
5986         /*
5987          * unique,active vs. mhomed,tombstone with same ip(s), unchecked
5988          */
5989         {
5990                 .line   = __location__,
5991                 .name   = _NBT_NAME("_UA_MT_SI_U", 0x00, NULL),
5992                 .wins   = {
5993                         .nb_flags       = 0,
5994                         .mhomed         = False,
5995                         .num_ips        = ctx->addresses_1_num,
5996                         .ips            = ctx->addresses_1,
5997                         .apply_expected = True
5998                 },
5999                 .defend = {
6000                         .timeout        = 0,
6001                 },
6002                 .replica= {
6003                         .type           = WREPL_TYPE_MHOMED,
6004                         .state          = WREPL_STATE_TOMBSTONE,
6005                         .node           = WREPL_NODE_B,
6006                         .is_static      = False,
6007                         .num_ips        = ctx->addresses_1_num,
6008                         .ips            = ctx->addresses_1,
6009                         .apply_expected = False
6010                 },
6011         },
6012         /*
6013          * unique,active vs. mhomed,tombstone with different ip(s), unchecked
6014          */
6015         {
6016                 .line   = __location__,
6017                 .name   = _NBT_NAME("_UA_MT_DI_U", 0x00, NULL),
6018                 .wins   = {
6019                         .nb_flags       = 0,
6020                         .mhomed         = False,
6021                         .num_ips        = ctx->addresses_1_num,
6022                         .ips            = ctx->addresses_1,
6023                         .apply_expected = True
6024                 },
6025                 .defend = {
6026                         .timeout        = 0,
6027                 },
6028                 .replica= {
6029                         .type           = WREPL_TYPE_MHOMED,
6030                         .state          = WREPL_STATE_TOMBSTONE,
6031                         .node           = WREPL_NODE_B,
6032                         .is_static      = False,
6033                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6034                         .ips            = addresses_B_1,
6035                         .apply_expected = False
6036                 },
6037         },
6038 /*
6039  * normal group vs. unique section
6040  */
6041         /*
6042          * group,active vs. unique,active with same ip(s), unchecked
6043          */
6044         {
6045                 .line   = __location__,
6046                 .name   = _NBT_NAME("_GA_UA_SI_U", 0x00, NULL),
6047                 .wins   = {
6048                         .nb_flags       = NBT_NM_GROUP,
6049                         .mhomed         = False,
6050                         .num_ips        = ctx->addresses_1_num,
6051                         .ips            = ctx->addresses_1,
6052                         .apply_expected = True
6053                 },
6054                 .defend = {
6055                         .timeout        = 0,
6056                 },
6057                 .replica= {
6058                         .type           = WREPL_TYPE_UNIQUE,
6059                         .state          = WREPL_STATE_ACTIVE,
6060                         .node           = WREPL_NODE_B,
6061                         .is_static      = False,
6062                         .num_ips        = ctx->addresses_1_num,
6063                         .ips            = ctx->addresses_1,
6064                         .apply_expected = False
6065                 },
6066         },
6067         /*
6068          * group,active vs. unique,active with different ip(s), unchecked
6069          */
6070         {
6071                 .line   = __location__,
6072                 .name   = _NBT_NAME("_GA_UA_DI_U", 0x00, NULL),
6073                 .wins   = {
6074                         .nb_flags       = NBT_NM_GROUP,
6075                         .mhomed         = False,
6076                         .num_ips        = ctx->addresses_1_num,
6077                         .ips            = ctx->addresses_1,
6078                         .apply_expected = True
6079                 },
6080                 .defend = {
6081                         .timeout        = 0,
6082                 },
6083                 .replica= {
6084                         .type           = WREPL_TYPE_UNIQUE,
6085                         .state          = WREPL_STATE_ACTIVE,
6086                         .node           = WREPL_NODE_B,
6087                         .is_static      = False,
6088                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6089                         .ips            = addresses_B_1,
6090                         .apply_expected = False
6091                 },
6092         },
6093         /*
6094          * group,active vs. unique,tombstone with same ip(s), unchecked
6095          */
6096         {
6097                 .line   = __location__,
6098                 .name   = _NBT_NAME("_GA_UT_SI_U", 0x00, NULL),
6099                 .wins   = {
6100                         .nb_flags       = NBT_NM_GROUP,
6101                         .mhomed         = False,
6102                         .num_ips        = ctx->addresses_1_num,
6103                         .ips            = ctx->addresses_1,
6104                         .apply_expected = True
6105                 },
6106                 .defend = {
6107                         .timeout        = 0,
6108                 },
6109                 .replica= {
6110                         .type           = WREPL_TYPE_UNIQUE,
6111                         .state          = WREPL_STATE_TOMBSTONE,
6112                         .node           = WREPL_NODE_B,
6113                         .is_static      = False,
6114                         .num_ips        = ctx->addresses_1_num,
6115                         .ips            = ctx->addresses_1,
6116                         .apply_expected = False
6117                 },
6118         },
6119         /*
6120          * group,active vs. unique,tombstone with different ip(s), unchecked
6121          */
6122         {
6123                 .line   = __location__,
6124                 .name   = _NBT_NAME("_GA_UT_DI_U", 0x00, NULL),
6125                 .wins   = {
6126                         .nb_flags       = NBT_NM_GROUP,
6127                         .mhomed         = False,
6128                         .num_ips        = ctx->addresses_1_num,
6129                         .ips            = ctx->addresses_1,
6130                         .apply_expected = True
6131                 },
6132                 .defend = {
6133                         .timeout        = 0,
6134                 },
6135                 .replica= {
6136                         .type           = WREPL_TYPE_UNIQUE,
6137                         .state          = WREPL_STATE_TOMBSTONE,
6138                         .node           = WREPL_NODE_B,
6139                         .is_static      = False,
6140                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6141                         .ips            = addresses_B_1,
6142                         .apply_expected = False
6143                 },
6144         },
6145 /*
6146  * normal group vs. normal group section
6147  */
6148         /*
6149          * group,active vs. group,active with same ip(s), unchecked
6150          */
6151         {
6152                 .line   = __location__,
6153                 .name   = _NBT_NAME("_GA_GA_SI_U", 0x00, NULL),
6154                 .wins   = {
6155                         .nb_flags       = NBT_NM_GROUP,
6156                         .mhomed         = False,
6157                         .num_ips        = ctx->addresses_1_num,
6158                         .ips            = ctx->addresses_1,
6159                         .apply_expected = True
6160                 },
6161                 .defend = {
6162                         .timeout        = 0,
6163                 },
6164                 .replica= {
6165                         .type           = WREPL_TYPE_GROUP,
6166                         .state          = WREPL_STATE_ACTIVE,
6167                         .node           = WREPL_NODE_B,
6168                         .is_static      = False,
6169                         .num_ips        = ctx->addresses_1_num,
6170                         .ips            = ctx->addresses_1,
6171                         .apply_expected = True
6172                 },
6173         },
6174         /*
6175          * group,active vs. group,active with different ip(s), unchecked
6176          */
6177         {
6178                 .line   = __location__,
6179                 .name   = _NBT_NAME("_GA_GA_DI_U", 0x00, NULL),
6180                 .wins   = {
6181                         .nb_flags       = NBT_NM_GROUP,
6182                         .mhomed         = False,
6183                         .num_ips        = ctx->addresses_1_num,
6184                         .ips            = ctx->addresses_1,
6185                         .apply_expected = True
6186                 },
6187                 .defend = {
6188                         .timeout        = 0,
6189                 },
6190                 .replica= {
6191                         .type           = WREPL_TYPE_GROUP,
6192                         .state          = WREPL_STATE_ACTIVE,
6193                         .node           = WREPL_NODE_B,
6194                         .is_static      = False,
6195                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6196                         .ips            = addresses_B_1,
6197                         .apply_expected = True
6198                 },
6199         },
6200         /*
6201          * group,active vs. group,tombstone with same ip(s), unchecked
6202          */
6203         {
6204                 .line   = __location__,
6205                 .name   = _NBT_NAME("_GA_GT_SI_U", 0x00, NULL),
6206                 .wins   = {
6207                         .nb_flags       = NBT_NM_GROUP,
6208                         .mhomed         = False,
6209                         .num_ips        = ctx->addresses_1_num,
6210                         .ips            = ctx->addresses_1,
6211                         .apply_expected = True
6212                 },
6213                 .defend = {
6214                         .timeout        = 0,
6215                 },
6216                 .replica= {
6217                         .type           = WREPL_TYPE_GROUP,
6218                         .state          = WREPL_STATE_TOMBSTONE,
6219                         .node           = WREPL_NODE_B,
6220                         .is_static      = False,
6221                         .num_ips        = ctx->addresses_1_num,
6222                         .ips            = ctx->addresses_1,
6223                         .apply_expected = False
6224                 },
6225         },
6226         /*
6227          * group,active vs. group,tombstone with different ip(s), unchecked
6228          */
6229         {
6230                 .line   = __location__,
6231                 .name   = _NBT_NAME("_GA_GT_DI_U", 0x00, NULL),
6232                 .wins   = {
6233                         .nb_flags       = NBT_NM_GROUP,
6234                         .mhomed         = False,
6235                         .num_ips        = ctx->addresses_1_num,
6236                         .ips            = ctx->addresses_1,
6237                         .apply_expected = True
6238                 },
6239                 .defend = {
6240                         .timeout        = 0,
6241                 },
6242                 .replica= {
6243                         .type           = WREPL_TYPE_GROUP,
6244                         .state          = WREPL_STATE_TOMBSTONE,
6245                         .node           = WREPL_NODE_B,
6246                         .is_static      = False,
6247                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6248                         .ips            = addresses_B_1,
6249                         .apply_expected = False
6250                 },
6251         },
6252 /*
6253  * normal group vs. special group section
6254  */
6255         /*
6256          * group,active vs. sgroup,active with same ip(s), unchecked
6257          */
6258         {
6259                 .line   = __location__,
6260                 .name   = _NBT_NAME("_GA_SA_SI_U", 0x00, NULL),
6261                 .wins   = {
6262                         .nb_flags       = NBT_NM_GROUP,
6263                         .mhomed         = False,
6264                         .num_ips        = ctx->addresses_1_num,
6265                         .ips            = ctx->addresses_1,
6266                         .apply_expected = True
6267                 },
6268                 .defend = {
6269                         .timeout        = 0,
6270                 },
6271                 .replica= {
6272                         .type           = WREPL_TYPE_SGROUP,
6273                         .state          = WREPL_STATE_ACTIVE,
6274                         .node           = WREPL_NODE_B,
6275                         .is_static      = False,
6276                         .num_ips        = ctx->addresses_1_num,
6277                         .ips            = ctx->addresses_1,
6278                         .apply_expected = False
6279                 },
6280         },
6281         /*
6282          * group,active vs. sgroup,active with different ip(s), unchecked
6283          */
6284         {
6285                 .line   = __location__,
6286                 .name   = _NBT_NAME("_GA_SA_DI_U", 0x00, NULL),
6287                 .wins   = {
6288                         .nb_flags       = NBT_NM_GROUP,
6289                         .mhomed         = False,
6290                         .num_ips        = ctx->addresses_1_num,
6291                         .ips            = ctx->addresses_1,
6292                         .apply_expected = True
6293                 },
6294                 .defend = {
6295                         .timeout        = 0,
6296                 },
6297                 .replica= {
6298                         .type           = WREPL_TYPE_SGROUP,
6299                         .state          = WREPL_STATE_ACTIVE,
6300                         .node           = WREPL_NODE_B,
6301                         .is_static      = False,
6302                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
6303                         .ips            = addresses_B_3_4,
6304                         .apply_expected = False
6305                 },
6306         },
6307         /*
6308          * group,active vs. sgroup,tombstone with same ip(s), unchecked
6309          */
6310         {
6311                 .line   = __location__,
6312                 .name   = _NBT_NAME("_GA_ST_SI_U", 0x00, NULL),
6313                 .wins   = {
6314                         .nb_flags       = NBT_NM_GROUP,
6315                         .mhomed         = False,
6316                         .num_ips        = ctx->addresses_1_num,
6317                         .ips            = ctx->addresses_1,
6318                         .apply_expected = True
6319                 },
6320                 .defend = {
6321                         .timeout        = 0,
6322                 },
6323                 .replica= {
6324                         .type           = WREPL_TYPE_SGROUP,
6325                         .state          = WREPL_STATE_TOMBSTONE,
6326                         .node           = WREPL_NODE_B,
6327                         .is_static      = False,
6328                         .num_ips        = ctx->addresses_1_num,
6329                         .ips            = ctx->addresses_1,
6330                         .apply_expected = False
6331                 },
6332         },
6333         /*
6334          * group,active vs. sgroup,tombstone with different ip(s), unchecked
6335          */
6336         {
6337                 .line   = __location__,
6338                 .name   = _NBT_NAME("_GA_ST_DI_U", 0x00, NULL),
6339                 .wins   = {
6340                         .nb_flags       = NBT_NM_GROUP,
6341                         .mhomed         = False,
6342                         .num_ips        = ctx->addresses_1_num,
6343                         .ips            = ctx->addresses_1,
6344                         .apply_expected = True
6345                 },
6346                 .defend = {
6347                         .timeout        = 0,
6348                 },
6349                 .replica= {
6350                         .type           = WREPL_TYPE_SGROUP,
6351                         .state          = WREPL_STATE_TOMBSTONE,
6352                         .node           = WREPL_NODE_B,
6353                         .is_static      = False,
6354                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
6355                         .ips            = addresses_B_3_4,
6356                         .apply_expected = False
6357                 },
6358         },
6359 /*
6360  * normal group vs. multi homed section
6361  */
6362         /*
6363          * group,active vs. mhomed,active with same ip(s), unchecked
6364          */
6365         {
6366                 .line   = __location__,
6367                 .name   = _NBT_NAME("_GA_MA_SI_U", 0x00, NULL),
6368                 .wins   = {
6369                         .nb_flags       = NBT_NM_GROUP,
6370                         .mhomed         = False,
6371                         .num_ips        = ctx->addresses_1_num,
6372                         .ips            = ctx->addresses_1,
6373                         .apply_expected = True
6374                 },
6375                 .defend = {
6376                         .timeout        = 0,
6377                 },
6378                 .replica= {
6379                         .type           = WREPL_TYPE_MHOMED,
6380                         .state          = WREPL_STATE_ACTIVE,
6381                         .node           = WREPL_NODE_B,
6382                         .is_static      = False,
6383                         .num_ips        = ctx->addresses_1_num,
6384                         .ips            = ctx->addresses_1,
6385                         .apply_expected = False
6386                 },
6387         },
6388         /*
6389          * group,active vs. mhomed,active with different ip(s), unchecked
6390          */
6391         {
6392                 .line   = __location__,
6393                 .name   = _NBT_NAME("_GA_MA_DI_U", 0x00, NULL),
6394                 .wins   = {
6395                         .nb_flags       = NBT_NM_GROUP,
6396                         .mhomed         = False,
6397                         .num_ips        = ctx->addresses_1_num,
6398                         .ips            = ctx->addresses_1,
6399                         .apply_expected = True
6400                 },
6401                 .defend = {
6402                         .timeout        = 0,
6403                 },
6404                 .replica= {
6405                         .type           = WREPL_TYPE_MHOMED,
6406                         .state          = WREPL_STATE_ACTIVE,
6407                         .node           = WREPL_NODE_B,
6408                         .is_static      = False,
6409                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
6410                         .ips            = addresses_B_3_4,
6411                         .apply_expected = False
6412                 },
6413         },
6414         /*
6415          * group,active vs. mhomed,tombstone with same ip(s), unchecked
6416          */
6417         {
6418                 .line   = __location__,
6419                 .name   = _NBT_NAME("_GA_MT_SI_U", 0x00, NULL),
6420                 .wins   = {
6421                         .nb_flags       = NBT_NM_GROUP,
6422                         .mhomed         = False,
6423                         .num_ips        = ctx->addresses_1_num,
6424                         .ips            = ctx->addresses_1,
6425                         .apply_expected = True
6426                 },
6427                 .defend = {
6428                         .timeout        = 0,
6429                 },
6430                 .replica= {
6431                         .type           = WREPL_TYPE_MHOMED,
6432                         .state          = WREPL_STATE_TOMBSTONE,
6433                         .node           = WREPL_NODE_B,
6434                         .is_static      = False,
6435                         .num_ips        = ctx->addresses_1_num,
6436                         .ips            = ctx->addresses_1,
6437                         .apply_expected = False
6438                 },
6439         },
6440         /*
6441          * group,active vs. mhomed,tombstone with different ip(s), unchecked
6442          */
6443         {
6444                 .line   = __location__,
6445                 .name   = _NBT_NAME("_GA_MT_DI_U", 0x00, NULL),
6446                 .wins   = {
6447                         .nb_flags       = NBT_NM_GROUP,
6448                         .mhomed         = False,
6449                         .num_ips        = ctx->addresses_1_num,
6450                         .ips            = ctx->addresses_1,
6451                         .apply_expected = True
6452                 },
6453                 .defend = {
6454                         .timeout        = 0,
6455                 },
6456                 .replica= {
6457                         .type           = WREPL_TYPE_MHOMED,
6458                         .state          = WREPL_STATE_TOMBSTONE,
6459                         .node           = WREPL_NODE_B,
6460                         .is_static      = False,
6461                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
6462                         .ips            = addresses_B_3_4,
6463                         .apply_expected = False
6464                 },
6465         },
6466         };
6467
6468         if (!ctx) return False;
6469
6470         if (!ctx->nbtsock_srv) {
6471                 printf("SKIP: Test Replica records vs. owned active records: not bound to port[%d]\n",
6472                         lp_nbt_port());
6473                 return True;
6474         }
6475
6476         printf("Test Replica records vs. owned active records\n");
6477
6478         for(i=0; ret && i < ARRAY_SIZE(records); i++) {
6479                 struct timeval end;
6480
6481                 printf("%s => %s\n", nbt_name_string(ctx, &records[i].name),
6482                         (records[i].replica.apply_expected?"REPLACE":"NOT REPLACE"));
6483
6484                 /* Prepare for the current test */
6485                 nbt_set_incoming_handler(ctx->nbtsock_srv,
6486                                          test_conflict_owned_active_vs_replica_handler,
6487                                          &records[i]);
6488
6489                 /*
6490                  * Setup Register
6491                  */
6492                 name_register->in.name          = records[i].name;
6493                 name_register->in.dest_addr     = ctx->address;
6494                 name_register->in.address       = records[i].wins.ips[0].ip;
6495                 name_register->in.nb_flags      = records[i].wins.nb_flags;
6496                 name_register->in.register_demand= False;
6497                 name_register->in.broadcast     = False;
6498                 name_register->in.multi_homed   = records[i].wins.mhomed;
6499                 name_register->in.ttl           = 300000;
6500                 name_register->in.timeout       = 70;
6501                 name_register->in.retries       = 0;
6502
6503                 status = nbt_name_register(ctx->nbtsock, ctx, name_register);
6504                 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
6505                         printf("No response from %s for name register\n", ctx->address);
6506                         ret = False;
6507                 }
6508                 if (!NT_STATUS_IS_OK(status)) {
6509                         printf("Bad response from %s for name register - %s\n",
6510                                ctx->address, nt_errstr(status));
6511                         ret = False;
6512                 }
6513                 CHECK_VALUE(name_register->out.rcode, 0);
6514                 CHECK_VALUE_STRING(name_register->out.reply_from, ctx->address);
6515                 CHECK_VALUE(name_register->out.name.type, records[i].name.type);
6516                 CHECK_VALUE_STRING(name_register->out.name.name, records[i].name.name);
6517                 CHECK_VALUE_STRING(name_register->out.name.scope, records[i].name.scope);
6518                 CHECK_VALUE_STRING(name_register->out.reply_addr, records[i].wins.ips[0].ip);
6519
6520                 /*
6521                  * Setup Replica
6522                  */
6523                 wins_name->name         = &records[i].name;
6524                 wins_name->flags        = WREPL_NAME_FLAGS(records[i].replica.type,
6525                                                            records[i].replica.state,
6526                                                            records[i].replica.node,
6527                                                            records[i].replica.is_static);
6528                 wins_name->id           = ++ctx->b.max_version;
6529                 if (wins_name->flags & 2) {
6530                         wins_name->addresses.addresses.num_ips = records[i].replica.num_ips;
6531                         wins_name->addresses.addresses.ips     = discard_const(records[i].replica.ips);
6532                 } else {
6533                         wins_name->addresses.ip = records[i].replica.ips[0].ip;
6534                 }
6535                 wins_name->unknown      = "255.255.255.255";
6536
6537                 ret &= test_wrepl_update_one(ctx, &ctx->b, wins_name);
6538
6539                 /*
6540                  * wait for the name query, which is handled in
6541                  * test_conflict_owned_active_vs_replica_handler()
6542                  */
6543                 end = timeval_current_ofs(records[i].defend.timeout,0);
6544                 records[i].defend.ret = True;
6545                 while (records[i].defend.timeout > 0) {
6546                         event_loop_once(ctx->nbtsock_srv->event_ctx);
6547                         if (timeval_expired(&end)) break;
6548                 }
6549                 ret &= records[i].defend.ret;
6550
6551                 ret &= test_wrepl_is_applied(ctx, &ctx->b, wins_name,
6552                                              records[i].replica.apply_expected);
6553
6554                 if (records[i].replica.apply_expected) {
6555                         wins_name->name         = &records[i].name;
6556                         wins_name->flags        = WREPL_NAME_FLAGS(WREPL_TYPE_UNIQUE,
6557                                                                    WREPL_STATE_TOMBSTONE,
6558                                                                    WREPL_NODE_B, False);
6559                         wins_name->id           = ++ctx->b.max_version;
6560                         wins_name->addresses.ip = addresses_B_1[0].ip;
6561                         wins_name->unknown      = "255.255.255.255";
6562
6563                         ret &= test_wrepl_update_one(ctx, &ctx->b, wins_name);
6564                         ret &= test_wrepl_is_applied(ctx, &ctx->b, wins_name, True);
6565                 } else {
6566                         release->in.name        = records[i].name;
6567                         release->in.dest_addr   = ctx->address;
6568                         release->in.address     = records[i].wins.ips[0].ip;
6569                         release->in.nb_flags    = records[i].wins.nb_flags;
6570                         release->in.broadcast   = False;
6571                         release->in.timeout     = 30;
6572                         release->in.retries     = 0;
6573
6574                         status = nbt_name_release(ctx->nbtsock, ctx, release);
6575                         if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
6576                                 printf("No response from %s for name release\n", ctx->address);
6577                                 return False;
6578                         }
6579                         if (!NT_STATUS_IS_OK(status)) {
6580                                 printf("Bad response from %s for name query - %s\n",
6581                                        ctx->address, nt_errstr(status));
6582                                 return False;
6583                         }
6584                         CHECK_VALUE(release->out.rcode, 0);
6585                 }
6586
6587 done:
6588                 if (!ret) {
6589                         printf("conflict handled wrong or record[%u]: %s\n", i, records[i].line);
6590                         return ret;
6591                 }
6592         }
6593
6594         return ret;
6595 }
6596
6597 #define _NBT_ASSERT(v, correct) do { \
6598         if ((v) != (correct)) { \
6599                 printf("(%s) Incorrect value %s=%d - should be %s (%d)\n", \
6600                        __location__, #v, v, #correct, correct); \
6601                 return; \
6602         } \
6603 } while (0)
6604
6605 #define _NBT_ASSERT_STRING(v, correct) do { \
6606         if ( ((!v) && (correct)) || \
6607              ((v) && (!correct)) || \
6608              ((v) && (correct) && strcmp(v,correct) != 0)) { \
6609                 printf("(%s) Incorrect value %s=%s - should be %s\n", \
6610                        __location__, #v, v, correct); \
6611                 return; \
6612         } \
6613 } while (0)
6614
6615 static void test_conflict_owned_active_vs_replica_handler_query(struct nbt_name_socket *nbtsock,
6616                                                                 struct nbt_name_packet *req_packet,
6617                                                                 const struct nbt_peer_socket *src)
6618 {
6619         struct nbt_name *name;
6620         struct nbt_name_packet *rep_packet;
6621         struct test_conflict_owned_active_vs_replica_struct *rec = nbtsock->incoming.private;
6622
6623         _NBT_ASSERT(req_packet->qdcount, 1);
6624         _NBT_ASSERT(req_packet->questions[0].question_type, NBT_QTYPE_NETBIOS);
6625         _NBT_ASSERT(req_packet->questions[0].question_class, NBT_QCLASS_IP);
6626
6627         name = &req_packet->questions[0].name;
6628
6629         _NBT_ASSERT(name->type, rec->name.type);
6630         _NBT_ASSERT_STRING(name->name, rec->name.name);
6631         _NBT_ASSERT_STRING(name->scope, rec->name.scope);
6632
6633         _NBT_ASSERT(rec->defend.expect_release, False);
6634
6635         rep_packet = talloc_zero(nbtsock, struct nbt_name_packet);
6636         if (rep_packet == NULL) return;
6637
6638         rep_packet->name_trn_id = req_packet->name_trn_id;
6639         rep_packet->ancount     = 1;
6640
6641         rep_packet->answers     = talloc_array(rep_packet, struct nbt_res_rec, 1);
6642         if (rep_packet->answers == NULL) return;
6643
6644         rep_packet->answers[0].name      = *name;
6645         rep_packet->answers[0].rr_class  = NBT_QCLASS_IP;
6646         rep_packet->answers[0].ttl       = 0;
6647
6648         if (rec->defend.positive) {
6649                 uint32_t i;
6650
6651                 /* send a positive reply */
6652                 rep_packet->operation   =
6653                                         NBT_FLAG_REPLY |
6654                                         NBT_OPCODE_QUERY |
6655                                         NBT_FLAG_AUTHORITIVE |
6656                                         NBT_FLAG_RECURSION_DESIRED |
6657                                         NBT_FLAG_RECURSION_AVAIL;
6658
6659                 rep_packet->answers[0].rr_type   = NBT_QTYPE_NETBIOS;
6660
6661                 rep_packet->answers[0].rdata.netbios.length = rec->wins.num_ips*6;
6662                 rep_packet->answers[0].rdata.netbios.addresses =
6663                         talloc_array(rep_packet->answers, struct nbt_rdata_address, rec->wins.num_ips);
6664                 if (rep_packet->answers[0].rdata.netbios.addresses == NULL) return;
6665
6666                 for (i=0; i < rec->wins.num_ips; i++) {
6667                         struct nbt_rdata_address *addr =
6668                                 &rep_packet->answers[0].rdata.netbios.addresses[i];
6669                         addr->nb_flags  = rec->wins.nb_flags;
6670                         addr->ipaddr    = rec->wins.ips[i].ip;
6671                 }
6672                 DEBUG(2,("Sending positive name query reply for %s to %s:%d\n",
6673                         nbt_name_string(rep_packet, name), src->addr, src->port));
6674         } else {
6675                 /* send a negative reply */
6676                 rep_packet->operation   =
6677                                         NBT_FLAG_REPLY |
6678                                         NBT_OPCODE_QUERY |
6679                                         NBT_FLAG_AUTHORITIVE |
6680                                         NBT_RCODE_NAM;
6681
6682                 rep_packet->answers[0].rr_type   = NBT_QTYPE_NULL;
6683
6684                 ZERO_STRUCT(rep_packet->answers[0].rdata);
6685
6686                 DEBUG(2,("Sending negative name query reply for %s to %s:%d\n",
6687                         nbt_name_string(rep_packet, name), src->addr, src->port));
6688         }
6689
6690         nbt_name_reply_send(nbtsock, src, rep_packet);
6691         talloc_free(rep_packet);
6692
6693         /* make sure we push the reply to the wire */
6694         event_loop_once(nbtsock->event_ctx);
6695
6696         rec->defend.timeout     = 0;
6697         rec->defend.ret         = True;
6698 }
6699
6700 static void test_conflict_owned_active_vs_replica_handler_release(struct nbt_name_socket *nbtsock,
6701                                                                   struct nbt_name_packet *req_packet,
6702                                                                   const struct nbt_peer_socket *src)
6703 {
6704         struct nbt_name *name;
6705         struct nbt_name_packet *rep_packet;
6706         struct test_conflict_owned_active_vs_replica_struct *rec = nbtsock->incoming.private;
6707
6708         _NBT_ASSERT(req_packet->qdcount, 1);
6709         _NBT_ASSERT(req_packet->questions[0].question_type, NBT_QTYPE_NETBIOS);
6710         _NBT_ASSERT(req_packet->questions[0].question_class, NBT_QCLASS_IP);
6711
6712         name = &req_packet->questions[0].name;
6713
6714         _NBT_ASSERT(name->type, rec->name.type);
6715         _NBT_ASSERT_STRING(name->name, rec->name.name);
6716         _NBT_ASSERT_STRING(name->scope, rec->name.scope);
6717
6718         _NBT_ASSERT(rec->defend.expect_release, True);
6719
6720         rep_packet = talloc_zero(nbtsock, struct nbt_name_packet);
6721         if (rep_packet == NULL) return;
6722
6723         rep_packet->name_trn_id = req_packet->name_trn_id;
6724         rep_packet->ancount     = 1;
6725         rep_packet->operation   =
6726                                 NBT_FLAG_REPLY |
6727                                 NBT_OPCODE_RELEASE |
6728                                 NBT_FLAG_AUTHORITIVE;
6729
6730         rep_packet->answers     = talloc_array(rep_packet, struct nbt_res_rec, 1);
6731         if (rep_packet->answers == NULL) return;
6732
6733         rep_packet->answers[0].name     = *name;
6734         rep_packet->answers[0].rr_type  = NBT_QTYPE_NETBIOS;
6735         rep_packet->answers[0].rr_class = NBT_QCLASS_IP;
6736         rep_packet->answers[0].ttl      = req_packet->additional[0].ttl;
6737         rep_packet->answers[0].rdata    = req_packet->additional[0].rdata;
6738
6739         DEBUG(2,("Sending name release reply for %s to %s:%d\n",
6740                 nbt_name_string(rep_packet, name), src->addr, src->port));
6741
6742         nbt_name_reply_send(nbtsock, src, rep_packet);
6743         talloc_free(rep_packet);
6744
6745         /* make sure we push the reply to the wire */
6746         event_loop_once(nbtsock->event_ctx);
6747
6748         rec->defend.timeout     = 0;
6749         rec->defend.ret         = True;
6750 }
6751
6752 static void test_conflict_owned_active_vs_replica_handler(struct nbt_name_socket *nbtsock,
6753                                                           struct nbt_name_packet *req_packet,
6754                                                           const struct nbt_peer_socket *src)
6755 {
6756         struct test_conflict_owned_active_vs_replica_struct *rec = nbtsock->incoming.private;
6757
6758         rec->defend.ret = False;
6759
6760         switch (req_packet->operation & NBT_OPCODE) {
6761         case NBT_OPCODE_QUERY:
6762                 test_conflict_owned_active_vs_replica_handler_query(nbtsock, req_packet, src);
6763                 break;
6764         case NBT_OPCODE_RELEASE:
6765                 test_conflict_owned_active_vs_replica_handler_release(nbtsock, req_packet, src);
6766                 break;
6767         default:
6768                 printf("%s: unexpected incoming packet\n", __location__);
6769                 return;
6770         }
6771 }
6772
6773 /*
6774   test WINS replication operations
6775 */
6776 BOOL torture_nbt_winsreplication_quick(void)
6777 {
6778         const char *address;
6779         struct nbt_name name;
6780         TALLOC_CTX *mem_ctx = talloc_new(NULL);
6781         NTSTATUS status;
6782         BOOL ret = True;
6783
6784         make_nbt_name_server(&name, lp_parm_string(-1, "torture", "host"));
6785
6786         /* do an initial name resolution to find its IP */
6787         status = resolve_name(&name, mem_ctx, &address, NULL);
6788         if (!NT_STATUS_IS_OK(status)) {
6789                 printf("Failed to resolve %s - %s\n",
6790                        name.name, nt_errstr(status));
6791                 talloc_free(mem_ctx);
6792                 return False;
6793         }
6794
6795         ret &= test_assoc_ctx1(mem_ctx, address);
6796         ret &= test_assoc_ctx2(mem_ctx, address);
6797
6798         talloc_free(mem_ctx);
6799
6800         return ret;
6801 }
6802
6803 /*
6804   test WINS replication operations
6805 */
6806 BOOL torture_nbt_winsreplication(void)
6807 {
6808         const char *address;
6809         struct nbt_name name;
6810         TALLOC_CTX *mem_ctx = talloc_new(NULL);
6811         NTSTATUS status;
6812         BOOL ret = True;
6813         struct test_wrepl_conflict_conn *ctx;
6814
6815         make_nbt_name_server(&name, lp_parm_string(-1, "torture", "host"));
6816
6817         /* do an initial name resolution to find its IP */
6818         status = resolve_name(&name, mem_ctx, &address, NULL);
6819         if (!NT_STATUS_IS_OK(status)) {
6820                 printf("Failed to resolve %s - %s\n",
6821                        name.name, nt_errstr(status));
6822                 talloc_free(mem_ctx);
6823                 return False;
6824         }
6825
6826         ret &= test_assoc_ctx1(mem_ctx, address);
6827         ret &= test_assoc_ctx2(mem_ctx, address);
6828
6829         ret &= test_wins_replication(mem_ctx, address);
6830
6831         ctx = test_create_conflict_ctx(mem_ctx, address);
6832
6833         ret &= test_conflict_same_owner(ctx);
6834         ret &= test_conflict_different_owner(ctx);
6835         ret &= test_conflict_owned_released_vs_replica(ctx);
6836         ret &= test_conflict_owned_active_vs_replica(ctx);
6837
6838         talloc_free(mem_ctx);
6839
6840         return ret;
6841 }