LCOV - code coverage report
Current view: top level - source4/torture/nbt - winsreplication.c (source / functions) Hit Total Coverage
Test: coverage report for master 6248eab5 Lines: 1573 1711 91.9 %
Date: 2021-08-25 13:27:56 Functions: 21 24 87.5 %

          Line data    Source code
       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         508 : static const char *wrepl_name_type_string(enum wrepl_name_type type)
      59             : {
      60         508 :         switch (type) {
      61         165 :         case WREPL_TYPE_UNIQUE: return "UNIQUE";
      62          61 :         case WREPL_TYPE_GROUP: return "GROUP";
      63         182 :         case WREPL_TYPE_SGROUP: return "SGROUP";
      64         100 :         case WREPL_TYPE_MHOMED: return "MHOMED";
      65             :         }
      66           0 :         return "UNKNOWN_TYPE";
      67             : }
      68             : 
      69         508 : static const char *wrepl_name_state_string(enum wrepl_name_state state)
      70             : {
      71         508 :         switch (state) {
      72         276 :         case WREPL_STATE_ACTIVE: return "ACTIVE";
      73          58 :         case WREPL_STATE_RELEASED: return "RELEASED";
      74         174 :         case WREPL_STATE_TOMBSTONE: return "TOMBSTONE";
      75           0 :         case WREPL_STATE_RESERVED: return "RESERVED";
      76             :         }
      77           0 :         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           0 : static bool test_assoc_ctx1(struct torture_context *tctx)
      85             : {
      86           0 :         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           0 :         if (!torture_nbt_get_name(tctx, &name, &address))
     102           0 :                 return false;
     103             : 
     104           0 :         torture_comment(tctx, "Test if assoc_ctx is only valid on the connection it was created on\n");
     105             : 
     106           0 :         wrepl_socket1 = wrepl_socket_init(tctx, tctx->ev);
     107           0 :         wrepl_socket2 = wrepl_socket_init(tctx, tctx->ev);
     108             : 
     109           0 :         torture_comment(tctx, "Setup 2 wrepl connections\n");
     110           0 :         status = wrepl_connect(wrepl_socket1, wrepl_best_ip(tctx->lp_ctx, address), address);
     111           0 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     112             : 
     113           0 :         status = wrepl_connect(wrepl_socket2, wrepl_best_ip(tctx->lp_ctx, address), address);
     114           0 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     115             : 
     116           0 :         torture_comment(tctx, "Send a start association request (conn1)\n");
     117           0 :         status = wrepl_associate(wrepl_socket1, &associate1);
     118           0 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     119             : 
     120           0 :         torture_comment(tctx, "association context (conn1): 0x%x\n", associate1.out.assoc_ctx);
     121             : 
     122           0 :         torture_comment(tctx, "Send a start association request (conn2)\n");
     123           0 :         status = wrepl_associate(wrepl_socket2, &associate2);
     124           0 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     125             : 
     126           0 :         torture_comment(tctx, "association context (conn2): 0x%x\n", associate2.out.assoc_ctx);
     127             : 
     128           0 :         torture_comment(tctx, "Send a replication table query, with assoc 1 (conn2), the answer should be on conn1\n");
     129           0 :         ZERO_STRUCT(packet);
     130           0 :         packet.opcode                      = WREPL_OPCODE_BITS;
     131           0 :         packet.assoc_ctx                   = associate1.out.assoc_ctx;
     132           0 :         packet.mess_type                   = WREPL_REPLICATION;
     133           0 :         packet.message.replication.command = WREPL_REPL_TABLE_QUERY;
     134           0 :         ZERO_STRUCT(ctrl);
     135           0 :         ctrl.send_only = true;
     136           0 :         subreq = wrepl_request_send(tctx, tctx->ev, wrepl_socket2, &packet, &ctrl);
     137           0 :         ok = tevent_req_poll(subreq, tctx->ev);
     138           0 :         if (!ok) {
     139           0 :                 CHECK_STATUS(tctx, NT_STATUS_INTERNAL_ERROR, NT_STATUS_OK);
     140             :         }
     141           0 :         status = wrepl_request_recv(subreq, tctx, &rep_packet);
     142           0 :         TALLOC_FREE(subreq);
     143           0 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     144             : 
     145           0 :         torture_comment(tctx, "Send a association request (conn2), to make sure the last request was ignored\n");
     146           0 :         status = wrepl_associate(wrepl_socket2, &associate2);
     147           0 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     148             : 
     149           0 :         torture_comment(tctx, "Send a replication table query, with invalid assoc (conn1), receive answer from conn2\n");
     150           0 :         ZERO_STRUCT(packet);
     151           0 :         packet.opcode                           = WREPL_OPCODE_BITS;
     152           0 :         packet.assoc_ctx                        = 0;
     153           0 :         packet.mess_type                        = WREPL_REPLICATION;
     154           0 :         packet.message.replication.command      = WREPL_REPL_TABLE_QUERY;
     155           0 :         status = wrepl_request(wrepl_socket1, tctx, &packet, &rep_packet);
     156           0 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     157             : 
     158           0 :         torture_comment(tctx, "Send a association request (conn1), to make sure the last request was handled correct\n");
     159           0 :         status = wrepl_associate(wrepl_socket1, &associate2);
     160           0 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     161             : 
     162           0 :         assoc_stop.in.assoc_ctx = associate1.out.assoc_ctx;
     163           0 :         assoc_stop.in.reason    = 4;
     164           0 :         torture_comment(tctx, "Send a association stop request (conn1), reson: %u\n", assoc_stop.in.reason);
     165           0 :         status = wrepl_associate_stop(wrepl_socket1, &assoc_stop);
     166           0 :         CHECK_STATUS(tctx, status, NT_STATUS_END_OF_FILE);
     167             : 
     168           0 :         assoc_stop.in.assoc_ctx = associate2.out.assoc_ctx;
     169           0 :         assoc_stop.in.reason    = 0;
     170           0 :         torture_comment(tctx, "Send a association stop request (conn2), reson: %u\n", assoc_stop.in.reason);
     171           0 :         status = wrepl_associate_stop(wrepl_socket2, &assoc_stop);
     172           0 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     173             : 
     174           0 :         torture_comment(tctx, "Close 2 wrepl connections\n");
     175           0 :         talloc_free(wrepl_socket1);
     176           0 :         talloc_free(wrepl_socket2);
     177           0 :         return ret;
     178             : }
     179             : 
     180             : /*
     181             :   test if we always get back the same assoc_ctx
     182             : */
     183           1 : 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           1 :         if (!torture_nbt_get_name(tctx, &name, &address))
     193           0 :                 return false;
     194             : 
     195           1 :         torture_comment(tctx, "Test if we always get back the same assoc_ctx\n");
     196             : 
     197           1 :         wrepl_socket = wrepl_socket_init(tctx, tctx->ev);
     198             :         
     199           1 :         torture_comment(tctx, "Setup wrepl connections\n");
     200           1 :         status = wrepl_connect(wrepl_socket, wrepl_best_ip(tctx->lp_ctx, address), address);
     201           1 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     202             : 
     203           1 :         torture_comment(tctx, "Send 1st start association request\n");
     204           1 :         status = wrepl_associate(wrepl_socket, &associate);
     205           1 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     206           1 :         assoc_ctx1 = associate.out.assoc_ctx;
     207           1 :         torture_comment(tctx, "1st association context: 0x%x\n", associate.out.assoc_ctx);
     208             : 
     209           1 :         torture_comment(tctx, "Send 2nd start association request\n");
     210           1 :         status = wrepl_associate(wrepl_socket, &associate);
     211           1 :         torture_assert_ntstatus_ok(tctx, status, "2nd start association failed");
     212           1 :         torture_assert(tctx, associate.out.assoc_ctx == assoc_ctx1, 
     213             :                                    "Different context returned");
     214           1 :         torture_comment(tctx, "2nd association context: 0x%x\n", associate.out.assoc_ctx);
     215             : 
     216           1 :         torture_comment(tctx, "Send 3rd start association request\n");
     217           1 :         status = wrepl_associate(wrepl_socket, &associate);
     218           1 :         torture_assert(tctx, associate.out.assoc_ctx == assoc_ctx1, 
     219             :                                    "Different context returned");
     220           1 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     221           1 :         torture_comment(tctx, "3rd association context: 0x%x\n", associate.out.assoc_ctx);
     222             : 
     223           1 :         torture_comment(tctx, "Close wrepl connections\n");
     224           1 :         talloc_free(wrepl_socket);
     225           1 :         return true;
     226             : }
     227             : 
     228             : 
     229             : /*
     230             :   display a replication entry
     231             : */
     232           1 : static void display_entry(struct torture_context *tctx, struct wrepl_name *name)
     233             : {
     234             :         int i;
     235             : 
     236           1 :         torture_comment(tctx, "%s\n", nbt_name_string(tctx, &name->name));
     237           3 :         torture_comment(tctx, "\tTYPE:%u STATE:%u NODE:%u STATIC:%u VERSION_ID: %llu\n",
     238           3 :                 name->type, name->state, name->node, name->is_static, (long long)name->version_id);
     239           1 :         torture_comment(tctx, "\tRAW_FLAGS: 0x%08X OWNER: %-15s\n",
     240             :                 name->raw_flags, name->owner);
     241           2 :         for (i=0;i<name->num_addresses;i++) {
     242           2 :                 torture_comment(tctx, "\tADDR: %-15s OWNER: %-15s\n", 
     243           2 :                         name->addresses[i].address, name->addresses[i].owner);
     244             :         }
     245           1 : }
     246             : 
     247             : /*
     248             :   test a full replication dump from a WINS server
     249             : */
     250           1 : 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           1 :         if (!torture_nbt_get_name(tctx, &name, &address))
     262           0 :                 return false;
     263             : 
     264           1 :         torture_comment(tctx, "Test one pull replication cycle\n");
     265             : 
     266           1 :         wrepl_socket = wrepl_socket_init(tctx, tctx->ev);
     267             :         
     268           1 :         torture_comment(tctx, "Setup wrepl connections\n");
     269           1 :         status = wrepl_connect(wrepl_socket, wrepl_best_ip(tctx->lp_ctx, address), address);
     270           1 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     271             : 
     272           1 :         torture_comment(tctx, "Send a start association request\n");
     273             : 
     274           1 :         status = wrepl_associate(wrepl_socket, &associate);
     275           1 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     276             : 
     277           1 :         torture_comment(tctx, "association context: 0x%x\n", associate.out.assoc_ctx);
     278             : 
     279           1 :         torture_comment(tctx, "Send a replication table query\n");
     280           1 :         pull_table.in.assoc_ctx = associate.out.assoc_ctx;
     281             : 
     282           1 :         status = wrepl_pull_table(wrepl_socket, tctx, &pull_table);
     283           1 :         if (NT_STATUS_EQUAL(NT_STATUS_NETWORK_ACCESS_DENIED,status)) {
     284             :                 struct wrepl_associate_stop assoc_stop;
     285             : 
     286           0 :                 assoc_stop.in.assoc_ctx = associate.out.assoc_ctx;
     287           0 :                 assoc_stop.in.reason = 0;
     288             : 
     289           0 :                 wrepl_associate_stop(wrepl_socket, &assoc_stop);
     290             : 
     291           0 :                 torture_fail(tctx, "We are not a valid pull partner for the server");
     292             :         }
     293           1 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     294             : 
     295           1 :         torture_comment(tctx, "Found %d replication partners\n", pull_table.out.num_partners);
     296             : 
     297           2 :         for (i=0;i<pull_table.out.num_partners;i++) {
     298           1 :                 struct wrepl_wins_owner *partner = &pull_table.out.partners[i];
     299           3 :                 torture_comment(tctx, "%s   max_version=%6llu   min_version=%6llu type=%d\n",
     300             :                        partner->address, 
     301           1 :                        (long long)partner->max_version, 
     302           1 :                        (long long)partner->min_version, 
     303             :                        partner->type);
     304             : 
     305           1 :                 pull_names.in.assoc_ctx = associate.out.assoc_ctx;
     306           1 :                 pull_names.in.partner = *partner;
     307             :                 
     308           1 :                 status = wrepl_pull_names(wrepl_socket, tctx, &pull_names);
     309           1 :                 CHECK_STATUS(tctx, status, NT_STATUS_OK);
     310             : 
     311           1 :                 torture_comment(tctx, "Received %d names\n", pull_names.out.num_names);
     312             : 
     313           2 :                 for (j=0;j<pull_names.out.num_names;j++) {
     314           1 :                         display_entry(tctx, &pull_names.out.names[j]);
     315             :                 }
     316             :         }
     317             : 
     318           1 :         torture_comment(tctx, "Close wrepl connections\n");
     319           1 :         talloc_free(wrepl_socket);
     320           1 :         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           2 : 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           2 :         ctx = talloc_zero(tctx, struct test_wrepl_conflict_conn);
     562           2 :         if (!ctx) return NULL;
     563             : 
     564           2 :         ctx->address = address;
     565           2 :         ctx->pull    = wrepl_socket_init(ctx, tctx->ev);
     566           2 :         if (!ctx->pull) return NULL;
     567             : 
     568           2 :         torture_comment(tctx, "Setup wrepl conflict pull connection\n");
     569           2 :         status = wrepl_connect(ctx->pull, wrepl_best_ip(tctx->lp_ctx, ctx->address), ctx->address);
     570           2 :         if (!NT_STATUS_IS_OK(status)) return NULL;
     571             : 
     572           2 :         status = wrepl_associate(ctx->pull, &associate);
     573           2 :         if (!NT_STATUS_IS_OK(status)) return NULL;
     574             : 
     575           2 :         ctx->pull_assoc = associate.out.assoc_ctx;
     576             : 
     577           2 :         ctx->a.address               = TEST_OWNER_A_ADDRESS;
     578           2 :         ctx->a.max_version   = 0;
     579           2 :         ctx->a.min_version   = 0;
     580           2 :         ctx->a.type          = 1;
     581             : 
     582           2 :         ctx->b.address               = TEST_OWNER_B_ADDRESS;
     583           2 :         ctx->b.max_version   = 0;
     584           2 :         ctx->b.min_version   = 0;
     585           2 :         ctx->b.type          = 1;
     586             : 
     587           2 :         ctx->x.address               = TEST_OWNER_X_ADDRESS;
     588           2 :         ctx->x.max_version   = 0;
     589           2 :         ctx->x.min_version   = 0;
     590           2 :         ctx->x.type          = 1;
     591             : 
     592           2 :         ctx->c.address               = address;
     593           2 :         ctx->c.max_version   = 0;
     594           2 :         ctx->c.min_version   = 0;
     595           2 :         ctx->c.type          = 1;
     596             : 
     597           2 :         pull_table.in.assoc_ctx = ctx->pull_assoc;
     598           2 :         status = wrepl_pull_table(ctx->pull, ctx->pull, &pull_table);
     599           2 :         if (!NT_STATUS_IS_OK(status)) return NULL;
     600             : 
     601           7 :         for (i=0; i < pull_table.out.num_partners; i++) {
     602           5 :                 if (strcmp(TEST_OWNER_A_ADDRESS,pull_table.out.partners[i].address)==0) {
     603           1 :                         ctx->a.max_version   = pull_table.out.partners[i].max_version;
     604           1 :                         ctx->a.min_version   = pull_table.out.partners[i].min_version;
     605             :                 }
     606           5 :                 if (strcmp(TEST_OWNER_B_ADDRESS,pull_table.out.partners[i].address)==0) {
     607           1 :                         ctx->b.max_version   = pull_table.out.partners[i].max_version;
     608           1 :                         ctx->b.min_version   = pull_table.out.partners[i].min_version;
     609             :                 }
     610           5 :                 if (strcmp(TEST_OWNER_X_ADDRESS,pull_table.out.partners[i].address)==0) {
     611           1 :                         ctx->x.max_version   = pull_table.out.partners[i].max_version;
     612           1 :                         ctx->x.min_version   = pull_table.out.partners[i].min_version;
     613             :                 }
     614           5 :                 if (strcmp(address,pull_table.out.partners[i].address)==0) {
     615           2 :                         ctx->c.max_version   = pull_table.out.partners[i].max_version;
     616           2 :                         ctx->c.min_version   = pull_table.out.partners[i].min_version;
     617             :                 }
     618             :         }
     619             : 
     620           2 :         talloc_free(pull_table.out.partners);
     621             : 
     622           2 :         ctx->nbtsock = nbt_name_socket_init(ctx, tctx->ev);
     623           2 :         if (!ctx->nbtsock) return NULL;
     624             : 
     625           2 :         load_interface_list(tctx, tctx->lp_ctx, &ifaces);
     626             : 
     627           2 :         ctx->myaddr = socket_address_from_strings(tctx, ctx->nbtsock->sock->backend_name, iface_list_best_ip(ifaces, address), 0);
     628           2 :         if (!ctx->myaddr) return NULL;
     629             : 
     630           4 :         for (i = 0; i < iface_list_count(ifaces); i++) {
     631           4 :                 if (!iface_list_n_is_v4(ifaces, i)) continue;
     632           4 :                 if (strcmp(ctx->myaddr->addr, iface_list_n_ip(ifaces, i)) == 0) continue;
     633           2 :                 ctx->myaddr2 = socket_address_from_strings(tctx, ctx->nbtsock->sock->backend_name, iface_list_n_ip(ifaces, i), 0);
     634           2 :                 if (!ctx->myaddr2) return NULL;
     635           2 :                 break;
     636             :         }
     637             : 
     638           2 :         status = socket_listen(ctx->nbtsock->sock, ctx->myaddr, 0, 0);
     639           2 :         if (!NT_STATUS_IS_OK(status)) return NULL;
     640             : 
     641           2 :         ctx->nbtsock_srv = nbt_name_socket_init(ctx, tctx->ev);
     642           2 :         if (!ctx->nbtsock_srv) return NULL;
     643             : 
     644             :         /* Make a port 137 version of ctx->myaddr */
     645           2 :         nbt_srv_addr = socket_address_from_strings(tctx, ctx->nbtsock_srv->sock->backend_name, ctx->myaddr->addr, lpcfg_nbt_port(tctx->lp_ctx));
     646           2 :         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           2 :         status = socket_listen(ctx->nbtsock_srv->sock, nbt_srv_addr, 0, 0);
     650           2 :         talloc_free(nbt_srv_addr);
     651           2 :         if (!NT_STATUS_IS_OK(status)) {
     652             :                 /* this isn't fatal */
     653           0 :                 talloc_free(ctx->nbtsock_srv);
     654           0 :                 ctx->nbtsock_srv = NULL;
     655             :         }
     656             : 
     657           2 :         if (ctx->myaddr2 && ctx->nbtsock_srv) {
     658           2 :                 ctx->nbtsock2 = nbt_name_socket_init(ctx, tctx->ev);
     659           2 :                 if (!ctx->nbtsock2) return NULL;
     660             : 
     661           2 :                 status = socket_listen(ctx->nbtsock2->sock, ctx->myaddr2, 0, 0);
     662           2 :                 if (!NT_STATUS_IS_OK(status)) return NULL;
     663             : 
     664           2 :                 ctx->nbtsock_srv2 = nbt_name_socket_init(ctx, ctx->nbtsock_srv->event_ctx);
     665           2 :                 if (!ctx->nbtsock_srv2) return NULL;
     666             : 
     667             :                 /* Make a port 137 version of ctx->myaddr2 */
     668           4 :                 nbt_srv_addr = socket_address_from_strings(tctx, 
     669           2 :                                                            ctx->nbtsock_srv->sock->backend_name, 
     670           2 :                                                            ctx->myaddr2->addr, 
     671             :                                                            lpcfg_nbt_port(tctx->lp_ctx));
     672           2 :                 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           2 :                 status = socket_listen(ctx->nbtsock_srv2->sock, ctx->myaddr2, 0, 0);
     676           2 :                 talloc_free(nbt_srv_addr);
     677           2 :                 if (!NT_STATUS_IS_OK(status)) {
     678             :                         /* this isn't fatal */
     679           0 :                         talloc_free(ctx->nbtsock_srv2);
     680           0 :                         ctx->nbtsock_srv2 = NULL;
     681             :                 }
     682             :         }
     683             : 
     684           2 :         ctx->addresses_best_num = 1;
     685           2 :         ctx->addresses_best = talloc_array(ctx, struct wrepl_ip, ctx->addresses_best_num);
     686           2 :         if (!ctx->addresses_best) return NULL;
     687           2 :         ctx->addresses_best[0].owner = ctx->b.address;
     688           2 :         ctx->addresses_best[0].ip    = ctx->myaddr->addr;
     689             : 
     690             : 
     691           2 :         num_ifaces = iface_list_count(ifaces);
     692           2 :         ctx->addresses_all = talloc_array(ctx, struct wrepl_ip, num_ifaces);
     693           2 :         ctx->addresses_all_num = 0;
     694           2 :         if (!ctx->addresses_all) return NULL;
     695          16 :         for (i=0; i < num_ifaces; i++) {
     696          14 :                 if (!iface_list_n_is_v4(ifaces, i)) continue;
     697          12 :                 ctx->addresses_all[i].owner  = ctx->b.address;
     698          12 :                 ctx->addresses_all[i].ip     = talloc_strdup(ctx->addresses_all, iface_list_n_ip(ifaces, i));
     699          12 :                 ctx->addresses_all_num++;
     700          12 :                 if (!ctx->addresses_all[i].ip) return NULL;
     701             :         }
     702             : 
     703           2 :         if (ctx->nbtsock_srv2) {
     704           2 :                 ctx->addresses_best2_num = 1;
     705           2 :                 ctx->addresses_best2 = talloc_array(ctx, struct wrepl_ip, ctx->addresses_best2_num);
     706           2 :                 if (!ctx->addresses_best2) return NULL;
     707           2 :                 ctx->addresses_best2[0].owner        = ctx->b.address;
     708           2 :                 ctx->addresses_best2[0].ip   = ctx->myaddr2->addr;
     709             : 
     710           2 :                 ctx->addresses_mhomed_num = 2;
     711           2 :                 ctx->addresses_mhomed = talloc_array(ctx, struct wrepl_ip, ctx->addresses_mhomed_num);
     712           2 :                 if (!ctx->addresses_mhomed) return NULL;
     713           2 :                 ctx->addresses_mhomed[0].owner       = ctx->b.address;
     714           2 :                 ctx->addresses_mhomed[0].ip  = ctx->myaddr->addr;
     715           2 :                 ctx->addresses_mhomed[1].owner       = ctx->b.address;
     716           2 :                 ctx->addresses_mhomed[1].ip  = ctx->myaddr2->addr;
     717             :         }
     718             : 
     719           2 :         return ctx;
     720             : }
     721             : 
     722         675 : 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         675 :         wrepl_socket = wrepl_socket_init(ctx, tctx->ev);
     739             : 
     740         675 :         status = wrepl_connect(wrepl_socket, wrepl_best_ip(tctx->lp_ctx, ctx->address), ctx->address);
     741         675 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     742             : 
     743         675 :         status = wrepl_associate(wrepl_socket, &associate);
     744         675 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     745         675 :         assoc_ctx = associate.out.assoc_ctx;
     746             : 
     747             :         /* now send a WREPL_REPL_UPDATE message */
     748         675 :         ZERO_STRUCT(update_packet);
     749         675 :         update_packet.opcode                    = WREPL_OPCODE_BITS;
     750         675 :         update_packet.assoc_ctx                 = assoc_ctx;
     751         675 :         update_packet.mess_type                 = WREPL_REPLICATION;
     752         675 :         update_packet.message.replication.command       = WREPL_REPL_UPDATE;
     753         675 :         update  = &update_packet.message.replication.info.table;
     754             : 
     755         675 :         update->partner_count        = ARRAY_SIZE(wrepl_wins_owners);
     756         675 :         update->partners     = wrepl_wins_owners;
     757         675 :         update->initiator    = "0.0.0.0";
     758             : 
     759         675 :         wrepl_wins_owners[0]    = *owner;
     760             : 
     761         675 :         status = wrepl_request(wrepl_socket, wrepl_socket,
     762             :                                &update_packet, &repl_recv);
     763         675 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     764         675 :         CHECK_VALUE(tctx, repl_recv->mess_type, WREPL_REPLICATION);
     765         675 :         CHECK_VALUE(tctx, repl_recv->message.replication.command, WREPL_REPL_SEND_REQUEST);
     766             : 
     767         675 :         ZERO_STRUCT(repl_send);
     768         675 :         repl_send.opcode                        = WREPL_OPCODE_BITS;
     769         675 :         repl_send.assoc_ctx                     = assoc_ctx;
     770         675 :         repl_send.mess_type                     = WREPL_REPLICATION;
     771         675 :         repl_send.message.replication.command   = WREPL_REPL_SEND_REPLY;
     772         675 :         send_reply = &repl_send.message.replication.info.reply;
     773             : 
     774         675 :         send_reply->num_names        = ARRAY_SIZE(wrepl_wins_names);
     775         675 :         send_reply->names    = wrepl_wins_names;
     776             : 
     777         675 :         wrepl_wins_names[0]     = *name;
     778             : 
     779         675 :         status = wrepl_request(wrepl_socket, wrepl_socket,
     780             :                                &repl_send, &repl_recv);
     781         675 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     782         675 :         CHECK_VALUE(tctx, repl_recv->mess_type, WREPL_STOP_ASSOCIATION);
     783         675 :         CHECK_VALUE(tctx, repl_recv->message.stop.reason, 0);
     784             : 
     785         675 :         talloc_free(wrepl_socket);
     786         675 :         return true;
     787             : }
     788             : 
     789         762 : 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         762 :         pull_names.in.assoc_ctx = ctx->pull_assoc;
     800         762 :         pull_names.in.partner   = *owner;
     801         762 :         pull_names.in.partner.min_version = pull_names.in.partner.max_version;
     802             :                 
     803         762 :         status = wrepl_pull_names(ctx->pull, ctx->pull, &pull_names);
     804         762 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     805         762 :         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         762 :         names = pull_names.out.names;
     809             : 
     810         762 :         if (expected) {
     811         509 :                 uint32_t flags = WREPL_NAME_FLAGS(names[0].type,
     812             :                                                   names[0].state,
     813             :                                                   names[0].node,
     814             :                                                   names[0].is_static);
     815         509 :                 char *expected_scope = NULL;
     816         509 :                 CHECK_VALUE(tctx, names[0].name.type, name->name->type);
     817         509 :                 CHECK_VALUE_STRING(tctx, names[0].name.name, name->name->name);
     818             : 
     819         509 :                 if (names[0].name.scope) {
     820         121 :                         expected_scope = talloc_strndup(tctx,
     821         121 :                                                         name->name->scope,
     822             :                                                         237);
     823             :                 }
     824         509 :                 CHECK_VALUE_STRING(tctx, names[0].name.scope, expected_scope);
     825         509 :                 CHECK_VALUE(tctx, flags, name->flags);
     826         509 :                 CHECK_VALUE_UINT64(tctx, names[0].version_id, name->id);
     827             : 
     828         509 :                 if (flags & 2) {
     829         222 :                         CHECK_VALUE(tctx, names[0].num_addresses,
     830             :                                     name->addresses.addresses.num_ips);
     831             :                 } else {
     832         287 :                         CHECK_VALUE(tctx, names[0].num_addresses, 1);
     833         287 :                         CHECK_VALUE_STRING(tctx, names[0].addresses[0].address,
     834             :                                            name->addresses.ip);
     835             :                 }
     836             :         }
     837         762 :         talloc_free(pull_names.out.names);
     838         762 :         return true;
     839             : }
     840             : 
     841           5 : 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           5 :         uint32_t num_ips = num_ips1 + num_ips2;
     855             : 
     856          10 :         for (i = 0; i < num_ips2; i++) {
     857           7 :                 for (j = 0; j < num_ips1; j++) {
     858           5 :                         if (strcmp(ips2[i].ip,ips1[j].ip) == 0) {
     859           3 :                                 num_ips--;
     860           3 :                                 break;
     861             :                         }
     862             :                 } 
     863             :         }
     864             : 
     865           5 :         pull_names.in.assoc_ctx = ctx->pull_assoc;
     866           5 :         pull_names.in.partner   = *owner2;
     867           5 :         pull_names.in.partner.min_version = pull_names.in.partner.max_version;
     868             : 
     869           5 :         status = wrepl_pull_names(ctx->pull, ctx->pull, &pull_names);
     870           5 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     871           5 :         CHECK_VALUE(tctx, pull_names.out.num_names, 1);
     872             : 
     873           5 :         names = pull_names.out.names;
     874             : 
     875           5 :         flags = WREPL_NAME_FLAGS(names[0].type,
     876             :                                  names[0].state,
     877             :                                  names[0].node,
     878             :                                  names[0].is_static);
     879           5 :         CHECK_VALUE(tctx, names[0].name.type, name2->name->type);
     880           5 :         CHECK_VALUE_STRING(tctx, names[0].name.name, name2->name->name);
     881           5 :         CHECK_VALUE_STRING(tctx, names[0].name.scope, name2->name->scope);
     882           5 :         CHECK_VALUE(tctx, flags, name2->flags | WREPL_TYPE_MHOMED);
     883           5 :         CHECK_VALUE_UINT64(tctx, names[0].version_id, name2->id);
     884             : 
     885           5 :         CHECK_VALUE(tctx, names[0].num_addresses, num_ips);
     886             : 
     887          15 :         for (i = 0; i < names[0].num_addresses; i++) {
     888          10 :                 const char *addr = names[0].addresses[i].address; 
     889          10 :                 const char *owner = names[0].addresses[i].owner;
     890          10 :                 bool found = false;
     891             : 
     892          15 :                 for (j = 0; j < num_ips2; j++) {
     893          10 :                         if (strcmp(addr, ips2[j].ip) == 0) {
     894           5 :                                 found = true;
     895           5 :                                 CHECK_VALUE_STRING(tctx, owner, owner2->address);
     896           5 :                                 break;
     897             :                         }
     898             :                 }
     899             : 
     900          10 :                 if (found) continue;
     901             : 
     902           8 :                 for (j = 0; j < num_ips1; j++) {
     903           8 :                         if (strcmp(addr, ips1[j].ip) == 0) {
     904           5 :                                 found = true;
     905           5 :                                 CHECK_VALUE_STRING(tctx, owner, owner1->address);
     906           5 :                                 break;
     907             :                         }
     908             :                 }
     909             : 
     910           5 :                 if (found) continue;
     911             : 
     912           0 :                 CHECK_VALUE_STRING(tctx, addr, "not found in address list");
     913             :         }
     914           5 :         talloc_free(pull_names.out.names);
     915           5 :         return true;
     916             : }
     917             : 
     918          12 : 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          12 :         struct wrepl_name *name = NULL;
     931             :         uint32_t flags;
     932             :         uint32_t i, j;
     933          12 :         uint32_t num_ips = num_ips1 + num_ips2;
     934             : 
     935          12 :         if (!merge_owner) {
     936           8 :                 merge_owner = &ctx->c;
     937             :         }
     938             : 
     939          46 :         for (i = 0; i < num_ips1; i++) {
     940          34 :                 if (owner1 != &ctx->c && strcmp(ips1[i].owner,owner2->address) == 0) {
     941           8 :                         num_ips--;
     942           8 :                         continue;
     943             :                 }
     944          58 :                 for (j = 0; j < num_ips2; j++) {
     945          39 :                         if (strcmp(ips1[i].ip,ips2[j].ip) == 0) {
     946           7 :                                 num_ips--;
     947           7 :                                 break;
     948             :                         }
     949             :                 }
     950             :         }
     951             : 
     952             : 
     953          12 :         pull_names.in.assoc_ctx = ctx->pull_assoc;
     954          12 :         pull_names.in.partner   = *merge_owner;
     955          12 :         pull_names.in.partner.min_version = pull_names.in.partner.max_version;
     956          12 :         pull_names.in.partner.max_version = 0;
     957             : 
     958          12 :         status = wrepl_pull_names(ctx->pull, ctx->pull, &pull_names);
     959          12 :         CHECK_STATUS(tctx, status, NT_STATUS_OK);
     960             : 
     961          12 :         names = pull_names.out.names;
     962             :         
     963          24 :         for (i = 0; i < pull_names.out.num_names; i++) {
     964          12 :                 if (names[i].name.type != name2->name->type)      continue;
     965          12 :                 if (!names[i].name.name) continue;
     966          12 :                 if (strcmp(names[i].name.name, name2->name->name) != 0) continue;
     967          12 :                 if (names[i].name.scope) continue;
     968             : 
     969          12 :                 name = &names[i];
     970             :         }
     971             : 
     972          12 :         if (pull_names.out.num_names > 0) {
     973          12 :                 merge_owner->max_version     = names[pull_names.out.num_names-1].version_id;
     974             :         }
     975             : 
     976          12 :         if (!name) {
     977           0 :                 torture_comment(tctx, "%s: Name '%s' not found\n", __location__, nbt_name_string(ctx, name2->name));
     978           0 :                 return false;
     979             :         }
     980             : 
     981          12 :         flags = WREPL_NAME_FLAGS(name->type,
     982             :                                  name->state,
     983             :                                  name->node,
     984             :                                  name->is_static);
     985          12 :         CHECK_VALUE(tctx, name->name.type, name2->name->type);
     986          12 :         CHECK_VALUE_STRING(tctx, name->name.name, name2->name->name);
     987          12 :         CHECK_VALUE_STRING(tctx, name->name.scope, name2->name->scope);
     988          12 :         CHECK_VALUE(tctx, flags, name2->flags);
     989             : 
     990          12 :         CHECK_VALUE(tctx, name->num_addresses, num_ips);
     991             : 
     992          54 :         for (i = 0; i < name->num_addresses; i++) {
     993          42 :                 const char *addr = name->addresses[i].address; 
     994          42 :                 const char *owner = name->addresses[i].owner;
     995          42 :                 bool found = false;
     996             : 
     997          98 :                 for (j = 0; j < num_ips2; j++) {
     998          79 :                         if (strcmp(addr, ips2[j].ip) == 0) {
     999          23 :                                 found = true;
    1000          23 :                                 CHECK_VALUE_STRING(tctx, owner, ips2[j].owner);
    1001          23 :                                 break;
    1002             :                         }
    1003             :                 }
    1004             : 
    1005          42 :                 if (found) continue;
    1006             : 
    1007          45 :                 for (j = 0; j < num_ips1; j++) {
    1008          45 :                         if (strcmp(addr, ips1[j].ip) == 0) {
    1009          19 :                                 found = true;
    1010          19 :                                 if (owner1 == &ctx->c) {
    1011           3 :                                         CHECK_VALUE_STRING(tctx, owner, owner1->address);
    1012             :                                 } else {
    1013          16 :                                         CHECK_VALUE_STRING(tctx, owner, ips1[j].owner);
    1014             :                                 }
    1015          19 :                                 break;
    1016             :                         }
    1017             :                 }
    1018             : 
    1019          19 :                 if (found) continue;
    1020             : 
    1021           0 :                 CHECK_VALUE_STRING(tctx, addr, "not found in address list");
    1022             :         }
    1023          12 :         talloc_free(pull_names.out.names);
    1024          12 :         return true;
    1025             : }
    1026             : 
    1027          11 : static char *test_nbt_winsrepl_scope_string(TALLOC_CTX *mem_ctx, uint8_t count)
    1028             : {
    1029             :         char *res;
    1030             :         uint8_t i;
    1031             : 
    1032          11 :         res = talloc_array(mem_ctx, char, count+1);
    1033          11 :         if (res == NULL) {
    1034           0 :                 return NULL;
    1035             :         }
    1036             : 
    1037         531 :         for (i=0; i < count; i++) {
    1038         520 :                 res[i] = '0' + (i%10);
    1039             :         }
    1040             : 
    1041          11 :         res[count] = '\0';
    1042             : 
    1043          11 :         talloc_set_name_const(res, res);
    1044             : 
    1045          11 :         return res;
    1046             : }
    1047             : 
    1048           1 : static bool test_conflict_same_owner(struct torture_context *tctx, 
    1049             :                                                                          struct test_wrepl_conflict_conn *ctx)
    1050             : {
    1051           1 :         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          12 :         struct nbt_name names[] = {
    1059             :                 _NBT_NAME("_SAME_OWNER_A", 0x00, NULL),
    1060           1 :                 _NBT_NAME("_SAME_OWNER_A", 0x00,
    1061             :                           test_nbt_winsrepl_scope_string(tctx, 1)),
    1062           1 :                 _NBT_NAME("_SAME_OWNER_A", 0x00,
    1063             :                           test_nbt_winsrepl_scope_string(tctx, 2)),
    1064           1 :                 _NBT_NAME("_SAME_OWNER_A", 0x00,
    1065             :                           test_nbt_winsrepl_scope_string(tctx, 3)),
    1066           1 :                 _NBT_NAME("_SAME_OWNER_A", 0x00,
    1067             :                           test_nbt_winsrepl_scope_string(tctx, 4)),
    1068           1 :                 _NBT_NAME("_SAME_OWNER_A", 0x00,
    1069             :                           test_nbt_winsrepl_scope_string(tctx, 5)),
    1070           1 :                 _NBT_NAME("_SAME_OWNER_A", 0x00,
    1071             :                           test_nbt_winsrepl_scope_string(tctx, 6)),
    1072           1 :                 _NBT_NAME("_SAME_OWNER_A", 0x00,
    1073             :                           test_nbt_winsrepl_scope_string(tctx, 7)),
    1074           1 :                 _NBT_NAME("_SAME_OWNER_A", 0x00,
    1075             :                           test_nbt_winsrepl_scope_string(tctx, 8)),
    1076           1 :                 _NBT_NAME("_SAME_OWNER_A", 0x00,
    1077             :                           test_nbt_winsrepl_scope_string(tctx, 9)),
    1078           1 :                 _NBT_NAME("_SAME_OWNER_A", 0x00,
    1079             :                           test_nbt_winsrepl_scope_string(tctx, 237)),
    1080           1 :                 _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           1 :         } 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           1 :         wins_name_tmp   = NULL;
    1181           1 :         wins_name_last  = &wins_name2;
    1182           1 :         wins_name_cur   = &wins_name1;
    1183             : 
    1184          14 :         for (j=0; ret && j < ARRAY_SIZE(names); j++) {
    1185          26 :                 torture_comment(tctx, "Test Replica Conflicts with same owner[%s] for %s\n",
    1186          13 :                         nbt_name_string(ctx, &names[j]), ctx->a.address);
    1187             : 
    1188         169 :                 for(i=0; ret && i < ARRAY_SIZE(records); i++) {
    1189         156 :                         wins_name_tmp   = wins_name_last;
    1190         156 :                         wins_name_last  = wins_name_cur;
    1191         156 :                         wins_name_cur   = wins_name_tmp;
    1192             : 
    1193         156 :                         if (i > 0) {
    1194         715 :                                 torture_comment(tctx, "%s,%s%s vs. %s,%s%s with %s ip(s) => %s\n",
    1195         143 :                                         wrepl_name_type_string(records[i-1].type),
    1196         143 :                                         wrepl_name_state_string(records[i-1].state),
    1197         143 :                                         (records[i-1].is_static?",static":""),
    1198             :                                         wrepl_name_type_string(records[i].type),
    1199             :                                         wrepl_name_state_string(records[i].state),
    1200         143 :                                         (records[i].is_static?",static":""),
    1201         143 :                                         (records[i-1].ips==records[i].ips?"same":"different"),
    1202             :                                         "REPLACE");
    1203             :                         }
    1204             : 
    1205         156 :                         wins_name_cur->name  = &names[j];
    1206         156 :                         wins_name_cur->flags = WREPL_NAME_FLAGS(records[i].type,
    1207             :                                                                    records[i].state,
    1208             :                                                                    records[i].node,
    1209             :                                                                    records[i].is_static);
    1210         156 :                         wins_name_cur->id    = ++ctx->a.max_version;
    1211         156 :                         if (wins_name_cur->flags & 2) {
    1212          78 :                                 wins_name_cur->addresses.addresses.num_ips = records[i].num_ips;
    1213          78 :                                 wins_name_cur->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
    1214             :                                                                              records[i].ips);
    1215             :                         } else {
    1216          78 :                                 wins_name_cur->addresses.ip = records[i].ips[0].ip;
    1217             :                         }
    1218         156 :                         wins_name_cur->unknown       = "255.255.255.255";
    1219             : 
    1220         156 :                         ret &= test_wrepl_update_one(tctx, ctx, &ctx->a,wins_name_cur);
    1221         156 :                         if (records[i].state == WREPL_STATE_RELEASED) {
    1222          13 :                                 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->a, wins_name_last, false);
    1223          13 :                                 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->a, wins_name_cur, false);
    1224             :                         } else {
    1225         143 :                                 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->a, wins_name_cur, true);
    1226             :                         }
    1227             : 
    1228             :                         /* the first one is a cleanup run */
    1229         156 :                         if (!ret && i == 0) ret = true;
    1230             : 
    1231         156 :                         if (!ret) {
    1232           0 :                                 torture_comment(tctx, "conflict handled wrong or record[%u]: %s\n", i, __location__);
    1233           0 :                                 return ret;
    1234             :                         }
    1235             :                 }
    1236             :         }
    1237           1 :         return ret;
    1238             : }
    1239             : 
    1240           1 : static bool test_conflict_different_owner(struct torture_context *tctx, 
    1241             :                                                                                   struct test_wrepl_conflict_conn *ctx)
    1242             : {
    1243           1 :         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         247 :         } 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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .merge_owner    = &ctx->b,
    4485             :                 }
    4486             :         },
    4487             :         {
    4488             :                 .line   = __location__,
    4489             :                 .name   = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
    4490             :                 .cleanup= true,
    4491             :                 .r1     = {
    4492           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :                         .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           1 :         wins_name_r1    = &wins_name1;
    4836           1 :         wins_name_r2    = &wins_name2;
    4837             : 
    4838           1 :         torture_comment(tctx, "Test Replica Conflicts with different owners\n");
    4839             : 
    4840         122 :         for(i=0; ret && i < ARRAY_SIZE(records); i++) {
    4841             : 
    4842         121 :                 if (!records[i].extra && !records[i].cleanup) {
    4843             :                         /* we should test the worst cases */
    4844          94 :                         if (records[i].r2.apply_expected && records[i].r1.ips==records[i].r2.ips) {
    4845           0 :                                 torture_comment(tctx, "(%s) Programmer error, invalid record[%u]: %s\n",
    4846             :                                         __location__, i, records[i].line);
    4847           0 :                                 return false;
    4848          94 :                         } else if (!records[i].r2.apply_expected && records[i].r1.ips!=records[i].r2.ips) {
    4849           0 :                                 torture_comment(tctx, "(%s) Programmer error, invalid record[%u]: %s\n",
    4850             :                                         __location__, i, records[i].line);
    4851           0 :                                 return false;
    4852             :                         }
    4853             :                 }
    4854             : 
    4855         121 :                 if (!records[i].cleanup) {
    4856             :                         const char *expected;
    4857             :                         const char *ips;
    4858             : 
    4859         111 :                         if (records[i].r2.sgroup_merge) {
    4860           7 :                                 expected = "SGROUP_MERGE";
    4861         104 :                         } else if (records[i].r2.apply_expected) {
    4862          70 :                                 expected = "REPLACE";
    4863             :                         } else {
    4864          34 :                                 expected = "NOT REPLACE";
    4865             :                         }
    4866             : 
    4867         111 :                         if (!records[i].r1.ips && !records[i].r2.ips) {
    4868           0 :                                 ips = "with no ip(s)";
    4869         111 :                         } else if (records[i].r1.ips==records[i].r2.ips) {
    4870          33 :                                 ips = "with same ip(s)";
    4871             :                         } else {
    4872          78 :                                 ips = "with different ip(s)";
    4873             :                         }
    4874             : 
    4875         333 :                         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         111 :                                 (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         111 :                                 (records[i].r2.is_static?",static":""),
    4882         111 :                                 (records[i].comment?records[i].comment:ips),
    4883             :                                 expected);
    4884             :                 }
    4885             : 
    4886             :                 /*
    4887             :                  * Setup R1
    4888             :                  */
    4889         121 :                 wins_name_r1->name   = &records[i].name;
    4890         121 :                 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         121 :                 wins_name_r1->id     = ++records[i].r1.owner->max_version;
    4895         121 :                 if (wins_name_r1->flags & 2) {
    4896          70 :                         wins_name_r1->addresses.addresses.num_ips = records[i].r1.num_ips;
    4897          70 :                         wins_name_r1->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
    4898             :                                                                     records[i].r1.ips);
    4899             :                 } else {
    4900          51 :                         wins_name_r1->addresses.ip = records[i].r1.ips[0].ip;
    4901             :                 }
    4902         121 :                 wins_name_r1->unknown        = "255.255.255.255";
    4903             : 
    4904             :                 /* now apply R1 */
    4905         121 :                 ret &= test_wrepl_update_one(tctx, ctx, records[i].r1.owner, wins_name_r1);
    4906         121 :                 ret &= test_wrepl_is_applied(tctx, ctx, records[i].r1.owner,
    4907         121 :                                              wins_name_r1, records[i].r1.apply_expected);
    4908             : 
    4909             :                 /*
    4910             :                  * Setup R2
    4911             :                  */
    4912         121 :                 wins_name_r2->name   = &records[i].name;
    4913         121 :                 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         121 :                 wins_name_r2->id     = ++records[i].r2.owner->max_version;
    4918         121 :                 if (wins_name_r2->flags & 2) {
    4919          68 :                         wins_name_r2->addresses.addresses.num_ips = records[i].r2.num_ips;
    4920          68 :                         wins_name_r2->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
    4921             :                                                                     records[i].r2.ips);
    4922             :                 } else {
    4923          53 :                         wins_name_r2->addresses.ip = records[i].r2.ips[0].ip;
    4924             :                 }
    4925         121 :                 wins_name_r2->unknown        = "255.255.255.255";
    4926             : 
    4927             :                 /* now apply R2 */
    4928         121 :                 ret &= test_wrepl_update_one(tctx, ctx, records[i].r2.owner, wins_name_r2);
    4929         121 :                 if (records[i].r1.state == WREPL_STATE_RELEASED) {
    4930          32 :                         ret &= test_wrepl_is_applied(tctx, ctx, records[i].r1.owner,
    4931             :                                                      wins_name_r1, false);
    4932          89 :                 } else if (records[i].r2.sgroup_merge) {
    4933           7 :                         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          82 :                 } else if (records[i].r1.owner != records[i].r2.owner) {
    4940             :                         bool _expected;
    4941          78 :                         _expected = (records[i].r1.apply_expected && !records[i].r2.apply_expected);
    4942          78 :                         ret &= test_wrepl_is_applied(tctx, ctx, records[i].r1.owner,
    4943             :                                                      wins_name_r1, _expected);
    4944             :                 }
    4945         121 :                 if (records[i].r2.state == WREPL_STATE_RELEASED) {
    4946           0 :                         ret &= test_wrepl_is_applied(tctx, ctx, records[i].r2.owner,
    4947             :                                                      wins_name_r2, false);
    4948         121 :                 } else if (!records[i].r2.sgroup_merge) {
    4949         114 :                         ret &= test_wrepl_is_applied(tctx, ctx, records[i].r2.owner,
    4950         114 :                                                      wins_name_r2, records[i].r2.apply_expected);
    4951             :                 }
    4952             : 
    4953         121 :                 if (records[i].r2.sgroup_cleanup) {
    4954           8 :                         if (!ret) {
    4955           0 :                                 torture_comment(tctx, "failed before sgroup_cleanup record[%u]: %s\n", i, records[i].line);
    4956           0 :                                 return ret;
    4957             :                         }
    4958             : 
    4959             :                         /* clean up the SGROUP record */
    4960           8 :                         wins_name_r1->name   = &records[i].name;
    4961           8 :                         wins_name_r1->flags  = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
    4962             :                                                                    WREPL_STATE_ACTIVE,
    4963             :                                                                    WREPL_NODE_B, false);
    4964           8 :                         wins_name_r1->id     = ++records[i].r1.owner->max_version;
    4965           8 :                         wins_name_r1->addresses.addresses.num_ips = 0;
    4966           8 :                         wins_name_r1->addresses.addresses.ips     = NULL;
    4967           8 :                         wins_name_r1->unknown        = "255.255.255.255";
    4968           8 :                         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           8 :                         if (records[i].r2.sgroup_merge && records[i].r2.num_ips) {
    4972           1 :                                 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           8 :                         wins_name_r2->name   = &records[i].name;
    4982           8 :                         wins_name_r2->flags  = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
    4983             :                                                                    WREPL_STATE_ACTIVE,
    4984             :                                                                    WREPL_NODE_B, false);
    4985           8 :                         wins_name_r2->id     = ++records[i].r2.owner->max_version;
    4986           8 :                         wins_name_r2->addresses.addresses.num_ips = 0;
    4987           8 :                         wins_name_r2->addresses.addresses.ips     = NULL;
    4988           8 :                         wins_name_r2->unknown        = "255.255.255.255";
    4989           8 :                         ret &= test_wrepl_update_one(tctx, ctx, records[i].r2.owner, wins_name_r2);
    4990             : 
    4991             :                         /* take ownership of the SGROUP record */
    4992           8 :                         wins_name_r2->name   = &records[i].name;
    4993           8 :                         wins_name_r2->flags  = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
    4994             :                                                                    WREPL_STATE_ACTIVE,
    4995             :                                                                    WREPL_NODE_B, false);
    4996           8 :                         wins_name_r2->id     = ++records[i].r2.owner->max_version;
    4997           8 :                         wins_name_r2->addresses.addresses.num_ips = ARRAY_SIZE(addresses_B_1);
    4998           8 :                         wins_name_r2->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
    4999             :                                                                     addresses_B_1);
    5000           8 :                         wins_name_r2->unknown        = "255.255.255.255";
    5001           8 :                         ret &= test_wrepl_update_one(tctx, ctx, records[i].r2.owner, wins_name_r2);
    5002           8 :                         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           8 :                         wins_name_r2->name   = &records[i].name;
    5006           8 :                         wins_name_r2->flags  = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
    5007             :                                                                    WREPL_STATE_TOMBSTONE,
    5008             :                                                                    WREPL_NODE_B, false);
    5009           8 :                         wins_name_r2->id     = ++records[i].r2.owner->max_version;
    5010           8 :                         wins_name_r2->addresses.addresses.num_ips = ARRAY_SIZE(addresses_B_1);
    5011           8 :                         wins_name_r2->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
    5012             :                                                                     addresses_B_1);
    5013           8 :                         wins_name_r2->unknown        = "255.255.255.255";
    5014           8 :                         ret &= test_wrepl_update_one(tctx, ctx, records[i].r2.owner, wins_name_r2);
    5015           8 :                         ret &= test_wrepl_is_applied(tctx, ctx, records[i].r2.owner, wins_name_r2, true);
    5016             : 
    5017           8 :                         if (!ret) {
    5018           0 :                                 torture_comment(tctx, "failed in sgroup_cleanup record[%u]: %s\n", i, records[i].line);
    5019           0 :                                 return ret;
    5020             :                         }
    5021             :                 }
    5022             : 
    5023             :                 /* the first one is a cleanup run */
    5024         121 :                 if (!ret && i == 0) ret = true;
    5025             : 
    5026         121 :                 if (!ret) {
    5027           0 :                         torture_comment(tctx, "conflict handled wrong or record[%u]: %s\n", i, records[i].line);
    5028           0 :                         return ret;
    5029             :                 }
    5030             :         }
    5031             : 
    5032           1 :         return ret;
    5033             : }
    5034             : 
    5035           1 : static bool test_conflict_owned_released_vs_replica(struct torture_context *tctx,
    5036             :                                                                                                         struct test_wrepl_conflict_conn *ctx)
    5037             : {
    5038           1 :         bool ret = true;
    5039             :         NTSTATUS status;
    5040             :         struct wrepl_wins_name wins_name_;
    5041           1 :         struct wrepl_wins_name *wins_name = &wins_name_;
    5042             :         struct nbt_name_register name_register_;
    5043           1 :         struct nbt_name_register *name_register = &name_register_;
    5044             :         struct nbt_name_release release_;
    5045           1 :         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         193 :         } 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           1 :                         .num_ips        = ctx->addresses_best_num,
    5080           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5089           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5103           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5126           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5135           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5149           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5175           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5184           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5198           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5221           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5230           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5244           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5270           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5279           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5293           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5316           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5325           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5339           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5365           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5374           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5388           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5411           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5420           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5434           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5460           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5469           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5483           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5506           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5515           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5529           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5555           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5564           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5578           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5601           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5610           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5624           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5650           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5659           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5673           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5696           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5705           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5719           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5745           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5754           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5768           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5791           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5800           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5814           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5840           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5849           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5863           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5886           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5895           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5909           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5935           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5944           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5958           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5981           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    5990           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6004           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6030           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6039           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6053           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6076           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6085           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6099           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6125           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6134           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6148           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6171           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6180           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6194           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6220           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6229           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6243           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6266           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6275           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6289           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6315           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6324           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6338           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6361           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6370           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6384           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6410           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6419           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6433           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6456           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6465           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6479           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6505           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6514           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6528           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6551           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6560           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6574           1 :                         .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           1 :         torture_comment(tctx, "Test Replica records vs. owned released records\n");
    6590             : 
    6591          65 :         for(i=0; ret && i < ARRAY_SIZE(records); i++) {
    6592          64 :                 torture_comment(tctx, "%s => %s\n", nbt_name_string(ctx, &records[i].name),
    6593          64 :                         (records[i].replica.apply_expected?"REPLACE":"NOT REPLACE"));
    6594             : 
    6595             :                 /*
    6596             :                  * Setup Register
    6597             :                  */
    6598          64 :                 name_register->in.name               = records[i].name;
    6599          64 :                 name_register->in.dest_addr  = ctx->address;
    6600          64 :                 name_register->in.dest_port  = lpcfg_nbt_port(tctx->lp_ctx);
    6601          64 :                 name_register->in.address    = records[i].wins.ips[0].ip;
    6602          64 :                 name_register->in.nb_flags   = records[i].wins.nb_flags;
    6603          64 :                 name_register->in.register_demand= false;
    6604          64 :                 name_register->in.broadcast  = false;
    6605          64 :                 name_register->in.multi_homed        = records[i].wins.mhomed;
    6606          64 :                 name_register->in.ttl                = 300000;
    6607          64 :                 name_register->in.timeout    = 70;
    6608          64 :                 name_register->in.retries    = 0;
    6609             : 
    6610          64 :                 status = nbt_name_register(ctx->nbtsock, ctx, name_register);
    6611          64 :                 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
    6612           0 :                         torture_comment(tctx, "No response from %s for name register\n", ctx->address);
    6613           0 :                         ret = false;
    6614             :                 }
    6615          64 :                 if (!NT_STATUS_IS_OK(status)) {
    6616           0 :                         torture_comment(tctx, "Bad response from %s for name register - %s\n",
    6617             :                                ctx->address, nt_errstr(status));
    6618           0 :                         ret = false;
    6619             :                 }
    6620          64 :                 CHECK_VALUE(tctx, name_register->out.rcode, 0);
    6621          64 :                 CHECK_VALUE_STRING(tctx, name_register->out.reply_from, ctx->address);
    6622          64 :                 CHECK_VALUE(tctx, name_register->out.name.type, records[i].name.type);
    6623          64 :                 CHECK_VALUE_STRING(tctx, name_register->out.name.name, records[i].name.name);
    6624          64 :                 CHECK_VALUE_STRING(tctx, name_register->out.name.scope, records[i].name.scope);
    6625          64 :                 CHECK_VALUE_STRING(tctx, name_register->out.reply_addr, records[i].wins.ips[0].ip);
    6626             : 
    6627             :                 /* release the record */
    6628          64 :                 release->in.name     = records[i].name;
    6629          64 :                 release->in.dest_port   = lpcfg_nbt_port(tctx->lp_ctx);
    6630          64 :                 release->in.dest_addr        = ctx->address;
    6631          64 :                 release->in.address  = records[i].wins.ips[0].ip;
    6632          64 :                 release->in.nb_flags = records[i].wins.nb_flags;
    6633          64 :                 release->in.broadcast        = false;
    6634          64 :                 release->in.timeout  = 30;
    6635          64 :                 release->in.retries  = 0;
    6636             : 
    6637          64 :                 status = nbt_name_release(ctx->nbtsock, ctx, release);
    6638          64 :                 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
    6639           0 :                         torture_comment(tctx, "No response from %s for name release\n", ctx->address);
    6640           0 :                         return false;
    6641             :                 }
    6642          64 :                 if (!NT_STATUS_IS_OK(status)) {
    6643           0 :                         torture_comment(tctx, "Bad response from %s for name query - %s\n",
    6644             :                                ctx->address, nt_errstr(status));
    6645           0 :                         return false;
    6646             :                 }
    6647          64 :                 CHECK_VALUE(tctx, release->out.rcode, 0);
    6648             : 
    6649             :                 /*
    6650             :                  * Setup Replica
    6651             :                  */
    6652          64 :                 wins_name->name              = &records[i].name;
    6653          64 :                 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          64 :                 wins_name->id                = ++ctx->b.max_version;
    6658          64 :                 if (wins_name->flags & 2) {
    6659          32 :                         wins_name->addresses.addresses.num_ips = records[i].replica.num_ips;
    6660          32 :                         wins_name->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
    6661             :                                                                  records[i].replica.ips);
    6662             :                 } else {
    6663          32 :                         wins_name->addresses.ip = records[i].replica.ips[0].ip;
    6664             :                 }
    6665          64 :                 wins_name->unknown   = "255.255.255.255";
    6666             : 
    6667          64 :                 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
    6668          64 :                 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name,
    6669          64 :                                              records[i].replica.apply_expected);
    6670             : 
    6671          64 :                 if (records[i].replica.apply_expected) {
    6672          52 :                         wins_name->name              = &records[i].name;
    6673          52 :                         wins_name->flags     = WREPL_NAME_FLAGS(WREPL_TYPE_UNIQUE,
    6674             :                                                                    WREPL_STATE_TOMBSTONE,
    6675             :                                                                    WREPL_NODE_B, false);
    6676          52 :                         wins_name->id                = ++ctx->b.max_version;
    6677          52 :                         wins_name->addresses.ip = addresses_B_1[0].ip;
    6678          52 :                         wins_name->unknown   = "255.255.255.255";
    6679             : 
    6680          52 :                         ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
    6681          52 :                         ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name, true);
    6682             :                 } else {
    6683          12 :                         release->in.name     = records[i].name;
    6684          12 :                         release->in.dest_addr        = ctx->address;
    6685          12 :                         release->in.dest_port        = lpcfg_nbt_port(tctx->lp_ctx);
    6686          12 :                         release->in.address  = records[i].wins.ips[0].ip;
    6687          12 :                         release->in.nb_flags = records[i].wins.nb_flags;
    6688          12 :                         release->in.broadcast        = false;
    6689          12 :                         release->in.timeout  = 30;
    6690          12 :                         release->in.retries  = 0;
    6691             : 
    6692          12 :                         status = nbt_name_release(ctx->nbtsock, ctx, release);
    6693          12 :                         if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
    6694           0 :                                 torture_comment(tctx, "No response from %s for name release\n", ctx->address);
    6695           0 :                                 return false;
    6696             :                         }
    6697          12 :                         if (!NT_STATUS_IS_OK(status)) {
    6698           0 :                                 torture_comment(tctx, "Bad response from %s for name query - %s\n",
    6699             :                                        ctx->address, nt_errstr(status));
    6700           0 :                                 return false;
    6701             :                         }
    6702          12 :                         CHECK_VALUE(tctx, release->out.rcode, 0);
    6703             :                 }
    6704          64 :                 if (!ret) {
    6705           0 :                         torture_comment(tctx, "conflict handled wrong or record[%u]: %s\n", i, records[i].line);
    6706           0 :                         return ret;
    6707             :                 }
    6708             :         }
    6709             : 
    6710           1 :         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           1 : static bool test_conflict_owned_active_vs_replica(struct torture_context *tctx,
    6755             :                                                                                                   struct test_wrepl_conflict_conn *ctx)
    6756             : {
    6757           1 :         bool ret = true;
    6758             :         NTSTATUS status;
    6759             :         struct wrepl_wins_name wins_name_;
    6760           1 :         struct wrepl_wins_name *wins_name = &wins_name_;
    6761             :         struct nbt_name_register name_register_;
    6762           1 :         struct nbt_name_register *name_register = &name_register_;
    6763             :         struct nbt_name_release release_;
    6764           1 :         struct nbt_name_release *release = &release_;
    6765             :         uint32_t i;
    6766         306 :         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           1 :                         .num_ips        = ctx->addresses_best_num,
    6781           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6793           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6808           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6836           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6866           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6894           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6906           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6921           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6951           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6964           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    6979           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7007           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7019           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7034           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7064           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7077           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7092           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7120           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7132           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7147           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7177           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7189           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7204           1 :                         .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           1 :                         .num_ips        = ctx->addresses_all_num,
    7216           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7231           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7259           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7289           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7317           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7329           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7344           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7374           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7386           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7401           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7428           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7440           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7455           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7485           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7497           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7512           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7539           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7551           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7566           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7596           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7608           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7623           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7650           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7662           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7677           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7707           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7719           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7734           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7761           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7773           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7788           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7818           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7830           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7845           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7872           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7884           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7899           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7929           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7941           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7956           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7983           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    7995           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8010           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8040           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8052           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8067           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8094           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8106           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8121           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8151           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8163           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8178           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8206           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8236           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8264           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8276           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8291           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8321           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8334           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8349           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8377           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8389           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8404           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8434           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8447           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8462           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8490           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8502           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8517           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8547           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8559           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8574           1 :                         .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           1 :                         .num_ips        = ctx->addresses_all_num,
    8586           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8601           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8629           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8659           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8687           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8699           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8714           1 :                         .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           1 :                 .skip   = (ctx->addresses_all_num < 3),
    8743             :                 .wins   = {
    8744             :                         .nb_flags       = 0,
    8745             :                         .mhomed         = true,
    8746           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    8747           1 :                         .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           1 :                         .num_ips        = ctx->addresses_all_num,
    8759           1 :                         .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           1 :                 .skip   = (ctx->addresses_mhomed_num < 2),
    8772             :                 .wins   = {
    8773             :                         .nb_flags       = 0,
    8774             :                         .mhomed         = true,
    8775           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    8776           1 :                         .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           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    8788           1 :                         .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           1 :                 .skip   = (ctx->addresses_mhomed_num < 2),
    8801             :                 .wins   = {
    8802             :                         .nb_flags       = 0,
    8803             :                         .mhomed         = true,
    8804           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    8805           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8818           1 :                         .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           1 :                 .skip   = (ctx->addresses_all_num < 3),
    8831             :                 .wins   = {
    8832             :                         .nb_flags       = 0,
    8833             :                         .mhomed         = true,
    8834           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    8835           1 :                         .ips            = ctx->addresses_mhomed,
    8836             :                         .apply_expected = true
    8837             :                 },
    8838             :                 .defend = {
    8839             :                         .timeout        = 10,
    8840             :                         .positive       = true,
    8841           1 :                         .num_ips        = ctx->addresses_all_num,
    8842           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8850           1 :                         .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           1 :                 .skip   = (ctx->addresses_all_num < 2),
    8865             :                 .wins   = {
    8866             :                         .nb_flags       = 0,
    8867             :                         .mhomed         = true,
    8868           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    8869           1 :                         .ips            = ctx->addresses_mhomed,
    8870             :                         .apply_expected = true
    8871             :                 },
    8872             :                 .defend = {
    8873             :                         .timeout        = 10,
    8874             :                         .positive       = true,
    8875           1 :                         .num_ips        = ctx->addresses_best_num,
    8876           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8885           1 :                         .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           1 :                 .skip   = (ctx->addresses_all_num < 2),
    8898             :                 .wins   = {
    8899             :                         .nb_flags       = 0,
    8900             :                         .mhomed         = true,
    8901           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    8902           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8917           1 :                         .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           1 :                 .skip   = (ctx->addresses_mhomed_num < 2),
    8930             :                 .wins   = {
    8931             :                         .nb_flags       = 0,
    8932             :                         .mhomed         = true,
    8933           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    8934           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8947           1 :                         .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           1 :                 .skip   = (ctx->addresses_all_num < 2),
    8964             :                 .wins   = {
    8965             :                         .nb_flags       = 0,
    8966             :                         .mhomed         = true,
    8967           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    8968           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    8981           1 :                         .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           1 :                 .skip   = (ctx->addresses_all_num < 2),
    8996             :                 .wins   = {
    8997             :                         .nb_flags       = 0,
    8998             :                         .mhomed         = false,
    8999           1 :                         .num_ips        = ctx->addresses_best_num,
    9000           1 :                         .ips            = ctx->addresses_best,
    9001             :                         .apply_expected = true
    9002             :                 },
    9003             :                 .defend = {
    9004             :                         .timeout        = 10,
    9005             :                         .positive       = true,
    9006           1 :                         .num_ips        = ctx->addresses_best2_num,
    9007           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best2_num,
    9016           1 :                         .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           1 :                 .skip   = (ctx->addresses_all_num < 3),
    9029             :                 .wins   = {
    9030             :                         .nb_flags       = 0,
    9031             :                         .mhomed         = false,
    9032           1 :                         .num_ips        = ctx->addresses_best_num,
    9033           1 :                         .ips            = ctx->addresses_best,
    9034             :                         .apply_expected = true
    9035             :                 },
    9036             :                 .defend = {
    9037             :                         .timeout        = 10,
    9038             :                         .positive       = true,
    9039           1 :                         .num_ips        = ctx->addresses_all_num,
    9040           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best2_num,
    9048           1 :                         .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           1 :                 .skip   = (ctx->addresses_all_num < 3),
    9061             :                 .wins   = {
    9062             :                         .nb_flags       = 0,
    9063             :                         .mhomed         = false,
    9064           1 :                         .num_ips        = ctx->addresses_best_num,
    9065           1 :                         .ips            = ctx->addresses_best,
    9066             :                         .apply_expected = true
    9067             :                 },
    9068             :                 .defend = {
    9069             :                         .timeout        = 10,
    9070             :                         .positive       = true,
    9071           1 :                         .num_ips        = ctx->addresses_all_num,
    9072           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best2_num,
    9080           1 :                         .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           1 :                 .skip   = (ctx->addresses_all_num < 3),
    9096             :                 .wins   = {
    9097             :                         .nb_flags       = NBT_NM_GROUP,
    9098             :                         .mhomed         = false,
    9099           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    9100           1 :                         .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           1 :                 .skip   = (ctx->addresses_all_num < 3),
    9124             :                 .wins   = {
    9125             :                         .nb_flags       = NBT_NM_GROUP,
    9126             :                         .mhomed         = false,
    9127           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    9128           1 :                         .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           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    9140           1 :                         .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           1 :                 .skip   = (ctx->addresses_all_num < 3),
    9152             :                 .wins   = {
    9153             :                         .nb_flags       = NBT_NM_GROUP,
    9154             :                         .mhomed         = false,
    9155           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    9156           1 :                         .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           1 :                         .num_ips        = ctx->addresses_all_num,
    9168           1 :                         .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           1 :                 .skip   = (ctx->addresses_all_num < 3),
    9180             :                 .wins   = {
    9181             :                         .nb_flags       = NBT_NM_GROUP,
    9182             :                         .mhomed         = false,
    9183           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    9184           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    9196           1 :                         .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           1 :                 .skip   = (ctx->addresses_all_num < 3),
    9208             :                 .wins   = {
    9209             :                         .nb_flags       = NBT_NM_GROUP,
    9210             :                         .mhomed         = false,
    9211           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    9212           1 :                         .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           1 :                 .skip   = (ctx->addresses_all_num < 3),
    9236             :                 .wins   = {
    9237             :                         .nb_flags       = NBT_NM_GROUP,
    9238             :                         .mhomed         = false,
    9239           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    9240           1 :                         .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           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    9252           1 :                         .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           1 :                 .skip   = (ctx->addresses_all_num < 3),
    9264             :                 .wins   = {
    9265             :                         .nb_flags       = NBT_NM_GROUP,
    9266             :                         .mhomed         = false,
    9267           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    9268           1 :                         .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           1 :                         .num_ips        = ctx->addresses_all_num,
    9280           1 :                         .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           1 :                 .skip   = (ctx->addresses_all_num < 3),
    9292             :                 .wins   = {
    9293             :                         .nb_flags       = NBT_NM_GROUP,
    9294             :                         .mhomed         = false,
    9295           1 :                         .num_ips        = ctx->addresses_mhomed_num,
    9296           1 :                         .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           1 :                         .num_ips        = ctx->addresses_best_num,
    9308           1 :                         .ips            = ctx->addresses_best,
    9309             :                         .apply_expected = false
    9310             :                 },
    9311             :         },
    9312             :         };
    9313             : 
    9314           1 :         if (!ctx->nbtsock_srv) {
    9315           0 :                 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           0 :                 return true;
    9318             :         }
    9319             : 
    9320           1 :         torture_comment(tctx, "Test Replica records vs. owned active records\n");
    9321             : 
    9322          90 :         for(i=0; ret && i < ARRAY_SIZE(records); i++) {
    9323             :                 struct timeval end;
    9324          89 :                 struct test_conflict_owned_active_vs_replica_struct record = records[i];
    9325          89 :                 uint32_t j, count = 1;
    9326             :                 const char *action;
    9327             : 
    9328          89 :                 if (records[i].wins.mhomed || records[i].name.type == 0x1C) {
    9329          49 :                         count = records[i].wins.num_ips;
    9330             :                 }
    9331             : 
    9332          89 :                 if (records[i].section) {
    9333           3 :                         torture_comment(tctx, "%s\n", records[i].section);
    9334             :                 }
    9335             : 
    9336          89 :                 if (records[i].skip) {
    9337           0 :                         torture_comment(tctx, "%s => SKIPPED\n", nbt_name_string(ctx, &records[i].name));
    9338           0 :                         continue;
    9339             :                 }
    9340             : 
    9341          89 :                 if (records[i].replica.mhomed_merge) {
    9342           5 :                         action = "MHOMED_MERGE";
    9343          84 :                 } else if (records[i].replica.sgroup_merge) {
    9344           4 :                         action = "SGROUP_MERGE";
    9345          80 :                 } else if (records[i].replica.apply_expected) {
    9346          23 :                         action = "REPLACE";
    9347             :                 } else {
    9348          57 :                         action = "NOT REPLACE";
    9349             :                 }
    9350             : 
    9351         267 :                 torture_comment(tctx, "%s%s%s => %s\n",
    9352          89 :                         nbt_name_string(ctx, &records[i].name),
    9353          89 :                         (records[i].comment?": ":""),
    9354          89 :                         (records[i].comment?records[i].comment:""),
    9355             :                         action);
    9356             : 
    9357             :                 /* Prepare for multi homed registration */
    9358          89 :                 ZERO_STRUCT(records[i].defend);
    9359          89 :                 records[i].defend.timeout       = 10;
    9360          89 :                 records[i].defend.positive      = true;
    9361          89 :                 nbt_set_incoming_handler(ctx->nbtsock_srv,
    9362             :                                          test_conflict_owned_active_vs_replica_handler,
    9363          89 :                                          &records[i]);
    9364          89 :                 if (ctx->nbtsock_srv2) {
    9365          89 :                         nbt_set_incoming_handler(ctx->nbtsock_srv2,
    9366             :                                                  test_conflict_owned_active_vs_replica_handler,
    9367          89 :                                                  &records[i]);
    9368             :                 }
    9369             : 
    9370             :                 /*
    9371             :                  * Setup Register
    9372             :                  */
    9373         194 :                 for (j=0; j < count; j++) {
    9374             :                         struct nbt_name_request *req;
    9375             : 
    9376         105 :                         name_register->in.name               = records[i].name;
    9377         105 :                         name_register->in.dest_addr  = ctx->address;
    9378         105 :                         name_register->in.dest_port     = lpcfg_nbt_port(tctx->lp_ctx);
    9379         105 :                         name_register->in.address    = records[i].wins.ips[j].ip;
    9380         105 :                         name_register->in.nb_flags   = records[i].wins.nb_flags;
    9381         105 :                         name_register->in.register_demand= false;
    9382         105 :                         name_register->in.broadcast  = false;
    9383         105 :                         name_register->in.multi_homed        = records[i].wins.mhomed;
    9384         105 :                         name_register->in.ttl                = 300000;
    9385         105 :                         name_register->in.timeout    = 70;
    9386         105 :                         name_register->in.retries    = 0;
    9387             : 
    9388         105 :                         req = nbt_name_register_send(ctx->nbtsock, name_register);
    9389             : 
    9390             :                         /* push the request on the wire */
    9391         105 :                         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         105 :                         if (records[i].wins.mhomed && j > 0) {
    9399           8 :                                 end = timeval_current_ofs(records[i].defend.timeout,0);
    9400           8 :                                 records[i].defend.ret = true;
    9401          32 :                                 while (records[i].defend.timeout > 0) {
    9402          16 :                                         tevent_loop_once(ctx->nbtsock_srv->event_ctx);
    9403          16 :                                         if (timeval_expired(&end)) break;
    9404             :                                 }
    9405           8 :                                 ret &= records[i].defend.ret;
    9406             :                         }
    9407             : 
    9408         105 :                         status = nbt_name_register_recv(req, ctx, name_register);
    9409         105 :                         if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
    9410           0 :                                 torture_comment(tctx, "No response from %s for name register\n", ctx->address);
    9411           0 :                                 ret = false;
    9412             :                         }
    9413         105 :                         if (!NT_STATUS_IS_OK(status)) {
    9414           0 :                                 torture_comment(tctx, "Bad response from %s for name register - %s\n",
    9415             :                                        ctx->address, nt_errstr(status));
    9416           0 :                                 ret = false;
    9417             :                         }
    9418         105 :                         CHECK_VALUE(tctx, name_register->out.rcode, 0);
    9419         105 :                         CHECK_VALUE_STRING(tctx, name_register->out.reply_from, ctx->address);
    9420         105 :                         CHECK_VALUE(tctx, name_register->out.name.type, records[i].name.type);
    9421         105 :                         CHECK_VALUE_STRING(tctx, name_register->out.name.name, records[i].name.name);
    9422         105 :                         CHECK_VALUE_STRING(tctx, name_register->out.name.scope, records[i].name.scope);
    9423         105 :                         CHECK_VALUE_STRING(tctx, name_register->out.reply_addr, records[i].wins.ips[j].ip);
    9424             :                 }
    9425             : 
    9426             :                 /* Prepare for the current test */
    9427          89 :                 records[i].defend = record.defend;
    9428          89 :                 nbt_set_incoming_handler(ctx->nbtsock_srv,
    9429             :                                          test_conflict_owned_active_vs_replica_handler,
    9430          89 :                                          &records[i]);
    9431          89 :                 if (ctx->nbtsock_srv2) {
    9432          89 :                         nbt_set_incoming_handler(ctx->nbtsock_srv2,
    9433             :                                                  test_conflict_owned_active_vs_replica_handler,
    9434          89 :                                                  &records[i]);
    9435             :                 }
    9436             : 
    9437             :                 /*
    9438             :                  * Setup Replica
    9439             :                  */
    9440          89 :                 wins_name->name              = &records[i].name;
    9441          89 :                 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          89 :                 wins_name->id                = ++ctx->b.max_version;
    9446          89 :                 if (wins_name->flags & 2) {
    9447          50 :                         wins_name->addresses.addresses.num_ips = records[i].replica.num_ips;
    9448          50 :                         wins_name->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
    9449             :                                                                  records[i].replica.ips);
    9450             :                 } else {
    9451          39 :                         wins_name->addresses.ip = records[i].replica.ips[0].ip;
    9452             :                 }
    9453          89 :                 wins_name->unknown   = "255.255.255.255";
    9454             : 
    9455          89 :                 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          89 :                 end = timeval_current_ofs(records[i].defend.timeout,0);
    9462          89 :                 records[i].defend.ret = true;
    9463         178 :                 while (records[i].defend.timeout > 0) {
    9464           0 :                         tevent_loop_once(ctx->nbtsock_srv->event_ctx);
    9465           0 :                         if (timeval_expired(&end)) break;
    9466             :                 }
    9467          89 :                 ret &= records[i].defend.ret;
    9468             : 
    9469          89 :                 if (records[i].defend.late_release) {
    9470           2 :                         records[i].defend = record.defend;
    9471           2 :                         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           2 :                         end = timeval_current_ofs(records[i].defend.timeout,0);
    9477           2 :                         records[i].defend.ret = true;
    9478           5 :                         while (records[i].defend.timeout > 0) {
    9479           2 :                                 tevent_loop_once(ctx->nbtsock_srv->event_ctx);
    9480           2 :                                 if (timeval_expired(&end)) break;
    9481             :                         }
    9482           2 :                         ret &= records[i].defend.ret;
    9483             :                 }
    9484             : 
    9485          89 :                 if (records[i].replica.mhomed_merge) {
    9486          10 :                         ret &= test_wrepl_mhomed_merged(tctx, ctx, &ctx->c,
    9487             :                                                         records[i].wins.num_ips, records[i].wins.ips,
    9488           5 :                                                         &ctx->b,
    9489             :                                                         records[i].replica.num_ips, records[i].replica.ips,
    9490             :                                                         wins_name);
    9491          84 :                 } else if (records[i].replica.sgroup_merge) {
    9492           4 :                         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          80 :                         ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name,
    9500          80 :                                                      records[i].replica.apply_expected);
    9501             :                 }
    9502             : 
    9503         155 :                 if (records[i].replica.apply_expected ||
    9504          66 :                     records[i].replica.mhomed_merge) {
    9505          28 :                         wins_name->name              = &records[i].name;
    9506          28 :                         wins_name->flags     = WREPL_NAME_FLAGS(WREPL_TYPE_UNIQUE,
    9507             :                                                                    WREPL_STATE_TOMBSTONE,
    9508             :                                                                    WREPL_NODE_B, false);
    9509          28 :                         wins_name->id                = ++ctx->b.max_version;
    9510          28 :                         wins_name->addresses.ip = addresses_B_1[0].ip;
    9511          28 :                         wins_name->unknown   = "255.255.255.255";
    9512             : 
    9513          28 :                         ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
    9514          28 :                         ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name, true);
    9515             :                 } else {
    9516         132 :                         for (j=0; j < count; j++) {
    9517          71 :                                 struct nbt_name_socket *nbtsock = ctx->nbtsock;
    9518             : 
    9519          71 :                                 if (ctx->myaddr2 && strcmp(records[i].wins.ips[j].ip, ctx->myaddr2->addr) == 0) {
    9520          10 :                                         nbtsock = ctx->nbtsock2;
    9521             :                                 }
    9522             : 
    9523          71 :                                 release->in.name     = records[i].name;
    9524          71 :                                 release->in.dest_addr        = ctx->address;
    9525          71 :                                 release->in.dest_port   = lpcfg_nbt_port(tctx->lp_ctx);
    9526          71 :                                 release->in.address  = records[i].wins.ips[j].ip;
    9527          71 :                                 release->in.nb_flags = records[i].wins.nb_flags;
    9528          71 :                                 release->in.broadcast        = false;
    9529          71 :                                 release->in.timeout  = 30;
    9530          71 :                                 release->in.retries  = 0;
    9531             : 
    9532          71 :                                 status = nbt_name_release(nbtsock, ctx, release);
    9533          71 :                                 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
    9534           0 :                                         torture_comment(tctx, "No response from %s for name release\n", ctx->address);
    9535           0 :                                         return false;
    9536             :                                 }
    9537          71 :                                 if (!NT_STATUS_IS_OK(status)) {
    9538           0 :                                         torture_comment(tctx, "Bad response from %s for name query - %s\n",
    9539             :                                                ctx->address, nt_errstr(status));
    9540           0 :                                         return false;
    9541             :                                 }
    9542          71 :                                 CHECK_VALUE(tctx, release->out.rcode, 0);
    9543             :                         }
    9544             : 
    9545          61 :                         if (records[i].replica.sgroup_merge) {
    9546             :                                 /* clean up the SGROUP record */
    9547           4 :                                 wins_name->name              = &records[i].name;
    9548           4 :                                 wins_name->flags     = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
    9549             :                                                                            WREPL_STATE_ACTIVE,
    9550             :                                                                            WREPL_NODE_B, false);
    9551           4 :                                 wins_name->id                = ++ctx->b.max_version;
    9552           4 :                                 wins_name->addresses.addresses.num_ips = 0;
    9553           4 :                                 wins_name->addresses.addresses.ips     = NULL;
    9554           4 :                                 wins_name->unknown   = "255.255.255.255";
    9555           4 :                                 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
    9556             : 
    9557             :                                 /* take ownership of the SGROUP record */
    9558           4 :                                 wins_name->name              = &records[i].name;
    9559           4 :                                 wins_name->flags     = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
    9560             :                                                                            WREPL_STATE_ACTIVE,
    9561             :                                                                            WREPL_NODE_B, false);
    9562           4 :                                 wins_name->id                = ++ctx->b.max_version;
    9563           4 :                                 wins_name->addresses.addresses.num_ips = ARRAY_SIZE(addresses_B_1);
    9564           4 :                                 wins_name->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
    9565             :                                                                          addresses_B_1);
    9566           4 :                                 wins_name->unknown   = "255.255.255.255";
    9567           4 :                                 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
    9568           4 :                                 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name, true);
    9569             : 
    9570             :                                 /* overwrite the SGROUP record with unique,tombstone */
    9571           4 :                                 wins_name->name              = &records[i].name;
    9572           4 :                                 wins_name->flags     = WREPL_NAME_FLAGS(WREPL_TYPE_UNIQUE,
    9573             :                                                                            WREPL_STATE_TOMBSTONE,
    9574             :                                                                            WREPL_NODE_B, false);
    9575           4 :                                 wins_name->id                = ++ctx->b.max_version;
    9576           4 :                                 wins_name->addresses.ip = addresses_A_1[0].ip;
    9577           4 :                                 wins_name->unknown   = "255.255.255.255";
    9578           4 :                                 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
    9579           4 :                                 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name, true);
    9580             :                         }
    9581             :                 }
    9582             : 
    9583          89 :                 if (!ret) {
    9584           0 :                         torture_comment(tctx, "conflict handled wrong or record[%u]: %s\n", i, records[i].line);
    9585           0 :                         return ret;
    9586             :                 }
    9587             :         }
    9588             : 
    9589           1 :         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          29 : 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          29 :         struct test_conflict_owned_active_vs_replica_struct *rec = 
    9623             :                 (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private_data;
    9624             : 
    9625          29 :         _NBT_ASSERT(req_packet->qdcount, 1);
    9626          29 :         _NBT_ASSERT(req_packet->questions[0].question_type, NBT_QTYPE_NETBIOS);
    9627          29 :         _NBT_ASSERT(req_packet->questions[0].question_class, NBT_QCLASS_IP);
    9628             : 
    9629          29 :         name = &req_packet->questions[0].name;
    9630             : 
    9631          29 :         _NBT_ASSERT_STRING(name->name, rec->name.name);
    9632          29 :         _NBT_ASSERT(name->type, rec->name.type);
    9633          29 :         _NBT_ASSERT_STRING(name->scope, rec->name.scope);
    9634             : 
    9635          29 :         _NBT_ASSERT(rec->defend.expect_release, false);
    9636             : 
    9637          29 :         rep_packet = talloc_zero(nbtsock, struct nbt_name_packet);
    9638          29 :         if (rep_packet == NULL) return;
    9639             : 
    9640          29 :         rep_packet->name_trn_id      = req_packet->name_trn_id;
    9641          29 :         rep_packet->ancount  = 1;
    9642             : 
    9643          29 :         rep_packet->answers  = talloc_array(rep_packet, struct nbt_res_rec, 1);
    9644          29 :         if (rep_packet->answers == NULL) return;
    9645             : 
    9646          29 :         rep_packet->answers[0].name      = *name;
    9647          29 :         rep_packet->answers[0].rr_class  = NBT_QCLASS_IP;
    9648          29 :         rep_packet->answers[0].ttl       = 0;
    9649             : 
    9650          29 :         if (rec->defend.positive) {
    9651             :                 uint32_t i, num_ips;
    9652             :                 const struct wrepl_ip *ips;             
    9653             : 
    9654          24 :                 if (rec->defend.num_ips > 0) {
    9655          10 :                         num_ips = rec->defend.num_ips;
    9656          10 :                         ips     = rec->defend.ips;
    9657             :                 } else {
    9658          14 :                         num_ips = rec->wins.num_ips;
    9659          14 :                         ips     = rec->wins.ips;
    9660             :                 }
    9661             : 
    9662             :                 /* send a positive reply */
    9663          24 :                 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          24 :                 rep_packet->answers[0].rr_type   = NBT_QTYPE_NETBIOS;
    9671             : 
    9672          24 :                 rep_packet->answers[0].rdata.netbios.length = num_ips*6;
    9673          48 :                 rep_packet->answers[0].rdata.netbios.addresses = 
    9674          48 :                         talloc_array(rep_packet->answers, struct nbt_rdata_address, num_ips);
    9675          24 :                 if (rep_packet->answers[0].rdata.netbios.addresses == NULL) return;
    9676             : 
    9677          78 :                 for (i=0; i < num_ips; i++) {
    9678          54 :                         struct nbt_rdata_address *addr = 
    9679          54 :                                 &rep_packet->answers[0].rdata.netbios.addresses[i];
    9680          54 :                         addr->nb_flags       = rec->wins.nb_flags;
    9681          54 :                         addr->ipaddr = ips[i].ip;
    9682             :                 }
    9683          24 :                 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           5 :                 rep_packet->operation        =
    9688             :                                         NBT_FLAG_REPLY |
    9689             :                                         NBT_OPCODE_QUERY |
    9690             :                                         NBT_FLAG_AUTHORITATIVE |
    9691             :                                         NBT_RCODE_NAM;
    9692             : 
    9693           5 :                 rep_packet->answers[0].rr_type   = NBT_QTYPE_NULL;
    9694             : 
    9695           5 :                 ZERO_STRUCT(rep_packet->answers[0].rdata);
    9696             : 
    9697           5 :                 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          29 :         nbt_name_reply_send(nbtsock, src, rep_packet);
    9702          29 :         talloc_free(rep_packet);
    9703             : 
    9704             :         /* make sure we push the reply to the wire */
    9705         107 :         while (nbtsock->send_queue) {
    9706          49 :                 tevent_loop_once(nbtsock->event_ctx);
    9707             :         }
    9708          29 :         smb_msleep(1000);
    9709             : 
    9710          29 :         rec->defend.timeout  = 0;
    9711          29 :         rec->defend.ret              = true;
    9712             : }
    9713             : 
    9714           9 : 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           9 :         struct test_conflict_owned_active_vs_replica_struct *rec = 
    9722             :                 (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private_data;
    9723             : 
    9724           9 :         _NBT_ASSERT(req_packet->qdcount, 1);
    9725           9 :         _NBT_ASSERT(req_packet->questions[0].question_type, NBT_QTYPE_NETBIOS);
    9726           9 :         _NBT_ASSERT(req_packet->questions[0].question_class, NBT_QCLASS_IP);
    9727             : 
    9728           9 :         name = &req_packet->questions[0].name;
    9729             : 
    9730           9 :         _NBT_ASSERT_STRING(name->name, rec->name.name);
    9731           9 :         _NBT_ASSERT(name->type, rec->name.type);
    9732           9 :         _NBT_ASSERT_STRING(name->scope, rec->name.scope);
    9733             : 
    9734           9 :         _NBT_ASSERT(rec->defend.expect_release, true);
    9735             : 
    9736           9 :         rep_packet = talloc_zero(nbtsock, struct nbt_name_packet);
    9737           9 :         if (rep_packet == NULL) return;
    9738             : 
    9739           9 :         rep_packet->name_trn_id      = req_packet->name_trn_id;
    9740           9 :         rep_packet->ancount  = 1;
    9741           9 :         rep_packet->operation        =
    9742             :                                 NBT_FLAG_REPLY |
    9743             :                                 NBT_OPCODE_RELEASE |
    9744             :                                 NBT_FLAG_AUTHORITATIVE;
    9745             : 
    9746           9 :         rep_packet->answers  = talloc_array(rep_packet, struct nbt_res_rec, 1);
    9747           9 :         if (rep_packet->answers == NULL) return;
    9748             : 
    9749           9 :         rep_packet->answers[0].name  = *name;
    9750           9 :         rep_packet->answers[0].rr_type       = NBT_QTYPE_NETBIOS;
    9751           9 :         rep_packet->answers[0].rr_class      = NBT_QCLASS_IP;
    9752           9 :         rep_packet->answers[0].ttl   = req_packet->additional[0].ttl;
    9753           9 :         rep_packet->answers[0].rdata    = req_packet->additional[0].rdata;
    9754             : 
    9755           9 :         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           9 :         nbt_name_reply_send(nbtsock, src, rep_packet);
    9759           9 :         talloc_free(rep_packet);
    9760             : 
    9761             :         /* make sure we push the reply to the wire */
    9762          35 :         while (nbtsock->send_queue) {
    9763          17 :                 tevent_loop_once(nbtsock->event_ctx);
    9764             :         }
    9765           9 :         smb_msleep(1000);
    9766             : 
    9767           9 :         rec->defend.timeout  = 0;
    9768           9 :         rec->defend.ret              = true;
    9769             : }
    9770             : 
    9771          38 : 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          38 :         struct test_conflict_owned_active_vs_replica_struct *rec = 
    9776             :                 (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private_data;
    9777          38 :         struct nbt_name *name = &req_packet->questions[0].name;
    9778             : 
    9779          38 :         if (req_packet->operation & NBT_FLAG_BROADCAST) {
    9780           0 :                 torture_comment(rec->tctx,
    9781             :                         "%s: incoming packet name[%s] flags[0x%08X] from[%s]\n",
    9782             :                         __location__,
    9783           0 :                         nbt_name_string(rec->tctx, name),
    9784           0 :                         req_packet->operation,
    9785             :                         src->addr);
    9786           0 :                 return;
    9787             :         }
    9788             : 
    9789          38 :         rec->defend.ret = false;
    9790             : 
    9791          38 :         switch (req_packet->operation & NBT_OPCODE) {
    9792          29 :         case NBT_OPCODE_QUERY:
    9793          29 :                 test_conflict_owned_active_vs_replica_handler_query(nbtsock, req_packet, src);
    9794          29 :                 break;
    9795           9 :         case NBT_OPCODE_RELEASE:
    9796           9 :                 test_conflict_owned_active_vs_replica_handler_release(nbtsock, req_packet, src);
    9797           9 :                 break;
    9798           0 :         default:
    9799           0 :                 torture_comment(rec->tctx,
    9800             :                         "%s: unexpected packet name[%s] flags[0x%08X] from[%s]\n",
    9801             :                         __location__,
    9802           0 :                         nbt_name_string(rec->tctx, name),
    9803           0 :                         req_packet->operation,
    9804             :                         src->addr);
    9805           0 :                 _NBT_ASSERT((req_packet->operation & NBT_OPCODE), NBT_OPCODE_QUERY);
    9806           0 :                 break;
    9807             :         }
    9808             : }
    9809             : 
    9810             : /*
    9811             :   test WINS replication replica conflicts operations
    9812             : */
    9813           1 : static bool torture_nbt_winsreplication_replica(struct torture_context *tctx)
    9814             : {
    9815           1 :         bool ret = true;
    9816             :         struct test_wrepl_conflict_conn *ctx;
    9817             : 
    9818             :         const char *address;
    9819             :         struct nbt_name name;
    9820             : 
    9821           1 :         if (!torture_nbt_get_name(tctx, &name, &address))
    9822           0 :                 return false;
    9823             : 
    9824           1 :         ctx = test_create_conflict_ctx(tctx, address);
    9825           1 :         if (!ctx) return false;
    9826             : 
    9827           1 :         ret &= test_conflict_same_owner(tctx, ctx);
    9828           1 :         ret &= test_conflict_different_owner(tctx, ctx);
    9829             : 
    9830           1 :         return ret;
    9831             : }
    9832             : 
    9833             : /*
    9834             :   test WINS replication owned conflicts operations
    9835             : */
    9836           1 : static bool torture_nbt_winsreplication_owned(struct torture_context *tctx)
    9837             : {
    9838             :         const char *address;
    9839             :         struct nbt_name name;
    9840           1 :         bool ret = true;
    9841             :         struct test_wrepl_conflict_conn *ctx;
    9842             : 
    9843           1 :         if (torture_setting_bool(tctx, "quick", false))
    9844           0 :                 torture_skip(tctx, 
    9845             :                         "skip NBT-WINSREPLICATION-OWNED test in quick test mode\n");
    9846             : 
    9847           1 :         if (!torture_nbt_get_name(tctx, &name, &address))
    9848           0 :                 return false;
    9849             : 
    9850           1 :         ctx = test_create_conflict_ctx(tctx, address);
    9851           1 :         torture_assert(tctx, ctx != NULL, "Creating context failed");
    9852             : 
    9853           1 :         ret &= test_conflict_owned_released_vs_replica(tctx, ctx);
    9854           1 :         ret &= test_conflict_owned_active_vs_replica(tctx, ctx);
    9855             : 
    9856           1 :         return ret;
    9857             : }
    9858             : 
    9859             : /*
    9860             :   test simple WINS replication operations
    9861             : */
    9862        2353 : struct torture_suite *torture_nbt_winsreplication(TALLOC_CTX *mem_ctx)
    9863             : {
    9864        2353 :         struct torture_suite *suite = torture_suite_create(
    9865             :                 mem_ctx, "winsreplication");
    9866             :         struct torture_tcase *tcase;
    9867             : 
    9868        2353 :         tcase = torture_suite_add_simple_test(suite, "assoc_ctx1", 
    9869             :                                              test_assoc_ctx1);
    9870        2353 :         tcase->tests->dangerous = true;
    9871             : 
    9872        2353 :         torture_suite_add_simple_test(suite, "assoc_ctx2", test_assoc_ctx2);
    9873             :         
    9874        2353 :         torture_suite_add_simple_test(suite, "wins_replication",
    9875             :                                       test_wins_replication);
    9876             : 
    9877        2353 :         torture_suite_add_simple_test(suite, "replica",
    9878             :                                       torture_nbt_winsreplication_replica);
    9879             : 
    9880        2353 :         torture_suite_add_simple_test(suite, "owned",
    9881             :                                       torture_nbt_winsreplication_owned);
    9882             : 
    9883        2353 :         return suite;
    9884             : }

Generated by: LCOV version 1.13