source4/torture/nbt/winsreplication.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    WINS replication testing
   5
   6    Copyright (C) Andrew Tridgell        2005
   7    Copyright (C) Stefan Metzmacher      2005
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include "includes.h"
  24 #include "libcli/wrepl/winsrepl.h"
  25 #include "lib/events/events.h"
  26 #include "lib/socket/socket.h"
  27 #include "system/network.h"
  28 #include "lib/socket/netif.h"
  29 #include "librpc/gen_ndr/ndr_nbt.h"
  30 #include "libcli/nbt/libnbt.h"
  31 #include "torture/torture.h"
  32 #include "torture/nbt/proto.h"
  33 #include "param/param.h"
  34
  35 #define CHECK_STATUS(tctx, status, correct) \
  36         torture_assert_ntstatus_equal(tctx, status, correct, \
  37                                                                   "Incorrect status")
  38
  39 #define CHECK_VALUE(tctx, v, correct) \
  40         torture_assert(tctx, (v) == (correct), \
  41                                    talloc_asprintf(tctx, "Incorrect value %s=%d - should be %d\n", \
  42                        #v, v, correct))
  43
  44 #define CHECK_VALUE_UINT64(tctx, v, correct) \
  45         torture_assert(tctx, (v) == (correct), \
  46                 talloc_asprintf(tctx, "Incorrect value %s=%llu - should be %llu\n", \
  47                        #v, (long long)v, (long long)correct))
  48
  49 #define CHECK_VALUE_STRING(tctx, v, correct) \
  50         torture_assert_str_equal(tctx, v, correct, "Invalid value")
  51
  52 #define _NBT_NAME(n,t,s) {\
  53         .name   = n,\
  54         .type   = t,\
  55         .scope  = s\
  56 }
  57
  58 static const char *wrepl_name_type_string(enum wrepl_name_type type)
  59 {
  60         switch (type) {
  61         case WREPL_TYPE_UNIQUE: return "UNIQUE";
  62         case WREPL_TYPE_GROUP: return "GROUP";
  63         case WREPL_TYPE_SGROUP: return "SGROUP";
  64         case WREPL_TYPE_MHOMED: return "MHOMED";
  65         }
  66         return "UNKNOWN_TYPE";
  67 }
  68
  69 static const char *wrepl_name_state_string(enum wrepl_name_state state)
  70 {
  71         switch (state) {
  72         case WREPL_STATE_ACTIVE: return "ACTIVE";
  73         case WREPL_STATE_RELEASED: return "RELEASED";
  74         case WREPL_STATE_TOMBSTONE: return "TOMBSTONE";
  75         case WREPL_STATE_RESERVED: return "RESERVED";
  76         }
  77         return "UNKNOWN_STATE";
  78 }
  79
  80 /*
  81   test how assoc_ctx's are only usable on the connection
  82   they are created on.
  83 */
  84 static bool test_assoc_ctx1(struct torture_context *tctx)
  85 {
  86         bool ret = true;
  87         struct tevent_req *subreq;
  88         struct wrepl_socket *wrepl_socket1;
  89         struct wrepl_associate associate1;
  90         struct wrepl_socket *wrepl_socket2;
  91         struct wrepl_associate associate2;
  92         struct wrepl_packet packet;
  93         struct wrepl_send_ctrl ctrl;
  94         struct wrepl_packet *rep_packet;
  95         struct wrepl_associate_stop assoc_stop;
  96         NTSTATUS status;
  97         struct nbt_name name;
  98         const char *address;
  99         bool ok;
 100
 101         if (!torture_nbt_get_name(tctx, &name, &address))
 102                 return false;
 103
 104         torture_comment(tctx, "Test if assoc_ctx is only valid on the connection it was created on\n");
 105
 106         wrepl_socket1 = wrepl_socket_init(tctx, tctx->ev);
 107         wrepl_socket2 = wrepl_socket_init(tctx, tctx->ev);
 108
 109         torture_comment(tctx, "Setup 2 wrepl connections\n");
 110         status = wrepl_connect(wrepl_socket1, wrepl_best_ip(tctx->lp_ctx, address), address);
 111         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 112
 113         status = wrepl_connect(wrepl_socket2, wrepl_best_ip(tctx->lp_ctx, address), address);
 114         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 115
 116         torture_comment(tctx, "Send a start association request (conn1)\n");
 117         status = wrepl_associate(wrepl_socket1, &associate1);
 118         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 119
 120         torture_comment(tctx, "association context (conn1): 0x%x\n", associate1.out.assoc_ctx);
 121
 122         torture_comment(tctx, "Send a start association request (conn2)\n");
 123         status = wrepl_associate(wrepl_socket2, &associate2);
 124         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 125
 126         torture_comment(tctx, "association context (conn2): 0x%x\n", associate2.out.assoc_ctx);
 127
 128         torture_comment(tctx, "Send a replication table query, with assoc 1 (conn2), the answer should be on conn1\n");
 129         ZERO_STRUCT(packet);
 130         packet.opcode                      = WREPL_OPCODE_BITS;
 131         packet.assoc_ctx                   = associate1.out.assoc_ctx;
 132         packet.mess_type                   = WREPL_REPLICATION;
 133         packet.message.replication.command = WREPL_REPL_TABLE_QUERY;
 134         ZERO_STRUCT(ctrl);
 135         ctrl.send_only = true;
 136         subreq = wrepl_request_send(tctx, tctx->ev, wrepl_socket2, &packet, &ctrl);
 137         ok = tevent_req_poll(subreq, tctx->ev);
 138         if (!ok) {
 139                 CHECK_STATUS(tctx, NT_STATUS_INTERNAL_ERROR, NT_STATUS_OK);
 140         }
 141         status = wrepl_request_recv(subreq, tctx, &rep_packet);
 142         TALLOC_FREE(subreq);
 143         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 144
 145         torture_comment(tctx, "Send a association request (conn2), to make sure the last request was ignored\n");
 146         status = wrepl_associate(wrepl_socket2, &associate2);
 147         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 148
 149         torture_comment(tctx, "Send a replication table query, with invalid assoc (conn1), receive answer from conn2\n");
 150         ZERO_STRUCT(packet);
 151         packet.opcode                           = WREPL_OPCODE_BITS;
 152         packet.assoc_ctx                        = 0;
 153         packet.mess_type                        = WREPL_REPLICATION;
 154         packet.message.replication.command      = WREPL_REPL_TABLE_QUERY;
 155         status = wrepl_request(wrepl_socket1, tctx, &packet, &rep_packet);
 156         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 157
 158         torture_comment(tctx, "Send a association request (conn1), to make sure the last request was handled correct\n");
 159         status = wrepl_associate(wrepl_socket1, &associate2);
 160         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 161
 162         assoc_stop.in.assoc_ctx = associate1.out.assoc_ctx;
 163         assoc_stop.in.reason    = 4;
 164         torture_comment(tctx, "Send a association stop request (conn1), reson: %u\n", assoc_stop.in.reason);
 165         status = wrepl_associate_stop(wrepl_socket1, &assoc_stop);
 166         CHECK_STATUS(tctx, status, NT_STATUS_END_OF_FILE);
 167
 168         assoc_stop.in.assoc_ctx = associate2.out.assoc_ctx;
 169         assoc_stop.in.reason    = 0;
 170         torture_comment(tctx, "Send a association stop request (conn2), reson: %u\n", assoc_stop.in.reason);
 171         status = wrepl_associate_stop(wrepl_socket2, &assoc_stop);
 172         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 173
 174         torture_comment(tctx, "Close 2 wrepl connections\n");
 175         talloc_free(wrepl_socket1);
 176         talloc_free(wrepl_socket2);
 177         return ret;
 178 }
 179
 180 /*
 181   test if we always get back the same assoc_ctx
 182 */
 183 static bool test_assoc_ctx2(struct torture_context *tctx)
 184 {
 185         struct wrepl_socket *wrepl_socket;
 186         struct wrepl_associate associate;
 187         uint32_t assoc_ctx1;
 188         struct nbt_name name;
 189         NTSTATUS status;
 190         const char *address;
 191
 192         if (!torture_nbt_get_name(tctx, &name, &address))
 193                 return false;
 194
 195         torture_comment(tctx, "Test if we always get back the same assoc_ctx\n");
 196
 197         wrepl_socket = wrepl_socket_init(tctx, tctx->ev);
 198
 199         torture_comment(tctx, "Setup wrepl connections\n");
 200         status = wrepl_connect(wrepl_socket, wrepl_best_ip(tctx->lp_ctx, address), address);
 201         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 202
 203         torture_comment(tctx, "Send 1st start association request\n");
 204         status = wrepl_associate(wrepl_socket, &associate);
 205         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 206         assoc_ctx1 = associate.out.assoc_ctx;
 207         torture_comment(tctx, "1st association context: 0x%x\n", associate.out.assoc_ctx);
 208
 209         torture_comment(tctx, "Send 2nd start association request\n");
 210         status = wrepl_associate(wrepl_socket, &associate);
 211         torture_assert_ntstatus_ok(tctx, status, "2nd start association failed");
 212         torture_assert(tctx, associate.out.assoc_ctx == assoc_ctx1,
 213                                    "Different context returned");
 214         torture_comment(tctx, "2nd association context: 0x%x\n", associate.out.assoc_ctx);
 215
 216         torture_comment(tctx, "Send 3rd start association request\n");
 217         status = wrepl_associate(wrepl_socket, &associate);
 218         torture_assert(tctx, associate.out.assoc_ctx == assoc_ctx1,
 219                                    "Different context returned");
 220         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 221         torture_comment(tctx, "3rd association context: 0x%x\n", associate.out.assoc_ctx);
 222
 223         torture_comment(tctx, "Close wrepl connections\n");
 224         talloc_free(wrepl_socket);
 225         return true;
 226 }
 227
 228
 229 /*
 230   display a replication entry
 231 */
 232 static void display_entry(struct torture_context *tctx, struct wrepl_name *name)
 233 {
 234         int i;
 235
 236         torture_comment(tctx, "%s\n", nbt_name_string(tctx, &name->name));
 237         torture_comment(tctx, "\tTYPE:%u STATE:%u NODE:%u STATIC:%u VERSION_ID: %llu\n",
 238                 name->type, name->state, name->node, name->is_static, (long long)name->version_id);
 239         torture_comment(tctx, "\tRAW_FLAGS: 0x%08X OWNER: %-15s\n",
 240                 name->raw_flags, name->owner);
 241         for (i=0;i<name->num_addresses;i++) {
 242                 torture_comment(tctx, "\tADDR: %-15s OWNER: %-15s\n",
 243                         name->addresses[i].address, name->addresses[i].owner);
 244         }
 245 }
 246
 247 /*
 248   test a full replication dump from a WINS server
 249 */
 250 static bool test_wins_replication(struct torture_context *tctx)
 251 {
 252         struct wrepl_socket *wrepl_socket;
 253         NTSTATUS status;
 254         int i, j;
 255         struct wrepl_associate associate;
 256         struct wrepl_pull_table pull_table;
 257         struct wrepl_pull_names pull_names;
 258         struct nbt_name name;
 259         const char *address;
 260
 261         if (!torture_nbt_get_name(tctx, &name, &address))
 262                 return false;
 263
 264         torture_comment(tctx, "Test one pull replication cycle\n");
 265
 266         wrepl_socket = wrepl_socket_init(tctx, tctx->ev);
 267
 268         torture_comment(tctx, "Setup wrepl connections\n");
 269         status = wrepl_connect(wrepl_socket, wrepl_best_ip(tctx->lp_ctx, address), address);
 270         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 271
 272         torture_comment(tctx, "Send a start association request\n");
 273
 274         status = wrepl_associate(wrepl_socket, &associate);
 275         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 276
 277         torture_comment(tctx, "association context: 0x%x\n", associate.out.assoc_ctx);
 278
 279         torture_comment(tctx, "Send a replication table query\n");
 280         pull_table.in.assoc_ctx = associate.out.assoc_ctx;
 281
 282         status = wrepl_pull_table(wrepl_socket, tctx, &pull_table);
 283         if (NT_STATUS_EQUAL(NT_STATUS_NETWORK_ACCESS_DENIED,status)) {
 284                 struct wrepl_associate_stop assoc_stop;
 285
 286                 assoc_stop.in.assoc_ctx = associate.out.assoc_ctx;
 287                 assoc_stop.in.reason = 0;
 288
 289                 wrepl_associate_stop(wrepl_socket, &assoc_stop);
 290
 291                 torture_fail(tctx, "We are not a valid pull partner for the server");
 292         }
 293         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 294
 295         torture_comment(tctx, "Found %d replication partners\n", pull_table.out.num_partners);
 296
 297         for (i=0;i<pull_table.out.num_partners;i++) {
 298                 struct wrepl_wins_owner *partner = &pull_table.out.partners[i];
 299                 torture_comment(tctx, "%s   max_version=%6llu   min_version=%6llu type=%d\n",
 300                        partner->address,
 301                        (long long)partner->max_version,
 302                        (long long)partner->min_version,
 303                        partner->type);
 304
 305                 pull_names.in.assoc_ctx = associate.out.assoc_ctx;
 306                 pull_names.in.partner = *partner;
 307
 308                 status = wrepl_pull_names(wrepl_socket, tctx, &pull_names);
 309                 CHECK_STATUS(tctx, status, NT_STATUS_OK);
 310
 311                 torture_comment(tctx, "Received %d names\n", pull_names.out.num_names);
 312
 313                 for (j=0;j<pull_names.out.num_names;j++) {
 314                         display_entry(tctx, &pull_names.out.names[j]);
 315                 }
 316         }
 317
 318         torture_comment(tctx, "Close wrepl connections\n");
 319         talloc_free(wrepl_socket);
 320         return true;
 321 }
 322
 323 struct test_wrepl_conflict_conn {
 324         const char *address;
 325         struct wrepl_socket *pull;
 326         uint32_t pull_assoc;
 327
 328 #define TEST_OWNER_A_ADDRESS "127.65.65.1"
 329 #define TEST_ADDRESS_A_PREFIX "127.0.65"
 330 #define TEST_OWNER_B_ADDRESS "127.66.66.1"
 331 #define TEST_ADDRESS_B_PREFIX "127.0.66"
 332 #define TEST_OWNER_X_ADDRESS "127.88.88.1"
 333 #define TEST_ADDRESS_X_PREFIX "127.0.88"
 334
 335         struct wrepl_wins_owner a, b, c, x;
 336
 337         struct socket_address *myaddr;
 338         struct socket_address *myaddr2;
 339         struct nbt_name_socket *nbtsock;
 340         struct nbt_name_socket *nbtsock2;
 341
 342         struct nbt_name_socket *nbtsock_srv;
 343         struct nbt_name_socket *nbtsock_srv2;
 344
 345         uint32_t addresses_best_num;
 346         struct wrepl_ip *addresses_best;
 347
 348         uint32_t addresses_best2_num;
 349         struct wrepl_ip *addresses_best2;
 350
 351         uint32_t addresses_all_num;
 352         struct wrepl_ip *addresses_all;
 353
 354         uint32_t addresses_mhomed_num;
 355         struct wrepl_ip *addresses_mhomed;
 356 };
 357
 358 static const struct wrepl_ip addresses_A_1[] = {
 359         {
 360         .owner  = TEST_OWNER_A_ADDRESS,
 361         .ip     = TEST_ADDRESS_A_PREFIX".1"
 362         }
 363 };
 364 static const struct wrepl_ip addresses_A_2[] = {
 365         {
 366         .owner  = TEST_OWNER_A_ADDRESS,
 367         .ip     = TEST_ADDRESS_A_PREFIX".2"
 368         }
 369 };
 370 static const struct wrepl_ip addresses_A_3_4[] = {
 371         {
 372         .owner  = TEST_OWNER_A_ADDRESS,
 373         .ip     = TEST_ADDRESS_A_PREFIX".3"
 374         },
 375         {
 376         .owner  = TEST_OWNER_A_ADDRESS,
 377         .ip     = TEST_ADDRESS_A_PREFIX".4"
 378         }
 379 };
 380 static const struct wrepl_ip addresses_A_3_4_X_3_4[] = {
 381         {
 382         .owner  = TEST_OWNER_A_ADDRESS,
 383         .ip     = TEST_ADDRESS_A_PREFIX".3"
 384         },
 385         {
 386         .owner  = TEST_OWNER_A_ADDRESS,
 387         .ip     = TEST_ADDRESS_A_PREFIX".4"
 388         },
 389         {
 390         .owner  = TEST_OWNER_X_ADDRESS,
 391         .ip     = TEST_ADDRESS_X_PREFIX".3"
 392         },
 393         {
 394         .owner  = TEST_OWNER_X_ADDRESS,
 395         .ip     = TEST_ADDRESS_X_PREFIX".4"
 396         }
 397 };
 398 static const struct wrepl_ip addresses_A_3_4_B_3_4[] = {
 399         {
 400         .owner  = TEST_OWNER_A_ADDRESS,
 401         .ip     = TEST_ADDRESS_A_PREFIX".3"
 402         },
 403         {
 404         .owner  = TEST_OWNER_A_ADDRESS,
 405         .ip     = TEST_ADDRESS_A_PREFIX".4"
 406         },
 407         {
 408         .owner  = TEST_OWNER_B_ADDRESS,
 409         .ip     = TEST_ADDRESS_B_PREFIX".3"
 410         },
 411         {
 412         .owner  = TEST_OWNER_B_ADDRESS,
 413         .ip     = TEST_ADDRESS_B_PREFIX".4"
 414         }
 415 };
 416 static const struct wrepl_ip addresses_A_3_4_OWNER_B[] = {
 417         {
 418         .owner  = TEST_OWNER_B_ADDRESS,
 419         .ip     = TEST_ADDRESS_A_PREFIX".3"
 420         },
 421         {
 422         .owner  = TEST_OWNER_B_ADDRESS,
 423         .ip     = TEST_ADDRESS_A_PREFIX".4"
 424         }
 425 };
 426 static const struct wrepl_ip addresses_A_3_4_X_3_4_OWNER_B[] = {
 427         {
 428         .owner  = TEST_OWNER_B_ADDRESS,
 429         .ip     = TEST_ADDRESS_A_PREFIX".3"
 430         },
 431         {
 432         .owner  = TEST_OWNER_B_ADDRESS,
 433         .ip     = TEST_ADDRESS_A_PREFIX".4"
 434         },
 435         {
 436         .owner  = TEST_OWNER_B_ADDRESS,
 437         .ip     = TEST_ADDRESS_X_PREFIX".3"
 438         },
 439         {
 440         .owner  = TEST_OWNER_B_ADDRESS,
 441         .ip     = TEST_ADDRESS_X_PREFIX".4"
 442         }
 443 };
 444 /*
 445 static const struct wrepl_ip addresses_A_3_4_X_1_2[] = {
 446         {
 447         .owner  = TEST_OWNER_A_ADDRESS,
 448         .ip     = TEST_ADDRESS_A_PREFIX".3"
 449         },
 450         {
 451         .owner  = TEST_OWNER_A_ADDRESS,
 452         .ip     = TEST_ADDRESS_A_PREFIX".4"
 453         },
 454         {
 455         .owner  = TEST_OWNER_X_ADDRESS,
 456         .ip     = TEST_ADDRESS_X_PREFIX".1"
 457         },
 458         {
 459         .owner  = TEST_OWNER_X_ADDRESS,
 460         .ip     = TEST_ADDRESS_X_PREFIX".2"
 461         }
 462 };
 463 */
 464 static const struct wrepl_ip addresses_B_1[] = {
 465         {
 466         .owner  = TEST_OWNER_B_ADDRESS,
 467         .ip     = TEST_ADDRESS_B_PREFIX".1"
 468         }
 469 };
 470 /*
 471 static const struct wrepl_ip addresses_B_2[] = {
 472         {
 473         .owner  = TEST_OWNER_B_ADDRESS,
 474         .ip     = TEST_ADDRESS_B_PREFIX".2"
 475         }
 476 };
 477 */
 478 static const struct wrepl_ip addresses_B_3_4[] = {
 479         {
 480         .owner  = TEST_OWNER_B_ADDRESS,
 481         .ip     = TEST_ADDRESS_B_PREFIX".3"
 482         },
 483         {
 484         .owner  = TEST_OWNER_B_ADDRESS,
 485         .ip     = TEST_ADDRESS_B_PREFIX".4"
 486         }
 487 };
 488 static const struct wrepl_ip addresses_B_3_4_X_3_4[] = {
 489         {
 490         .owner  = TEST_OWNER_B_ADDRESS,
 491         .ip     = TEST_ADDRESS_B_PREFIX".3"
 492         },
 493         {
 494         .owner  = TEST_OWNER_B_ADDRESS,
 495         .ip     = TEST_ADDRESS_B_PREFIX".4"
 496         },
 497         {
 498         .owner  = TEST_OWNER_X_ADDRESS,
 499         .ip     = TEST_ADDRESS_X_PREFIX".3"
 500         },
 501         {
 502         .owner  = TEST_OWNER_X_ADDRESS,
 503         .ip     = TEST_ADDRESS_X_PREFIX".4"
 504         }
 505 };
 506 static const struct wrepl_ip addresses_B_3_4_X_1_2[] = {
 507         {
 508         .owner  = TEST_OWNER_B_ADDRESS,
 509         .ip     = TEST_ADDRESS_B_PREFIX".3"
 510         },
 511         {
 512         .owner  = TEST_OWNER_B_ADDRESS,
 513         .ip     = TEST_ADDRESS_B_PREFIX".4"
 514         },
 515         {
 516         .owner  = TEST_OWNER_X_ADDRESS,
 517         .ip     = TEST_ADDRESS_X_PREFIX".1"
 518         },
 519         {
 520         .owner  = TEST_OWNER_X_ADDRESS,
 521         .ip     = TEST_ADDRESS_X_PREFIX".2"
 522         }
 523 };
 524
 525 /*
 526 static const struct wrepl_ip addresses_X_1_2[] = {
 527         {
 528         .owner  = TEST_OWNER_X_ADDRESS,
 529         .ip     = TEST_ADDRESS_X_PREFIX".1"
 530         },
 531         {
 532         .owner  = TEST_OWNER_X_ADDRESS,
 533         .ip     = TEST_ADDRESS_X_PREFIX".2"
 534         }
 535 };
 536 */
 537
 538 static const struct wrepl_ip addresses_X_3_4[] = {
 539         {
 540         .owner  = TEST_OWNER_X_ADDRESS,
 541         .ip     = TEST_ADDRESS_X_PREFIX".3"
 542         },
 543         {
 544         .owner  = TEST_OWNER_X_ADDRESS,
 545         .ip     = TEST_ADDRESS_X_PREFIX".4"
 546         }
 547 };
 548
 549 static struct test_wrepl_conflict_conn *test_create_conflict_ctx(
 550                 struct torture_context *tctx, const char *address)
 551 {
 552         struct test_wrepl_conflict_conn *ctx;
 553         struct wrepl_associate associate;
 554         struct wrepl_pull_table pull_table;
 555         struct socket_address *nbt_srv_addr;
 556         NTSTATUS status;
 557         uint32_t i;
 558         uint32_t num_ifaces;
 559         struct interface *ifaces;
 560
 561         ctx = talloc_zero(tctx, struct test_wrepl_conflict_conn);
 562         if (!ctx) return NULL;
 563
 564         ctx->address    = address;
 565         ctx->pull       = wrepl_socket_init(ctx, tctx->ev);
 566         if (!ctx->pull) return NULL;
 567
 568         torture_comment(tctx, "Setup wrepl conflict pull connection\n");
 569         status = wrepl_connect(ctx->pull, wrepl_best_ip(tctx->lp_ctx, ctx->address), ctx->address);
 570         if (!NT_STATUS_IS_OK(status)) return NULL;
 571
 572         status = wrepl_associate(ctx->pull, &associate);
 573         if (!NT_STATUS_IS_OK(status)) return NULL;
 574
 575         ctx->pull_assoc = associate.out.assoc_ctx;
 576
 577         ctx->a.address          = TEST_OWNER_A_ADDRESS;
 578         ctx->a.max_version      = 0;
 579         ctx->a.min_version      = 0;
 580         ctx->a.type             = 1;
 581
 582         ctx->b.address          = TEST_OWNER_B_ADDRESS;
 583         ctx->b.max_version      = 0;
 584         ctx->b.min_version      = 0;
 585         ctx->b.type             = 1;
 586
 587         ctx->x.address          = TEST_OWNER_X_ADDRESS;
 588         ctx->x.max_version      = 0;
 589         ctx->x.min_version      = 0;
 590         ctx->x.type             = 1;
 591
 592         ctx->c.address          = address;
 593         ctx->c.max_version      = 0;
 594         ctx->c.min_version      = 0;
 595         ctx->c.type             = 1;
 596
 597         pull_table.in.assoc_ctx = ctx->pull_assoc;
 598         status = wrepl_pull_table(ctx->pull, ctx->pull, &pull_table);
 599         if (!NT_STATUS_IS_OK(status)) return NULL;
 600
 601         for (i=0; i < pull_table.out.num_partners; i++) {
 602                 if (strcmp(TEST_OWNER_A_ADDRESS,pull_table.out.partners[i].address)==0) {
 603                         ctx->a.max_version      = pull_table.out.partners[i].max_version;
 604                         ctx->a.min_version      = pull_table.out.partners[i].min_version;
 605                 }
 606                 if (strcmp(TEST_OWNER_B_ADDRESS,pull_table.out.partners[i].address)==0) {
 607                         ctx->b.max_version      = pull_table.out.partners[i].max_version;
 608                         ctx->b.min_version      = pull_table.out.partners[i].min_version;
 609                 }
 610                 if (strcmp(TEST_OWNER_X_ADDRESS,pull_table.out.partners[i].address)==0) {
 611                         ctx->x.max_version      = pull_table.out.partners[i].max_version;
 612                         ctx->x.min_version      = pull_table.out.partners[i].min_version;
 613                 }
 614                 if (strcmp(address,pull_table.out.partners[i].address)==0) {
 615                         ctx->c.max_version      = pull_table.out.partners[i].max_version;
 616                         ctx->c.min_version      = pull_table.out.partners[i].min_version;
 617                 }
 618         }
 619
 620         talloc_free(pull_table.out.partners);
 621
 622         ctx->nbtsock = nbt_name_socket_init(ctx, tctx->ev);
 623         if (!ctx->nbtsock) return NULL;
 624
 625         load_interface_list(tctx, tctx->lp_ctx, &ifaces);
 626
 627         ctx->myaddr = socket_address_from_strings(tctx, ctx->nbtsock->sock->backend_name, iface_list_best_ip(ifaces, address), 0);
 628         if (!ctx->myaddr) return NULL;
 629
 630         for (i = 0; i < iface_list_count(ifaces); i++) {
 631                 if (!iface_list_n_is_v4(ifaces, i)) continue;
 632                 if (strcmp(ctx->myaddr->addr, iface_list_n_ip(ifaces, i)) == 0) continue;
 633                 ctx->myaddr2 = socket_address_from_strings(tctx, ctx->nbtsock->sock->backend_name, iface_list_n_ip(ifaces, i), 0);
 634                 if (!ctx->myaddr2) return NULL;
 635                 break;
 636         }
 637
 638         status = socket_listen(ctx->nbtsock->sock, ctx->myaddr, 0, 0);
 639         if (!NT_STATUS_IS_OK(status)) return NULL;
 640
 641         ctx->nbtsock_srv = nbt_name_socket_init(ctx, tctx->ev);
 642         if (!ctx->nbtsock_srv) return NULL;
 643
 644         /* Make a port 137 version of ctx->myaddr */
 645         nbt_srv_addr = socket_address_from_strings(tctx, ctx->nbtsock_srv->sock->backend_name, ctx->myaddr->addr, lpcfg_nbt_port(tctx->lp_ctx));
 646         if (!nbt_srv_addr) return NULL;
 647
 648         /* And if possible, bind to it.  This won't work unless we are root or in sockewrapper */
 649         status = socket_listen(ctx->nbtsock_srv->sock, nbt_srv_addr, 0, 0);
 650         talloc_free(nbt_srv_addr);
 651         if (!NT_STATUS_IS_OK(status)) {
 652                 /* this isn't fatal */
 653                 talloc_free(ctx->nbtsock_srv);
 654                 ctx->nbtsock_srv = NULL;
 655         }
 656
 657         if (ctx->myaddr2 && ctx->nbtsock_srv) {
 658                 ctx->nbtsock2 = nbt_name_socket_init(ctx, tctx->ev);
 659                 if (!ctx->nbtsock2) return NULL;
 660
 661                 status = socket_listen(ctx->nbtsock2->sock, ctx->myaddr2, 0, 0);
 662                 if (!NT_STATUS_IS_OK(status)) return NULL;
 663
 664                 ctx->nbtsock_srv2 = nbt_name_socket_init(ctx, ctx->nbtsock_srv->event_ctx);
 665                 if (!ctx->nbtsock_srv2) return NULL;
 666
 667                 /* Make a port 137 version of ctx->myaddr2 */
 668                 nbt_srv_addr = socket_address_from_strings(tctx,
 669                                                            ctx->nbtsock_srv->sock->backend_name,
 670                                                            ctx->myaddr2->addr,
 671                                                            lpcfg_nbt_port(tctx->lp_ctx));
 672                 if (!nbt_srv_addr) return NULL;
 673
 674                 /* And if possible, bind to it.  This won't work unless we are root or in sockewrapper */
 675                 status = socket_listen(ctx->nbtsock_srv2->sock, ctx->myaddr2, 0, 0);
 676                 talloc_free(nbt_srv_addr);
 677                 if (!NT_STATUS_IS_OK(status)) {
 678                         /* this isn't fatal */
 679                         talloc_free(ctx->nbtsock_srv2);
 680                         ctx->nbtsock_srv2 = NULL;
 681                 }
 682         }
 683
 684         ctx->addresses_best_num = 1;
 685         ctx->addresses_best = talloc_array(ctx, struct wrepl_ip, ctx->addresses_best_num);
 686         if (!ctx->addresses_best) return NULL;
 687         ctx->addresses_best[0].owner    = ctx->b.address;
 688         ctx->addresses_best[0].ip       = ctx->myaddr->addr;
 689
 690
 691         num_ifaces = iface_list_count(ifaces);
 692         ctx->addresses_all = talloc_array(ctx, struct wrepl_ip, num_ifaces);
 693         ctx->addresses_all_num = 0;
 694         if (!ctx->addresses_all) return NULL;
 695         for (i=0; i < num_ifaces; i++) {
 696                 if (!iface_list_n_is_v4(ifaces, i)) continue;
 697                 ctx->addresses_all[i].owner     = ctx->b.address;
 698                 ctx->addresses_all[i].ip        = talloc_strdup(ctx->addresses_all, iface_list_n_ip(ifaces, i));
 699                 ctx->addresses_all_num++;
 700                 if (!ctx->addresses_all[i].ip) return NULL;
 701         }
 702
 703         if (ctx->nbtsock_srv2) {
 704                 ctx->addresses_best2_num = 1;
 705                 ctx->addresses_best2 = talloc_array(ctx, struct wrepl_ip, ctx->addresses_best2_num);
 706                 if (!ctx->addresses_best2) return NULL;
 707                 ctx->addresses_best2[0].owner   = ctx->b.address;
 708                 ctx->addresses_best2[0].ip      = ctx->myaddr2->addr;
 709
 710                 ctx->addresses_mhomed_num = 2;
 711                 ctx->addresses_mhomed = talloc_array(ctx, struct wrepl_ip, ctx->addresses_mhomed_num);
 712                 if (!ctx->addresses_mhomed) return NULL;
 713                 ctx->addresses_mhomed[0].owner  = ctx->b.address;
 714                 ctx->addresses_mhomed[0].ip     = ctx->myaddr->addr;
 715                 ctx->addresses_mhomed[1].owner  = ctx->b.address;
 716                 ctx->addresses_mhomed[1].ip     = ctx->myaddr2->addr;
 717         }
 718
 719         return ctx;
 720 }
 721
 722 static bool test_wrepl_update_one(struct torture_context *tctx,
 723                                                                   struct test_wrepl_conflict_conn *ctx,
 724                                   const struct wrepl_wins_owner *owner,
 725                                   const struct wrepl_wins_name *name)
 726 {
 727         struct wrepl_socket *wrepl_socket;
 728         struct wrepl_associate associate;
 729         struct wrepl_packet update_packet, repl_send;
 730         struct wrepl_table *update;
 731         struct wrepl_wins_owner wrepl_wins_owners[1];
 732         struct wrepl_packet *repl_recv;
 733         struct wrepl_send_reply *send_reply;
 734         struct wrepl_wins_name wrepl_wins_names[1];
 735         uint32_t assoc_ctx;
 736         NTSTATUS status;
 737
 738         wrepl_socket = wrepl_socket_init(ctx, tctx->ev);
 739
 740         status = wrepl_connect(wrepl_socket, wrepl_best_ip(tctx->lp_ctx, ctx->address), ctx->address);
 741         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 742
 743         status = wrepl_associate(wrepl_socket, &associate);
 744         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 745         assoc_ctx = associate.out.assoc_ctx;
 746
 747         /* now send a WREPL_REPL_UPDATE message */
 748         ZERO_STRUCT(update_packet);
 749         update_packet.opcode                    = WREPL_OPCODE_BITS;
 750         update_packet.assoc_ctx                 = assoc_ctx;
 751         update_packet.mess_type                 = WREPL_REPLICATION;
 752         update_packet.message.replication.command       = WREPL_REPL_UPDATE;
 753         update  = &update_packet.message.replication.info.table;
 754
 755         update->partner_count   = ARRAY_SIZE(wrepl_wins_owners);
 756         update->partners        = wrepl_wins_owners;
 757         update->initiator       = "0.0.0.0";
 758
 759         wrepl_wins_owners[0]    = *owner;
 760
 761         status = wrepl_request(wrepl_socket, wrepl_socket,
 762                                &update_packet, &repl_recv);
 763         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 764         CHECK_VALUE(tctx, repl_recv->mess_type, WREPL_REPLICATION);
 765         CHECK_VALUE(tctx, repl_recv->message.replication.command, WREPL_REPL_SEND_REQUEST);
 766
 767         ZERO_STRUCT(repl_send);
 768         repl_send.opcode                        = WREPL_OPCODE_BITS;
 769         repl_send.assoc_ctx                     = assoc_ctx;
 770         repl_send.mess_type                     = WREPL_REPLICATION;
 771         repl_send.message.replication.command   = WREPL_REPL_SEND_REPLY;
 772         send_reply = &repl_send.message.replication.info.reply;
 773
 774         send_reply->num_names   = ARRAY_SIZE(wrepl_wins_names);
 775         send_reply->names       = wrepl_wins_names;
 776
 777         wrepl_wins_names[0]     = *name;
 778
 779         status = wrepl_request(wrepl_socket, wrepl_socket,
 780                                &repl_send, &repl_recv);
 781         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 782         CHECK_VALUE(tctx, repl_recv->mess_type, WREPL_STOP_ASSOCIATION);
 783         CHECK_VALUE(tctx, repl_recv->message.stop.reason, 0);
 784
 785         talloc_free(wrepl_socket);
 786         return true;
 787 }
 788
 789 static bool test_wrepl_is_applied(struct torture_context *tctx,
 790                                                                   struct test_wrepl_conflict_conn *ctx,
 791                                   const struct wrepl_wins_owner *owner,
 792                                   const struct wrepl_wins_name *name,
 793                                   bool expected)
 794 {
 795         NTSTATUS status;
 796         struct wrepl_pull_names pull_names;
 797         struct wrepl_name *names;
 798
 799         pull_names.in.assoc_ctx = ctx->pull_assoc;
 800         pull_names.in.partner   = *owner;
 801         pull_names.in.partner.min_version = pull_names.in.partner.max_version;
 802
 803         status = wrepl_pull_names(ctx->pull, ctx->pull, &pull_names);
 804         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 805         torture_assert(tctx, pull_names.out.num_names == (expected?1:0),
 806                        talloc_asprintf(tctx, "Invalid number of records returned - expected %d got %d", expected, pull_names.out.num_names));
 807
 808         names = pull_names.out.names;
 809
 810         if (expected) {
 811                 uint32_t flags = WREPL_NAME_FLAGS(names[0].type,
 812                                                   names[0].state,
 813                                                   names[0].node,
 814                                                   names[0].is_static);
 815                 char *expected_scope = NULL;
 816                 CHECK_VALUE(tctx, names[0].name.type, name->name->type);
 817                 CHECK_VALUE_STRING(tctx, names[0].name.name, name->name->name);
 818
 819                 if (names[0].name.scope) {
 820                         expected_scope = talloc_strndup(tctx,
 821                                                         name->name->scope,
 822                                                         237);
 823                 }
 824                 CHECK_VALUE_STRING(tctx, names[0].name.scope, expected_scope);
 825                 CHECK_VALUE(tctx, flags, name->flags);
 826                 CHECK_VALUE_UINT64(tctx, names[0].version_id, name->id);
 827
 828                 if (flags & 2) {
 829                         CHECK_VALUE(tctx, names[0].num_addresses,
 830                                     name->addresses.addresses.num_ips);
 831                 } else {
 832                         CHECK_VALUE(tctx, names[0].num_addresses, 1);
 833                         CHECK_VALUE_STRING(tctx, names[0].addresses[0].address,
 834                                            name->addresses.ip);
 835                 }
 836         }
 837         talloc_free(pull_names.out.names);
 838         return true;
 839 }
 840
 841 static bool test_wrepl_mhomed_merged(struct torture_context *tctx,
 842                                                                          struct test_wrepl_conflict_conn *ctx,
 843                                      const struct wrepl_wins_owner *owner1,
 844                                      uint32_t num_ips1, const struct wrepl_ip *ips1,
 845                                      const struct wrepl_wins_owner *owner2,
 846                                      uint32_t num_ips2, const struct wrepl_ip *ips2,
 847                                      const struct wrepl_wins_name *name2)
 848 {
 849         NTSTATUS status;
 850         struct wrepl_pull_names pull_names;
 851         struct wrepl_name *names;
 852         uint32_t flags;
 853         uint32_t i, j;
 854         uint32_t num_ips = num_ips1 + num_ips2;
 855
 856         for (i = 0; i < num_ips2; i++) {
 857                 for (j = 0; j < num_ips1; j++) {
 858                         if (strcmp(ips2[i].ip,ips1[j].ip) == 0) {
 859                                 num_ips--;
 860                                 break;
 861                         }
 862                 }
 863         }
 864
 865         pull_names.in.assoc_ctx = ctx->pull_assoc;
 866         pull_names.in.partner   = *owner2;
 867         pull_names.in.partner.min_version = pull_names.in.partner.max_version;
 868
 869         status = wrepl_pull_names(ctx->pull, ctx->pull, &pull_names);
 870         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 871         CHECK_VALUE(tctx, pull_names.out.num_names, 1);
 872
 873         names = pull_names.out.names;
 874
 875         flags = WREPL_NAME_FLAGS(names[0].type,
 876                                  names[0].state,
 877                                  names[0].node,
 878                                  names[0].is_static);
 879         CHECK_VALUE(tctx, names[0].name.type, name2->name->type);
 880         CHECK_VALUE_STRING(tctx, names[0].name.name, name2->name->name);
 881         CHECK_VALUE_STRING(tctx, names[0].name.scope, name2->name->scope);
 882         CHECK_VALUE(tctx, flags, name2->flags | WREPL_TYPE_MHOMED);
 883         CHECK_VALUE_UINT64(tctx, names[0].version_id, name2->id);
 884
 885         CHECK_VALUE(tctx, names[0].num_addresses, num_ips);
 886
 887         for (i = 0; i < names[0].num_addresses; i++) {
 888                 const char *addr = names[0].addresses[i].address;
 889                 const char *owner = names[0].addresses[i].owner;
 890                 bool found = false;
 891
 892                 for (j = 0; j < num_ips2; j++) {
 893                         if (strcmp(addr, ips2[j].ip) == 0) {
 894                                 found = true;
 895                                 CHECK_VALUE_STRING(tctx, owner, owner2->address);
 896                                 break;
 897                         }
 898                 }
 899
 900                 if (found) continue;
 901
 902                 for (j = 0; j < num_ips1; j++) {
 903                         if (strcmp(addr, ips1[j].ip) == 0) {
 904                                 found = true;
 905                                 CHECK_VALUE_STRING(tctx, owner, owner1->address);
 906                                 break;
 907                         }
 908                 }
 909
 910                 if (found) continue;
 911
 912                 CHECK_VALUE_STRING(tctx, addr, "not found in address list");
 913         }
 914         talloc_free(pull_names.out.names);
 915         return true;
 916 }
 917
 918 static bool test_wrepl_sgroup_merged(struct torture_context *tctx,
 919                                                                          struct test_wrepl_conflict_conn *ctx,
 920                                      struct wrepl_wins_owner *merge_owner,
 921                                      struct wrepl_wins_owner *owner1,
 922                                      uint32_t num_ips1, const struct wrepl_ip *ips1,
 923                                      struct wrepl_wins_owner *owner2,
 924                                      uint32_t num_ips2, const struct wrepl_ip *ips2,
 925                                      const struct wrepl_wins_name *name2)
 926 {
 927         NTSTATUS status;
 928         struct wrepl_pull_names pull_names;
 929         struct wrepl_name *names;
 930         struct wrepl_name *name = NULL;
 931         uint32_t flags;
 932         uint32_t i, j;
 933         uint32_t num_ips = num_ips1 + num_ips2;
 934
 935         if (!merge_owner) {
 936                 merge_owner = &ctx->c;
 937         }
 938
 939         for (i = 0; i < num_ips1; i++) {
 940                 if (owner1 != &ctx->c && strcmp(ips1[i].owner,owner2->address) == 0) {
 941                         num_ips--;
 942                         continue;
 943                 }
 944                 for (j = 0; j < num_ips2; j++) {
 945                         if (strcmp(ips1[i].ip,ips2[j].ip) == 0) {
 946                                 num_ips--;
 947                                 break;
 948                         }
 949                 }
 950         }
 951
 952
 953         pull_names.in.assoc_ctx = ctx->pull_assoc;
 954         pull_names.in.partner   = *merge_owner;
 955         pull_names.in.partner.min_version = pull_names.in.partner.max_version;
 956         pull_names.in.partner.max_version = 0;
 957
 958         status = wrepl_pull_names(ctx->pull, ctx->pull, &pull_names);
 959         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 960
 961         names = pull_names.out.names;
 962
 963         for (i = 0; i < pull_names.out.num_names; i++) {
 964                 if (names[i].name.type != name2->name->type)    continue;
 965                 if (!names[i].name.name) continue;
 966                 if (strcmp(names[i].name.name, name2->name->name) != 0) continue;
 967                 if (names[i].name.scope) continue;
 968
 969                 name = &names[i];
 970         }
 971
 972         if (pull_names.out.num_names > 0) {
 973                 merge_owner->max_version        = names[pull_names.out.num_names-1].version_id;
 974         }
 975
 976         if (!name) {
 977                 torture_comment(tctx, "%s: Name '%s' not found\n", __location__, nbt_name_string(ctx, name2->name));
 978                 return false;
 979         }
 980
 981         flags = WREPL_NAME_FLAGS(name->type,
 982                                  name->state,
 983                                  name->node,
 984                                  name->is_static);
 985         CHECK_VALUE(tctx, name->name.type, name2->name->type);
 986         CHECK_VALUE_STRING(tctx, name->name.name, name2->name->name);
 987         CHECK_VALUE_STRING(tctx, name->name.scope, name2->name->scope);
 988         CHECK_VALUE(tctx, flags, name2->flags);
 989
 990         CHECK_VALUE(tctx, name->num_addresses, num_ips);
 991
 992         for (i = 0; i < name->num_addresses; i++) {
 993                 const char *addr = name->addresses[i].address;
 994                 const char *owner = name->addresses[i].owner;
 995                 bool found = false;
 996
 997                 for (j = 0; j < num_ips2; j++) {
 998                         if (strcmp(addr, ips2[j].ip) == 0) {
 999                                 found = true;
1000                                 CHECK_VALUE_STRING(tctx, owner, ips2[j].owner);
1001                                 break;
1002                         }
1003                 }
1004
1005                 if (found) continue;
1006
1007                 for (j = 0; j < num_ips1; j++) {
1008                         if (strcmp(addr, ips1[j].ip) == 0) {
1009                                 found = true;
1010                                 if (owner1 == &ctx->c) {
1011                                         CHECK_VALUE_STRING(tctx, owner, owner1->address);
1012                                 } else {
1013                                         CHECK_VALUE_STRING(tctx, owner, ips1[j].owner);
1014                                 }
1015                                 break;
1016                         }
1017                 }
1018
1019                 if (found) continue;
1020
1021                 CHECK_VALUE_STRING(tctx, addr, "not found in address list");
1022         }
1023         talloc_free(pull_names.out.names);
1024         return true;
1025 }
1026
1027 static char *test_nbt_winsrepl_scope_string(TALLOC_CTX *mem_ctx, uint8_t count)
1028 {
1029         char *res;
1030         uint8_t i;
1031
1032         res = talloc_array(mem_ctx, char, count+1);
1033         if (res == NULL) {
1034                 return NULL;
1035         }
1036
1037         for (i=0; i < count; i++) {
1038                 res[i] = '0' + (i%10);
1039         }
1040
1041         res[count] = '\0';
1042
1043         talloc_set_name_const(res, res);
1044
1045         return res;
1046 }
1047
1048 static bool test_conflict_same_owner(struct torture_context *tctx,
1049                                                                          struct test_wrepl_conflict_conn *ctx)
1050 {
1051         bool ret = true;
1052         struct wrepl_wins_name wins_name1;
1053         struct wrepl_wins_name wins_name2;
1054         struct wrepl_wins_name *wins_name_tmp;
1055         struct wrepl_wins_name *wins_name_last;
1056         struct wrepl_wins_name *wins_name_cur;
1057         uint32_t i,j;
1058         struct nbt_name names[] = {
1059                 _NBT_NAME("_SAME_OWNER_A", 0x00, NULL),
1060                 _NBT_NAME("_SAME_OWNER_A", 0x00,
1061                           test_nbt_winsrepl_scope_string(tctx, 1)),
1062                 _NBT_NAME("_SAME_OWNER_A", 0x00,
1063                           test_nbt_winsrepl_scope_string(tctx, 2)),
1064                 _NBT_NAME("_SAME_OWNER_A", 0x00,
1065                           test_nbt_winsrepl_scope_string(tctx, 3)),
1066                 _NBT_NAME("_SAME_OWNER_A", 0x00,
1067                           test_nbt_winsrepl_scope_string(tctx, 4)),
1068                 _NBT_NAME("_SAME_OWNER_A", 0x00,
1069                           test_nbt_winsrepl_scope_string(tctx, 5)),
1070                 _NBT_NAME("_SAME_OWNER_A", 0x00,
1071                           test_nbt_winsrepl_scope_string(tctx, 6)),
1072                 _NBT_NAME("_SAME_OWNER_A", 0x00,
1073                           test_nbt_winsrepl_scope_string(tctx, 7)),
1074                 _NBT_NAME("_SAME_OWNER_A", 0x00,
1075                           test_nbt_winsrepl_scope_string(tctx, 8)),
1076                 _NBT_NAME("_SAME_OWNER_A", 0x00,
1077                           test_nbt_winsrepl_scope_string(tctx, 9)),
1078                 _NBT_NAME("_SAME_OWNER_A", 0x00,
1079                           test_nbt_winsrepl_scope_string(tctx, 237)),
1080                 _NBT_NAME("_SAME_OWNER_A", 0x00,
1081                           test_nbt_winsrepl_scope_string(tctx, 238)),
1082                 _NBT_NAME("_SAME_OWNER_A", 0x1C, NULL),
1083         };
1084         struct {
1085                 enum wrepl_name_type type;
1086                 enum wrepl_name_state state;
1087                 enum wrepl_name_node node;
1088                 bool is_static;
1089                 uint32_t num_ips;
1090                 const struct wrepl_ip *ips;
1091         } records[] = {
1092                 {
1093                 .type           = WREPL_TYPE_GROUP,
1094                 .state          = WREPL_STATE_ACTIVE,
1095                 .node           = WREPL_NODE_B,
1096                 .is_static      = false,
1097                 .num_ips        = ARRAY_SIZE(addresses_A_1),
1098                 .ips            = addresses_A_1,
1099                 },{
1100                 .type           = WREPL_TYPE_UNIQUE,
1101                 .state          = WREPL_STATE_ACTIVE,
1102                 .node           = WREPL_NODE_B,
1103                 .is_static      = false,
1104                 .num_ips        = ARRAY_SIZE(addresses_A_1),
1105                 .ips            = addresses_A_1,
1106                 },{
1107                 .type           = WREPL_TYPE_UNIQUE,
1108                 .state          = WREPL_STATE_ACTIVE,
1109                 .node           = WREPL_NODE_B,
1110                 .is_static      = false,
1111                 .num_ips        = ARRAY_SIZE(addresses_A_2),
1112                 .ips            = addresses_A_2,
1113                 },{
1114                 .type           = WREPL_TYPE_UNIQUE,
1115                 .state          = WREPL_STATE_ACTIVE,
1116                 .node           = WREPL_NODE_B,
1117                 .is_static      = true,
1118                 .num_ips        = ARRAY_SIZE(addresses_A_1),
1119                 .ips            = addresses_A_1,
1120                 },{
1121                 .type           = WREPL_TYPE_UNIQUE,
1122                 .state          = WREPL_STATE_ACTIVE,
1123                 .node           = WREPL_NODE_B,
1124                 .is_static      = false,
1125                 .num_ips        = ARRAY_SIZE(addresses_A_2),
1126                 .ips            = addresses_A_2,
1127                 },{
1128                 .type           = WREPL_TYPE_SGROUP,
1129                 .state          = WREPL_STATE_TOMBSTONE,
1130                 .node           = WREPL_NODE_B,
1131                 .is_static      = false,
1132                 .num_ips        = ARRAY_SIZE(addresses_A_2),
1133                 .ips            = addresses_A_2,
1134                 },{
1135                 .type           = WREPL_TYPE_MHOMED,
1136                 .state          = WREPL_STATE_TOMBSTONE,
1137                 .node           = WREPL_NODE_B,
1138                 .is_static      = false,
1139                 .num_ips        = ARRAY_SIZE(addresses_A_1),
1140                 .ips            = addresses_A_1,
1141                 },{
1142                 .type           = WREPL_TYPE_MHOMED,
1143                 .state          = WREPL_STATE_RELEASED,
1144                 .node           = WREPL_NODE_B,
1145                 .is_static      = false,
1146                 .num_ips        = ARRAY_SIZE(addresses_A_2),
1147                 .ips            = addresses_A_2,
1148                 },{
1149                 .type           = WREPL_TYPE_SGROUP,
1150                 .state          = WREPL_STATE_ACTIVE,
1151                 .node           = WREPL_NODE_B,
1152                 .is_static      = false,
1153                 .num_ips        = ARRAY_SIZE(addresses_A_1),
1154                 .ips            = addresses_A_1,
1155                 },{
1156                 .type           = WREPL_TYPE_SGROUP,
1157                 .state          = WREPL_STATE_ACTIVE,
1158                 .node           = WREPL_NODE_B,
1159                 .is_static      = false,
1160                 .num_ips        = ARRAY_SIZE(addresses_A_3_4),
1161                 .ips            = addresses_A_3_4,
1162                 },{
1163                 .type           = WREPL_TYPE_SGROUP,
1164                 .state          = WREPL_STATE_TOMBSTONE,
1165                 .node           = WREPL_NODE_B,
1166                 .is_static      = false,
1167                 .num_ips        = ARRAY_SIZE(addresses_B_3_4),
1168                 .ips            = addresses_B_3_4,
1169                 },{
1170                 /* the last one should always be a unique,tomstone record! */
1171                 .type           = WREPL_TYPE_UNIQUE,
1172                 .state          = WREPL_STATE_TOMBSTONE,
1173                 .node           = WREPL_NODE_B,
1174                 .is_static      = false,
1175                 .num_ips        = ARRAY_SIZE(addresses_A_1),
1176                 .ips            = addresses_A_1,
1177                 }
1178         };
1179
1180         wins_name_tmp   = NULL;
1181         wins_name_last  = &wins_name2;
1182         wins_name_cur   = &wins_name1;
1183
1184         for (j=0; ret && j < ARRAY_SIZE(names); j++) {
1185                 torture_comment(tctx, "Test Replica Conflicts with same owner[%s] for %s\n",
1186                         nbt_name_string(ctx, &names[j]), ctx->a.address);
1187
1188                 for(i=0; ret && i < ARRAY_SIZE(records); i++) {
1189                         wins_name_tmp   = wins_name_last;
1190                         wins_name_last  = wins_name_cur;
1191                         wins_name_cur   = wins_name_tmp;
1192
1193                         if (i > 0) {
1194                                 torture_comment(tctx, "%s,%s%s vs. %s,%s%s with %s ip(s) => %s\n",
1195                                         wrepl_name_type_string(records[i-1].type),
1196                                         wrepl_name_state_string(records[i-1].state),
1197                                         (records[i-1].is_static?",static":""),
1198                                         wrepl_name_type_string(records[i].type),
1199                                         wrepl_name_state_string(records[i].state),
1200                                         (records[i].is_static?",static":""),
1201                                         (records[i-1].ips==records[i].ips?"same":"different"),
1202                                         "REPLACE");
1203                         }
1204
1205                         wins_name_cur->name     = &names[j];
1206                         wins_name_cur->flags    = WREPL_NAME_FLAGS(records[i].type,
1207                                                                    records[i].state,
1208                                                                    records[i].node,
1209                                                                    records[i].is_static);
1210                         wins_name_cur->id       = ++ctx->a.max_version;
1211                         if (wins_name_cur->flags & 2) {
1212                                 wins_name_cur->addresses.addresses.num_ips = records[i].num_ips;
1213                                 wins_name_cur->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
1214                                                                              records[i].ips);
1215                         } else {
1216                                 wins_name_cur->addresses.ip = records[i].ips[0].ip;
1217                         }
1218                         wins_name_cur->unknown  = "255.255.255.255";
1219
1220                         ret &= test_wrepl_update_one(tctx, ctx, &ctx->a,wins_name_cur);
1221                         if (records[i].state == WREPL_STATE_RELEASED) {
1222                                 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->a, wins_name_last, false);
1223                                 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->a, wins_name_cur, false);
1224                         } else {
1225                                 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->a, wins_name_cur, true);
1226                         }
1227
1228                         /* the first one is a cleanup run */
1229                         if (!ret && i == 0) ret = true;
1230
1231                         if (!ret) {
1232                                 torture_comment(tctx, "conflict handled wrong or record[%u]: %s\n", i, __location__);
1233                                 return ret;
1234                         }
1235                 }
1236         }
1237         return ret;
1238 }
1239
1240 static bool test_conflict_different_owner(struct torture_context *tctx,
1241                                                                                   struct test_wrepl_conflict_conn *ctx)
1242 {
1243         bool ret = true;
1244         struct wrepl_wins_name wins_name1;
1245         struct wrepl_wins_name wins_name2;
1246         struct wrepl_wins_name *wins_name_r1;
1247         struct wrepl_wins_name *wins_name_r2;
1248         uint32_t i;
1249         struct {
1250                 const char *line; /* just better debugging */
1251                 struct nbt_name name;
1252                 const char *comment;
1253                 bool extra; /* not the worst case, this is an extra test */
1254                 bool cleanup;
1255                 struct {
1256                         struct wrepl_wins_owner *owner;
1257                         enum wrepl_name_type type;
1258                         enum wrepl_name_state state;
1259                         enum wrepl_name_node node;
1260                         bool is_static;
1261                         uint32_t num_ips;
1262                         const struct wrepl_ip *ips;
1263                         bool apply_expected;
1264                         bool sgroup_merge;
1265                         struct wrepl_wins_owner *merge_owner;
1266                         bool sgroup_cleanup;
1267                 } r1, r2;
1268         } records[] = {
1269         /*
1270          * NOTE: the first record and the last applied one
1271          *       needs to be from the same owner,
1272          *       to not conflict in the next smbtorture run!!!
1273          */
1274         {
1275                 .line   = __location__,
1276                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1277                 .cleanup= true,
1278                 .r1     = {
1279                         .owner          = &ctx->b,
1280                         .type           = WREPL_TYPE_UNIQUE,
1281                         .state          = WREPL_STATE_TOMBSTONE,
1282                         .node           = WREPL_NODE_B,
1283                         .is_static      = false,
1284                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1285                         .ips            = addresses_B_1,
1286                         .apply_expected = true /* ignored */
1287                 },
1288                 .r2     = {
1289                         .owner          = &ctx->a,
1290                         .type           = WREPL_TYPE_UNIQUE,
1291                         .state          = WREPL_STATE_TOMBSTONE,
1292                         .node           = WREPL_NODE_B,
1293                         .is_static      = false,
1294                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1295                         .ips            = addresses_A_1,
1296                         .apply_expected = true /* ignored */
1297                 }
1298         },
1299
1300 /*
1301  * unique vs unique section
1302  */
1303         /*
1304          * unique,active vs. unique,active
1305          * => should be replaced
1306          */
1307         {
1308                 .line   = __location__,
1309                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1310                 .r1     = {
1311                         .owner          = &ctx->a,
1312                         .type           = WREPL_TYPE_UNIQUE,
1313                         .state          = WREPL_STATE_ACTIVE,
1314                         .node           = WREPL_NODE_B,
1315                         .is_static      = false,
1316                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1317                         .ips            = addresses_A_1,
1318                         .apply_expected = true
1319                 },
1320                 .r2     = {
1321                         .owner          = &ctx->b,
1322                         .type           = WREPL_TYPE_UNIQUE,
1323                         .state          = WREPL_STATE_ACTIVE,
1324                         .node           = WREPL_NODE_B,
1325                         .is_static      = false,
1326                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1327                         .ips            = addresses_B_1,
1328                         .apply_expected = true
1329                 }
1330         },
1331
1332         /*
1333          * unique,active vs. unique,tombstone
1334          * => should NOT be replaced
1335          */
1336         {
1337                 .line   = __location__,
1338                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1339                 .r1     = {
1340                         .owner          = &ctx->b,
1341                         .type           = WREPL_TYPE_UNIQUE,
1342                         .state          = WREPL_STATE_ACTIVE,
1343                         .node           = WREPL_NODE_B,
1344                         .is_static      = false,
1345                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1346                         .ips            = addresses_B_1,
1347                         .apply_expected = true
1348                 },
1349                 .r2     = {
1350                         .owner          = &ctx->a,
1351                         .type           = WREPL_TYPE_UNIQUE,
1352                         .state          = WREPL_STATE_TOMBSTONE,
1353                         .node           = WREPL_NODE_B,
1354                         .is_static      = false,
1355                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1356                         .ips            = addresses_B_1,
1357                         .apply_expected = false
1358                 }
1359         },
1360
1361         /*
1362          * unique,released vs. unique,active
1363          * => should be replaced
1364          */
1365         {
1366                 .line   = __location__,
1367                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1368                 .r1     = {
1369                         .owner          = &ctx->b,
1370                         .type           = WREPL_TYPE_UNIQUE,
1371                         .state          = WREPL_STATE_RELEASED,
1372                         .node           = WREPL_NODE_B,
1373                         .is_static      = false,
1374                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1375                         .ips            = addresses_B_1,
1376                         .apply_expected = false
1377                 },
1378                 .r2     = {
1379                         .owner          = &ctx->a,
1380                         .type           = WREPL_TYPE_UNIQUE,
1381                         .state          = WREPL_STATE_ACTIVE,
1382                         .node           = WREPL_NODE_B,
1383                         .is_static      = false,
1384                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1385                         .ips            = addresses_A_1,
1386                         .apply_expected = true
1387                 }
1388         },
1389
1390         /*
1391          * unique,released vs. unique,tombstone
1392          * => should be replaced
1393          */
1394         {
1395                 .line   = __location__,
1396                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1397                 .r1     = {
1398                         .owner          = &ctx->a,
1399                         .type           = WREPL_TYPE_UNIQUE,
1400                         .state          = WREPL_STATE_RELEASED,
1401                         .node           = WREPL_NODE_B,
1402                         .is_static      = false,
1403                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1404                         .ips            = addresses_A_1,
1405                         .apply_expected = false
1406                 },
1407                 .r2     = {
1408                         .owner          = &ctx->b,
1409                         .type           = WREPL_TYPE_UNIQUE,
1410                         .state          = WREPL_STATE_TOMBSTONE,
1411                         .node           = WREPL_NODE_B,
1412                         .is_static      = false,
1413                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1414                         .ips            = addresses_B_1,
1415                         .apply_expected = true
1416                 }
1417         },
1418
1419         /*
1420          * unique,tombstone vs. unique,active
1421          * => should be replaced
1422          */
1423         {
1424                 .line   = __location__,
1425                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1426                 .r1     = {
1427                         .owner          = &ctx->b,
1428                         .type           = WREPL_TYPE_UNIQUE,
1429                         .state          = WREPL_STATE_TOMBSTONE,
1430                         .node           = WREPL_NODE_B,
1431                         .is_static      = false,
1432                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1433                         .ips            = addresses_B_1,
1434                         .apply_expected = true
1435                 },
1436                 .r2     = {
1437                         .owner          = &ctx->a,
1438                         .type           = WREPL_TYPE_UNIQUE,
1439                         .state          = WREPL_STATE_ACTIVE,
1440                         .node           = WREPL_NODE_B,
1441                         .is_static      = false,
1442                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1443                         .ips            = addresses_A_1,
1444                         .apply_expected = true
1445                 }
1446         },
1447
1448         /*
1449          * unique,tombstone vs. unique,tombstone
1450          * => should be replaced
1451          */
1452         {
1453                 .line   = __location__,
1454                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1455                 .r1     = {
1456                         .owner          = &ctx->a,
1457                         .type           = WREPL_TYPE_UNIQUE,
1458                         .state          = WREPL_STATE_TOMBSTONE,
1459                         .node           = WREPL_NODE_B,
1460                         .is_static      = false,
1461                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1462                         .ips            = addresses_A_1,
1463                         .apply_expected = true
1464                 },
1465                 .r2     = {
1466                         .owner          = &ctx->b,
1467                         .type           = WREPL_TYPE_UNIQUE,
1468                         .state          = WREPL_STATE_TOMBSTONE,
1469                         .node           = WREPL_NODE_B,
1470                         .is_static      = false,
1471                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1472                         .ips            = addresses_B_1,
1473                         .apply_expected = true
1474                 }
1475         },
1476
1477
1478 /*
1479  * unique vs normal groups section,
1480  */
1481         /*
1482          * unique,active vs. group,active
1483          * => should be replaced
1484          */
1485         {
1486                 .line   = __location__,
1487                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1488                 .r1     = {
1489                         .owner          = &ctx->b,
1490                         .type           = WREPL_TYPE_UNIQUE,
1491                         .state          = WREPL_STATE_ACTIVE,
1492                         .node           = WREPL_NODE_B,
1493                         .is_static      = false,
1494                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1495                         .ips            = addresses_B_1,
1496                         .apply_expected = true
1497                 },
1498                 .r2     = {
1499                         .owner          = &ctx->a,
1500                         .type           = WREPL_TYPE_GROUP,
1501                         .state          = WREPL_STATE_ACTIVE,
1502                         .node           = WREPL_NODE_B,
1503                         .is_static      = false,
1504                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1505                         .ips            = addresses_A_1,
1506                         .apply_expected = true
1507                 }
1508         },
1509
1510         /*
1511          * unique,active vs. group,tombstone
1512          * => should NOT be replaced
1513          */
1514         {
1515                 .line   = __location__,
1516                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1517                 .r1     = {
1518                         .owner          = &ctx->a,
1519                         .type           = WREPL_TYPE_UNIQUE,
1520                         .state          = WREPL_STATE_ACTIVE,
1521                         .node           = WREPL_NODE_B,
1522                         .is_static      = false,
1523                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1524                         .ips            = addresses_A_1,
1525                         .apply_expected = true
1526                 },
1527                 .r2     = {
1528                         .owner          = &ctx->b,
1529                         .type           = WREPL_TYPE_GROUP,
1530                         .state          = WREPL_STATE_TOMBSTONE,
1531                         .node           = WREPL_NODE_B,
1532                         .is_static      = false,
1533                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1534                         .ips            = addresses_A_1,
1535                         .apply_expected = false
1536                 }
1537         },
1538
1539         /*
1540          * unique,released vs. group,active
1541          * => should be replaced
1542          */
1543         {
1544                 .line   = __location__,
1545                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1546                 .r1     = {
1547                         .owner          = &ctx->a,
1548                         .type           = WREPL_TYPE_UNIQUE,
1549                         .state          = WREPL_STATE_RELEASED,
1550                         .node           = WREPL_NODE_B,
1551                         .is_static      = false,
1552                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1553                         .ips            = addresses_A_1,
1554                         .apply_expected = false
1555                 },
1556                 .r2     = {
1557                         .owner          = &ctx->b,
1558                         .type           = WREPL_TYPE_GROUP,
1559                         .state          = WREPL_STATE_ACTIVE,
1560                         .node           = WREPL_NODE_B,
1561                         .is_static      = false,
1562                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1563                         .ips            = addresses_B_1,
1564                         .apply_expected = true
1565                 }
1566         },
1567
1568         /*
1569          * unique,released vs. group,tombstone
1570          * => should be replaced
1571          */
1572         {
1573                 .line   = __location__,
1574                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1575                 .r1     = {
1576                         .owner          = &ctx->b,
1577                         .type           = WREPL_TYPE_UNIQUE,
1578                         .state          = WREPL_STATE_RELEASED,
1579                         .node           = WREPL_NODE_B,
1580                         .is_static      = false,
1581                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1582                         .ips            = addresses_B_1,
1583                         .apply_expected = false
1584                 },
1585                 .r2     = {
1586                         .owner          = &ctx->a,
1587                         .type           = WREPL_TYPE_GROUP,
1588                         .state          = WREPL_STATE_TOMBSTONE,
1589                         .node           = WREPL_NODE_B,
1590                         .is_static      = false,
1591                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1592                         .ips            = addresses_A_1,
1593                         .apply_expected = true
1594                 }
1595         },
1596
1597         /*
1598          * unique,tombstone vs. group,active
1599          * => should be replaced
1600          */
1601         {
1602                 .line   = __location__,
1603                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1604                 .r1     = {
1605                         .owner          = &ctx->a,
1606                         .type           = WREPL_TYPE_UNIQUE,
1607                         .state          = WREPL_STATE_TOMBSTONE,
1608                         .node           = WREPL_NODE_B,
1609                         .is_static      = false,
1610                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1611                         .ips            = addresses_A_1,
1612                         .apply_expected = true
1613                 },
1614                 .r2     = {
1615                         .owner          = &ctx->b,
1616                         .type           = WREPL_TYPE_GROUP,
1617                         .state          = WREPL_STATE_ACTIVE,
1618                         .node           = WREPL_NODE_B,
1619                         .is_static      = false,
1620                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1621                         .ips            = addresses_B_1,
1622                         .apply_expected = true
1623                 }
1624         },
1625
1626         /*
1627          * unique,tombstone vs. group,tombstone
1628          * => should be replaced
1629          */
1630         {
1631                 .line   = __location__,
1632                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1633                 .r1     = {
1634                         .owner          = &ctx->b,
1635                         .type           = WREPL_TYPE_UNIQUE,
1636                         .state          = WREPL_STATE_TOMBSTONE,
1637                         .node           = WREPL_NODE_B,
1638                         .is_static      = false,
1639                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1640                         .ips            = addresses_B_1,
1641                         .apply_expected = true
1642                 },
1643                 .r2     = {
1644                         .owner          = &ctx->a,
1645                         .type           = WREPL_TYPE_GROUP,
1646                         .state          = WREPL_STATE_TOMBSTONE,
1647                         .node           = WREPL_NODE_B,
1648                         .is_static      = false,
1649                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1650                         .ips            = addresses_A_1,
1651                         .apply_expected = true
1652                 }
1653         },
1654
1655 /*
1656  * unique vs special groups section,
1657  */
1658         /*
1659          * unique,active vs. sgroup,active
1660          * => should NOT be replaced
1661          */
1662         {
1663                 .line   = __location__,
1664                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1665                 .r1     = {
1666                         .owner          = &ctx->a,
1667                         .type           = WREPL_TYPE_UNIQUE,
1668                         .state          = WREPL_STATE_ACTIVE,
1669                         .node           = WREPL_NODE_B,
1670                         .is_static      = false,
1671                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1672                         .ips            = addresses_A_1,
1673                         .apply_expected = true
1674                 },
1675                 .r2     = {
1676                         .owner          = &ctx->b,
1677                         .type           = WREPL_TYPE_SGROUP,
1678                         .state          = WREPL_STATE_ACTIVE,
1679                         .node           = WREPL_NODE_B,
1680                         .is_static      = false,
1681                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1682                         .ips            = addresses_A_1,
1683                         .apply_expected = false
1684                 }
1685         },
1686
1687         /*
1688          * unique,active vs. sgroup,tombstone
1689          * => should NOT be replaced
1690          */
1691         {
1692                 .line   = __location__,
1693                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1694                 .r1     = {
1695                         .owner          = &ctx->a,
1696                         .type           = WREPL_TYPE_UNIQUE,
1697                         .state          = WREPL_STATE_ACTIVE,
1698                         .node           = WREPL_NODE_B,
1699                         .is_static      = false,
1700                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1701                         .ips            = addresses_A_1,
1702                         .apply_expected = true
1703                 },
1704                 .r2     = {
1705                         .owner          = &ctx->b,
1706                         .type           = WREPL_TYPE_SGROUP,
1707                         .state          = WREPL_STATE_TOMBSTONE,
1708                         .node           = WREPL_NODE_B,
1709                         .is_static      = false,
1710                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1711                         .ips            = addresses_A_1,
1712                         .apply_expected = false
1713                 }
1714         },
1715
1716         /*
1717          * unique,released vs. sgroup,active
1718          * => should be replaced
1719          */
1720         {
1721                 .line   = __location__,
1722                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1723                 .r1     = {
1724                         .owner          = &ctx->a,
1725                         .type           = WREPL_TYPE_UNIQUE,
1726                         .state          = WREPL_STATE_RELEASED,
1727                         .node           = WREPL_NODE_B,
1728                         .is_static      = false,
1729                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1730                         .ips            = addresses_A_1,
1731                         .apply_expected = false
1732                 },
1733                 .r2     = {
1734                         .owner          = &ctx->b,
1735                         .type           = WREPL_TYPE_SGROUP,
1736                         .state          = WREPL_STATE_ACTIVE,
1737                         .node           = WREPL_NODE_B,
1738                         .is_static      = false,
1739                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
1740                         .ips            = addresses_B_3_4,
1741                         .apply_expected = true
1742                 }
1743         },
1744
1745         /*
1746          * unique,released vs. sgroup,tombstone
1747          * => should be replaced
1748          */
1749         {
1750                 .line   = __location__,
1751                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1752                 .r1     = {
1753                         .owner          = &ctx->b,
1754                         .type           = WREPL_TYPE_UNIQUE,
1755                         .state          = WREPL_STATE_RELEASED,
1756                         .node           = WREPL_NODE_B,
1757                         .is_static      = false,
1758                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1759                         .ips            = addresses_B_1,
1760                         .apply_expected = false
1761                 },
1762                 .r2     = {
1763                         .owner          = &ctx->a,
1764                         .type           = WREPL_TYPE_SGROUP,
1765                         .state          = WREPL_STATE_TOMBSTONE,
1766                         .node           = WREPL_NODE_B,
1767                         .is_static      = false,
1768                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
1769                         .ips            = addresses_A_3_4,
1770                         .apply_expected = true
1771                 }
1772         },
1773
1774         /*
1775          * unique,tombstone vs. sgroup,active
1776          * => should be replaced
1777          */
1778         {
1779                 .line   = __location__,
1780                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1781                 .r1     = {
1782                         .owner          = &ctx->a,
1783                         .type           = WREPL_TYPE_UNIQUE,
1784                         .state          = WREPL_STATE_TOMBSTONE,
1785                         .node           = WREPL_NODE_B,
1786                         .is_static      = false,
1787                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1788                         .ips            = addresses_A_1,
1789                         .apply_expected = true
1790                 },
1791                 .r2     = {
1792                         .owner          = &ctx->b,
1793                         .type           = WREPL_TYPE_SGROUP,
1794                         .state          = WREPL_STATE_ACTIVE,
1795                         .node           = WREPL_NODE_B,
1796                         .is_static      = false,
1797                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
1798                         .ips            = addresses_B_3_4,
1799                         .apply_expected = true
1800                 }
1801         },
1802
1803         /*
1804          * unique,tombstone vs. sgroup,tombstone
1805          * => should be replaced
1806          */
1807         {
1808                 .line   = __location__,
1809                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1810                 .r1     = {
1811                         .owner          = &ctx->b,
1812                         .type           = WREPL_TYPE_UNIQUE,
1813                         .state          = WREPL_STATE_TOMBSTONE,
1814                         .node           = WREPL_NODE_B,
1815                         .is_static      = false,
1816                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1817                         .ips            = addresses_B_1,
1818                         .apply_expected = true
1819                 },
1820                 .r2     = {
1821                         .owner          = &ctx->a,
1822                         .type           = WREPL_TYPE_SGROUP,
1823                         .state          = WREPL_STATE_TOMBSTONE,
1824                         .node           = WREPL_NODE_B,
1825                         .is_static      = false,
1826                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
1827                         .ips            = addresses_A_3_4,
1828                         .apply_expected = true
1829                 }
1830         },
1831
1832 /*
1833  * unique vs multi homed section,
1834  */
1835         /*
1836          * unique,active vs. mhomed,active
1837          * => should be replaced
1838          */
1839         {
1840                 .line   = __location__,
1841                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1842                 .r1     = {
1843                         .owner          = &ctx->a,
1844                         .type           = WREPL_TYPE_UNIQUE,
1845                         .state          = WREPL_STATE_ACTIVE,
1846                         .node           = WREPL_NODE_B,
1847                         .is_static      = false,
1848                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1849                         .ips            = addresses_A_1,
1850                         .apply_expected = true
1851                 },
1852                 .r2     = {
1853                         .owner          = &ctx->b,
1854                         .type           = WREPL_TYPE_MHOMED,
1855                         .state          = WREPL_STATE_ACTIVE,
1856                         .node           = WREPL_NODE_B,
1857                         .is_static      = false,
1858                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
1859                         .ips            = addresses_B_3_4,
1860                         .apply_expected = true
1861                 }
1862         },
1863
1864         /*
1865          * unique,active vs. mhomed,tombstone
1866          * => should NOT be replaced
1867          */
1868         {
1869                 .line   = __location__,
1870                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1871                 .r1     = {
1872                         .owner          = &ctx->b,
1873                         .type           = WREPL_TYPE_UNIQUE,
1874                         .state          = WREPL_STATE_ACTIVE,
1875                         .node           = WREPL_NODE_B,
1876                         .is_static      = false,
1877                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
1878                         .ips            = addresses_B_3_4,
1879                         .apply_expected = true
1880                 },
1881                 .r2     = {
1882                         .owner          = &ctx->a,
1883                         .type           = WREPL_TYPE_MHOMED,
1884                         .state          = WREPL_STATE_TOMBSTONE,
1885                         .node           = WREPL_NODE_B,
1886                         .is_static      = false,
1887                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
1888                         .ips            = addresses_B_3_4,
1889                         .apply_expected = false
1890                 }
1891         },
1892
1893         /*
1894          * unique,released vs. mhomed,active
1895          * => should be replaced
1896          */
1897         {
1898                 .line   = __location__,
1899                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1900                 .r1     = {
1901                         .owner          = &ctx->b,
1902                         .type           = WREPL_TYPE_UNIQUE,
1903                         .state          = WREPL_STATE_RELEASED,
1904                         .node           = WREPL_NODE_B,
1905                         .is_static      = false,
1906                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1907                         .ips            = addresses_B_1,
1908                         .apply_expected = false
1909                 },
1910                 .r2     = {
1911                         .owner          = &ctx->a,
1912                         .type           = WREPL_TYPE_MHOMED,
1913                         .state          = WREPL_STATE_ACTIVE,
1914                         .node           = WREPL_NODE_B,
1915                         .is_static      = false,
1916                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
1917                         .ips            = addresses_A_3_4,
1918                         .apply_expected = true
1919                 }
1920         },
1921
1922         /*
1923          * unique,released vs. mhomed,tombstone
1924          * => should be replaced
1925          */
1926         {
1927                 .line   = __location__,
1928                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1929                 .r1     = {
1930                         .owner          = &ctx->a,
1931                         .type           = WREPL_TYPE_UNIQUE,
1932                         .state          = WREPL_STATE_RELEASED,
1933                         .node           = WREPL_NODE_B,
1934                         .is_static      = false,
1935                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1936                         .ips            = addresses_A_1,
1937                         .apply_expected = false
1938                 },
1939                 .r2     = {
1940                         .owner          = &ctx->b,
1941                         .type           = WREPL_TYPE_MHOMED,
1942                         .state          = WREPL_STATE_TOMBSTONE,
1943                         .node           = WREPL_NODE_B,
1944                         .is_static      = false,
1945                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
1946                         .ips            = addresses_B_3_4,
1947                         .apply_expected = true
1948                 }
1949         },
1950
1951         /*
1952          * unique,tombstone vs. mhomed,active
1953          * => should be replaced
1954          */
1955         {
1956                 .line   = __location__,
1957                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1958                 .r1     = {
1959                         .owner          = &ctx->b,
1960                         .type           = WREPL_TYPE_UNIQUE,
1961                         .state          = WREPL_STATE_TOMBSTONE,
1962                         .node           = WREPL_NODE_B,
1963                         .is_static      = false,
1964                         .num_ips        = ARRAY_SIZE(addresses_B_1),
1965                         .ips            = addresses_B_1,
1966                         .apply_expected = true
1967                 },
1968                 .r2     = {
1969                         .owner          = &ctx->a,
1970                         .type           = WREPL_TYPE_MHOMED,
1971                         .state          = WREPL_STATE_ACTIVE,
1972                         .node           = WREPL_NODE_B,
1973                         .is_static      = false,
1974                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
1975                         .ips            = addresses_A_3_4,
1976                         .apply_expected = true
1977                 }
1978         },
1979
1980         /*
1981          * unique,tombstone vs. mhomed,tombstone
1982          * => should be replaced
1983          */
1984         {
1985                 .line   = __location__,
1986                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1987                 .r1     = {
1988                         .owner          = &ctx->a,
1989                         .type           = WREPL_TYPE_UNIQUE,
1990                         .state          = WREPL_STATE_TOMBSTONE,
1991                         .node           = WREPL_NODE_B,
1992                         .is_static      = false,
1993                         .num_ips        = ARRAY_SIZE(addresses_A_1),
1994                         .ips            = addresses_A_1,
1995                         .apply_expected = true
1996                 },
1997                 .r2     = {
1998                         .owner          = &ctx->b,
1999                         .type           = WREPL_TYPE_MHOMED,
2000                         .state          = WREPL_STATE_TOMBSTONE,
2001                         .node           = WREPL_NODE_B,
2002                         .is_static      = false,
2003                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
2004                         .ips            = addresses_B_3_4,
2005                         .apply_expected = true
2006                 }
2007         },
2008
2009 /*
2010  * normal groups vs unique section,
2011  */
2012         /*
2013          * group,active vs. unique,active
2014          * => should NOT be replaced
2015          */
2016         {
2017                 .line   = __location__,
2018                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2019                 .r1     = {
2020                         .owner          = &ctx->a,
2021                         .type           = WREPL_TYPE_GROUP,
2022                         .state          = WREPL_STATE_ACTIVE,
2023                         .node           = WREPL_NODE_B,
2024                         .is_static      = false,
2025                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2026                         .ips            = addresses_A_1,
2027                         .apply_expected = true
2028                 },
2029                 .r2     = {
2030                         .owner          = &ctx->b,
2031                         .type           = WREPL_TYPE_UNIQUE,
2032                         .state          = WREPL_STATE_ACTIVE,
2033                         .node           = WREPL_NODE_B,
2034                         .is_static      = false,
2035                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2036                         .ips            = addresses_A_1,
2037                         .apply_expected = false
2038                 }
2039         },
2040
2041         /*
2042          * group,active vs. unique,tombstone
2043          * => should NOT be replaced
2044          */
2045         {
2046                 .line   = __location__,
2047                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2048                 .r1     = {
2049                         .owner          = &ctx->a,
2050                         .type           = WREPL_TYPE_GROUP,
2051                         .state          = WREPL_STATE_ACTIVE,
2052                         .node           = WREPL_NODE_B,
2053                         .is_static      = false,
2054                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2055                         .ips            = addresses_A_1,
2056                         .apply_expected = true
2057                 },
2058                 .r2     = {
2059                         .owner          = &ctx->b,
2060                         .type           = WREPL_TYPE_UNIQUE,
2061                         .state          = WREPL_STATE_TOMBSTONE,
2062                         .node           = WREPL_NODE_B,
2063                         .is_static      = false,
2064                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2065                         .ips            = addresses_A_1,
2066                         .apply_expected = false
2067                 }
2068         },
2069
2070         /*
2071          * group,released vs. unique,active
2072          * => should NOT be replaced
2073          */
2074         {
2075                 .line   = __location__,
2076                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2077                 .r1     = {
2078                         .owner          = &ctx->a,
2079                         .type           = WREPL_TYPE_GROUP,
2080                         .state          = WREPL_STATE_RELEASED,
2081                         .node           = WREPL_NODE_B,
2082                         .is_static      = false,
2083                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2084                         .ips            = addresses_A_1,
2085                         .apply_expected = false
2086                 },
2087                 .r2     = {
2088                         .owner          = &ctx->b,
2089                         .type           = WREPL_TYPE_UNIQUE,
2090                         .state          = WREPL_STATE_ACTIVE,
2091                         .node           = WREPL_NODE_B,
2092                         .is_static      = false,
2093                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2094                         .ips            = addresses_A_1,
2095                         .apply_expected = false
2096                 }
2097         },
2098
2099         /*
2100          * group,released vs. unique,tombstone
2101          * => should NOT be replaced
2102          */
2103         {
2104                 .line   = __location__,
2105                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2106                 .r1     = {
2107                         .owner          = &ctx->a,
2108                         .type           = WREPL_TYPE_GROUP,
2109                         .state          = WREPL_STATE_RELEASED,
2110                         .node           = WREPL_NODE_B,
2111                         .is_static      = false,
2112                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2113                         .ips            = addresses_A_1,
2114                         .apply_expected = false
2115                 },
2116                 .r2     = {
2117                         .owner          = &ctx->b,
2118                         .type           = WREPL_TYPE_UNIQUE,
2119                         .state          = WREPL_STATE_TOMBSTONE,
2120                         .node           = WREPL_NODE_B,
2121                         .is_static      = false,
2122                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2123                         .ips            = addresses_A_1,
2124                         .apply_expected = false
2125                 }
2126         },
2127
2128         /*
2129          * group,tombstone vs. unique,active
2130          * => should NOT be replaced
2131          */
2132         {
2133                 .line   = __location__,
2134                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2135                 .r1     = {
2136                         .owner          = &ctx->a,
2137                         .type           = WREPL_TYPE_GROUP,
2138                         .state          = WREPL_STATE_TOMBSTONE,
2139                         .node           = WREPL_NODE_B,
2140                         .is_static      = false,
2141                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2142                         .ips            = addresses_A_1,
2143                         .apply_expected = true
2144                 },
2145                 .r2     = {
2146                         .owner          = &ctx->b,
2147                         .type           = WREPL_TYPE_UNIQUE,
2148                         .state          = WREPL_STATE_ACTIVE,
2149                         .node           = WREPL_NODE_B,
2150                         .is_static      = false,
2151                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2152                         .ips            = addresses_A_1,
2153                         .apply_expected = false
2154                 }
2155         },
2156
2157         /*
2158          * group,tombstone vs. unique,tombstone
2159          * => should NOT be replaced
2160          */
2161         {
2162                 .line   = __location__,
2163                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2164                 .r1     = {
2165                         .owner          = &ctx->a,
2166                         .type           = WREPL_TYPE_GROUP,
2167                         .state          = WREPL_STATE_TOMBSTONE,
2168                         .node           = WREPL_NODE_B,
2169                         .is_static      = false,
2170                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2171                         .ips            = addresses_A_1,
2172                         .apply_expected = true
2173                 },
2174                 .r2     = {
2175                         .owner          = &ctx->b,
2176                         .type           = WREPL_TYPE_UNIQUE,
2177                         .state          = WREPL_STATE_TOMBSTONE,
2178                         .node           = WREPL_NODE_B,
2179                         .is_static      = false,
2180                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2181                         .ips            = addresses_A_1,
2182                         .apply_expected = false
2183                 }
2184         },
2185
2186 /*
2187  * normal groups vs normal groups section,
2188  */
2189         /*
2190          * group,active vs. group,active
2191          * => should NOT be replaced
2192          */
2193         {
2194                 .line   = __location__,
2195                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2196                 .r1     = {
2197                         .owner          = &ctx->a,
2198                         .type           = WREPL_TYPE_GROUP,
2199                         .state          = WREPL_STATE_ACTIVE,
2200                         .node           = WREPL_NODE_B,
2201                         .is_static      = false,
2202                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2203                         .ips            = addresses_A_1,
2204                         .apply_expected = true
2205                 },
2206                 .r2     = {
2207                         .owner          = &ctx->b,
2208                         .type           = WREPL_TYPE_GROUP,
2209                         .state          = WREPL_STATE_ACTIVE,
2210                         .node           = WREPL_NODE_B,
2211                         .is_static      = false,
2212                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2213                         .ips            = addresses_A_1,
2214                         .apply_expected = false
2215                 }
2216         },
2217
2218         /*
2219          * group,active vs. group,tombstone
2220          * => should NOT be replaced
2221          */
2222         {
2223                 .line   = __location__,
2224                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2225                 .r1     = {
2226                         .owner          = &ctx->a,
2227                         .type           = WREPL_TYPE_GROUP,
2228                         .state          = WREPL_STATE_ACTIVE,
2229                         .node           = WREPL_NODE_B,
2230                         .is_static      = false,
2231                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2232                         .ips            = addresses_A_1,
2233                         .apply_expected = true
2234                 },
2235                 .r2     = {
2236                         .owner          = &ctx->b,
2237                         .type           = WREPL_TYPE_GROUP,
2238                         .state          = WREPL_STATE_TOMBSTONE,
2239                         .node           = WREPL_NODE_B,
2240                         .is_static      = false,
2241                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2242                         .ips            = addresses_A_1,
2243                         .apply_expected = false
2244                 }
2245         },
2246
2247         /*
2248          * group,released vs. group,active
2249          * => should be replaced
2250          */
2251         {
2252                 .line   = __location__,
2253                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2254                 .r1     = {
2255                         .owner          = &ctx->a,
2256                         .type           = WREPL_TYPE_GROUP,
2257                         .state          = WREPL_STATE_RELEASED,
2258                         .node           = WREPL_NODE_B,
2259                         .is_static      = false,
2260                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2261                         .ips            = addresses_A_1,
2262                         .apply_expected = false
2263                 },
2264                 .r2     = {
2265                         .owner          = &ctx->b,
2266                         .type           = WREPL_TYPE_GROUP,
2267                         .state          = WREPL_STATE_ACTIVE,
2268                         .node           = WREPL_NODE_B,
2269                         .is_static      = false,
2270                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2271                         .ips            = addresses_B_1,
2272                         .apply_expected = true
2273                 }
2274         },
2275
2276         /*
2277          * group,released vs. group,tombstone
2278          * => should be replaced
2279          */
2280         {
2281                 .line   = __location__,
2282                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2283                 .r1     = {
2284                         .owner          = &ctx->a,
2285                         .type           = WREPL_TYPE_GROUP,
2286                         .state          = WREPL_STATE_RELEASED,
2287                         .node           = WREPL_NODE_B,
2288                         .is_static      = false,
2289                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2290                         .ips            = addresses_A_1,
2291                         .apply_expected = false
2292                 },
2293                 .r2     = {
2294                         .owner          = &ctx->b,
2295                         .type           = WREPL_TYPE_GROUP,
2296                         .state          = WREPL_STATE_TOMBSTONE,
2297                         .node           = WREPL_NODE_B,
2298                         .is_static      = false,
2299                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2300                         .ips            = addresses_B_1,
2301                         .apply_expected = true
2302                 }
2303         },
2304
2305         /*
2306          * group,tombstone vs. group,active
2307          * => should be replaced
2308          */
2309         {
2310                 .line   = __location__,
2311                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2312                 .r1     = {
2313                         .owner          = &ctx->b,
2314                         .type           = WREPL_TYPE_GROUP,
2315                         .state          = WREPL_STATE_TOMBSTONE,
2316                         .node           = WREPL_NODE_B,
2317                         .is_static      = false,
2318                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2319                         .ips            = addresses_B_1,
2320                         .apply_expected = true
2321                 },
2322                 .r2     = {
2323                         .owner          = &ctx->a,
2324                         .type           = WREPL_TYPE_GROUP,
2325                         .state          = WREPL_STATE_ACTIVE,
2326                         .node           = WREPL_NODE_B,
2327                         .is_static      = false,
2328                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2329                         .ips            = addresses_A_1,
2330                         .apply_expected = true
2331                 }
2332         },
2333
2334         /*
2335          * group,tombstone vs. group,tombstone
2336          * => should be replaced
2337          */
2338         {
2339                 .line   = __location__,
2340                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2341                 .r1     = {
2342                         .owner          = &ctx->a,
2343                         .type           = WREPL_TYPE_GROUP,
2344                         .state          = WREPL_STATE_TOMBSTONE,
2345                         .node           = WREPL_NODE_B,
2346                         .is_static      = false,
2347                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2348                         .ips            = addresses_A_1,
2349                         .apply_expected = true
2350                 },
2351                 .r2     = {
2352                         .owner          = &ctx->b,
2353                         .type           = WREPL_TYPE_GROUP,
2354                         .state          = WREPL_STATE_TOMBSTONE,
2355                         .node           = WREPL_NODE_B,
2356                         .is_static      = false,
2357                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2358                         .ips            = addresses_B_1,
2359                         .apply_expected = true
2360                 }
2361         },
2362
2363 /*
2364  * normal groups vs special groups section,
2365  */
2366         /*
2367          * group,active vs. sgroup,active
2368          * => should NOT be replaced
2369          */
2370         {
2371                 .line   = __location__,
2372                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2373                 .r1     = {
2374                         .owner          = &ctx->b,
2375                         .type           = WREPL_TYPE_GROUP,
2376                         .state          = WREPL_STATE_ACTIVE,
2377                         .node           = WREPL_NODE_B,
2378                         .is_static      = false,
2379                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2380                         .ips            = addresses_B_1,
2381                         .apply_expected = true
2382                 },
2383                 .r2     = {
2384                         .owner          = &ctx->a,
2385                         .type           = WREPL_TYPE_SGROUP,
2386                         .state          = WREPL_STATE_ACTIVE,
2387                         .node           = WREPL_NODE_B,
2388                         .is_static      = false,
2389                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2390                         .ips            = addresses_B_1,
2391                         .apply_expected = false
2392                 }
2393         },
2394
2395         /*
2396          * group,active vs. sgroup,tombstone
2397          * => should NOT be replaced
2398          */
2399         {
2400                 .line   = __location__,
2401                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2402                 .r1     = {
2403                         .owner          = &ctx->b,
2404                         .type           = WREPL_TYPE_GROUP,
2405                         .state          = WREPL_STATE_ACTIVE,
2406                         .node           = WREPL_NODE_B,
2407                         .is_static      = false,
2408                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2409                         .ips            = addresses_B_1,
2410                         .apply_expected = true
2411                 },
2412                 .r2     = {
2413                         .owner          = &ctx->a,
2414                         .type           = WREPL_TYPE_SGROUP,
2415                         .state          = WREPL_STATE_TOMBSTONE,
2416                         .node           = WREPL_NODE_B,
2417                         .is_static      = false,
2418                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2419                         .ips            = addresses_B_1,
2420                         .apply_expected = false
2421                 }
2422         },
2423
2424         /*
2425          * group,released vs. sgroup,active
2426          * => should be replaced
2427          */
2428         {
2429                 .line   = __location__,
2430                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2431                 .r1     = {
2432                         .owner          = &ctx->a,
2433                         .type           = WREPL_TYPE_GROUP,
2434                         .state          = WREPL_STATE_RELEASED,
2435                         .node           = WREPL_NODE_B,
2436                         .is_static      = false,
2437                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2438                         .ips            = addresses_A_1,
2439                         .apply_expected = false
2440                 },
2441                 .r2     = {
2442                         .owner          = &ctx->b,
2443                         .type           = WREPL_TYPE_SGROUP,
2444                         .state          = WREPL_STATE_ACTIVE,
2445                         .node           = WREPL_NODE_B,
2446                         .is_static      = false,
2447                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2448                         .ips            = addresses_B_1,
2449                         .apply_expected = true
2450                 }
2451         },
2452
2453         /*
2454          * group,released vs. sgroup,tombstone
2455          * => should NOT be replaced
2456          */
2457         {
2458                 .line   = __location__,
2459                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2460                 .r1     = {
2461                         .owner          = &ctx->b,
2462                         .type           = WREPL_TYPE_GROUP,
2463                         .state          = WREPL_STATE_RELEASED,
2464                         .node           = WREPL_NODE_B,
2465                         .is_static      = false,
2466                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2467                         .ips            = addresses_B_1,
2468                         .apply_expected = false
2469                 },
2470                 .r2     = {
2471                         .owner          = &ctx->a,
2472                         .type           = WREPL_TYPE_SGROUP,
2473                         .state          = WREPL_STATE_TOMBSTONE,
2474                         .node           = WREPL_NODE_B,
2475                         .is_static      = false,
2476                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2477                         .ips            = addresses_B_1,
2478                         .apply_expected = false
2479                 }
2480         },
2481
2482         /*
2483          * group,tombstone vs. sgroup,active
2484          * => should be replaced
2485          */
2486         {
2487                 .line   = __location__,
2488                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2489                 .r1     = {
2490                         .owner          = &ctx->b,
2491                         .type           = WREPL_TYPE_GROUP,
2492                         .state          = WREPL_STATE_TOMBSTONE,
2493                         .node           = WREPL_NODE_B,
2494                         .is_static      = false,
2495                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2496                         .ips            = addresses_B_1,
2497                         .apply_expected = true
2498                 },
2499                 .r2     = {
2500                         .owner          = &ctx->a,
2501                         .type           = WREPL_TYPE_SGROUP,
2502                         .state          = WREPL_STATE_ACTIVE,
2503                         .node           = WREPL_NODE_B,
2504                         .is_static      = false,
2505                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2506                         .ips            = addresses_A_1,
2507                         .apply_expected = true
2508                 }
2509         },
2510
2511         /*
2512          * group,tombstone vs. sgroup,tombstone
2513          * => should be replaced
2514          */
2515         {
2516                 .line   = __location__,
2517                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2518                 .r1     = {
2519                         .owner          = &ctx->a,
2520                         .type           = WREPL_TYPE_GROUP,
2521                         .state          = WREPL_STATE_TOMBSTONE,
2522                         .node           = WREPL_NODE_B,
2523                         .is_static      = false,
2524                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2525                         .ips            = addresses_A_1,
2526                         .apply_expected = true
2527                 },
2528                 .r2     = {
2529                         .owner          = &ctx->b,
2530                         .type           = WREPL_TYPE_SGROUP,
2531                         .state          = WREPL_STATE_TOMBSTONE,
2532                         .node           = WREPL_NODE_B,
2533                         .is_static      = false,
2534                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2535                         .ips            = addresses_B_1,
2536                         .apply_expected = true
2537                 }
2538         },
2539
2540 /*
2541  * normal groups vs multi homed section,
2542  */
2543         /*
2544          * group,active vs. mhomed,active
2545          * => should NOT be replaced
2546          */
2547         {
2548                 .line   = __location__,
2549                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2550                 .r1     = {
2551                         .owner          = &ctx->b,
2552                         .type           = WREPL_TYPE_GROUP,
2553                         .state          = WREPL_STATE_ACTIVE,
2554                         .node           = WREPL_NODE_B,
2555                         .is_static      = false,
2556                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2557                         .ips            = addresses_B_1,
2558                         .apply_expected = true
2559                 },
2560                 .r2     = {
2561                         .owner          = &ctx->a,
2562                         .type           = WREPL_TYPE_MHOMED,
2563                         .state          = WREPL_STATE_ACTIVE,
2564                         .node           = WREPL_NODE_B,
2565                         .is_static      = false,
2566                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2567                         .ips            = addresses_B_1,
2568                         .apply_expected = false
2569                 }
2570         },
2571
2572         /*
2573          * group,active vs. mhomed,tombstone
2574          * => should NOT be replaced
2575          */
2576         {
2577                 .line   = __location__,
2578                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2579                 .r1     = {
2580                         .owner          = &ctx->b,
2581                         .type           = WREPL_TYPE_GROUP,
2582                         .state          = WREPL_STATE_ACTIVE,
2583                         .node           = WREPL_NODE_B,
2584                         .is_static      = false,
2585                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2586                         .ips            = addresses_B_1,
2587                         .apply_expected = true
2588                 },
2589                 .r2     = {
2590                         .owner          = &ctx->a,
2591                         .type           = WREPL_TYPE_MHOMED,
2592                         .state          = WREPL_STATE_TOMBSTONE,
2593                         .node           = WREPL_NODE_B,
2594                         .is_static      = false,
2595                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2596                         .ips            = addresses_B_1,
2597                         .apply_expected = false
2598                 }
2599         },
2600
2601         /*
2602          * group,released vs. mhomed,active
2603          * => should NOT be replaced
2604          */
2605         {
2606                 .line   = __location__,
2607                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2608                 .r1     = {
2609                         .owner          = &ctx->b,
2610                         .type           = WREPL_TYPE_GROUP,
2611                         .state          = WREPL_STATE_RELEASED,
2612                         .node           = WREPL_NODE_B,
2613                         .is_static      = false,
2614                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2615                         .ips            = addresses_B_1,
2616                         .apply_expected = false
2617                 },
2618                 .r2     = {
2619                         .owner          = &ctx->a,
2620                         .type           = WREPL_TYPE_MHOMED,
2621                         .state          = WREPL_STATE_ACTIVE,
2622                         .node           = WREPL_NODE_B,
2623                         .is_static      = false,
2624                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2625                         .ips            = addresses_B_1,
2626                         .apply_expected = false
2627                 }
2628         },
2629
2630         /*
2631          * group,released vs. mhomed,tombstone
2632          * => should NOT be replaced
2633          */
2634         {
2635                 .line   = __location__,
2636                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2637                 .r1     = {
2638                         .owner          = &ctx->b,
2639                         .type           = WREPL_TYPE_GROUP,
2640                         .state          = WREPL_STATE_RELEASED,
2641                         .node           = WREPL_NODE_B,
2642                         .is_static      = false,
2643                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2644                         .ips            = addresses_B_1,
2645                         .apply_expected = false
2646                 },
2647                 .r2     = {
2648                         .owner          = &ctx->a,
2649                         .type           = WREPL_TYPE_MHOMED,
2650                         .state          = WREPL_STATE_TOMBSTONE,
2651                         .node           = WREPL_NODE_B,
2652                         .is_static      = false,
2653                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2654                         .ips            = addresses_B_1,
2655                         .apply_expected = false
2656                 }
2657         },
2658
2659         /*
2660          * group,tombstone vs. mhomed,active
2661          * => should be replaced
2662          */
2663         {
2664                 .line   = __location__,
2665                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2666                 .r1     = {
2667                         .owner          = &ctx->b,
2668                         .type           = WREPL_TYPE_GROUP,
2669                         .state          = WREPL_STATE_TOMBSTONE,
2670                         .node           = WREPL_NODE_B,
2671                         .is_static      = false,
2672                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2673                         .ips            = addresses_B_1,
2674                         .apply_expected = true
2675                 },
2676                 .r2     = {
2677                         .owner          = &ctx->a,
2678                         .type           = WREPL_TYPE_MHOMED,
2679                         .state          = WREPL_STATE_ACTIVE,
2680                         .node           = WREPL_NODE_B,
2681                         .is_static      = false,
2682                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2683                         .ips            = addresses_A_1,
2684                         .apply_expected = true
2685                 }
2686         },
2687
2688         /*
2689          * group,tombstone vs. mhomed,tombstone
2690          * => should be replaced
2691          */
2692         {
2693                 .line   = __location__,
2694                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2695                 .r1     = {
2696                         .owner          = &ctx->a,
2697                         .type           = WREPL_TYPE_GROUP,
2698                         .state          = WREPL_STATE_TOMBSTONE,
2699                         .node           = WREPL_NODE_B,
2700                         .is_static      = false,
2701                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2702                         .ips            = addresses_A_1,
2703                         .apply_expected = true
2704                 },
2705                 .r2     = {
2706                         .owner          = &ctx->b,
2707                         .type           = WREPL_TYPE_MHOMED,
2708                         .state          = WREPL_STATE_TOMBSTONE,
2709                         .node           = WREPL_NODE_B,
2710                         .is_static      = false,
2711                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2712                         .ips            = addresses_B_1,
2713                         .apply_expected = true
2714                 }
2715         },
2716
2717 /*
2718  * special groups vs unique section,
2719  */
2720         /*
2721          * sgroup,active vs. unique,active
2722          * => should NOT be replaced
2723          */
2724         {
2725                 .line   = __location__,
2726                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2727                 .r1     = {
2728                         .owner          = &ctx->b,
2729                         .type           = WREPL_TYPE_SGROUP,
2730                         .state          = WREPL_STATE_ACTIVE,
2731                         .node           = WREPL_NODE_B,
2732                         .is_static      = false,
2733                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2734                         .ips            = addresses_B_1,
2735                         .apply_expected = true
2736                 },
2737                 .r2     = {
2738                         .owner          = &ctx->a,
2739                         .type           = WREPL_TYPE_UNIQUE,
2740                         .state          = WREPL_STATE_ACTIVE,
2741                         .node           = WREPL_NODE_B,
2742                         .is_static      = false,
2743                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2744                         .ips            = addresses_B_1,
2745                         .apply_expected = false
2746                 }
2747         },
2748
2749         /*
2750          * sgroup,active vs. unique,tombstone
2751          * => should NOT be replaced
2752          */
2753         {
2754                 .line   = __location__,
2755                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2756                 .r1     = {
2757                         .owner          = &ctx->b,
2758                         .type           = WREPL_TYPE_SGROUP,
2759                         .state          = WREPL_STATE_ACTIVE,
2760                         .node           = WREPL_NODE_B,
2761                         .is_static      = false,
2762                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2763                         .ips            = addresses_B_1,
2764                         .apply_expected = true
2765                 },
2766                 .r2     = {
2767                         .owner          = &ctx->a,
2768                         .type           = WREPL_TYPE_UNIQUE,
2769                         .state          = WREPL_STATE_TOMBSTONE,
2770                         .node           = WREPL_NODE_B,
2771                         .is_static      = false,
2772                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2773                         .ips            = addresses_B_1,
2774                         .apply_expected = false
2775                 }
2776         },
2777
2778         /*
2779          * sgroup,released vs. unique,active
2780          * => should be replaced
2781          */
2782         {
2783                 .line   = __location__,
2784                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2785                 .r1     = {
2786                         .owner          = &ctx->b,
2787                         .type           = WREPL_TYPE_SGROUP,
2788                         .state          = WREPL_STATE_RELEASED,
2789                         .node           = WREPL_NODE_B,
2790                         .is_static      = false,
2791                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2792                         .ips            = addresses_B_1,
2793                         .apply_expected = false
2794                 },
2795                 .r2     = {
2796                         .owner          = &ctx->a,
2797                         .type           = WREPL_TYPE_UNIQUE,
2798                         .state          = WREPL_STATE_ACTIVE,
2799                         .node           = WREPL_NODE_B,
2800                         .is_static      = false,
2801                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2802                         .ips            = addresses_A_1,
2803                         .apply_expected = true
2804                 }
2805         },
2806
2807         /*
2808          * sgroup,released vs. unique,tombstone
2809          * => should be replaced
2810          */
2811         {
2812                 .line   = __location__,
2813                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2814                 .r1     = {
2815                         .owner          = &ctx->a,
2816                         .type           = WREPL_TYPE_SGROUP,
2817                         .state          = WREPL_STATE_RELEASED,
2818                         .node           = WREPL_NODE_B,
2819                         .is_static      = false,
2820                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2821                         .ips            = addresses_A_1,
2822                         .apply_expected = false
2823                 },
2824                 .r2     = {
2825                         .owner          = &ctx->b,
2826                         .type           = WREPL_TYPE_UNIQUE,
2827                         .state          = WREPL_STATE_TOMBSTONE,
2828                         .node           = WREPL_NODE_B,
2829                         .is_static      = false,
2830                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2831                         .ips            = addresses_B_1,
2832                         .apply_expected = true
2833                 }
2834         },
2835
2836         /*
2837          * sgroup,tombstone vs. unique,active
2838          * => should be replaced
2839          */
2840         {
2841                 .line   = __location__,
2842                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2843                 .r1     = {
2844                         .owner          = &ctx->a,
2845                         .type           = WREPL_TYPE_SGROUP,
2846                         .state          = WREPL_STATE_TOMBSTONE,
2847                         .node           = WREPL_NODE_B,
2848                         .is_static      = false,
2849                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2850                         .ips            = addresses_A_1,
2851                         .apply_expected = true
2852                 },
2853                 .r2     = {
2854                         .owner          = &ctx->b,
2855                         .type           = WREPL_TYPE_UNIQUE,
2856                         .state          = WREPL_STATE_ACTIVE,
2857                         .node           = WREPL_NODE_B,
2858                         .is_static      = false,
2859                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2860                         .ips            = addresses_B_1,
2861                         .apply_expected = true
2862                 }
2863         },
2864
2865         /*
2866          * sgroup,tombstone vs. unique,tombstone
2867          * => should be replaced
2868          */
2869         {
2870                 .line   = __location__,
2871                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2872                 .r1     = {
2873                         .owner          = &ctx->b,
2874                         .type           = WREPL_TYPE_SGROUP,
2875                         .state          = WREPL_STATE_TOMBSTONE,
2876                         .node           = WREPL_NODE_B,
2877                         .is_static      = false,
2878                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2879                         .ips            = addresses_B_1,
2880                         .apply_expected = true
2881                 },
2882                 .r2     = {
2883                         .owner          = &ctx->a,
2884                         .type           = WREPL_TYPE_UNIQUE,
2885                         .state          = WREPL_STATE_TOMBSTONE,
2886                         .node           = WREPL_NODE_B,
2887                         .is_static      = false,
2888                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2889                         .ips            = addresses_A_1,
2890                         .apply_expected = true
2891                 }
2892         },
2893
2894 /*
2895  * special groups vs normal group section,
2896  */
2897         /*
2898          * sgroup,active vs. group,active
2899          * => should NOT be replaced
2900          */
2901         {
2902                 .line   = __location__,
2903                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2904                 .r1     = {
2905                         .owner          = &ctx->a,
2906                         .type           = WREPL_TYPE_SGROUP,
2907                         .state          = WREPL_STATE_ACTIVE,
2908                         .node           = WREPL_NODE_B,
2909                         .is_static      = false,
2910                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2911                         .ips            = addresses_A_1,
2912                         .apply_expected = true
2913                 },
2914                 .r2     = {
2915                         .owner          = &ctx->b,
2916                         .type           = WREPL_TYPE_GROUP,
2917                         .state          = WREPL_STATE_ACTIVE,
2918                         .node           = WREPL_NODE_B,
2919                         .is_static      = false,
2920                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2921                         .ips            = addresses_A_1,
2922                         .apply_expected = false
2923                 }
2924         },
2925
2926         /*
2927          * sgroup,active vs. group,tombstone
2928          * => should NOT be replaced
2929          */
2930         {
2931                 .line   = __location__,
2932                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2933                 .r1     = {
2934                         .owner          = &ctx->a,
2935                         .type           = WREPL_TYPE_SGROUP,
2936                         .state          = WREPL_STATE_ACTIVE,
2937                         .node           = WREPL_NODE_B,
2938                         .is_static      = false,
2939                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2940                         .ips            = addresses_A_1,
2941                         .apply_expected = true
2942                 },
2943                 .r2     = {
2944                         .owner          = &ctx->b,
2945                         .type           = WREPL_TYPE_GROUP,
2946                         .state          = WREPL_STATE_TOMBSTONE,
2947                         .node           = WREPL_NODE_B,
2948                         .is_static      = false,
2949                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2950                         .ips            = addresses_A_1,
2951                         .apply_expected = false
2952                 }
2953         },
2954
2955         /*
2956          * sgroup,released vs. group,active
2957          * => should be replaced
2958          */
2959         {
2960                 .line   = __location__,
2961                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2962                 .r1     = {
2963                         .owner          = &ctx->a,
2964                         .type           = WREPL_TYPE_SGROUP,
2965                         .state          = WREPL_STATE_RELEASED,
2966                         .node           = WREPL_NODE_B,
2967                         .is_static      = false,
2968                         .num_ips        = ARRAY_SIZE(addresses_A_1),
2969                         .ips            = addresses_A_1,
2970                         .apply_expected = false
2971                 },
2972                 .r2     = {
2973                         .owner          = &ctx->b,
2974                         .type           = WREPL_TYPE_GROUP,
2975                         .state          = WREPL_STATE_ACTIVE,
2976                         .node           = WREPL_NODE_B,
2977                         .is_static      = false,
2978                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2979                         .ips            = addresses_B_1,
2980                         .apply_expected = true
2981                 }
2982         },
2983
2984         /*
2985          * sgroup,released vs. group,tombstone
2986          * => should be replaced
2987          */
2988         {
2989                 .line   = __location__,
2990                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2991                 .r1     = {
2992                         .owner          = &ctx->b,
2993                         .type           = WREPL_TYPE_SGROUP,
2994                         .state          = WREPL_STATE_RELEASED,
2995                         .node           = WREPL_NODE_B,
2996                         .is_static      = false,
2997                         .num_ips        = ARRAY_SIZE(addresses_B_1),
2998                         .ips            = addresses_B_1,
2999                         .apply_expected = false
3000                 },
3001                 .r2     = {
3002                         .owner          = &ctx->a,
3003                         .type           = WREPL_TYPE_GROUP,
3004                         .state          = WREPL_STATE_TOMBSTONE,
3005                         .node           = WREPL_NODE_B,
3006                         .is_static      = false,
3007                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3008                         .ips            = addresses_A_1,
3009                         .apply_expected = true
3010                 }
3011         },
3012
3013         /*
3014          * sgroup,tombstone vs. group,active
3015          * => should NOT be replaced
3016          */
3017         {
3018                 .line   = __location__,
3019                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3020                 .r1     = {
3021                         .owner          = &ctx->a,
3022                         .type           = WREPL_TYPE_SGROUP,
3023                         .state          = WREPL_STATE_TOMBSTONE,
3024                         .node           = WREPL_NODE_B,
3025                         .is_static      = false,
3026                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3027                         .ips            = addresses_A_1,
3028                         .apply_expected = true
3029                 },
3030                 .r2     = {
3031                         .owner          = &ctx->b,
3032                         .type           = WREPL_TYPE_GROUP,
3033                         .state          = WREPL_STATE_ACTIVE,
3034                         .node           = WREPL_NODE_B,
3035                         .is_static      = false,
3036                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3037                         .ips            = addresses_B_1,
3038                         .apply_expected = true
3039                 }
3040         },
3041
3042         /*
3043          * sgroup,tombstone vs. group,tombstone
3044          * => should NOT be replaced
3045          */
3046         {
3047                 .line   = __location__,
3048                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3049                 .r1     = {
3050                         .owner          = &ctx->b,
3051                         .type           = WREPL_TYPE_SGROUP,
3052                         .state          = WREPL_STATE_TOMBSTONE,
3053                         .node           = WREPL_NODE_B,
3054                         .is_static      = false,
3055                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3056                         .ips            = addresses_B_1,
3057                         .apply_expected = true
3058                 },
3059                 .r2     = {
3060                         .owner          = &ctx->a,
3061                         .type           = WREPL_TYPE_GROUP,
3062                         .state          = WREPL_STATE_TOMBSTONE,
3063                         .node           = WREPL_NODE_B,
3064                         .is_static      = false,
3065                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3066                         .ips            = addresses_A_1,
3067                         .apply_expected = true
3068                 }
3069         },
3070
3071 /*
3072  * special groups (not active) vs special group section,
3073  */
3074         /*
3075          * sgroup,released vs. sgroup,active
3076          * => should be replaced
3077          */
3078         {
3079                 .line   = __location__,
3080                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3081                 .r1     = {
3082                         .owner          = &ctx->a,
3083                         .type           = WREPL_TYPE_SGROUP,
3084                         .state          = WREPL_STATE_RELEASED,
3085                         .node           = WREPL_NODE_B,
3086                         .is_static      = false,
3087                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3088                         .ips            = addresses_A_1,
3089                         .apply_expected = false
3090                 },
3091                 .r2     = {
3092                         .owner          = &ctx->b,
3093                         .type           = WREPL_TYPE_SGROUP,
3094                         .state          = WREPL_STATE_ACTIVE,
3095                         .node           = WREPL_NODE_B,
3096                         .is_static      = false,
3097                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3098                         .ips            = addresses_B_1,
3099                         .apply_expected = true
3100                 }
3101         },
3102
3103         /*
3104          * sgroup,released vs. sgroup,tombstone
3105          * => should be replaced
3106          */
3107         {
3108                 .line   = __location__,
3109                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3110                 .r1     = {
3111                         .owner          = &ctx->b,
3112                         .type           = WREPL_TYPE_SGROUP,
3113                         .state          = WREPL_STATE_RELEASED,
3114                         .node           = WREPL_NODE_B,
3115                         .is_static      = false,
3116                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3117                         .ips            = addresses_B_1,
3118                         .apply_expected = false
3119                 },
3120                 .r2     = {
3121                         .owner          = &ctx->a,
3122                         .type           = WREPL_TYPE_SGROUP,
3123                         .state          = WREPL_STATE_TOMBSTONE,
3124                         .node           = WREPL_NODE_B,
3125                         .is_static      = false,
3126                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3127                         .ips            = addresses_A_1,
3128                         .apply_expected = true
3129                 }
3130         },
3131
3132         /*
3133          * sgroup,tombstone vs. sgroup,active
3134          * => should NOT be replaced
3135          */
3136         {
3137                 .line   = __location__,
3138                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3139                 .r1     = {
3140                         .owner          = &ctx->a,
3141                         .type           = WREPL_TYPE_SGROUP,
3142                         .state          = WREPL_STATE_TOMBSTONE,
3143                         .node           = WREPL_NODE_B,
3144                         .is_static      = false,
3145                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3146                         .ips            = addresses_A_1,
3147                         .apply_expected = true
3148                 },
3149                 .r2     = {
3150                         .owner          = &ctx->b,
3151                         .type           = WREPL_TYPE_SGROUP,
3152                         .state          = WREPL_STATE_ACTIVE,
3153                         .node           = WREPL_NODE_B,
3154                         .is_static      = false,
3155                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3156                         .ips            = addresses_B_1,
3157                         .apply_expected = true
3158                 }
3159         },
3160
3161         /*
3162          * sgroup,tombstone vs. sgroup,tombstone
3163          * => should NOT be replaced
3164          */
3165         {
3166                 .line   = __location__,
3167                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3168                 .r1     = {
3169                         .owner          = &ctx->b,
3170                         .type           = WREPL_TYPE_SGROUP,
3171                         .state          = WREPL_STATE_TOMBSTONE,
3172                         .node           = WREPL_NODE_B,
3173                         .is_static      = false,
3174                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3175                         .ips            = addresses_B_1,
3176                         .apply_expected = true
3177                 },
3178                 .r2     = {
3179                         .owner          = &ctx->a,
3180                         .type           = WREPL_TYPE_SGROUP,
3181                         .state          = WREPL_STATE_TOMBSTONE,
3182                         .node           = WREPL_NODE_B,
3183                         .is_static      = false,
3184                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3185                         .ips            = addresses_A_1,
3186                         .apply_expected = true
3187                 }
3188         },
3189
3190 /*
3191  * special groups vs multi homed section,
3192  */
3193         /*
3194          * sgroup,active vs. mhomed,active
3195          * => should NOT be replaced
3196          */
3197         {
3198                 .line   = __location__,
3199                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3200                 .r1     = {
3201                         .owner          = &ctx->a,
3202                         .type           = WREPL_TYPE_SGROUP,
3203                         .state          = WREPL_STATE_ACTIVE,
3204                         .node           = WREPL_NODE_B,
3205                         .is_static      = false,
3206                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3207                         .ips            = addresses_A_1,
3208                         .apply_expected = true
3209                 },
3210                 .r2     = {
3211                         .owner          = &ctx->b,
3212                         .type           = WREPL_TYPE_MHOMED,
3213                         .state          = WREPL_STATE_ACTIVE,
3214                         .node           = WREPL_NODE_B,
3215                         .is_static      = false,
3216                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3217                         .ips            = addresses_A_1,
3218                         .apply_expected = false
3219                 }
3220         },
3221
3222         /*
3223          * sgroup,active vs. mhomed,tombstone
3224          * => should NOT be replaced
3225          */
3226         {
3227                 .line   = __location__,
3228                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3229                 .r1     = {
3230                         .owner          = &ctx->a,
3231                         .type           = WREPL_TYPE_SGROUP,
3232                         .state          = WREPL_STATE_ACTIVE,
3233                         .node           = WREPL_NODE_B,
3234                         .is_static      = false,
3235                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3236                         .ips            = addresses_A_1,
3237                         .apply_expected = true
3238                 },
3239                 .r2     = {
3240                         .owner          = &ctx->b,
3241                         .type           = WREPL_TYPE_MHOMED,
3242                         .state          = WREPL_STATE_TOMBSTONE,
3243                         .node           = WREPL_NODE_B,
3244                         .is_static      = false,
3245                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3246                         .ips            = addresses_A_1,
3247                         .apply_expected = false
3248                 }
3249         },
3250
3251         /*
3252          * sgroup,released vs. mhomed,active
3253          * => should be replaced
3254          */
3255         {
3256                 .line   = __location__,
3257                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3258                 .r1     = {
3259                         .owner          = &ctx->a,
3260                         .type           = WREPL_TYPE_SGROUP,
3261                         .state          = WREPL_STATE_RELEASED,
3262                         .node           = WREPL_NODE_B,
3263                         .is_static      = false,
3264                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3265                         .ips            = addresses_A_1,
3266                         .apply_expected = false
3267                 },
3268                 .r2     = {
3269                         .owner          = &ctx->b,
3270                         .type           = WREPL_TYPE_MHOMED,
3271                         .state          = WREPL_STATE_ACTIVE,
3272                         .node           = WREPL_NODE_B,
3273                         .is_static      = false,
3274                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3275                         .ips            = addresses_B_1,
3276                         .apply_expected = true
3277                 }
3278         },
3279
3280         /*
3281          * sgroup,released vs. mhomed,tombstone
3282          * => should be replaced
3283          */
3284         {
3285                 .line   = __location__,
3286                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3287                 .r1     = {
3288                         .owner          = &ctx->b,
3289                         .type           = WREPL_TYPE_SGROUP,
3290                         .state          = WREPL_STATE_RELEASED,
3291                         .node           = WREPL_NODE_B,
3292                         .is_static      = false,
3293                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3294                         .ips            = addresses_B_1,
3295                         .apply_expected = false
3296                 },
3297                 .r2     = {
3298                         .owner          = &ctx->a,
3299                         .type           = WREPL_TYPE_MHOMED,
3300                         .state          = WREPL_STATE_TOMBSTONE,
3301                         .node           = WREPL_NODE_B,
3302                         .is_static      = false,
3303                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3304                         .ips            = addresses_A_1,
3305                         .apply_expected = true
3306                 }
3307         },
3308
3309         /*
3310          * sgroup,tombstone vs. mhomed,active
3311          * => should be replaced
3312          */
3313         {
3314                 .line   = __location__,
3315                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3316                 .r1     = {
3317                         .owner          = &ctx->a,
3318                         .type           = WREPL_TYPE_SGROUP,
3319                         .state          = WREPL_STATE_TOMBSTONE,
3320                         .node           = WREPL_NODE_B,
3321                         .is_static      = false,
3322                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3323                         .ips            = addresses_A_1,
3324                         .apply_expected = true
3325                 },
3326                 .r2     = {
3327                         .owner          = &ctx->b,
3328                         .type           = WREPL_TYPE_MHOMED,
3329                         .state          = WREPL_STATE_ACTIVE,
3330                         .node           = WREPL_NODE_B,
3331                         .is_static      = false,
3332                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3333                         .ips            = addresses_B_1,
3334                         .apply_expected = true
3335                 }
3336         },
3337
3338         /*
3339          * sgroup,tombstone vs. mhomed,tombstone
3340          * => should be replaced
3341          */
3342         {
3343                 .line   = __location__,
3344                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3345                 .r1     = {
3346                         .owner          = &ctx->b,
3347                         .type           = WREPL_TYPE_SGROUP,
3348                         .state          = WREPL_STATE_TOMBSTONE,
3349                         .node           = WREPL_NODE_B,
3350                         .is_static      = false,
3351                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3352                         .ips            = addresses_B_1,
3353                         .apply_expected = true
3354                 },
3355                 .r2     = {
3356                         .owner          = &ctx->a,
3357                         .type           = WREPL_TYPE_MHOMED,
3358                         .state          = WREPL_STATE_TOMBSTONE,
3359                         .node           = WREPL_NODE_B,
3360                         .is_static      = false,
3361                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3362                         .ips            = addresses_A_1,
3363                         .apply_expected = true
3364                 }
3365         },
3366
3367 /*
3368  * multi homed vs. unique section,
3369  */
3370         /*
3371          * mhomed,active vs. unique,active
3372          * => should be replaced
3373          */
3374         {
3375                 .line   = __location__,
3376                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3377                 .r1     = {
3378                         .owner          = &ctx->a,
3379                         .type           = WREPL_TYPE_MHOMED,
3380                         .state          = WREPL_STATE_ACTIVE,
3381                         .node           = WREPL_NODE_B,
3382                         .is_static      = false,
3383                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
3384                         .ips            = addresses_A_3_4,
3385                         .apply_expected = true
3386                 },
3387                 .r2     = {
3388                         .owner          = &ctx->b,
3389                         .type           = WREPL_TYPE_UNIQUE,
3390                         .state          = WREPL_STATE_ACTIVE,
3391                         .node           = WREPL_NODE_B,
3392                         .is_static      = false,
3393                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3394                         .ips            = addresses_B_1,
3395                         .apply_expected = true
3396                 }
3397         },
3398
3399         /*
3400          * mhomed,active vs. unique,tombstone
3401          * => should NOT be replaced
3402          */
3403         {
3404                 .line   = __location__,
3405                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3406                 .r1     = {
3407                         .owner          = &ctx->b,
3408                         .type           = WREPL_TYPE_MHOMED,
3409                         .state          = WREPL_STATE_ACTIVE,
3410                         .node           = WREPL_NODE_B,
3411                         .is_static      = false,
3412                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3413                         .ips            = addresses_B_1,
3414                         .apply_expected = true
3415                 },
3416                 .r2     = {
3417                         .owner          = &ctx->a,
3418                         .type           = WREPL_TYPE_UNIQUE,
3419                         .state          = WREPL_STATE_TOMBSTONE,
3420                         .node           = WREPL_NODE_B,
3421                         .is_static      = false,
3422                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3423                         .ips            = addresses_B_1,
3424                         .apply_expected = false
3425                 }
3426         },
3427
3428         /*
3429          * mhomed,released vs. unique,active
3430          * => should be replaced
3431          */
3432         {
3433                 .line   = __location__,
3434                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3435                 .r1     = {
3436                         .owner          = &ctx->a,
3437                         .type           = WREPL_TYPE_MHOMED,
3438                         .state          = WREPL_STATE_RELEASED,
3439                         .node           = WREPL_NODE_B,
3440                         .is_static      = false,
3441                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3442                         .ips            = addresses_A_1,
3443                         .apply_expected = false
3444                 },
3445                 .r2     = {
3446                         .owner          = &ctx->b,
3447                         .type           = WREPL_TYPE_UNIQUE,
3448                         .state          = WREPL_STATE_ACTIVE,
3449                         .node           = WREPL_NODE_B,
3450                         .is_static      = false,
3451                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3452                         .ips            = addresses_B_1,
3453                         .apply_expected = true
3454                 }
3455         },
3456
3457         /*
3458          * mhomed,released vs. uinique,tombstone
3459          * => should be replaced
3460          */
3461         {
3462                 .line   = __location__,
3463                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3464                 .r1     = {
3465                         .owner          = &ctx->b,
3466                         .type           = WREPL_TYPE_MHOMED,
3467                         .state          = WREPL_STATE_RELEASED,
3468                         .node           = WREPL_NODE_B,
3469                         .is_static      = false,
3470                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3471                         .ips            = addresses_B_1,
3472                         .apply_expected = false
3473                 },
3474                 .r2     = {
3475                         .owner          = &ctx->a,
3476                         .type           = WREPL_TYPE_UNIQUE,
3477                         .state          = WREPL_STATE_TOMBSTONE,
3478                         .node           = WREPL_NODE_B,
3479                         .is_static      = false,
3480                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3481                         .ips            = addresses_A_1,
3482                         .apply_expected = true
3483                 }
3484         },
3485
3486         /*
3487          * mhomed,tombstone vs. unique,active
3488          * => should be replaced
3489          */
3490         {
3491                 .line   = __location__,
3492                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3493                 .r1     = {
3494                         .owner          = &ctx->a,
3495                         .type           = WREPL_TYPE_MHOMED,
3496                         .state          = WREPL_STATE_TOMBSTONE,
3497                         .node           = WREPL_NODE_B,
3498                         .is_static      = false,
3499                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3500                         .ips            = addresses_A_1,
3501                         .apply_expected = true
3502                 },
3503                 .r2     = {
3504                         .owner          = &ctx->b,
3505                         .type           = WREPL_TYPE_UNIQUE,
3506                         .state          = WREPL_STATE_ACTIVE,
3507                         .node           = WREPL_NODE_B,
3508                         .is_static      = false,
3509                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3510                         .ips            = addresses_B_1,
3511                         .apply_expected = true
3512                 }
3513         },
3514
3515         /*
3516          * mhomed,tombstone vs. uinique,tombstone
3517          * => should be replaced
3518          */
3519         {
3520                 .line   = __location__,
3521                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3522                 .r1     = {
3523                         .owner          = &ctx->b,
3524                         .type           = WREPL_TYPE_MHOMED,
3525                         .state          = WREPL_STATE_TOMBSTONE,
3526                         .node           = WREPL_NODE_B,
3527                         .is_static      = false,
3528                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3529                         .ips            = addresses_B_1,
3530                         .apply_expected = true
3531                 },
3532                 .r2     = {
3533                         .owner          = &ctx->a,
3534                         .type           = WREPL_TYPE_UNIQUE,
3535                         .state          = WREPL_STATE_TOMBSTONE,
3536                         .node           = WREPL_NODE_B,
3537                         .is_static      = false,
3538                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3539                         .ips            = addresses_A_1,
3540                         .apply_expected = true
3541                 }
3542         },
3543
3544 /*
3545  * multi homed vs. normal group section,
3546  */
3547         /*
3548          * mhomed,active vs. group,active
3549          * => should be replaced
3550          */
3551         {
3552                 .line   = __location__,
3553                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3554                 .r1     = {
3555                         .owner          = &ctx->a,
3556                         .type           = WREPL_TYPE_MHOMED,
3557                         .state          = WREPL_STATE_ACTIVE,
3558                         .node           = WREPL_NODE_B,
3559                         .is_static      = false,
3560                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3561                         .ips            = addresses_A_1,
3562                         .apply_expected = true
3563                 },
3564                 .r2     = {
3565                         .owner          = &ctx->b,
3566                         .type           = WREPL_TYPE_GROUP,
3567                         .state          = WREPL_STATE_ACTIVE,
3568                         .node           = WREPL_NODE_B,
3569                         .is_static      = false,
3570                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3571                         .ips            = addresses_B_1,
3572                         .apply_expected = true
3573                 }
3574         },
3575
3576         /*
3577          * mhomed,active vs. group,tombstone
3578          * => should NOT be replaced
3579          */
3580         {
3581                 .line   = __location__,
3582                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3583                 .r1     = {
3584                         .owner          = &ctx->b,
3585                         .type           = WREPL_TYPE_MHOMED,
3586                         .state          = WREPL_STATE_ACTIVE,
3587                         .node           = WREPL_NODE_B,
3588                         .is_static      = false,
3589                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3590                         .ips            = addresses_B_1,
3591                         .apply_expected = true
3592                 },
3593                 .r2     = {
3594                         .owner          = &ctx->a,
3595                         .type           = WREPL_TYPE_GROUP,
3596                         .state          = WREPL_STATE_TOMBSTONE,
3597                         .node           = WREPL_NODE_B,
3598                         .is_static      = false,
3599                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3600                         .ips            = addresses_B_1,
3601                         .apply_expected = false
3602                 }
3603         },
3604
3605         /*
3606          * mhomed,released vs. group,active
3607          * => should be replaced
3608          */
3609         {
3610                 .line   = __location__,
3611                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3612                 .r1     = {
3613                         .owner          = &ctx->b,
3614                         .type           = WREPL_TYPE_MHOMED,
3615                         .state          = WREPL_STATE_RELEASED,
3616                         .node           = WREPL_NODE_B,
3617                         .is_static      = false,
3618                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3619                         .ips            = addresses_B_1,
3620                         .apply_expected = false
3621                 },
3622                 .r2     = {
3623                         .owner          = &ctx->a,
3624                         .type           = WREPL_TYPE_GROUP,
3625                         .state          = WREPL_STATE_ACTIVE,
3626                         .node           = WREPL_NODE_B,
3627                         .is_static      = false,
3628                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3629                         .ips            = addresses_A_1,
3630                         .apply_expected = true
3631                 }
3632         },
3633
3634         /*
3635          * mhomed,released vs. group,tombstone
3636          * => should be replaced
3637          */
3638         {
3639                 .line   = __location__,
3640                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3641                 .r1     = {
3642                         .owner          = &ctx->a,
3643                         .type           = WREPL_TYPE_MHOMED,
3644                         .state          = WREPL_STATE_RELEASED,
3645                         .node           = WREPL_NODE_B,
3646                         .is_static      = false,
3647                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3648                         .ips            = addresses_A_1,
3649                         .apply_expected = false
3650                 },
3651                 .r2     = {
3652                         .owner          = &ctx->b,
3653                         .type           = WREPL_TYPE_GROUP,
3654                         .state          = WREPL_STATE_TOMBSTONE,
3655                         .node           = WREPL_NODE_B,
3656                         .is_static      = false,
3657                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3658                         .ips            = addresses_B_1,
3659                         .apply_expected = true
3660                 }
3661         },
3662
3663         /*
3664          * mhomed,tombstone vs. group,active
3665          * => should be replaced
3666          */
3667         {
3668                 .line   = __location__,
3669                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3670                 .r1     = {
3671                         .owner          = &ctx->b,
3672                         .type           = WREPL_TYPE_MHOMED,
3673                         .state          = WREPL_STATE_TOMBSTONE,
3674                         .node           = WREPL_NODE_B,
3675                         .is_static      = false,
3676                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3677                         .ips            = addresses_B_1,
3678                         .apply_expected = true
3679                 },
3680                 .r2     = {
3681                         .owner          = &ctx->a,
3682                         .type           = WREPL_TYPE_GROUP,
3683                         .state          = WREPL_STATE_ACTIVE,
3684                         .node           = WREPL_NODE_B,
3685                         .is_static      = false,
3686                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3687                         .ips            = addresses_A_1,
3688                         .apply_expected = true
3689                 }
3690         },
3691
3692         /*
3693          * mhomed,tombstone vs. group,tombstone
3694          * => should be replaced
3695          */
3696         {
3697                 .line   = __location__,
3698                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3699                 .r1     = {
3700                         .owner          = &ctx->a,
3701                         .type           = WREPL_TYPE_MHOMED,
3702                         .state          = WREPL_STATE_TOMBSTONE,
3703                         .node           = WREPL_NODE_B,
3704                         .is_static      = false,
3705                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3706                         .ips            = addresses_A_1,
3707                         .apply_expected = true
3708                 },
3709                 .r2     = {
3710                         .owner          = &ctx->b,
3711                         .type           = WREPL_TYPE_GROUP,
3712                         .state          = WREPL_STATE_TOMBSTONE,
3713                         .node           = WREPL_NODE_B,
3714                         .is_static      = false,
3715                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3716                         .ips            = addresses_B_1,
3717                         .apply_expected = true
3718                 }
3719         },
3720
3721 /*
3722  * multi homed vs. special group section,
3723  */
3724         /*
3725          * mhomed,active vs. sgroup,active
3726          * => should NOT be replaced
3727          */
3728         {
3729                 .line   = __location__,
3730                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3731                 .r1     = {
3732                         .owner          = &ctx->a,
3733                         .type           = WREPL_TYPE_MHOMED,
3734                         .state          = WREPL_STATE_ACTIVE,
3735                         .node           = WREPL_NODE_B,
3736                         .is_static      = false,
3737                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3738                         .ips            = addresses_A_1,
3739                         .apply_expected = true
3740                 },
3741                 .r2     = {
3742                         .owner          = &ctx->b,
3743                         .type           = WREPL_TYPE_SGROUP,
3744                         .state          = WREPL_STATE_ACTIVE,
3745                         .node           = WREPL_NODE_B,
3746                         .is_static      = false,
3747                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3748                         .ips            = addresses_A_1,
3749                         .apply_expected = false
3750                 }
3751         },
3752
3753         /*
3754          * mhomed,active vs. sgroup,tombstone
3755          * => should NOT be replaced
3756          */
3757         {
3758                 .line   = __location__,
3759                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3760                 .r1     = {
3761                         .owner          = &ctx->a,
3762                         .type           = WREPL_TYPE_MHOMED,
3763                         .state          = WREPL_STATE_ACTIVE,
3764                         .node           = WREPL_NODE_B,
3765                         .is_static      = false,
3766                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3767                         .ips            = addresses_A_1,
3768                         .apply_expected = true
3769                 },
3770                 .r2     = {
3771                         .owner          = &ctx->b,
3772                         .type           = WREPL_TYPE_SGROUP,
3773                         .state          = WREPL_STATE_TOMBSTONE,
3774                         .node           = WREPL_NODE_B,
3775                         .is_static      = false,
3776                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3777                         .ips            = addresses_A_1,
3778                         .apply_expected = false
3779                 }
3780         },
3781
3782         /*
3783          * mhomed,released vs. sgroup,active
3784          * => should be replaced
3785          */
3786         {
3787                 .line   = __location__,
3788                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3789                 .r1     = {
3790                         .owner          = &ctx->a,
3791                         .type           = WREPL_TYPE_MHOMED,
3792                         .state          = WREPL_STATE_RELEASED,
3793                         .node           = WREPL_NODE_B,
3794                         .is_static      = false,
3795                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3796                         .ips            = addresses_A_1,
3797                         .apply_expected = false
3798                 },
3799                 .r2     = {
3800                         .owner          = &ctx->b,
3801                         .type           = WREPL_TYPE_SGROUP,
3802                         .state          = WREPL_STATE_ACTIVE,
3803                         .node           = WREPL_NODE_B,
3804                         .is_static      = false,
3805                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3806                         .ips            = addresses_B_1,
3807                         .apply_expected = true
3808                 }
3809         },
3810
3811         /*
3812          * mhomed,released vs. sgroup,tombstone
3813          * => should be replaced
3814          */
3815         {
3816                 .line   = __location__,
3817                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3818                 .r1     = {
3819                         .owner          = &ctx->b,
3820                         .type           = WREPL_TYPE_MHOMED,
3821                         .state          = WREPL_STATE_RELEASED,
3822                         .node           = WREPL_NODE_B,
3823                         .is_static      = false,
3824                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3825                         .ips            = addresses_B_1,
3826                         .apply_expected = false
3827                 },
3828                 .r2     = {
3829                         .owner          = &ctx->a,
3830                         .type           = WREPL_TYPE_SGROUP,
3831                         .state          = WREPL_STATE_TOMBSTONE,
3832                         .node           = WREPL_NODE_B,
3833                         .is_static      = false,
3834                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3835                         .ips            = addresses_A_1,
3836                         .apply_expected = true
3837                 }
3838         },
3839
3840         /*
3841          * mhomed,tombstone vs. sgroup,active
3842          * => should be replaced
3843          */
3844         {
3845                 .line   = __location__,
3846                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3847                 .r1     = {
3848                         .owner          = &ctx->a,
3849                         .type           = WREPL_TYPE_MHOMED,
3850                         .state          = WREPL_STATE_TOMBSTONE,
3851                         .node           = WREPL_NODE_B,
3852                         .is_static      = false,
3853                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3854                         .ips            = addresses_A_1,
3855                         .apply_expected = true
3856                 },
3857                 .r2     = {
3858                         .owner          = &ctx->b,
3859                         .type           = WREPL_TYPE_SGROUP,
3860                         .state          = WREPL_STATE_ACTIVE,
3861                         .node           = WREPL_NODE_B,
3862                         .is_static      = false,
3863                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3864                         .ips            = addresses_B_1,
3865                         .apply_expected = true
3866                 }
3867         },
3868
3869         /*
3870          * mhomed,tombstone vs. sgroup,tombstone
3871          * => should be replaced
3872          */
3873         {
3874                 .line   = __location__,
3875                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3876                 .r1     = {
3877                         .owner          = &ctx->b,
3878                         .type           = WREPL_TYPE_MHOMED,
3879                         .state          = WREPL_STATE_TOMBSTONE,
3880                         .node           = WREPL_NODE_B,
3881                         .is_static      = false,
3882                         .num_ips        = ARRAY_SIZE(addresses_B_1),
3883                         .ips            = addresses_B_1,
3884                         .apply_expected = true
3885                 },
3886                 .r2     = {
3887                         .owner          = &ctx->a,
3888                         .type           = WREPL_TYPE_SGROUP,
3889                         .state          = WREPL_STATE_TOMBSTONE,
3890                         .node           = WREPL_NODE_B,
3891                         .is_static      = false,
3892                         .num_ips        = ARRAY_SIZE(addresses_A_1),
3893                         .ips            = addresses_A_1,
3894                         .apply_expected = true
3895                 }
3896         },
3897
3898 /*
3899  * multi homed vs. mlti homed section,
3900  */
3901         /*
3902          * mhomed,active vs. mhomed,active
3903          * => should be replaced
3904          */
3905         {
3906                 .line   = __location__,
3907                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3908                 .r1     = {
3909                         .owner          = &ctx->a,
3910                         .type           = WREPL_TYPE_MHOMED,
3911                         .state          = WREPL_STATE_ACTIVE,
3912                         .node           = WREPL_NODE_B,
3913                         .is_static      = false,
3914                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
3915                         .ips            = addresses_A_3_4,
3916                         .apply_expected = true
3917                 },
3918                 .r2     = {
3919                         .owner          = &ctx->b,
3920                         .type           = WREPL_TYPE_MHOMED,
3921                         .state          = WREPL_STATE_ACTIVE,
3922                         .node           = WREPL_NODE_B,
3923                         .is_static      = false,
3924                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
3925                         .ips            = addresses_B_3_4,
3926                         .apply_expected = true
3927                 }
3928         },
3929
3930         /*
3931          * mhomed,active vs. mhomed,tombstone
3932          * => should NOT be replaced
3933          */
3934         {
3935                 .line   = __location__,
3936                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3937                 .r1     = {
3938                         .owner          = &ctx->b,
3939                         .type           = WREPL_TYPE_MHOMED,
3940                         .state          = WREPL_STATE_ACTIVE,
3941                         .node           = WREPL_NODE_B,
3942                         .is_static      = false,
3943                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
3944                         .ips            = addresses_B_3_4,
3945                         .apply_expected = true
3946                 },
3947                 .r2     = {
3948                         .owner          = &ctx->a,
3949                         .type           = WREPL_TYPE_MHOMED,
3950                         .state          = WREPL_STATE_TOMBSTONE,
3951                         .node           = WREPL_NODE_B,
3952                         .is_static      = false,
3953                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
3954                         .ips            = addresses_B_3_4,
3955                         .apply_expected = false
3956                 }
3957         },
3958
3959         /*
3960          * mhomed,released vs. mhomed,active
3961          * => should be replaced
3962          */
3963         {
3964                 .line   = __location__,
3965                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3966                 .r1     = {
3967                         .owner          = &ctx->b,
3968                         .type           = WREPL_TYPE_MHOMED,
3969                         .state          = WREPL_STATE_RELEASED,
3970                         .node           = WREPL_NODE_B,
3971                         .is_static      = false,
3972                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
3973                         .ips            = addresses_B_3_4,
3974                         .apply_expected = false
3975                 },
3976                 .r2     = {
3977                         .owner          = &ctx->a,
3978                         .type           = WREPL_TYPE_MHOMED,
3979                         .state          = WREPL_STATE_ACTIVE,
3980                         .node           = WREPL_NODE_B,
3981                         .is_static      = false,
3982                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
3983                         .ips            = addresses_A_3_4,
3984                         .apply_expected = true
3985                 }
3986         },
3987
3988         /*
3989          * mhomed,released vs. mhomed,tombstone
3990          * => should be replaced
3991          */
3992         {
3993                 .line   = __location__,
3994                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3995                 .r1     = {
3996                         .owner          = &ctx->a,
3997                         .type           = WREPL_TYPE_MHOMED,
3998                         .state          = WREPL_STATE_RELEASED,
3999                         .node           = WREPL_NODE_B,
4000                         .is_static      = false,
4001                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
4002                         .ips            = addresses_A_3_4,
4003                         .apply_expected = false
4004                 },
4005                 .r2     = {
4006                         .owner          = &ctx->b,
4007                         .type           = WREPL_TYPE_MHOMED,
4008                         .state          = WREPL_STATE_TOMBSTONE,
4009                         .node           = WREPL_NODE_B,
4010                         .is_static      = false,
4011                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
4012                         .ips            = addresses_B_3_4,
4013                         .apply_expected = true
4014                 }
4015         },
4016
4017         /*
4018          * mhomed,tombstone vs. mhomed,active
4019          * => should be replaced
4020          */
4021         {
4022                 .line   = __location__,
4023                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4024                 .r1     = {
4025                         .owner          = &ctx->b,
4026                         .type           = WREPL_TYPE_MHOMED,
4027                         .state          = WREPL_STATE_TOMBSTONE,
4028                         .node           = WREPL_NODE_B,
4029                         .is_static      = false,
4030                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
4031                         .ips            = addresses_B_3_4,
4032                         .apply_expected = true
4033                 },
4034                 .r2     = {
4035                         .owner          = &ctx->a,
4036                         .type           = WREPL_TYPE_MHOMED,
4037                         .state          = WREPL_STATE_ACTIVE,
4038                         .node           = WREPL_NODE_B,
4039                         .is_static      = false,
4040                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
4041                         .ips            = addresses_A_3_4,
4042                         .apply_expected = true
4043                 }
4044         },
4045
4046         /*
4047          * mhomed,tombstone vs. mhomed,tombstone
4048          * => should be replaced
4049          */
4050         {
4051                 .line   = __location__,
4052                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4053                 .r1     = {
4054                         .owner          = &ctx->a,
4055                         .type           = WREPL_TYPE_MHOMED,
4056                         .state          = WREPL_STATE_TOMBSTONE,
4057                         .node           = WREPL_NODE_B,
4058                         .is_static      = false,
4059                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
4060                         .ips            = addresses_A_3_4,
4061                         .apply_expected = true
4062                 },
4063                 .r2     = {
4064                         .owner          = &ctx->b,
4065                         .type           = WREPL_TYPE_MHOMED,
4066                         .state          = WREPL_STATE_TOMBSTONE,
4067                         .node           = WREPL_NODE_B,
4068                         .is_static      = false,
4069                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
4070                         .ips            = addresses_B_3_4,
4071                         .apply_expected = true
4072                 }
4073         },
4074         {
4075                 .line   = __location__,
4076                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4077                 .cleanup= true,
4078                 .r1     = {
4079                         .owner          = &ctx->b,
4080                         .type           = WREPL_TYPE_UNIQUE,
4081                         .state          = WREPL_STATE_TOMBSTONE,
4082                         .node           = WREPL_NODE_B,
4083                         .is_static      = false,
4084                         .num_ips        = ARRAY_SIZE(addresses_B_1),
4085                         .ips            = addresses_B_1,
4086                         .apply_expected = true,
4087                 },
4088                 .r2     = {
4089                         .owner          = &ctx->a,
4090                         .type           = WREPL_TYPE_UNIQUE,
4091                         .state          = WREPL_STATE_TOMBSTONE,
4092                         .node           = WREPL_NODE_B,
4093                         .is_static      = false,
4094                         .num_ips        = ARRAY_SIZE(addresses_A_1),
4095                         .ips            = addresses_A_1,
4096                         .apply_expected = true,
4097                 }
4098         },
4099 /*
4100  * special group vs special group section,
4101  */
4102         /*
4103          * sgroup,active vs. sgroup,active same addresses
4104          * => should be NOT replaced
4105          */
4106         {
4107                 .line   = __location__,
4108                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4109                 .comment= "A:A_3_4 vs. B:A_3_4",
4110                 .extra  = true,
4111                 .r1     = {
4112                         .owner          = &ctx->a,
4113                         .type           = WREPL_TYPE_SGROUP,
4114                         .state          = WREPL_STATE_ACTIVE,
4115                         .node           = WREPL_NODE_B,
4116                         .is_static      = false,
4117                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
4118                         .ips            = addresses_A_3_4,
4119                         .apply_expected = true
4120                 },
4121                 .r2     = {
4122                         .owner          = &ctx->b,
4123                         .type           = WREPL_TYPE_SGROUP,
4124                         .state          = WREPL_STATE_ACTIVE,
4125                         .node           = WREPL_NODE_B,
4126                         .is_static      = false,
4127                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
4128                         .ips            = addresses_A_3_4,
4129                         .apply_expected = false,
4130                         .sgroup_cleanup = true
4131                 }
4132         },
4133         /*
4134          * sgroup,active vs. sgroup,active same addresses
4135          * => should be NOT replaced
4136          */
4137         {
4138                 .line   = __location__,
4139                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4140                 .comment= "A:A_3_4 vs. B:NULL",
4141                 .extra  = true,
4142                 .r1     = {
4143                         .owner          = &ctx->a,
4144                         .type           = WREPL_TYPE_SGROUP,
4145                         .state          = WREPL_STATE_ACTIVE,
4146                         .node           = WREPL_NODE_B,
4147                         .is_static      = false,
4148                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
4149                         .ips            = addresses_A_3_4,
4150                         .apply_expected = true
4151                 },
4152                 .r2     = {
4153                         .owner          = &ctx->b,
4154                         .type           = WREPL_TYPE_SGROUP,
4155                         .state          = WREPL_STATE_ACTIVE,
4156                         .node           = WREPL_NODE_B,
4157                         .is_static      = false,
4158                         .num_ips        = 0,
4159                         .ips            = NULL,
4160                         .apply_expected = false,
4161                         .sgroup_cleanup = true
4162                 }
4163         },
4164         /*
4165          * sgroup,active vs. sgroup,active subset addresses, special case...
4166          * => should NOT be replaced
4167          */
4168         {
4169                 .line   = __location__,
4170                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4171                 .comment= "A:A_3_4_X_3_4 vs. B:A_3_4",
4172                 .extra  = true,
4173                 .r1     = {
4174                         .owner          = &ctx->a,
4175                         .type           = WREPL_TYPE_SGROUP,
4176                         .state          = WREPL_STATE_ACTIVE,
4177                         .node           = WREPL_NODE_B,
4178                         .is_static      = false,
4179                         .num_ips        = ARRAY_SIZE(addresses_A_3_4_X_3_4),
4180                         .ips            = addresses_A_3_4_X_3_4,
4181                         .apply_expected = true,
4182                 },
4183                 .r2     = {
4184                         .owner          = &ctx->b,
4185                         .type           = WREPL_TYPE_SGROUP,
4186                         .state          = WREPL_STATE_ACTIVE,
4187                         .node           = WREPL_NODE_B,
4188                         .is_static      = false,
4189                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
4190                         .ips            = addresses_A_3_4,
4191                         .apply_expected = false,
4192                 }
4193         },
4194         {
4195                 .line   = __location__,
4196                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4197                 .cleanup= true,
4198                 .r1     = {
4199                         .owner          = &ctx->a,
4200                         .type           = WREPL_TYPE_SGROUP,
4201                         .state          = WREPL_STATE_ACTIVE,
4202                         .node           = WREPL_NODE_B,
4203                         .is_static      = false,
4204                         .num_ips        = 0,
4205                         .ips            = NULL,
4206                         .apply_expected = false,
4207                 },
4208                 .r2     = {
4209                         .owner          = &ctx->x,
4210                         .type           = WREPL_TYPE_SGROUP,
4211                         .state          = WREPL_STATE_ACTIVE,
4212                         .node           = WREPL_NODE_B,
4213                         .is_static      = false,
4214                         .num_ips        = 0,
4215                         .ips            = NULL,
4216                         .apply_expected = false,
4217                 }
4218         },
4219         /*
4220          * sgroup,active vs. sgroup,active different addresses, but owner changed
4221          * => should be replaced
4222          */
4223         {
4224                 .line   = __location__,
4225                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4226                 .comment= "A:B_3_4 vs. B:A_3_4",
4227                 .extra  = true,
4228                 .r1     = {
4229                         .owner          = &ctx->a,
4230                         .type           = WREPL_TYPE_SGROUP,
4231                         .state          = WREPL_STATE_ACTIVE,
4232                         .node           = WREPL_NODE_B,
4233                         .is_static      = false,
4234                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
4235                         .ips            = addresses_B_3_4,
4236                         .apply_expected = true,
4237                 },
4238                 .r2     = {
4239                         .owner          = &ctx->b,
4240                         .type           = WREPL_TYPE_SGROUP,
4241                         .state          = WREPL_STATE_ACTIVE,
4242                         .node           = WREPL_NODE_B,
4243                         .is_static      = false,
4244                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
4245                         .ips            = addresses_A_3_4,
4246                         .apply_expected = true,
4247                         .sgroup_cleanup = true
4248                 }
4249         },
4250         /*
4251          * sgroup,active vs. sgroup,active different addresses, but owner changed
4252          * => should be replaced
4253          */
4254         {
4255                 .line   = __location__,
4256                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4257                 .comment= "A:A_3_4 vs. B:A_3_4_OWNER_B",
4258                 .extra  = true,
4259                 .r1     = {
4260                         .owner          = &ctx->a,
4261                         .type           = WREPL_TYPE_SGROUP,
4262                         .state          = WREPL_STATE_ACTIVE,
4263                         .node           = WREPL_NODE_B,
4264                         .is_static      = false,
4265                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
4266                         .ips            = addresses_A_3_4,
4267                         .apply_expected = true,
4268                 },
4269                 .r2     = {
4270                         .owner          = &ctx->b,
4271                         .type           = WREPL_TYPE_SGROUP,
4272                         .state          = WREPL_STATE_ACTIVE,
4273                         .node           = WREPL_NODE_B,
4274                         .is_static      = false,
4275                         .num_ips        = ARRAY_SIZE(addresses_A_3_4_OWNER_B),
4276                         .ips            = addresses_A_3_4_OWNER_B,
4277                         .apply_expected = true,
4278                         .sgroup_cleanup = true
4279                 }
4280         },
4281         /*
4282          * sgroup,active vs. sgroup,active different addresses, but owner changed
4283          * => should be replaced
4284          */
4285         {
4286                 .line   = __location__,
4287                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4288                 .comment= "A:A_3_4_OWNER_B vs. B:A_3_4",
4289                 .extra  = true,
4290                 .r1     = {
4291                         .owner          = &ctx->a,
4292                         .type           = WREPL_TYPE_SGROUP,
4293                         .state          = WREPL_STATE_ACTIVE,
4294                         .node           = WREPL_NODE_B,
4295                         .is_static      = false,
4296                         .num_ips        = ARRAY_SIZE(addresses_A_3_4_OWNER_B),
4297                         .ips            = addresses_A_3_4_OWNER_B,
4298                         .apply_expected = true,
4299                 },
4300                 .r2     = {
4301                         .owner          = &ctx->b,
4302                         .type           = WREPL_TYPE_SGROUP,
4303                         .state          = WREPL_STATE_ACTIVE,
4304                         .node           = WREPL_NODE_B,
4305                         .is_static      = false,
4306                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
4307                         .ips            = addresses_A_3_4,
4308                         .apply_expected = true,
4309                         .sgroup_cleanup = true
4310                 }
4311         },
4312         /*
4313          * sgroup,active vs. sgroup,active different addresses
4314          * => should be merged
4315          */
4316         {
4317                 .line   = __location__,
4318                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4319                 .comment= "A:A_3_4 vs. B:B_3_4 => C:A_3_4_B_3_4",
4320                 .extra  = true,
4321                 .r1     = {
4322                         .owner          = &ctx->a,
4323                         .type           = WREPL_TYPE_SGROUP,
4324                         .state          = WREPL_STATE_ACTIVE,
4325                         .node           = WREPL_NODE_B,
4326                         .is_static      = false,
4327                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
4328                         .ips            = addresses_A_3_4,
4329                         .apply_expected = true,
4330                 },
4331                 .r2     = {
4332                         .owner          = &ctx->b,
4333                         .type           = WREPL_TYPE_SGROUP,
4334                         .state          = WREPL_STATE_ACTIVE,
4335                         .node           = WREPL_NODE_B,
4336                         .is_static      = false,
4337                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
4338                         .ips            = addresses_B_3_4,
4339                         .sgroup_merge   = true,
4340                         .sgroup_cleanup = true,
4341                 }
4342         },
4343         /*
4344          * sgroup,active vs. sgroup,active different addresses, special case...
4345          * => should be merged
4346          */
4347         {
4348                 .line   = __location__,
4349                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4350                 .comment= "A:B_3_4_X_3_4 vs. B:A_3_4 => B:A_3_4_X_3_4",
4351                 .extra  = true,
4352                 .r1     = {
4353                         .owner          = &ctx->a,
4354                         .type           = WREPL_TYPE_SGROUP,
4355                         .state          = WREPL_STATE_ACTIVE,
4356                         .node           = WREPL_NODE_B,
4357                         .is_static      = false,
4358                         .num_ips        = ARRAY_SIZE(addresses_B_3_4_X_3_4),
4359                         .ips            = addresses_B_3_4_X_3_4,
4360                         .apply_expected = true,
4361                 },
4362                 .r2     = {
4363                         .owner          = &ctx->b,
4364                         .type           = WREPL_TYPE_SGROUP,
4365                         .state          = WREPL_STATE_ACTIVE,
4366                         .node           = WREPL_NODE_B,
4367                         .is_static      = false,
4368                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
4369                         .ips            = addresses_A_3_4,
4370                         .sgroup_merge   = true,
4371                         .merge_owner    = &ctx->b,
4372                         .sgroup_cleanup = false
4373                 }
4374         },
4375         {
4376                 .line   = __location__,
4377                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4378                 .cleanup= true,
4379                 .r1     = {
4380                         .owner          = &ctx->b,
4381                         .type           = WREPL_TYPE_SGROUP,
4382                         .state          = WREPL_STATE_ACTIVE,
4383                         .node           = WREPL_NODE_B,
4384                         .is_static      = false,
4385                         .num_ips        = ARRAY_SIZE(addresses_A_3_4_X_3_4_OWNER_B),
4386                         .ips            = addresses_A_3_4_X_3_4_OWNER_B,
4387                         .apply_expected = true,
4388                 },
4389                 .r2     = {
4390                         .owner          = &ctx->b,
4391                         .type           = WREPL_TYPE_SGROUP,
4392                         .state          = WREPL_STATE_ACTIVE,
4393                         .node           = WREPL_NODE_B,
4394                         .is_static      = false,
4395                         .num_ips        = 0,
4396                         .ips            = NULL,
4397                         .apply_expected = false,
4398                 }
4399         },
4400         /*
4401          * sgroup,active vs. sgroup,active different addresses, special case...
4402          * => should be merged
4403          */
4404         {
4405                 .line   = __location__,
4406                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4407                 .comment= "A:X_3_4 vs. B:A_3_4 => C:A_3_4_X_3_4",
4408                 .extra  = true,
4409                 .r1     = {
4410                         .owner          = &ctx->a,
4411                         .type           = WREPL_TYPE_SGROUP,
4412                         .state          = WREPL_STATE_ACTIVE,
4413                         .node           = WREPL_NODE_B,
4414                         .is_static      = false,
4415                         .num_ips        = ARRAY_SIZE(addresses_X_3_4),
4416                         .ips            = addresses_X_3_4,
4417                         .apply_expected = true,
4418                 },
4419                 .r2     = {
4420                         .owner          = &ctx->b,
4421                         .type           = WREPL_TYPE_SGROUP,
4422                         .state          = WREPL_STATE_ACTIVE,
4423                         .node           = WREPL_NODE_B,
4424                         .is_static      = false,
4425                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
4426                         .ips            = addresses_A_3_4,
4427                         .sgroup_merge   = true,
4428                         .sgroup_cleanup = false
4429                 }
4430         },
4431         {
4432                 .line   = __location__,
4433                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4434                 .cleanup= true,
4435                 .r1     = {
4436                         .owner          = &ctx->a,
4437                         .type           = WREPL_TYPE_SGROUP,
4438                         .state          = WREPL_STATE_ACTIVE,
4439                         .node           = WREPL_NODE_B,
4440                         .is_static      = false,
4441                         .num_ips        = 0,
4442                         .ips            = NULL,
4443                         .apply_expected = false,
4444                 },
4445                 .r2     = {
4446                         .owner          = &ctx->x,
4447                         .type           = WREPL_TYPE_SGROUP,
4448                         .state          = WREPL_STATE_ACTIVE,
4449                         .node           = WREPL_NODE_B,
4450                         .is_static      = false,
4451                         .num_ips        = 0,
4452                         .ips            = NULL,
4453                         .apply_expected = false,
4454                 }
4455         },
4456         /*
4457          * sgroup,active vs. sgroup,active different addresses, special case...
4458          * => should be merged
4459          */
4460         {
4461                 .line   = __location__,
4462                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4463                 .comment= "A:A_3_4_X_3_4 vs. B:A_3_4_OWNER_B => B:A_3_4_OWNER_B_X_3_4",
4464                 .extra  = true,
4465                 .r1     = {
4466                         .owner          = &ctx->a,
4467                         .type           = WREPL_TYPE_SGROUP,
4468                         .state          = WREPL_STATE_ACTIVE,
4469                         .node           = WREPL_NODE_B,
4470                         .is_static      = false,
4471                         .num_ips        = ARRAY_SIZE(addresses_A_3_4_X_3_4),
4472                         .ips            = addresses_A_3_4_X_3_4,
4473                         .apply_expected = true,
4474                 },
4475                 .r2     = {
4476                         .owner          = &ctx->b,
4477                         .type           = WREPL_TYPE_SGROUP,
4478                         .state          = WREPL_STATE_ACTIVE,
4479                         .node           = WREPL_NODE_B,
4480                         .is_static      = false,
4481                         .num_ips        = ARRAY_SIZE(addresses_A_3_4_OWNER_B),
4482                         .ips            = addresses_A_3_4_OWNER_B,
4483                         .sgroup_merge   = true,
4484                         .merge_owner    = &ctx->b,
4485                 }
4486         },
4487         {
4488                 .line   = __location__,
4489                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4490                 .cleanup= true,
4491                 .r1     = {
4492                         .owner          = &ctx->b,
4493                         .type           = WREPL_TYPE_SGROUP,
4494                         .state          = WREPL_STATE_ACTIVE,
4495                         .node           = WREPL_NODE_B,
4496                         .is_static      = false,
4497                         .num_ips        = 0,
4498                         .ips            = NULL,
4499                         .apply_expected = false,
4500                 },
4501                 .r2     = {
4502                         .owner          = &ctx->x,
4503                         .type           = WREPL_TYPE_SGROUP,
4504                         .state          = WREPL_STATE_ACTIVE,
4505                         .node           = WREPL_NODE_B,
4506                         .is_static      = false,
4507                         .num_ips        = 0,
4508                         .ips            = NULL,
4509                         .apply_expected = false,
4510                 }
4511         },
4512         /*
4513          * sgroup,active vs. sgroup,active partly different addresses, special case...
4514          * => should be merged
4515          */
4516         {
4517                 .line   = __location__,
4518                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4519                 .comment= "A:B_3_4_X_3_4 vs. B:B_3_4_X_1_2 => C:B_3_4_X_1_2_3_4",
4520                 .extra  = true,
4521                 .r1     = {
4522                         .owner          = &ctx->a,
4523                         .type           = WREPL_TYPE_SGROUP,
4524                         .state          = WREPL_STATE_ACTIVE,
4525                         .node           = WREPL_NODE_B,
4526                         .is_static      = false,
4527                         .num_ips        = ARRAY_SIZE(addresses_B_3_4_X_3_4),
4528                         .ips            = addresses_B_3_4_X_3_4,
4529                         .apply_expected = true,
4530                 },
4531                 .r2     = {
4532                         .owner          = &ctx->b,
4533                         .type           = WREPL_TYPE_SGROUP,
4534                         .state          = WREPL_STATE_ACTIVE,
4535                         .node           = WREPL_NODE_B,
4536                         .is_static      = false,
4537                         .num_ips        = ARRAY_SIZE(addresses_B_3_4_X_1_2),
4538                         .ips            = addresses_B_3_4_X_1_2,
4539                         .sgroup_merge   = true,
4540                         .sgroup_cleanup = false
4541                 }
4542         },
4543         {
4544                 .line   = __location__,
4545                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4546                 .cleanup= true,
4547                 .r1     = {
4548                         .owner          = &ctx->b,
4549                         .type           = WREPL_TYPE_SGROUP,
4550                         .state          = WREPL_STATE_ACTIVE,
4551                         .node           = WREPL_NODE_B,
4552                         .is_static      = false,
4553                         .num_ips        = 0,
4554                         .ips            = NULL,
4555                         .apply_expected = false,
4556                 },
4557                 .r2     = {
4558                         .owner          = &ctx->x,
4559                         .type           = WREPL_TYPE_SGROUP,
4560                         .state          = WREPL_STATE_ACTIVE,
4561                         .node           = WREPL_NODE_B,
4562                         .is_static      = false,
4563                         .num_ips        = 0,
4564                         .ips            = NULL,
4565                         .apply_expected = false,
4566                 }
4567         },
4568         /*
4569          * sgroup,active vs. sgroup,active different addresses, special case...
4570          * => should be merged
4571          */
4572         {
4573                 .line   = __location__,
4574                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4575                 .comment= "A:A_3_4_B_3_4 vs. B:NULL => B:A_3_4",
4576                 .extra  = true,
4577                 .r1     = {
4578                         .owner          = &ctx->a,
4579                         .type           = WREPL_TYPE_SGROUP,
4580                         .state          = WREPL_STATE_ACTIVE,
4581                         .node           = WREPL_NODE_B,
4582                         .is_static      = false,
4583                         .num_ips        = ARRAY_SIZE(addresses_A_3_4_B_3_4),
4584                         .ips            = addresses_A_3_4_B_3_4,
4585                         .apply_expected = true,
4586                 },
4587                 .r2     = {
4588                         .owner          = &ctx->b,
4589                         .type           = WREPL_TYPE_SGROUP,
4590                         .state          = WREPL_STATE_ACTIVE,
4591                         .node           = WREPL_NODE_B,
4592                         .is_static      = false,
4593                         .num_ips        = 0,
4594                         .ips            = NULL,
4595                         .sgroup_merge   = true,
4596                         .merge_owner    = &ctx->b,
4597                         .sgroup_cleanup = true
4598                 }
4599         },
4600         {
4601                 .line   = __location__,
4602                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4603                 .cleanup= true,
4604                 .r1     = {
4605                         .owner          = &ctx->a,
4606                         .type           = WREPL_TYPE_SGROUP,
4607                         .state          = WREPL_STATE_ACTIVE,
4608                         .node           = WREPL_NODE_B,
4609                         .is_static      = false,
4610                         .num_ips        = 0,
4611                         .ips            = NULL,
4612                         .apply_expected = false,
4613                 },
4614                 .r2     = {
4615                         .owner          = &ctx->a,
4616                         .type           = WREPL_TYPE_UNIQUE,
4617                         .state          = WREPL_STATE_TOMBSTONE,
4618                         .node           = WREPL_NODE_B,
4619                         .is_static      = false,
4620                         .num_ips        = ARRAY_SIZE(addresses_A_1),
4621                         .ips            = addresses_A_1,
4622                         .apply_expected = true,
4623                 }
4624         },
4625         /*
4626          * sgroup,active vs. sgroup,active different addresses, special case...
4627          * => should be merged
4628          */
4629         {
4630                 .line   = __location__,
4631                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4632                 .comment= "A:B_3_4_X_3_4 vs. B:NULL => B:X_3_4",
4633                 .extra  = true,
4634                 .r1     = {
4635                         .owner          = &ctx->a,
4636                         .type           = WREPL_TYPE_SGROUP,
4637                         .state          = WREPL_STATE_ACTIVE,
4638                         .node           = WREPL_NODE_B,
4639                         .is_static      = false,
4640                         .num_ips        = ARRAY_SIZE(addresses_B_3_4_X_3_4),
4641                         .ips            = addresses_B_3_4_X_3_4,
4642                         .apply_expected = true,
4643                 },
4644                 .r2     = {
4645                         .owner          = &ctx->b,
4646                         .type           = WREPL_TYPE_SGROUP,
4647                         .state          = WREPL_STATE_ACTIVE,
4648                         .node           = WREPL_NODE_B,
4649                         .is_static      = false,
4650                         .num_ips        = 0,
4651                         .ips            = NULL,
4652                         .sgroup_merge   = true,
4653                         .merge_owner    = &ctx->b,
4654                         .sgroup_cleanup = true
4655                 }
4656         },
4657         {
4658                 .line   = __location__,
4659                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4660                 .cleanup= true,
4661                 .r1     = {
4662                         .owner          = &ctx->x,
4663                         .type           = WREPL_TYPE_SGROUP,
4664                         .state          = WREPL_STATE_ACTIVE,
4665                         .node           = WREPL_NODE_B,
4666                         .is_static      = false,
4667                         .num_ips        = 0,
4668                         .ips            = NULL,
4669                         .apply_expected = false,
4670                 },
4671                 .r2     = {
4672                         .owner          = &ctx->x,
4673                         .type           = WREPL_TYPE_UNIQUE,
4674                         .state          = WREPL_STATE_TOMBSTONE,
4675                         .node           = WREPL_NODE_B,
4676                         .is_static      = false,
4677                         .num_ips        = ARRAY_SIZE(addresses_A_1),
4678                         .ips            = addresses_A_1,
4679                         .apply_expected = true,
4680                 }
4681         },
4682
4683         /*
4684          * sgroup,active vs. sgroup,tombstone different no addresses, special
4685          * => should be replaced
4686          */
4687         {
4688                 .line   = __location__,
4689                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4690                 .comment= "A:B_3_4_X_3_4 vs. B:NULL => B:NULL",
4691                 .extra  = true,
4692                 .r1     = {
4693                         .owner          = &ctx->a,
4694                         .type           = WREPL_TYPE_SGROUP,
4695                         .state          = WREPL_STATE_ACTIVE,
4696                         .node           = WREPL_NODE_B,
4697                         .is_static      = false,
4698                         .num_ips        = ARRAY_SIZE(addresses_B_3_4_X_3_4),
4699                         .ips            = addresses_B_3_4_X_3_4,
4700                         .apply_expected = true,
4701                 },
4702                 .r2     = {
4703                         .owner          = &ctx->b,
4704                         .type           = WREPL_TYPE_SGROUP,
4705                         .state          = WREPL_STATE_TOMBSTONE,
4706                         .node           = WREPL_NODE_B,
4707                         .is_static      = false,
4708                         .num_ips        = 0,
4709                         .ips            = NULL,
4710                         .apply_expected = true,
4711                 }
4712         },
4713         /*
4714          * sgroup,active vs. sgroup,tombstone different addresses
4715          * => should be replaced
4716          */
4717         {
4718                 .line   = __location__,
4719                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4720                 .comment= "A:B_3_4_X_3_4 vs. B:A_3_4 => B:A_3_4",
4721                 .extra  = true,
4722                 .r1     = {
4723                         .owner          = &ctx->a,
4724                         .type           = WREPL_TYPE_SGROUP,
4725                         .state          = WREPL_STATE_ACTIVE,
4726                         .node           = WREPL_NODE_B,
4727                         .is_static      = false,
4728                         .num_ips        = ARRAY_SIZE(addresses_B_3_4_X_3_4),
4729                         .ips            = addresses_B_3_4_X_3_4,
4730                         .apply_expected = true,
4731                 },
4732                 .r2     = {
4733                         .owner          = &ctx->b,
4734                         .type           = WREPL_TYPE_SGROUP,
4735                         .state          = WREPL_STATE_TOMBSTONE,
4736                         .node           = WREPL_NODE_B,
4737                         .is_static      = false,
4738                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
4739                         .ips            = addresses_A_3_4,
4740                         .apply_expected = true,
4741                 }
4742         },
4743         /*
4744          * sgroup,active vs. sgroup,tombstone subset addresses
4745          * => should be replaced
4746          */
4747         {
4748                 .line   = __location__,
4749                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4750                 .comment= "A:B_3_4_X_3_4 vs. B:B_3_4 => B:B_3_4",
4751                 .extra  = true,
4752                 .r1     = {
4753                         .owner          = &ctx->a,
4754                         .type           = WREPL_TYPE_SGROUP,
4755                         .state          = WREPL_STATE_ACTIVE,
4756                         .node           = WREPL_NODE_B,
4757                         .is_static      = false,
4758                         .num_ips        = ARRAY_SIZE(addresses_B_3_4_X_3_4),
4759                         .ips            = addresses_B_3_4_X_3_4,
4760                         .apply_expected = true,
4761                 },
4762                 .r2     = {
4763                         .owner          = &ctx->b,
4764                         .type           = WREPL_TYPE_SGROUP,
4765                         .state          = WREPL_STATE_TOMBSTONE,
4766                         .node           = WREPL_NODE_B,
4767                         .is_static      = false,
4768                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
4769                         .ips            = addresses_B_3_4,
4770                         .apply_expected = true,
4771                 }
4772         },
4773         /*
4774          * sgroup,active vs. sgroup,active same addresses
4775          * => should be replaced
4776          */
4777         {
4778                 .line   = __location__,
4779                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4780                 .comment= "A:B_3_4_X_3_4 vs. B:B_3_4_X_3_4 => B:B_3_4_X_3_4",
4781                 .extra  = true,
4782                 .r1     = {
4783                         .owner          = &ctx->a,
4784                         .type           = WREPL_TYPE_SGROUP,
4785                         .state          = WREPL_STATE_ACTIVE,
4786                         .node           = WREPL_NODE_B,
4787                         .is_static      = false,
4788                         .num_ips        = ARRAY_SIZE(addresses_B_3_4_X_3_4),
4789                         .ips            = addresses_B_3_4_X_3_4,
4790                         .apply_expected = true,
4791                 },
4792                 .r2     = {
4793                         .owner          = &ctx->b,
4794                         .type           = WREPL_TYPE_SGROUP,
4795                         .state          = WREPL_STATE_TOMBSTONE,
4796                         .node           = WREPL_NODE_B,
4797                         .is_static      = false,
4798                         .num_ips        = ARRAY_SIZE(addresses_B_3_4_X_3_4),
4799                         .ips            = addresses_B_3_4_X_3_4,
4800                         .apply_expected = true,
4801                 }
4802         },
4803
4804         /*
4805          * This should be the last record in this array,
4806          * we need to make sure the we leave a tombstoned unique entry
4807          * owned by OWNER_A
4808          */
4809         {
4810                 .line   = __location__,
4811                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4812                 .cleanup= true,
4813                 .r1     = {
4814                         .owner          = &ctx->a,
4815                         .type           = WREPL_TYPE_UNIQUE,
4816                         .state          = WREPL_STATE_TOMBSTONE,
4817                         .node           = WREPL_NODE_B,
4818                         .is_static      = false,
4819                         .num_ips        = ARRAY_SIZE(addresses_A_1),
4820                         .ips            = addresses_A_1,
4821                         .apply_expected = true
4822                 },
4823                 .r2     = {
4824                         .owner          = &ctx->a,
4825                         .type           = WREPL_TYPE_UNIQUE,
4826                         .state          = WREPL_STATE_TOMBSTONE,
4827                         .node           = WREPL_NODE_B,
4828                         .is_static      = false,
4829                         .num_ips        = ARRAY_SIZE(addresses_A_1),
4830                         .ips            = addresses_A_1,
4831                         .apply_expected = true
4832                 }
4833         }}; /* do not add entries here, this should be the last record! */
4834
4835         wins_name_r1    = &wins_name1;
4836         wins_name_r2    = &wins_name2;
4837
4838         torture_comment(tctx, "Test Replica Conflicts with different owners\n");
4839
4840         for(i=0; ret && i < ARRAY_SIZE(records); i++) {
4841
4842                 if (!records[i].extra && !records[i].cleanup) {
4843                         /* we should test the worst cases */
4844                         if (records[i].r2.apply_expected && records[i].r1.ips==records[i].r2.ips) {
4845                                 torture_comment(tctx, "(%s) Programmer error, invalid record[%u]: %s\n",
4846                                         __location__, i, records[i].line);
4847                                 return false;
4848                         } else if (!records[i].r2.apply_expected && records[i].r1.ips!=records[i].r2.ips) {
4849                                 torture_comment(tctx, "(%s) Programmer error, invalid record[%u]: %s\n",
4850                                         __location__, i, records[i].line);
4851                                 return false;
4852                         }
4853                 }
4854
4855                 if (!records[i].cleanup) {
4856                         const char *expected;
4857                         const char *ips;
4858
4859                         if (records[i].r2.sgroup_merge) {
4860                                 expected = "SGROUP_MERGE";
4861                         } else if (records[i].r2.apply_expected) {
4862                                 expected = "REPLACE";
4863                         } else {
4864                                 expected = "NOT REPLACE";
4865                         }
4866
4867                         if (!records[i].r1.ips && !records[i].r2.ips) {
4868                                 ips = "with no ip(s)";
4869                         } else if (records[i].r1.ips==records[i].r2.ips) {
4870                                 ips = "with same ip(s)";
4871                         } else {
4872                                 ips = "with different ip(s)";
4873                         }
4874
4875                         torture_comment(tctx, "%s,%s%s vs. %s,%s%s %s => %s\n",
4876                                 wrepl_name_type_string(records[i].r1.type),
4877                                 wrepl_name_state_string(records[i].r1.state),
4878                                 (records[i].r1.is_static?",static":""),
4879                                 wrepl_name_type_string(records[i].r2.type),
4880                                 wrepl_name_state_string(records[i].r2.state),
4881                                 (records[i].r2.is_static?",static":""),
4882                                 (records[i].comment?records[i].comment:ips),
4883                                 expected);
4884                 }
4885
4886                 /*
4887                  * Setup R1
4888                  */
4889                 wins_name_r1->name      = &records[i].name;
4890                 wins_name_r1->flags     = WREPL_NAME_FLAGS(records[i].r1.type,
4891                                                            records[i].r1.state,
4892                                                            records[i].r1.node,
4893                                                            records[i].r1.is_static);
4894                 wins_name_r1->id        = ++records[i].r1.owner->max_version;
4895                 if (wins_name_r1->flags & 2) {
4896                         wins_name_r1->addresses.addresses.num_ips = records[i].r1.num_ips;
4897                         wins_name_r1->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
4898                                                                     records[i].r1.ips);
4899                 } else {
4900                         wins_name_r1->addresses.ip = records[i].r1.ips[0].ip;
4901                 }
4902                 wins_name_r1->unknown   = "255.255.255.255";
4903
4904                 /* now apply R1 */
4905                 ret &= test_wrepl_update_one(tctx, ctx, records[i].r1.owner, wins_name_r1);
4906                 ret &= test_wrepl_is_applied(tctx, ctx, records[i].r1.owner,
4907                                              wins_name_r1, records[i].r1.apply_expected);
4908
4909                 /*
4910                  * Setup R2
4911                  */
4912                 wins_name_r2->name      = &records[i].name;
4913                 wins_name_r2->flags     = WREPL_NAME_FLAGS(records[i].r2.type,
4914                                                            records[i].r2.state,
4915                                                            records[i].r2.node,
4916                                                            records[i].r2.is_static);
4917                 wins_name_r2->id        = ++records[i].r2.owner->max_version;
4918                 if (wins_name_r2->flags & 2) {
4919                         wins_name_r2->addresses.addresses.num_ips = records[i].r2.num_ips;
4920                         wins_name_r2->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
4921                                                                     records[i].r2.ips);
4922                 } else {
4923                         wins_name_r2->addresses.ip = records[i].r2.ips[0].ip;
4924                 }
4925                 wins_name_r2->unknown   = "255.255.255.255";
4926
4927                 /* now apply R2 */
4928                 ret &= test_wrepl_update_one(tctx, ctx, records[i].r2.owner, wins_name_r2);
4929                 if (records[i].r1.state == WREPL_STATE_RELEASED) {
4930                         ret &= test_wrepl_is_applied(tctx, ctx, records[i].r1.owner,
4931                                                      wins_name_r1, false);
4932                 } else if (records[i].r2.sgroup_merge) {
4933                         ret &= test_wrepl_sgroup_merged(tctx, ctx, records[i].r2.merge_owner,
4934                                                         records[i].r1.owner,
4935                                                         records[i].r1.num_ips, records[i].r1.ips,
4936                                                         records[i].r2.owner,
4937                                                         records[i].r2.num_ips, records[i].r2.ips,
4938                                                         wins_name_r2);
4939                 } else if (records[i].r1.owner != records[i].r2.owner) {
4940                         bool _expected;
4941                         _expected = (records[i].r1.apply_expected && !records[i].r2.apply_expected);
4942                         ret &= test_wrepl_is_applied(tctx, ctx, records[i].r1.owner,
4943                                                      wins_name_r1, _expected);
4944                 }
4945                 if (records[i].r2.state == WREPL_STATE_RELEASED) {
4946                         ret &= test_wrepl_is_applied(tctx, ctx, records[i].r2.owner,
4947                                                      wins_name_r2, false);
4948                 } else if (!records[i].r2.sgroup_merge) {
4949                         ret &= test_wrepl_is_applied(tctx, ctx, records[i].r2.owner,
4950                                                      wins_name_r2, records[i].r2.apply_expected);
4951                 }
4952
4953                 if (records[i].r2.sgroup_cleanup) {
4954                         if (!ret) {
4955                                 torture_comment(tctx, "failed before sgroup_cleanup record[%u]: %s\n", i, records[i].line);
4956                                 return ret;
4957                         }
4958
4959                         /* clean up the SGROUP record */
4960                         wins_name_r1->name      = &records[i].name;
4961                         wins_name_r1->flags     = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
4962                                                                    WREPL_STATE_ACTIVE,
4963                                                                    WREPL_NODE_B, false);
4964                         wins_name_r1->id        = ++records[i].r1.owner->max_version;
4965                         wins_name_r1->addresses.addresses.num_ips = 0;
4966                         wins_name_r1->addresses.addresses.ips     = NULL;
4967                         wins_name_r1->unknown   = "255.255.255.255";
4968                         ret &= test_wrepl_update_one(tctx, ctx, records[i].r1.owner, wins_name_r1);
4969
4970                         /* here we test how names from an owner are deleted */
4971                         if (records[i].r2.sgroup_merge && records[i].r2.num_ips) {
4972                                 ret &= test_wrepl_sgroup_merged(tctx, ctx, NULL,
4973                                                                 records[i].r2.owner,
4974                                                                 records[i].r2.num_ips, records[i].r2.ips,
4975                                                                 records[i].r1.owner,
4976                                                                 0, NULL,
4977                                                                 wins_name_r2);
4978                         }
4979
4980                         /* clean up the SGROUP record */
4981                         wins_name_r2->name      = &records[i].name;
4982                         wins_name_r2->flags     = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
4983                                                                    WREPL_STATE_ACTIVE,
4984                                                                    WREPL_NODE_B, false);
4985                         wins_name_r2->id        = ++records[i].r2.owner->max_version;
4986                         wins_name_r2->addresses.addresses.num_ips = 0;
4987                         wins_name_r2->addresses.addresses.ips     = NULL;
4988                         wins_name_r2->unknown   = "255.255.255.255";
4989                         ret &= test_wrepl_update_one(tctx, ctx, records[i].r2.owner, wins_name_r2);
4990
4991                         /* take ownership of the SGROUP record */
4992                         wins_name_r2->name      = &records[i].name;
4993                         wins_name_r2->flags     = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
4994                                                                    WREPL_STATE_ACTIVE,
4995                                                                    WREPL_NODE_B, false);
4996                         wins_name_r2->id        = ++records[i].r2.owner->max_version;
4997                         wins_name_r2->addresses.addresses.num_ips = ARRAY_SIZE(addresses_B_1);
4998                         wins_name_r2->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
4999                                                                     addresses_B_1);
5000                         wins_name_r2->unknown   = "255.255.255.255";
5001                         ret &= test_wrepl_update_one(tctx, ctx, records[i].r2.owner, wins_name_r2);
5002                         ret &= test_wrepl_is_applied(tctx, ctx, records[i].r2.owner, wins_name_r2, true);
5003
5004                         /* overwrite the SGROUP record with unique,tombstone */
5005                         wins_name_r2->name      = &records[i].name;
5006                         wins_name_r2->flags     = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
5007                                                                    WREPL_STATE_TOMBSTONE,
5008                                                                    WREPL_NODE_B, false);
5009                         wins_name_r2->id        = ++records[i].r2.owner->max_version;
5010                         wins_name_r2->addresses.addresses.num_ips = ARRAY_SIZE(addresses_B_1);
5011                         wins_name_r2->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
5012                                                                     addresses_B_1);
5013                         wins_name_r2->unknown   = "255.255.255.255";
5014                         ret &= test_wrepl_update_one(tctx, ctx, records[i].r2.owner, wins_name_r2);
5015                         ret &= test_wrepl_is_applied(tctx, ctx, records[i].r2.owner, wins_name_r2, true);
5016
5017                         if (!ret) {
5018                                 torture_comment(tctx, "failed in sgroup_cleanup record[%u]: %s\n", i, records[i].line);
5019                                 return ret;
5020                         }
5021                 }
5022
5023                 /* the first one is a cleanup run */
5024                 if (!ret && i == 0) ret = true;
5025
5026                 if (!ret) {
5027                         torture_comment(tctx, "conflict handled wrong or record[%u]: %s\n", i, records[i].line);
5028                         return ret;
5029                 }
5030         }
5031
5032         return ret;
5033 }
5034
5035 static bool test_conflict_owned_released_vs_replica(struct torture_context *tctx,
5036                                                                                                         struct test_wrepl_conflict_conn *ctx)
5037 {
5038         bool ret = true;
5039         NTSTATUS status;
5040         struct wrepl_wins_name wins_name_;
5041         struct wrepl_wins_name *wins_name = &wins_name_;
5042         struct nbt_name_register name_register_;
5043         struct nbt_name_register *name_register = &name_register_;
5044         struct nbt_name_release release_;
5045         struct nbt_name_release *release = &release_;
5046         uint32_t i;
5047         struct {
5048                 const char *line; /* just better debugging */
5049                 struct nbt_name name;
5050                 struct {
5051                         uint32_t nb_flags;
5052                         bool mhomed;
5053                         uint32_t num_ips;
5054                         const struct wrepl_ip *ips;
5055                         bool apply_expected;
5056                 } wins;
5057                 struct {
5058                         enum wrepl_name_type type;
5059                         enum wrepl_name_state state;
5060                         enum wrepl_name_node node;
5061                         bool is_static;
5062                         uint32_t num_ips;
5063                         const struct wrepl_ip *ips;
5064                         bool apply_expected;
5065                 } replica;
5066         } records[] = {
5067 /*
5068  * unique vs. unique section
5069  */
5070         /*
5071          * unique,released vs. unique,active with same ip(s)
5072          */
5073         {
5074                 .line   = __location__,
5075                 .name   = _NBT_NAME("_UR_UA_SI", 0x00, NULL),
5076                 .wins   = {
5077                         .nb_flags       = 0,
5078                         .mhomed         = false,
5079                         .num_ips        = ctx->addresses_best_num,
5080                         .ips            = ctx->addresses_best,
5081                         .apply_expected = true
5082                 },
5083                 .replica= {
5084                         .type           = WREPL_TYPE_UNIQUE,
5085                         .state          = WREPL_STATE_ACTIVE,
5086                         .node           = WREPL_NODE_B,
5087                         .is_static      = false,
5088                         .num_ips        = ctx->addresses_best_num,
5089                         .ips            = ctx->addresses_best,
5090                         .apply_expected = true
5091                 },
5092         },
5093         /*
5094          * unique,released vs. unique,active with different ip(s)
5095          */
5096         {
5097                 .line   = __location__,
5098                 .name   = _NBT_NAME("_UR_UA_DI", 0x00, NULL),
5099                 .wins   = {
5100                         .nb_flags       = 0,
5101                         .mhomed         = false,
5102                         .num_ips        = ctx->addresses_best_num,
5103                         .ips            = ctx->addresses_best,
5104                         .apply_expected = true
5105                 },
5106                 .replica= {
5107                         .type           = WREPL_TYPE_UNIQUE,
5108                         .state          = WREPL_STATE_ACTIVE,
5109                         .node           = WREPL_NODE_B,
5110                         .is_static      = false,
5111                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5112                         .ips            = addresses_B_1,
5113                         .apply_expected = true
5114                 },
5115         },
5116         /*
5117          * unique,released vs. unique,tombstone with same ip(s)
5118          */
5119         {
5120                 .line   = __location__,
5121                 .name   = _NBT_NAME("_UR_UT_SI", 0x00, NULL),
5122                 .wins   = {
5123                         .nb_flags       = 0,
5124                         .mhomed         = false,
5125                         .num_ips        = ctx->addresses_best_num,
5126                         .ips            = ctx->addresses_best,
5127                         .apply_expected = true
5128                 },
5129                 .replica= {
5130                         .type           = WREPL_TYPE_UNIQUE,
5131                         .state          = WREPL_STATE_TOMBSTONE,
5132                         .node           = WREPL_NODE_B,
5133                         .is_static      = false,
5134                         .num_ips        = ctx->addresses_best_num,
5135                         .ips            = ctx->addresses_best,
5136                         .apply_expected = true
5137                 },
5138         },
5139         /*
5140          * unique,released vs. unique,tombstone with different ip(s)
5141          */
5142         {
5143                 .line   = __location__,
5144                 .name   = _NBT_NAME("_UR_UT_DI", 0x00, NULL),
5145                 .wins   = {
5146                         .nb_flags       = 0,
5147                         .mhomed         = false,
5148                         .num_ips        = ctx->addresses_best_num,
5149                         .ips            = ctx->addresses_best,
5150                         .apply_expected = true
5151                 },
5152                 .replica= {
5153                         .type           = WREPL_TYPE_UNIQUE,
5154                         .state          = WREPL_STATE_TOMBSTONE,
5155                         .node           = WREPL_NODE_B,
5156                         .is_static      = false,
5157                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5158                         .ips            = addresses_B_1,
5159                         .apply_expected = true
5160                 },
5161         },
5162 /*
5163  * unique vs. group section
5164  */
5165         /*
5166          * unique,released vs. group,active with same ip(s)
5167          */
5168         {
5169                 .line   = __location__,
5170                 .name   = _NBT_NAME("_UR_GA_SI", 0x00, NULL),
5171                 .wins   = {
5172                         .nb_flags       = 0,
5173                         .mhomed         = false,
5174                         .num_ips        = ctx->addresses_best_num,
5175                         .ips            = ctx->addresses_best,
5176                         .apply_expected = true
5177                 },
5178                 .replica= {
5179                         .type           = WREPL_TYPE_GROUP,
5180                         .state          = WREPL_STATE_ACTIVE,
5181                         .node           = WREPL_NODE_B,
5182                         .is_static      = false,
5183                         .num_ips        = ctx->addresses_best_num,
5184                         .ips            = ctx->addresses_best,
5185                         .apply_expected = true
5186                 },
5187         },
5188         /*
5189          * unique,released vs. group,active with different ip(s)
5190          */
5191         {
5192                 .line   = __location__,
5193                 .name   = _NBT_NAME("_UR_GA_DI", 0x00, NULL),
5194                 .wins   = {
5195                         .nb_flags       = 0,
5196                         .mhomed         = false,
5197                         .num_ips        = ctx->addresses_best_num,
5198                         .ips            = ctx->addresses_best,
5199                         .apply_expected = true
5200                 },
5201                 .replica= {
5202                         .type           = WREPL_TYPE_GROUP,
5203                         .state          = WREPL_STATE_ACTIVE,
5204                         .node           = WREPL_NODE_B,
5205                         .is_static      = false,
5206                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5207                         .ips            = addresses_B_1,
5208                         .apply_expected = true
5209                 },
5210         },
5211         /*
5212          * unique,released vs. group,tombstone with same ip(s)
5213          */
5214         {
5215                 .line   = __location__,
5216                 .name   = _NBT_NAME("_UR_GT_SI", 0x00, NULL),
5217                 .wins   = {
5218                         .nb_flags       = 0,
5219                         .mhomed         = false,
5220                         .num_ips        = ctx->addresses_best_num,
5221                         .ips            = ctx->addresses_best,
5222                         .apply_expected = true
5223                 },
5224                 .replica= {
5225                         .type           = WREPL_TYPE_GROUP,
5226                         .state          = WREPL_STATE_TOMBSTONE,
5227                         .node           = WREPL_NODE_B,
5228                         .is_static      = false,
5229                         .num_ips        = ctx->addresses_best_num,
5230                         .ips            = ctx->addresses_best,
5231                         .apply_expected = true
5232                 },
5233         },
5234         /*
5235          * unique,released vs. group,tombstone with different ip(s)
5236          */
5237         {
5238                 .line   = __location__,
5239                 .name   = _NBT_NAME("_UR_GT_DI", 0x00, NULL),
5240                 .wins   = {
5241                         .nb_flags       = 0,
5242                         .mhomed         = false,
5243                         .num_ips        = ctx->addresses_best_num,
5244                         .ips            = ctx->addresses_best,
5245                         .apply_expected = true
5246                 },
5247                 .replica= {
5248                         .type           = WREPL_TYPE_GROUP,
5249                         .state          = WREPL_STATE_TOMBSTONE,
5250                         .node           = WREPL_NODE_B,
5251                         .is_static      = false,
5252                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5253                         .ips            = addresses_B_1,
5254                         .apply_expected = true
5255                 },
5256         },
5257 /*
5258  * unique vs. special group section
5259  */
5260         /*
5261          * unique,released vs. sgroup,active with same ip(s)
5262          */
5263         {
5264                 .line   = __location__,
5265                 .name   = _NBT_NAME("_UR_SA_SI", 0x00, NULL),
5266                 .wins   = {
5267                         .nb_flags       = 0,
5268                         .mhomed         = false,
5269                         .num_ips        = ctx->addresses_best_num,
5270                         .ips            = ctx->addresses_best,
5271                         .apply_expected = true
5272                 },
5273                 .replica= {
5274                         .type           = WREPL_TYPE_SGROUP,
5275                         .state          = WREPL_STATE_ACTIVE,
5276                         .node           = WREPL_NODE_B,
5277                         .is_static      = false,
5278                         .num_ips        = ctx->addresses_best_num,
5279                         .ips            = ctx->addresses_best,
5280                         .apply_expected = true
5281                 },
5282         },
5283         /*
5284          * unique,released vs. sgroup,active with different ip(s)
5285          */
5286         {
5287                 .line   = __location__,
5288                 .name   = _NBT_NAME("_UR_SA_DI", 0x00, NULL),
5289                 .wins   = {
5290                         .nb_flags       = 0,
5291                         .mhomed         = false,
5292                         .num_ips        = ctx->addresses_best_num,
5293                         .ips            = ctx->addresses_best,
5294                         .apply_expected = true
5295                 },
5296                 .replica= {
5297                         .type           = WREPL_TYPE_SGROUP,
5298                         .state          = WREPL_STATE_ACTIVE,
5299                         .node           = WREPL_NODE_B,
5300                         .is_static      = false,
5301                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5302                         .ips            = addresses_B_1,
5303                         .apply_expected = true
5304                 },
5305         },
5306         /*
5307          * unique,released vs. sgroup,tombstone with same ip(s)
5308          */
5309         {
5310                 .line   = __location__,
5311                 .name   = _NBT_NAME("_UR_ST_SI", 0x00, NULL),
5312                 .wins   = {
5313                         .nb_flags       = 0,
5314                         .mhomed         = false,
5315                         .num_ips        = ctx->addresses_best_num,
5316                         .ips            = ctx->addresses_best,
5317                         .apply_expected = true
5318                 },
5319                 .replica= {
5320                         .type           = WREPL_TYPE_SGROUP,
5321                         .state          = WREPL_STATE_TOMBSTONE,
5322                         .node           = WREPL_NODE_B,
5323                         .is_static      = false,
5324                         .num_ips        = ctx->addresses_best_num,
5325                         .ips            = ctx->addresses_best,
5326                         .apply_expected = true
5327                 },
5328         },
5329         /*
5330          * unique,released vs. sgroup,tombstone with different ip(s)
5331          */
5332         {
5333                 .line   = __location__,
5334                 .name   = _NBT_NAME("_UR_ST_DI", 0x00, NULL),
5335                 .wins   = {
5336                         .nb_flags       = 0,
5337                         .mhomed         = false,
5338                         .num_ips        = ctx->addresses_best_num,
5339                         .ips            = ctx->addresses_best,
5340                         .apply_expected = true
5341                 },
5342                 .replica= {
5343                         .type           = WREPL_TYPE_SGROUP,
5344                         .state          = WREPL_STATE_TOMBSTONE,
5345                         .node           = WREPL_NODE_B,
5346                         .is_static      = false,
5347                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5348                         .ips            = addresses_B_1,
5349                         .apply_expected = true
5350                 },
5351         },
5352 /*
5353  * unique vs. multi homed section
5354  */
5355         /*
5356          * unique,released vs. mhomed,active with same ip(s)
5357          */
5358         {
5359                 .line   = __location__,
5360                 .name   = _NBT_NAME("_UR_MA_SI", 0x00, NULL),
5361                 .wins   = {
5362                         .nb_flags       = 0,
5363                         .mhomed         = false,
5364                         .num_ips        = ctx->addresses_best_num,
5365                         .ips            = ctx->addresses_best,
5366                         .apply_expected = true
5367                 },
5368                 .replica= {
5369                         .type           = WREPL_TYPE_MHOMED,
5370                         .state          = WREPL_STATE_ACTIVE,
5371                         .node           = WREPL_NODE_B,
5372                         .is_static      = false,
5373                         .num_ips        = ctx->addresses_best_num,
5374                         .ips            = ctx->addresses_best,
5375                         .apply_expected = true
5376                 },
5377         },
5378         /*
5379          * unique,released vs. mhomed,active with different ip(s)
5380          */
5381         {
5382                 .line   = __location__,
5383                 .name   = _NBT_NAME("_UR_MA_DI", 0x00, NULL),
5384                 .wins   = {
5385                         .nb_flags       = 0,
5386                         .mhomed         = false,
5387                         .num_ips        = ctx->addresses_best_num,
5388                         .ips            = ctx->addresses_best,
5389                         .apply_expected = true
5390                 },
5391                 .replica= {
5392                         .type           = WREPL_TYPE_MHOMED,
5393                         .state          = WREPL_STATE_ACTIVE,
5394                         .node           = WREPL_NODE_B,
5395                         .is_static      = false,
5396                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5397                         .ips            = addresses_B_1,
5398                         .apply_expected = true
5399                 },
5400         },
5401         /*
5402          * unique,released vs. mhomed,tombstone with same ip(s)
5403          */
5404         {
5405                 .line   = __location__,
5406                 .name   = _NBT_NAME("_UR_MT_SI", 0x00, NULL),
5407                 .wins   = {
5408                         .nb_flags       = 0,
5409                         .mhomed         = false,
5410                         .num_ips        = ctx->addresses_best_num,
5411                         .ips            = ctx->addresses_best,
5412                         .apply_expected = true
5413                 },
5414                 .replica= {
5415                         .type           = WREPL_TYPE_MHOMED,
5416                         .state          = WREPL_STATE_TOMBSTONE,
5417                         .node           = WREPL_NODE_B,
5418                         .is_static      = false,
5419                         .num_ips        = ctx->addresses_best_num,
5420                         .ips            = ctx->addresses_best,
5421                         .apply_expected = true
5422                 },
5423         },
5424         /*
5425          * unique,released vs. mhomed,tombstone with different ip(s)
5426          */
5427         {
5428                 .line   = __location__,
5429                 .name   = _NBT_NAME("_UR_MT_DI", 0x00, NULL),
5430                 .wins   = {
5431                         .nb_flags       = 0,
5432                         .mhomed         = false,
5433                         .num_ips        = ctx->addresses_best_num,
5434                         .ips            = ctx->addresses_best,
5435                         .apply_expected = true
5436                 },
5437                 .replica= {
5438                         .type           = WREPL_TYPE_MHOMED,
5439                         .state          = WREPL_STATE_TOMBSTONE,
5440                         .node           = WREPL_NODE_B,
5441                         .is_static      = false,
5442                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5443                         .ips            = addresses_B_1,
5444                         .apply_expected = true
5445                 },
5446         },
5447 /*
5448  * group vs. unique section
5449  */
5450         /*
5451          * group,released vs. unique,active with same ip(s)
5452          */
5453         {
5454                 .line   = __location__,
5455                 .name   = _NBT_NAME("_GR_UA_SI", 0x00, NULL),
5456                 .wins   = {
5457                         .nb_flags       = NBT_NM_GROUP,
5458                         .mhomed         = false,
5459                         .num_ips        = ctx->addresses_best_num,
5460                         .ips            = ctx->addresses_best,
5461                         .apply_expected = true
5462                 },
5463                 .replica= {
5464                         .type           = WREPL_TYPE_UNIQUE,
5465                         .state          = WREPL_STATE_ACTIVE,
5466                         .node           = WREPL_NODE_B,
5467                         .is_static      = false,
5468                         .num_ips        = ctx->addresses_best_num,
5469                         .ips            = ctx->addresses_best,
5470                         .apply_expected = false
5471                 },
5472         },
5473         /*
5474          * group,released vs. unique,active with different ip(s)
5475          */
5476         {
5477                 .line   = __location__,
5478                 .name   = _NBT_NAME("_GR_UA_DI", 0x00, NULL),
5479                 .wins   = {
5480                         .nb_flags       = NBT_NM_GROUP,
5481                         .mhomed         = false,
5482                         .num_ips        = ctx->addresses_best_num,
5483                         .ips            = ctx->addresses_best,
5484                         .apply_expected = true
5485                 },
5486                 .replica= {
5487                         .type           = WREPL_TYPE_UNIQUE,
5488                         .state          = WREPL_STATE_ACTIVE,
5489                         .node           = WREPL_NODE_B,
5490                         .is_static      = false,
5491                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5492                         .ips            = addresses_B_1,
5493                         .apply_expected = false
5494                 },
5495         },
5496         /*
5497          * group,released vs. unique,tombstone with same ip(s)
5498          */
5499         {
5500                 .line   = __location__,
5501                 .name   = _NBT_NAME("_GR_UT_SI", 0x00, NULL),
5502                 .wins   = {
5503                         .nb_flags       = NBT_NM_GROUP,
5504                         .mhomed         = false,
5505                         .num_ips        = ctx->addresses_best_num,
5506                         .ips            = ctx->addresses_best,
5507                         .apply_expected = true
5508                 },
5509                 .replica= {
5510                         .type           = WREPL_TYPE_UNIQUE,
5511                         .state          = WREPL_STATE_TOMBSTONE,
5512                         .node           = WREPL_NODE_B,
5513                         .is_static      = false,
5514                         .num_ips        = ctx->addresses_best_num,
5515                         .ips            = ctx->addresses_best,
5516                         .apply_expected = false
5517                 },
5518         },
5519         /*
5520          * group,released vs. unique,tombstone with different ip(s)
5521          */
5522         {
5523                 .line   = __location__,
5524                 .name   = _NBT_NAME("_GR_UT_DI", 0x00, NULL),
5525                 .wins   = {
5526                         .nb_flags       = NBT_NM_GROUP,
5527                         .mhomed         = false,
5528                         .num_ips        = ctx->addresses_best_num,
5529                         .ips            = ctx->addresses_best,
5530                         .apply_expected = true
5531                 },
5532                 .replica= {
5533                         .type           = WREPL_TYPE_UNIQUE,
5534                         .state          = WREPL_STATE_TOMBSTONE,
5535                         .node           = WREPL_NODE_B,
5536                         .is_static      = false,
5537                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5538                         .ips            = addresses_B_1,
5539                         .apply_expected = false
5540                 },
5541         },
5542 /*
5543  * group vs. group section
5544  */
5545         /*
5546          * group,released vs. group,active with same ip(s)
5547          */
5548         {
5549                 .line   = __location__,
5550                 .name   = _NBT_NAME("_GR_GA_SI", 0x00, NULL),
5551                 .wins   = {
5552                         .nb_flags       = NBT_NM_GROUP,
5553                         .mhomed         = false,
5554                         .num_ips        = ctx->addresses_best_num,
5555                         .ips            = ctx->addresses_best,
5556                         .apply_expected = true
5557                 },
5558                 .replica= {
5559                         .type           = WREPL_TYPE_GROUP,
5560                         .state          = WREPL_STATE_ACTIVE,
5561                         .node           = WREPL_NODE_B,
5562                         .is_static      = false,
5563                         .num_ips        = ctx->addresses_best_num,
5564                         .ips            = ctx->addresses_best,
5565                         .apply_expected = true
5566                 },
5567         },
5568         /*
5569          * group,released vs. group,active with different ip(s)
5570          */
5571         {
5572                 .line   = __location__,
5573                 .name   = _NBT_NAME("_GR_GA_DI", 0x00, NULL),
5574                 .wins   = {
5575                         .nb_flags       = NBT_NM_GROUP,
5576                         .mhomed         = false,
5577                         .num_ips        = ctx->addresses_best_num,
5578                         .ips            = ctx->addresses_best,
5579                         .apply_expected = true
5580                 },
5581                 .replica= {
5582                         .type           = WREPL_TYPE_GROUP,
5583                         .state          = WREPL_STATE_ACTIVE,
5584                         .node           = WREPL_NODE_B,
5585                         .is_static      = false,
5586                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5587                         .ips            = addresses_B_1,
5588                         .apply_expected = true
5589                 },
5590         },
5591         /*
5592          * group,released vs. group,tombstone with same ip(s)
5593          */
5594         {
5595                 .line   = __location__,
5596                 .name   = _NBT_NAME("_GR_GT_SI", 0x00, NULL),
5597                 .wins   = {
5598                         .nb_flags       = NBT_NM_GROUP,
5599                         .mhomed         = false,
5600                         .num_ips        = ctx->addresses_best_num,
5601                         .ips            = ctx->addresses_best,
5602                         .apply_expected = true
5603                 },
5604                 .replica= {
5605                         .type           = WREPL_TYPE_GROUP,
5606                         .state          = WREPL_STATE_TOMBSTONE,
5607                         .node           = WREPL_NODE_B,
5608                         .is_static      = false,
5609                         .num_ips        = ctx->addresses_best_num,
5610                         .ips            = ctx->addresses_best,
5611                         .apply_expected = true
5612                 },
5613         },
5614         /*
5615          * group,released vs. group,tombstone with different ip(s)
5616          */
5617         {
5618                 .line   = __location__,
5619                 .name   = _NBT_NAME("_GR_GT_DI", 0x00, NULL),
5620                 .wins   = {
5621                         .nb_flags       = NBT_NM_GROUP,
5622                         .mhomed         = false,
5623                         .num_ips        = ctx->addresses_best_num,
5624                         .ips            = ctx->addresses_best,
5625                         .apply_expected = true
5626                 },
5627                 .replica= {
5628                         .type           = WREPL_TYPE_GROUP,
5629                         .state          = WREPL_STATE_TOMBSTONE,
5630                         .node           = WREPL_NODE_B,
5631                         .is_static      = false,
5632                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5633                         .ips            = addresses_B_1,
5634                         .apply_expected = true
5635                 },
5636         },
5637 /*
5638  * group vs. special group section
5639  */
5640         /*
5641          * group,released vs. sgroup,active with same ip(s)
5642          */
5643         {
5644                 .line   = __location__,
5645                 .name   = _NBT_NAME("_GR_SA_SI", 0x00, NULL),
5646                 .wins   = {
5647                         .nb_flags       = NBT_NM_GROUP,
5648                         .mhomed         = false,
5649                         .num_ips        = ctx->addresses_best_num,
5650                         .ips            = ctx->addresses_best,
5651                         .apply_expected = true
5652                 },
5653                 .replica= {
5654                         .type           = WREPL_TYPE_SGROUP,
5655                         .state          = WREPL_STATE_ACTIVE,
5656                         .node           = WREPL_NODE_B,
5657                         .is_static      = false,
5658                         .num_ips        = ctx->addresses_best_num,
5659                         .ips            = ctx->addresses_best,
5660                         .apply_expected = false
5661                 },
5662         },
5663         /*
5664          * group,released vs. sgroup,active with different ip(s)
5665          */
5666         {
5667                 .line   = __location__,
5668                 .name   = _NBT_NAME("_GR_SA_DI", 0x00, NULL),
5669                 .wins   = {
5670                         .nb_flags       = NBT_NM_GROUP,
5671                         .mhomed         = false,
5672                         .num_ips        = ctx->addresses_best_num,
5673                         .ips            = ctx->addresses_best,
5674                         .apply_expected = true
5675                 },
5676                 .replica= {
5677                         .type           = WREPL_TYPE_SGROUP,
5678                         .state          = WREPL_STATE_ACTIVE,
5679                         .node           = WREPL_NODE_B,
5680                         .is_static      = false,
5681                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5682                         .ips            = addresses_B_1,
5683                         .apply_expected = false
5684                 },
5685         },
5686         /*
5687          * group,released vs. sgroup,tombstone with same ip(s)
5688          */
5689         {
5690                 .line   = __location__,
5691                 .name   = _NBT_NAME("_GR_ST_SI", 0x00, NULL),
5692                 .wins   = {
5693                         .nb_flags       = NBT_NM_GROUP,
5694                         .mhomed         = false,
5695                         .num_ips        = ctx->addresses_best_num,
5696                         .ips            = ctx->addresses_best,
5697                         .apply_expected = true
5698                 },
5699                 .replica= {
5700                         .type           = WREPL_TYPE_SGROUP,
5701                         .state          = WREPL_STATE_TOMBSTONE,
5702                         .node           = WREPL_NODE_B,
5703                         .is_static      = false,
5704                         .num_ips        = ctx->addresses_best_num,
5705                         .ips            = ctx->addresses_best,
5706                         .apply_expected = false
5707                 },
5708         },
5709         /*
5710          * group,released vs. sgroup,tombstone with different ip(s)
5711          */
5712         {
5713                 .line   = __location__,
5714                 .name   = _NBT_NAME("_GR_ST_DI", 0x00, NULL),
5715                 .wins   = {
5716                         .nb_flags       = NBT_NM_GROUP,
5717                         .mhomed         = false,
5718                         .num_ips        = ctx->addresses_best_num,
5719                         .ips            = ctx->addresses_best,
5720                         .apply_expected = true
5721                 },
5722                 .replica= {
5723                         .type           = WREPL_TYPE_SGROUP,
5724                         .state          = WREPL_STATE_TOMBSTONE,
5725                         .node           = WREPL_NODE_B,
5726                         .is_static      = false,
5727                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5728                         .ips            = addresses_B_1,
5729                         .apply_expected = false
5730                 },
5731         },
5732 /*
5733  * group vs. multi homed section
5734  */
5735         /*
5736          * group,released vs. mhomed,active with same ip(s)
5737          */
5738         {
5739                 .line   = __location__,
5740                 .name   = _NBT_NAME("_GR_MA_SI", 0x00, NULL),
5741                 .wins   = {
5742                         .nb_flags       = NBT_NM_GROUP,
5743                         .mhomed         = false,
5744                         .num_ips        = ctx->addresses_best_num,
5745                         .ips            = ctx->addresses_best,
5746                         .apply_expected = true
5747                 },
5748                 .replica= {
5749                         .type           = WREPL_TYPE_MHOMED,
5750                         .state          = WREPL_STATE_ACTIVE,
5751                         .node           = WREPL_NODE_B,
5752                         .is_static      = false,
5753                         .num_ips        = ctx->addresses_best_num,
5754                         .ips            = ctx->addresses_best,
5755                         .apply_expected = false
5756                 },
5757         },
5758         /*
5759          * group,released vs. mhomed,active with different ip(s)
5760          */
5761         {
5762                 .line   = __location__,
5763                 .name   = _NBT_NAME("_GR_MA_DI", 0x00, NULL),
5764                 .wins   = {
5765                         .nb_flags       = NBT_NM_GROUP,
5766                         .mhomed         = false,
5767                         .num_ips        = ctx->addresses_best_num,
5768                         .ips            = ctx->addresses_best,
5769                         .apply_expected = true
5770                 },
5771                 .replica= {
5772                         .type           = WREPL_TYPE_MHOMED,
5773                         .state          = WREPL_STATE_ACTIVE,
5774                         .node           = WREPL_NODE_B,
5775                         .is_static      = false,
5776                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5777                         .ips            = addresses_B_1,
5778                         .apply_expected = false
5779                 },
5780         },
5781         /*
5782          * group,released vs. mhomed,tombstone with same ip(s)
5783          */
5784         {
5785                 .line   = __location__,
5786                 .name   = _NBT_NAME("_GR_MT_SI", 0x00, NULL),
5787                 .wins   = {
5788                         .nb_flags       = NBT_NM_GROUP,
5789                         .mhomed         = false,
5790                         .num_ips        = ctx->addresses_best_num,
5791                         .ips            = ctx->addresses_best,
5792                         .apply_expected = true
5793                 },
5794                 .replica= {
5795                         .type           = WREPL_TYPE_MHOMED,
5796                         .state          = WREPL_STATE_TOMBSTONE,
5797                         .node           = WREPL_NODE_B,
5798                         .is_static      = false,
5799                         .num_ips        = ctx->addresses_best_num,
5800                         .ips            = ctx->addresses_best,
5801                         .apply_expected = false
5802                 },
5803         },
5804         /*
5805          * group,released vs. mhomed,tombstone with different ip(s)
5806          */
5807         {
5808                 .line   = __location__,
5809                 .name   = _NBT_NAME("_GR_MT_DI", 0x00, NULL),
5810                 .wins   = {
5811                         .nb_flags       = NBT_NM_GROUP,
5812                         .mhomed         = false,
5813                         .num_ips        = ctx->addresses_best_num,
5814                         .ips            = ctx->addresses_best,
5815                         .apply_expected = true
5816                 },
5817                 .replica= {
5818                         .type           = WREPL_TYPE_MHOMED,
5819                         .state          = WREPL_STATE_TOMBSTONE,
5820                         .node           = WREPL_NODE_B,
5821                         .is_static      = false,
5822                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5823                         .ips            = addresses_B_1,
5824                         .apply_expected = false
5825                 },
5826         },
5827 /*
5828  * special group vs. unique section
5829  */
5830         /*
5831          * sgroup,released vs. unique,active with same ip(s)
5832          */
5833         {
5834                 .line   = __location__,
5835                 .name   = _NBT_NAME("_SR_UA_SI", 0x1C, NULL),
5836                 .wins   = {
5837                         .nb_flags       = NBT_NM_GROUP,
5838                         .mhomed         = false,
5839                         .num_ips        = ctx->addresses_best_num,
5840                         .ips            = ctx->addresses_best,
5841                         .apply_expected = true
5842                 },
5843                 .replica= {
5844                         .type           = WREPL_TYPE_UNIQUE,
5845                         .state          = WREPL_STATE_ACTIVE,
5846                         .node           = WREPL_NODE_B,
5847                         .is_static      = false,
5848                         .num_ips        = ctx->addresses_best_num,
5849                         .ips            = ctx->addresses_best,
5850                         .apply_expected = true
5851                 },
5852         },
5853         /*
5854          * sgroup,released vs. unique,active with different ip(s)
5855          */
5856         {
5857                 .line   = __location__,
5858                 .name   = _NBT_NAME("_SR_UA_DI", 0x1C, NULL),
5859                 .wins   = {
5860                         .nb_flags       = NBT_NM_GROUP,
5861                         .mhomed         = false,
5862                         .num_ips        = ctx->addresses_best_num,
5863                         .ips            = ctx->addresses_best,
5864                         .apply_expected = true
5865                 },
5866                 .replica= {
5867                         .type           = WREPL_TYPE_UNIQUE,
5868                         .state          = WREPL_STATE_ACTIVE,
5869                         .node           = WREPL_NODE_B,
5870                         .is_static      = false,
5871                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5872                         .ips            = addresses_B_1,
5873                         .apply_expected = true
5874                 },
5875         },
5876         /*
5877          * sgroup,released vs. unique,tombstone with same ip(s)
5878          */
5879         {
5880                 .line   = __location__,
5881                 .name   = _NBT_NAME("_SR_UT_SI", 0x1C, NULL),
5882                 .wins   = {
5883                         .nb_flags       = NBT_NM_GROUP,
5884                         .mhomed         = false,
5885                         .num_ips        = ctx->addresses_best_num,
5886                         .ips            = ctx->addresses_best,
5887                         .apply_expected = true
5888                 },
5889                 .replica= {
5890                         .type           = WREPL_TYPE_UNIQUE,
5891                         .state          = WREPL_STATE_TOMBSTONE,
5892                         .node           = WREPL_NODE_B,
5893                         .is_static      = false,
5894                         .num_ips        = ctx->addresses_best_num,
5895                         .ips            = ctx->addresses_best,
5896                         .apply_expected = true
5897                 },
5898         },
5899         /*
5900          * sgroup,released vs. unique,tombstone with different ip(s)
5901          */
5902         {
5903                 .line   = __location__,
5904                 .name   = _NBT_NAME("_SR_UT_DI", 0x1C, NULL),
5905                 .wins   = {
5906                         .nb_flags       = NBT_NM_GROUP,
5907                         .mhomed         = false,
5908                         .num_ips        = ctx->addresses_best_num,
5909                         .ips            = ctx->addresses_best,
5910                         .apply_expected = true
5911                 },
5912                 .replica= {
5913                         .type           = WREPL_TYPE_UNIQUE,
5914                         .state          = WREPL_STATE_TOMBSTONE,
5915                         .node           = WREPL_NODE_B,
5916                         .is_static      = false,
5917                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5918                         .ips            = addresses_B_1,
5919                         .apply_expected = true
5920                 },
5921         },
5922 /*
5923  * special group vs. group section
5924  */
5925         /*
5926          * sgroup,released vs. group,active with same ip(s)
5927          */
5928         {
5929                 .line   = __location__,
5930                 .name   = _NBT_NAME("_SR_GA_SI", 0x1C, NULL),
5931                 .wins   = {
5932                         .nb_flags       = NBT_NM_GROUP,
5933                         .mhomed         = false,
5934                         .num_ips        = ctx->addresses_best_num,
5935                         .ips            = ctx->addresses_best,
5936                         .apply_expected = true
5937                 },
5938                 .replica= {
5939                         .type           = WREPL_TYPE_GROUP,
5940                         .state          = WREPL_STATE_ACTIVE,
5941                         .node           = WREPL_NODE_B,
5942                         .is_static      = false,
5943                         .num_ips        = ctx->addresses_best_num,
5944                         .ips            = ctx->addresses_best,
5945                         .apply_expected = true
5946                 },
5947         },
5948         /*
5949          * sgroup,released vs. group,active with different ip(s)
5950          */
5951         {
5952                 .line   = __location__,
5953                 .name   = _NBT_NAME("_SR_GA_DI", 0x1C, NULL),
5954                 .wins   = {
5955                         .nb_flags       = NBT_NM_GROUP,
5956                         .mhomed         = false,
5957                         .num_ips        = ctx->addresses_best_num,
5958                         .ips            = ctx->addresses_best,
5959                         .apply_expected = true
5960                 },
5961                 .replica= {
5962                         .type           = WREPL_TYPE_GROUP,
5963                         .state          = WREPL_STATE_ACTIVE,
5964                         .node           = WREPL_NODE_B,
5965                         .is_static      = false,
5966                         .num_ips        = ARRAY_SIZE(addresses_B_1),
5967                         .ips            = addresses_B_1,
5968                         .apply_expected = true
5969                 },
5970         },
5971         /*
5972          * sgroup,released vs. group,tombstone with same ip(s)
5973          */
5974         {
5975                 .line   = __location__,
5976                 .name   = _NBT_NAME("_SR_GT_SI", 0x1C, NULL),
5977                 .wins   = {
5978                         .nb_flags       = NBT_NM_GROUP,
5979                         .mhomed         = false,
5980                         .num_ips        = ctx->addresses_best_num,
5981                         .ips            = ctx->addresses_best,
5982                         .apply_expected = true
5983                 },
5984                 .replica= {
5985                         .type           = WREPL_TYPE_GROUP,
5986                         .state          = WREPL_STATE_TOMBSTONE,
5987                         .node           = WREPL_NODE_B,
5988                         .is_static      = false,
5989                         .num_ips        = ctx->addresses_best_num,
5990                         .ips            = ctx->addresses_best,
5991                         .apply_expected = true
5992                 },
5993         },
5994         /*
5995          * sgroup,released vs. group,tombstone with different ip(s)
5996          */
5997         {
5998                 .line   = __location__,
5999                 .name   = _NBT_NAME("_SR_GT_DI", 0x1C, NULL),
6000                 .wins   = {
6001                         .nb_flags       = NBT_NM_GROUP,
6002                         .mhomed         = false,
6003                         .num_ips        = ctx->addresses_best_num,
6004                         .ips            = ctx->addresses_best,
6005                         .apply_expected = true
6006                 },
6007                 .replica= {
6008                         .type           = WREPL_TYPE_GROUP,
6009                         .state          = WREPL_STATE_TOMBSTONE,
6010                         .node           = WREPL_NODE_B,
6011                         .is_static      = false,
6012                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6013                         .ips            = addresses_B_1,
6014                         .apply_expected = true
6015                 },
6016         },
6017 /*
6018  * special group vs. special group section
6019  */
6020         /*
6021          * sgroup,released vs. sgroup,active with same ip(s)
6022          */
6023         {
6024                 .line   = __location__,
6025                 .name   = _NBT_NAME("_SR_SA_SI", 0x1C, NULL),
6026                 .wins   = {
6027                         .nb_flags       = NBT_NM_GROUP,
6028                         .mhomed         = false,
6029                         .num_ips        = ctx->addresses_best_num,
6030                         .ips            = ctx->addresses_best,
6031                         .apply_expected = true
6032                 },
6033                 .replica= {
6034                         .type           = WREPL_TYPE_SGROUP,
6035                         .state          = WREPL_STATE_ACTIVE,
6036                         .node           = WREPL_NODE_B,
6037                         .is_static      = false,
6038                         .num_ips        = ctx->addresses_best_num,
6039                         .ips            = ctx->addresses_best,
6040                         .apply_expected = true
6041                 },
6042         },
6043         /*
6044          * sgroup,released vs. sgroup,active with different ip(s)
6045          */
6046         {
6047                 .line   = __location__,
6048                 .name   = _NBT_NAME("_SR_SA_DI", 0x1C, NULL),
6049                 .wins   = {
6050                         .nb_flags       = NBT_NM_GROUP,
6051                         .mhomed         = false,
6052                         .num_ips        = ctx->addresses_best_num,
6053                         .ips            = ctx->addresses_best,
6054                         .apply_expected = true
6055                 },
6056                 .replica= {
6057                         .type           = WREPL_TYPE_SGROUP,
6058                         .state          = WREPL_STATE_ACTIVE,
6059                         .node           = WREPL_NODE_B,
6060                         .is_static      = false,
6061                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6062                         .ips            = addresses_B_1,
6063                         .apply_expected = true
6064                 },
6065         },
6066         /*
6067          * sgroup,released vs. sgroup,tombstone with same ip(s)
6068          */
6069         {
6070                 .line   = __location__,
6071                 .name   = _NBT_NAME("_SR_ST_SI", 0x1C, NULL),
6072                 .wins   = {
6073                         .nb_flags       = NBT_NM_GROUP,
6074                         .mhomed         = false,
6075                         .num_ips        = ctx->addresses_best_num,
6076                         .ips            = ctx->addresses_best,
6077                         .apply_expected = true
6078                 },
6079                 .replica= {
6080                         .type           = WREPL_TYPE_SGROUP,
6081                         .state          = WREPL_STATE_TOMBSTONE,
6082                         .node           = WREPL_NODE_B,
6083                         .is_static      = false,
6084                         .num_ips        = ctx->addresses_best_num,
6085                         .ips            = ctx->addresses_best,
6086                         .apply_expected = true
6087                 },
6088         },
6089         /*
6090          * sgroup,released vs. sgroup,tombstone with different ip(s)
6091          */
6092         {
6093                 .line   = __location__,
6094                 .name   = _NBT_NAME("_SR_ST_DI", 0x1C, NULL),
6095                 .wins   = {
6096                         .nb_flags       = NBT_NM_GROUP,
6097                         .mhomed         = false,
6098                         .num_ips        = ctx->addresses_best_num,
6099                         .ips            = ctx->addresses_best,
6100                         .apply_expected = true
6101                 },
6102                 .replica= {
6103                         .type           = WREPL_TYPE_SGROUP,
6104                         .state          = WREPL_STATE_TOMBSTONE,
6105                         .node           = WREPL_NODE_B,
6106                         .is_static      = false,
6107                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6108                         .ips            = addresses_B_1,
6109                         .apply_expected = true
6110                 },
6111         },
6112 /*
6113  * special group vs. multi homed section
6114  */
6115         /*
6116          * sgroup,released vs. mhomed,active with same ip(s)
6117          */
6118         {
6119                 .line   = __location__,
6120                 .name   = _NBT_NAME("_SR_MA_SI", 0x1C, NULL),
6121                 .wins   = {
6122                         .nb_flags       = NBT_NM_GROUP,
6123                         .mhomed         = false,
6124                         .num_ips        = ctx->addresses_best_num,
6125                         .ips            = ctx->addresses_best,
6126                         .apply_expected = true
6127                 },
6128                 .replica= {
6129                         .type           = WREPL_TYPE_MHOMED,
6130                         .state          = WREPL_STATE_ACTIVE,
6131                         .node           = WREPL_NODE_B,
6132                         .is_static      = false,
6133                         .num_ips        = ctx->addresses_best_num,
6134                         .ips            = ctx->addresses_best,
6135                         .apply_expected = true
6136                 },
6137         },
6138         /*
6139          * sgroup,released vs. mhomed,active with different ip(s)
6140          */
6141         {
6142                 .line   = __location__,
6143                 .name   = _NBT_NAME("_SR_MA_DI", 0x1C, NULL),
6144                 .wins   = {
6145                         .nb_flags       = NBT_NM_GROUP,
6146                         .mhomed         = false,
6147                         .num_ips        = ctx->addresses_best_num,
6148                         .ips            = ctx->addresses_best,
6149                         .apply_expected = true
6150                 },
6151                 .replica= {
6152                         .type           = WREPL_TYPE_MHOMED,
6153                         .state          = WREPL_STATE_ACTIVE,
6154                         .node           = WREPL_NODE_B,
6155                         .is_static      = false,
6156                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6157                         .ips            = addresses_B_1,
6158                         .apply_expected = true
6159                 },
6160         },
6161         /*
6162          * sgroup,released vs. mhomed,tombstone with same ip(s)
6163          */
6164         {
6165                 .line   = __location__,
6166                 .name   = _NBT_NAME("_SR_MT_SI", 0x1C, NULL),
6167                 .wins   = {
6168                         .nb_flags       = NBT_NM_GROUP,
6169                         .mhomed         = false,
6170                         .num_ips        = ctx->addresses_best_num,
6171                         .ips            = ctx->addresses_best,
6172                         .apply_expected = true
6173                 },
6174                 .replica= {
6175                         .type           = WREPL_TYPE_MHOMED,
6176                         .state          = WREPL_STATE_TOMBSTONE,
6177                         .node           = WREPL_NODE_B,
6178                         .is_static      = false,
6179                         .num_ips        = ctx->addresses_best_num,
6180                         .ips            = ctx->addresses_best,
6181                         .apply_expected = true
6182                 },
6183         },
6184         /*
6185          * sgroup,released vs. mhomed,tombstone with different ip(s)
6186          */
6187         {
6188                 .line   = __location__,
6189                 .name   = _NBT_NAME("_SR_MT_DI", 0x1C, NULL),
6190                 .wins   = {
6191                         .nb_flags       = NBT_NM_GROUP,
6192                         .mhomed         = false,
6193                         .num_ips        = ctx->addresses_best_num,
6194                         .ips            = ctx->addresses_best,
6195                         .apply_expected = true
6196                 },
6197                 .replica= {
6198                         .type           = WREPL_TYPE_MHOMED,
6199                         .state          = WREPL_STATE_TOMBSTONE,
6200                         .node           = WREPL_NODE_B,
6201                         .is_static      = false,
6202                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6203                         .ips            = addresses_B_1,
6204                         .apply_expected = true
6205                 },
6206         },
6207 /*
6208  * multi homed vs. unique section
6209  */
6210         /*
6211          * mhomed,released vs. unique,active with same ip(s)
6212          */
6213         {
6214                 .line   = __location__,
6215                 .name   = _NBT_NAME("_MR_UA_SI", 0x00, NULL),
6216                 .wins   = {
6217                         .nb_flags       = 0,
6218                         .mhomed         = true,
6219                         .num_ips        = ctx->addresses_best_num,
6220                         .ips            = ctx->addresses_best,
6221                         .apply_expected = true
6222                 },
6223                 .replica= {
6224                         .type           = WREPL_TYPE_UNIQUE,
6225                         .state          = WREPL_STATE_ACTIVE,
6226                         .node           = WREPL_NODE_B,
6227                         .is_static      = false,
6228                         .num_ips        = ctx->addresses_best_num,
6229                         .ips            = ctx->addresses_best,
6230                         .apply_expected = true
6231                 },
6232         },
6233         /*
6234          * mhomed,released vs. unique,active with different ip(s)
6235          */
6236         {
6237                 .line   = __location__,
6238                 .name   = _NBT_NAME("_MR_UA_DI", 0x00, NULL),
6239                 .wins   = {
6240                         .nb_flags       = 0,
6241                         .mhomed         = true,
6242                         .num_ips        = ctx->addresses_best_num,
6243                         .ips            = ctx->addresses_best,
6244                         .apply_expected = true
6245                 },
6246                 .replica= {
6247                         .type           = WREPL_TYPE_UNIQUE,
6248                         .state          = WREPL_STATE_ACTIVE,
6249                         .node           = WREPL_NODE_B,
6250                         .is_static      = false,
6251                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6252                         .ips            = addresses_B_1,
6253                         .apply_expected = true
6254                 },
6255         },
6256         /*
6257          * mhomed,released vs. unique,tombstone with same ip(s)
6258          */
6259         {
6260                 .line   = __location__,
6261                 .name   = _NBT_NAME("_MR_UT_SI", 0x00, NULL),
6262                 .wins   = {
6263                         .nb_flags       = 0,
6264                         .mhomed         = true,
6265                         .num_ips        = ctx->addresses_best_num,
6266                         .ips            = ctx->addresses_best,
6267                         .apply_expected = true
6268                 },
6269                 .replica= {
6270                         .type           = WREPL_TYPE_UNIQUE,
6271                         .state          = WREPL_STATE_TOMBSTONE,
6272                         .node           = WREPL_NODE_B,
6273                         .is_static      = false,
6274                         .num_ips        = ctx->addresses_best_num,
6275                         .ips            = ctx->addresses_best,
6276                         .apply_expected = true
6277                 },
6278         },
6279         /*
6280          * mhomed,released vs. unique,tombstone with different ip(s)
6281          */
6282         {
6283                 .line   = __location__,
6284                 .name   = _NBT_NAME("_MR_UT_DI", 0x00, NULL),
6285                 .wins   = {
6286                         .nb_flags       = 0,
6287                         .mhomed         = true,
6288                         .num_ips        = ctx->addresses_best_num,
6289                         .ips            = ctx->addresses_best,
6290                         .apply_expected = true
6291                 },
6292                 .replica= {
6293                         .type           = WREPL_TYPE_UNIQUE,
6294                         .state          = WREPL_STATE_TOMBSTONE,
6295                         .node           = WREPL_NODE_B,
6296                         .is_static      = false,
6297                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6298                         .ips            = addresses_B_1,
6299                         .apply_expected = true
6300                 },
6301         },
6302 /*
6303  * multi homed vs. group section
6304  */
6305         /*
6306          * mhomed,released vs. group,active with same ip(s)
6307          */
6308         {
6309                 .line   = __location__,
6310                 .name   = _NBT_NAME("_MR_GA_SI", 0x00, NULL),
6311                 .wins   = {
6312                         .nb_flags       = 0,
6313                         .mhomed         = true,
6314                         .num_ips        = ctx->addresses_best_num,
6315                         .ips            = ctx->addresses_best,
6316                         .apply_expected = true
6317                 },
6318                 .replica= {
6319                         .type           = WREPL_TYPE_GROUP,
6320                         .state          = WREPL_STATE_ACTIVE,
6321                         .node           = WREPL_NODE_B,
6322                         .is_static      = false,
6323                         .num_ips        = ctx->addresses_best_num,
6324                         .ips            = ctx->addresses_best,
6325                         .apply_expected = true
6326                 },
6327         },
6328         /*
6329          * mhomed,released vs. group,active with different ip(s)
6330          */
6331         {
6332                 .line   = __location__,
6333                 .name   = _NBT_NAME("_MR_GA_DI", 0x00, NULL),
6334                 .wins   = {
6335                         .nb_flags       = 0,
6336                         .mhomed         = true,
6337                         .num_ips        = ctx->addresses_best_num,
6338                         .ips            = ctx->addresses_best,
6339                         .apply_expected = true
6340                 },
6341                 .replica= {
6342                         .type           = WREPL_TYPE_GROUP,
6343                         .state          = WREPL_STATE_ACTIVE,
6344                         .node           = WREPL_NODE_B,
6345                         .is_static      = false,
6346                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6347                         .ips            = addresses_B_1,
6348                         .apply_expected = true
6349                 },
6350         },
6351         /*
6352          * mhomed,released vs. group,tombstone with same ip(s)
6353          */
6354         {
6355                 .line   = __location__,
6356                 .name   = _NBT_NAME("_MR_GT_SI", 0x00, NULL),
6357                 .wins   = {
6358                         .nb_flags       = 0,
6359                         .mhomed         = true,
6360                         .num_ips        = ctx->addresses_best_num,
6361                         .ips            = ctx->addresses_best,
6362                         .apply_expected = true
6363                 },
6364                 .replica= {
6365                         .type           = WREPL_TYPE_GROUP,
6366                         .state          = WREPL_STATE_TOMBSTONE,
6367                         .node           = WREPL_NODE_B,
6368                         .is_static      = false,
6369                         .num_ips        = ctx->addresses_best_num,
6370                         .ips            = ctx->addresses_best,
6371                         .apply_expected = true
6372                 },
6373         },
6374         /*
6375          * mhomed,released vs. group,tombstone with different ip(s)
6376          */
6377         {
6378                 .line   = __location__,
6379                 .name   = _NBT_NAME("_MR_GT_DI", 0x00, NULL),
6380                 .wins   = {
6381                         .nb_flags       = 0,
6382                         .mhomed         = true,
6383                         .num_ips        = ctx->addresses_best_num,
6384                         .ips            = ctx->addresses_best,
6385                         .apply_expected = true
6386                 },
6387                 .replica= {
6388                         .type           = WREPL_TYPE_GROUP,
6389                         .state          = WREPL_STATE_TOMBSTONE,
6390                         .node           = WREPL_NODE_B,
6391                         .is_static      = false,
6392                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6393                         .ips            = addresses_B_1,
6394                         .apply_expected = true
6395                 },
6396         },
6397 /*
6398  * multi homed vs. special group section
6399  */
6400         /*
6401          * mhomed,released vs. sgroup,active with same ip(s)
6402          */
6403         {
6404                 .line   = __location__,
6405                 .name   = _NBT_NAME("_MR_SA_SI", 0x00, NULL),
6406                 .wins   = {
6407                         .nb_flags       = 0,
6408                         .mhomed         = true,
6409                         .num_ips        = ctx->addresses_best_num,
6410                         .ips            = ctx->addresses_best,
6411                         .apply_expected = true
6412                 },
6413                 .replica= {
6414                         .type           = WREPL_TYPE_SGROUP,
6415                         .state          = WREPL_STATE_ACTIVE,
6416                         .node           = WREPL_NODE_B,
6417                         .is_static      = false,
6418                         .num_ips        = ctx->addresses_best_num,
6419                         .ips            = ctx->addresses_best,
6420                         .apply_expected = true
6421                 },
6422         },
6423         /*
6424          * mhomed,released vs. sgroup,active with different ip(s)
6425          */
6426         {
6427                 .line   = __location__,
6428                 .name   = _NBT_NAME("_MR_SA_DI", 0x00, NULL),
6429                 .wins   = {
6430                         .nb_flags       = 0,
6431                         .mhomed         = true,
6432                         .num_ips        = ctx->addresses_best_num,
6433                         .ips            = ctx->addresses_best,
6434                         .apply_expected = true
6435                 },
6436                 .replica= {
6437                         .type           = WREPL_TYPE_SGROUP,
6438                         .state          = WREPL_STATE_ACTIVE,
6439                         .node           = WREPL_NODE_B,
6440                         .is_static      = false,
6441                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6442                         .ips            = addresses_B_1,
6443                         .apply_expected = true
6444                 },
6445         },
6446         /*
6447          * mhomed,released vs. sgroup,tombstone with same ip(s)
6448          */
6449         {
6450                 .line   = __location__,
6451                 .name   = _NBT_NAME("_MR_ST_SI", 0x00, NULL),
6452                 .wins   = {
6453                         .nb_flags       = 0,
6454                         .mhomed         = true,
6455                         .num_ips        = ctx->addresses_best_num,
6456                         .ips            = ctx->addresses_best,
6457                         .apply_expected = true
6458                 },
6459                 .replica= {
6460                         .type           = WREPL_TYPE_SGROUP,
6461                         .state          = WREPL_STATE_TOMBSTONE,
6462                         .node           = WREPL_NODE_B,
6463                         .is_static      = false,
6464                         .num_ips        = ctx->addresses_best_num,
6465                         .ips            = ctx->addresses_best,
6466                         .apply_expected = true
6467                 },
6468         },
6469         /*
6470          * mhomed,released vs. sgroup,tombstone with different ip(s)
6471          */
6472         {
6473                 .line   = __location__,
6474                 .name   = _NBT_NAME("_MR_ST_DI", 0x00, NULL),
6475                 .wins   = {
6476                         .nb_flags       = 0,
6477                         .mhomed         = true,
6478                         .num_ips        = ctx->addresses_best_num,
6479                         .ips            = ctx->addresses_best,
6480                         .apply_expected = true
6481                 },
6482                 .replica= {
6483                         .type           = WREPL_TYPE_SGROUP,
6484                         .state          = WREPL_STATE_TOMBSTONE,
6485                         .node           = WREPL_NODE_B,
6486                         .is_static      = false,
6487                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6488                         .ips            = addresses_B_1,
6489                         .apply_expected = true
6490                 },
6491         },
6492 /*
6493  * multi homed vs. multi homed section
6494  */
6495         /*
6496          * mhomed,released vs. mhomed,active with same ip(s)
6497          */
6498         {
6499                 .line   = __location__,
6500                 .name   = _NBT_NAME("_MR_MA_SI", 0x00, NULL),
6501                 .wins   = {
6502                         .nb_flags       = 0,
6503                         .mhomed         = true,
6504                         .num_ips        = ctx->addresses_best_num,
6505                         .ips            = ctx->addresses_best,
6506                         .apply_expected = true
6507                 },
6508                 .replica= {
6509                         .type           = WREPL_TYPE_MHOMED,
6510                         .state          = WREPL_STATE_ACTIVE,
6511                         .node           = WREPL_NODE_B,
6512                         .is_static      = false,
6513                         .num_ips        = ctx->addresses_best_num,
6514                         .ips            = ctx->addresses_best,
6515                         .apply_expected = true
6516                 },
6517         },
6518         /*
6519          * mhomed,released vs. mhomed,active with different ip(s)
6520          */
6521         {
6522                 .line   = __location__,
6523                 .name   = _NBT_NAME("_MR_MA_DI", 0x00, NULL),
6524                 .wins   = {
6525                         .nb_flags       = 0,
6526                         .mhomed         = true,
6527                         .num_ips        = ctx->addresses_best_num,
6528                         .ips            = ctx->addresses_best,
6529                         .apply_expected = true
6530                 },
6531                 .replica= {
6532                         .type           = WREPL_TYPE_MHOMED,
6533                         .state          = WREPL_STATE_ACTIVE,
6534                         .node           = WREPL_NODE_B,
6535                         .is_static      = false,
6536                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6537                         .ips            = addresses_B_1,
6538                         .apply_expected = true
6539                 },
6540         },
6541         /*
6542          * mhomed,released vs. mhomed,tombstone with same ip(s)
6543          */
6544         {
6545                 .line   = __location__,
6546                 .name   = _NBT_NAME("_MR_MT_SI", 0x00, NULL),
6547                 .wins   = {
6548                         .nb_flags       = 0,
6549                         .mhomed         = true,
6550                         .num_ips        = ctx->addresses_best_num,
6551                         .ips            = ctx->addresses_best,
6552                         .apply_expected = true
6553                 },
6554                 .replica= {
6555                         .type           = WREPL_TYPE_MHOMED,
6556                         .state          = WREPL_STATE_TOMBSTONE,
6557                         .node           = WREPL_NODE_B,
6558                         .is_static      = false,
6559                         .num_ips        = ctx->addresses_best_num,
6560                         .ips            = ctx->addresses_best,
6561                         .apply_expected = true
6562                 },
6563         },
6564         /*
6565          * mhomed,released vs. mhomed,tombstone with different ip(s)
6566          */
6567         {
6568                 .line   = __location__,
6569                 .name   = _NBT_NAME("_MR_MT_DI", 0x00, NULL),
6570                 .wins   = {
6571                         .nb_flags       = 0,
6572                         .mhomed         = true,
6573                         .num_ips        = ctx->addresses_best_num,
6574                         .ips            = ctx->addresses_best,
6575                         .apply_expected = true
6576                 },
6577                 .replica= {
6578                         .type           = WREPL_TYPE_MHOMED,
6579                         .state          = WREPL_STATE_TOMBSTONE,
6580                         .node           = WREPL_NODE_B,
6581                         .is_static      = false,
6582                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6583                         .ips            = addresses_B_1,
6584                         .apply_expected = true
6585                 },
6586         },
6587         };
6588
6589         torture_comment(tctx, "Test Replica records vs. owned released records\n");
6590
6591         for(i=0; ret && i < ARRAY_SIZE(records); i++) {
6592                 torture_comment(tctx, "%s => %s\n", nbt_name_string(ctx, &records[i].name),
6593                         (records[i].replica.apply_expected?"REPLACE":"NOT REPLACE"));
6594
6595                 /*
6596                  * Setup Register
6597                  */
6598                 name_register->in.name          = records[i].name;
6599                 name_register->in.dest_addr     = ctx->address;
6600                 name_register->in.dest_port     = lpcfg_nbt_port(tctx->lp_ctx);
6601                 name_register->in.address       = records[i].wins.ips[0].ip;
6602                 name_register->in.nb_flags      = records[i].wins.nb_flags;
6603                 name_register->in.register_demand= false;
6604                 name_register->in.broadcast     = false;
6605                 name_register->in.multi_homed   = records[i].wins.mhomed;
6606                 name_register->in.ttl           = 300000;
6607                 name_register->in.timeout       = 70;
6608                 name_register->in.retries       = 0;
6609
6610                 status = nbt_name_register(ctx->nbtsock, ctx, name_register);
6611                 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
6612                         torture_comment(tctx, "No response from %s for name register\n", ctx->address);
6613                         ret = false;
6614                 }
6615                 if (!NT_STATUS_IS_OK(status)) {
6616                         torture_comment(tctx, "Bad response from %s for name register - %s\n",
6617                                ctx->address, nt_errstr(status));
6618                         ret = false;
6619                 }
6620                 CHECK_VALUE(tctx, name_register->out.rcode, 0);
6621                 CHECK_VALUE_STRING(tctx, name_register->out.reply_from, ctx->address);
6622                 CHECK_VALUE(tctx, name_register->out.name.type, records[i].name.type);
6623                 CHECK_VALUE_STRING(tctx, name_register->out.name.name, records[i].name.name);
6624                 CHECK_VALUE_STRING(tctx, name_register->out.name.scope, records[i].name.scope);
6625                 CHECK_VALUE_STRING(tctx, name_register->out.reply_addr, records[i].wins.ips[0].ip);
6626
6627                 /* release the record */
6628                 release->in.name        = records[i].name;
6629                 release->in.dest_port   = lpcfg_nbt_port(tctx->lp_ctx);
6630                 release->in.dest_addr   = ctx->address;
6631                 release->in.address     = records[i].wins.ips[0].ip;
6632                 release->in.nb_flags    = records[i].wins.nb_flags;
6633                 release->in.broadcast   = false;
6634                 release->in.timeout     = 30;
6635                 release->in.retries     = 0;
6636
6637                 status = nbt_name_release(ctx->nbtsock, ctx, release);
6638                 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
6639                         torture_comment(tctx, "No response from %s for name release\n", ctx->address);
6640                         return false;
6641                 }
6642                 if (!NT_STATUS_IS_OK(status)) {
6643                         torture_comment(tctx, "Bad response from %s for name query - %s\n",
6644                                ctx->address, nt_errstr(status));
6645                         return false;
6646                 }
6647                 CHECK_VALUE(tctx, release->out.rcode, 0);
6648
6649                 /*
6650                  * Setup Replica
6651                  */
6652                 wins_name->name         = &records[i].name;
6653                 wins_name->flags        = WREPL_NAME_FLAGS(records[i].replica.type,
6654                                                            records[i].replica.state,
6655                                                            records[i].replica.node,
6656                                                            records[i].replica.is_static);
6657                 wins_name->id           = ++ctx->b.max_version;
6658                 if (wins_name->flags & 2) {
6659                         wins_name->addresses.addresses.num_ips = records[i].replica.num_ips;
6660                         wins_name->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
6661                                                                  records[i].replica.ips);
6662                 } else {
6663                         wins_name->addresses.ip = records[i].replica.ips[0].ip;
6664                 }
6665                 wins_name->unknown      = "255.255.255.255";
6666
6667                 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
6668                 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name,
6669                                              records[i].replica.apply_expected);
6670
6671                 if (records[i].replica.apply_expected) {
6672                         wins_name->name         = &records[i].name;
6673                         wins_name->flags        = WREPL_NAME_FLAGS(WREPL_TYPE_UNIQUE,
6674                                                                    WREPL_STATE_TOMBSTONE,
6675                                                                    WREPL_NODE_B, false);
6676                         wins_name->id           = ++ctx->b.max_version;
6677                         wins_name->addresses.ip = addresses_B_1[0].ip;
6678                         wins_name->unknown      = "255.255.255.255";
6679
6680                         ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
6681                         ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name, true);
6682                 } else {
6683                         release->in.name        = records[i].name;
6684                         release->in.dest_addr   = ctx->address;
6685                         release->in.dest_port   = lpcfg_nbt_port(tctx->lp_ctx);
6686                         release->in.address     = records[i].wins.ips[0].ip;
6687                         release->in.nb_flags    = records[i].wins.nb_flags;
6688                         release->in.broadcast   = false;
6689                         release->in.timeout     = 30;
6690                         release->in.retries     = 0;
6691
6692                         status = nbt_name_release(ctx->nbtsock, ctx, release);
6693                         if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
6694                                 torture_comment(tctx, "No response from %s for name release\n", ctx->address);
6695                                 return false;
6696                         }
6697                         if (!NT_STATUS_IS_OK(status)) {
6698                                 torture_comment(tctx, "Bad response from %s for name query - %s\n",
6699                                        ctx->address, nt_errstr(status));
6700                                 return false;
6701                         }
6702                         CHECK_VALUE(tctx, release->out.rcode, 0);
6703                 }
6704                 if (!ret) {
6705                         torture_comment(tctx, "conflict handled wrong or record[%u]: %s\n", i, records[i].line);
6706                         return ret;
6707                 }
6708         }
6709
6710         return ret;
6711 }
6712
6713 struct test_conflict_owned_active_vs_replica_struct {
6714         struct torture_context *tctx;
6715         const char *line; /* just better debugging */
6716         const char *section; /* just better debugging */
6717         struct nbt_name name;
6718         const char *comment;
6719         bool skip;
6720         struct {
6721                 uint32_t nb_flags;
6722                 bool mhomed;
6723                 uint32_t num_ips;
6724                 const struct wrepl_ip *ips;
6725                 bool apply_expected;
6726         } wins;
6727         struct {
6728                 uint32_t timeout;
6729                 bool positive;
6730                 bool expect_release;
6731                 bool late_release;
6732                 bool ret;
6733                 /* when num_ips == 0, then .wins.ips are used */
6734                 uint32_t num_ips;
6735                 const struct wrepl_ip *ips;
6736         } defend;
6737         struct {
6738                 enum wrepl_name_type type;
6739                 enum wrepl_name_state state;
6740                 enum wrepl_name_node node;
6741                 bool is_static;
6742                 uint32_t num_ips;
6743                 const struct wrepl_ip *ips;
6744                 bool apply_expected;
6745                 bool mhomed_merge;
6746                 bool sgroup_merge;
6747         } replica;
6748 };
6749
6750 static void test_conflict_owned_active_vs_replica_handler(struct nbt_name_socket *nbtsock,
6751                                                           struct nbt_name_packet *req_packet,
6752                                                           struct socket_address *src);
6753
6754 static bool test_conflict_owned_active_vs_replica(struct torture_context *tctx,
6755                                                                                                   struct test_wrepl_conflict_conn *ctx)
6756 {
6757         bool ret = true;
6758         NTSTATUS status;
6759         struct wrepl_wins_name wins_name_;
6760         struct wrepl_wins_name *wins_name = &wins_name_;
6761         struct nbt_name_register name_register_;
6762         struct nbt_name_register *name_register = &name_register_;
6763         struct nbt_name_release release_;
6764         struct nbt_name_release *release = &release_;
6765         uint32_t i;
6766         struct test_conflict_owned_active_vs_replica_struct records[] = {
6767 /*
6768  * unique vs. unique section
6769  */
6770         /*
6771          * unique,active vs. unique,active with same ip(s), unchecked
6772          */
6773         {
6774                 .tctx   = tctx,
6775                 .line   = __location__,
6776                 .name   = _NBT_NAME("_UA_UA_SI_U", 0x00, NULL),
6777                 .wins   = {
6778                         .nb_flags       = 0,
6779                         .mhomed         = false,
6780                         .num_ips        = ctx->addresses_best_num,
6781                         .ips            = ctx->addresses_best,
6782                         .apply_expected = true
6783                 },
6784                 .defend = {
6785                         .timeout        = 0,
6786                 },
6787                 .replica= {
6788                         .type           = WREPL_TYPE_UNIQUE,
6789                         .state          = WREPL_STATE_ACTIVE,
6790                         .node           = WREPL_NODE_B,
6791                         .is_static      = false,
6792                         .num_ips        = ctx->addresses_best_num,
6793                         .ips            = ctx->addresses_best,
6794                         .apply_expected = true
6795                 },
6796         },
6797         /*
6798          * unique,active vs. unique,active with different ip(s), positive response
6799          */
6800         {
6801                 .tctx   = tctx,
6802                 .line   = __location__,
6803                 .name   = _NBT_NAME("_UA_UA_DI_P", 0x00, NULL),
6804                 .wins   = {
6805                         .nb_flags       = 0,
6806                         .mhomed         = false,
6807                         .num_ips        = ctx->addresses_best_num,
6808                         .ips            = ctx->addresses_best,
6809                         .apply_expected = true
6810                 },
6811                 .defend = {
6812                         .timeout        = 10,
6813                         .positive       = true,
6814                 },
6815                 .replica= {
6816                         .type           = WREPL_TYPE_UNIQUE,
6817                         .state          = WREPL_STATE_ACTIVE,
6818                         .node           = WREPL_NODE_B,
6819                         .is_static      = false,
6820                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6821                         .ips            = addresses_B_1,
6822                         .apply_expected = false
6823                 },
6824         },
6825         /*
6826          * unique,active vs. unique,active with different ip(s), positive response other ips
6827          */
6828         {
6829                 .tctx   = tctx,
6830                 .line   = __location__,
6831                 .name   = _NBT_NAME("_UA_UA_DI_O", 0x00, NULL),
6832                 .wins   = {
6833                         .nb_flags       = 0,
6834                         .mhomed         = false,
6835                         .num_ips        = ctx->addresses_best_num,
6836                         .ips            = ctx->addresses_best,
6837                         .apply_expected = true
6838                 },
6839                 .defend = {
6840                         .timeout        = 10,
6841                         .positive       = true,
6842                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
6843                         .ips            = addresses_A_3_4,
6844                 },
6845                 .replica= {
6846                         .type           = WREPL_TYPE_UNIQUE,
6847                         .state          = WREPL_STATE_ACTIVE,
6848                         .node           = WREPL_NODE_B,
6849                         .is_static      = false,
6850                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6851                         .ips            = addresses_B_1,
6852                         .apply_expected = false
6853                 },
6854         },
6855         /*
6856          * unique,active vs. unique,active with different ip(s), negative response
6857          */
6858         {
6859                 .tctx   = tctx,
6860                 .line   = __location__,
6861                 .name   = _NBT_NAME("_UA_UA_DI_N", 0x00, NULL),
6862                 .wins   = {
6863                         .nb_flags       = 0,
6864                         .mhomed         = false,
6865                         .num_ips        = ctx->addresses_best_num,
6866                         .ips            = ctx->addresses_best,
6867                         .apply_expected = true
6868                 },
6869                 .defend = {
6870                         .timeout        = 10,
6871                         .positive       = false,
6872                 },
6873                 .replica= {
6874                         .type           = WREPL_TYPE_UNIQUE,
6875                         .state          = WREPL_STATE_ACTIVE,
6876                         .node           = WREPL_NODE_B,
6877                         .is_static      = false,
6878                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6879                         .ips            = addresses_B_1,
6880                         .apply_expected = true
6881                 },
6882         },
6883         /*
6884          * unique,active vs. unique,tombstone with same ip(s), unchecked
6885          */
6886         {
6887                 .tctx   = tctx,
6888                 .line   = __location__,
6889                 .name   = _NBT_NAME("_UA_UT_SI_U", 0x00, NULL),
6890                 .wins   = {
6891                         .nb_flags       = 0,
6892                         .mhomed         = false,
6893                         .num_ips        = ctx->addresses_best_num,
6894                         .ips            = ctx->addresses_best,
6895                         .apply_expected = true
6896                 },
6897                 .defend = {
6898                         .timeout        = 0,
6899                 },
6900                 .replica= {
6901                         .type           = WREPL_TYPE_UNIQUE,
6902                         .state          = WREPL_STATE_TOMBSTONE,
6903                         .node           = WREPL_NODE_B,
6904                         .is_static      = false,
6905                         .num_ips        = ctx->addresses_best_num,
6906                         .ips            = ctx->addresses_best,
6907                         .apply_expected = false
6908                 },
6909         },
6910         /*
6911          * unique,active vs. unique,tombstone with different ip(s), unchecked
6912          */
6913         {
6914                 .tctx   = tctx,
6915                 .line   = __location__,
6916                 .name   = _NBT_NAME("_UA_UT_DI_U", 0x00, NULL),
6917                 .wins   = {
6918                         .nb_flags       = 0,
6919                         .mhomed         = false,
6920                         .num_ips        = ctx->addresses_best_num,
6921                         .ips            = ctx->addresses_best,
6922                         .apply_expected = true
6923                 },
6924                 .defend = {
6925                         .timeout        = 0,
6926                 },
6927                 .replica= {
6928                         .type           = WREPL_TYPE_UNIQUE,
6929                         .state          = WREPL_STATE_TOMBSTONE,
6930                         .node           = WREPL_NODE_B,
6931                         .is_static      = false,
6932                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6933                         .ips            = addresses_B_1,
6934                         .apply_expected = false
6935                 },
6936         },
6937 /*
6938  * unique vs. group section
6939  */
6940         /*
6941          * unique,active vs. group,active with same ip(s), release expected
6942          */
6943         {
6944                 .tctx   = tctx,
6945                 .line   = __location__,
6946                 .name   = _NBT_NAME("_UA_GA_SI_R", 0x00, NULL),
6947                 .wins   = {
6948                         .nb_flags       = 0,
6949                         .mhomed         = false,
6950                         .num_ips        = ctx->addresses_best_num,
6951                         .ips            = ctx->addresses_best,
6952                         .apply_expected = true
6953                 },
6954                 .defend = {
6955                         .timeout        = 10,
6956                         .expect_release = true,
6957                 },
6958                 .replica= {
6959                         .type           = WREPL_TYPE_GROUP,
6960                         .state          = WREPL_STATE_ACTIVE,
6961                         .node           = WREPL_NODE_B,
6962                         .is_static      = false,
6963                         .num_ips        = ctx->addresses_best_num,
6964                         .ips            = ctx->addresses_best,
6965                         .apply_expected = true
6966                 },
6967         },
6968         /*
6969          * unique,active vs. group,active with different ip(s), release expected
6970          */
6971         {
6972                 .tctx   = tctx,
6973                 .line   = __location__,
6974                 .name   = _NBT_NAME("_UA_GA_DI_R", 0x00, NULL),
6975                 .wins   = {
6976                         .nb_flags       = 0,
6977                         .mhomed         = false,
6978                         .num_ips        = ctx->addresses_best_num,
6979                         .ips            = ctx->addresses_best,
6980                         .apply_expected = true
6981                 },
6982                 .defend = {
6983                         .timeout        = 10,
6984                         .expect_release = true,
6985                 },
6986                 .replica= {
6987                         .type           = WREPL_TYPE_GROUP,
6988                         .state          = WREPL_STATE_ACTIVE,
6989                         .node           = WREPL_NODE_B,
6990                         .is_static      = false,
6991                         .num_ips        = ARRAY_SIZE(addresses_B_1),
6992                         .ips            = addresses_B_1,
6993                         .apply_expected = true
6994                 },
6995         },
6996         /*
6997          * unique,active vs. group,tombstone with same ip(s), unchecked
6998          */
6999         {
7000                 .tctx   = tctx,
7001                 .line   = __location__,
7002                 .name   = _NBT_NAME("_UA_GT_SI_U", 0x00, NULL),
7003                 .wins   = {
7004                         .nb_flags       = 0,
7005                         .mhomed         = false,
7006                         .num_ips        = ctx->addresses_best_num,
7007                         .ips            = ctx->addresses_best,
7008                         .apply_expected = true
7009                 },
7010                 .defend = {
7011                         .timeout        = 0,
7012                 },
7013                 .replica= {
7014                         .type           = WREPL_TYPE_GROUP,
7015                         .state          = WREPL_STATE_TOMBSTONE,
7016                         .node           = WREPL_NODE_B,
7017                         .is_static      = false,
7018                         .num_ips        = ctx->addresses_best_num,
7019                         .ips            = ctx->addresses_best,
7020                         .apply_expected = false
7021                 },
7022         },
7023         /*
7024          * unique,active vs. group,tombstone with different ip(s), unchecked
7025          */
7026         {
7027                 .tctx   = tctx,
7028                 .line   = __location__,
7029                 .name   = _NBT_NAME("_UA_GT_DI_U", 0x00, NULL),
7030                 .wins   = {
7031                         .nb_flags       = 0,
7032                         .mhomed         = false,
7033                         .num_ips        = ctx->addresses_best_num,
7034                         .ips            = ctx->addresses_best,
7035                         .apply_expected = true
7036                 },
7037                 .defend = {
7038                         .timeout        = 0,
7039                 },
7040                 .replica= {
7041                         .type           = WREPL_TYPE_GROUP,
7042                         .state          = WREPL_STATE_TOMBSTONE,
7043                         .node           = WREPL_NODE_B,
7044                         .is_static      = false,
7045                         .num_ips        = ARRAY_SIZE(addresses_B_1),
7046                         .ips            = addresses_B_1,
7047                         .apply_expected = false
7048                 },
7049         },
7050 /*
7051  * unique vs. special group section
7052  */
7053         /*
7054          * unique,active vs. sgroup,active with same ip(s), release expected
7055          */
7056         {
7057                 .tctx   = tctx,
7058                 .line   = __location__,
7059                 .name   = _NBT_NAME("_UA_SA_SI_R", 0x00, NULL),
7060                 .wins   = {
7061                         .nb_flags       = 0,
7062                         .mhomed         = false,
7063                         .num_ips        = ctx->addresses_best_num,
7064                         .ips            = ctx->addresses_best,
7065                         .apply_expected = true
7066                 },
7067                 .defend = {
7068                         .timeout        = 10,
7069                         .expect_release = true,
7070                 },
7071                 .replica= {
7072                         .type           = WREPL_TYPE_SGROUP,
7073                         .state          = WREPL_STATE_ACTIVE,
7074                         .node           = WREPL_NODE_B,
7075                         .is_static      = false,
7076                         .num_ips        = ctx->addresses_best_num,
7077                         .ips            = ctx->addresses_best,
7078                         .apply_expected = true
7079                 },
7080         },
7081         /*
7082          * unique,active vs. group,active with different ip(s), release expected
7083          */
7084         {
7085                 .tctx   = tctx,
7086                 .line   = __location__,
7087                 .name   = _NBT_NAME("_UA_SA_DI_R", 0x00, NULL),
7088                 .wins   = {
7089                         .nb_flags       = 0,
7090                         .mhomed         = false,
7091                         .num_ips        = ctx->addresses_best_num,
7092                         .ips            = ctx->addresses_best,
7093                         .apply_expected = true
7094                 },
7095                 .defend = {
7096                         .timeout        = 10,
7097                         .expect_release = true,
7098                 },
7099                 .replica= {
7100                         .type           = WREPL_TYPE_SGROUP,
7101                         .state          = WREPL_STATE_ACTIVE,
7102                         .node           = WREPL_NODE_B,
7103                         .is_static      = false,
7104                         .num_ips        = ARRAY_SIZE(addresses_B_1),
7105                         .ips            = addresses_B_1,
7106                         .apply_expected = true
7107                 },
7108         },
7109         /*
7110          * unique,active vs. sgroup,tombstone with same ip(s), unchecked
7111          */
7112         {
7113                 .tctx   = tctx,
7114                 .line   = __location__,
7115                 .name   = _NBT_NAME("_UA_ST_SI_U", 0x00, NULL),
7116                 .wins   = {
7117                         .nb_flags       = 0,
7118                         .mhomed         = false,
7119                         .num_ips        = ctx->addresses_best_num,
7120                         .ips            = ctx->addresses_best,
7121                         .apply_expected = true
7122                 },
7123                 .defend = {
7124                         .timeout        = 0,
7125                 },
7126                 .replica= {
7127                         .type           = WREPL_TYPE_SGROUP,
7128                         .state          = WREPL_STATE_TOMBSTONE,
7129                         .node           = WREPL_NODE_B,
7130                         .is_static      = false,
7131                         .num_ips        = ctx->addresses_best_num,
7132                         .ips            = ctx->addresses_best,
7133                         .apply_expected = false
7134                 },
7135         },
7136         /*
7137          * unique,active vs. sgroup,tombstone with different ip(s), unchecked
7138          */
7139         {
7140                 .tctx   = tctx,
7141                 .line   = __location__,
7142                 .name   = _NBT_NAME("_UA_ST_DI_U", 0x00, NULL),
7143                 .wins   = {
7144                         .nb_flags       = 0,
7145                         .mhomed         = false,
7146                         .num_ips        = ctx->addresses_best_num,
7147                         .ips            = ctx->addresses_best,
7148                         .apply_expected = true
7149                 },
7150                 .defend = {
7151                         .timeout        = 0,
7152                 },
7153                 .replica= {
7154                         .type           = WREPL_TYPE_SGROUP,
7155                         .state          = WREPL_STATE_TOMBSTONE,
7156                         .node           = WREPL_NODE_B,
7157                         .is_static      = false,
7158                         .num_ips        = ARRAY_SIZE(addresses_B_1),
7159                         .ips            = addresses_B_1,
7160                         .apply_expected = false
7161                 },
7162         },
7163 /*
7164  * unique vs. multi homed section
7165  */
7166         /*
7167          * unique,active vs. mhomed,active with same ip(s), unchecked
7168          */
7169         {
7170                 .tctx   = tctx,
7171                 .line   = __location__,
7172                 .name   = _NBT_NAME("_UA_MA_SI_U", 0x00, NULL),
7173                 .wins   = {
7174                         .nb_flags       = 0,
7175                         .mhomed         = false,
7176                         .num_ips        = ctx->addresses_best_num,
7177                         .ips            = ctx->addresses_best,
7178                         .apply_expected = true
7179                 },
7180                 .defend = {
7181                         .timeout        = 0,
7182                 },
7183                 .replica= {
7184                         .type           = WREPL_TYPE_MHOMED,
7185                         .state          = WREPL_STATE_ACTIVE,
7186                         .node           = WREPL_NODE_B,
7187                         .is_static      = false,
7188                         .num_ips        = ctx->addresses_best_num,
7189                         .ips            = ctx->addresses_best,
7190                         .apply_expected = true
7191                 },
7192         },
7193         /*
7194          * unique,active vs. mhomed,active with superset ip(s), unchecked
7195          */
7196         {
7197                 .tctx   = tctx,
7198                 .line   = __location__,
7199                 .name   = _NBT_NAME("_UA_MA_SP_U", 0x00, NULL),
7200                 .wins   = {
7201                         .nb_flags       = 0,
7202                         .mhomed         = false,
7203                         .num_ips        = ctx->addresses_best_num,
7204                         .ips            = ctx->addresses_best,
7205                         .apply_expected = true
7206                 },
7207                 .defend = {
7208                         .timeout        = 0,
7209                 },
7210                 .replica= {
7211                         .type           = WREPL_TYPE_MHOMED,
7212                         .state          = WREPL_STATE_ACTIVE,
7213                         .node           = WREPL_NODE_B,
7214                         .is_static      = false,
7215                         .num_ips        = ctx->addresses_all_num,
7216                         .ips            = ctx->addresses_all,
7217                         .apply_expected = true
7218                 },
7219         },
7220         /*
7221          * unique,active vs. mhomed,active with different ip(s), positive response
7222          */
7223         {
7224                 .tctx   = tctx,
7225                 .line   = __location__,
7226                 .name   = _NBT_NAME("_UA_MA_DI_P", 0x00, NULL),
7227                 .wins   = {
7228                         .nb_flags       = 0,
7229                         .mhomed         = false,
7230                         .num_ips        = ctx->addresses_best_num,
7231                         .ips            = ctx->addresses_best,
7232                         .apply_expected = true
7233                 },
7234                 .defend = {
7235                         .timeout        = 10,
7236                         .positive       = true,
7237                 },
7238                 .replica= {
7239                         .type           = WREPL_TYPE_MHOMED,
7240                         .state          = WREPL_STATE_ACTIVE,
7241                         .node           = WREPL_NODE_B,
7242                         .is_static      = false,
7243                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
7244                         .ips            = addresses_B_3_4,
7245                         .apply_expected = false
7246                 },
7247         },
7248         /*
7249          * unique,active vs. mhomed,active with different ip(s), positive response other ips
7250          */
7251         {
7252                 .tctx   = tctx,
7253                 .line   = __location__,
7254                 .name   = _NBT_NAME("_UA_MA_DI_O", 0x00, NULL),
7255                 .wins   = {
7256                         .nb_flags       = 0,
7257                         .mhomed         = false,
7258                         .num_ips        = ctx->addresses_best_num,
7259                         .ips            = ctx->addresses_best,
7260                         .apply_expected = true
7261                 },
7262                 .defend = {
7263                         .timeout        = 10,
7264                         .positive       = true,
7265                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
7266                         .ips            = addresses_A_3_4,
7267                 },
7268                 .replica= {
7269                         .type           = WREPL_TYPE_MHOMED,
7270                         .state          = WREPL_STATE_ACTIVE,
7271                         .node           = WREPL_NODE_B,
7272                         .is_static      = false,
7273                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
7274                         .ips            = addresses_B_3_4,
7275                         .apply_expected = false
7276                 },
7277         },
7278         /*
7279          * unique,active vs. mhomed,active with different ip(s), negative response
7280          */
7281         {
7282                 .tctx   = tctx,
7283                 .line   = __location__,
7284                 .name   = _NBT_NAME("_UA_MA_DI_N", 0x00, NULL),
7285                 .wins   = {
7286                         .nb_flags       = 0,
7287                         .mhomed         = false,
7288                         .num_ips        = ctx->addresses_best_num,
7289                         .ips            = ctx->addresses_best,
7290                         .apply_expected = true
7291                 },
7292                 .defend = {
7293                         .timeout        = 10,
7294                         .positive       = false,
7295                 },
7296                 .replica= {
7297                         .type           = WREPL_TYPE_MHOMED,
7298                         .state          = WREPL_STATE_ACTIVE,
7299                         .node           = WREPL_NODE_B,
7300                         .is_static      = false,
7301                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
7302                         .ips            = addresses_B_3_4,
7303                         .apply_expected = true
7304                 },
7305         },
7306         /*
7307          * unique,active vs. mhomed,tombstone with same ip(s), unchecked
7308          */
7309         {
7310                 .tctx   = tctx,
7311                 .line   = __location__,
7312                 .name   = _NBT_NAME("_UA_MT_SI_U", 0x00, NULL),
7313                 .wins   = {
7314                         .nb_flags       = 0,
7315                         .mhomed         = false,
7316                         .num_ips        = ctx->addresses_best_num,
7317                         .ips            = ctx->addresses_best,
7318                         .apply_expected = true
7319                 },
7320                 .defend = {
7321                         .timeout        = 0,
7322                 },
7323                 .replica= {
7324                         .type           = WREPL_TYPE_MHOMED,
7325                         .state          = WREPL_STATE_TOMBSTONE,
7326                         .node           = WREPL_NODE_B,
7327                         .is_static      = false,
7328                         .num_ips        = ctx->addresses_best_num,
7329                         .ips            = ctx->addresses_best,
7330                         .apply_expected = false
7331                 },
7332         },
7333         /*
7334          * unique,active vs. mhomed,tombstone with different ip(s), unchecked
7335          */
7336         {
7337                 .tctx   = tctx,
7338                 .line   = __location__,
7339                 .name   = _NBT_NAME("_UA_MT_DI_U", 0x00, NULL),
7340                 .wins   = {
7341                         .nb_flags       = 0,
7342                         .mhomed         = false,
7343                         .num_ips        = ctx->addresses_best_num,
7344                         .ips            = ctx->addresses_best,
7345                         .apply_expected = true
7346                 },
7347                 .defend = {
7348                         .timeout        = 0,
7349                 },
7350                 .replica= {
7351                         .type           = WREPL_TYPE_MHOMED,
7352                         .state          = WREPL_STATE_TOMBSTONE,
7353                         .node           = WREPL_NODE_B,
7354                         .is_static      = false,
7355                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
7356                         .ips            = addresses_B_3_4,
7357                         .apply_expected = false
7358                 },
7359         },
7360 /*
7361  * normal group vs. unique section
7362  */
7363         /*
7364          * group,active vs. unique,active with same ip(s), unchecked
7365          */
7366         {
7367                 .tctx   = tctx,
7368                 .line   = __location__,
7369                 .name   = _NBT_NAME("_GA_UA_SI_U", 0x00, NULL),
7370                 .wins   = {
7371                         .nb_flags       = NBT_NM_GROUP,
7372                         .mhomed         = false,
7373                         .num_ips        = ctx->addresses_best_num,
7374                         .ips            = ctx->addresses_best,
7375                         .apply_expected = true
7376                 },
7377                 .defend = {
7378                         .timeout        = 0,
7379                 },
7380                 .replica= {
7381                         .type           = WREPL_TYPE_UNIQUE,
7382                         .state          = WREPL_STATE_ACTIVE,
7383                         .node           = WREPL_NODE_B,
7384                         .is_static      = false,
7385                         .num_ips        = ctx->addresses_best_num,
7386                         .ips            = ctx->addresses_best,
7387                         .apply_expected = false
7388                 },
7389         },
7390         /*
7391          * group,active vs. unique,active with different ip(s), unchecked
7392          */
7393         {
7394                 .tctx   = tctx,
7395                 .line   = __location__,
7396                 .name   = _NBT_NAME("_GA_UA_DI_U", 0x00, NULL),
7397                 .wins   = {
7398                         .nb_flags       = NBT_NM_GROUP,
7399                         .mhomed         = false,
7400                         .num_ips        = ctx->addresses_best_num,
7401                         .ips            = ctx->addresses_best,
7402                         .apply_expected = true
7403                 },
7404                 .defend = {
7405                         .timeout        = 0,
7406                 },
7407                 .replica= {
7408                         .type           = WREPL_TYPE_UNIQUE,
7409                         .state          = WREPL_STATE_ACTIVE,
7410                         .node           = WREPL_NODE_B,
7411                         .is_static      = false,
7412                         .num_ips        = ARRAY_SIZE(addresses_B_1),
7413                         .ips            = addresses_B_1,
7414                         .apply_expected = false
7415                 },
7416         },
7417         /*
7418          * group,active vs. unique,tombstone with same ip(s), unchecked
7419          */
7420         {
7421                 .tctx   = tctx,
7422                 .line   = __location__,
7423                 .name   = _NBT_NAME("_GA_UT_SI_U", 0x00, NULL),
7424                 .wins   = {
7425                         .nb_flags       = NBT_NM_GROUP,
7426                         .mhomed         = false,
7427                         .num_ips        = ctx->addresses_best_num,
7428                         .ips            = ctx->addresses_best,
7429                         .apply_expected = true
7430                 },
7431                 .defend = {
7432                         .timeout        = 0,
7433                 },
7434                 .replica= {
7435                         .type           = WREPL_TYPE_UNIQUE,
7436                         .state          = WREPL_STATE_TOMBSTONE,
7437                         .node           = WREPL_NODE_B,
7438                         .is_static      = false,
7439                         .num_ips        = ctx->addresses_best_num,
7440                         .ips            = ctx->addresses_best,
7441                         .apply_expected = false
7442                 },
7443         },
7444         /*
7445          * group,active vs. unique,tombstone with different ip(s), unchecked
7446          */
7447         {
7448                 .tctx   = tctx,
7449                 .line   = __location__,
7450                 .name   = _NBT_NAME("_GA_UT_DI_U", 0x00, NULL),
7451                 .wins   = {
7452                         .nb_flags       = NBT_NM_GROUP,
7453                         .mhomed         = false,
7454                         .num_ips        = ctx->addresses_best_num,
7455                         .ips            = ctx->addresses_best,
7456                         .apply_expected = true
7457                 },
7458                 .defend = {
7459                         .timeout        = 0,
7460                 },
7461                 .replica= {
7462                         .type           = WREPL_TYPE_UNIQUE,
7463                         .state          = WREPL_STATE_TOMBSTONE,
7464                         .node           = WREPL_NODE_B,
7465                         .is_static      = false,
7466                         .num_ips        = ARRAY_SIZE(addresses_B_1),
7467                         .ips            = addresses_B_1,
7468                         .apply_expected = false
7469                 },
7470         },
7471 /*
7472  * normal group vs. normal group section
7473  */
7474         /*
7475          * group,active vs. group,active with same ip(s), unchecked
7476          */
7477         {
7478                 .tctx   = tctx,
7479                 .line   = __location__,
7480                 .name   = _NBT_NAME("_GA_GA_SI_U", 0x00, NULL),
7481                 .wins   = {
7482                         .nb_flags       = NBT_NM_GROUP,
7483                         .mhomed         = false,
7484                         .num_ips        = ctx->addresses_best_num,
7485                         .ips            = ctx->addresses_best,
7486                         .apply_expected = true
7487                 },
7488                 .defend = {
7489                         .timeout        = 0,
7490                 },
7491                 .replica= {
7492                         .type           = WREPL_TYPE_GROUP,
7493                         .state          = WREPL_STATE_ACTIVE,
7494                         .node           = WREPL_NODE_B,
7495                         .is_static      = false,
7496                         .num_ips        = ctx->addresses_best_num,
7497                         .ips            = ctx->addresses_best,
7498                         .apply_expected = true
7499                 },
7500         },
7501         /*
7502          * group,active vs. group,active with different ip(s), unchecked
7503          */
7504         {
7505                 .tctx   = tctx,
7506                 .line   = __location__,
7507                 .name   = _NBT_NAME("_GA_GA_DI_U", 0x00, NULL),
7508                 .wins   = {
7509                         .nb_flags       = NBT_NM_GROUP,
7510                         .mhomed         = false,
7511                         .num_ips        = ctx->addresses_best_num,
7512                         .ips            = ctx->addresses_best,
7513                         .apply_expected = true
7514                 },
7515                 .defend = {
7516                         .timeout        = 0,
7517                 },
7518                 .replica= {
7519                         .type           = WREPL_TYPE_GROUP,
7520                         .state          = WREPL_STATE_ACTIVE,
7521                         .node           = WREPL_NODE_B,
7522                         .is_static      = false,
7523                         .num_ips        = ARRAY_SIZE(addresses_B_1),
7524                         .ips            = addresses_B_1,
7525                         .apply_expected = true
7526                 },
7527         },
7528         /*
7529          * group,active vs. group,tombstone with same ip(s), unchecked
7530          */
7531         {
7532                 .tctx   = tctx,
7533                 .line   = __location__,
7534                 .name   = _NBT_NAME("_GA_GT_SI_U", 0x00, NULL),
7535                 .wins   = {
7536                         .nb_flags       = NBT_NM_GROUP,
7537                         .mhomed         = false,
7538                         .num_ips        = ctx->addresses_best_num,
7539                         .ips            = ctx->addresses_best,
7540                         .apply_expected = true
7541                 },
7542                 .defend = {
7543                         .timeout        = 0,
7544                 },
7545                 .replica= {
7546                         .type           = WREPL_TYPE_GROUP,
7547                         .state          = WREPL_STATE_TOMBSTONE,
7548                         .node           = WREPL_NODE_B,
7549                         .is_static      = false,
7550                         .num_ips        = ctx->addresses_best_num,
7551                         .ips            = ctx->addresses_best,
7552                         .apply_expected = false
7553                 },
7554         },
7555         /*
7556          * group,active vs. group,tombstone with different ip(s), unchecked
7557          */
7558         {
7559                 .tctx   = tctx,
7560                 .line   = __location__,
7561                 .name   = _NBT_NAME("_GA_GT_DI_U", 0x00, NULL),
7562                 .wins   = {
7563                         .nb_flags       = NBT_NM_GROUP,
7564                         .mhomed         = false,
7565                         .num_ips        = ctx->addresses_best_num,
7566                         .ips            = ctx->addresses_best,
7567                         .apply_expected = true
7568                 },
7569                 .defend = {
7570                         .timeout        = 0,
7571                 },
7572                 .replica= {
7573                         .type           = WREPL_TYPE_GROUP,
7574                         .state          = WREPL_STATE_TOMBSTONE,
7575                         .node           = WREPL_NODE_B,
7576                         .is_static      = false,
7577                         .num_ips        = ARRAY_SIZE(addresses_B_1),
7578                         .ips            = addresses_B_1,
7579                         .apply_expected = false
7580                 },
7581         },
7582 /*
7583  * normal group vs. special group section
7584  */
7585         /*
7586          * group,active vs. sgroup,active with same ip(s), unchecked
7587          */
7588         {
7589                 .tctx   = tctx,
7590                 .line   = __location__,
7591                 .name   = _NBT_NAME("_GA_SA_SI_U", 0x00, NULL),
7592                 .wins   = {
7593                         .nb_flags       = NBT_NM_GROUP,
7594                         .mhomed         = false,
7595                         .num_ips        = ctx->addresses_best_num,
7596                         .ips            = ctx->addresses_best,
7597                         .apply_expected = true
7598                 },
7599                 .defend = {
7600                         .timeout        = 0,
7601                 },
7602                 .replica= {
7603                         .type           = WREPL_TYPE_SGROUP,
7604                         .state          = WREPL_STATE_ACTIVE,
7605                         .node           = WREPL_NODE_B,
7606                         .is_static      = false,
7607                         .num_ips        = ctx->addresses_best_num,
7608                         .ips            = ctx->addresses_best,
7609                         .apply_expected = false
7610                 },
7611         },
7612         /*
7613          * group,active vs. sgroup,active with different ip(s), unchecked
7614          */
7615         {
7616                 .tctx   = tctx,
7617                 .line   = __location__,
7618                 .name   = _NBT_NAME("_GA_SA_DI_U", 0x00, NULL),
7619                 .wins   = {
7620                         .nb_flags       = NBT_NM_GROUP,
7621                         .mhomed         = false,
7622                         .num_ips        = ctx->addresses_best_num,
7623                         .ips            = ctx->addresses_best,
7624                         .apply_expected = true
7625                 },
7626                 .defend = {
7627                         .timeout        = 0,
7628                 },
7629                 .replica= {
7630                         .type           = WREPL_TYPE_SGROUP,
7631                         .state          = WREPL_STATE_ACTIVE,
7632                         .node           = WREPL_NODE_B,
7633                         .is_static      = false,
7634                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
7635                         .ips            = addresses_B_3_4,
7636                         .apply_expected = false
7637                 },
7638         },
7639         /*
7640          * group,active vs. sgroup,tombstone with same ip(s), unchecked
7641          */
7642         {
7643                 .tctx   = tctx,
7644                 .line   = __location__,
7645                 .name   = _NBT_NAME("_GA_ST_SI_U", 0x00, NULL),
7646                 .wins   = {
7647                         .nb_flags       = NBT_NM_GROUP,
7648                         .mhomed         = false,
7649                         .num_ips        = ctx->addresses_best_num,
7650                         .ips            = ctx->addresses_best,
7651                         .apply_expected = true
7652                 },
7653                 .defend = {
7654                         .timeout        = 0,
7655                 },
7656                 .replica= {
7657                         .type           = WREPL_TYPE_SGROUP,
7658                         .state          = WREPL_STATE_TOMBSTONE,
7659                         .node           = WREPL_NODE_B,
7660                         .is_static      = false,
7661                         .num_ips        = ctx->addresses_best_num,
7662                         .ips            = ctx->addresses_best,
7663                         .apply_expected = false
7664                 },
7665         },
7666         /*
7667          * group,active vs. sgroup,tombstone with different ip(s), unchecked
7668          */
7669         {
7670                 .tctx   = tctx,
7671                 .line   = __location__,
7672                 .name   = _NBT_NAME("_GA_ST_DI_U", 0x00, NULL),
7673                 .wins   = {
7674                         .nb_flags       = NBT_NM_GROUP,
7675                         .mhomed         = false,
7676                         .num_ips        = ctx->addresses_best_num,
7677                         .ips            = ctx->addresses_best,
7678                         .apply_expected = true
7679                 },
7680                 .defend = {
7681                         .timeout        = 0,
7682                 },
7683                 .replica= {
7684                         .type           = WREPL_TYPE_SGROUP,
7685                         .state          = WREPL_STATE_TOMBSTONE,
7686                         .node           = WREPL_NODE_B,
7687                         .is_static      = false,
7688                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
7689                         .ips            = addresses_B_3_4,
7690                         .apply_expected = false
7691                 },
7692         },
7693 /*
7694  * normal group vs. multi homed section
7695  */
7696         /*
7697          * group,active vs. mhomed,active with same ip(s), unchecked
7698          */
7699         {
7700                 .tctx   = tctx,
7701                 .line   = __location__,
7702                 .name   = _NBT_NAME("_GA_MA_SI_U", 0x00, NULL),
7703                 .wins   = {
7704                         .nb_flags       = NBT_NM_GROUP,
7705                         .mhomed         = false,
7706                         .num_ips        = ctx->addresses_best_num,
7707                         .ips            = ctx->addresses_best,
7708                         .apply_expected = true
7709                 },
7710                 .defend = {
7711                         .timeout        = 0,
7712                 },
7713                 .replica= {
7714                         .type           = WREPL_TYPE_MHOMED,
7715                         .state          = WREPL_STATE_ACTIVE,
7716                         .node           = WREPL_NODE_B,
7717                         .is_static      = false,
7718                         .num_ips        = ctx->addresses_best_num,
7719                         .ips            = ctx->addresses_best,
7720                         .apply_expected = false
7721                 },
7722         },
7723         /*
7724          * group,active vs. mhomed,active with different ip(s), unchecked
7725          */
7726         {
7727                 .tctx   = tctx,
7728                 .line   = __location__,
7729                 .name   = _NBT_NAME("_GA_MA_DI_U", 0x00, NULL),
7730                 .wins   = {
7731                         .nb_flags       = NBT_NM_GROUP,
7732                         .mhomed         = false,
7733                         .num_ips        = ctx->addresses_best_num,
7734                         .ips            = ctx->addresses_best,
7735                         .apply_expected = true
7736                 },
7737                 .defend = {
7738                         .timeout        = 0,
7739                 },
7740                 .replica= {
7741                         .type           = WREPL_TYPE_MHOMED,
7742                         .state          = WREPL_STATE_ACTIVE,
7743                         .node           = WREPL_NODE_B,
7744                         .is_static      = false,
7745                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
7746                         .ips            = addresses_B_3_4,
7747                         .apply_expected = false
7748                 },
7749         },
7750         /*
7751          * group,active vs. mhomed,tombstone with same ip(s), unchecked
7752          */
7753         {
7754                 .tctx   = tctx,
7755                 .line   = __location__,
7756                 .name   = _NBT_NAME("_GA_MT_SI_U", 0x00, NULL),
7757                 .wins   = {
7758                         .nb_flags       = NBT_NM_GROUP,
7759                         .mhomed         = false,
7760                         .num_ips        = ctx->addresses_best_num,
7761                         .ips            = ctx->addresses_best,
7762                         .apply_expected = true
7763                 },
7764                 .defend = {
7765                         .timeout        = 0,
7766                 },
7767                 .replica= {
7768                         .type           = WREPL_TYPE_MHOMED,
7769                         .state          = WREPL_STATE_TOMBSTONE,
7770                         .node           = WREPL_NODE_B,
7771                         .is_static      = false,
7772                         .num_ips        = ctx->addresses_best_num,
7773                         .ips            = ctx->addresses_best,
7774                         .apply_expected = false
7775                 },
7776         },
7777         /*
7778          * group,active vs. mhomed,tombstone with different ip(s), unchecked
7779          */
7780         {
7781                 .tctx   = tctx,
7782                 .line   = __location__,
7783                 .name   = _NBT_NAME("_GA_MT_DI_U", 0x00, NULL),
7784                 .wins   = {
7785                         .nb_flags       = NBT_NM_GROUP,
7786                         .mhomed         = false,
7787                         .num_ips        = ctx->addresses_best_num,
7788                         .ips            = ctx->addresses_best,
7789                         .apply_expected = true
7790                 },
7791                 .defend = {
7792                         .timeout        = 0,
7793                 },
7794                 .replica= {
7795                         .type           = WREPL_TYPE_MHOMED,
7796                         .state          = WREPL_STATE_TOMBSTONE,
7797                         .node           = WREPL_NODE_B,
7798                         .is_static      = false,
7799                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
7800                         .ips            = addresses_B_3_4,
7801                         .apply_expected = false
7802                 },
7803         },
7804 /*
7805  * special group vs. unique section
7806  */
7807         /*
7808          * sgroup,active vs. unique,active with same ip(s), unchecked
7809          */
7810         {
7811                 .tctx   = tctx,
7812                 .line   = __location__,
7813                 .name   = _NBT_NAME("_SA_UA_SI_U", 0x1C, NULL),
7814                 .wins   = {
7815                         .nb_flags       = NBT_NM_GROUP,
7816                         .mhomed         = false,
7817                         .num_ips        = ctx->addresses_best_num,
7818                         .ips            = ctx->addresses_best,
7819                         .apply_expected = true
7820                 },
7821                 .defend = {
7822                         .timeout        = 0,
7823                 },
7824                 .replica= {
7825                         .type           = WREPL_TYPE_UNIQUE,
7826                         .state          = WREPL_STATE_ACTIVE,
7827                         .node           = WREPL_NODE_B,
7828                         .is_static      = false,
7829                         .num_ips        = ctx->addresses_best_num,
7830                         .ips            = ctx->addresses_best,
7831                         .apply_expected = false
7832                 },
7833         },
7834         /*
7835          * sgroup,active vs. unique,active with different ip(s), unchecked
7836          */
7837         {
7838                 .tctx   = tctx,
7839                 .line   = __location__,
7840                 .name   = _NBT_NAME("_SA_UA_DI_U", 0x1C, NULL),
7841                 .wins   = {
7842                         .nb_flags       = NBT_NM_GROUP,
7843                         .mhomed         = false,
7844                         .num_ips        = ctx->addresses_best_num,
7845                         .ips            = ctx->addresses_best,
7846                         .apply_expected = true
7847                 },
7848                 .defend = {
7849                         .timeout        = 0,
7850                 },
7851                 .replica= {
7852                         .type           = WREPL_TYPE_UNIQUE,
7853                         .state          = WREPL_STATE_ACTIVE,
7854                         .node           = WREPL_NODE_B,
7855                         .is_static      = false,
7856                         .num_ips        = ARRAY_SIZE(addresses_B_1),
7857                         .ips            = addresses_B_1,
7858                         .apply_expected = false
7859                 },
7860         },
7861         /*
7862          * sgroup,active vs. unique,tombstone with same ip(s), unchecked
7863          */
7864         {
7865                 .tctx   = tctx,
7866                 .line   = __location__,
7867                 .name   = _NBT_NAME("_SA_UT_SI_U", 0x1C, NULL),
7868                 .wins   = {
7869                         .nb_flags       = NBT_NM_GROUP,
7870                         .mhomed         = false,
7871                         .num_ips        = ctx->addresses_best_num,
7872                         .ips            = ctx->addresses_best,
7873                         .apply_expected = true
7874                 },
7875                 .defend = {
7876                         .timeout        = 0,
7877                 },
7878                 .replica= {
7879                         .type           = WREPL_TYPE_UNIQUE,
7880                         .state          = WREPL_STATE_TOMBSTONE,
7881                         .node           = WREPL_NODE_B,
7882                         .is_static      = false,
7883                         .num_ips        = ctx->addresses_best_num,
7884                         .ips            = ctx->addresses_best,
7885                         .apply_expected = false
7886                 },
7887         },
7888         /*
7889          * sgroup,active vs. unique,tombstone with different ip(s), unchecked
7890          */
7891         {
7892                 .tctx   = tctx,
7893                 .line   = __location__,
7894                 .name   = _NBT_NAME("_SA_UT_DI_U", 0x1C, NULL),
7895                 .wins   = {
7896                         .nb_flags       = NBT_NM_GROUP,
7897                         .mhomed         = false,
7898                         .num_ips        = ctx->addresses_best_num,
7899                         .ips            = ctx->addresses_best,
7900                         .apply_expected = true
7901                 },
7902                 .defend = {
7903                         .timeout        = 0,
7904                 },
7905                 .replica= {
7906                         .type           = WREPL_TYPE_UNIQUE,
7907                         .state          = WREPL_STATE_TOMBSTONE,
7908                         .node           = WREPL_NODE_B,
7909                         .is_static      = false,
7910                         .num_ips        = ARRAY_SIZE(addresses_B_1),
7911                         .ips            = addresses_B_1,
7912                         .apply_expected = false
7913                 },
7914         },
7915 /*
7916  * special group vs. normal group section
7917  */
7918         /*
7919          * sgroup,active vs. group,active with same ip(s), unchecked
7920          */
7921         {
7922                 .tctx   = tctx,
7923                 .line   = __location__,
7924                 .name   = _NBT_NAME("_SA_GA_SI_U", 0x1C, NULL),
7925                 .wins   = {
7926                         .nb_flags       = NBT_NM_GROUP,
7927                         .mhomed         = false,
7928                         .num_ips        = ctx->addresses_best_num,
7929                         .ips            = ctx->addresses_best,
7930                         .apply_expected = true
7931                 },
7932                 .defend = {
7933                         .timeout        = 0,
7934                 },
7935                 .replica= {
7936                         .type           = WREPL_TYPE_GROUP,
7937                         .state          = WREPL_STATE_ACTIVE,
7938                         .node           = WREPL_NODE_B,
7939                         .is_static      = false,
7940                         .num_ips        = ctx->addresses_best_num,
7941                         .ips            = ctx->addresses_best,
7942                         .apply_expected = false
7943                 },
7944         },
7945         /*
7946          * sgroup,active vs. group,active with different ip(s), unchecked
7947          */
7948         {
7949                 .tctx   = tctx,
7950                 .line   = __location__,
7951                 .name   = _NBT_NAME("_SA_GA_DI_U", 0x1C, NULL),
7952                 .wins   = {
7953                         .nb_flags       = NBT_NM_GROUP,
7954                         .mhomed         = false,
7955                         .num_ips        = ctx->addresses_best_num,
7956                         .ips            = ctx->addresses_best,
7957                         .apply_expected = true
7958                 },
7959                 .defend = {
7960                         .timeout        = 0,
7961                 },
7962                 .replica= {
7963                         .type           = WREPL_TYPE_GROUP,
7964                         .state          = WREPL_STATE_ACTIVE,
7965                         .node           = WREPL_NODE_B,
7966                         .is_static      = false,
7967                         .num_ips        = ARRAY_SIZE(addresses_B_1),
7968                         .ips            = addresses_B_1,
7969                         .apply_expected = false
7970                 },
7971         },
7972         /*
7973          * sgroup,active vs. group,tombstone with same ip(s), unchecked
7974          */
7975         {
7976                 .tctx   = tctx,
7977                 .line   = __location__,
7978                 .name   = _NBT_NAME("_SA_GT_SI_U", 0x1C, NULL),
7979                 .wins   = {
7980                         .nb_flags       = NBT_NM_GROUP,
7981                         .mhomed         = false,
7982                         .num_ips        = ctx->addresses_best_num,
7983                         .ips            = ctx->addresses_best,
7984                         .apply_expected = true
7985                 },
7986                 .defend = {
7987                         .timeout        = 0,
7988                 },
7989                 .replica= {
7990                         .type           = WREPL_TYPE_GROUP,
7991                         .state          = WREPL_STATE_TOMBSTONE,
7992                         .node           = WREPL_NODE_B,
7993                         .is_static      = false,
7994                         .num_ips        = ctx->addresses_best_num,
7995                         .ips            = ctx->addresses_best,
7996                         .apply_expected = false
7997                 },
7998         },
7999         /*
8000          * sgroup,active vs. group,tombstone with different ip(s), unchecked
8001          */
8002         {
8003                 .tctx   = tctx,
8004                 .line   = __location__,
8005                 .name   = _NBT_NAME("_SA_GT_DI_U", 0x1C, NULL),
8006                 .wins   = {
8007                         .nb_flags       = NBT_NM_GROUP,
8008                         .mhomed         = false,
8009                         .num_ips        = ctx->addresses_best_num,
8010                         .ips            = ctx->addresses_best,
8011                         .apply_expected = true
8012                 },
8013                 .defend = {
8014                         .timeout        = 0,
8015                 },
8016                 .replica= {
8017                         .type           = WREPL_TYPE_GROUP,
8018                         .state          = WREPL_STATE_TOMBSTONE,
8019                         .node           = WREPL_NODE_B,
8020                         .is_static      = false,
8021                         .num_ips        = ARRAY_SIZE(addresses_B_1),
8022                         .ips            = addresses_B_1,
8023                         .apply_expected = false
8024                 },
8025         },
8026 /*
8027  * special group vs. multi homed section
8028  */
8029         /*
8030          * sgroup,active vs. mhomed,active with same ip(s), unchecked
8031          */
8032         {
8033                 .tctx   = tctx,
8034                 .line   = __location__,
8035                 .name   = _NBT_NAME("_SA_MA_SI_U", 0x1C, NULL),
8036                 .wins   = {
8037                         .nb_flags       = NBT_NM_GROUP,
8038                         .mhomed         = false,
8039                         .num_ips        = ctx->addresses_best_num,
8040                         .ips            = ctx->addresses_best,
8041                         .apply_expected = true
8042                 },
8043                 .defend = {
8044                         .timeout        = 0,
8045                 },
8046                 .replica= {
8047                         .type           = WREPL_TYPE_MHOMED,
8048                         .state          = WREPL_STATE_ACTIVE,
8049                         .node           = WREPL_NODE_B,
8050                         .is_static      = false,
8051                         .num_ips        = ctx->addresses_best_num,
8052                         .ips            = ctx->addresses_best,
8053                         .apply_expected = false
8054                 },
8055         },
8056         /*
8057          * sgroup,active vs. mhomed,active with different ip(s), unchecked
8058          */
8059         {
8060                 .tctx   = tctx,
8061                 .line   = __location__,
8062                 .name   = _NBT_NAME("_SA_MA_DI_U", 0x1C, NULL),
8063                 .wins   = {
8064                         .nb_flags       = NBT_NM_GROUP,
8065                         .mhomed         = false,
8066                         .num_ips        = ctx->addresses_best_num,
8067                         .ips            = ctx->addresses_best,
8068                         .apply_expected = true
8069                 },
8070                 .defend = {
8071                         .timeout        = 0,
8072                 },
8073                 .replica= {
8074                         .type           = WREPL_TYPE_MHOMED,
8075                         .state          = WREPL_STATE_ACTIVE,
8076                         .node           = WREPL_NODE_B,
8077                         .is_static      = false,
8078                         .num_ips        = ARRAY_SIZE(addresses_B_1),
8079                         .ips            = addresses_B_1,
8080                         .apply_expected = false
8081                 },
8082         },
8083         /*
8084          * sgroup,active vs. mhomed,tombstone with same ip(s), unchecked
8085          */
8086         {
8087                 .tctx   = tctx,
8088                 .line   = __location__,
8089                 .name   = _NBT_NAME("_SA_MT_SI_U", 0x1C, NULL),
8090                 .wins   = {
8091                         .nb_flags       = NBT_NM_GROUP,
8092                         .mhomed         = false,
8093                         .num_ips        = ctx->addresses_best_num,
8094                         .ips            = ctx->addresses_best,
8095                         .apply_expected = true
8096                 },
8097                 .defend = {
8098                         .timeout        = 0,
8099                 },
8100                 .replica= {
8101                         .type           = WREPL_TYPE_MHOMED,
8102                         .state          = WREPL_STATE_TOMBSTONE,
8103                         .node           = WREPL_NODE_B,
8104                         .is_static      = false,
8105                         .num_ips        = ctx->addresses_best_num,
8106                         .ips            = ctx->addresses_best,
8107                         .apply_expected = false
8108                 },
8109         },
8110         /*
8111          * sgroup,active vs. mhomed,tombstone with different ip(s), unchecked
8112          */
8113         {
8114                 .tctx   = tctx,
8115                 .line   = __location__,
8116                 .name   = _NBT_NAME("_SA_MT_DI_U", 0x1C, NULL),
8117                 .wins   = {
8118                         .nb_flags       = NBT_NM_GROUP,
8119                         .mhomed         = false,
8120                         .num_ips        = ctx->addresses_best_num,
8121                         .ips            = ctx->addresses_best,
8122                         .apply_expected = true
8123                 },
8124                 .defend = {
8125                         .timeout        = 0,
8126                 },
8127                 .replica= {
8128                         .type           = WREPL_TYPE_MHOMED,
8129                         .state          = WREPL_STATE_TOMBSTONE,
8130                         .node           = WREPL_NODE_B,
8131                         .is_static      = false,
8132                         .num_ips        = ARRAY_SIZE(addresses_B_1),
8133                         .ips            = addresses_B_1,
8134                         .apply_expected = false
8135                 },
8136         },
8137 /*
8138  * multi homed vs. unique section
8139  */
8140         /*
8141          * mhomed,active vs. unique,active with same ip(s), unchecked
8142          */
8143         {
8144                 .tctx   = tctx,
8145                 .line   = __location__,
8146                 .name   = _NBT_NAME("_MA_UA_SI_U", 0x00, NULL),
8147                 .wins   = {
8148                         .nb_flags       = 0,
8149                         .mhomed         = true,
8150                         .num_ips        = ctx->addresses_best_num,
8151                         .ips            = ctx->addresses_best,
8152                         .apply_expected = true
8153                 },
8154                 .defend = {
8155                         .timeout        = 0,
8156                 },
8157                 .replica= {
8158                         .type           = WREPL_TYPE_UNIQUE,
8159                         .state          = WREPL_STATE_ACTIVE,
8160                         .node           = WREPL_NODE_B,
8161                         .is_static      = false,
8162                         .num_ips        = ctx->addresses_best_num,
8163                         .ips            = ctx->addresses_best,
8164                         .apply_expected = true
8165                 },
8166         },
8167         /*
8168          * mhomed,active vs. unique,active with different ip(s), positive response
8169          */
8170         {
8171                 .tctx   = tctx,
8172                 .line   = __location__,
8173                 .name   = _NBT_NAME("_MA_UA_DI_P", 0x00, NULL),
8174                 .wins   = {
8175                         .nb_flags       = 0,
8176                         .mhomed         = true,
8177                         .num_ips        = ctx->addresses_best_num,
8178                         .ips            = ctx->addresses_best,
8179                         .apply_expected = true
8180                 },
8181                 .defend = {
8182                         .timeout        = 10,
8183                         .positive       = true,
8184                 },
8185                 .replica= {
8186                         .type           = WREPL_TYPE_UNIQUE,
8187                         .state          = WREPL_STATE_ACTIVE,
8188                         .node           = WREPL_NODE_B,
8189                         .is_static      = false,
8190                         .num_ips        = ARRAY_SIZE(addresses_B_1),
8191                         .ips            = addresses_B_1,
8192                         .apply_expected = false
8193                 },
8194         },
8195         /*
8196          * mhomed,active vs. unique,active with different ip(s), positive response other ips
8197          */
8198         {
8199                 .tctx   = tctx,
8200                 .line   = __location__,
8201                 .name   = _NBT_NAME("_MA_UA_DI_O", 0x00, NULL),
8202                 .wins   = {
8203                         .nb_flags       = 0,
8204                         .mhomed         = true,
8205                         .num_ips        = ctx->addresses_best_num,
8206                         .ips            = ctx->addresses_best,
8207                         .apply_expected = true
8208                 },
8209                 .defend = {
8210                         .timeout        = 10,
8211                         .positive       = true,
8212                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
8213                         .ips            = addresses_A_3_4,
8214                 },
8215                 .replica= {
8216                         .type           = WREPL_TYPE_UNIQUE,
8217                         .state          = WREPL_STATE_ACTIVE,
8218                         .node           = WREPL_NODE_B,
8219                         .is_static      = false,
8220                         .num_ips        = ARRAY_SIZE(addresses_B_1),
8221                         .ips            = addresses_B_1,
8222                         .apply_expected = false
8223                 },
8224         },
8225         /*
8226          * mhomed,active vs. unique,active with different ip(s), negative response
8227          */
8228         {
8229                 .tctx   = tctx,
8230                 .line   = __location__,
8231                 .name   = _NBT_NAME("_MA_UA_DI_N", 0x00, NULL),
8232                 .wins   = {
8233                         .nb_flags       = 0,
8234                         .mhomed         = true,
8235                         .num_ips        = ctx->addresses_best_num,
8236                         .ips            = ctx->addresses_best,
8237                         .apply_expected = true
8238                 },
8239                 .defend = {
8240                         .timeout        = 10,
8241                         .positive       = false,
8242                 },
8243                 .replica= {
8244                         .type           = WREPL_TYPE_UNIQUE,
8245                         .state          = WREPL_STATE_ACTIVE,
8246                         .node           = WREPL_NODE_B,
8247                         .is_static      = false,
8248                         .num_ips        = ARRAY_SIZE(addresses_B_1),
8249                         .ips            = addresses_B_1,
8250                         .apply_expected = true
8251                 },
8252         },
8253         /*
8254          * mhomed,active vs. unique,tombstone with same ip(s), unchecked
8255          */
8256         {
8257                 .tctx   = tctx,
8258                 .line   = __location__,
8259                 .name   = _NBT_NAME("_MA_UT_SI_U", 0x00, NULL),
8260                 .wins   = {
8261                         .nb_flags       = 0,
8262                         .mhomed         = true,
8263                         .num_ips        = ctx->addresses_best_num,
8264                         .ips            = ctx->addresses_best,
8265                         .apply_expected = true
8266                 },
8267                 .defend = {
8268                         .timeout        = 0,
8269                 },
8270                 .replica= {
8271                         .type           = WREPL_TYPE_UNIQUE,
8272                         .state          = WREPL_STATE_TOMBSTONE,
8273                         .node           = WREPL_NODE_B,
8274                         .is_static      = false,
8275                         .num_ips        = ctx->addresses_best_num,
8276                         .ips            = ctx->addresses_best,
8277                         .apply_expected = false
8278                 },
8279         },
8280         /*
8281          * mhomed,active vs. unique,tombstone with different ip(s), unchecked
8282          */
8283         {
8284                 .tctx   = tctx,
8285                 .line   = __location__,
8286                 .name   = _NBT_NAME("_MA_UT_DI_U", 0x00, NULL),
8287                 .wins   = {
8288                         .nb_flags       = 0,
8289                         .mhomed         = true,
8290                         .num_ips        = ctx->addresses_best_num,
8291                         .ips            = ctx->addresses_best,
8292                         .apply_expected = true
8293                 },
8294                 .defend = {
8295                         .timeout        = 0,
8296                 },
8297                 .replica= {
8298                         .type           = WREPL_TYPE_UNIQUE,
8299                         .state          = WREPL_STATE_TOMBSTONE,
8300                         .node           = WREPL_NODE_B,
8301                         .is_static      = false,
8302                         .num_ips        = ARRAY_SIZE(addresses_B_1),
8303                         .ips            = addresses_B_1,
8304                         .apply_expected = false
8305                 },
8306         },
8307 /*
8308  * multi homed vs. normal group section
8309  */
8310         /*
8311          * mhomed,active vs. group,active with same ip(s), release expected
8312          */
8313         {
8314                 .tctx   = tctx,
8315                 .line   = __location__,
8316                 .name   = _NBT_NAME("_MA_GA_SI_R", 0x00, NULL),
8317                 .wins   = {
8318                         .nb_flags       = 0,
8319                         .mhomed         = true,
8320                         .num_ips        = ctx->addresses_best_num,
8321                         .ips            = ctx->addresses_best,
8322                         .apply_expected = true
8323                 },
8324                 .defend = {
8325                         .timeout        = 10,
8326                         .expect_release = true,
8327                 },
8328                 .replica= {
8329                         .type           = WREPL_TYPE_GROUP,
8330                         .state          = WREPL_STATE_ACTIVE,
8331                         .node           = WREPL_NODE_B,
8332                         .is_static      = false,
8333                         .num_ips        = ctx->addresses_best_num,
8334                         .ips            = ctx->addresses_best,
8335                         .apply_expected = true
8336                 },
8337         },
8338         /*
8339          * mhomed,active vs. group,active with different ip(s), release expected
8340          */
8341         {
8342                 .tctx   = tctx,
8343                 .line   = __location__,
8344                 .name   = _NBT_NAME("_MA_GA_DI_R", 0x00, NULL),
8345                 .wins   = {
8346                         .nb_flags       = 0,
8347                         .mhomed         = true,
8348                         .num_ips        = ctx->addresses_best_num,
8349                         .ips            = ctx->addresses_best,
8350                         .apply_expected = true
8351                 },
8352                 .defend = {
8353                         .timeout        = 10,
8354                         .expect_release = true,
8355                 },
8356                 .replica= {
8357                         .type           = WREPL_TYPE_GROUP,
8358                         .state          = WREPL_STATE_ACTIVE,
8359                         .node           = WREPL_NODE_B,
8360                         .is_static      = false,
8361                         .num_ips        = ARRAY_SIZE(addresses_B_1),
8362                         .ips            = addresses_B_1,
8363                         .apply_expected = true
8364                 },
8365         },
8366         /*
8367          * mhomed,active vs. group,tombstone with same ip(s), unchecked
8368          */
8369         {
8370                 .tctx   = tctx,
8371                 .line   = __location__,
8372                 .name   = _NBT_NAME("_MA_GT_SI_U", 0x00, NULL),
8373                 .wins   = {
8374                         .nb_flags       = 0,
8375                         .mhomed         = true,
8376                         .num_ips        = ctx->addresses_best_num,
8377                         .ips            = ctx->addresses_best,
8378                         .apply_expected = true
8379                 },
8380                 .defend = {
8381                         .timeout        = 0,
8382                 },
8383                 .replica= {
8384                         .type           = WREPL_TYPE_GROUP,
8385                         .state          = WREPL_STATE_TOMBSTONE,
8386                         .node           = WREPL_NODE_B,
8387                         .is_static      = false,
8388                         .num_ips        = ctx->addresses_best_num,
8389                         .ips            = ctx->addresses_best,
8390                         .apply_expected = false
8391                 },
8392         },
8393         /*
8394          * mhomed,active vs. group,tombstone with different ip(s), unchecked
8395          */
8396         {
8397                 .tctx   = tctx,
8398                 .line   = __location__,
8399                 .name   = _NBT_NAME("_MA_GT_DI_U", 0x00, NULL),
8400                 .wins   = {
8401                         .nb_flags       = 0,
8402                         .mhomed         = true,
8403                         .num_ips        = ctx->addresses_best_num,
8404                         .ips            = ctx->addresses_best,
8405                         .apply_expected = true
8406                 },
8407                 .defend = {
8408                         .timeout        = 0,
8409                 },
8410                 .replica= {
8411                         .type           = WREPL_TYPE_GROUP,
8412                         .state          = WREPL_STATE_TOMBSTONE,
8413                         .node           = WREPL_NODE_B,
8414                         .is_static      = false,
8415                         .num_ips        = ARRAY_SIZE(addresses_B_1),
8416                         .ips            = addresses_B_1,
8417                         .apply_expected = false
8418                 },
8419         },
8420 /*
8421  * multi homed vs. special group section
8422  */
8423         /*
8424          * mhomed,active vs. sgroup,active with same ip(s), release expected
8425          */
8426         {
8427                 .tctx   = tctx,
8428                 .line   = __location__,
8429                 .name   = _NBT_NAME("_MA_SA_SI_R", 0x00, NULL),
8430                 .wins   = {
8431                         .nb_flags       = 0,
8432                         .mhomed         = true,
8433                         .num_ips        = ctx->addresses_best_num,
8434                         .ips            = ctx->addresses_best,
8435                         .apply_expected = true
8436                 },
8437                 .defend = {
8438                         .timeout        = 10,
8439                         .expect_release = true,
8440                 },
8441                 .replica= {
8442                         .type           = WREPL_TYPE_SGROUP,
8443                         .state          = WREPL_STATE_ACTIVE,
8444                         .node           = WREPL_NODE_B,
8445                         .is_static      = false,
8446                         .num_ips        = ctx->addresses_best_num,
8447                         .ips            = ctx->addresses_best,
8448                         .apply_expected = true
8449                 },
8450         },
8451         /*
8452          * mhomed,active vs. group,active with different ip(s), release expected
8453          */
8454         {
8455                 .tctx   = tctx,
8456                 .line   = __location__,
8457                 .name   = _NBT_NAME("_MA_SA_DI_R", 0x00, NULL),
8458                 .wins   = {
8459                         .nb_flags       = 0,
8460                         .mhomed         = true,
8461                         .num_ips        = ctx->addresses_best_num,
8462                         .ips            = ctx->addresses_best,
8463                         .apply_expected = true
8464                 },
8465                 .defend = {
8466                         .timeout        = 10,
8467                         .expect_release = true,
8468                 },
8469                 .replica= {
8470                         .type           = WREPL_TYPE_SGROUP,
8471                         .state          = WREPL_STATE_ACTIVE,
8472                         .node           = WREPL_NODE_B,
8473                         .is_static      = false,
8474                         .num_ips        = ARRAY_SIZE(addresses_B_1),
8475                         .ips            = addresses_B_1,
8476                         .apply_expected = true
8477                 },
8478         },
8479         /*
8480          * mhomed,active vs. sgroup,tombstone with same ip(s), unchecked
8481          */
8482         {
8483                 .tctx   = tctx,
8484                 .line   = __location__,
8485                 .name   = _NBT_NAME("_MA_ST_SI_U", 0x00, NULL),
8486                 .wins   = {
8487                         .nb_flags       = 0,
8488                         .mhomed         = true,
8489                         .num_ips        = ctx->addresses_best_num,
8490                         .ips            = ctx->addresses_best,
8491                         .apply_expected = true
8492                 },
8493                 .defend = {
8494                         .timeout        = 0,
8495                 },
8496                 .replica= {
8497                         .type           = WREPL_TYPE_SGROUP,
8498                         .state          = WREPL_STATE_TOMBSTONE,
8499                         .node           = WREPL_NODE_B,
8500                         .is_static      = false,
8501                         .num_ips        = ctx->addresses_best_num,
8502                         .ips            = ctx->addresses_best,
8503                         .apply_expected = false
8504                 },
8505         },
8506         /*
8507          * mhomed,active vs. sgroup,tombstone with different ip(s), unchecked
8508          */
8509         {
8510                 .tctx   = tctx,
8511                 .line   = __location__,
8512                 .name   = _NBT_NAME("_MA_ST_DI_U", 0x00, NULL),
8513                 .wins   = {
8514                         .nb_flags       = 0,
8515                         .mhomed         = true,
8516                         .num_ips        = ctx->addresses_best_num,
8517                         .ips            = ctx->addresses_best,
8518                         .apply_expected = true
8519                 },
8520                 .defend = {
8521                         .timeout        = 0,
8522                 },
8523                 .replica= {
8524                         .type           = WREPL_TYPE_SGROUP,
8525                         .state          = WREPL_STATE_TOMBSTONE,
8526                         .node           = WREPL_NODE_B,
8527                         .is_static      = false,
8528                         .num_ips        = ARRAY_SIZE(addresses_B_1),
8529                         .ips            = addresses_B_1,
8530                         .apply_expected = false
8531                 },
8532         },
8533 /*
8534  * multi homed vs. multi homed section
8535  */
8536         /*
8537          * mhomed,active vs. mhomed,active with same ip(s), unchecked
8538          */
8539         {
8540                 .tctx   = tctx,
8541                 .line   = __location__,
8542                 .name   = _NBT_NAME("_MA_MA_SI_U", 0x00, NULL),
8543                 .wins   = {
8544                         .nb_flags       = 0,
8545                         .mhomed         = true,
8546                         .num_ips        = ctx->addresses_best_num,
8547                         .ips            = ctx->addresses_best,
8548                         .apply_expected = true
8549                 },
8550                 .defend = {
8551                         .timeout        = 0,
8552                 },
8553                 .replica= {
8554                         .type           = WREPL_TYPE_MHOMED,
8555                         .state          = WREPL_STATE_ACTIVE,
8556                         .node           = WREPL_NODE_B,
8557                         .is_static      = false,
8558                         .num_ips        = ctx->addresses_best_num,
8559                         .ips            = ctx->addresses_best,
8560                         .apply_expected = true
8561                 },
8562         },
8563         /*
8564          * mhomed,active vs. mhomed,active with superset ip(s), unchecked
8565          */
8566         {
8567                 .tctx   = tctx,
8568                 .line   = __location__,
8569                 .name   = _NBT_NAME("_MA_MA_SP_U", 0x00, NULL),
8570                 .wins   = {
8571                         .nb_flags       = 0,
8572                         .mhomed         = true,
8573                         .num_ips        = ctx->addresses_best_num,
8574                         .ips            = ctx->addresses_best,
8575                         .apply_expected = true
8576                 },
8577                 .defend = {
8578                         .timeout        = 0,
8579                 },
8580                 .replica= {
8581                         .type           = WREPL_TYPE_MHOMED,
8582                         .state          = WREPL_STATE_ACTIVE,
8583                         .node           = WREPL_NODE_B,
8584                         .is_static      = false,
8585                         .num_ips        = ctx->addresses_all_num,
8586                         .ips            = ctx->addresses_all,
8587                         .apply_expected = true
8588                 },
8589         },
8590         /*
8591          * mhomed,active vs. mhomed,active with different ip(s), positive response
8592          */
8593         {
8594                 .tctx   = tctx,
8595                 .line   = __location__,
8596                 .name   = _NBT_NAME("_MA_MA_DI_P", 0x00, NULL),
8597                 .wins   = {
8598                         .nb_flags       = 0,
8599                         .mhomed         = true,
8600                         .num_ips        = ctx->addresses_best_num,
8601                         .ips            = ctx->addresses_best,
8602                         .apply_expected = true
8603                 },
8604                 .defend = {
8605                         .timeout        = 10,
8606                         .positive       = true,
8607                 },
8608                 .replica= {
8609                         .type           = WREPL_TYPE_MHOMED,
8610                         .state          = WREPL_STATE_ACTIVE,
8611                         .node           = WREPL_NODE_B,
8612                         .is_static      = false,
8613                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
8614                         .ips            = addresses_B_3_4,
8615                         .apply_expected = false
8616                 },
8617         },
8618         /*
8619          * mhomed,active vs. mhomed,active with different ip(s), positive response other ips
8620          */
8621         {
8622                 .tctx   = tctx,
8623                 .line   = __location__,
8624                 .name   = _NBT_NAME("_MA_MA_DI_O", 0x00, NULL),
8625                 .wins   = {
8626                         .nb_flags       = 0,
8627                         .mhomed         = true,
8628                         .num_ips        = ctx->addresses_best_num,
8629                         .ips            = ctx->addresses_best,
8630                         .apply_expected = true
8631                 },
8632                 .defend = {
8633                         .timeout        = 10,
8634                         .positive       = true,
8635                         .num_ips        = ARRAY_SIZE(addresses_A_3_4),
8636                         .ips            = addresses_A_3_4,
8637                 },
8638                 .replica= {
8639                         .type           = WREPL_TYPE_MHOMED,
8640                         .state          = WREPL_STATE_ACTIVE,
8641                         .node           = WREPL_NODE_B,
8642                         .is_static      = false,
8643                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
8644                         .ips            = addresses_B_3_4,
8645                         .apply_expected = false
8646                 },
8647         },
8648         /*
8649          * mhomed,active vs. mhomed,active with different ip(s), negative response
8650          */
8651         {
8652                 .tctx   = tctx,
8653                 .line   = __location__,
8654                 .name   = _NBT_NAME("_MA_MA_DI_N", 0x00, NULL),
8655                 .wins   = {
8656                         .nb_flags       = 0,
8657                         .mhomed         = true,
8658                         .num_ips        = ctx->addresses_best_num,
8659                         .ips            = ctx->addresses_best,
8660                         .apply_expected = true
8661                 },
8662                 .defend = {
8663                         .timeout        = 10,
8664                         .positive       = false,
8665                 },
8666                 .replica= {
8667                         .type           = WREPL_TYPE_MHOMED,
8668                         .state          = WREPL_STATE_ACTIVE,
8669                         .node           = WREPL_NODE_B,
8670                         .is_static      = false,
8671                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
8672                         .ips            = addresses_B_3_4,
8673                         .apply_expected = true
8674                 },
8675         },
8676         /*
8677          * mhomed,active vs. mhomed,tombstone with same ip(s), unchecked
8678          */
8679         {
8680                 .tctx   = tctx,
8681                 .line   = __location__,
8682                 .name   = _NBT_NAME("_MA_MT_SI_U", 0x00, NULL),
8683                 .wins   = {
8684                         .nb_flags       = 0,
8685                         .mhomed         = true,
8686                         .num_ips        = ctx->addresses_best_num,
8687                         .ips            = ctx->addresses_best,
8688                         .apply_expected = true
8689                 },
8690                 .defend = {
8691                         .timeout        = 0,
8692                 },
8693                 .replica= {
8694                         .type           = WREPL_TYPE_MHOMED,
8695                         .state          = WREPL_STATE_TOMBSTONE,
8696                         .node           = WREPL_NODE_B,
8697                         .is_static      = false,
8698                         .num_ips        = ctx->addresses_best_num,
8699                         .ips            = ctx->addresses_best,
8700                         .apply_expected = false
8701                 },
8702         },
8703         /*
8704          * mhomed,active vs. mhomed,tombstone with different ip(s), unchecked
8705          */
8706         {
8707                 .tctx   = tctx,
8708                 .line   = __location__,
8709                 .name   = _NBT_NAME("_MA_MT_DI_U", 0x00, NULL),
8710                 .wins   = {
8711                         .nb_flags       = 0,
8712                         .mhomed         = true,
8713                         .num_ips        = ctx->addresses_best_num,
8714                         .ips            = ctx->addresses_best,
8715                         .apply_expected = true
8716                 },
8717                 .defend = {
8718                         .timeout        = 0,
8719                 },
8720                 .replica= {
8721                         .type           = WREPL_TYPE_MHOMED,
8722                         .state          = WREPL_STATE_TOMBSTONE,
8723                         .node           = WREPL_NODE_B,
8724                         .is_static      = false,
8725                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
8726                         .ips            = addresses_B_3_4,
8727                         .apply_expected = false
8728                 },
8729         },
8730 /*
8731  * some more multi homed test, including merging
8732  */
8733         /*
8734          * mhomed,active vs. mhomed,active with superset ip(s), unchecked
8735          */
8736         {
8737                 .tctx   = tctx,
8738                 .line   = __location__,
8739                 .section= "Test Replica vs. owned active: some more MHOMED combinations",
8740                 .name   = _NBT_NAME("_MA_MA_SP_U", 0x00, NULL),
8741                 .comment= "C:MHOMED vs. B:ALL => B:ALL",
8742                 .skip   = (ctx->addresses_all_num < 3),
8743                 .wins   = {
8744                         .nb_flags       = 0,
8745                         .mhomed         = true,
8746                         .num_ips        = ctx->addresses_mhomed_num,
8747                         .ips            = ctx->addresses_mhomed,
8748                         .apply_expected = true
8749                 },
8750                 .defend = {
8751                         .timeout        = 0,
8752                 },
8753                 .replica= {
8754                         .type           = WREPL_TYPE_MHOMED,
8755                         .state          = WREPL_STATE_ACTIVE,
8756                         .node           = WREPL_NODE_B,
8757                         .is_static      = false,
8758                         .num_ips        = ctx->addresses_all_num,
8759                         .ips            = ctx->addresses_all,
8760                         .apply_expected = true
8761                 },
8762         },
8763         /*
8764          * mhomed,active vs. mhomed,active with same ips, unchecked
8765          */
8766         {
8767                 .tctx   = tctx,
8768                 .line   = __location__,
8769                 .name   = _NBT_NAME("_MA_MA_SM_U", 0x00, NULL),
8770                 .comment= "C:MHOMED vs. B:MHOMED => B:MHOMED",
8771                 .skip   = (ctx->addresses_mhomed_num < 2),
8772                 .wins   = {
8773                         .nb_flags       = 0,
8774                         .mhomed         = true,
8775                         .num_ips        = ctx->addresses_mhomed_num,
8776                         .ips            = ctx->addresses_mhomed,
8777                         .apply_expected = true
8778                 },
8779                 .defend = {
8780                         .timeout        = 0,
8781                 },
8782                 .replica= {
8783                         .type           = WREPL_TYPE_MHOMED,
8784                         .state          = WREPL_STATE_ACTIVE,
8785                         .node           = WREPL_NODE_B,
8786                         .is_static      = false,
8787                         .num_ips        = ctx->addresses_mhomed_num,
8788                         .ips            = ctx->addresses_mhomed,
8789                         .apply_expected = true
8790                 },
8791         },
8792         /*
8793          * mhomed,active vs. mhomed,active with subset ip(s), positive response
8794          */
8795         {
8796                 .tctx   = tctx,
8797                 .line   = __location__,
8798                 .name   = _NBT_NAME("_MA_MA_SB_P", 0x00, NULL),
8799                 .comment= "C:MHOMED vs. B:BEST (C:MHOMED) => B:MHOMED",
8800                 .skip   = (ctx->addresses_mhomed_num < 2),
8801                 .wins   = {
8802                         .nb_flags       = 0,
8803                         .mhomed         = true,
8804                         .num_ips        = ctx->addresses_mhomed_num,
8805                         .ips            = ctx->addresses_mhomed,
8806                         .apply_expected = true
8807                 },
8808                 .defend = {
8809                         .timeout        = 10,
8810                         .positive       = true
8811                 },
8812                 .replica= {
8813                         .type           = WREPL_TYPE_MHOMED,
8814                         .state          = WREPL_STATE_ACTIVE,
8815                         .node           = WREPL_NODE_B,
8816                         .is_static      = false,
8817                         .num_ips        = ctx->addresses_best_num,
8818                         .ips            = ctx->addresses_best,
8819                         .mhomed_merge   = true
8820                 },
8821         },
8822         /*
8823          * mhomed,active vs. mhomed,active with subset ip(s), positive response, with all addresses
8824          */
8825         {
8826                 .tctx   = tctx,
8827                 .line   = __location__,
8828                 .name   = _NBT_NAME("_MA_MA_SB_A", 0x00, NULL),
8829                 .comment= "C:MHOMED vs. B:BEST (C:ALL) => B:MHOMED",
8830                 .skip   = (ctx->addresses_all_num < 3),
8831                 .wins   = {
8832                         .nb_flags       = 0,
8833                         .mhomed         = true,
8834                         .num_ips        = ctx->addresses_mhomed_num,
8835                         .ips            = ctx->addresses_mhomed,
8836                         .apply_expected = true
8837                 },
8838                 .defend = {
8839                         .timeout        = 10,
8840                         .positive       = true,
8841                         .num_ips        = ctx->addresses_all_num,
8842                         .ips            = ctx->addresses_all,
8843                 },
8844                 .replica= {
8845                         .type           = WREPL_TYPE_MHOMED,
8846                         .state          = WREPL_STATE_ACTIVE,
8847                         .node           = WREPL_NODE_B,
8848                         .is_static      = false,
8849                         .num_ips        = ctx->addresses_best_num,
8850                         .ips            = ctx->addresses_best,
8851                         .mhomed_merge   = true
8852                 },
8853         },
8854         /*
8855          * mhomed,active vs. mhomed,active with subset ip(s), positive response, with replicas addresses
8856          * TODO: check why the server sends a name release demand for one address?
8857          *       the release demand has no effect to the database record...
8858          */
8859         {
8860                 .tctx   = tctx,
8861                 .line   = __location__,
8862                 .name   = _NBT_NAME("_MA_MA_SB_PRA", 0x00, NULL),
8863                 .comment= "C:MHOMED vs. B:BEST (C:BEST) => C:MHOMED",
8864                 .skip   = (ctx->addresses_all_num < 2),
8865                 .wins   = {
8866                         .nb_flags       = 0,
8867                         .mhomed         = true,
8868                         .num_ips        = ctx->addresses_mhomed_num,
8869                         .ips            = ctx->addresses_mhomed,
8870                         .apply_expected = true
8871                 },
8872                 .defend = {
8873                         .timeout        = 10,
8874                         .positive       = true,
8875                         .num_ips        = ctx->addresses_best_num,
8876                         .ips            = ctx->addresses_best,
8877                         .late_release   = true
8878                 },
8879                 .replica= {
8880                         .type           = WREPL_TYPE_MHOMED,
8881                         .state          = WREPL_STATE_ACTIVE,
8882                         .node           = WREPL_NODE_B,
8883                         .is_static      = false,
8884                         .num_ips        = ctx->addresses_best_num,
8885                         .ips            = ctx->addresses_best,
8886                         .apply_expected = false
8887                 },
8888         },
8889         /*
8890          * mhomed,active vs. mhomed,active with subset ip(s), positive response, with other addresses
8891          */
8892         {
8893                 .tctx   = tctx,
8894                 .line   = __location__,
8895                 .name   = _NBT_NAME("_MA_MA_SB_O", 0x00, NULL),
8896                 .comment= "C:MHOMED vs. B:BEST (B:B_3_4) =>C:MHOMED",
8897                 .skip   = (ctx->addresses_all_num < 2),
8898                 .wins   = {
8899                         .nb_flags       = 0,
8900                         .mhomed         = true,
8901                         .num_ips        = ctx->addresses_mhomed_num,
8902                         .ips            = ctx->addresses_mhomed,
8903                         .apply_expected = true
8904                 },
8905                 .defend = {
8906                         .timeout        = 10,
8907                         .positive       = true,
8908                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
8909                         .ips            = addresses_B_3_4,
8910                 },
8911                 .replica= {
8912                         .type           = WREPL_TYPE_MHOMED,
8913                         .state          = WREPL_STATE_ACTIVE,
8914                         .node           = WREPL_NODE_B,
8915                         .is_static      = false,
8916                         .num_ips        = ctx->addresses_best_num,
8917                         .ips            = ctx->addresses_best,
8918                         .apply_expected = false
8919                 },
8920         },
8921         /*
8922          * mhomed,active vs. mhomed,active with subset ip(s), negative response
8923          */
8924         {
8925                 .tctx   = tctx,
8926                 .line   = __location__,
8927                 .name   = _NBT_NAME("_MA_MA_SB_N", 0x00, NULL),
8928                 .comment= "C:MHOMED vs. B:BEST (NEGATIVE) => B:BEST",
8929                 .skip   = (ctx->addresses_mhomed_num < 2),
8930                 .wins   = {
8931                         .nb_flags       = 0,
8932                         .mhomed         = true,
8933                         .num_ips        = ctx->addresses_mhomed_num,
8934                         .ips            = ctx->addresses_mhomed,
8935                         .apply_expected = true
8936                 },
8937                 .defend = {
8938                         .timeout        = 10,
8939                         .positive       = false
8940                 },
8941                 .replica= {
8942                         .type           = WREPL_TYPE_MHOMED,
8943                         .state          = WREPL_STATE_ACTIVE,
8944                         .node           = WREPL_NODE_B,
8945                         .is_static      = false,
8946                         .num_ips        = ctx->addresses_best_num,
8947                         .ips            = ctx->addresses_best,
8948                         .apply_expected = true
8949                 },
8950         },
8951 /*
8952  * some more multi homed and unique test, including merging
8953  */
8954         /*
8955          * mhomed,active vs. unique,active with subset ip(s), positive response
8956          */
8957         {
8958                 .tctx   = tctx,
8959                 .line   = __location__,
8960                 .section= "Test Replica vs. owned active: some more UNIQUE,MHOMED combinations",
8961                 .name   = _NBT_NAME("_MA_UA_SB_P", 0x00, NULL),
8962                 .comment= "C:MHOMED vs. B:UNIQUE,BEST (C:MHOMED) => B:MHOMED",
8963                 .skip   = (ctx->addresses_all_num < 2),
8964                 .wins   = {
8965                         .nb_flags       = 0,
8966                         .mhomed         = true,
8967                         .num_ips        = ctx->addresses_mhomed_num,
8968                         .ips            = ctx->addresses_mhomed,
8969                         .apply_expected = true
8970                 },
8971                 .defend = {
8972                         .timeout        = 10,
8973                         .positive       = true,
8974                 },
8975                 .replica= {
8976                         .type           = WREPL_TYPE_UNIQUE,
8977                         .state          = WREPL_STATE_ACTIVE,
8978                         .node           = WREPL_NODE_B,
8979                         .is_static      = false,
8980                         .num_ips        = ctx->addresses_best_num,
8981                         .ips            = ctx->addresses_best,
8982                         .mhomed_merge   = true
8983                 },
8984         },
8985         /*
8986          * unique,active vs. unique,active with different ip(s), positive response, with replicas address
8987          * TODO: check why the server sends a name release demand for one address?
8988          *       the release demand has no effect to the database record...
8989          */
8990         {
8991                 .tctx   = tctx,
8992                 .line   = __location__,
8993                 .name   = _NBT_NAME("_UA_UA_DI_PRA", 0x00, NULL),
8994                 .comment= "C:BEST vs. B:BEST2 (C:BEST2,LR:BEST2) => C:BEST",
8995                 .skip   = (ctx->addresses_all_num < 2),
8996                 .wins   = {
8997                         .nb_flags       = 0,
8998                         .mhomed         = false,
8999                         .num_ips        = ctx->addresses_best_num,
9000                         .ips            = ctx->addresses_best,
9001                         .apply_expected = true
9002                 },
9003                 .defend = {
9004                         .timeout        = 10,
9005                         .positive       = true,
9006                         .num_ips        = ctx->addresses_best2_num,
9007                         .ips            = ctx->addresses_best2,
9008                         .late_release   = true
9009                 },
9010                 .replica= {
9011                         .type           = WREPL_TYPE_UNIQUE,
9012                         .state          = WREPL_STATE_ACTIVE,
9013                         .node           = WREPL_NODE_B,
9014                         .is_static      = false,
9015                         .num_ips        = ctx->addresses_best2_num,
9016                         .ips            = ctx->addresses_best2,
9017                         .apply_expected = false,
9018                 },
9019         },
9020         /*
9021          * unique,active vs. unique,active with different ip(s), positive response, with all addresses
9022          */
9023         {
9024                 .tctx   = tctx,
9025                 .line   = __location__,
9026                 .name   = _NBT_NAME("_UA_UA_DI_A", 0x00, NULL),
9027                 .comment= "C:BEST vs. B:BEST2 (C:ALL) => B:MHOMED",
9028                 .skip   = (ctx->addresses_all_num < 3),
9029                 .wins   = {
9030                         .nb_flags       = 0,
9031                         .mhomed         = false,
9032                         .num_ips        = ctx->addresses_best_num,
9033                         .ips            = ctx->addresses_best,
9034                         .apply_expected = true
9035                 },
9036                 .defend = {
9037                         .timeout        = 10,
9038                         .positive       = true,
9039                         .num_ips        = ctx->addresses_all_num,
9040                         .ips            = ctx->addresses_all,
9041                 },
9042                 .replica= {
9043                         .type           = WREPL_TYPE_UNIQUE,
9044                         .state          = WREPL_STATE_ACTIVE,
9045                         .node           = WREPL_NODE_B,
9046                         .is_static      = false,
9047                         .num_ips        = ctx->addresses_best2_num,
9048                         .ips            = ctx->addresses_best2,
9049                         .mhomed_merge   = true,
9050                 },
9051         },
9052         /*
9053          * unique,active vs. mhomed,active with different ip(s), positive response, with all addresses
9054          */
9055         {
9056                 .tctx   = tctx,
9057                 .line   = __location__,
9058                 .name   = _NBT_NAME("_UA_MA_DI_A", 0x00, NULL),
9059                 .comment= "C:BEST vs. B:BEST2 (C:ALL) => B:MHOMED",
9060                 .skip   = (ctx->addresses_all_num < 3),
9061                 .wins   = {
9062                         .nb_flags       = 0,
9063                         .mhomed         = false,
9064                         .num_ips        = ctx->addresses_best_num,
9065                         .ips            = ctx->addresses_best,
9066                         .apply_expected = true
9067                 },
9068                 .defend = {
9069                         .timeout        = 10,
9070                         .positive       = true,
9071                         .num_ips        = ctx->addresses_all_num,
9072                         .ips            = ctx->addresses_all,
9073                 },
9074                 .replica= {
9075                         .type           = WREPL_TYPE_MHOMED,
9076                         .state          = WREPL_STATE_ACTIVE,
9077                         .node           = WREPL_NODE_B,
9078                         .is_static      = false,
9079                         .num_ips        = ctx->addresses_best2_num,
9080                         .ips            = ctx->addresses_best2,
9081                         .mhomed_merge   = true,
9082                 },
9083         },
9084 /*
9085  * special group vs. special group merging section
9086  */
9087         /*
9088          * sgroup,active vs. sgroup,active with different ip(s)
9089          */
9090         {
9091                 .tctx   = tctx,
9092                 .line   = __location__,
9093                 .section= "Test Replica vs. owned active: SGROUP vs. SGROUP tests",
9094                 .name   = _NBT_NAME("_SA_SA_DI_U", 0x1C, NULL),
9095                 .skip   = (ctx->addresses_all_num < 3),
9096                 .wins   = {
9097                         .nb_flags       = NBT_NM_GROUP,
9098                         .mhomed         = false,
9099                         .num_ips        = ctx->addresses_mhomed_num,
9100                         .ips            = ctx->addresses_mhomed,
9101                         .apply_expected = true
9102                 },
9103                 .defend = {
9104                         .timeout        = 0,
9105                 },
9106                 .replica= {
9107                         .type           = WREPL_TYPE_SGROUP,
9108                         .state          = WREPL_STATE_ACTIVE,
9109                         .node           = WREPL_NODE_B,
9110                         .is_static      = false,
9111                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
9112                         .ips            = addresses_B_3_4,
9113                         .sgroup_merge   = true
9114                 },
9115         },
9116         /*
9117          * sgroup,active vs. sgroup,active with same ip(s)
9118          */
9119         {
9120                 .tctx   = tctx,
9121                 .line   = __location__,
9122                 .name   = _NBT_NAME("_SA_SA_SI_U", 0x1C, NULL),
9123                 .skip   = (ctx->addresses_all_num < 3),
9124                 .wins   = {
9125                         .nb_flags       = NBT_NM_GROUP,
9126                         .mhomed         = false,
9127                         .num_ips        = ctx->addresses_mhomed_num,
9128                         .ips            = ctx->addresses_mhomed,
9129                         .apply_expected = true
9130                 },
9131                 .defend = {
9132                         .timeout        = 0,
9133                 },
9134                 .replica= {
9135                         .type           = WREPL_TYPE_SGROUP,
9136                         .state          = WREPL_STATE_ACTIVE,
9137                         .node           = WREPL_NODE_B,
9138                         .is_static      = false,
9139                         .num_ips        = ctx->addresses_mhomed_num,
9140                         .ips            = ctx->addresses_mhomed,
9141                         .sgroup_merge   = true
9142                 },
9143         },
9144         /*
9145          * sgroup,active vs. sgroup,active with superset ip(s)
9146          */
9147         {
9148                 .tctx   = tctx,
9149                 .line   = __location__,
9150                 .name   = _NBT_NAME("_SA_SA_SP_U", 0x1C, NULL),
9151                 .skip   = (ctx->addresses_all_num < 3),
9152                 .wins   = {
9153                         .nb_flags       = NBT_NM_GROUP,
9154                         .mhomed         = false,
9155                         .num_ips        = ctx->addresses_mhomed_num,
9156                         .ips            = ctx->addresses_mhomed,
9157                         .apply_expected = true
9158                 },
9159                 .defend = {
9160                         .timeout        = 0,
9161                 },
9162                 .replica= {
9163                         .type           = WREPL_TYPE_SGROUP,
9164                         .state          = WREPL_STATE_ACTIVE,
9165                         .node           = WREPL_NODE_B,
9166                         .is_static      = false,
9167                         .num_ips        = ctx->addresses_all_num,
9168                         .ips            = ctx->addresses_all,
9169                         .sgroup_merge   = true
9170                 },
9171         },
9172         /*
9173          * sgroup,active vs. sgroup,active with subset ip(s)
9174          */
9175         {
9176                 .tctx   = tctx,
9177                 .line   = __location__,
9178                 .name   = _NBT_NAME("_SA_SA_SB_U", 0x1C, NULL),
9179                 .skip   = (ctx->addresses_all_num < 3),
9180                 .wins   = {
9181                         .nb_flags       = NBT_NM_GROUP,
9182                         .mhomed         = false,
9183                         .num_ips        = ctx->addresses_mhomed_num,
9184                         .ips            = ctx->addresses_mhomed,
9185                         .apply_expected = true
9186                 },
9187                 .defend = {
9188                         .timeout        = 0,
9189                 },
9190                 .replica= {
9191                         .type           = WREPL_TYPE_SGROUP,
9192                         .state          = WREPL_STATE_ACTIVE,
9193                         .node           = WREPL_NODE_B,
9194                         .is_static      = false,
9195                         .num_ips        = ctx->addresses_best_num,
9196                         .ips            = ctx->addresses_best,
9197                         .sgroup_merge   = true
9198                 },
9199         },
9200         /*
9201          * sgroup,active vs. sgroup,tombstone with different ip(s)
9202          */
9203         {
9204                 .tctx   = tctx,
9205                 .line   = __location__,
9206                 .name   = _NBT_NAME("_SA_ST_DI_U", 0x1C, NULL),
9207                 .skip   = (ctx->addresses_all_num < 3),
9208                 .wins   = {
9209                         .nb_flags       = NBT_NM_GROUP,
9210                         .mhomed         = false,
9211                         .num_ips        = ctx->addresses_mhomed_num,
9212                         .ips            = ctx->addresses_mhomed,
9213                         .apply_expected = true
9214                 },
9215                 .defend = {
9216                         .timeout        = 0,
9217                 },
9218                 .replica= {
9219                         .type           = WREPL_TYPE_SGROUP,
9220                         .state          = WREPL_STATE_TOMBSTONE,
9221                         .node           = WREPL_NODE_B,
9222                         .is_static      = false,
9223                         .num_ips        = ARRAY_SIZE(addresses_B_3_4),
9224                         .ips            = addresses_B_3_4,
9225                         .apply_expected = false
9226                 },
9227         },
9228         /*
9229          * sgroup,active vs. sgroup,tombstone with same ip(s)
9230          */
9231         {
9232                 .tctx   = tctx,
9233                 .line   = __location__,
9234                 .name   = _NBT_NAME("_SA_ST_SI_U", 0x1C, NULL),
9235                 .skip   = (ctx->addresses_all_num < 3),
9236                 .wins   = {
9237                         .nb_flags       = NBT_NM_GROUP,
9238                         .mhomed         = false,
9239                         .num_ips        = ctx->addresses_mhomed_num,
9240                         .ips            = ctx->addresses_mhomed,
9241                         .apply_expected = true
9242                 },
9243                 .defend = {
9244                         .timeout        = 0,
9245                 },
9246                 .replica= {
9247                         .type           = WREPL_TYPE_SGROUP,
9248                         .state          = WREPL_STATE_TOMBSTONE,
9249                         .node           = WREPL_NODE_B,
9250                         .is_static      = false,
9251                         .num_ips        = ctx->addresses_mhomed_num,
9252                         .ips            = ctx->addresses_mhomed,
9253                         .apply_expected = false
9254                 },
9255         },
9256         /*
9257          * sgroup,active vs. sgroup,tombstone with superset ip(s)
9258          */
9259         {
9260                 .tctx   = tctx,
9261                 .line   = __location__,
9262                 .name   = _NBT_NAME("_SA_ST_SP_U", 0x1C, NULL),
9263                 .skip   = (ctx->addresses_all_num < 3),
9264                 .wins   = {
9265                         .nb_flags       = NBT_NM_GROUP,
9266                         .mhomed         = false,
9267                         .num_ips        = ctx->addresses_mhomed_num,
9268                         .ips            = ctx->addresses_mhomed,
9269                         .apply_expected = true
9270                 },
9271                 .defend = {
9272                         .timeout        = 0,
9273                 },
9274                 .replica= {
9275                         .type           = WREPL_TYPE_SGROUP,
9276                         .state          = WREPL_STATE_TOMBSTONE,
9277                         .node           = WREPL_NODE_B,
9278                         .is_static      = false,
9279                         .num_ips        = ctx->addresses_all_num,
9280                         .ips            = ctx->addresses_all,
9281                         .apply_expected = false
9282                 },
9283         },
9284         /*
9285          * sgroup,active vs. sgroup,tombstone with subset ip(s)
9286          */
9287         {
9288                 .tctx   = tctx,
9289                 .line   = __location__,
9290                 .name   = _NBT_NAME("_SA_ST_SB_U", 0x1C, NULL),
9291                 .skip   = (ctx->addresses_all_num < 3),
9292                 .wins   = {
9293                         .nb_flags       = NBT_NM_GROUP,
9294                         .mhomed         = false,
9295                         .num_ips        = ctx->addresses_mhomed_num,
9296                         .ips            = ctx->addresses_mhomed,
9297                         .apply_expected = true
9298                 },
9299                 .defend = {
9300                         .timeout        = 0,
9301                 },
9302                 .replica= {
9303                         .type           = WREPL_TYPE_SGROUP,
9304                         .state          = WREPL_STATE_TOMBSTONE,
9305                         .node           = WREPL_NODE_B,
9306                         .is_static      = false,
9307                         .num_ips        = ctx->addresses_best_num,
9308                         .ips            = ctx->addresses_best,
9309                         .apply_expected = false
9310                 },
9311         },
9312         };
9313
9314         if (!ctx->nbtsock_srv) {
9315                 torture_comment(tctx, "SKIP: Test Replica records vs. owned active records: not bound to port[%d]\n",
9316                         lpcfg_nbt_port(tctx->lp_ctx));
9317                 return true;
9318         }
9319
9320         torture_comment(tctx, "Test Replica records vs. owned active records\n");
9321
9322         for(i=0; ret && i < ARRAY_SIZE(records); i++) {
9323                 struct timeval end;
9324                 struct test_conflict_owned_active_vs_replica_struct record = records[i];
9325                 uint32_t j, count = 1;
9326                 const char *action;
9327
9328                 if (records[i].wins.mhomed || records[i].name.type == 0x1C) {
9329                         count = records[i].wins.num_ips;
9330                 }
9331
9332                 if (records[i].section) {
9333                         torture_comment(tctx, "%s\n", records[i].section);
9334                 }
9335
9336                 if (records[i].skip) {
9337                         torture_comment(tctx, "%s => SKIPPED\n", nbt_name_string(ctx, &records[i].name));
9338                         continue;
9339                 }
9340
9341                 if (records[i].replica.mhomed_merge) {
9342                         action = "MHOMED_MERGE";
9343                 } else if (records[i].replica.sgroup_merge) {
9344                         action = "SGROUP_MERGE";
9345                 } else if (records[i].replica.apply_expected) {
9346                         action = "REPLACE";
9347                 } else {
9348                         action = "NOT REPLACE";
9349                 }
9350
9351                 torture_comment(tctx, "%s%s%s => %s\n",
9352                         nbt_name_string(ctx, &records[i].name),
9353                         (records[i].comment?": ":""),
9354                         (records[i].comment?records[i].comment:""),
9355                         action);
9356
9357                 /* Prepare for multi homed registration */
9358                 ZERO_STRUCT(records[i].defend);
9359                 records[i].defend.timeout       = 10;
9360                 records[i].defend.positive      = true;
9361                 nbt_set_incoming_handler(ctx->nbtsock_srv,
9362                                          test_conflict_owned_active_vs_replica_handler,
9363                                          &records[i]);
9364                 if (ctx->nbtsock_srv2) {
9365                         nbt_set_incoming_handler(ctx->nbtsock_srv2,
9366                                                  test_conflict_owned_active_vs_replica_handler,
9367                                                  &records[i]);
9368                 }
9369
9370                 /*
9371                  * Setup Register
9372                  */
9373                 for (j=0; j < count; j++) {
9374                         struct nbt_name_request *req;
9375
9376                         name_register->in.name          = records[i].name;
9377                         name_register->in.dest_addr     = ctx->address;
9378                         name_register->in.dest_port     = lpcfg_nbt_port(tctx->lp_ctx);
9379                         name_register->in.address       = records[i].wins.ips[j].ip;
9380                         name_register->in.nb_flags      = records[i].wins.nb_flags;
9381                         name_register->in.register_demand= false;
9382                         name_register->in.broadcast     = false;
9383                         name_register->in.multi_homed   = records[i].wins.mhomed;
9384                         name_register->in.ttl           = 300000;
9385                         name_register->in.timeout       = 70;
9386                         name_register->in.retries       = 0;
9387
9388                         req = nbt_name_register_send(ctx->nbtsock, name_register);
9389
9390                         /* push the request on the wire */
9391                         tevent_loop_once(ctx->nbtsock->event_ctx);
9392
9393                         /*
9394                          * if we register multiple addresses,
9395                          * the server will do name queries to see if the old addresses
9396                          * are still alive
9397                          */
9398                         if (records[i].wins.mhomed && j > 0) {
9399                                 end = timeval_current_ofs(records[i].defend.timeout,0);
9400                                 records[i].defend.ret = true;
9401                                 while (records[i].defend.timeout > 0) {
9402                                         tevent_loop_once(ctx->nbtsock_srv->event_ctx);
9403                                         if (timeval_expired(&end)) break;
9404                                 }
9405                                 ret &= records[i].defend.ret;
9406                         }
9407
9408                         status = nbt_name_register_recv(req, ctx, name_register);
9409                         if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
9410                                 torture_comment(tctx, "No response from %s for name register\n", ctx->address);
9411                                 ret = false;
9412                         }
9413                         if (!NT_STATUS_IS_OK(status)) {
9414                                 torture_comment(tctx, "Bad response from %s for name register - %s\n",
9415                                        ctx->address, nt_errstr(status));
9416                                 ret = false;
9417                         }
9418                         CHECK_VALUE(tctx, name_register->out.rcode, 0);
9419                         CHECK_VALUE_STRING(tctx, name_register->out.reply_from, ctx->address);
9420                         CHECK_VALUE(tctx, name_register->out.name.type, records[i].name.type);
9421                         CHECK_VALUE_STRING(tctx, name_register->out.name.name, records[i].name.name);
9422                         CHECK_VALUE_STRING(tctx, name_register->out.name.scope, records[i].name.scope);
9423                         CHECK_VALUE_STRING(tctx, name_register->out.reply_addr, records[i].wins.ips[j].ip);
9424                 }
9425
9426                 /* Prepare for the current test */
9427                 records[i].defend = record.defend;
9428                 nbt_set_incoming_handler(ctx->nbtsock_srv,
9429                                          test_conflict_owned_active_vs_replica_handler,
9430                                          &records[i]);
9431                 if (ctx->nbtsock_srv2) {
9432                         nbt_set_incoming_handler(ctx->nbtsock_srv2,
9433                                                  test_conflict_owned_active_vs_replica_handler,
9434                                                  &records[i]);
9435                 }
9436
9437                 /*
9438                  * Setup Replica
9439                  */
9440                 wins_name->name         = &records[i].name;
9441                 wins_name->flags        = WREPL_NAME_FLAGS(records[i].replica.type,
9442                                                            records[i].replica.state,
9443                                                            records[i].replica.node,
9444                                                            records[i].replica.is_static);
9445                 wins_name->id           = ++ctx->b.max_version;
9446                 if (wins_name->flags & 2) {
9447                         wins_name->addresses.addresses.num_ips = records[i].replica.num_ips;
9448                         wins_name->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
9449                                                                  records[i].replica.ips);
9450                 } else {
9451                         wins_name->addresses.ip = records[i].replica.ips[0].ip;
9452                 }
9453                 wins_name->unknown      = "255.255.255.255";
9454
9455                 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
9456
9457                 /*
9458                  * wait for the name query, which is handled in
9459                  * test_conflict_owned_active_vs_replica_handler()
9460                  */
9461                 end = timeval_current_ofs(records[i].defend.timeout,0);
9462                 records[i].defend.ret = true;
9463                 while (records[i].defend.timeout > 0) {
9464                         tevent_loop_once(ctx->nbtsock_srv->event_ctx);
9465                         if (timeval_expired(&end)) break;
9466                 }
9467                 ret &= records[i].defend.ret;
9468
9469                 if (records[i].defend.late_release) {
9470                         records[i].defend = record.defend;
9471                         records[i].defend.expect_release = true;
9472                         /*
9473                          * wait for the name release demand, which is handled in
9474                          * test_conflict_owned_active_vs_replica_handler()
9475                          */
9476                         end = timeval_current_ofs(records[i].defend.timeout,0);
9477                         records[i].defend.ret = true;
9478                         while (records[i].defend.timeout > 0) {
9479                                 tevent_loop_once(ctx->nbtsock_srv->event_ctx);
9480                                 if (timeval_expired(&end)) break;
9481                         }
9482                         ret &= records[i].defend.ret;
9483                 }
9484
9485                 if (records[i].replica.mhomed_merge) {
9486                         ret &= test_wrepl_mhomed_merged(tctx, ctx, &ctx->c,
9487                                                         records[i].wins.num_ips, records[i].wins.ips,
9488                                                         &ctx->b,
9489                                                         records[i].replica.num_ips, records[i].replica.ips,
9490                                                         wins_name);
9491                 } else if (records[i].replica.sgroup_merge) {
9492                         ret &= test_wrepl_sgroup_merged(tctx, ctx, NULL,
9493                                                         &ctx->c,
9494                                                         records[i].wins.num_ips, records[i].wins.ips,
9495                                                         &ctx->b,
9496                                                         records[i].replica.num_ips, records[i].replica.ips,
9497                                                         wins_name);
9498                 } else {
9499                         ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name,
9500                                                      records[i].replica.apply_expected);
9501                 }
9502
9503                 if (records[i].replica.apply_expected ||
9504                     records[i].replica.mhomed_merge) {
9505                         wins_name->name         = &records[i].name;
9506                         wins_name->flags        = WREPL_NAME_FLAGS(WREPL_TYPE_UNIQUE,
9507                                                                    WREPL_STATE_TOMBSTONE,
9508                                                                    WREPL_NODE_B, false);
9509                         wins_name->id           = ++ctx->b.max_version;
9510                         wins_name->addresses.ip = addresses_B_1[0].ip;
9511                         wins_name->unknown      = "255.255.255.255";
9512
9513                         ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
9514                         ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name, true);
9515                 } else {
9516                         for (j=0; j < count; j++) {
9517                                 struct nbt_name_socket *nbtsock = ctx->nbtsock;
9518
9519                                 if (ctx->myaddr2 && strcmp(records[i].wins.ips[j].ip, ctx->myaddr2->addr) == 0) {
9520                                         nbtsock = ctx->nbtsock2;
9521                                 }
9522
9523                                 release->in.name        = records[i].name;
9524                                 release->in.dest_addr   = ctx->address;
9525                                 release->in.dest_port   = lpcfg_nbt_port(tctx->lp_ctx);
9526                                 release->in.address     = records[i].wins.ips[j].ip;
9527                                 release->in.nb_flags    = records[i].wins.nb_flags;
9528                                 release->in.broadcast   = false;
9529                                 release->in.timeout     = 30;
9530                                 release->in.retries     = 0;
9531
9532                                 status = nbt_name_release(nbtsock, ctx, release);
9533                                 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
9534                                         torture_comment(tctx, "No response from %s for name release\n", ctx->address);
9535                                         return false;
9536                                 }
9537                                 if (!NT_STATUS_IS_OK(status)) {
9538                                         torture_comment(tctx, "Bad response from %s for name query - %s\n",
9539                                                ctx->address, nt_errstr(status));
9540                                         return false;
9541                                 }
9542                                 CHECK_VALUE(tctx, release->out.rcode, 0);
9543                         }
9544
9545                         if (records[i].replica.sgroup_merge) {
9546                                 /* clean up the SGROUP record */
9547                                 wins_name->name         = &records[i].name;
9548                                 wins_name->flags        = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
9549                                                                            WREPL_STATE_ACTIVE,
9550                                                                            WREPL_NODE_B, false);
9551                                 wins_name->id           = ++ctx->b.max_version;
9552                                 wins_name->addresses.addresses.num_ips = 0;
9553                                 wins_name->addresses.addresses.ips     = NULL;
9554                                 wins_name->unknown      = "255.255.255.255";
9555                                 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
9556
9557                                 /* take ownership of the SGROUP record */
9558                                 wins_name->name         = &records[i].name;
9559                                 wins_name->flags        = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
9560                                                                            WREPL_STATE_ACTIVE,
9561                                                                            WREPL_NODE_B, false);
9562                                 wins_name->id           = ++ctx->b.max_version;
9563                                 wins_name->addresses.addresses.num_ips = ARRAY_SIZE(addresses_B_1);
9564                                 wins_name->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
9565                                                                          addresses_B_1);
9566                                 wins_name->unknown      = "255.255.255.255";
9567                                 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
9568                                 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name, true);
9569
9570                                 /* overwrite the SGROUP record with unique,tombstone */
9571                                 wins_name->name         = &records[i].name;
9572                                 wins_name->flags        = WREPL_NAME_FLAGS(WREPL_TYPE_UNIQUE,
9573                                                                            WREPL_STATE_TOMBSTONE,
9574                                                                            WREPL_NODE_B, false);
9575                                 wins_name->id           = ++ctx->b.max_version;
9576                                 wins_name->addresses.ip = addresses_A_1[0].ip;
9577                                 wins_name->unknown      = "255.255.255.255";
9578                                 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
9579                                 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name, true);
9580                         }
9581                 }
9582
9583                 if (!ret) {
9584                         torture_comment(tctx, "conflict handled wrong or record[%u]: %s\n", i, records[i].line);
9585                         return ret;
9586                 }
9587         }
9588
9589         return ret;
9590 }
9591
9592 #define __NBT_LABEL_CAT1__(a,b)    a##b
9593 #define __NBT_LABEL_CAT2__(a,b)    __NBT_LABEL_CAT1__(a,b)
9594 #define _NBT_LABEL __NBT_LABEL_CAT2__(_label_, __LINE__)
9595
9596 #define _NBT_ASSERT(v, correct) do { \
9597         bool _ret = true; \
9598         torture_assert_int_equal_goto(rec->tctx, v, correct, \
9599                         _ret, _NBT_LABEL, "Invalid int value"); \
9600 _NBT_LABEL: \
9601         if (!_ret) { \
9602                 return; \
9603         } \
9604 } while (0)
9605
9606 #define _NBT_ASSERT_STRING(v, correct) do { \
9607         bool _ret = true; \
9608         torture_assert_str_equal_goto(rec->tctx, v, correct, \
9609                         _ret, _NBT_LABEL, "Invalid string value"); \
9610 _NBT_LABEL: \
9611         if (!_ret) { \
9612                 return; \
9613         } \
9614 } while (0)
9615
9616 static void test_conflict_owned_active_vs_replica_handler_query(struct nbt_name_socket *nbtsock,
9617                                                                 struct nbt_name_packet *req_packet,
9618                                                                 struct socket_address *src)
9619 {
9620         struct nbt_name *name;
9621         struct nbt_name_packet *rep_packet;
9622         struct test_conflict_owned_active_vs_replica_struct *rec =
9623                 (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private_data;
9624
9625         _NBT_ASSERT(req_packet->qdcount, 1);
9626         _NBT_ASSERT(req_packet->questions[0].question_type, NBT_QTYPE_NETBIOS);
9627         _NBT_ASSERT(req_packet->questions[0].question_class, NBT_QCLASS_IP);
9628
9629         name = &req_packet->questions[0].name;
9630
9631         _NBT_ASSERT_STRING(name->name, rec->name.name);
9632         _NBT_ASSERT(name->type, rec->name.type);
9633         _NBT_ASSERT_STRING(name->scope, rec->name.scope);
9634
9635         _NBT_ASSERT(rec->defend.expect_release, false);
9636
9637         rep_packet = talloc_zero(nbtsock, struct nbt_name_packet);
9638         if (rep_packet == NULL) return;
9639
9640         rep_packet->name_trn_id = req_packet->name_trn_id;
9641         rep_packet->ancount     = 1;
9642
9643         rep_packet->answers     = talloc_array(rep_packet, struct nbt_res_rec, 1);
9644         if (rep_packet->answers == NULL) return;
9645
9646         rep_packet->answers[0].name      = *name;
9647         rep_packet->answers[0].rr_class  = NBT_QCLASS_IP;
9648         rep_packet->answers[0].ttl       = 0;
9649
9650         if (rec->defend.positive) {
9651                 uint32_t i, num_ips;
9652                 const struct wrepl_ip *ips;
9653
9654                 if (rec->defend.num_ips > 0) {
9655                         num_ips = rec->defend.num_ips;
9656                         ips     = rec->defend.ips;
9657                 } else {
9658                         num_ips = rec->wins.num_ips;
9659                         ips     = rec->wins.ips;
9660                 }
9661
9662                 /* send a positive reply */
9663                 rep_packet->operation   =
9664                                         NBT_FLAG_REPLY |
9665                                         NBT_OPCODE_QUERY |
9666                                         NBT_FLAG_AUTHORITATIVE |
9667                                         NBT_FLAG_RECURSION_DESIRED |
9668                                         NBT_FLAG_RECURSION_AVAIL;
9669
9670                 rep_packet->answers[0].rr_type   = NBT_QTYPE_NETBIOS;
9671
9672                 rep_packet->answers[0].rdata.netbios.length = num_ips*6;
9673                 rep_packet->answers[0].rdata.netbios.addresses =
9674                         talloc_array(rep_packet->answers, struct nbt_rdata_address, num_ips);
9675                 if (rep_packet->answers[0].rdata.netbios.addresses == NULL) return;
9676
9677                 for (i=0; i < num_ips; i++) {
9678                         struct nbt_rdata_address *addr =
9679                                 &rep_packet->answers[0].rdata.netbios.addresses[i];
9680                         addr->nb_flags  = rec->wins.nb_flags;
9681                         addr->ipaddr    = ips[i].ip;
9682                 }
9683                 DEBUG(2,("Sending positive name query reply for %s to %s:%d\n",
9684                         nbt_name_string(rep_packet, name), src->addr, src->port));
9685         } else {
9686                 /* send a negative reply */
9687                 rep_packet->operation   =
9688                                         NBT_FLAG_REPLY |
9689                                         NBT_OPCODE_QUERY |
9690                                         NBT_FLAG_AUTHORITATIVE |
9691                                         NBT_RCODE_NAM;
9692
9693                 rep_packet->answers[0].rr_type   = NBT_QTYPE_NULL;
9694
9695                 ZERO_STRUCT(rep_packet->answers[0].rdata);
9696
9697                 DEBUG(2,("Sending negative name query reply for %s to %s:%d\n",
9698                         nbt_name_string(rep_packet, name), src->addr, src->port));
9699         }
9700
9701         nbt_name_reply_send(nbtsock, src, rep_packet);
9702         talloc_free(rep_packet);
9703
9704         /* make sure we push the reply to the wire */
9705         while (nbtsock->send_queue) {
9706                 tevent_loop_once(nbtsock->event_ctx);
9707         }
9708         smb_msleep(1000);
9709
9710         rec->defend.timeout     = 0;
9711         rec->defend.ret         = true;
9712 }
9713
9714 static void test_conflict_owned_active_vs_replica_handler_release(
9715                                                                   struct nbt_name_socket *nbtsock,
9716                                                                   struct nbt_name_packet *req_packet,
9717                                                                   struct socket_address *src)
9718 {
9719         struct nbt_name *name;
9720         struct nbt_name_packet *rep_packet;
9721         struct test_conflict_owned_active_vs_replica_struct *rec =
9722                 (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private_data;
9723
9724         _NBT_ASSERT(req_packet->qdcount, 1);
9725         _NBT_ASSERT(req_packet->questions[0].question_type, NBT_QTYPE_NETBIOS);
9726         _NBT_ASSERT(req_packet->questions[0].question_class, NBT_QCLASS_IP);
9727
9728         name = &req_packet->questions[0].name;
9729
9730         _NBT_ASSERT_STRING(name->name, rec->name.name);
9731         _NBT_ASSERT(name->type, rec->name.type);
9732         _NBT_ASSERT_STRING(name->scope, rec->name.scope);
9733
9734         _NBT_ASSERT(rec->defend.expect_release, true);
9735
9736         rep_packet = talloc_zero(nbtsock, struct nbt_name_packet);
9737         if (rep_packet == NULL) return;
9738
9739         rep_packet->name_trn_id = req_packet->name_trn_id;
9740         rep_packet->ancount     = 1;
9741         rep_packet->operation   =
9742                                 NBT_FLAG_REPLY |
9743                                 NBT_OPCODE_RELEASE |
9744                                 NBT_FLAG_AUTHORITATIVE;
9745
9746         rep_packet->answers     = talloc_array(rep_packet, struct nbt_res_rec, 1);
9747         if (rep_packet->answers == NULL) return;
9748
9749         rep_packet->answers[0].name     = *name;
9750         rep_packet->answers[0].rr_type  = NBT_QTYPE_NETBIOS;
9751         rep_packet->answers[0].rr_class = NBT_QCLASS_IP;
9752         rep_packet->answers[0].ttl      = req_packet->additional[0].ttl;
9753         rep_packet->answers[0].rdata    = req_packet->additional[0].rdata;
9754
9755         DEBUG(2,("Sending name release reply for %s to %s:%d\n",
9756                 nbt_name_string(rep_packet, name), src->addr, src->port));
9757
9758         nbt_name_reply_send(nbtsock, src, rep_packet);
9759         talloc_free(rep_packet);
9760
9761         /* make sure we push the reply to the wire */
9762         while (nbtsock->send_queue) {
9763                 tevent_loop_once(nbtsock->event_ctx);
9764         }
9765         smb_msleep(1000);
9766
9767         rec->defend.timeout     = 0;
9768         rec->defend.ret         = true;
9769 }
9770
9771 static void test_conflict_owned_active_vs_replica_handler(struct nbt_name_socket *nbtsock,
9772                                                           struct nbt_name_packet *req_packet,
9773                                                           struct socket_address *src)
9774 {
9775         struct test_conflict_owned_active_vs_replica_struct *rec =
9776                 (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private_data;
9777         struct nbt_name *name = &req_packet->questions[0].name;
9778
9779         if (req_packet->operation & NBT_FLAG_BROADCAST) {
9780                 torture_comment(rec->tctx,
9781                         "%s: incoming packet name[%s] flags[0x%08X] from[%s]\n",
9782                         __location__,
9783                         nbt_name_string(rec->tctx, name),
9784                         req_packet->operation,
9785                         src->addr);
9786                 return;
9787         }
9788
9789         rec->defend.ret = false;
9790
9791         switch (req_packet->operation & NBT_OPCODE) {
9792         case NBT_OPCODE_QUERY:
9793                 test_conflict_owned_active_vs_replica_handler_query(nbtsock, req_packet, src);
9794                 break;
9795         case NBT_OPCODE_RELEASE:
9796                 test_conflict_owned_active_vs_replica_handler_release(nbtsock, req_packet, src);
9797                 break;
9798         default:
9799                 torture_comment(rec->tctx,
9800                         "%s: unexpected packet name[%s] flags[0x%08X] from[%s]\n",
9801                         __location__,
9802                         nbt_name_string(rec->tctx, name),
9803                         req_packet->operation,
9804                         src->addr);
9805                 _NBT_ASSERT((req_packet->operation & NBT_OPCODE), NBT_OPCODE_QUERY);
9806                 break;
9807         }
9808 }
9809
9810 /*
9811   test WINS replication replica conflicts operations
9812 */
9813 static bool torture_nbt_winsreplication_replica(struct torture_context *tctx)
9814 {
9815         bool ret = true;
9816         struct test_wrepl_conflict_conn *ctx;
9817
9818         const char *address;
9819         struct nbt_name name;
9820
9821         if (!torture_nbt_get_name(tctx, &name, &address))
9822                 return false;
9823
9824         ctx = test_create_conflict_ctx(tctx, address);
9825         if (!ctx) return false;
9826
9827         ret &= test_conflict_same_owner(tctx, ctx);
9828         ret &= test_conflict_different_owner(tctx, ctx);
9829
9830         return ret;
9831 }
9832
9833 /*
9834   test WINS replication owned conflicts operations
9835 */
9836 static bool torture_nbt_winsreplication_owned(struct torture_context *tctx)
9837 {
9838         const char *address;
9839         struct nbt_name name;
9840         bool ret = true;
9841         struct test_wrepl_conflict_conn *ctx;
9842
9843         if (torture_setting_bool(tctx, "quick", false))
9844                 torture_skip(tctx,
9845                         "skip NBT-WINSREPLICATION-OWNED test in quick test mode\n");
9846
9847         if (!torture_nbt_get_name(tctx, &name, &address))
9848                 return false;
9849
9850         ctx = test_create_conflict_ctx(tctx, address);
9851         torture_assert(tctx, ctx != NULL, "Creating context failed");
9852
9853         ret &= test_conflict_owned_released_vs_replica(tctx, ctx);
9854         ret &= test_conflict_owned_active_vs_replica(tctx, ctx);
9855
9856         return ret;
9857 }
9858
9859 /*
9860   test simple WINS replication operations
9861 */
9862 struct torture_suite *torture_nbt_winsreplication(TALLOC_CTX *mem_ctx)
9863 {
9864         struct torture_suite *suite = torture_suite_create(
9865                 mem_ctx, "winsreplication");
9866         struct torture_tcase *tcase;
9867
9868         tcase = torture_suite_add_simple_test(suite, "assoc_ctx1",
9869                                              test_assoc_ctx1);
9870         tcase->tests->dangerous = true;
9871
9872         torture_suite_add_simple_test(suite, "assoc_ctx2", test_assoc_ctx2);
9873
9874         torture_suite_add_simple_test(suite, "wins_replication",
9875                                       test_wins_replication);
9876
9877         torture_suite_add_simple_test(suite, "replica",
9878                                       torture_nbt_winsreplication_replica);
9879
9880         torture_suite_add_simple_test(suite, "owned",
9881                                       torture_nbt_winsreplication_owned);
9882
9883         return suite;
9884 }