2 Unix SMB/CIFS implementation.
4 WINS replication testing
6 Copyright (C) Andrew Tridgell 2005
7 Copyright (C) Stefan Metzmacher 2005
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.
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.
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/>.
24 #include "libcli/wrepl/winsrepl.h"
25 #include "lib/events/events.h"
26 #include "lib/socket/socket.h"
27 #include "libcli/resolve/resolve.h"
28 #include "system/network.h"
29 #include "lib/socket/netif.h"
30 #include "librpc/gen_ndr/ndr_nbt.h"
31 #include "torture/torture.h"
32 #include "torture/nbt/proto.h"
33 #include "param/param.h"
35 #define CHECK_STATUS(tctx, status, correct) \
36 torture_assert_ntstatus_equal(tctx, status, correct, \
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", \
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))
49 #define CHECK_VALUE_STRING(tctx, v, correct) \
50 torture_assert_str_equal(tctx, v, correct, "Invalid value")
52 #define _NBT_NAME(n,t,s) {\
58 static const char *wrepl_name_type_string(enum wrepl_name_type type)
61 case WREPL_TYPE_UNIQUE: return "UNIQUE";
62 case WREPL_TYPE_GROUP: return "GROUP";
63 case WREPL_TYPE_SGROUP: return "SGROUP";
64 case WREPL_TYPE_MHOMED: return "MHOMED";
66 return "UNKNOWN_TYPE";
69 static const char *wrepl_name_state_string(enum wrepl_name_state state)
72 case WREPL_STATE_ACTIVE: return "ACTIVE";
73 case WREPL_STATE_RELEASED: return "RELEASED";
74 case WREPL_STATE_TOMBSTONE: return "TOMBSTONE";
75 case WREPL_STATE_RESERVED: return "RESERVED";
77 return "UNKNOWN_STATE";
81 test how assoc_ctx's are only usable on the connection
84 static bool test_assoc_ctx1(struct torture_context *tctx)
87 struct wrepl_request *req;
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_pull_table pull_table;
93 struct wrepl_packet packet;
94 struct wrepl_send_ctrl ctrl;
95 struct wrepl_packet *rep_packet;
96 struct wrepl_associate_stop assoc_stop;
101 if (!torture_nbt_get_name(tctx, &name, &address))
104 torture_comment(tctx, "Test if assoc_ctx is only valid on the conection it was created on\n");
106 wrepl_socket1 = wrepl_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
107 wrepl_socket2 = wrepl_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
109 torture_comment(tctx, "Setup 2 wrepl connections\n");
110 status = wrepl_connect(wrepl_socket1, lp_resolve_context(tctx->lp_ctx), wrepl_best_ip(tctx->lp_ctx, address), address);
111 CHECK_STATUS(tctx, status, NT_STATUS_OK);
113 status = wrepl_connect(wrepl_socket2, lp_resolve_context(tctx->lp_ctx), wrepl_best_ip(tctx->lp_ctx, address), address);
114 CHECK_STATUS(tctx, status, NT_STATUS_OK);
116 torture_comment(tctx, "Send a start association request (conn1)\n");
117 status = wrepl_associate(wrepl_socket1, &associate1);
118 CHECK_STATUS(tctx, status, NT_STATUS_OK);
120 torture_comment(tctx, "association context (conn1): 0x%x\n", associate1.out.assoc_ctx);
122 torture_comment(tctx, "Send a start association request (conn2)\n");
123 status = wrepl_associate(wrepl_socket2, &associate2);
124 CHECK_STATUS(tctx, status, NT_STATUS_OK);
126 torture_comment(tctx, "association context (conn2): 0x%x\n", associate2.out.assoc_ctx);
128 torture_comment(tctx, "Send a replication table query, with assoc 1 (conn2), the anwser should be on conn1\n");
130 packet.opcode = WREPL_OPCODE_BITS;
131 packet.assoc_ctx = associate1.out.assoc_ctx;
132 packet.mess_type = WREPL_REPLICATION;
133 packet.message.replication.command = WREPL_REPL_TABLE_QUERY;
135 ctrl.send_only = true;
136 req = wrepl_request_send(wrepl_socket2, &packet, &ctrl);
137 status = wrepl_request_recv(req, tctx, &rep_packet);
138 CHECK_STATUS(tctx, status, NT_STATUS_OK);
140 torture_comment(tctx, "Send a association request (conn2), to make sure the last request was ignored\n");
141 status = wrepl_associate(wrepl_socket2, &associate2);
142 CHECK_STATUS(tctx, status, NT_STATUS_OK);
144 torture_comment(tctx, "Send a replication table query, with invalid assoc (conn1), receive answer from conn2\n");
145 pull_table.in.assoc_ctx = 0;
146 req = wrepl_pull_table_send(wrepl_socket1, &pull_table);
147 status = wrepl_request_recv(req, tctx, &rep_packet);
148 CHECK_STATUS(tctx, status, NT_STATUS_OK);
150 torture_comment(tctx, "Send a association request (conn1), to make sure the last request was handled correct\n");
151 status = wrepl_associate(wrepl_socket1, &associate2);
152 CHECK_STATUS(tctx, status, NT_STATUS_OK);
154 assoc_stop.in.assoc_ctx = associate1.out.assoc_ctx;
155 assoc_stop.in.reason = 4;
156 torture_comment(tctx, "Send a association stop request (conn1), reson: %u\n", assoc_stop.in.reason);
157 status = wrepl_associate_stop(wrepl_socket1, &assoc_stop);
158 CHECK_STATUS(tctx, status, NT_STATUS_END_OF_FILE);
160 assoc_stop.in.assoc_ctx = associate2.out.assoc_ctx;
161 assoc_stop.in.reason = 0;
162 torture_comment(tctx, "Send a association stop request (conn2), reson: %u\n", assoc_stop.in.reason);
163 status = wrepl_associate_stop(wrepl_socket2, &assoc_stop);
164 CHECK_STATUS(tctx, status, NT_STATUS_OK);
166 torture_comment(tctx, "Close 2 wrepl connections\n");
167 talloc_free(wrepl_socket1);
168 talloc_free(wrepl_socket2);
173 test if we always get back the same assoc_ctx
175 static bool test_assoc_ctx2(struct torture_context *tctx)
177 struct wrepl_socket *wrepl_socket;
178 struct wrepl_associate associate;
180 struct nbt_name name;
184 if (!torture_nbt_get_name(tctx, &name, &address))
187 torture_comment(tctx, "Test if we always get back the same assoc_ctx\n");
189 wrepl_socket = wrepl_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
191 torture_comment(tctx, "Setup wrepl connections\n");
192 status = wrepl_connect(wrepl_socket, lp_resolve_context(tctx->lp_ctx), wrepl_best_ip(tctx->lp_ctx, address), address);
193 CHECK_STATUS(tctx, status, NT_STATUS_OK);
195 torture_comment(tctx, "Send 1st start association request\n");
196 status = wrepl_associate(wrepl_socket, &associate);
197 CHECK_STATUS(tctx, status, NT_STATUS_OK);
198 assoc_ctx1 = associate.out.assoc_ctx;
199 torture_comment(tctx, "1st association context: 0x%x\n", associate.out.assoc_ctx);
201 torture_comment(tctx, "Send 2nd start association request\n");
202 status = wrepl_associate(wrepl_socket, &associate);
203 torture_assert_ntstatus_ok(tctx, status, "2nd start association failed");
204 torture_assert(tctx, associate.out.assoc_ctx == assoc_ctx1,
205 "Different context returned");
206 torture_comment(tctx, "2nd association context: 0x%x\n", associate.out.assoc_ctx);
208 torture_comment(tctx, "Send 3rd start association request\n");
209 status = wrepl_associate(wrepl_socket, &associate);
210 torture_assert(tctx, associate.out.assoc_ctx == assoc_ctx1,
211 "Different context returned");
212 CHECK_STATUS(tctx, status, NT_STATUS_OK);
213 torture_comment(tctx, "3rd association context: 0x%x\n", associate.out.assoc_ctx);
215 torture_comment(tctx, "Close wrepl connections\n");
216 talloc_free(wrepl_socket);
222 display a replication entry
224 static void display_entry(struct torture_context *tctx, struct wrepl_name *name)
228 torture_comment(tctx, "%s\n", nbt_name_string(tctx, &name->name));
229 torture_comment(tctx, "\tTYPE:%u STATE:%u NODE:%u STATIC:%u VERSION_ID: %llu\n",
230 name->type, name->state, name->node, name->is_static, (long long)name->version_id);
231 torture_comment(tctx, "\tRAW_FLAGS: 0x%08X OWNER: %-15s\n",
232 name->raw_flags, name->owner);
233 for (i=0;i<name->num_addresses;i++) {
234 torture_comment(tctx, "\tADDR: %-15s OWNER: %-15s\n",
235 name->addresses[i].address, name->addresses[i].owner);
240 test a full replication dump from a WINS server
242 static bool test_wins_replication(struct torture_context *tctx)
244 struct wrepl_socket *wrepl_socket;
247 struct wrepl_associate associate;
248 struct wrepl_pull_table pull_table;
249 struct wrepl_pull_names pull_names;
250 struct nbt_name name;
253 if (!torture_nbt_get_name(tctx, &name, &address))
256 torture_comment(tctx, "Test one pull replication cycle\n");
258 wrepl_socket = wrepl_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
260 torture_comment(tctx, "Setup wrepl connections\n");
261 status = wrepl_connect(wrepl_socket, lp_resolve_context(tctx->lp_ctx), wrepl_best_ip(tctx->lp_ctx, address), address);
262 CHECK_STATUS(tctx, status, NT_STATUS_OK);
264 torture_comment(tctx, "Send a start association request\n");
266 status = wrepl_associate(wrepl_socket, &associate);
267 CHECK_STATUS(tctx, status, NT_STATUS_OK);
269 torture_comment(tctx, "association context: 0x%x\n", associate.out.assoc_ctx);
271 torture_comment(tctx, "Send a replication table query\n");
272 pull_table.in.assoc_ctx = associate.out.assoc_ctx;
274 status = wrepl_pull_table(wrepl_socket, tctx, &pull_table);
275 if (NT_STATUS_EQUAL(NT_STATUS_NETWORK_ACCESS_DENIED,status)) {
276 struct wrepl_packet packet;
277 struct wrepl_request *req;
280 packet.opcode = WREPL_OPCODE_BITS;
281 packet.assoc_ctx = associate.out.assoc_ctx;
282 packet.mess_type = WREPL_STOP_ASSOCIATION;
283 packet.message.stop.reason = 0;
285 req = wrepl_request_send(wrepl_socket, &packet, NULL);
288 torture_fail(tctx, "We are not a valid pull partner for the server");
290 CHECK_STATUS(tctx, status, NT_STATUS_OK);
292 torture_comment(tctx, "Found %d replication partners\n", pull_table.out.num_partners);
294 for (i=0;i<pull_table.out.num_partners;i++) {
295 struct wrepl_wins_owner *partner = &pull_table.out.partners[i];
296 torture_comment(tctx, "%s max_version=%6llu min_version=%6llu type=%d\n",
298 (long long)partner->max_version,
299 (long long)partner->min_version,
302 pull_names.in.assoc_ctx = associate.out.assoc_ctx;
303 pull_names.in.partner = *partner;
305 status = wrepl_pull_names(wrepl_socket, tctx, &pull_names);
306 CHECK_STATUS(tctx, status, NT_STATUS_OK);
308 torture_comment(tctx, "Received %d names\n", pull_names.out.num_names);
310 for (j=0;j<pull_names.out.num_names;j++) {
311 display_entry(tctx, &pull_names.out.names[j]);
315 torture_comment(tctx, "Close wrepl connections\n");
316 talloc_free(wrepl_socket);
320 struct test_wrepl_conflict_conn {
322 struct wrepl_socket *pull;
325 #define TEST_OWNER_A_ADDRESS "127.65.65.1"
326 #define TEST_ADDRESS_A_PREFIX "127.0.65"
327 #define TEST_OWNER_B_ADDRESS "127.66.66.1"
328 #define TEST_ADDRESS_B_PREFIX "127.0.66"
329 #define TEST_OWNER_X_ADDRESS "127.88.88.1"
330 #define TEST_ADDRESS_X_PREFIX "127.0.88"
332 struct wrepl_wins_owner a, b, c, x;
334 struct socket_address *myaddr;
335 struct socket_address *myaddr2;
336 struct nbt_name_socket *nbtsock;
337 struct nbt_name_socket *nbtsock2;
339 struct nbt_name_socket *nbtsock_srv;
340 struct nbt_name_socket *nbtsock_srv2;
342 uint32_t addresses_best_num;
343 struct wrepl_ip *addresses_best;
345 uint32_t addresses_best2_num;
346 struct wrepl_ip *addresses_best2;
348 uint32_t addresses_all_num;
349 struct wrepl_ip *addresses_all;
351 uint32_t addresses_mhomed_num;
352 struct wrepl_ip *addresses_mhomed;
355 static const struct wrepl_ip addresses_A_1[] = {
357 .owner = TEST_OWNER_A_ADDRESS,
358 .ip = TEST_ADDRESS_A_PREFIX".1"
361 static const struct wrepl_ip addresses_A_2[] = {
363 .owner = TEST_OWNER_A_ADDRESS,
364 .ip = TEST_ADDRESS_A_PREFIX".2"
367 static const struct wrepl_ip addresses_A_3_4[] = {
369 .owner = TEST_OWNER_A_ADDRESS,
370 .ip = TEST_ADDRESS_A_PREFIX".3"
373 .owner = TEST_OWNER_A_ADDRESS,
374 .ip = TEST_ADDRESS_A_PREFIX".4"
377 static const struct wrepl_ip addresses_A_3_4_X_3_4[] = {
379 .owner = TEST_OWNER_A_ADDRESS,
380 .ip = TEST_ADDRESS_A_PREFIX".3"
383 .owner = TEST_OWNER_A_ADDRESS,
384 .ip = TEST_ADDRESS_A_PREFIX".4"
387 .owner = TEST_OWNER_X_ADDRESS,
388 .ip = TEST_ADDRESS_X_PREFIX".3"
391 .owner = TEST_OWNER_X_ADDRESS,
392 .ip = TEST_ADDRESS_X_PREFIX".4"
395 static const struct wrepl_ip addresses_A_3_4_B_3_4[] = {
397 .owner = TEST_OWNER_A_ADDRESS,
398 .ip = TEST_ADDRESS_A_PREFIX".3"
401 .owner = TEST_OWNER_A_ADDRESS,
402 .ip = TEST_ADDRESS_A_PREFIX".4"
405 .owner = TEST_OWNER_B_ADDRESS,
406 .ip = TEST_ADDRESS_B_PREFIX".3"
409 .owner = TEST_OWNER_B_ADDRESS,
410 .ip = TEST_ADDRESS_B_PREFIX".4"
413 static const struct wrepl_ip addresses_A_3_4_OWNER_B[] = {
415 .owner = TEST_OWNER_B_ADDRESS,
416 .ip = TEST_ADDRESS_A_PREFIX".3"
419 .owner = TEST_OWNER_B_ADDRESS,
420 .ip = TEST_ADDRESS_A_PREFIX".4"
423 static const struct wrepl_ip addresses_A_3_4_X_3_4_OWNER_B[] = {
425 .owner = TEST_OWNER_B_ADDRESS,
426 .ip = TEST_ADDRESS_A_PREFIX".3"
429 .owner = TEST_OWNER_B_ADDRESS,
430 .ip = TEST_ADDRESS_A_PREFIX".4"
433 .owner = TEST_OWNER_B_ADDRESS,
434 .ip = TEST_ADDRESS_X_PREFIX".3"
437 .owner = TEST_OWNER_B_ADDRESS,
438 .ip = TEST_ADDRESS_X_PREFIX".4"
442 static const struct wrepl_ip addresses_A_3_4_X_1_2[] = {
444 .owner = TEST_OWNER_A_ADDRESS,
445 .ip = TEST_ADDRESS_A_PREFIX".3"
448 .owner = TEST_OWNER_A_ADDRESS,
449 .ip = TEST_ADDRESS_A_PREFIX".4"
452 .owner = TEST_OWNER_X_ADDRESS,
453 .ip = TEST_ADDRESS_X_PREFIX".1"
456 .owner = TEST_OWNER_X_ADDRESS,
457 .ip = TEST_ADDRESS_X_PREFIX".2"
461 static const struct wrepl_ip addresses_B_1[] = {
463 .owner = TEST_OWNER_B_ADDRESS,
464 .ip = TEST_ADDRESS_B_PREFIX".1"
467 static const struct wrepl_ip addresses_B_2[] = {
469 .owner = TEST_OWNER_B_ADDRESS,
470 .ip = TEST_ADDRESS_B_PREFIX".2"
473 static const struct wrepl_ip addresses_B_3_4[] = {
475 .owner = TEST_OWNER_B_ADDRESS,
476 .ip = TEST_ADDRESS_B_PREFIX".3"
479 .owner = TEST_OWNER_B_ADDRESS,
480 .ip = TEST_ADDRESS_B_PREFIX".4"
483 static const struct wrepl_ip addresses_B_3_4_X_3_4[] = {
485 .owner = TEST_OWNER_B_ADDRESS,
486 .ip = TEST_ADDRESS_B_PREFIX".3"
489 .owner = TEST_OWNER_B_ADDRESS,
490 .ip = TEST_ADDRESS_B_PREFIX".4"
493 .owner = TEST_OWNER_X_ADDRESS,
494 .ip = TEST_ADDRESS_X_PREFIX".3"
497 .owner = TEST_OWNER_X_ADDRESS,
498 .ip = TEST_ADDRESS_X_PREFIX".4"
501 static const struct wrepl_ip addresses_B_3_4_X_1_2[] = {
503 .owner = TEST_OWNER_B_ADDRESS,
504 .ip = TEST_ADDRESS_B_PREFIX".3"
507 .owner = TEST_OWNER_B_ADDRESS,
508 .ip = TEST_ADDRESS_B_PREFIX".4"
511 .owner = TEST_OWNER_X_ADDRESS,
512 .ip = TEST_ADDRESS_X_PREFIX".1"
515 .owner = TEST_OWNER_X_ADDRESS,
516 .ip = TEST_ADDRESS_X_PREFIX".2"
520 static const struct wrepl_ip addresses_X_1_2[] = {
522 .owner = TEST_OWNER_X_ADDRESS,
523 .ip = TEST_ADDRESS_X_PREFIX".1"
526 .owner = TEST_OWNER_X_ADDRESS,
527 .ip = TEST_ADDRESS_X_PREFIX".2"
530 static const struct wrepl_ip addresses_X_3_4[] = {
532 .owner = TEST_OWNER_X_ADDRESS,
533 .ip = TEST_ADDRESS_X_PREFIX".3"
536 .owner = TEST_OWNER_X_ADDRESS,
537 .ip = TEST_ADDRESS_X_PREFIX".4"
541 static struct test_wrepl_conflict_conn *test_create_conflict_ctx(
542 struct torture_context *tctx, const char *address)
544 struct test_wrepl_conflict_conn *ctx;
545 struct wrepl_associate associate;
546 struct wrepl_pull_table pull_table;
547 struct socket_address *nbt_srv_addr;
550 struct interface *ifaces;
552 ctx = talloc_zero(tctx, struct test_wrepl_conflict_conn);
553 if (!ctx) return NULL;
555 ctx->address = address;
556 ctx->pull = wrepl_socket_init(ctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
557 if (!ctx->pull) return NULL;
559 torture_comment(tctx, "Setup wrepl conflict pull connection\n");
560 status = wrepl_connect(ctx->pull, lp_resolve_context(tctx->lp_ctx), wrepl_best_ip(tctx->lp_ctx, ctx->address), ctx->address);
561 if (!NT_STATUS_IS_OK(status)) return NULL;
563 status = wrepl_associate(ctx->pull, &associate);
564 if (!NT_STATUS_IS_OK(status)) return NULL;
566 ctx->pull_assoc = associate.out.assoc_ctx;
568 ctx->a.address = TEST_OWNER_A_ADDRESS;
569 ctx->a.max_version = 0;
570 ctx->a.min_version = 0;
573 ctx->b.address = TEST_OWNER_B_ADDRESS;
574 ctx->b.max_version = 0;
575 ctx->b.min_version = 0;
578 ctx->x.address = TEST_OWNER_X_ADDRESS;
579 ctx->x.max_version = 0;
580 ctx->x.min_version = 0;
583 ctx->c.address = address;
584 ctx->c.max_version = 0;
585 ctx->c.min_version = 0;
588 pull_table.in.assoc_ctx = ctx->pull_assoc;
589 status = wrepl_pull_table(ctx->pull, ctx->pull, &pull_table);
590 if (!NT_STATUS_IS_OK(status)) return NULL;
592 for (i=0; i < pull_table.out.num_partners; i++) {
593 if (strcmp(TEST_OWNER_A_ADDRESS,pull_table.out.partners[i].address)==0) {
594 ctx->a.max_version = pull_table.out.partners[i].max_version;
595 ctx->a.min_version = pull_table.out.partners[i].min_version;
597 if (strcmp(TEST_OWNER_B_ADDRESS,pull_table.out.partners[i].address)==0) {
598 ctx->b.max_version = pull_table.out.partners[i].max_version;
599 ctx->b.min_version = pull_table.out.partners[i].min_version;
601 if (strcmp(TEST_OWNER_X_ADDRESS,pull_table.out.partners[i].address)==0) {
602 ctx->x.max_version = pull_table.out.partners[i].max_version;
603 ctx->x.min_version = pull_table.out.partners[i].min_version;
605 if (strcmp(address,pull_table.out.partners[i].address)==0) {
606 ctx->c.max_version = pull_table.out.partners[i].max_version;
607 ctx->c.min_version = pull_table.out.partners[i].min_version;
611 talloc_free(pull_table.out.partners);
613 ctx->nbtsock = nbt_name_socket_init(ctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
614 if (!ctx->nbtsock) return NULL;
616 load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
618 ctx->myaddr = socket_address_from_strings(tctx, ctx->nbtsock->sock->backend_name, iface_best_ip(ifaces, address), 0);
619 if (!ctx->myaddr) return NULL;
621 for (i = 0; i < iface_count(ifaces); i++) {
622 if (strcmp(ctx->myaddr->addr, iface_n_ip(ifaces, i)) == 0) continue;
623 ctx->myaddr2 = socket_address_from_strings(tctx, ctx->nbtsock->sock->backend_name, iface_n_ip(ifaces, i), 0);
624 if (!ctx->myaddr2) return NULL;
628 status = socket_listen(ctx->nbtsock->sock, ctx->myaddr, 0, 0);
629 if (!NT_STATUS_IS_OK(status)) return NULL;
631 ctx->nbtsock_srv = nbt_name_socket_init(ctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
632 if (!ctx->nbtsock_srv) return NULL;
634 /* Make a port 137 version of ctx->myaddr */
635 nbt_srv_addr = socket_address_from_strings(tctx, ctx->nbtsock_srv->sock->backend_name, ctx->myaddr->addr, lp_nbt_port(tctx->lp_ctx));
636 if (!nbt_srv_addr) return NULL;
638 /* And if possible, bind to it. This won't work unless we are root or in sockewrapper */
639 status = socket_listen(ctx->nbtsock_srv->sock, nbt_srv_addr, 0, 0);
640 talloc_free(nbt_srv_addr);
641 if (!NT_STATUS_IS_OK(status)) {
642 /* this isn't fatal */
643 talloc_free(ctx->nbtsock_srv);
644 ctx->nbtsock_srv = NULL;
647 if (ctx->myaddr2 && ctx->nbtsock_srv) {
648 ctx->nbtsock2 = nbt_name_socket_init(ctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
649 if (!ctx->nbtsock2) return NULL;
651 status = socket_listen(ctx->nbtsock2->sock, ctx->myaddr2, 0, 0);
652 if (!NT_STATUS_IS_OK(status)) return NULL;
654 ctx->nbtsock_srv2 = nbt_name_socket_init(ctx, ctx->nbtsock_srv->event_ctx, lp_iconv_convenience(tctx->lp_ctx));
655 if (!ctx->nbtsock_srv2) return NULL;
657 /* Make a port 137 version of ctx->myaddr2 */
658 nbt_srv_addr = socket_address_from_strings(tctx,
659 ctx->nbtsock_srv->sock->backend_name,
661 lp_nbt_port(tctx->lp_ctx));
662 if (!nbt_srv_addr) return NULL;
664 /* And if possible, bind to it. This won't work unless we are root or in sockewrapper */
665 status = socket_listen(ctx->nbtsock_srv2->sock, ctx->myaddr2, 0, 0);
666 talloc_free(nbt_srv_addr);
667 if (!NT_STATUS_IS_OK(status)) {
668 /* this isn't fatal */
669 talloc_free(ctx->nbtsock_srv2);
670 ctx->nbtsock_srv2 = NULL;
674 ctx->addresses_best_num = 1;
675 ctx->addresses_best = talloc_array(ctx, struct wrepl_ip, ctx->addresses_best_num);
676 if (!ctx->addresses_best) return NULL;
677 ctx->addresses_best[0].owner = ctx->b.address;
678 ctx->addresses_best[0].ip = ctx->myaddr->addr;
680 ctx->addresses_all_num = iface_count(ifaces);
681 ctx->addresses_all = talloc_array(ctx, struct wrepl_ip, ctx->addresses_all_num);
682 if (!ctx->addresses_all) return NULL;
683 for (i=0; i < ctx->addresses_all_num; i++) {
684 ctx->addresses_all[i].owner = ctx->b.address;
685 ctx->addresses_all[i].ip = talloc_strdup(ctx->addresses_all, iface_n_ip(ifaces, i));
686 if (!ctx->addresses_all[i].ip) return NULL;
689 if (ctx->nbtsock_srv2) {
690 ctx->addresses_best2_num = 1;
691 ctx->addresses_best2 = talloc_array(ctx, struct wrepl_ip, ctx->addresses_best2_num);
692 if (!ctx->addresses_best2) return NULL;
693 ctx->addresses_best2[0].owner = ctx->b.address;
694 ctx->addresses_best2[0].ip = ctx->myaddr2->addr;
696 ctx->addresses_mhomed_num = 2;
697 ctx->addresses_mhomed = talloc_array(ctx, struct wrepl_ip, ctx->addresses_mhomed_num);
698 if (!ctx->addresses_mhomed) return NULL;
699 ctx->addresses_mhomed[0].owner = ctx->b.address;
700 ctx->addresses_mhomed[0].ip = ctx->myaddr->addr;
701 ctx->addresses_mhomed[1].owner = ctx->b.address;
702 ctx->addresses_mhomed[1].ip = ctx->myaddr2->addr;
708 static bool test_wrepl_update_one(struct torture_context *tctx,
709 struct test_wrepl_conflict_conn *ctx,
710 const struct wrepl_wins_owner *owner,
711 const struct wrepl_wins_name *name)
713 struct wrepl_socket *wrepl_socket;
714 struct wrepl_associate associate;
715 struct wrepl_packet update_packet, repl_send;
716 struct wrepl_table *update;
717 struct wrepl_wins_owner wrepl_wins_owners[1];
718 struct wrepl_packet *repl_recv;
719 struct wrepl_wins_owner *send_request;
720 struct wrepl_send_reply *send_reply;
721 struct wrepl_wins_name wrepl_wins_names[1];
725 wrepl_socket = wrepl_socket_init(ctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
727 status = wrepl_connect(wrepl_socket, lp_resolve_context(tctx->lp_ctx), wrepl_best_ip(tctx->lp_ctx, ctx->address), ctx->address);
728 CHECK_STATUS(tctx, status, NT_STATUS_OK);
730 status = wrepl_associate(wrepl_socket, &associate);
731 CHECK_STATUS(tctx, status, NT_STATUS_OK);
732 assoc_ctx = associate.out.assoc_ctx;
734 /* now send a WREPL_REPL_UPDATE message */
735 ZERO_STRUCT(update_packet);
736 update_packet.opcode = WREPL_OPCODE_BITS;
737 update_packet.assoc_ctx = assoc_ctx;
738 update_packet.mess_type = WREPL_REPLICATION;
739 update_packet.message.replication.command = WREPL_REPL_UPDATE;
740 update = &update_packet.message.replication.info.table;
742 update->partner_count = ARRAY_SIZE(wrepl_wins_owners);
743 update->partners = wrepl_wins_owners;
744 update->initiator = "0.0.0.0";
746 wrepl_wins_owners[0] = *owner;
748 status = wrepl_request(wrepl_socket, wrepl_socket,
749 &update_packet, &repl_recv);
750 CHECK_STATUS(tctx, status, NT_STATUS_OK);
751 CHECK_VALUE(tctx, repl_recv->mess_type, WREPL_REPLICATION);
752 CHECK_VALUE(tctx, repl_recv->message.replication.command, WREPL_REPL_SEND_REQUEST);
753 send_request = &repl_recv->message.replication.info.owner;
755 ZERO_STRUCT(repl_send);
756 repl_send.opcode = WREPL_OPCODE_BITS;
757 repl_send.assoc_ctx = assoc_ctx;
758 repl_send.mess_type = WREPL_REPLICATION;
759 repl_send.message.replication.command = WREPL_REPL_SEND_REPLY;
760 send_reply = &repl_send.message.replication.info.reply;
762 send_reply->num_names = ARRAY_SIZE(wrepl_wins_names);
763 send_reply->names = wrepl_wins_names;
765 wrepl_wins_names[0] = *name;
767 status = wrepl_request(wrepl_socket, wrepl_socket,
768 &repl_send, &repl_recv);
769 CHECK_STATUS(tctx, status, NT_STATUS_OK);
770 CHECK_VALUE(tctx, repl_recv->mess_type, WREPL_STOP_ASSOCIATION);
771 CHECK_VALUE(tctx, repl_recv->message.stop.reason, 0);
773 talloc_free(wrepl_socket);
777 static bool test_wrepl_is_applied(struct torture_context *tctx,
778 struct test_wrepl_conflict_conn *ctx,
779 const struct wrepl_wins_owner *owner,
780 const struct wrepl_wins_name *name,
784 struct wrepl_pull_names pull_names;
785 struct wrepl_name *names;
787 pull_names.in.assoc_ctx = ctx->pull_assoc;
788 pull_names.in.partner = *owner;
789 pull_names.in.partner.min_version = pull_names.in.partner.max_version;
791 status = wrepl_pull_names(ctx->pull, ctx->pull, &pull_names);
792 CHECK_STATUS(tctx, status, NT_STATUS_OK);
793 torture_assert(tctx, pull_names.out.num_names == (expected?1:0),
794 talloc_asprintf(tctx, "Invalid number of records returned - expected %d got %d", expected, pull_names.out.num_names));
796 names = pull_names.out.names;
799 uint32_t flags = WREPL_NAME_FLAGS(names[0].type,
803 CHECK_VALUE(tctx, names[0].name.type, name->name->type);
804 CHECK_VALUE_STRING(tctx, names[0].name.name, name->name->name);
805 CHECK_VALUE_STRING(tctx, names[0].name.scope, name->name->scope);
806 CHECK_VALUE(tctx, flags, name->flags);
807 CHECK_VALUE_UINT64(tctx, names[0].version_id, name->id);
810 CHECK_VALUE(tctx, names[0].num_addresses,
811 name->addresses.addresses.num_ips);
813 CHECK_VALUE(tctx, names[0].num_addresses, 1);
814 CHECK_VALUE_STRING(tctx, names[0].addresses[0].address,
818 talloc_free(pull_names.out.names);
822 static bool test_wrepl_mhomed_merged(struct torture_context *tctx,
823 struct test_wrepl_conflict_conn *ctx,
824 const struct wrepl_wins_owner *owner1,
825 uint32_t num_ips1, const struct wrepl_ip *ips1,
826 const struct wrepl_wins_owner *owner2,
827 uint32_t num_ips2, const struct wrepl_ip *ips2,
828 const struct wrepl_wins_name *name2)
831 struct wrepl_pull_names pull_names;
832 struct wrepl_name *names;
835 uint32_t num_ips = num_ips1 + num_ips2;
837 for (i = 0; i < num_ips2; i++) {
838 for (j = 0; j < num_ips1; j++) {
839 if (strcmp(ips2[i].ip,ips1[j].ip) == 0) {
846 pull_names.in.assoc_ctx = ctx->pull_assoc;
847 pull_names.in.partner = *owner2;
848 pull_names.in.partner.min_version = pull_names.in.partner.max_version;
850 status = wrepl_pull_names(ctx->pull, ctx->pull, &pull_names);
851 CHECK_STATUS(tctx, status, NT_STATUS_OK);
852 CHECK_VALUE(tctx, pull_names.out.num_names, 1);
854 names = pull_names.out.names;
856 flags = WREPL_NAME_FLAGS(names[0].type,
860 CHECK_VALUE(tctx, names[0].name.type, name2->name->type);
861 CHECK_VALUE_STRING(tctx, names[0].name.name, name2->name->name);
862 CHECK_VALUE_STRING(tctx, names[0].name.scope, name2->name->scope);
863 CHECK_VALUE(tctx, flags, name2->flags | WREPL_TYPE_MHOMED);
864 CHECK_VALUE_UINT64(tctx, names[0].version_id, name2->id);
866 CHECK_VALUE(tctx, names[0].num_addresses, num_ips);
868 for (i = 0; i < names[0].num_addresses; i++) {
869 const char *addr = names[0].addresses[i].address;
870 const char *owner = names[0].addresses[i].owner;
873 for (j = 0; j < num_ips2; j++) {
874 if (strcmp(addr, ips2[j].ip) == 0) {
876 CHECK_VALUE_STRING(tctx, owner, owner2->address);
883 for (j = 0; j < num_ips1; j++) {
884 if (strcmp(addr, ips1[j].ip) == 0) {
886 CHECK_VALUE_STRING(tctx, owner, owner1->address);
893 CHECK_VALUE_STRING(tctx, addr, "not found in address list");
895 talloc_free(pull_names.out.names);
899 static bool test_wrepl_sgroup_merged(struct torture_context *tctx,
900 struct test_wrepl_conflict_conn *ctx,
901 struct wrepl_wins_owner *merge_owner,
902 struct wrepl_wins_owner *owner1,
903 uint32_t num_ips1, const struct wrepl_ip *ips1,
904 struct wrepl_wins_owner *owner2,
905 uint32_t num_ips2, const struct wrepl_ip *ips2,
906 const struct wrepl_wins_name *name2)
909 struct wrepl_pull_names pull_names;
910 struct wrepl_name *names;
911 struct wrepl_name *name = NULL;
914 uint32_t num_ips = num_ips1 + num_ips2;
917 merge_owner = &ctx->c;
920 for (i = 0; i < num_ips1; i++) {
921 if (owner1 != &ctx->c && strcmp(ips1[i].owner,owner2->address) == 0) {
925 for (j = 0; j < num_ips2; j++) {
926 if (strcmp(ips1[i].ip,ips2[j].ip) == 0) {
934 pull_names.in.assoc_ctx = ctx->pull_assoc;
935 pull_names.in.partner = *merge_owner;
936 pull_names.in.partner.min_version = pull_names.in.partner.max_version;
937 pull_names.in.partner.max_version = 0;
939 status = wrepl_pull_names(ctx->pull, ctx->pull, &pull_names);
940 CHECK_STATUS(tctx, status, NT_STATUS_OK);
942 names = pull_names.out.names;
944 for (i = 0; i < pull_names.out.num_names; i++) {
945 if (names[i].name.type != name2->name->type) continue;
946 if (!names[i].name.name) continue;
947 if (strcmp(names[i].name.name, name2->name->name) != 0) continue;
948 if (names[i].name.scope) continue;
953 if (pull_names.out.num_names > 0) {
954 merge_owner->max_version = names[pull_names.out.num_names-1].version_id;
958 torture_comment(tctx, "%s: Name '%s' not found\n", __location__, nbt_name_string(ctx, name2->name));
962 flags = WREPL_NAME_FLAGS(name->type,
966 CHECK_VALUE(tctx, name->name.type, name2->name->type);
967 CHECK_VALUE_STRING(tctx, name->name.name, name2->name->name);
968 CHECK_VALUE_STRING(tctx, name->name.scope, name2->name->scope);
969 CHECK_VALUE(tctx, flags, name2->flags);
971 CHECK_VALUE(tctx, name->num_addresses, num_ips);
973 for (i = 0; i < name->num_addresses; i++) {
974 const char *addr = name->addresses[i].address;
975 const char *owner = name->addresses[i].owner;
978 for (j = 0; j < num_ips2; j++) {
979 if (strcmp(addr, ips2[j].ip) == 0) {
981 CHECK_VALUE_STRING(tctx, owner, ips2[j].owner);
988 for (j = 0; j < num_ips1; j++) {
989 if (strcmp(addr, ips1[j].ip) == 0) {
991 if (owner1 == &ctx->c) {
992 CHECK_VALUE_STRING(tctx, owner, owner1->address);
994 CHECK_VALUE_STRING(tctx, owner, ips1[j].owner);
1000 if (found) continue;
1002 CHECK_VALUE_STRING(tctx, addr, "not found in address list");
1004 talloc_free(pull_names.out.names);
1008 static bool test_conflict_same_owner(struct torture_context *tctx,
1009 struct test_wrepl_conflict_conn *ctx)
1011 static bool ret = true;
1012 struct nbt_name name;
1013 struct wrepl_wins_name wins_name1;
1014 struct wrepl_wins_name wins_name2;
1015 struct wrepl_wins_name *wins_name_tmp;
1016 struct wrepl_wins_name *wins_name_last;
1017 struct wrepl_wins_name *wins_name_cur;
1019 uint8_t types[] = { 0x00, 0x1C };
1021 enum wrepl_name_type type;
1022 enum wrepl_name_state state;
1023 enum wrepl_name_node node;
1026 const struct wrepl_ip *ips;
1029 .type = WREPL_TYPE_GROUP,
1030 .state = WREPL_STATE_ACTIVE,
1031 .node = WREPL_NODE_B,
1033 .num_ips = ARRAY_SIZE(addresses_A_1),
1034 .ips = addresses_A_1,
1036 .type = WREPL_TYPE_UNIQUE,
1037 .state = WREPL_STATE_ACTIVE,
1038 .node = WREPL_NODE_B,
1040 .num_ips = ARRAY_SIZE(addresses_A_1),
1041 .ips = addresses_A_1,
1043 .type = WREPL_TYPE_UNIQUE,
1044 .state = WREPL_STATE_ACTIVE,
1045 .node = WREPL_NODE_B,
1047 .num_ips = ARRAY_SIZE(addresses_A_2),
1048 .ips = addresses_A_2,
1050 .type = WREPL_TYPE_UNIQUE,
1051 .state = WREPL_STATE_ACTIVE,
1052 .node = WREPL_NODE_B,
1054 .num_ips = ARRAY_SIZE(addresses_A_1),
1055 .ips = addresses_A_1,
1057 .type = WREPL_TYPE_UNIQUE,
1058 .state = WREPL_STATE_ACTIVE,
1059 .node = WREPL_NODE_B,
1061 .num_ips = ARRAY_SIZE(addresses_A_2),
1062 .ips = addresses_A_2,
1064 .type = WREPL_TYPE_SGROUP,
1065 .state = WREPL_STATE_TOMBSTONE,
1066 .node = WREPL_NODE_B,
1068 .num_ips = ARRAY_SIZE(addresses_A_2),
1069 .ips = addresses_A_2,
1071 .type = WREPL_TYPE_MHOMED,
1072 .state = WREPL_STATE_TOMBSTONE,
1073 .node = WREPL_NODE_B,
1075 .num_ips = ARRAY_SIZE(addresses_A_1),
1076 .ips = addresses_A_1,
1078 .type = WREPL_TYPE_MHOMED,
1079 .state = WREPL_STATE_RELEASED,
1080 .node = WREPL_NODE_B,
1082 .num_ips = ARRAY_SIZE(addresses_A_2),
1083 .ips = addresses_A_2,
1085 .type = WREPL_TYPE_SGROUP,
1086 .state = WREPL_STATE_ACTIVE,
1087 .node = WREPL_NODE_B,
1089 .num_ips = ARRAY_SIZE(addresses_A_1),
1090 .ips = addresses_A_1,
1092 .type = WREPL_TYPE_SGROUP,
1093 .state = WREPL_STATE_ACTIVE,
1094 .node = WREPL_NODE_B,
1096 .num_ips = ARRAY_SIZE(addresses_A_3_4),
1097 .ips = addresses_A_3_4,
1099 .type = WREPL_TYPE_SGROUP,
1100 .state = WREPL_STATE_TOMBSTONE,
1101 .node = WREPL_NODE_B,
1103 .num_ips = ARRAY_SIZE(addresses_B_3_4),
1104 .ips = addresses_B_3_4,
1106 /* the last one should always be a unique,tomstone record! */
1107 .type = WREPL_TYPE_UNIQUE,
1108 .state = WREPL_STATE_TOMBSTONE,
1109 .node = WREPL_NODE_B,
1111 .num_ips = ARRAY_SIZE(addresses_A_1),
1112 .ips = addresses_A_1,
1116 name.name = "_SAME_OWNER_A";
1120 wins_name_tmp = NULL;
1121 wins_name_last = &wins_name2;
1122 wins_name_cur = &wins_name1;
1124 for (j=0; ret && j < ARRAY_SIZE(types); j++) {
1125 name.type = types[j];
1126 torture_comment(tctx, "Test Replica Conflicts with same owner[%s] for %s\n",
1127 nbt_name_string(ctx, &name), ctx->a.address);
1129 for(i=0; ret && i < ARRAY_SIZE(records); i++) {
1130 wins_name_tmp = wins_name_last;
1131 wins_name_last = wins_name_cur;
1132 wins_name_cur = wins_name_tmp;
1135 torture_comment(tctx, "%s,%s%s vs. %s,%s%s with %s ip(s) => %s\n",
1136 wrepl_name_type_string(records[i-1].type),
1137 wrepl_name_state_string(records[i-1].state),
1138 (records[i-1].is_static?",static":""),
1139 wrepl_name_type_string(records[i].type),
1140 wrepl_name_state_string(records[i].state),
1141 (records[i].is_static?",static":""),
1142 (records[i-1].ips==records[i].ips?"same":"different"),
1146 wins_name_cur->name = &name;
1147 wins_name_cur->flags = WREPL_NAME_FLAGS(records[i].type,
1150 records[i].is_static);
1151 wins_name_cur->id = ++ctx->a.max_version;
1152 if (wins_name_cur->flags & 2) {
1153 wins_name_cur->addresses.addresses.num_ips = records[i].num_ips;
1154 wins_name_cur->addresses.addresses.ips = discard_const(records[i].ips);
1156 wins_name_cur->addresses.ip = records[i].ips[0].ip;
1158 wins_name_cur->unknown = "255.255.255.255";
1160 ret &= test_wrepl_update_one(tctx, ctx, &ctx->a,wins_name_cur);
1161 if (records[i].state == WREPL_STATE_RELEASED) {
1162 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->a, wins_name_last, false);
1163 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->a, wins_name_cur, false);
1165 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->a, wins_name_cur, true);
1168 /* the first one is a cleanup run */
1169 if (!ret && i == 0) ret = true;
1172 torture_comment(tctx, "conflict handled wrong or record[%u]: %s\n", i, __location__);
1180 static bool test_conflict_different_owner(struct torture_context *tctx,
1181 struct test_wrepl_conflict_conn *ctx)
1184 struct wrepl_wins_name wins_name1;
1185 struct wrepl_wins_name wins_name2;
1186 struct wrepl_wins_name *wins_name_r1;
1187 struct wrepl_wins_name *wins_name_r2;
1190 const char *line; /* just better debugging */
1191 struct nbt_name name;
1192 const char *comment;
1193 bool extra; /* not the worst case, this is an extra test */
1196 struct wrepl_wins_owner *owner;
1197 enum wrepl_name_type type;
1198 enum wrepl_name_state state;
1199 enum wrepl_name_node node;
1202 const struct wrepl_ip *ips;
1203 bool apply_expected;
1205 struct wrepl_wins_owner *merge_owner;
1206 bool sgroup_cleanup;
1210 * NOTE: the first record and the last applied one
1211 * needs to be from the same owner,
1212 * to not conflict in the next smbtorture run!!!
1215 .line = __location__,
1216 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1220 .type = WREPL_TYPE_UNIQUE,
1221 .state = WREPL_STATE_TOMBSTONE,
1222 .node = WREPL_NODE_B,
1224 .num_ips = ARRAY_SIZE(addresses_B_1),
1225 .ips = addresses_B_1,
1226 .apply_expected = true /* ignored */
1230 .type = WREPL_TYPE_UNIQUE,
1231 .state = WREPL_STATE_TOMBSTONE,
1232 .node = WREPL_NODE_B,
1234 .num_ips = ARRAY_SIZE(addresses_A_1),
1235 .ips = addresses_A_1,
1236 .apply_expected = true /* ignored */
1241 * unique vs unique section
1244 * unique,active vs. unique,active
1245 * => should be replaced
1248 .line = __location__,
1249 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1252 .type = WREPL_TYPE_UNIQUE,
1253 .state = WREPL_STATE_ACTIVE,
1254 .node = WREPL_NODE_B,
1256 .num_ips = ARRAY_SIZE(addresses_A_1),
1257 .ips = addresses_A_1,
1258 .apply_expected = true
1262 .type = WREPL_TYPE_UNIQUE,
1263 .state = WREPL_STATE_ACTIVE,
1264 .node = WREPL_NODE_B,
1266 .num_ips = ARRAY_SIZE(addresses_B_1),
1267 .ips = addresses_B_1,
1268 .apply_expected = true
1273 * unique,active vs. unique,tombstone
1274 * => should NOT be replaced
1277 .line = __location__,
1278 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1281 .type = WREPL_TYPE_UNIQUE,
1282 .state = WREPL_STATE_ACTIVE,
1283 .node = WREPL_NODE_B,
1285 .num_ips = ARRAY_SIZE(addresses_B_1),
1286 .ips = addresses_B_1,
1287 .apply_expected = true
1291 .type = WREPL_TYPE_UNIQUE,
1292 .state = WREPL_STATE_TOMBSTONE,
1293 .node = WREPL_NODE_B,
1295 .num_ips = ARRAY_SIZE(addresses_B_1),
1296 .ips = addresses_B_1,
1297 .apply_expected = false
1302 * unique,released vs. unique,active
1303 * => should be replaced
1306 .line = __location__,
1307 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1310 .type = WREPL_TYPE_UNIQUE,
1311 .state = WREPL_STATE_RELEASED,
1312 .node = WREPL_NODE_B,
1314 .num_ips = ARRAY_SIZE(addresses_B_1),
1315 .ips = addresses_B_1,
1316 .apply_expected = false
1320 .type = WREPL_TYPE_UNIQUE,
1321 .state = WREPL_STATE_ACTIVE,
1322 .node = WREPL_NODE_B,
1324 .num_ips = ARRAY_SIZE(addresses_A_1),
1325 .ips = addresses_A_1,
1326 .apply_expected = true
1331 * unique,released vs. unique,tombstone
1332 * => should be replaced
1335 .line = __location__,
1336 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1339 .type = WREPL_TYPE_UNIQUE,
1340 .state = WREPL_STATE_RELEASED,
1341 .node = WREPL_NODE_B,
1343 .num_ips = ARRAY_SIZE(addresses_A_1),
1344 .ips = addresses_A_1,
1345 .apply_expected = false
1349 .type = WREPL_TYPE_UNIQUE,
1350 .state = WREPL_STATE_TOMBSTONE,
1351 .node = WREPL_NODE_B,
1353 .num_ips = ARRAY_SIZE(addresses_B_1),
1354 .ips = addresses_B_1,
1355 .apply_expected = true
1360 * unique,tombstone vs. unique,active
1361 * => should be replaced
1364 .line = __location__,
1365 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1368 .type = WREPL_TYPE_UNIQUE,
1369 .state = WREPL_STATE_TOMBSTONE,
1370 .node = WREPL_NODE_B,
1372 .num_ips = ARRAY_SIZE(addresses_B_1),
1373 .ips = addresses_B_1,
1374 .apply_expected = true
1378 .type = WREPL_TYPE_UNIQUE,
1379 .state = WREPL_STATE_ACTIVE,
1380 .node = WREPL_NODE_B,
1382 .num_ips = ARRAY_SIZE(addresses_A_1),
1383 .ips = addresses_A_1,
1384 .apply_expected = true
1389 * unique,tombstone vs. unique,tombstone
1390 * => should be replaced
1393 .line = __location__,
1394 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1397 .type = WREPL_TYPE_UNIQUE,
1398 .state = WREPL_STATE_TOMBSTONE,
1399 .node = WREPL_NODE_B,
1401 .num_ips = ARRAY_SIZE(addresses_A_1),
1402 .ips = addresses_A_1,
1403 .apply_expected = true
1407 .type = WREPL_TYPE_UNIQUE,
1408 .state = WREPL_STATE_TOMBSTONE,
1409 .node = WREPL_NODE_B,
1411 .num_ips = ARRAY_SIZE(addresses_B_1),
1412 .ips = addresses_B_1,
1413 .apply_expected = true
1419 * unique vs normal groups section,
1422 * unique,active vs. group,active
1423 * => should be replaced
1426 .line = __location__,
1427 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1430 .type = WREPL_TYPE_UNIQUE,
1431 .state = WREPL_STATE_ACTIVE,
1432 .node = WREPL_NODE_B,
1434 .num_ips = ARRAY_SIZE(addresses_B_1),
1435 .ips = addresses_B_1,
1436 .apply_expected = true
1440 .type = WREPL_TYPE_GROUP,
1441 .state = WREPL_STATE_ACTIVE,
1442 .node = WREPL_NODE_B,
1444 .num_ips = ARRAY_SIZE(addresses_A_1),
1445 .ips = addresses_A_1,
1446 .apply_expected = true
1451 * unique,active vs. group,tombstone
1452 * => should NOT be replaced
1455 .line = __location__,
1456 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1459 .type = WREPL_TYPE_UNIQUE,
1460 .state = WREPL_STATE_ACTIVE,
1461 .node = WREPL_NODE_B,
1463 .num_ips = ARRAY_SIZE(addresses_A_1),
1464 .ips = addresses_A_1,
1465 .apply_expected = true
1469 .type = WREPL_TYPE_GROUP,
1470 .state = WREPL_STATE_TOMBSTONE,
1471 .node = WREPL_NODE_B,
1473 .num_ips = ARRAY_SIZE(addresses_A_1),
1474 .ips = addresses_A_1,
1475 .apply_expected = false
1480 * unique,released vs. group,active
1481 * => should be replaced
1484 .line = __location__,
1485 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1488 .type = WREPL_TYPE_UNIQUE,
1489 .state = WREPL_STATE_RELEASED,
1490 .node = WREPL_NODE_B,
1492 .num_ips = ARRAY_SIZE(addresses_A_1),
1493 .ips = addresses_A_1,
1494 .apply_expected = false
1498 .type = WREPL_TYPE_GROUP,
1499 .state = WREPL_STATE_ACTIVE,
1500 .node = WREPL_NODE_B,
1502 .num_ips = ARRAY_SIZE(addresses_B_1),
1503 .ips = addresses_B_1,
1504 .apply_expected = true
1509 * unique,released vs. group,tombstone
1510 * => should be replaced
1513 .line = __location__,
1514 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1517 .type = WREPL_TYPE_UNIQUE,
1518 .state = WREPL_STATE_RELEASED,
1519 .node = WREPL_NODE_B,
1521 .num_ips = ARRAY_SIZE(addresses_B_1),
1522 .ips = addresses_B_1,
1523 .apply_expected = false
1527 .type = WREPL_TYPE_GROUP,
1528 .state = WREPL_STATE_TOMBSTONE,
1529 .node = WREPL_NODE_B,
1531 .num_ips = ARRAY_SIZE(addresses_A_1),
1532 .ips = addresses_A_1,
1533 .apply_expected = true
1538 * unique,tombstone vs. group,active
1539 * => should be replaced
1542 .line = __location__,
1543 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1546 .type = WREPL_TYPE_UNIQUE,
1547 .state = WREPL_STATE_TOMBSTONE,
1548 .node = WREPL_NODE_B,
1550 .num_ips = ARRAY_SIZE(addresses_A_1),
1551 .ips = addresses_A_1,
1552 .apply_expected = true
1556 .type = WREPL_TYPE_GROUP,
1557 .state = WREPL_STATE_ACTIVE,
1558 .node = WREPL_NODE_B,
1560 .num_ips = ARRAY_SIZE(addresses_B_1),
1561 .ips = addresses_B_1,
1562 .apply_expected = true
1567 * unique,tombstone vs. group,tombstone
1568 * => should be replaced
1571 .line = __location__,
1572 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1575 .type = WREPL_TYPE_UNIQUE,
1576 .state = WREPL_STATE_TOMBSTONE,
1577 .node = WREPL_NODE_B,
1579 .num_ips = ARRAY_SIZE(addresses_B_1),
1580 .ips = addresses_B_1,
1581 .apply_expected = true
1585 .type = WREPL_TYPE_GROUP,
1586 .state = WREPL_STATE_TOMBSTONE,
1587 .node = WREPL_NODE_B,
1589 .num_ips = ARRAY_SIZE(addresses_A_1),
1590 .ips = addresses_A_1,
1591 .apply_expected = true
1596 * unique vs special groups section,
1599 * unique,active vs. sgroup,active
1600 * => should NOT be replaced
1603 .line = __location__,
1604 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1607 .type = WREPL_TYPE_UNIQUE,
1608 .state = WREPL_STATE_ACTIVE,
1609 .node = WREPL_NODE_B,
1611 .num_ips = ARRAY_SIZE(addresses_A_1),
1612 .ips = addresses_A_1,
1613 .apply_expected = true
1617 .type = WREPL_TYPE_SGROUP,
1618 .state = WREPL_STATE_ACTIVE,
1619 .node = WREPL_NODE_B,
1621 .num_ips = ARRAY_SIZE(addresses_A_1),
1622 .ips = addresses_A_1,
1623 .apply_expected = false
1628 * unique,active vs. sgroup,tombstone
1629 * => should NOT be replaced
1632 .line = __location__,
1633 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1636 .type = WREPL_TYPE_UNIQUE,
1637 .state = WREPL_STATE_ACTIVE,
1638 .node = WREPL_NODE_B,
1640 .num_ips = ARRAY_SIZE(addresses_A_1),
1641 .ips = addresses_A_1,
1642 .apply_expected = true
1646 .type = WREPL_TYPE_SGROUP,
1647 .state = WREPL_STATE_TOMBSTONE,
1648 .node = WREPL_NODE_B,
1650 .num_ips = ARRAY_SIZE(addresses_A_1),
1651 .ips = addresses_A_1,
1652 .apply_expected = false
1657 * unique,released vs. sgroup,active
1658 * => should be replaced
1661 .line = __location__,
1662 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1665 .type = WREPL_TYPE_UNIQUE,
1666 .state = WREPL_STATE_RELEASED,
1667 .node = WREPL_NODE_B,
1669 .num_ips = ARRAY_SIZE(addresses_A_1),
1670 .ips = addresses_A_1,
1671 .apply_expected = false
1675 .type = WREPL_TYPE_SGROUP,
1676 .state = WREPL_STATE_ACTIVE,
1677 .node = WREPL_NODE_B,
1679 .num_ips = ARRAY_SIZE(addresses_B_3_4),
1680 .ips = addresses_B_3_4,
1681 .apply_expected = true
1686 * unique,released vs. sgroup,tombstone
1687 * => should be replaced
1690 .line = __location__,
1691 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1694 .type = WREPL_TYPE_UNIQUE,
1695 .state = WREPL_STATE_RELEASED,
1696 .node = WREPL_NODE_B,
1698 .num_ips = ARRAY_SIZE(addresses_B_1),
1699 .ips = addresses_B_1,
1700 .apply_expected = false
1704 .type = WREPL_TYPE_SGROUP,
1705 .state = WREPL_STATE_TOMBSTONE,
1706 .node = WREPL_NODE_B,
1708 .num_ips = ARRAY_SIZE(addresses_A_3_4),
1709 .ips = addresses_A_3_4,
1710 .apply_expected = true
1715 * unique,tombstone vs. sgroup,active
1716 * => should be replaced
1719 .line = __location__,
1720 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1723 .type = WREPL_TYPE_UNIQUE,
1724 .state = WREPL_STATE_TOMBSTONE,
1725 .node = WREPL_NODE_B,
1727 .num_ips = ARRAY_SIZE(addresses_A_1),
1728 .ips = addresses_A_1,
1729 .apply_expected = true
1733 .type = WREPL_TYPE_SGROUP,
1734 .state = WREPL_STATE_ACTIVE,
1735 .node = WREPL_NODE_B,
1737 .num_ips = ARRAY_SIZE(addresses_B_3_4),
1738 .ips = addresses_B_3_4,
1739 .apply_expected = true
1744 * unique,tombstone vs. sgroup,tombstone
1745 * => should be replaced
1748 .line = __location__,
1749 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1752 .type = WREPL_TYPE_UNIQUE,
1753 .state = WREPL_STATE_TOMBSTONE,
1754 .node = WREPL_NODE_B,
1756 .num_ips = ARRAY_SIZE(addresses_B_1),
1757 .ips = addresses_B_1,
1758 .apply_expected = true
1762 .type = WREPL_TYPE_SGROUP,
1763 .state = WREPL_STATE_TOMBSTONE,
1764 .node = WREPL_NODE_B,
1766 .num_ips = ARRAY_SIZE(addresses_A_3_4),
1767 .ips = addresses_A_3_4,
1768 .apply_expected = true
1773 * unique vs multi homed section,
1776 * unique,active vs. mhomed,active
1777 * => should be replaced
1780 .line = __location__,
1781 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1784 .type = WREPL_TYPE_UNIQUE,
1785 .state = WREPL_STATE_ACTIVE,
1786 .node = WREPL_NODE_B,
1788 .num_ips = ARRAY_SIZE(addresses_A_1),
1789 .ips = addresses_A_1,
1790 .apply_expected = true
1794 .type = WREPL_TYPE_MHOMED,
1795 .state = WREPL_STATE_ACTIVE,
1796 .node = WREPL_NODE_B,
1798 .num_ips = ARRAY_SIZE(addresses_B_3_4),
1799 .ips = addresses_B_3_4,
1800 .apply_expected = true
1805 * unique,active vs. mhomed,tombstone
1806 * => should NOT be replaced
1809 .line = __location__,
1810 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1813 .type = WREPL_TYPE_UNIQUE,
1814 .state = WREPL_STATE_ACTIVE,
1815 .node = WREPL_NODE_B,
1817 .num_ips = ARRAY_SIZE(addresses_B_3_4),
1818 .ips = addresses_B_3_4,
1819 .apply_expected = true
1823 .type = WREPL_TYPE_MHOMED,
1824 .state = WREPL_STATE_TOMBSTONE,
1825 .node = WREPL_NODE_B,
1827 .num_ips = ARRAY_SIZE(addresses_B_3_4),
1828 .ips = addresses_B_3_4,
1829 .apply_expected = false
1834 * unique,released vs. mhomed,active
1835 * => should be replaced
1838 .line = __location__,
1839 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1842 .type = WREPL_TYPE_UNIQUE,
1843 .state = WREPL_STATE_RELEASED,
1844 .node = WREPL_NODE_B,
1846 .num_ips = ARRAY_SIZE(addresses_B_1),
1847 .ips = addresses_B_1,
1848 .apply_expected = false
1852 .type = WREPL_TYPE_MHOMED,
1853 .state = WREPL_STATE_ACTIVE,
1854 .node = WREPL_NODE_B,
1856 .num_ips = ARRAY_SIZE(addresses_A_3_4),
1857 .ips = addresses_A_3_4,
1858 .apply_expected = true
1863 * unique,released vs. mhomed,tombstone
1864 * => should be replaced
1867 .line = __location__,
1868 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1871 .type = WREPL_TYPE_UNIQUE,
1872 .state = WREPL_STATE_RELEASED,
1873 .node = WREPL_NODE_B,
1875 .num_ips = ARRAY_SIZE(addresses_A_1),
1876 .ips = addresses_A_1,
1877 .apply_expected = false
1881 .type = WREPL_TYPE_MHOMED,
1882 .state = WREPL_STATE_TOMBSTONE,
1883 .node = WREPL_NODE_B,
1885 .num_ips = ARRAY_SIZE(addresses_B_3_4),
1886 .ips = addresses_B_3_4,
1887 .apply_expected = true
1892 * unique,tombstone vs. mhomed,active
1893 * => should be replaced
1896 .line = __location__,
1897 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1900 .type = WREPL_TYPE_UNIQUE,
1901 .state = WREPL_STATE_TOMBSTONE,
1902 .node = WREPL_NODE_B,
1904 .num_ips = ARRAY_SIZE(addresses_B_1),
1905 .ips = addresses_B_1,
1906 .apply_expected = true
1910 .type = WREPL_TYPE_MHOMED,
1911 .state = WREPL_STATE_ACTIVE,
1912 .node = WREPL_NODE_B,
1914 .num_ips = ARRAY_SIZE(addresses_A_3_4),
1915 .ips = addresses_A_3_4,
1916 .apply_expected = true
1921 * unique,tombstone vs. mhomed,tombstone
1922 * => should be replaced
1925 .line = __location__,
1926 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1929 .type = WREPL_TYPE_UNIQUE,
1930 .state = WREPL_STATE_TOMBSTONE,
1931 .node = WREPL_NODE_B,
1933 .num_ips = ARRAY_SIZE(addresses_A_1),
1934 .ips = addresses_A_1,
1935 .apply_expected = true
1939 .type = WREPL_TYPE_MHOMED,
1940 .state = WREPL_STATE_TOMBSTONE,
1941 .node = WREPL_NODE_B,
1943 .num_ips = ARRAY_SIZE(addresses_B_3_4),
1944 .ips = addresses_B_3_4,
1945 .apply_expected = true
1950 * normal groups vs unique section,
1953 * group,active vs. unique,active
1954 * => should NOT be replaced
1957 .line = __location__,
1958 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1961 .type = WREPL_TYPE_GROUP,
1962 .state = WREPL_STATE_ACTIVE,
1963 .node = WREPL_NODE_B,
1965 .num_ips = ARRAY_SIZE(addresses_A_1),
1966 .ips = addresses_A_1,
1967 .apply_expected = true
1971 .type = WREPL_TYPE_UNIQUE,
1972 .state = WREPL_STATE_ACTIVE,
1973 .node = WREPL_NODE_B,
1975 .num_ips = ARRAY_SIZE(addresses_A_1),
1976 .ips = addresses_A_1,
1977 .apply_expected = false
1982 * group,active vs. unique,tombstone
1983 * => should NOT be replaced
1986 .line = __location__,
1987 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
1990 .type = WREPL_TYPE_GROUP,
1991 .state = WREPL_STATE_ACTIVE,
1992 .node = WREPL_NODE_B,
1994 .num_ips = ARRAY_SIZE(addresses_A_1),
1995 .ips = addresses_A_1,
1996 .apply_expected = true
2000 .type = WREPL_TYPE_UNIQUE,
2001 .state = WREPL_STATE_TOMBSTONE,
2002 .node = WREPL_NODE_B,
2004 .num_ips = ARRAY_SIZE(addresses_A_1),
2005 .ips = addresses_A_1,
2006 .apply_expected = false
2011 * group,released vs. unique,active
2012 * => should NOT be replaced
2015 .line = __location__,
2016 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2019 .type = WREPL_TYPE_GROUP,
2020 .state = WREPL_STATE_RELEASED,
2021 .node = WREPL_NODE_B,
2023 .num_ips = ARRAY_SIZE(addresses_A_1),
2024 .ips = addresses_A_1,
2025 .apply_expected = false
2029 .type = WREPL_TYPE_UNIQUE,
2030 .state = WREPL_STATE_ACTIVE,
2031 .node = WREPL_NODE_B,
2033 .num_ips = ARRAY_SIZE(addresses_A_1),
2034 .ips = addresses_A_1,
2035 .apply_expected = false
2040 * group,released vs. unique,tombstone
2041 * => should NOT be replaced
2044 .line = __location__,
2045 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2048 .type = WREPL_TYPE_GROUP,
2049 .state = WREPL_STATE_RELEASED,
2050 .node = WREPL_NODE_B,
2052 .num_ips = ARRAY_SIZE(addresses_A_1),
2053 .ips = addresses_A_1,
2054 .apply_expected = false
2058 .type = WREPL_TYPE_UNIQUE,
2059 .state = WREPL_STATE_TOMBSTONE,
2060 .node = WREPL_NODE_B,
2062 .num_ips = ARRAY_SIZE(addresses_A_1),
2063 .ips = addresses_A_1,
2064 .apply_expected = false
2069 * group,tombstone vs. unique,active
2070 * => should NOT be replaced
2073 .line = __location__,
2074 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2077 .type = WREPL_TYPE_GROUP,
2078 .state = WREPL_STATE_TOMBSTONE,
2079 .node = WREPL_NODE_B,
2081 .num_ips = ARRAY_SIZE(addresses_A_1),
2082 .ips = addresses_A_1,
2083 .apply_expected = true
2087 .type = WREPL_TYPE_UNIQUE,
2088 .state = WREPL_STATE_ACTIVE,
2089 .node = WREPL_NODE_B,
2091 .num_ips = ARRAY_SIZE(addresses_A_1),
2092 .ips = addresses_A_1,
2093 .apply_expected = false
2098 * group,tombstone vs. unique,tombstone
2099 * => should NOT be replaced
2102 .line = __location__,
2103 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2106 .type = WREPL_TYPE_GROUP,
2107 .state = WREPL_STATE_TOMBSTONE,
2108 .node = WREPL_NODE_B,
2110 .num_ips = ARRAY_SIZE(addresses_A_1),
2111 .ips = addresses_A_1,
2112 .apply_expected = true
2116 .type = WREPL_TYPE_UNIQUE,
2117 .state = WREPL_STATE_TOMBSTONE,
2118 .node = WREPL_NODE_B,
2120 .num_ips = ARRAY_SIZE(addresses_A_1),
2121 .ips = addresses_A_1,
2122 .apply_expected = false
2127 * normal groups vs normal groups section,
2130 * group,active vs. group,active
2131 * => should NOT be replaced
2134 .line = __location__,
2135 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2138 .type = WREPL_TYPE_GROUP,
2139 .state = WREPL_STATE_ACTIVE,
2140 .node = WREPL_NODE_B,
2142 .num_ips = ARRAY_SIZE(addresses_A_1),
2143 .ips = addresses_A_1,
2144 .apply_expected = true
2148 .type = WREPL_TYPE_GROUP,
2149 .state = WREPL_STATE_ACTIVE,
2150 .node = WREPL_NODE_B,
2152 .num_ips = ARRAY_SIZE(addresses_A_1),
2153 .ips = addresses_A_1,
2154 .apply_expected = false
2159 * group,active vs. group,tombstone
2160 * => should NOT be replaced
2163 .line = __location__,
2164 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2167 .type = WREPL_TYPE_GROUP,
2168 .state = WREPL_STATE_ACTIVE,
2169 .node = WREPL_NODE_B,
2171 .num_ips = ARRAY_SIZE(addresses_A_1),
2172 .ips = addresses_A_1,
2173 .apply_expected = true
2177 .type = WREPL_TYPE_GROUP,
2178 .state = WREPL_STATE_TOMBSTONE,
2179 .node = WREPL_NODE_B,
2181 .num_ips = ARRAY_SIZE(addresses_A_1),
2182 .ips = addresses_A_1,
2183 .apply_expected = false
2188 * group,released vs. group,active
2189 * => should be replaced
2192 .line = __location__,
2193 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2196 .type = WREPL_TYPE_GROUP,
2197 .state = WREPL_STATE_RELEASED,
2198 .node = WREPL_NODE_B,
2200 .num_ips = ARRAY_SIZE(addresses_A_1),
2201 .ips = addresses_A_1,
2202 .apply_expected = false
2206 .type = WREPL_TYPE_GROUP,
2207 .state = WREPL_STATE_ACTIVE,
2208 .node = WREPL_NODE_B,
2210 .num_ips = ARRAY_SIZE(addresses_B_1),
2211 .ips = addresses_B_1,
2212 .apply_expected = true
2217 * group,released vs. group,tombstone
2218 * => should be replaced
2221 .line = __location__,
2222 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2225 .type = WREPL_TYPE_GROUP,
2226 .state = WREPL_STATE_RELEASED,
2227 .node = WREPL_NODE_B,
2229 .num_ips = ARRAY_SIZE(addresses_A_1),
2230 .ips = addresses_A_1,
2231 .apply_expected = false
2235 .type = WREPL_TYPE_GROUP,
2236 .state = WREPL_STATE_TOMBSTONE,
2237 .node = WREPL_NODE_B,
2239 .num_ips = ARRAY_SIZE(addresses_B_1),
2240 .ips = addresses_B_1,
2241 .apply_expected = true
2246 * group,tombstone vs. group,active
2247 * => should be replaced
2250 .line = __location__,
2251 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2254 .type = WREPL_TYPE_GROUP,
2255 .state = WREPL_STATE_TOMBSTONE,
2256 .node = WREPL_NODE_B,
2258 .num_ips = ARRAY_SIZE(addresses_B_1),
2259 .ips = addresses_B_1,
2260 .apply_expected = true
2264 .type = WREPL_TYPE_GROUP,
2265 .state = WREPL_STATE_ACTIVE,
2266 .node = WREPL_NODE_B,
2268 .num_ips = ARRAY_SIZE(addresses_A_1),
2269 .ips = addresses_A_1,
2270 .apply_expected = true
2275 * group,tombstone vs. group,tombstone
2276 * => should be replaced
2279 .line = __location__,
2280 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2283 .type = WREPL_TYPE_GROUP,
2284 .state = WREPL_STATE_TOMBSTONE,
2285 .node = WREPL_NODE_B,
2287 .num_ips = ARRAY_SIZE(addresses_A_1),
2288 .ips = addresses_A_1,
2289 .apply_expected = true
2293 .type = WREPL_TYPE_GROUP,
2294 .state = WREPL_STATE_TOMBSTONE,
2295 .node = WREPL_NODE_B,
2297 .num_ips = ARRAY_SIZE(addresses_B_1),
2298 .ips = addresses_B_1,
2299 .apply_expected = true
2304 * normal groups vs special groups section,
2307 * group,active vs. sgroup,active
2308 * => should NOT be replaced
2311 .line = __location__,
2312 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2315 .type = WREPL_TYPE_GROUP,
2316 .state = WREPL_STATE_ACTIVE,
2317 .node = WREPL_NODE_B,
2319 .num_ips = ARRAY_SIZE(addresses_B_1),
2320 .ips = addresses_B_1,
2321 .apply_expected = true
2325 .type = WREPL_TYPE_SGROUP,
2326 .state = WREPL_STATE_ACTIVE,
2327 .node = WREPL_NODE_B,
2329 .num_ips = ARRAY_SIZE(addresses_B_1),
2330 .ips = addresses_B_1,
2331 .apply_expected = false
2336 * group,active vs. sgroup,tombstone
2337 * => should NOT be replaced
2340 .line = __location__,
2341 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2344 .type = WREPL_TYPE_GROUP,
2345 .state = WREPL_STATE_ACTIVE,
2346 .node = WREPL_NODE_B,
2348 .num_ips = ARRAY_SIZE(addresses_B_1),
2349 .ips = addresses_B_1,
2350 .apply_expected = true
2354 .type = WREPL_TYPE_SGROUP,
2355 .state = WREPL_STATE_TOMBSTONE,
2356 .node = WREPL_NODE_B,
2358 .num_ips = ARRAY_SIZE(addresses_B_1),
2359 .ips = addresses_B_1,
2360 .apply_expected = false
2365 * group,released vs. sgroup,active
2366 * => should be replaced
2369 .line = __location__,
2370 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2373 .type = WREPL_TYPE_GROUP,
2374 .state = WREPL_STATE_RELEASED,
2375 .node = WREPL_NODE_B,
2377 .num_ips = ARRAY_SIZE(addresses_A_1),
2378 .ips = addresses_A_1,
2379 .apply_expected = false
2383 .type = WREPL_TYPE_SGROUP,
2384 .state = WREPL_STATE_ACTIVE,
2385 .node = WREPL_NODE_B,
2387 .num_ips = ARRAY_SIZE(addresses_B_1),
2388 .ips = addresses_B_1,
2389 .apply_expected = true
2394 * group,released vs. sgroup,tombstone
2395 * => should NOT be replaced
2398 .line = __location__,
2399 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2402 .type = WREPL_TYPE_GROUP,
2403 .state = WREPL_STATE_RELEASED,
2404 .node = WREPL_NODE_B,
2406 .num_ips = ARRAY_SIZE(addresses_B_1),
2407 .ips = addresses_B_1,
2408 .apply_expected = false
2412 .type = WREPL_TYPE_SGROUP,
2413 .state = WREPL_STATE_TOMBSTONE,
2414 .node = WREPL_NODE_B,
2416 .num_ips = ARRAY_SIZE(addresses_B_1),
2417 .ips = addresses_B_1,
2418 .apply_expected = false
2423 * group,tombstone vs. sgroup,active
2424 * => should be replaced
2427 .line = __location__,
2428 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2431 .type = WREPL_TYPE_GROUP,
2432 .state = WREPL_STATE_TOMBSTONE,
2433 .node = WREPL_NODE_B,
2435 .num_ips = ARRAY_SIZE(addresses_B_1),
2436 .ips = addresses_B_1,
2437 .apply_expected = true
2441 .type = WREPL_TYPE_SGROUP,
2442 .state = WREPL_STATE_ACTIVE,
2443 .node = WREPL_NODE_B,
2445 .num_ips = ARRAY_SIZE(addresses_A_1),
2446 .ips = addresses_A_1,
2447 .apply_expected = true
2452 * group,tombstone vs. sgroup,tombstone
2453 * => should be replaced
2456 .line = __location__,
2457 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2460 .type = WREPL_TYPE_GROUP,
2461 .state = WREPL_STATE_TOMBSTONE,
2462 .node = WREPL_NODE_B,
2464 .num_ips = ARRAY_SIZE(addresses_A_1),
2465 .ips = addresses_A_1,
2466 .apply_expected = true
2470 .type = WREPL_TYPE_SGROUP,
2471 .state = WREPL_STATE_TOMBSTONE,
2472 .node = WREPL_NODE_B,
2474 .num_ips = ARRAY_SIZE(addresses_B_1),
2475 .ips = addresses_B_1,
2476 .apply_expected = true
2481 * normal groups vs multi homed section,
2484 * group,active vs. mhomed,active
2485 * => should NOT be replaced
2488 .line = __location__,
2489 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2492 .type = WREPL_TYPE_GROUP,
2493 .state = WREPL_STATE_ACTIVE,
2494 .node = WREPL_NODE_B,
2496 .num_ips = ARRAY_SIZE(addresses_B_1),
2497 .ips = addresses_B_1,
2498 .apply_expected = true
2502 .type = WREPL_TYPE_MHOMED,
2503 .state = WREPL_STATE_ACTIVE,
2504 .node = WREPL_NODE_B,
2506 .num_ips = ARRAY_SIZE(addresses_B_1),
2507 .ips = addresses_B_1,
2508 .apply_expected = false
2513 * group,active vs. mhomed,tombstone
2514 * => should NOT be replaced
2517 .line = __location__,
2518 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2521 .type = WREPL_TYPE_GROUP,
2522 .state = WREPL_STATE_ACTIVE,
2523 .node = WREPL_NODE_B,
2525 .num_ips = ARRAY_SIZE(addresses_B_1),
2526 .ips = addresses_B_1,
2527 .apply_expected = true
2531 .type = WREPL_TYPE_MHOMED,
2532 .state = WREPL_STATE_TOMBSTONE,
2533 .node = WREPL_NODE_B,
2535 .num_ips = ARRAY_SIZE(addresses_B_1),
2536 .ips = addresses_B_1,
2537 .apply_expected = false
2542 * group,released vs. mhomed,active
2543 * => should NOT be replaced
2546 .line = __location__,
2547 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2550 .type = WREPL_TYPE_GROUP,
2551 .state = WREPL_STATE_RELEASED,
2552 .node = WREPL_NODE_B,
2554 .num_ips = ARRAY_SIZE(addresses_B_1),
2555 .ips = addresses_B_1,
2556 .apply_expected = false
2560 .type = WREPL_TYPE_MHOMED,
2561 .state = WREPL_STATE_ACTIVE,
2562 .node = WREPL_NODE_B,
2564 .num_ips = ARRAY_SIZE(addresses_B_1),
2565 .ips = addresses_B_1,
2566 .apply_expected = false
2571 * group,released vs. mhomed,tombstone
2572 * => should NOT be replaced
2575 .line = __location__,
2576 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2579 .type = WREPL_TYPE_GROUP,
2580 .state = WREPL_STATE_RELEASED,
2581 .node = WREPL_NODE_B,
2583 .num_ips = ARRAY_SIZE(addresses_B_1),
2584 .ips = addresses_B_1,
2585 .apply_expected = false
2589 .type = WREPL_TYPE_MHOMED,
2590 .state = WREPL_STATE_TOMBSTONE,
2591 .node = WREPL_NODE_B,
2593 .num_ips = ARRAY_SIZE(addresses_B_1),
2594 .ips = addresses_B_1,
2595 .apply_expected = false
2600 * group,tombstone vs. mhomed,active
2601 * => should be replaced
2604 .line = __location__,
2605 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2608 .type = WREPL_TYPE_GROUP,
2609 .state = WREPL_STATE_TOMBSTONE,
2610 .node = WREPL_NODE_B,
2612 .num_ips = ARRAY_SIZE(addresses_B_1),
2613 .ips = addresses_B_1,
2614 .apply_expected = true
2618 .type = WREPL_TYPE_MHOMED,
2619 .state = WREPL_STATE_ACTIVE,
2620 .node = WREPL_NODE_B,
2622 .num_ips = ARRAY_SIZE(addresses_A_1),
2623 .ips = addresses_A_1,
2624 .apply_expected = true
2629 * group,tombstone vs. mhomed,tombstone
2630 * => should be replaced
2633 .line = __location__,
2634 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2637 .type = WREPL_TYPE_GROUP,
2638 .state = WREPL_STATE_TOMBSTONE,
2639 .node = WREPL_NODE_B,
2641 .num_ips = ARRAY_SIZE(addresses_A_1),
2642 .ips = addresses_A_1,
2643 .apply_expected = true
2647 .type = WREPL_TYPE_MHOMED,
2648 .state = WREPL_STATE_TOMBSTONE,
2649 .node = WREPL_NODE_B,
2651 .num_ips = ARRAY_SIZE(addresses_B_1),
2652 .ips = addresses_B_1,
2653 .apply_expected = true
2658 * special groups vs unique section,
2661 * sgroup,active vs. unique,active
2662 * => should NOT be replaced
2665 .line = __location__,
2666 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2669 .type = WREPL_TYPE_SGROUP,
2670 .state = WREPL_STATE_ACTIVE,
2671 .node = WREPL_NODE_B,
2673 .num_ips = ARRAY_SIZE(addresses_B_1),
2674 .ips = addresses_B_1,
2675 .apply_expected = true
2679 .type = WREPL_TYPE_UNIQUE,
2680 .state = WREPL_STATE_ACTIVE,
2681 .node = WREPL_NODE_B,
2683 .num_ips = ARRAY_SIZE(addresses_B_1),
2684 .ips = addresses_B_1,
2685 .apply_expected = false
2690 * sgroup,active vs. unique,tombstone
2691 * => should NOT be replaced
2694 .line = __location__,
2695 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2698 .type = WREPL_TYPE_SGROUP,
2699 .state = WREPL_STATE_ACTIVE,
2700 .node = WREPL_NODE_B,
2702 .num_ips = ARRAY_SIZE(addresses_B_1),
2703 .ips = addresses_B_1,
2704 .apply_expected = true
2708 .type = WREPL_TYPE_UNIQUE,
2709 .state = WREPL_STATE_TOMBSTONE,
2710 .node = WREPL_NODE_B,
2712 .num_ips = ARRAY_SIZE(addresses_B_1),
2713 .ips = addresses_B_1,
2714 .apply_expected = false
2719 * sgroup,released vs. unique,active
2720 * => should be replaced
2723 .line = __location__,
2724 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2727 .type = WREPL_TYPE_SGROUP,
2728 .state = WREPL_STATE_RELEASED,
2729 .node = WREPL_NODE_B,
2731 .num_ips = ARRAY_SIZE(addresses_B_1),
2732 .ips = addresses_B_1,
2733 .apply_expected = false
2737 .type = WREPL_TYPE_UNIQUE,
2738 .state = WREPL_STATE_ACTIVE,
2739 .node = WREPL_NODE_B,
2741 .num_ips = ARRAY_SIZE(addresses_A_1),
2742 .ips = addresses_A_1,
2743 .apply_expected = true
2748 * sgroup,released vs. unique,tombstone
2749 * => should be replaced
2752 .line = __location__,
2753 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2756 .type = WREPL_TYPE_SGROUP,
2757 .state = WREPL_STATE_RELEASED,
2758 .node = WREPL_NODE_B,
2760 .num_ips = ARRAY_SIZE(addresses_A_1),
2761 .ips = addresses_A_1,
2762 .apply_expected = false
2766 .type = WREPL_TYPE_UNIQUE,
2767 .state = WREPL_STATE_TOMBSTONE,
2768 .node = WREPL_NODE_B,
2770 .num_ips = ARRAY_SIZE(addresses_B_1),
2771 .ips = addresses_B_1,
2772 .apply_expected = true
2777 * sgroup,tombstone vs. unique,active
2778 * => should be replaced
2781 .line = __location__,
2782 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2785 .type = WREPL_TYPE_SGROUP,
2786 .state = WREPL_STATE_TOMBSTONE,
2787 .node = WREPL_NODE_B,
2789 .num_ips = ARRAY_SIZE(addresses_A_1),
2790 .ips = addresses_A_1,
2791 .apply_expected = true
2795 .type = WREPL_TYPE_UNIQUE,
2796 .state = WREPL_STATE_ACTIVE,
2797 .node = WREPL_NODE_B,
2799 .num_ips = ARRAY_SIZE(addresses_B_1),
2800 .ips = addresses_B_1,
2801 .apply_expected = true
2806 * sgroup,tombstone vs. unique,tombstone
2807 * => should be replaced
2810 .line = __location__,
2811 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2814 .type = WREPL_TYPE_SGROUP,
2815 .state = WREPL_STATE_TOMBSTONE,
2816 .node = WREPL_NODE_B,
2818 .num_ips = ARRAY_SIZE(addresses_B_1),
2819 .ips = addresses_B_1,
2820 .apply_expected = true
2824 .type = WREPL_TYPE_UNIQUE,
2825 .state = WREPL_STATE_TOMBSTONE,
2826 .node = WREPL_NODE_B,
2828 .num_ips = ARRAY_SIZE(addresses_A_1),
2829 .ips = addresses_A_1,
2830 .apply_expected = true
2835 * special groups vs normal group section,
2838 * sgroup,active vs. group,active
2839 * => should NOT be replaced
2842 .line = __location__,
2843 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2846 .type = WREPL_TYPE_SGROUP,
2847 .state = WREPL_STATE_ACTIVE,
2848 .node = WREPL_NODE_B,
2850 .num_ips = ARRAY_SIZE(addresses_A_1),
2851 .ips = addresses_A_1,
2852 .apply_expected = true
2856 .type = WREPL_TYPE_GROUP,
2857 .state = WREPL_STATE_ACTIVE,
2858 .node = WREPL_NODE_B,
2860 .num_ips = ARRAY_SIZE(addresses_A_1),
2861 .ips = addresses_A_1,
2862 .apply_expected = false
2867 * sgroup,active vs. group,tombstone
2868 * => should NOT be replaced
2871 .line = __location__,
2872 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2875 .type = WREPL_TYPE_SGROUP,
2876 .state = WREPL_STATE_ACTIVE,
2877 .node = WREPL_NODE_B,
2879 .num_ips = ARRAY_SIZE(addresses_A_1),
2880 .ips = addresses_A_1,
2881 .apply_expected = true
2885 .type = WREPL_TYPE_GROUP,
2886 .state = WREPL_STATE_TOMBSTONE,
2887 .node = WREPL_NODE_B,
2889 .num_ips = ARRAY_SIZE(addresses_A_1),
2890 .ips = addresses_A_1,
2891 .apply_expected = false
2896 * sgroup,released vs. group,active
2897 * => should be replaced
2900 .line = __location__,
2901 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2904 .type = WREPL_TYPE_SGROUP,
2905 .state = WREPL_STATE_RELEASED,
2906 .node = WREPL_NODE_B,
2908 .num_ips = ARRAY_SIZE(addresses_A_1),
2909 .ips = addresses_A_1,
2910 .apply_expected = false
2914 .type = WREPL_TYPE_GROUP,
2915 .state = WREPL_STATE_ACTIVE,
2916 .node = WREPL_NODE_B,
2918 .num_ips = ARRAY_SIZE(addresses_B_1),
2919 .ips = addresses_B_1,
2920 .apply_expected = true
2925 * sgroup,released vs. group,tombstone
2926 * => should be replaced
2929 .line = __location__,
2930 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2933 .type = WREPL_TYPE_SGROUP,
2934 .state = WREPL_STATE_RELEASED,
2935 .node = WREPL_NODE_B,
2937 .num_ips = ARRAY_SIZE(addresses_B_1),
2938 .ips = addresses_B_1,
2939 .apply_expected = false
2943 .type = WREPL_TYPE_GROUP,
2944 .state = WREPL_STATE_TOMBSTONE,
2945 .node = WREPL_NODE_B,
2947 .num_ips = ARRAY_SIZE(addresses_A_1),
2948 .ips = addresses_A_1,
2949 .apply_expected = true
2954 * sgroup,tombstone vs. group,active
2955 * => should NOT be replaced
2958 .line = __location__,
2959 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2962 .type = WREPL_TYPE_SGROUP,
2963 .state = WREPL_STATE_TOMBSTONE,
2964 .node = WREPL_NODE_B,
2966 .num_ips = ARRAY_SIZE(addresses_A_1),
2967 .ips = addresses_A_1,
2968 .apply_expected = true
2972 .type = WREPL_TYPE_GROUP,
2973 .state = WREPL_STATE_ACTIVE,
2974 .node = WREPL_NODE_B,
2976 .num_ips = ARRAY_SIZE(addresses_B_1),
2977 .ips = addresses_B_1,
2978 .apply_expected = true
2983 * sgroup,tombstone vs. group,tombstone
2984 * => should NOT be replaced
2987 .line = __location__,
2988 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
2991 .type = WREPL_TYPE_SGROUP,
2992 .state = WREPL_STATE_TOMBSTONE,
2993 .node = WREPL_NODE_B,
2995 .num_ips = ARRAY_SIZE(addresses_B_1),
2996 .ips = addresses_B_1,
2997 .apply_expected = true
3001 .type = WREPL_TYPE_GROUP,
3002 .state = WREPL_STATE_TOMBSTONE,
3003 .node = WREPL_NODE_B,
3005 .num_ips = ARRAY_SIZE(addresses_A_1),
3006 .ips = addresses_A_1,
3007 .apply_expected = true
3012 * special groups (not active) vs special group section,
3015 * sgroup,released vs. sgroup,active
3016 * => should be replaced
3019 .line = __location__,
3020 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3023 .type = WREPL_TYPE_SGROUP,
3024 .state = WREPL_STATE_RELEASED,
3025 .node = WREPL_NODE_B,
3027 .num_ips = ARRAY_SIZE(addresses_A_1),
3028 .ips = addresses_A_1,
3029 .apply_expected = false
3033 .type = WREPL_TYPE_SGROUP,
3034 .state = WREPL_STATE_ACTIVE,
3035 .node = WREPL_NODE_B,
3037 .num_ips = ARRAY_SIZE(addresses_B_1),
3038 .ips = addresses_B_1,
3039 .apply_expected = true
3044 * sgroup,released vs. sgroup,tombstone
3045 * => should be replaced
3048 .line = __location__,
3049 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3052 .type = WREPL_TYPE_SGROUP,
3053 .state = WREPL_STATE_RELEASED,
3054 .node = WREPL_NODE_B,
3056 .num_ips = ARRAY_SIZE(addresses_B_1),
3057 .ips = addresses_B_1,
3058 .apply_expected = false
3062 .type = WREPL_TYPE_SGROUP,
3063 .state = WREPL_STATE_TOMBSTONE,
3064 .node = WREPL_NODE_B,
3066 .num_ips = ARRAY_SIZE(addresses_A_1),
3067 .ips = addresses_A_1,
3068 .apply_expected = true
3073 * sgroup,tombstone vs. sgroup,active
3074 * => should NOT be replaced
3077 .line = __location__,
3078 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3081 .type = WREPL_TYPE_SGROUP,
3082 .state = WREPL_STATE_TOMBSTONE,
3083 .node = WREPL_NODE_B,
3085 .num_ips = ARRAY_SIZE(addresses_A_1),
3086 .ips = addresses_A_1,
3087 .apply_expected = true
3091 .type = WREPL_TYPE_SGROUP,
3092 .state = WREPL_STATE_ACTIVE,
3093 .node = WREPL_NODE_B,
3095 .num_ips = ARRAY_SIZE(addresses_B_1),
3096 .ips = addresses_B_1,
3097 .apply_expected = true
3102 * sgroup,tombstone vs. sgroup,tombstone
3103 * => should NOT be replaced
3106 .line = __location__,
3107 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3110 .type = WREPL_TYPE_SGROUP,
3111 .state = WREPL_STATE_TOMBSTONE,
3112 .node = WREPL_NODE_B,
3114 .num_ips = ARRAY_SIZE(addresses_B_1),
3115 .ips = addresses_B_1,
3116 .apply_expected = true
3120 .type = WREPL_TYPE_SGROUP,
3121 .state = WREPL_STATE_TOMBSTONE,
3122 .node = WREPL_NODE_B,
3124 .num_ips = ARRAY_SIZE(addresses_A_1),
3125 .ips = addresses_A_1,
3126 .apply_expected = true
3131 * special groups vs multi homed section,
3134 * sgroup,active vs. mhomed,active
3135 * => should NOT be replaced
3138 .line = __location__,
3139 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3142 .type = WREPL_TYPE_SGROUP,
3143 .state = WREPL_STATE_ACTIVE,
3144 .node = WREPL_NODE_B,
3146 .num_ips = ARRAY_SIZE(addresses_A_1),
3147 .ips = addresses_A_1,
3148 .apply_expected = true
3152 .type = WREPL_TYPE_MHOMED,
3153 .state = WREPL_STATE_ACTIVE,
3154 .node = WREPL_NODE_B,
3156 .num_ips = ARRAY_SIZE(addresses_A_1),
3157 .ips = addresses_A_1,
3158 .apply_expected = false
3163 * sgroup,active vs. mhomed,tombstone
3164 * => should NOT be replaced
3167 .line = __location__,
3168 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3171 .type = WREPL_TYPE_SGROUP,
3172 .state = WREPL_STATE_ACTIVE,
3173 .node = WREPL_NODE_B,
3175 .num_ips = ARRAY_SIZE(addresses_A_1),
3176 .ips = addresses_A_1,
3177 .apply_expected = true
3181 .type = WREPL_TYPE_MHOMED,
3182 .state = WREPL_STATE_TOMBSTONE,
3183 .node = WREPL_NODE_B,
3185 .num_ips = ARRAY_SIZE(addresses_A_1),
3186 .ips = addresses_A_1,
3187 .apply_expected = false
3192 * sgroup,released vs. mhomed,active
3193 * => should be replaced
3196 .line = __location__,
3197 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3200 .type = WREPL_TYPE_SGROUP,
3201 .state = WREPL_STATE_RELEASED,
3202 .node = WREPL_NODE_B,
3204 .num_ips = ARRAY_SIZE(addresses_A_1),
3205 .ips = addresses_A_1,
3206 .apply_expected = false
3210 .type = WREPL_TYPE_MHOMED,
3211 .state = WREPL_STATE_ACTIVE,
3212 .node = WREPL_NODE_B,
3214 .num_ips = ARRAY_SIZE(addresses_B_1),
3215 .ips = addresses_B_1,
3216 .apply_expected = true
3221 * sgroup,released vs. mhomed,tombstone
3222 * => should be replaced
3225 .line = __location__,
3226 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3229 .type = WREPL_TYPE_SGROUP,
3230 .state = WREPL_STATE_RELEASED,
3231 .node = WREPL_NODE_B,
3233 .num_ips = ARRAY_SIZE(addresses_B_1),
3234 .ips = addresses_B_1,
3235 .apply_expected = false
3239 .type = WREPL_TYPE_MHOMED,
3240 .state = WREPL_STATE_TOMBSTONE,
3241 .node = WREPL_NODE_B,
3243 .num_ips = ARRAY_SIZE(addresses_A_1),
3244 .ips = addresses_A_1,
3245 .apply_expected = true
3250 * sgroup,tombstone vs. mhomed,active
3251 * => should be replaced
3254 .line = __location__,
3255 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3258 .type = WREPL_TYPE_SGROUP,
3259 .state = WREPL_STATE_TOMBSTONE,
3260 .node = WREPL_NODE_B,
3262 .num_ips = ARRAY_SIZE(addresses_A_1),
3263 .ips = addresses_A_1,
3264 .apply_expected = true
3268 .type = WREPL_TYPE_MHOMED,
3269 .state = WREPL_STATE_ACTIVE,
3270 .node = WREPL_NODE_B,
3272 .num_ips = ARRAY_SIZE(addresses_B_1),
3273 .ips = addresses_B_1,
3274 .apply_expected = true
3279 * sgroup,tombstone vs. mhomed,tombstone
3280 * => should be replaced
3283 .line = __location__,
3284 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3287 .type = WREPL_TYPE_SGROUP,
3288 .state = WREPL_STATE_TOMBSTONE,
3289 .node = WREPL_NODE_B,
3291 .num_ips = ARRAY_SIZE(addresses_B_1),
3292 .ips = addresses_B_1,
3293 .apply_expected = true
3297 .type = WREPL_TYPE_MHOMED,
3298 .state = WREPL_STATE_TOMBSTONE,
3299 .node = WREPL_NODE_B,
3301 .num_ips = ARRAY_SIZE(addresses_A_1),
3302 .ips = addresses_A_1,
3303 .apply_expected = true
3308 * multi homed vs. unique section,
3311 * mhomed,active vs. unique,active
3312 * => should be replaced
3315 .line = __location__,
3316 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3319 .type = WREPL_TYPE_MHOMED,
3320 .state = WREPL_STATE_ACTIVE,
3321 .node = WREPL_NODE_B,
3323 .num_ips = ARRAY_SIZE(addresses_A_3_4),
3324 .ips = addresses_A_3_4,
3325 .apply_expected = true
3329 .type = WREPL_TYPE_UNIQUE,
3330 .state = WREPL_STATE_ACTIVE,
3331 .node = WREPL_NODE_B,
3333 .num_ips = ARRAY_SIZE(addresses_B_1),
3334 .ips = addresses_B_1,
3335 .apply_expected = true
3340 * mhomed,active vs. unique,tombstone
3341 * => should NOT be replaced
3344 .line = __location__,
3345 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3348 .type = WREPL_TYPE_MHOMED,
3349 .state = WREPL_STATE_ACTIVE,
3350 .node = WREPL_NODE_B,
3352 .num_ips = ARRAY_SIZE(addresses_B_1),
3353 .ips = addresses_B_1,
3354 .apply_expected = true
3358 .type = WREPL_TYPE_UNIQUE,
3359 .state = WREPL_STATE_TOMBSTONE,
3360 .node = WREPL_NODE_B,
3362 .num_ips = ARRAY_SIZE(addresses_B_1),
3363 .ips = addresses_B_1,
3364 .apply_expected = false
3369 * mhomed,released vs. unique,active
3370 * => should be replaced
3373 .line = __location__,
3374 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3377 .type = WREPL_TYPE_MHOMED,
3378 .state = WREPL_STATE_RELEASED,
3379 .node = WREPL_NODE_B,
3381 .num_ips = ARRAY_SIZE(addresses_A_1),
3382 .ips = addresses_A_1,
3383 .apply_expected = false
3387 .type = WREPL_TYPE_UNIQUE,
3388 .state = WREPL_STATE_ACTIVE,
3389 .node = WREPL_NODE_B,
3391 .num_ips = ARRAY_SIZE(addresses_B_1),
3392 .ips = addresses_B_1,
3393 .apply_expected = true
3398 * mhomed,released vs. uinique,tombstone
3399 * => should be replaced
3402 .line = __location__,
3403 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3406 .type = WREPL_TYPE_MHOMED,
3407 .state = WREPL_STATE_RELEASED,
3408 .node = WREPL_NODE_B,
3410 .num_ips = ARRAY_SIZE(addresses_B_1),
3411 .ips = addresses_B_1,
3412 .apply_expected = false
3416 .type = WREPL_TYPE_UNIQUE,
3417 .state = WREPL_STATE_TOMBSTONE,
3418 .node = WREPL_NODE_B,
3420 .num_ips = ARRAY_SIZE(addresses_A_1),
3421 .ips = addresses_A_1,
3422 .apply_expected = true
3427 * mhomed,tombstone vs. unique,active
3428 * => should be replaced
3431 .line = __location__,
3432 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3435 .type = WREPL_TYPE_MHOMED,
3436 .state = WREPL_STATE_TOMBSTONE,
3437 .node = WREPL_NODE_B,
3439 .num_ips = ARRAY_SIZE(addresses_A_1),
3440 .ips = addresses_A_1,
3441 .apply_expected = true
3445 .type = WREPL_TYPE_UNIQUE,
3446 .state = WREPL_STATE_ACTIVE,
3447 .node = WREPL_NODE_B,
3449 .num_ips = ARRAY_SIZE(addresses_B_1),
3450 .ips = addresses_B_1,
3451 .apply_expected = true
3456 * mhomed,tombstone vs. uinique,tombstone
3457 * => should be replaced
3460 .line = __location__,
3461 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3464 .type = WREPL_TYPE_MHOMED,
3465 .state = WREPL_STATE_TOMBSTONE,
3466 .node = WREPL_NODE_B,
3468 .num_ips = ARRAY_SIZE(addresses_B_1),
3469 .ips = addresses_B_1,
3470 .apply_expected = true
3474 .type = WREPL_TYPE_UNIQUE,
3475 .state = WREPL_STATE_TOMBSTONE,
3476 .node = WREPL_NODE_B,
3478 .num_ips = ARRAY_SIZE(addresses_A_1),
3479 .ips = addresses_A_1,
3480 .apply_expected = true
3485 * multi homed vs. normal group section,
3488 * mhomed,active vs. group,active
3489 * => should be replaced
3492 .line = __location__,
3493 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3496 .type = WREPL_TYPE_MHOMED,
3497 .state = WREPL_STATE_ACTIVE,
3498 .node = WREPL_NODE_B,
3500 .num_ips = ARRAY_SIZE(addresses_A_1),
3501 .ips = addresses_A_1,
3502 .apply_expected = true
3506 .type = WREPL_TYPE_GROUP,
3507 .state = WREPL_STATE_ACTIVE,
3508 .node = WREPL_NODE_B,
3510 .num_ips = ARRAY_SIZE(addresses_B_1),
3511 .ips = addresses_B_1,
3512 .apply_expected = true
3517 * mhomed,active vs. group,tombstone
3518 * => should NOT be replaced
3521 .line = __location__,
3522 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3525 .type = WREPL_TYPE_MHOMED,
3526 .state = WREPL_STATE_ACTIVE,
3527 .node = WREPL_NODE_B,
3529 .num_ips = ARRAY_SIZE(addresses_B_1),
3530 .ips = addresses_B_1,
3531 .apply_expected = true
3535 .type = WREPL_TYPE_GROUP,
3536 .state = WREPL_STATE_TOMBSTONE,
3537 .node = WREPL_NODE_B,
3539 .num_ips = ARRAY_SIZE(addresses_B_1),
3540 .ips = addresses_B_1,
3541 .apply_expected = false
3546 * mhomed,released vs. group,active
3547 * => should be replaced
3550 .line = __location__,
3551 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3554 .type = WREPL_TYPE_MHOMED,
3555 .state = WREPL_STATE_RELEASED,
3556 .node = WREPL_NODE_B,
3558 .num_ips = ARRAY_SIZE(addresses_B_1),
3559 .ips = addresses_B_1,
3560 .apply_expected = false
3564 .type = WREPL_TYPE_GROUP,
3565 .state = WREPL_STATE_ACTIVE,
3566 .node = WREPL_NODE_B,
3568 .num_ips = ARRAY_SIZE(addresses_A_1),
3569 .ips = addresses_A_1,
3570 .apply_expected = true
3575 * mhomed,released vs. group,tombstone
3576 * => should be replaced
3579 .line = __location__,
3580 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3583 .type = WREPL_TYPE_MHOMED,
3584 .state = WREPL_STATE_RELEASED,
3585 .node = WREPL_NODE_B,
3587 .num_ips = ARRAY_SIZE(addresses_A_1),
3588 .ips = addresses_A_1,
3589 .apply_expected = false
3593 .type = WREPL_TYPE_GROUP,
3594 .state = WREPL_STATE_TOMBSTONE,
3595 .node = WREPL_NODE_B,
3597 .num_ips = ARRAY_SIZE(addresses_B_1),
3598 .ips = addresses_B_1,
3599 .apply_expected = true
3604 * mhomed,tombstone vs. group,active
3605 * => should be replaced
3608 .line = __location__,
3609 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3612 .type = WREPL_TYPE_MHOMED,
3613 .state = WREPL_STATE_TOMBSTONE,
3614 .node = WREPL_NODE_B,
3616 .num_ips = ARRAY_SIZE(addresses_B_1),
3617 .ips = addresses_B_1,
3618 .apply_expected = true
3622 .type = WREPL_TYPE_GROUP,
3623 .state = WREPL_STATE_ACTIVE,
3624 .node = WREPL_NODE_B,
3626 .num_ips = ARRAY_SIZE(addresses_A_1),
3627 .ips = addresses_A_1,
3628 .apply_expected = true
3633 * mhomed,tombstone vs. group,tombstone
3634 * => should be replaced
3637 .line = __location__,
3638 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3641 .type = WREPL_TYPE_MHOMED,
3642 .state = WREPL_STATE_TOMBSTONE,
3643 .node = WREPL_NODE_B,
3645 .num_ips = ARRAY_SIZE(addresses_A_1),
3646 .ips = addresses_A_1,
3647 .apply_expected = true
3651 .type = WREPL_TYPE_GROUP,
3652 .state = WREPL_STATE_TOMBSTONE,
3653 .node = WREPL_NODE_B,
3655 .num_ips = ARRAY_SIZE(addresses_B_1),
3656 .ips = addresses_B_1,
3657 .apply_expected = true
3662 * multi homed vs. special group section,
3665 * mhomed,active vs. sgroup,active
3666 * => should NOT be replaced
3669 .line = __location__,
3670 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3673 .type = WREPL_TYPE_MHOMED,
3674 .state = WREPL_STATE_ACTIVE,
3675 .node = WREPL_NODE_B,
3677 .num_ips = ARRAY_SIZE(addresses_A_1),
3678 .ips = addresses_A_1,
3679 .apply_expected = true
3683 .type = WREPL_TYPE_SGROUP,
3684 .state = WREPL_STATE_ACTIVE,
3685 .node = WREPL_NODE_B,
3687 .num_ips = ARRAY_SIZE(addresses_A_1),
3688 .ips = addresses_A_1,
3689 .apply_expected = false
3694 * mhomed,active vs. sgroup,tombstone
3695 * => should NOT be replaced
3698 .line = __location__,
3699 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3702 .type = WREPL_TYPE_MHOMED,
3703 .state = WREPL_STATE_ACTIVE,
3704 .node = WREPL_NODE_B,
3706 .num_ips = ARRAY_SIZE(addresses_A_1),
3707 .ips = addresses_A_1,
3708 .apply_expected = true
3712 .type = WREPL_TYPE_SGROUP,
3713 .state = WREPL_STATE_TOMBSTONE,
3714 .node = WREPL_NODE_B,
3716 .num_ips = ARRAY_SIZE(addresses_A_1),
3717 .ips = addresses_A_1,
3718 .apply_expected = false
3723 * mhomed,released vs. sgroup,active
3724 * => should be replaced
3727 .line = __location__,
3728 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3731 .type = WREPL_TYPE_MHOMED,
3732 .state = WREPL_STATE_RELEASED,
3733 .node = WREPL_NODE_B,
3735 .num_ips = ARRAY_SIZE(addresses_A_1),
3736 .ips = addresses_A_1,
3737 .apply_expected = false
3741 .type = WREPL_TYPE_SGROUP,
3742 .state = WREPL_STATE_ACTIVE,
3743 .node = WREPL_NODE_B,
3745 .num_ips = ARRAY_SIZE(addresses_B_1),
3746 .ips = addresses_B_1,
3747 .apply_expected = true
3752 * mhomed,released vs. sgroup,tombstone
3753 * => should be replaced
3756 .line = __location__,
3757 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3760 .type = WREPL_TYPE_MHOMED,
3761 .state = WREPL_STATE_RELEASED,
3762 .node = WREPL_NODE_B,
3764 .num_ips = ARRAY_SIZE(addresses_B_1),
3765 .ips = addresses_B_1,
3766 .apply_expected = false
3770 .type = WREPL_TYPE_SGROUP,
3771 .state = WREPL_STATE_TOMBSTONE,
3772 .node = WREPL_NODE_B,
3774 .num_ips = ARRAY_SIZE(addresses_A_1),
3775 .ips = addresses_A_1,
3776 .apply_expected = true
3781 * mhomed,tombstone vs. sgroup,active
3782 * => should be replaced
3785 .line = __location__,
3786 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3789 .type = WREPL_TYPE_MHOMED,
3790 .state = WREPL_STATE_TOMBSTONE,
3791 .node = WREPL_NODE_B,
3793 .num_ips = ARRAY_SIZE(addresses_A_1),
3794 .ips = addresses_A_1,
3795 .apply_expected = true
3799 .type = WREPL_TYPE_SGROUP,
3800 .state = WREPL_STATE_ACTIVE,
3801 .node = WREPL_NODE_B,
3803 .num_ips = ARRAY_SIZE(addresses_B_1),
3804 .ips = addresses_B_1,
3805 .apply_expected = true
3810 * mhomed,tombstone vs. sgroup,tombstone
3811 * => should be replaced
3814 .line = __location__,
3815 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3818 .type = WREPL_TYPE_MHOMED,
3819 .state = WREPL_STATE_TOMBSTONE,
3820 .node = WREPL_NODE_B,
3822 .num_ips = ARRAY_SIZE(addresses_B_1),
3823 .ips = addresses_B_1,
3824 .apply_expected = true
3828 .type = WREPL_TYPE_SGROUP,
3829 .state = WREPL_STATE_TOMBSTONE,
3830 .node = WREPL_NODE_B,
3832 .num_ips = ARRAY_SIZE(addresses_A_1),
3833 .ips = addresses_A_1,
3834 .apply_expected = true
3839 * multi homed vs. mlti homed section,
3842 * mhomed,active vs. mhomed,active
3843 * => should be replaced
3846 .line = __location__,
3847 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3850 .type = WREPL_TYPE_MHOMED,
3851 .state = WREPL_STATE_ACTIVE,
3852 .node = WREPL_NODE_B,
3854 .num_ips = ARRAY_SIZE(addresses_A_3_4),
3855 .ips = addresses_A_3_4,
3856 .apply_expected = true
3860 .type = WREPL_TYPE_MHOMED,
3861 .state = WREPL_STATE_ACTIVE,
3862 .node = WREPL_NODE_B,
3864 .num_ips = ARRAY_SIZE(addresses_B_3_4),
3865 .ips = addresses_B_3_4,
3866 .apply_expected = true
3871 * mhomed,active vs. mhomed,tombstone
3872 * => should NOT be replaced
3875 .line = __location__,
3876 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3879 .type = WREPL_TYPE_MHOMED,
3880 .state = WREPL_STATE_ACTIVE,
3881 .node = WREPL_NODE_B,
3883 .num_ips = ARRAY_SIZE(addresses_B_3_4),
3884 .ips = addresses_B_3_4,
3885 .apply_expected = true
3889 .type = WREPL_TYPE_MHOMED,
3890 .state = WREPL_STATE_TOMBSTONE,
3891 .node = WREPL_NODE_B,
3893 .num_ips = ARRAY_SIZE(addresses_B_3_4),
3894 .ips = addresses_B_3_4,
3895 .apply_expected = false
3900 * mhomed,released vs. mhomed,active
3901 * => should be replaced
3904 .line = __location__,
3905 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3908 .type = WREPL_TYPE_MHOMED,
3909 .state = WREPL_STATE_RELEASED,
3910 .node = WREPL_NODE_B,
3912 .num_ips = ARRAY_SIZE(addresses_B_3_4),
3913 .ips = addresses_B_3_4,
3914 .apply_expected = false
3918 .type = WREPL_TYPE_MHOMED,
3919 .state = WREPL_STATE_ACTIVE,
3920 .node = WREPL_NODE_B,
3922 .num_ips = ARRAY_SIZE(addresses_A_3_4),
3923 .ips = addresses_A_3_4,
3924 .apply_expected = true
3929 * mhomed,released vs. mhomed,tombstone
3930 * => should be replaced
3933 .line = __location__,
3934 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3937 .type = WREPL_TYPE_MHOMED,
3938 .state = WREPL_STATE_RELEASED,
3939 .node = WREPL_NODE_B,
3941 .num_ips = ARRAY_SIZE(addresses_A_3_4),
3942 .ips = addresses_A_3_4,
3943 .apply_expected = false
3947 .type = WREPL_TYPE_MHOMED,
3948 .state = WREPL_STATE_TOMBSTONE,
3949 .node = WREPL_NODE_B,
3951 .num_ips = ARRAY_SIZE(addresses_B_3_4),
3952 .ips = addresses_B_3_4,
3953 .apply_expected = true
3958 * mhomed,tombstone vs. mhomed,active
3959 * => should be replaced
3962 .line = __location__,
3963 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3966 .type = WREPL_TYPE_MHOMED,
3967 .state = WREPL_STATE_TOMBSTONE,
3968 .node = WREPL_NODE_B,
3970 .num_ips = ARRAY_SIZE(addresses_B_3_4),
3971 .ips = addresses_B_3_4,
3972 .apply_expected = true
3976 .type = WREPL_TYPE_MHOMED,
3977 .state = WREPL_STATE_ACTIVE,
3978 .node = WREPL_NODE_B,
3980 .num_ips = ARRAY_SIZE(addresses_A_3_4),
3981 .ips = addresses_A_3_4,
3982 .apply_expected = true
3987 * mhomed,tombstone vs. mhomed,tombstone
3988 * => should be replaced
3991 .line = __location__,
3992 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
3995 .type = WREPL_TYPE_MHOMED,
3996 .state = WREPL_STATE_TOMBSTONE,
3997 .node = WREPL_NODE_B,
3999 .num_ips = ARRAY_SIZE(addresses_A_3_4),
4000 .ips = addresses_A_3_4,
4001 .apply_expected = true
4005 .type = WREPL_TYPE_MHOMED,
4006 .state = WREPL_STATE_TOMBSTONE,
4007 .node = WREPL_NODE_B,
4009 .num_ips = ARRAY_SIZE(addresses_B_3_4),
4010 .ips = addresses_B_3_4,
4011 .apply_expected = true
4015 .line = __location__,
4016 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4020 .type = WREPL_TYPE_UNIQUE,
4021 .state = WREPL_STATE_TOMBSTONE,
4022 .node = WREPL_NODE_B,
4024 .num_ips = ARRAY_SIZE(addresses_B_1),
4025 .ips = addresses_B_1,
4026 .apply_expected = true,
4030 .type = WREPL_TYPE_UNIQUE,
4031 .state = WREPL_STATE_TOMBSTONE,
4032 .node = WREPL_NODE_B,
4034 .num_ips = ARRAY_SIZE(addresses_A_1),
4035 .ips = addresses_A_1,
4036 .apply_expected = true,
4040 * special group vs special group section,
4043 * sgroup,active vs. sgroup,active same addresses
4044 * => should be NOT replaced
4047 .line = __location__,
4048 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4049 .comment= "A:A_3_4 vs. B:A_3_4",
4053 .type = WREPL_TYPE_SGROUP,
4054 .state = WREPL_STATE_ACTIVE,
4055 .node = WREPL_NODE_B,
4057 .num_ips = ARRAY_SIZE(addresses_A_3_4),
4058 .ips = addresses_A_3_4,
4059 .apply_expected = true
4063 .type = WREPL_TYPE_SGROUP,
4064 .state = WREPL_STATE_ACTIVE,
4065 .node = WREPL_NODE_B,
4067 .num_ips = ARRAY_SIZE(addresses_A_3_4),
4068 .ips = addresses_A_3_4,
4069 .apply_expected = false,
4070 .sgroup_cleanup = true
4074 * sgroup,active vs. sgroup,active same addresses
4075 * => should be NOT replaced
4078 .line = __location__,
4079 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4080 .comment= "A:A_3_4 vs. B:NULL",
4084 .type = WREPL_TYPE_SGROUP,
4085 .state = WREPL_STATE_ACTIVE,
4086 .node = WREPL_NODE_B,
4088 .num_ips = ARRAY_SIZE(addresses_A_3_4),
4089 .ips = addresses_A_3_4,
4090 .apply_expected = true
4094 .type = WREPL_TYPE_SGROUP,
4095 .state = WREPL_STATE_ACTIVE,
4096 .node = WREPL_NODE_B,
4100 .apply_expected = false,
4101 .sgroup_cleanup = true
4105 * sgroup,active vs. sgroup,active subset addresses, special case...
4106 * => should NOT be replaced
4109 .line = __location__,
4110 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4111 .comment= "A:A_3_4_X_3_4 vs. B:A_3_4",
4115 .type = WREPL_TYPE_SGROUP,
4116 .state = WREPL_STATE_ACTIVE,
4117 .node = WREPL_NODE_B,
4119 .num_ips = ARRAY_SIZE(addresses_A_3_4_X_3_4),
4120 .ips = addresses_A_3_4_X_3_4,
4121 .apply_expected = true,
4125 .type = WREPL_TYPE_SGROUP,
4126 .state = WREPL_STATE_ACTIVE,
4127 .node = WREPL_NODE_B,
4129 .num_ips = ARRAY_SIZE(addresses_A_3_4),
4130 .ips = addresses_A_3_4,
4131 .apply_expected = false,
4135 .line = __location__,
4136 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4140 .type = WREPL_TYPE_SGROUP,
4141 .state = WREPL_STATE_ACTIVE,
4142 .node = WREPL_NODE_B,
4146 .apply_expected = false,
4150 .type = WREPL_TYPE_SGROUP,
4151 .state = WREPL_STATE_ACTIVE,
4152 .node = WREPL_NODE_B,
4156 .apply_expected = false,
4160 * sgroup,active vs. sgroup,active different addresses, but owner changed
4161 * => should be replaced
4164 .line = __location__,
4165 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4166 .comment= "A:B_3_4 vs. B:A_3_4",
4170 .type = WREPL_TYPE_SGROUP,
4171 .state = WREPL_STATE_ACTIVE,
4172 .node = WREPL_NODE_B,
4174 .num_ips = ARRAY_SIZE(addresses_B_3_4),
4175 .ips = addresses_B_3_4,
4176 .apply_expected = true,
4180 .type = WREPL_TYPE_SGROUP,
4181 .state = WREPL_STATE_ACTIVE,
4182 .node = WREPL_NODE_B,
4184 .num_ips = ARRAY_SIZE(addresses_A_3_4),
4185 .ips = addresses_A_3_4,
4186 .apply_expected = true,
4187 .sgroup_cleanup = true
4191 * sgroup,active vs. sgroup,active different addresses, but owner changed
4192 * => should be replaced
4195 .line = __location__,
4196 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4197 .comment= "A:A_3_4 vs. B:A_3_4_OWNER_B",
4201 .type = WREPL_TYPE_SGROUP,
4202 .state = WREPL_STATE_ACTIVE,
4203 .node = WREPL_NODE_B,
4205 .num_ips = ARRAY_SIZE(addresses_A_3_4),
4206 .ips = addresses_A_3_4,
4207 .apply_expected = true,
4211 .type = WREPL_TYPE_SGROUP,
4212 .state = WREPL_STATE_ACTIVE,
4213 .node = WREPL_NODE_B,
4215 .num_ips = ARRAY_SIZE(addresses_A_3_4_OWNER_B),
4216 .ips = addresses_A_3_4_OWNER_B,
4217 .apply_expected = true,
4218 .sgroup_cleanup = true
4222 * sgroup,active vs. sgroup,active different addresses, but owner changed
4223 * => should be replaced
4226 .line = __location__,
4227 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4228 .comment= "A:A_3_4_OWNER_B vs. B:A_3_4",
4232 .type = WREPL_TYPE_SGROUP,
4233 .state = WREPL_STATE_ACTIVE,
4234 .node = WREPL_NODE_B,
4236 .num_ips = ARRAY_SIZE(addresses_A_3_4_OWNER_B),
4237 .ips = addresses_A_3_4_OWNER_B,
4238 .apply_expected = true,
4242 .type = WREPL_TYPE_SGROUP,
4243 .state = WREPL_STATE_ACTIVE,
4244 .node = WREPL_NODE_B,
4246 .num_ips = ARRAY_SIZE(addresses_A_3_4),
4247 .ips = addresses_A_3_4,
4248 .apply_expected = true,
4249 .sgroup_cleanup = true
4253 * sgroup,active vs. sgroup,active different addresses
4254 * => should be merged
4257 .line = __location__,
4258 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4259 .comment= "A:A_3_4 vs. B:B_3_4 => C:A_3_4_B_3_4",
4263 .type = WREPL_TYPE_SGROUP,
4264 .state = WREPL_STATE_ACTIVE,
4265 .node = WREPL_NODE_B,
4267 .num_ips = ARRAY_SIZE(addresses_A_3_4),
4268 .ips = addresses_A_3_4,
4269 .apply_expected = true,
4273 .type = WREPL_TYPE_SGROUP,
4274 .state = WREPL_STATE_ACTIVE,
4275 .node = WREPL_NODE_B,
4277 .num_ips = ARRAY_SIZE(addresses_B_3_4),
4278 .ips = addresses_B_3_4,
4279 .sgroup_merge = true,
4280 .sgroup_cleanup = true,
4284 * sgroup,active vs. sgroup,active different addresses, special case...
4285 * => should be merged
4288 .line = __location__,
4289 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4290 .comment= "A:B_3_4_X_3_4 vs. B:A_3_4 => B:A_3_4_X_3_4",
4294 .type = WREPL_TYPE_SGROUP,
4295 .state = WREPL_STATE_ACTIVE,
4296 .node = WREPL_NODE_B,
4298 .num_ips = ARRAY_SIZE(addresses_B_3_4_X_3_4),
4299 .ips = addresses_B_3_4_X_3_4,
4300 .apply_expected = true,
4304 .type = WREPL_TYPE_SGROUP,
4305 .state = WREPL_STATE_ACTIVE,
4306 .node = WREPL_NODE_B,
4308 .num_ips = ARRAY_SIZE(addresses_A_3_4),
4309 .ips = addresses_A_3_4,
4310 .sgroup_merge = true,
4311 .merge_owner = &ctx->b,
4312 .sgroup_cleanup = false
4316 .line = __location__,
4317 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4321 .type = WREPL_TYPE_SGROUP,
4322 .state = WREPL_STATE_ACTIVE,
4323 .node = WREPL_NODE_B,
4325 .num_ips = ARRAY_SIZE(addresses_A_3_4_X_3_4_OWNER_B),
4326 .ips = addresses_A_3_4_X_3_4_OWNER_B,
4327 .apply_expected = true,
4331 .type = WREPL_TYPE_SGROUP,
4332 .state = WREPL_STATE_ACTIVE,
4333 .node = WREPL_NODE_B,
4337 .apply_expected = false,
4341 * sgroup,active vs. sgroup,active different addresses, special case...
4342 * => should be merged
4345 .line = __location__,
4346 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4347 .comment= "A:X_3_4 vs. B:A_3_4 => C:A_3_4_X_3_4",
4351 .type = WREPL_TYPE_SGROUP,
4352 .state = WREPL_STATE_ACTIVE,
4353 .node = WREPL_NODE_B,
4355 .num_ips = ARRAY_SIZE(addresses_X_3_4),
4356 .ips = addresses_X_3_4,
4357 .apply_expected = true,
4361 .type = WREPL_TYPE_SGROUP,
4362 .state = WREPL_STATE_ACTIVE,
4363 .node = WREPL_NODE_B,
4365 .num_ips = ARRAY_SIZE(addresses_A_3_4),
4366 .ips = addresses_A_3_4,
4367 .sgroup_merge = true,
4368 .sgroup_cleanup = false
4372 .line = __location__,
4373 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4377 .type = WREPL_TYPE_SGROUP,
4378 .state = WREPL_STATE_ACTIVE,
4379 .node = WREPL_NODE_B,
4383 .apply_expected = false,
4387 .type = WREPL_TYPE_SGROUP,
4388 .state = WREPL_STATE_ACTIVE,
4389 .node = WREPL_NODE_B,
4393 .apply_expected = false,
4397 * sgroup,active vs. sgroup,active different addresses, special case...
4398 * => should be merged
4401 .line = __location__,
4402 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4403 .comment= "A:A_3_4_X_3_4 vs. B:A_3_4_OWNER_B => B:A_3_4_OWNER_B_X_3_4",
4407 .type = WREPL_TYPE_SGROUP,
4408 .state = WREPL_STATE_ACTIVE,
4409 .node = WREPL_NODE_B,
4411 .num_ips = ARRAY_SIZE(addresses_A_3_4_X_3_4),
4412 .ips = addresses_A_3_4_X_3_4,
4413 .apply_expected = true,
4417 .type = WREPL_TYPE_SGROUP,
4418 .state = WREPL_STATE_ACTIVE,
4419 .node = WREPL_NODE_B,
4421 .num_ips = ARRAY_SIZE(addresses_A_3_4_OWNER_B),
4422 .ips = addresses_A_3_4_OWNER_B,
4423 .sgroup_merge = true,
4424 .merge_owner = &ctx->b,
4428 .line = __location__,
4429 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4433 .type = WREPL_TYPE_SGROUP,
4434 .state = WREPL_STATE_ACTIVE,
4435 .node = WREPL_NODE_B,
4439 .apply_expected = false,
4443 .type = WREPL_TYPE_SGROUP,
4444 .state = WREPL_STATE_ACTIVE,
4445 .node = WREPL_NODE_B,
4449 .apply_expected = false,
4453 * sgroup,active vs. sgroup,active partly different addresses, special case...
4454 * => should be merged
4457 .line = __location__,
4458 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4459 .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",
4463 .type = WREPL_TYPE_SGROUP,
4464 .state = WREPL_STATE_ACTIVE,
4465 .node = WREPL_NODE_B,
4467 .num_ips = ARRAY_SIZE(addresses_B_3_4_X_3_4),
4468 .ips = addresses_B_3_4_X_3_4,
4469 .apply_expected = true,
4473 .type = WREPL_TYPE_SGROUP,
4474 .state = WREPL_STATE_ACTIVE,
4475 .node = WREPL_NODE_B,
4477 .num_ips = ARRAY_SIZE(addresses_B_3_4_X_1_2),
4478 .ips = addresses_B_3_4_X_1_2,
4479 .sgroup_merge = true,
4480 .sgroup_cleanup = false
4484 .line = __location__,
4485 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4489 .type = WREPL_TYPE_SGROUP,
4490 .state = WREPL_STATE_ACTIVE,
4491 .node = WREPL_NODE_B,
4495 .apply_expected = false,
4499 .type = WREPL_TYPE_SGROUP,
4500 .state = WREPL_STATE_ACTIVE,
4501 .node = WREPL_NODE_B,
4505 .apply_expected = false,
4509 * sgroup,active vs. sgroup,active different addresses, special case...
4510 * => should be merged
4513 .line = __location__,
4514 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4515 .comment= "A:A_3_4_B_3_4 vs. B:NULL => B:A_3_4",
4519 .type = WREPL_TYPE_SGROUP,
4520 .state = WREPL_STATE_ACTIVE,
4521 .node = WREPL_NODE_B,
4523 .num_ips = ARRAY_SIZE(addresses_A_3_4_B_3_4),
4524 .ips = addresses_A_3_4_B_3_4,
4525 .apply_expected = true,
4529 .type = WREPL_TYPE_SGROUP,
4530 .state = WREPL_STATE_ACTIVE,
4531 .node = WREPL_NODE_B,
4535 .sgroup_merge = true,
4536 .merge_owner = &ctx->b,
4537 .sgroup_cleanup = true
4541 .line = __location__,
4542 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4546 .type = WREPL_TYPE_SGROUP,
4547 .state = WREPL_STATE_ACTIVE,
4548 .node = WREPL_NODE_B,
4552 .apply_expected = false,
4556 .type = WREPL_TYPE_UNIQUE,
4557 .state = WREPL_STATE_TOMBSTONE,
4558 .node = WREPL_NODE_B,
4560 .num_ips = ARRAY_SIZE(addresses_A_1),
4561 .ips = addresses_A_1,
4562 .apply_expected = true,
4566 * sgroup,active vs. sgroup,active different addresses, special case...
4567 * => should be merged
4570 .line = __location__,
4571 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4572 .comment= "A:B_3_4_X_3_4 vs. B:NULL => B:X_3_4",
4576 .type = WREPL_TYPE_SGROUP,
4577 .state = WREPL_STATE_ACTIVE,
4578 .node = WREPL_NODE_B,
4580 .num_ips = ARRAY_SIZE(addresses_B_3_4_X_3_4),
4581 .ips = addresses_B_3_4_X_3_4,
4582 .apply_expected = true,
4586 .type = WREPL_TYPE_SGROUP,
4587 .state = WREPL_STATE_ACTIVE,
4588 .node = WREPL_NODE_B,
4592 .sgroup_merge = true,
4593 .merge_owner = &ctx->b,
4594 .sgroup_cleanup = true
4598 .line = __location__,
4599 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4603 .type = WREPL_TYPE_SGROUP,
4604 .state = WREPL_STATE_ACTIVE,
4605 .node = WREPL_NODE_B,
4609 .apply_expected = false,
4613 .type = WREPL_TYPE_UNIQUE,
4614 .state = WREPL_STATE_TOMBSTONE,
4615 .node = WREPL_NODE_B,
4617 .num_ips = ARRAY_SIZE(addresses_A_1),
4618 .ips = addresses_A_1,
4619 .apply_expected = true,
4624 * sgroup,active vs. sgroup,tombstone different no addresses, special
4625 * => should be replaced
4628 .line = __location__,
4629 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4630 .comment= "A:B_3_4_X_3_4 vs. B:NULL => B:NULL",
4634 .type = WREPL_TYPE_SGROUP,
4635 .state = WREPL_STATE_ACTIVE,
4636 .node = WREPL_NODE_B,
4638 .num_ips = ARRAY_SIZE(addresses_B_3_4_X_3_4),
4639 .ips = addresses_B_3_4_X_3_4,
4640 .apply_expected = true,
4644 .type = WREPL_TYPE_SGROUP,
4645 .state = WREPL_STATE_TOMBSTONE,
4646 .node = WREPL_NODE_B,
4650 .apply_expected = true,
4654 * sgroup,active vs. sgroup,tombstone different addresses
4655 * => should be replaced
4658 .line = __location__,
4659 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4660 .comment= "A:B_3_4_X_3_4 vs. B:A_3_4 => B:A_3_4",
4664 .type = WREPL_TYPE_SGROUP,
4665 .state = WREPL_STATE_ACTIVE,
4666 .node = WREPL_NODE_B,
4668 .num_ips = ARRAY_SIZE(addresses_B_3_4_X_3_4),
4669 .ips = addresses_B_3_4_X_3_4,
4670 .apply_expected = true,
4674 .type = WREPL_TYPE_SGROUP,
4675 .state = WREPL_STATE_TOMBSTONE,
4676 .node = WREPL_NODE_B,
4678 .num_ips = ARRAY_SIZE(addresses_A_3_4),
4679 .ips = addresses_A_3_4,
4680 .apply_expected = true,
4684 * sgroup,active vs. sgroup,tombstone subset addresses
4685 * => should be replaced
4688 .line = __location__,
4689 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4690 .comment= "A:B_3_4_X_3_4 vs. B:B_3_4 => B:B_3_4",
4694 .type = WREPL_TYPE_SGROUP,
4695 .state = WREPL_STATE_ACTIVE,
4696 .node = WREPL_NODE_B,
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,
4704 .type = WREPL_TYPE_SGROUP,
4705 .state = WREPL_STATE_TOMBSTONE,
4706 .node = WREPL_NODE_B,
4708 .num_ips = ARRAY_SIZE(addresses_B_3_4),
4709 .ips = addresses_B_3_4,
4710 .apply_expected = true,
4714 * sgroup,active vs. sgroup,active same addresses
4715 * => should be replaced
4718 .line = __location__,
4719 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4720 .comment= "A:B_3_4_X_3_4 vs. B:B_3_4_X_3_4 => B:B_3_4_X_3_4",
4724 .type = WREPL_TYPE_SGROUP,
4725 .state = WREPL_STATE_ACTIVE,
4726 .node = WREPL_NODE_B,
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,
4734 .type = WREPL_TYPE_SGROUP,
4735 .state = WREPL_STATE_TOMBSTONE,
4736 .node = WREPL_NODE_B,
4738 .num_ips = ARRAY_SIZE(addresses_B_3_4_X_3_4),
4739 .ips = addresses_B_3_4_X_3_4,
4740 .apply_expected = true,
4745 * This should be the last record in this array,
4746 * we need to make sure the we leave a tombstoned unique entry
4750 .line = __location__,
4751 .name = _NBT_NAME("_DIFF_OWNER", 0x00, NULL),
4755 .type = WREPL_TYPE_UNIQUE,
4756 .state = WREPL_STATE_TOMBSTONE,
4757 .node = WREPL_NODE_B,
4759 .num_ips = ARRAY_SIZE(addresses_A_1),
4760 .ips = addresses_A_1,
4761 .apply_expected = true
4765 .type = WREPL_TYPE_UNIQUE,
4766 .state = WREPL_STATE_TOMBSTONE,
4767 .node = WREPL_NODE_B,
4769 .num_ips = ARRAY_SIZE(addresses_A_1),
4770 .ips = addresses_A_1,
4771 .apply_expected = true
4773 }}; /* do not add entries here, this should be the last record! */
4775 wins_name_r1 = &wins_name1;
4776 wins_name_r2 = &wins_name2;
4778 torture_comment(tctx, "Test Replica Conflicts with different owners\n");
4780 for(i=0; ret && i < ARRAY_SIZE(records); i++) {
4782 if (!records[i].extra && !records[i].cleanup) {
4783 /* we should test the worst cases */
4784 if (records[i].r2.apply_expected && records[i].r1.ips==records[i].r2.ips) {
4785 torture_comment(tctx, "(%s) Programmer error, invalid record[%u]: %s\n",
4786 __location__, i, records[i].line);
4788 } else if (!records[i].r2.apply_expected && records[i].r1.ips!=records[i].r2.ips) {
4789 torture_comment(tctx, "(%s) Programmer error, invalid record[%u]: %s\n",
4790 __location__, i, records[i].line);
4795 if (!records[i].cleanup) {
4796 const char *expected;
4799 if (records[i].r2.sgroup_merge) {
4800 expected = "SGROUP_MERGE";
4801 } else if (records[i].r2.apply_expected) {
4802 expected = "REPLACE";
4804 expected = "NOT REPLACE";
4807 if (!records[i].r1.ips && !records[i].r2.ips) {
4808 ips = "with no ip(s)";
4809 } else if (records[i].r1.ips==records[i].r2.ips) {
4810 ips = "with same ip(s)";
4812 ips = "with different ip(s)";
4815 torture_comment(tctx, "%s,%s%s vs. %s,%s%s %s => %s\n",
4816 wrepl_name_type_string(records[i].r1.type),
4817 wrepl_name_state_string(records[i].r1.state),
4818 (records[i].r1.is_static?",static":""),
4819 wrepl_name_type_string(records[i].r2.type),
4820 wrepl_name_state_string(records[i].r2.state),
4821 (records[i].r2.is_static?",static":""),
4822 (records[i].comment?records[i].comment:ips),
4829 wins_name_r1->name = &records[i].name;
4830 wins_name_r1->flags = WREPL_NAME_FLAGS(records[i].r1.type,
4831 records[i].r1.state,
4833 records[i].r1.is_static);
4834 wins_name_r1->id = ++records[i].r1.owner->max_version;
4835 if (wins_name_r1->flags & 2) {
4836 wins_name_r1->addresses.addresses.num_ips = records[i].r1.num_ips;
4837 wins_name_r1->addresses.addresses.ips = discard_const(records[i].r1.ips);
4839 wins_name_r1->addresses.ip = records[i].r1.ips[0].ip;
4841 wins_name_r1->unknown = "255.255.255.255";
4844 ret &= test_wrepl_update_one(tctx, ctx, records[i].r1.owner, wins_name_r1);
4845 ret &= test_wrepl_is_applied(tctx, ctx, records[i].r1.owner,
4846 wins_name_r1, records[i].r1.apply_expected);
4851 wins_name_r2->name = &records[i].name;
4852 wins_name_r2->flags = WREPL_NAME_FLAGS(records[i].r2.type,
4853 records[i].r2.state,
4855 records[i].r2.is_static);
4856 wins_name_r2->id = ++records[i].r2.owner->max_version;
4857 if (wins_name_r2->flags & 2) {
4858 wins_name_r2->addresses.addresses.num_ips = records[i].r2.num_ips;
4859 wins_name_r2->addresses.addresses.ips = discard_const(records[i].r2.ips);
4861 wins_name_r2->addresses.ip = records[i].r2.ips[0].ip;
4863 wins_name_r2->unknown = "255.255.255.255";
4866 ret &= test_wrepl_update_one(tctx, ctx, records[i].r2.owner, wins_name_r2);
4867 if (records[i].r1.state == WREPL_STATE_RELEASED) {
4868 ret &= test_wrepl_is_applied(tctx, ctx, records[i].r1.owner,
4869 wins_name_r1, false);
4870 } else if (records[i].r2.sgroup_merge) {
4871 ret &= test_wrepl_sgroup_merged(tctx, ctx, records[i].r2.merge_owner,
4872 records[i].r1.owner,
4873 records[i].r1.num_ips, records[i].r1.ips,
4874 records[i].r2.owner,
4875 records[i].r2.num_ips, records[i].r2.ips,
4877 } else if (records[i].r1.owner != records[i].r2.owner) {
4879 _expected = (records[i].r1.apply_expected && !records[i].r2.apply_expected);
4880 ret &= test_wrepl_is_applied(tctx, ctx, records[i].r1.owner,
4881 wins_name_r1, _expected);
4883 if (records[i].r2.state == WREPL_STATE_RELEASED) {
4884 ret &= test_wrepl_is_applied(tctx, ctx, records[i].r2.owner,
4885 wins_name_r2, false);
4886 } else if (!records[i].r2.sgroup_merge) {
4887 ret &= test_wrepl_is_applied(tctx, ctx, records[i].r2.owner,
4888 wins_name_r2, records[i].r2.apply_expected);
4891 if (records[i].r2.sgroup_cleanup) {
4893 torture_comment(tctx, "failed before sgroup_cleanup record[%u]: %s\n", i, records[i].line);
4897 /* clean up the SGROUP record */
4898 wins_name_r1->name = &records[i].name;
4899 wins_name_r1->flags = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
4901 WREPL_NODE_B, false);
4902 wins_name_r1->id = ++records[i].r1.owner->max_version;
4903 wins_name_r1->addresses.addresses.num_ips = 0;
4904 wins_name_r1->addresses.addresses.ips = NULL;
4905 wins_name_r1->unknown = "255.255.255.255";
4906 ret &= test_wrepl_update_one(tctx, ctx, records[i].r1.owner, wins_name_r1);
4908 /* here we test how names from an owner are deleted */
4909 if (records[i].r2.sgroup_merge && records[i].r2.num_ips) {
4910 ret &= test_wrepl_sgroup_merged(tctx, ctx, NULL,
4911 records[i].r2.owner,
4912 records[i].r2.num_ips, records[i].r2.ips,
4913 records[i].r1.owner,
4918 /* clean up the SGROUP record */
4919 wins_name_r2->name = &records[i].name;
4920 wins_name_r2->flags = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
4922 WREPL_NODE_B, false);
4923 wins_name_r2->id = ++records[i].r2.owner->max_version;
4924 wins_name_r2->addresses.addresses.num_ips = 0;
4925 wins_name_r2->addresses.addresses.ips = NULL;
4926 wins_name_r2->unknown = "255.255.255.255";
4927 ret &= test_wrepl_update_one(tctx, ctx, records[i].r2.owner, wins_name_r2);
4929 /* take ownership of the SGROUP record */
4930 wins_name_r2->name = &records[i].name;
4931 wins_name_r2->flags = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
4933 WREPL_NODE_B, false);
4934 wins_name_r2->id = ++records[i].r2.owner->max_version;
4935 wins_name_r2->addresses.addresses.num_ips = ARRAY_SIZE(addresses_B_1);
4936 wins_name_r2->addresses.addresses.ips = discard_const(addresses_B_1);
4937 wins_name_r2->unknown = "255.255.255.255";
4938 ret &= test_wrepl_update_one(tctx, ctx, records[i].r2.owner, wins_name_r2);
4939 ret &= test_wrepl_is_applied(tctx, ctx, records[i].r2.owner, wins_name_r2, true);
4941 /* overwrite the SGROUP record with unique,tombstone */
4942 wins_name_r2->name = &records[i].name;
4943 wins_name_r2->flags = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
4944 WREPL_STATE_TOMBSTONE,
4945 WREPL_NODE_B, false);
4946 wins_name_r2->id = ++records[i].r2.owner->max_version;
4947 wins_name_r2->addresses.addresses.num_ips = ARRAY_SIZE(addresses_B_1);
4948 wins_name_r2->addresses.addresses.ips = discard_const(addresses_B_1);
4949 wins_name_r2->unknown = "255.255.255.255";
4950 ret &= test_wrepl_update_one(tctx, ctx, records[i].r2.owner, wins_name_r2);
4951 ret &= test_wrepl_is_applied(tctx, ctx, records[i].r2.owner, wins_name_r2, true);
4954 torture_comment(tctx, "failed in sgroup_cleanup record[%u]: %s\n", i, records[i].line);
4959 /* the first one is a cleanup run */
4960 if (!ret && i == 0) ret = true;
4963 torture_comment(tctx, "conflict handled wrong or record[%u]: %s\n", i, records[i].line);
4971 static bool test_conflict_owned_released_vs_replica(struct torture_context *tctx,
4972 struct test_wrepl_conflict_conn *ctx)
4976 struct wrepl_wins_name wins_name_;
4977 struct wrepl_wins_name *wins_name = &wins_name_;
4978 struct nbt_name_register name_register_;
4979 struct nbt_name_register *name_register = &name_register_;
4980 struct nbt_name_release release_;
4981 struct nbt_name_release *release = &release_;
4984 const char *line; /* just better debugging */
4985 struct nbt_name name;
4990 const struct wrepl_ip *ips;
4991 bool apply_expected;
4994 enum wrepl_name_type type;
4995 enum wrepl_name_state state;
4996 enum wrepl_name_node node;
4999 const struct wrepl_ip *ips;
5000 bool apply_expected;
5004 * unique vs. unique section
5007 * unique,released vs. unique,active with same ip(s)
5010 .line = __location__,
5011 .name = _NBT_NAME("_UR_UA_SI", 0x00, NULL),
5015 .num_ips = ctx->addresses_best_num,
5016 .ips = ctx->addresses_best,
5017 .apply_expected = true
5020 .type = WREPL_TYPE_UNIQUE,
5021 .state = WREPL_STATE_ACTIVE,
5022 .node = WREPL_NODE_B,
5024 .num_ips = ctx->addresses_best_num,
5025 .ips = ctx->addresses_best,
5026 .apply_expected = true
5030 * unique,released vs. unique,active with different ip(s)
5033 .line = __location__,
5034 .name = _NBT_NAME("_UR_UA_DI", 0x00, NULL),
5038 .num_ips = ctx->addresses_best_num,
5039 .ips = ctx->addresses_best,
5040 .apply_expected = true
5043 .type = WREPL_TYPE_UNIQUE,
5044 .state = WREPL_STATE_ACTIVE,
5045 .node = WREPL_NODE_B,
5047 .num_ips = ARRAY_SIZE(addresses_B_1),
5048 .ips = addresses_B_1,
5049 .apply_expected = true
5053 * unique,released vs. unique,tombstone with same ip(s)
5056 .line = __location__,
5057 .name = _NBT_NAME("_UR_UT_SI", 0x00, NULL),
5061 .num_ips = ctx->addresses_best_num,
5062 .ips = ctx->addresses_best,
5063 .apply_expected = true
5066 .type = WREPL_TYPE_UNIQUE,
5067 .state = WREPL_STATE_TOMBSTONE,
5068 .node = WREPL_NODE_B,
5070 .num_ips = ctx->addresses_best_num,
5071 .ips = ctx->addresses_best,
5072 .apply_expected = true
5076 * unique,released vs. unique,tombstone with different ip(s)
5079 .line = __location__,
5080 .name = _NBT_NAME("_UR_UT_DI", 0x00, NULL),
5084 .num_ips = ctx->addresses_best_num,
5085 .ips = ctx->addresses_best,
5086 .apply_expected = true
5089 .type = WREPL_TYPE_UNIQUE,
5090 .state = WREPL_STATE_TOMBSTONE,
5091 .node = WREPL_NODE_B,
5093 .num_ips = ARRAY_SIZE(addresses_B_1),
5094 .ips = addresses_B_1,
5095 .apply_expected = true
5099 * unique vs. group section
5102 * unique,released vs. group,active with same ip(s)
5105 .line = __location__,
5106 .name = _NBT_NAME("_UR_GA_SI", 0x00, NULL),
5110 .num_ips = ctx->addresses_best_num,
5111 .ips = ctx->addresses_best,
5112 .apply_expected = true
5115 .type = WREPL_TYPE_GROUP,
5116 .state = WREPL_STATE_ACTIVE,
5117 .node = WREPL_NODE_B,
5119 .num_ips = ctx->addresses_best_num,
5120 .ips = ctx->addresses_best,
5121 .apply_expected = true
5125 * unique,released vs. group,active with different ip(s)
5128 .line = __location__,
5129 .name = _NBT_NAME("_UR_GA_DI", 0x00, NULL),
5133 .num_ips = ctx->addresses_best_num,
5134 .ips = ctx->addresses_best,
5135 .apply_expected = true
5138 .type = WREPL_TYPE_GROUP,
5139 .state = WREPL_STATE_ACTIVE,
5140 .node = WREPL_NODE_B,
5142 .num_ips = ARRAY_SIZE(addresses_B_1),
5143 .ips = addresses_B_1,
5144 .apply_expected = true
5148 * unique,released vs. group,tombstone with same ip(s)
5151 .line = __location__,
5152 .name = _NBT_NAME("_UR_GT_SI", 0x00, NULL),
5156 .num_ips = ctx->addresses_best_num,
5157 .ips = ctx->addresses_best,
5158 .apply_expected = true
5161 .type = WREPL_TYPE_GROUP,
5162 .state = WREPL_STATE_TOMBSTONE,
5163 .node = WREPL_NODE_B,
5165 .num_ips = ctx->addresses_best_num,
5166 .ips = ctx->addresses_best,
5167 .apply_expected = true
5171 * unique,released vs. group,tombstone with different ip(s)
5174 .line = __location__,
5175 .name = _NBT_NAME("_UR_GT_DI", 0x00, NULL),
5179 .num_ips = ctx->addresses_best_num,
5180 .ips = ctx->addresses_best,
5181 .apply_expected = true
5184 .type = WREPL_TYPE_GROUP,
5185 .state = WREPL_STATE_TOMBSTONE,
5186 .node = WREPL_NODE_B,
5188 .num_ips = ARRAY_SIZE(addresses_B_1),
5189 .ips = addresses_B_1,
5190 .apply_expected = true
5194 * unique vs. special group section
5197 * unique,released vs. sgroup,active with same ip(s)
5200 .line = __location__,
5201 .name = _NBT_NAME("_UR_SA_SI", 0x00, NULL),
5205 .num_ips = ctx->addresses_best_num,
5206 .ips = ctx->addresses_best,
5207 .apply_expected = true
5210 .type = WREPL_TYPE_SGROUP,
5211 .state = WREPL_STATE_ACTIVE,
5212 .node = WREPL_NODE_B,
5214 .num_ips = ctx->addresses_best_num,
5215 .ips = ctx->addresses_best,
5216 .apply_expected = true
5220 * unique,released vs. sgroup,active with different ip(s)
5223 .line = __location__,
5224 .name = _NBT_NAME("_UR_SA_DI", 0x00, NULL),
5228 .num_ips = ctx->addresses_best_num,
5229 .ips = ctx->addresses_best,
5230 .apply_expected = true
5233 .type = WREPL_TYPE_SGROUP,
5234 .state = WREPL_STATE_ACTIVE,
5235 .node = WREPL_NODE_B,
5237 .num_ips = ARRAY_SIZE(addresses_B_1),
5238 .ips = addresses_B_1,
5239 .apply_expected = true
5243 * unique,released vs. sgroup,tombstone with same ip(s)
5246 .line = __location__,
5247 .name = _NBT_NAME("_UR_ST_SI", 0x00, NULL),
5251 .num_ips = ctx->addresses_best_num,
5252 .ips = ctx->addresses_best,
5253 .apply_expected = true
5256 .type = WREPL_TYPE_SGROUP,
5257 .state = WREPL_STATE_TOMBSTONE,
5258 .node = WREPL_NODE_B,
5260 .num_ips = ctx->addresses_best_num,
5261 .ips = ctx->addresses_best,
5262 .apply_expected = true
5266 * unique,released vs. sgroup,tombstone with different ip(s)
5269 .line = __location__,
5270 .name = _NBT_NAME("_UR_ST_DI", 0x00, NULL),
5274 .num_ips = ctx->addresses_best_num,
5275 .ips = ctx->addresses_best,
5276 .apply_expected = true
5279 .type = WREPL_TYPE_SGROUP,
5280 .state = WREPL_STATE_TOMBSTONE,
5281 .node = WREPL_NODE_B,
5283 .num_ips = ARRAY_SIZE(addresses_B_1),
5284 .ips = addresses_B_1,
5285 .apply_expected = true
5289 * unique vs. multi homed section
5292 * unique,released vs. mhomed,active with same ip(s)
5295 .line = __location__,
5296 .name = _NBT_NAME("_UR_MA_SI", 0x00, NULL),
5300 .num_ips = ctx->addresses_best_num,
5301 .ips = ctx->addresses_best,
5302 .apply_expected = true
5305 .type = WREPL_TYPE_MHOMED,
5306 .state = WREPL_STATE_ACTIVE,
5307 .node = WREPL_NODE_B,
5309 .num_ips = ctx->addresses_best_num,
5310 .ips = ctx->addresses_best,
5311 .apply_expected = true
5315 * unique,released vs. mhomed,active with different ip(s)
5318 .line = __location__,
5319 .name = _NBT_NAME("_UR_MA_DI", 0x00, NULL),
5323 .num_ips = ctx->addresses_best_num,
5324 .ips = ctx->addresses_best,
5325 .apply_expected = true
5328 .type = WREPL_TYPE_MHOMED,
5329 .state = WREPL_STATE_ACTIVE,
5330 .node = WREPL_NODE_B,
5332 .num_ips = ARRAY_SIZE(addresses_B_1),
5333 .ips = addresses_B_1,
5334 .apply_expected = true
5338 * unique,released vs. mhomed,tombstone with same ip(s)
5341 .line = __location__,
5342 .name = _NBT_NAME("_UR_MT_SI", 0x00, NULL),
5346 .num_ips = ctx->addresses_best_num,
5347 .ips = ctx->addresses_best,
5348 .apply_expected = true
5351 .type = WREPL_TYPE_MHOMED,
5352 .state = WREPL_STATE_TOMBSTONE,
5353 .node = WREPL_NODE_B,
5355 .num_ips = ctx->addresses_best_num,
5356 .ips = ctx->addresses_best,
5357 .apply_expected = true
5361 * unique,released vs. mhomed,tombstone with different ip(s)
5364 .line = __location__,
5365 .name = _NBT_NAME("_UR_MT_DI", 0x00, NULL),
5369 .num_ips = ctx->addresses_best_num,
5370 .ips = ctx->addresses_best,
5371 .apply_expected = true
5374 .type = WREPL_TYPE_MHOMED,
5375 .state = WREPL_STATE_TOMBSTONE,
5376 .node = WREPL_NODE_B,
5378 .num_ips = ARRAY_SIZE(addresses_B_1),
5379 .ips = addresses_B_1,
5380 .apply_expected = true
5384 * group vs. unique section
5387 * group,released vs. unique,active with same ip(s)
5390 .line = __location__,
5391 .name = _NBT_NAME("_GR_UA_SI", 0x00, NULL),
5393 .nb_flags = NBT_NM_GROUP,
5395 .num_ips = ctx->addresses_best_num,
5396 .ips = ctx->addresses_best,
5397 .apply_expected = true
5400 .type = WREPL_TYPE_UNIQUE,
5401 .state = WREPL_STATE_ACTIVE,
5402 .node = WREPL_NODE_B,
5404 .num_ips = ctx->addresses_best_num,
5405 .ips = ctx->addresses_best,
5406 .apply_expected = false
5410 * group,released vs. unique,active with different ip(s)
5413 .line = __location__,
5414 .name = _NBT_NAME("_GR_UA_DI", 0x00, NULL),
5416 .nb_flags = NBT_NM_GROUP,
5418 .num_ips = ctx->addresses_best_num,
5419 .ips = ctx->addresses_best,
5420 .apply_expected = true
5423 .type = WREPL_TYPE_UNIQUE,
5424 .state = WREPL_STATE_ACTIVE,
5425 .node = WREPL_NODE_B,
5427 .num_ips = ARRAY_SIZE(addresses_B_1),
5428 .ips = addresses_B_1,
5429 .apply_expected = false
5433 * group,released vs. unique,tombstone with same ip(s)
5436 .line = __location__,
5437 .name = _NBT_NAME("_GR_UT_SI", 0x00, NULL),
5439 .nb_flags = NBT_NM_GROUP,
5441 .num_ips = ctx->addresses_best_num,
5442 .ips = ctx->addresses_best,
5443 .apply_expected = true
5446 .type = WREPL_TYPE_UNIQUE,
5447 .state = WREPL_STATE_TOMBSTONE,
5448 .node = WREPL_NODE_B,
5450 .num_ips = ctx->addresses_best_num,
5451 .ips = ctx->addresses_best,
5452 .apply_expected = false
5456 * group,released vs. unique,tombstone with different ip(s)
5459 .line = __location__,
5460 .name = _NBT_NAME("_GR_UT_DI", 0x00, NULL),
5462 .nb_flags = NBT_NM_GROUP,
5464 .num_ips = ctx->addresses_best_num,
5465 .ips = ctx->addresses_best,
5466 .apply_expected = true
5469 .type = WREPL_TYPE_UNIQUE,
5470 .state = WREPL_STATE_TOMBSTONE,
5471 .node = WREPL_NODE_B,
5473 .num_ips = ARRAY_SIZE(addresses_B_1),
5474 .ips = addresses_B_1,
5475 .apply_expected = false
5479 * group vs. group section
5482 * group,released vs. group,active with same ip(s)
5485 .line = __location__,
5486 .name = _NBT_NAME("_GR_GA_SI", 0x00, NULL),
5488 .nb_flags = NBT_NM_GROUP,
5490 .num_ips = ctx->addresses_best_num,
5491 .ips = ctx->addresses_best,
5492 .apply_expected = true
5495 .type = WREPL_TYPE_GROUP,
5496 .state = WREPL_STATE_ACTIVE,
5497 .node = WREPL_NODE_B,
5499 .num_ips = ctx->addresses_best_num,
5500 .ips = ctx->addresses_best,
5501 .apply_expected = true
5505 * group,released vs. group,active with different ip(s)
5508 .line = __location__,
5509 .name = _NBT_NAME("_GR_GA_DI", 0x00, NULL),
5511 .nb_flags = NBT_NM_GROUP,
5513 .num_ips = ctx->addresses_best_num,
5514 .ips = ctx->addresses_best,
5515 .apply_expected = true
5518 .type = WREPL_TYPE_GROUP,
5519 .state = WREPL_STATE_ACTIVE,
5520 .node = WREPL_NODE_B,
5522 .num_ips = ARRAY_SIZE(addresses_B_1),
5523 .ips = addresses_B_1,
5524 .apply_expected = true
5528 * group,released vs. group,tombstone with same ip(s)
5531 .line = __location__,
5532 .name = _NBT_NAME("_GR_GT_SI", 0x00, NULL),
5534 .nb_flags = NBT_NM_GROUP,
5536 .num_ips = ctx->addresses_best_num,
5537 .ips = ctx->addresses_best,
5538 .apply_expected = true
5541 .type = WREPL_TYPE_GROUP,
5542 .state = WREPL_STATE_TOMBSTONE,
5543 .node = WREPL_NODE_B,
5545 .num_ips = ctx->addresses_best_num,
5546 .ips = ctx->addresses_best,
5547 .apply_expected = true
5551 * group,released vs. group,tombstone with different ip(s)
5554 .line = __location__,
5555 .name = _NBT_NAME("_GR_GT_DI", 0x00, NULL),
5557 .nb_flags = NBT_NM_GROUP,
5559 .num_ips = ctx->addresses_best_num,
5560 .ips = ctx->addresses_best,
5561 .apply_expected = true
5564 .type = WREPL_TYPE_GROUP,
5565 .state = WREPL_STATE_TOMBSTONE,
5566 .node = WREPL_NODE_B,
5568 .num_ips = ARRAY_SIZE(addresses_B_1),
5569 .ips = addresses_B_1,
5570 .apply_expected = true
5574 * group vs. special group section
5577 * group,released vs. sgroup,active with same ip(s)
5580 .line = __location__,
5581 .name = _NBT_NAME("_GR_SA_SI", 0x00, NULL),
5583 .nb_flags = NBT_NM_GROUP,
5585 .num_ips = ctx->addresses_best_num,
5586 .ips = ctx->addresses_best,
5587 .apply_expected = true
5590 .type = WREPL_TYPE_SGROUP,
5591 .state = WREPL_STATE_ACTIVE,
5592 .node = WREPL_NODE_B,
5594 .num_ips = ctx->addresses_best_num,
5595 .ips = ctx->addresses_best,
5596 .apply_expected = false
5600 * group,released vs. sgroup,active with different ip(s)
5603 .line = __location__,
5604 .name = _NBT_NAME("_GR_SA_DI", 0x00, NULL),
5606 .nb_flags = NBT_NM_GROUP,
5608 .num_ips = ctx->addresses_best_num,
5609 .ips = ctx->addresses_best,
5610 .apply_expected = true
5613 .type = WREPL_TYPE_SGROUP,
5614 .state = WREPL_STATE_ACTIVE,
5615 .node = WREPL_NODE_B,
5617 .num_ips = ARRAY_SIZE(addresses_B_1),
5618 .ips = addresses_B_1,
5619 .apply_expected = false
5623 * group,released vs. sgroup,tombstone with same ip(s)
5626 .line = __location__,
5627 .name = _NBT_NAME("_GR_ST_SI", 0x00, NULL),
5629 .nb_flags = NBT_NM_GROUP,
5631 .num_ips = ctx->addresses_best_num,
5632 .ips = ctx->addresses_best,
5633 .apply_expected = true
5636 .type = WREPL_TYPE_SGROUP,
5637 .state = WREPL_STATE_TOMBSTONE,
5638 .node = WREPL_NODE_B,
5640 .num_ips = ctx->addresses_best_num,
5641 .ips = ctx->addresses_best,
5642 .apply_expected = false
5646 * group,released vs. sgroup,tombstone with different ip(s)
5649 .line = __location__,
5650 .name = _NBT_NAME("_GR_ST_DI", 0x00, NULL),
5652 .nb_flags = NBT_NM_GROUP,
5654 .num_ips = ctx->addresses_best_num,
5655 .ips = ctx->addresses_best,
5656 .apply_expected = true
5659 .type = WREPL_TYPE_SGROUP,
5660 .state = WREPL_STATE_TOMBSTONE,
5661 .node = WREPL_NODE_B,
5663 .num_ips = ARRAY_SIZE(addresses_B_1),
5664 .ips = addresses_B_1,
5665 .apply_expected = false
5669 * group vs. multi homed section
5672 * group,released vs. mhomed,active with same ip(s)
5675 .line = __location__,
5676 .name = _NBT_NAME("_GR_MA_SI", 0x00, NULL),
5678 .nb_flags = NBT_NM_GROUP,
5680 .num_ips = ctx->addresses_best_num,
5681 .ips = ctx->addresses_best,
5682 .apply_expected = true
5685 .type = WREPL_TYPE_MHOMED,
5686 .state = WREPL_STATE_ACTIVE,
5687 .node = WREPL_NODE_B,
5689 .num_ips = ctx->addresses_best_num,
5690 .ips = ctx->addresses_best,
5691 .apply_expected = false
5695 * group,released vs. mhomed,active with different ip(s)
5698 .line = __location__,
5699 .name = _NBT_NAME("_GR_MA_DI", 0x00, NULL),
5701 .nb_flags = NBT_NM_GROUP,
5703 .num_ips = ctx->addresses_best_num,
5704 .ips = ctx->addresses_best,
5705 .apply_expected = true
5708 .type = WREPL_TYPE_MHOMED,
5709 .state = WREPL_STATE_ACTIVE,
5710 .node = WREPL_NODE_B,
5712 .num_ips = ARRAY_SIZE(addresses_B_1),
5713 .ips = addresses_B_1,
5714 .apply_expected = false
5718 * group,released vs. mhomed,tombstone with same ip(s)
5721 .line = __location__,
5722 .name = _NBT_NAME("_GR_MT_SI", 0x00, NULL),
5724 .nb_flags = NBT_NM_GROUP,
5726 .num_ips = ctx->addresses_best_num,
5727 .ips = ctx->addresses_best,
5728 .apply_expected = true
5731 .type = WREPL_TYPE_MHOMED,
5732 .state = WREPL_STATE_TOMBSTONE,
5733 .node = WREPL_NODE_B,
5735 .num_ips = ctx->addresses_best_num,
5736 .ips = ctx->addresses_best,
5737 .apply_expected = false
5741 * group,released vs. mhomed,tombstone with different ip(s)
5744 .line = __location__,
5745 .name = _NBT_NAME("_GR_MT_DI", 0x00, NULL),
5747 .nb_flags = NBT_NM_GROUP,
5749 .num_ips = ctx->addresses_best_num,
5750 .ips = ctx->addresses_best,
5751 .apply_expected = true
5754 .type = WREPL_TYPE_MHOMED,
5755 .state = WREPL_STATE_TOMBSTONE,
5756 .node = WREPL_NODE_B,
5758 .num_ips = ARRAY_SIZE(addresses_B_1),
5759 .ips = addresses_B_1,
5760 .apply_expected = false
5764 * special group vs. unique section
5767 * sgroup,released vs. unique,active with same ip(s)
5770 .line = __location__,
5771 .name = _NBT_NAME("_SR_UA_SI", 0x1C, NULL),
5773 .nb_flags = NBT_NM_GROUP,
5775 .num_ips = ctx->addresses_best_num,
5776 .ips = ctx->addresses_best,
5777 .apply_expected = true
5780 .type = WREPL_TYPE_UNIQUE,
5781 .state = WREPL_STATE_ACTIVE,
5782 .node = WREPL_NODE_B,
5784 .num_ips = ctx->addresses_best_num,
5785 .ips = ctx->addresses_best,
5786 .apply_expected = true
5790 * sgroup,released vs. unique,active with different ip(s)
5793 .line = __location__,
5794 .name = _NBT_NAME("_SR_UA_DI", 0x1C, NULL),
5796 .nb_flags = NBT_NM_GROUP,
5798 .num_ips = ctx->addresses_best_num,
5799 .ips = ctx->addresses_best,
5800 .apply_expected = true
5803 .type = WREPL_TYPE_UNIQUE,
5804 .state = WREPL_STATE_ACTIVE,
5805 .node = WREPL_NODE_B,
5807 .num_ips = ARRAY_SIZE(addresses_B_1),
5808 .ips = addresses_B_1,
5809 .apply_expected = true
5813 * sgroup,released vs. unique,tombstone with same ip(s)
5816 .line = __location__,
5817 .name = _NBT_NAME("_SR_UT_SI", 0x1C, NULL),
5819 .nb_flags = NBT_NM_GROUP,
5821 .num_ips = ctx->addresses_best_num,
5822 .ips = ctx->addresses_best,
5823 .apply_expected = true
5826 .type = WREPL_TYPE_UNIQUE,
5827 .state = WREPL_STATE_TOMBSTONE,
5828 .node = WREPL_NODE_B,
5830 .num_ips = ctx->addresses_best_num,
5831 .ips = ctx->addresses_best,
5832 .apply_expected = true
5836 * sgroup,released vs. unique,tombstone with different ip(s)
5839 .line = __location__,
5840 .name = _NBT_NAME("_SR_UT_DI", 0x1C, NULL),
5842 .nb_flags = NBT_NM_GROUP,
5844 .num_ips = ctx->addresses_best_num,
5845 .ips = ctx->addresses_best,
5846 .apply_expected = true
5849 .type = WREPL_TYPE_UNIQUE,
5850 .state = WREPL_STATE_TOMBSTONE,
5851 .node = WREPL_NODE_B,
5853 .num_ips = ARRAY_SIZE(addresses_B_1),
5854 .ips = addresses_B_1,
5855 .apply_expected = true
5859 * special group vs. group section
5862 * sgroup,released vs. group,active with same ip(s)
5865 .line = __location__,
5866 .name = _NBT_NAME("_SR_GA_SI", 0x1C, NULL),
5868 .nb_flags = NBT_NM_GROUP,
5870 .num_ips = ctx->addresses_best_num,
5871 .ips = ctx->addresses_best,
5872 .apply_expected = true
5875 .type = WREPL_TYPE_GROUP,
5876 .state = WREPL_STATE_ACTIVE,
5877 .node = WREPL_NODE_B,
5879 .num_ips = ctx->addresses_best_num,
5880 .ips = ctx->addresses_best,
5881 .apply_expected = true
5885 * sgroup,released vs. group,active with different ip(s)
5888 .line = __location__,
5889 .name = _NBT_NAME("_SR_GA_DI", 0x1C, NULL),
5891 .nb_flags = NBT_NM_GROUP,
5893 .num_ips = ctx->addresses_best_num,
5894 .ips = ctx->addresses_best,
5895 .apply_expected = true
5898 .type = WREPL_TYPE_GROUP,
5899 .state = WREPL_STATE_ACTIVE,
5900 .node = WREPL_NODE_B,
5902 .num_ips = ARRAY_SIZE(addresses_B_1),
5903 .ips = addresses_B_1,
5904 .apply_expected = true
5908 * sgroup,released vs. group,tombstone with same ip(s)
5911 .line = __location__,
5912 .name = _NBT_NAME("_SR_GT_SI", 0x1C, NULL),
5914 .nb_flags = NBT_NM_GROUP,
5916 .num_ips = ctx->addresses_best_num,
5917 .ips = ctx->addresses_best,
5918 .apply_expected = true
5921 .type = WREPL_TYPE_GROUP,
5922 .state = WREPL_STATE_TOMBSTONE,
5923 .node = WREPL_NODE_B,
5925 .num_ips = ctx->addresses_best_num,
5926 .ips = ctx->addresses_best,
5927 .apply_expected = true
5931 * sgroup,released vs. group,tombstone with different ip(s)
5934 .line = __location__,
5935 .name = _NBT_NAME("_SR_GT_DI", 0x1C, NULL),
5937 .nb_flags = NBT_NM_GROUP,
5939 .num_ips = ctx->addresses_best_num,
5940 .ips = ctx->addresses_best,
5941 .apply_expected = true
5944 .type = WREPL_TYPE_GROUP,
5945 .state = WREPL_STATE_TOMBSTONE,
5946 .node = WREPL_NODE_B,
5948 .num_ips = ARRAY_SIZE(addresses_B_1),
5949 .ips = addresses_B_1,
5950 .apply_expected = true
5954 * special group vs. special group section
5957 * sgroup,released vs. sgroup,active with same ip(s)
5960 .line = __location__,
5961 .name = _NBT_NAME("_SR_SA_SI", 0x1C, NULL),
5963 .nb_flags = NBT_NM_GROUP,
5965 .num_ips = ctx->addresses_best_num,
5966 .ips = ctx->addresses_best,
5967 .apply_expected = true
5970 .type = WREPL_TYPE_SGROUP,
5971 .state = WREPL_STATE_ACTIVE,
5972 .node = WREPL_NODE_B,
5974 .num_ips = ctx->addresses_best_num,
5975 .ips = ctx->addresses_best,
5976 .apply_expected = true
5980 * sgroup,released vs. sgroup,active with different ip(s)
5983 .line = __location__,
5984 .name = _NBT_NAME("_SR_SA_DI", 0x1C, NULL),
5986 .nb_flags = NBT_NM_GROUP,
5988 .num_ips = ctx->addresses_best_num,
5989 .ips = ctx->addresses_best,
5990 .apply_expected = true
5993 .type = WREPL_TYPE_SGROUP,
5994 .state = WREPL_STATE_ACTIVE,
5995 .node = WREPL_NODE_B,
5997 .num_ips = ARRAY_SIZE(addresses_B_1),
5998 .ips = addresses_B_1,
5999 .apply_expected = true
6003 * sgroup,released vs. sgroup,tombstone with same ip(s)
6006 .line = __location__,
6007 .name = _NBT_NAME("_SR_ST_SI", 0x1C, NULL),
6009 .nb_flags = NBT_NM_GROUP,
6011 .num_ips = ctx->addresses_best_num,
6012 .ips = ctx->addresses_best,
6013 .apply_expected = true
6016 .type = WREPL_TYPE_SGROUP,
6017 .state = WREPL_STATE_TOMBSTONE,
6018 .node = WREPL_NODE_B,
6020 .num_ips = ctx->addresses_best_num,
6021 .ips = ctx->addresses_best,
6022 .apply_expected = true
6026 * sgroup,released vs. sgroup,tombstone with different ip(s)
6029 .line = __location__,
6030 .name = _NBT_NAME("_SR_ST_DI", 0x1C, NULL),
6032 .nb_flags = NBT_NM_GROUP,
6034 .num_ips = ctx->addresses_best_num,
6035 .ips = ctx->addresses_best,
6036 .apply_expected = true
6039 .type = WREPL_TYPE_SGROUP,
6040 .state = WREPL_STATE_TOMBSTONE,
6041 .node = WREPL_NODE_B,
6043 .num_ips = ARRAY_SIZE(addresses_B_1),
6044 .ips = addresses_B_1,
6045 .apply_expected = true
6049 * special group vs. multi homed section
6052 * sgroup,released vs. mhomed,active with same ip(s)
6055 .line = __location__,
6056 .name = _NBT_NAME("_SR_MA_SI", 0x1C, NULL),
6058 .nb_flags = NBT_NM_GROUP,
6060 .num_ips = ctx->addresses_best_num,
6061 .ips = ctx->addresses_best,
6062 .apply_expected = true
6065 .type = WREPL_TYPE_MHOMED,
6066 .state = WREPL_STATE_ACTIVE,
6067 .node = WREPL_NODE_B,
6069 .num_ips = ctx->addresses_best_num,
6070 .ips = ctx->addresses_best,
6071 .apply_expected = true
6075 * sgroup,released vs. mhomed,active with different ip(s)
6078 .line = __location__,
6079 .name = _NBT_NAME("_SR_MA_DI", 0x1C, NULL),
6081 .nb_flags = NBT_NM_GROUP,
6083 .num_ips = ctx->addresses_best_num,
6084 .ips = ctx->addresses_best,
6085 .apply_expected = true
6088 .type = WREPL_TYPE_MHOMED,
6089 .state = WREPL_STATE_ACTIVE,
6090 .node = WREPL_NODE_B,
6092 .num_ips = ARRAY_SIZE(addresses_B_1),
6093 .ips = addresses_B_1,
6094 .apply_expected = true
6098 * sgroup,released vs. mhomed,tombstone with same ip(s)
6101 .line = __location__,
6102 .name = _NBT_NAME("_SR_MT_SI", 0x1C, NULL),
6104 .nb_flags = NBT_NM_GROUP,
6106 .num_ips = ctx->addresses_best_num,
6107 .ips = ctx->addresses_best,
6108 .apply_expected = true
6111 .type = WREPL_TYPE_MHOMED,
6112 .state = WREPL_STATE_TOMBSTONE,
6113 .node = WREPL_NODE_B,
6115 .num_ips = ctx->addresses_best_num,
6116 .ips = ctx->addresses_best,
6117 .apply_expected = true
6121 * sgroup,released vs. mhomed,tombstone with different ip(s)
6124 .line = __location__,
6125 .name = _NBT_NAME("_SR_MT_DI", 0x1C, NULL),
6127 .nb_flags = NBT_NM_GROUP,
6129 .num_ips = ctx->addresses_best_num,
6130 .ips = ctx->addresses_best,
6131 .apply_expected = true
6134 .type = WREPL_TYPE_MHOMED,
6135 .state = WREPL_STATE_TOMBSTONE,
6136 .node = WREPL_NODE_B,
6138 .num_ips = ARRAY_SIZE(addresses_B_1),
6139 .ips = addresses_B_1,
6140 .apply_expected = true
6144 * multi homed vs. unique section
6147 * mhomed,released vs. unique,active with same ip(s)
6150 .line = __location__,
6151 .name = _NBT_NAME("_MR_UA_SI", 0x00, NULL),
6155 .num_ips = ctx->addresses_best_num,
6156 .ips = ctx->addresses_best,
6157 .apply_expected = true
6160 .type = WREPL_TYPE_UNIQUE,
6161 .state = WREPL_STATE_ACTIVE,
6162 .node = WREPL_NODE_B,
6164 .num_ips = ctx->addresses_best_num,
6165 .ips = ctx->addresses_best,
6166 .apply_expected = true
6170 * mhomed,released vs. unique,active with different ip(s)
6173 .line = __location__,
6174 .name = _NBT_NAME("_MR_UA_DI", 0x00, NULL),
6178 .num_ips = ctx->addresses_best_num,
6179 .ips = ctx->addresses_best,
6180 .apply_expected = true
6183 .type = WREPL_TYPE_UNIQUE,
6184 .state = WREPL_STATE_ACTIVE,
6185 .node = WREPL_NODE_B,
6187 .num_ips = ARRAY_SIZE(addresses_B_1),
6188 .ips = addresses_B_1,
6189 .apply_expected = true
6193 * mhomed,released vs. unique,tombstone with same ip(s)
6196 .line = __location__,
6197 .name = _NBT_NAME("_MR_UT_SI", 0x00, NULL),
6201 .num_ips = ctx->addresses_best_num,
6202 .ips = ctx->addresses_best,
6203 .apply_expected = true
6206 .type = WREPL_TYPE_UNIQUE,
6207 .state = WREPL_STATE_TOMBSTONE,
6208 .node = WREPL_NODE_B,
6210 .num_ips = ctx->addresses_best_num,
6211 .ips = ctx->addresses_best,
6212 .apply_expected = true
6216 * mhomed,released vs. unique,tombstone with different ip(s)
6219 .line = __location__,
6220 .name = _NBT_NAME("_MR_UT_DI", 0x00, NULL),
6224 .num_ips = ctx->addresses_best_num,
6225 .ips = ctx->addresses_best,
6226 .apply_expected = true
6229 .type = WREPL_TYPE_UNIQUE,
6230 .state = WREPL_STATE_TOMBSTONE,
6231 .node = WREPL_NODE_B,
6233 .num_ips = ARRAY_SIZE(addresses_B_1),
6234 .ips = addresses_B_1,
6235 .apply_expected = true
6239 * multi homed vs. group section
6242 * mhomed,released vs. group,active with same ip(s)
6245 .line = __location__,
6246 .name = _NBT_NAME("_MR_GA_SI", 0x00, NULL),
6250 .num_ips = ctx->addresses_best_num,
6251 .ips = ctx->addresses_best,
6252 .apply_expected = true
6255 .type = WREPL_TYPE_GROUP,
6256 .state = WREPL_STATE_ACTIVE,
6257 .node = WREPL_NODE_B,
6259 .num_ips = ctx->addresses_best_num,
6260 .ips = ctx->addresses_best,
6261 .apply_expected = true
6265 * mhomed,released vs. group,active with different ip(s)
6268 .line = __location__,
6269 .name = _NBT_NAME("_MR_GA_DI", 0x00, NULL),
6273 .num_ips = ctx->addresses_best_num,
6274 .ips = ctx->addresses_best,
6275 .apply_expected = true
6278 .type = WREPL_TYPE_GROUP,
6279 .state = WREPL_STATE_ACTIVE,
6280 .node = WREPL_NODE_B,
6282 .num_ips = ARRAY_SIZE(addresses_B_1),
6283 .ips = addresses_B_1,
6284 .apply_expected = true
6288 * mhomed,released vs. group,tombstone with same ip(s)
6291 .line = __location__,
6292 .name = _NBT_NAME("_MR_GT_SI", 0x00, NULL),
6296 .num_ips = ctx->addresses_best_num,
6297 .ips = ctx->addresses_best,
6298 .apply_expected = true
6301 .type = WREPL_TYPE_GROUP,
6302 .state = WREPL_STATE_TOMBSTONE,
6303 .node = WREPL_NODE_B,
6305 .num_ips = ctx->addresses_best_num,
6306 .ips = ctx->addresses_best,
6307 .apply_expected = true
6311 * mhomed,released vs. group,tombstone with different ip(s)
6314 .line = __location__,
6315 .name = _NBT_NAME("_MR_GT_DI", 0x00, NULL),
6319 .num_ips = ctx->addresses_best_num,
6320 .ips = ctx->addresses_best,
6321 .apply_expected = true
6324 .type = WREPL_TYPE_GROUP,
6325 .state = WREPL_STATE_TOMBSTONE,
6326 .node = WREPL_NODE_B,
6328 .num_ips = ARRAY_SIZE(addresses_B_1),
6329 .ips = addresses_B_1,
6330 .apply_expected = true
6334 * multi homed vs. special group section
6337 * mhomed,released vs. sgroup,active with same ip(s)
6340 .line = __location__,
6341 .name = _NBT_NAME("_MR_SA_SI", 0x00, NULL),
6345 .num_ips = ctx->addresses_best_num,
6346 .ips = ctx->addresses_best,
6347 .apply_expected = true
6350 .type = WREPL_TYPE_SGROUP,
6351 .state = WREPL_STATE_ACTIVE,
6352 .node = WREPL_NODE_B,
6354 .num_ips = ctx->addresses_best_num,
6355 .ips = ctx->addresses_best,
6356 .apply_expected = true
6360 * mhomed,released vs. sgroup,active with different ip(s)
6363 .line = __location__,
6364 .name = _NBT_NAME("_MR_SA_DI", 0x00, NULL),
6368 .num_ips = ctx->addresses_best_num,
6369 .ips = ctx->addresses_best,
6370 .apply_expected = true
6373 .type = WREPL_TYPE_SGROUP,
6374 .state = WREPL_STATE_ACTIVE,
6375 .node = WREPL_NODE_B,
6377 .num_ips = ARRAY_SIZE(addresses_B_1),
6378 .ips = addresses_B_1,
6379 .apply_expected = true
6383 * mhomed,released vs. sgroup,tombstone with same ip(s)
6386 .line = __location__,
6387 .name = _NBT_NAME("_MR_ST_SI", 0x00, NULL),
6391 .num_ips = ctx->addresses_best_num,
6392 .ips = ctx->addresses_best,
6393 .apply_expected = true
6396 .type = WREPL_TYPE_SGROUP,
6397 .state = WREPL_STATE_TOMBSTONE,
6398 .node = WREPL_NODE_B,
6400 .num_ips = ctx->addresses_best_num,
6401 .ips = ctx->addresses_best,
6402 .apply_expected = true
6406 * mhomed,released vs. sgroup,tombstone with different ip(s)
6409 .line = __location__,
6410 .name = _NBT_NAME("_MR_ST_DI", 0x00, NULL),
6414 .num_ips = ctx->addresses_best_num,
6415 .ips = ctx->addresses_best,
6416 .apply_expected = true
6419 .type = WREPL_TYPE_SGROUP,
6420 .state = WREPL_STATE_TOMBSTONE,
6421 .node = WREPL_NODE_B,
6423 .num_ips = ARRAY_SIZE(addresses_B_1),
6424 .ips = addresses_B_1,
6425 .apply_expected = true
6429 * multi homed vs. multi homed section
6432 * mhomed,released vs. mhomed,active with same ip(s)
6435 .line = __location__,
6436 .name = _NBT_NAME("_MR_MA_SI", 0x00, NULL),
6440 .num_ips = ctx->addresses_best_num,
6441 .ips = ctx->addresses_best,
6442 .apply_expected = true
6445 .type = WREPL_TYPE_MHOMED,
6446 .state = WREPL_STATE_ACTIVE,
6447 .node = WREPL_NODE_B,
6449 .num_ips = ctx->addresses_best_num,
6450 .ips = ctx->addresses_best,
6451 .apply_expected = true
6455 * mhomed,released vs. mhomed,active with different ip(s)
6458 .line = __location__,
6459 .name = _NBT_NAME("_MR_MA_DI", 0x00, NULL),
6463 .num_ips = ctx->addresses_best_num,
6464 .ips = ctx->addresses_best,
6465 .apply_expected = true
6468 .type = WREPL_TYPE_MHOMED,
6469 .state = WREPL_STATE_ACTIVE,
6470 .node = WREPL_NODE_B,
6472 .num_ips = ARRAY_SIZE(addresses_B_1),
6473 .ips = addresses_B_1,
6474 .apply_expected = true
6478 * mhomed,released vs. mhomed,tombstone with same ip(s)
6481 .line = __location__,
6482 .name = _NBT_NAME("_MR_MT_SI", 0x00, NULL),
6486 .num_ips = ctx->addresses_best_num,
6487 .ips = ctx->addresses_best,
6488 .apply_expected = true
6491 .type = WREPL_TYPE_MHOMED,
6492 .state = WREPL_STATE_TOMBSTONE,
6493 .node = WREPL_NODE_B,
6495 .num_ips = ctx->addresses_best_num,
6496 .ips = ctx->addresses_best,
6497 .apply_expected = true
6501 * mhomed,released vs. mhomed,tombstone with different ip(s)
6504 .line = __location__,
6505 .name = _NBT_NAME("_MR_MT_DI", 0x00, NULL),
6509 .num_ips = ctx->addresses_best_num,
6510 .ips = ctx->addresses_best,
6511 .apply_expected = true
6514 .type = WREPL_TYPE_MHOMED,
6515 .state = WREPL_STATE_TOMBSTONE,
6516 .node = WREPL_NODE_B,
6518 .num_ips = ARRAY_SIZE(addresses_B_1),
6519 .ips = addresses_B_1,
6520 .apply_expected = true
6525 torture_comment(tctx, "Test Replica records vs. owned released records\n");
6527 for(i=0; ret && i < ARRAY_SIZE(records); i++) {
6528 torture_comment(tctx, "%s => %s\n", nbt_name_string(ctx, &records[i].name),
6529 (records[i].replica.apply_expected?"REPLACE":"NOT REPLACE"));
6534 name_register->in.name = records[i].name;
6535 name_register->in.dest_addr = ctx->address;
6536 name_register->in.dest_port = lp_nbt_port(tctx->lp_ctx);
6537 name_register->in.address = records[i].wins.ips[0].ip;
6538 name_register->in.nb_flags = records[i].wins.nb_flags;
6539 name_register->in.register_demand= false;
6540 name_register->in.broadcast = false;
6541 name_register->in.multi_homed = records[i].wins.mhomed;
6542 name_register->in.ttl = 300000;
6543 name_register->in.timeout = 70;
6544 name_register->in.retries = 0;
6546 status = nbt_name_register(ctx->nbtsock, ctx, name_register);
6547 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
6548 torture_comment(tctx, "No response from %s for name register\n", ctx->address);
6551 if (!NT_STATUS_IS_OK(status)) {
6552 torture_comment(tctx, "Bad response from %s for name register - %s\n",
6553 ctx->address, nt_errstr(status));
6556 CHECK_VALUE(tctx, name_register->out.rcode, 0);
6557 CHECK_VALUE_STRING(tctx, name_register->out.reply_from, ctx->address);
6558 CHECK_VALUE(tctx, name_register->out.name.type, records[i].name.type);
6559 CHECK_VALUE_STRING(tctx, name_register->out.name.name, records[i].name.name);
6560 CHECK_VALUE_STRING(tctx, name_register->out.name.scope, records[i].name.scope);
6561 CHECK_VALUE_STRING(tctx, name_register->out.reply_addr, records[i].wins.ips[0].ip);
6563 /* release the record */
6564 release->in.name = records[i].name;
6565 release->in.dest_port = lp_nbt_port(tctx->lp_ctx);
6566 release->in.dest_addr = ctx->address;
6567 release->in.address = records[i].wins.ips[0].ip;
6568 release->in.nb_flags = records[i].wins.nb_flags;
6569 release->in.broadcast = false;
6570 release->in.timeout = 30;
6571 release->in.retries = 0;
6573 status = nbt_name_release(ctx->nbtsock, ctx, release);
6574 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
6575 torture_comment(tctx, "No response from %s for name release\n", ctx->address);
6578 if (!NT_STATUS_IS_OK(status)) {
6579 torture_comment(tctx, "Bad response from %s for name query - %s\n",
6580 ctx->address, nt_errstr(status));
6583 CHECK_VALUE(tctx, release->out.rcode, 0);
6588 wins_name->name = &records[i].name;
6589 wins_name->flags = WREPL_NAME_FLAGS(records[i].replica.type,
6590 records[i].replica.state,
6591 records[i].replica.node,
6592 records[i].replica.is_static);
6593 wins_name->id = ++ctx->b.max_version;
6594 if (wins_name->flags & 2) {
6595 wins_name->addresses.addresses.num_ips = records[i].replica.num_ips;
6596 wins_name->addresses.addresses.ips = discard_const(records[i].replica.ips);
6598 wins_name->addresses.ip = records[i].replica.ips[0].ip;
6600 wins_name->unknown = "255.255.255.255";
6602 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
6603 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name,
6604 records[i].replica.apply_expected);
6606 if (records[i].replica.apply_expected) {
6607 wins_name->name = &records[i].name;
6608 wins_name->flags = WREPL_NAME_FLAGS(WREPL_TYPE_UNIQUE,
6609 WREPL_STATE_TOMBSTONE,
6610 WREPL_NODE_B, false);
6611 wins_name->id = ++ctx->b.max_version;
6612 wins_name->addresses.ip = addresses_B_1[0].ip;
6613 wins_name->unknown = "255.255.255.255";
6615 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
6616 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name, true);
6618 release->in.name = records[i].name;
6619 release->in.dest_addr = ctx->address;
6620 release->in.dest_port = lp_nbt_port(tctx->lp_ctx);
6621 release->in.address = records[i].wins.ips[0].ip;
6622 release->in.nb_flags = records[i].wins.nb_flags;
6623 release->in.broadcast = false;
6624 release->in.timeout = 30;
6625 release->in.retries = 0;
6627 status = nbt_name_release(ctx->nbtsock, ctx, release);
6628 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
6629 torture_comment(tctx, "No response from %s for name release\n", ctx->address);
6632 if (!NT_STATUS_IS_OK(status)) {
6633 torture_comment(tctx, "Bad response from %s for name query - %s\n",
6634 ctx->address, nt_errstr(status));
6637 CHECK_VALUE(tctx, release->out.rcode, 0);
6640 torture_comment(tctx, "conflict handled wrong or record[%u]: %s\n", i, records[i].line);
6648 struct test_conflict_owned_active_vs_replica_struct {
6649 const char *line; /* just better debugging */
6650 const char *section; /* just better debugging */
6651 struct nbt_name name;
6652 const char *comment;
6658 const struct wrepl_ip *ips;
6659 bool apply_expected;
6664 bool expect_release;
6667 /* when num_ips == 0, then .wins.ips are used */
6669 const struct wrepl_ip *ips;
6672 enum wrepl_name_type type;
6673 enum wrepl_name_state state;
6674 enum wrepl_name_node node;
6677 const struct wrepl_ip *ips;
6678 bool apply_expected;
6684 static void test_conflict_owned_active_vs_replica_handler(struct nbt_name_socket *nbtsock,
6685 struct nbt_name_packet *req_packet,
6686 struct socket_address *src);
6688 static bool test_conflict_owned_active_vs_replica(struct torture_context *tctx,
6689 struct test_wrepl_conflict_conn *ctx)
6693 struct wrepl_wins_name wins_name_;
6694 struct wrepl_wins_name *wins_name = &wins_name_;
6695 struct nbt_name_register name_register_;
6696 struct nbt_name_register *name_register = &name_register_;
6697 struct nbt_name_release release_;
6698 struct nbt_name_release *release = &release_;
6700 struct test_conflict_owned_active_vs_replica_struct records[] = {
6702 * unique vs. unique section
6705 * unique,active vs. unique,active with same ip(s), unchecked
6708 .line = __location__,
6709 .name = _NBT_NAME("_UA_UA_SI_U", 0x00, NULL),
6713 .num_ips = ctx->addresses_best_num,
6714 .ips = ctx->addresses_best,
6715 .apply_expected = true
6721 .type = WREPL_TYPE_UNIQUE,
6722 .state = WREPL_STATE_ACTIVE,
6723 .node = WREPL_NODE_B,
6725 .num_ips = ctx->addresses_best_num,
6726 .ips = ctx->addresses_best,
6727 .apply_expected = true
6731 * unique,active vs. unique,active with different ip(s), positive response
6734 .line = __location__,
6735 .name = _NBT_NAME("_UA_UA_DI_P", 0x00, NULL),
6739 .num_ips = ctx->addresses_best_num,
6740 .ips = ctx->addresses_best,
6741 .apply_expected = true
6748 .type = WREPL_TYPE_UNIQUE,
6749 .state = WREPL_STATE_ACTIVE,
6750 .node = WREPL_NODE_B,
6752 .num_ips = ARRAY_SIZE(addresses_B_1),
6753 .ips = addresses_B_1,
6754 .apply_expected = false
6758 * unique,active vs. unique,active with different ip(s), positive response other ips
6761 .line = __location__,
6762 .name = _NBT_NAME("_UA_UA_DI_O", 0x00, NULL),
6766 .num_ips = ctx->addresses_best_num,
6767 .ips = ctx->addresses_best,
6768 .apply_expected = true
6773 .num_ips = ARRAY_SIZE(addresses_A_3_4),
6774 .ips = addresses_A_3_4,
6777 .type = WREPL_TYPE_UNIQUE,
6778 .state = WREPL_STATE_ACTIVE,
6779 .node = WREPL_NODE_B,
6781 .num_ips = ARRAY_SIZE(addresses_B_1),
6782 .ips = addresses_B_1,
6783 .apply_expected = false
6787 * unique,active vs. unique,active with different ip(s), negative response
6790 .line = __location__,
6791 .name = _NBT_NAME("_UA_UA_DI_N", 0x00, NULL),
6795 .num_ips = ctx->addresses_best_num,
6796 .ips = ctx->addresses_best,
6797 .apply_expected = true
6804 .type = WREPL_TYPE_UNIQUE,
6805 .state = WREPL_STATE_ACTIVE,
6806 .node = WREPL_NODE_B,
6808 .num_ips = ARRAY_SIZE(addresses_B_1),
6809 .ips = addresses_B_1,
6810 .apply_expected = true
6814 * unique,active vs. unique,tombstone with same ip(s), unchecked
6817 .line = __location__,
6818 .name = _NBT_NAME("_UA_UT_SI_U", 0x00, NULL),
6822 .num_ips = ctx->addresses_best_num,
6823 .ips = ctx->addresses_best,
6824 .apply_expected = true
6830 .type = WREPL_TYPE_UNIQUE,
6831 .state = WREPL_STATE_TOMBSTONE,
6832 .node = WREPL_NODE_B,
6834 .num_ips = ctx->addresses_best_num,
6835 .ips = ctx->addresses_best,
6836 .apply_expected = false
6840 * unique,active vs. unique,tombstone with different ip(s), unchecked
6843 .line = __location__,
6844 .name = _NBT_NAME("_UA_UT_DI_U", 0x00, NULL),
6848 .num_ips = ctx->addresses_best_num,
6849 .ips = ctx->addresses_best,
6850 .apply_expected = true
6856 .type = WREPL_TYPE_UNIQUE,
6857 .state = WREPL_STATE_TOMBSTONE,
6858 .node = WREPL_NODE_B,
6860 .num_ips = ARRAY_SIZE(addresses_B_1),
6861 .ips = addresses_B_1,
6862 .apply_expected = false
6866 * unique vs. group section
6869 * unique,active vs. group,active with same ip(s), release expected
6872 .line = __location__,
6873 .name = _NBT_NAME("_UA_GA_SI_R", 0x00, NULL),
6877 .num_ips = ctx->addresses_best_num,
6878 .ips = ctx->addresses_best,
6879 .apply_expected = true
6883 .expect_release = true,
6886 .type = WREPL_TYPE_GROUP,
6887 .state = WREPL_STATE_ACTIVE,
6888 .node = WREPL_NODE_B,
6890 .num_ips = ctx->addresses_best_num,
6891 .ips = ctx->addresses_best,
6892 .apply_expected = true
6896 * unique,active vs. group,active with different ip(s), release expected
6899 .line = __location__,
6900 .name = _NBT_NAME("_UA_GA_DI_R", 0x00, NULL),
6904 .num_ips = ctx->addresses_best_num,
6905 .ips = ctx->addresses_best,
6906 .apply_expected = true
6910 .expect_release = true,
6913 .type = WREPL_TYPE_GROUP,
6914 .state = WREPL_STATE_ACTIVE,
6915 .node = WREPL_NODE_B,
6917 .num_ips = ARRAY_SIZE(addresses_B_1),
6918 .ips = addresses_B_1,
6919 .apply_expected = true
6923 * unique,active vs. group,tombstone with same ip(s), unchecked
6926 .line = __location__,
6927 .name = _NBT_NAME("_UA_GT_SI_U", 0x00, NULL),
6931 .num_ips = ctx->addresses_best_num,
6932 .ips = ctx->addresses_best,
6933 .apply_expected = true
6939 .type = WREPL_TYPE_GROUP,
6940 .state = WREPL_STATE_TOMBSTONE,
6941 .node = WREPL_NODE_B,
6943 .num_ips = ctx->addresses_best_num,
6944 .ips = ctx->addresses_best,
6945 .apply_expected = false
6949 * unique,active vs. group,tombstone with different ip(s), unchecked
6952 .line = __location__,
6953 .name = _NBT_NAME("_UA_GT_DI_U", 0x00, NULL),
6957 .num_ips = ctx->addresses_best_num,
6958 .ips = ctx->addresses_best,
6959 .apply_expected = true
6965 .type = WREPL_TYPE_GROUP,
6966 .state = WREPL_STATE_TOMBSTONE,
6967 .node = WREPL_NODE_B,
6969 .num_ips = ARRAY_SIZE(addresses_B_1),
6970 .ips = addresses_B_1,
6971 .apply_expected = false
6975 * unique vs. special group section
6978 * unique,active vs. sgroup,active with same ip(s), release expected
6981 .line = __location__,
6982 .name = _NBT_NAME("_UA_SA_SI_R", 0x00, NULL),
6986 .num_ips = ctx->addresses_best_num,
6987 .ips = ctx->addresses_best,
6988 .apply_expected = true
6992 .expect_release = true,
6995 .type = WREPL_TYPE_SGROUP,
6996 .state = WREPL_STATE_ACTIVE,
6997 .node = WREPL_NODE_B,
6999 .num_ips = ctx->addresses_best_num,
7000 .ips = ctx->addresses_best,
7001 .apply_expected = true
7005 * unique,active vs. group,active with different ip(s), release expected
7008 .line = __location__,
7009 .name = _NBT_NAME("_UA_SA_DI_R", 0x00, NULL),
7013 .num_ips = ctx->addresses_best_num,
7014 .ips = ctx->addresses_best,
7015 .apply_expected = true
7019 .expect_release = true,
7022 .type = WREPL_TYPE_SGROUP,
7023 .state = WREPL_STATE_ACTIVE,
7024 .node = WREPL_NODE_B,
7026 .num_ips = ARRAY_SIZE(addresses_B_1),
7027 .ips = addresses_B_1,
7028 .apply_expected = true
7032 * unique,active vs. sgroup,tombstone with same ip(s), unchecked
7035 .line = __location__,
7036 .name = _NBT_NAME("_UA_ST_SI_U", 0x00, NULL),
7040 .num_ips = ctx->addresses_best_num,
7041 .ips = ctx->addresses_best,
7042 .apply_expected = true
7048 .type = WREPL_TYPE_SGROUP,
7049 .state = WREPL_STATE_TOMBSTONE,
7050 .node = WREPL_NODE_B,
7052 .num_ips = ctx->addresses_best_num,
7053 .ips = ctx->addresses_best,
7054 .apply_expected = false
7058 * unique,active vs. sgroup,tombstone with different ip(s), unchecked
7061 .line = __location__,
7062 .name = _NBT_NAME("_UA_ST_DI_U", 0x00, NULL),
7066 .num_ips = ctx->addresses_best_num,
7067 .ips = ctx->addresses_best,
7068 .apply_expected = true
7074 .type = WREPL_TYPE_SGROUP,
7075 .state = WREPL_STATE_TOMBSTONE,
7076 .node = WREPL_NODE_B,
7078 .num_ips = ARRAY_SIZE(addresses_B_1),
7079 .ips = addresses_B_1,
7080 .apply_expected = false
7084 * unique vs. multi homed section
7087 * unique,active vs. mhomed,active with same ip(s), unchecked
7090 .line = __location__,
7091 .name = _NBT_NAME("_UA_MA_SI_U", 0x00, NULL),
7095 .num_ips = ctx->addresses_best_num,
7096 .ips = ctx->addresses_best,
7097 .apply_expected = true
7103 .type = WREPL_TYPE_MHOMED,
7104 .state = WREPL_STATE_ACTIVE,
7105 .node = WREPL_NODE_B,
7107 .num_ips = ctx->addresses_best_num,
7108 .ips = ctx->addresses_best,
7109 .apply_expected = true
7113 * unique,active vs. mhomed,active with superset ip(s), unchecked
7116 .line = __location__,
7117 .name = _NBT_NAME("_UA_MA_SP_U", 0x00, NULL),
7121 .num_ips = ctx->addresses_best_num,
7122 .ips = ctx->addresses_best,
7123 .apply_expected = true
7129 .type = WREPL_TYPE_MHOMED,
7130 .state = WREPL_STATE_ACTIVE,
7131 .node = WREPL_NODE_B,
7133 .num_ips = ctx->addresses_all_num,
7134 .ips = ctx->addresses_all,
7135 .apply_expected = true
7139 * unique,active vs. mhomed,active with different ip(s), positive response
7142 .line = __location__,
7143 .name = _NBT_NAME("_UA_MA_DI_P", 0x00, NULL),
7147 .num_ips = ctx->addresses_best_num,
7148 .ips = ctx->addresses_best,
7149 .apply_expected = true
7156 .type = WREPL_TYPE_MHOMED,
7157 .state = WREPL_STATE_ACTIVE,
7158 .node = WREPL_NODE_B,
7160 .num_ips = ARRAY_SIZE(addresses_B_3_4),
7161 .ips = addresses_B_3_4,
7162 .apply_expected = false
7166 * unique,active vs. mhomed,active with different ip(s), positive response other ips
7169 .line = __location__,
7170 .name = _NBT_NAME("_UA_MA_DI_O", 0x00, NULL),
7174 .num_ips = ctx->addresses_best_num,
7175 .ips = ctx->addresses_best,
7176 .apply_expected = true
7181 .num_ips = ARRAY_SIZE(addresses_A_3_4),
7182 .ips = addresses_A_3_4,
7185 .type = WREPL_TYPE_MHOMED,
7186 .state = WREPL_STATE_ACTIVE,
7187 .node = WREPL_NODE_B,
7189 .num_ips = ARRAY_SIZE(addresses_B_3_4),
7190 .ips = addresses_B_3_4,
7191 .apply_expected = false
7195 * unique,active vs. mhomed,active with different ip(s), negative response
7198 .line = __location__,
7199 .name = _NBT_NAME("_UA_MA_DI_N", 0x00, NULL),
7203 .num_ips = ctx->addresses_best_num,
7204 .ips = ctx->addresses_best,
7205 .apply_expected = true
7212 .type = WREPL_TYPE_MHOMED,
7213 .state = WREPL_STATE_ACTIVE,
7214 .node = WREPL_NODE_B,
7216 .num_ips = ARRAY_SIZE(addresses_B_3_4),
7217 .ips = addresses_B_3_4,
7218 .apply_expected = true
7222 * unique,active vs. mhomed,tombstone with same ip(s), unchecked
7225 .line = __location__,
7226 .name = _NBT_NAME("_UA_MT_SI_U", 0x00, NULL),
7230 .num_ips = ctx->addresses_best_num,
7231 .ips = ctx->addresses_best,
7232 .apply_expected = true
7238 .type = WREPL_TYPE_MHOMED,
7239 .state = WREPL_STATE_TOMBSTONE,
7240 .node = WREPL_NODE_B,
7242 .num_ips = ctx->addresses_best_num,
7243 .ips = ctx->addresses_best,
7244 .apply_expected = false
7248 * unique,active vs. mhomed,tombstone with different ip(s), unchecked
7251 .line = __location__,
7252 .name = _NBT_NAME("_UA_MT_DI_U", 0x00, NULL),
7256 .num_ips = ctx->addresses_best_num,
7257 .ips = ctx->addresses_best,
7258 .apply_expected = true
7264 .type = WREPL_TYPE_MHOMED,
7265 .state = WREPL_STATE_TOMBSTONE,
7266 .node = WREPL_NODE_B,
7268 .num_ips = ARRAY_SIZE(addresses_B_3_4),
7269 .ips = addresses_B_3_4,
7270 .apply_expected = false
7274 * normal group vs. unique section
7277 * group,active vs. unique,active with same ip(s), unchecked
7280 .line = __location__,
7281 .name = _NBT_NAME("_GA_UA_SI_U", 0x00, NULL),
7283 .nb_flags = NBT_NM_GROUP,
7285 .num_ips = ctx->addresses_best_num,
7286 .ips = ctx->addresses_best,
7287 .apply_expected = true
7293 .type = WREPL_TYPE_UNIQUE,
7294 .state = WREPL_STATE_ACTIVE,
7295 .node = WREPL_NODE_B,
7297 .num_ips = ctx->addresses_best_num,
7298 .ips = ctx->addresses_best,
7299 .apply_expected = false
7303 * group,active vs. unique,active with different ip(s), unchecked
7306 .line = __location__,
7307 .name = _NBT_NAME("_GA_UA_DI_U", 0x00, NULL),
7309 .nb_flags = NBT_NM_GROUP,
7311 .num_ips = ctx->addresses_best_num,
7312 .ips = ctx->addresses_best,
7313 .apply_expected = true
7319 .type = WREPL_TYPE_UNIQUE,
7320 .state = WREPL_STATE_ACTIVE,
7321 .node = WREPL_NODE_B,
7323 .num_ips = ARRAY_SIZE(addresses_B_1),
7324 .ips = addresses_B_1,
7325 .apply_expected = false
7329 * group,active vs. unique,tombstone with same ip(s), unchecked
7332 .line = __location__,
7333 .name = _NBT_NAME("_GA_UT_SI_U", 0x00, NULL),
7335 .nb_flags = NBT_NM_GROUP,
7337 .num_ips = ctx->addresses_best_num,
7338 .ips = ctx->addresses_best,
7339 .apply_expected = true
7345 .type = WREPL_TYPE_UNIQUE,
7346 .state = WREPL_STATE_TOMBSTONE,
7347 .node = WREPL_NODE_B,
7349 .num_ips = ctx->addresses_best_num,
7350 .ips = ctx->addresses_best,
7351 .apply_expected = false
7355 * group,active vs. unique,tombstone with different ip(s), unchecked
7358 .line = __location__,
7359 .name = _NBT_NAME("_GA_UT_DI_U", 0x00, NULL),
7361 .nb_flags = NBT_NM_GROUP,
7363 .num_ips = ctx->addresses_best_num,
7364 .ips = ctx->addresses_best,
7365 .apply_expected = true
7371 .type = WREPL_TYPE_UNIQUE,
7372 .state = WREPL_STATE_TOMBSTONE,
7373 .node = WREPL_NODE_B,
7375 .num_ips = ARRAY_SIZE(addresses_B_1),
7376 .ips = addresses_B_1,
7377 .apply_expected = false
7381 * normal group vs. normal group section
7384 * group,active vs. group,active with same ip(s), unchecked
7387 .line = __location__,
7388 .name = _NBT_NAME("_GA_GA_SI_U", 0x00, NULL),
7390 .nb_flags = NBT_NM_GROUP,
7392 .num_ips = ctx->addresses_best_num,
7393 .ips = ctx->addresses_best,
7394 .apply_expected = true
7400 .type = WREPL_TYPE_GROUP,
7401 .state = WREPL_STATE_ACTIVE,
7402 .node = WREPL_NODE_B,
7404 .num_ips = ctx->addresses_best_num,
7405 .ips = ctx->addresses_best,
7406 .apply_expected = true
7410 * group,active vs. group,active with different ip(s), unchecked
7413 .line = __location__,
7414 .name = _NBT_NAME("_GA_GA_DI_U", 0x00, NULL),
7416 .nb_flags = NBT_NM_GROUP,
7418 .num_ips = ctx->addresses_best_num,
7419 .ips = ctx->addresses_best,
7420 .apply_expected = true
7426 .type = WREPL_TYPE_GROUP,
7427 .state = WREPL_STATE_ACTIVE,
7428 .node = WREPL_NODE_B,
7430 .num_ips = ARRAY_SIZE(addresses_B_1),
7431 .ips = addresses_B_1,
7432 .apply_expected = true
7436 * group,active vs. group,tombstone with same ip(s), unchecked
7439 .line = __location__,
7440 .name = _NBT_NAME("_GA_GT_SI_U", 0x00, NULL),
7442 .nb_flags = NBT_NM_GROUP,
7444 .num_ips = ctx->addresses_best_num,
7445 .ips = ctx->addresses_best,
7446 .apply_expected = true
7452 .type = WREPL_TYPE_GROUP,
7453 .state = WREPL_STATE_TOMBSTONE,
7454 .node = WREPL_NODE_B,
7456 .num_ips = ctx->addresses_best_num,
7457 .ips = ctx->addresses_best,
7458 .apply_expected = false
7462 * group,active vs. group,tombstone with different ip(s), unchecked
7465 .line = __location__,
7466 .name = _NBT_NAME("_GA_GT_DI_U", 0x00, NULL),
7468 .nb_flags = NBT_NM_GROUP,
7470 .num_ips = ctx->addresses_best_num,
7471 .ips = ctx->addresses_best,
7472 .apply_expected = true
7478 .type = WREPL_TYPE_GROUP,
7479 .state = WREPL_STATE_TOMBSTONE,
7480 .node = WREPL_NODE_B,
7482 .num_ips = ARRAY_SIZE(addresses_B_1),
7483 .ips = addresses_B_1,
7484 .apply_expected = false
7488 * normal group vs. special group section
7491 * group,active vs. sgroup,active with same ip(s), unchecked
7494 .line = __location__,
7495 .name = _NBT_NAME("_GA_SA_SI_U", 0x00, NULL),
7497 .nb_flags = NBT_NM_GROUP,
7499 .num_ips = ctx->addresses_best_num,
7500 .ips = ctx->addresses_best,
7501 .apply_expected = true
7507 .type = WREPL_TYPE_SGROUP,
7508 .state = WREPL_STATE_ACTIVE,
7509 .node = WREPL_NODE_B,
7511 .num_ips = ctx->addresses_best_num,
7512 .ips = ctx->addresses_best,
7513 .apply_expected = false
7517 * group,active vs. sgroup,active with different ip(s), unchecked
7520 .line = __location__,
7521 .name = _NBT_NAME("_GA_SA_DI_U", 0x00, NULL),
7523 .nb_flags = NBT_NM_GROUP,
7525 .num_ips = ctx->addresses_best_num,
7526 .ips = ctx->addresses_best,
7527 .apply_expected = true
7533 .type = WREPL_TYPE_SGROUP,
7534 .state = WREPL_STATE_ACTIVE,
7535 .node = WREPL_NODE_B,
7537 .num_ips = ARRAY_SIZE(addresses_B_3_4),
7538 .ips = addresses_B_3_4,
7539 .apply_expected = false
7543 * group,active vs. sgroup,tombstone with same ip(s), unchecked
7546 .line = __location__,
7547 .name = _NBT_NAME("_GA_ST_SI_U", 0x00, NULL),
7549 .nb_flags = NBT_NM_GROUP,
7551 .num_ips = ctx->addresses_best_num,
7552 .ips = ctx->addresses_best,
7553 .apply_expected = true
7559 .type = WREPL_TYPE_SGROUP,
7560 .state = WREPL_STATE_TOMBSTONE,
7561 .node = WREPL_NODE_B,
7563 .num_ips = ctx->addresses_best_num,
7564 .ips = ctx->addresses_best,
7565 .apply_expected = false
7569 * group,active vs. sgroup,tombstone with different ip(s), unchecked
7572 .line = __location__,
7573 .name = _NBT_NAME("_GA_ST_DI_U", 0x00, NULL),
7575 .nb_flags = NBT_NM_GROUP,
7577 .num_ips = ctx->addresses_best_num,
7578 .ips = ctx->addresses_best,
7579 .apply_expected = true
7585 .type = WREPL_TYPE_SGROUP,
7586 .state = WREPL_STATE_TOMBSTONE,
7587 .node = WREPL_NODE_B,
7589 .num_ips = ARRAY_SIZE(addresses_B_3_4),
7590 .ips = addresses_B_3_4,
7591 .apply_expected = false
7595 * normal group vs. multi homed section
7598 * group,active vs. mhomed,active with same ip(s), unchecked
7601 .line = __location__,
7602 .name = _NBT_NAME("_GA_MA_SI_U", 0x00, NULL),
7604 .nb_flags = NBT_NM_GROUP,
7606 .num_ips = ctx->addresses_best_num,
7607 .ips = ctx->addresses_best,
7608 .apply_expected = true
7614 .type = WREPL_TYPE_MHOMED,
7615 .state = WREPL_STATE_ACTIVE,
7616 .node = WREPL_NODE_B,
7618 .num_ips = ctx->addresses_best_num,
7619 .ips = ctx->addresses_best,
7620 .apply_expected = false
7624 * group,active vs. mhomed,active with different ip(s), unchecked
7627 .line = __location__,
7628 .name = _NBT_NAME("_GA_MA_DI_U", 0x00, NULL),
7630 .nb_flags = NBT_NM_GROUP,
7632 .num_ips = ctx->addresses_best_num,
7633 .ips = ctx->addresses_best,
7634 .apply_expected = true
7640 .type = WREPL_TYPE_MHOMED,
7641 .state = WREPL_STATE_ACTIVE,
7642 .node = WREPL_NODE_B,
7644 .num_ips = ARRAY_SIZE(addresses_B_3_4),
7645 .ips = addresses_B_3_4,
7646 .apply_expected = false
7650 * group,active vs. mhomed,tombstone with same ip(s), unchecked
7653 .line = __location__,
7654 .name = _NBT_NAME("_GA_MT_SI_U", 0x00, NULL),
7656 .nb_flags = NBT_NM_GROUP,
7658 .num_ips = ctx->addresses_best_num,
7659 .ips = ctx->addresses_best,
7660 .apply_expected = true
7666 .type = WREPL_TYPE_MHOMED,
7667 .state = WREPL_STATE_TOMBSTONE,
7668 .node = WREPL_NODE_B,
7670 .num_ips = ctx->addresses_best_num,
7671 .ips = ctx->addresses_best,
7672 .apply_expected = false
7676 * group,active vs. mhomed,tombstone with different ip(s), unchecked
7679 .line = __location__,
7680 .name = _NBT_NAME("_GA_MT_DI_U", 0x00, NULL),
7682 .nb_flags = NBT_NM_GROUP,
7684 .num_ips = ctx->addresses_best_num,
7685 .ips = ctx->addresses_best,
7686 .apply_expected = true
7692 .type = WREPL_TYPE_MHOMED,
7693 .state = WREPL_STATE_TOMBSTONE,
7694 .node = WREPL_NODE_B,
7696 .num_ips = ARRAY_SIZE(addresses_B_3_4),
7697 .ips = addresses_B_3_4,
7698 .apply_expected = false
7702 * special group vs. unique section
7705 * sgroup,active vs. unique,active with same ip(s), unchecked
7708 .line = __location__,
7709 .name = _NBT_NAME("_SA_UA_SI_U", 0x1C, NULL),
7711 .nb_flags = NBT_NM_GROUP,
7713 .num_ips = ctx->addresses_best_num,
7714 .ips = ctx->addresses_best,
7715 .apply_expected = true
7721 .type = WREPL_TYPE_UNIQUE,
7722 .state = WREPL_STATE_ACTIVE,
7723 .node = WREPL_NODE_B,
7725 .num_ips = ctx->addresses_best_num,
7726 .ips = ctx->addresses_best,
7727 .apply_expected = false
7731 * sgroup,active vs. unique,active with different ip(s), unchecked
7734 .line = __location__,
7735 .name = _NBT_NAME("_SA_UA_DI_U", 0x1C, NULL),
7737 .nb_flags = NBT_NM_GROUP,
7739 .num_ips = ctx->addresses_best_num,
7740 .ips = ctx->addresses_best,
7741 .apply_expected = true
7747 .type = WREPL_TYPE_UNIQUE,
7748 .state = WREPL_STATE_ACTIVE,
7749 .node = WREPL_NODE_B,
7751 .num_ips = ARRAY_SIZE(addresses_B_1),
7752 .ips = addresses_B_1,
7753 .apply_expected = false
7757 * sgroup,active vs. unique,tombstone with same ip(s), unchecked
7760 .line = __location__,
7761 .name = _NBT_NAME("_SA_UT_SI_U", 0x1C, NULL),
7763 .nb_flags = NBT_NM_GROUP,
7765 .num_ips = ctx->addresses_best_num,
7766 .ips = ctx->addresses_best,
7767 .apply_expected = true
7773 .type = WREPL_TYPE_UNIQUE,
7774 .state = WREPL_STATE_TOMBSTONE,
7775 .node = WREPL_NODE_B,
7777 .num_ips = ctx->addresses_best_num,
7778 .ips = ctx->addresses_best,
7779 .apply_expected = false
7783 * sgroup,active vs. unique,tombstone with different ip(s), unchecked
7786 .line = __location__,
7787 .name = _NBT_NAME("_SA_UT_DI_U", 0x1C, NULL),
7789 .nb_flags = NBT_NM_GROUP,
7791 .num_ips = ctx->addresses_best_num,
7792 .ips = ctx->addresses_best,
7793 .apply_expected = true
7799 .type = WREPL_TYPE_UNIQUE,
7800 .state = WREPL_STATE_TOMBSTONE,
7801 .node = WREPL_NODE_B,
7803 .num_ips = ARRAY_SIZE(addresses_B_1),
7804 .ips = addresses_B_1,
7805 .apply_expected = false
7809 * special group vs. normal group section
7812 * sgroup,active vs. group,active with same ip(s), unchecked
7815 .line = __location__,
7816 .name = _NBT_NAME("_SA_GA_SI_U", 0x1C, NULL),
7818 .nb_flags = NBT_NM_GROUP,
7820 .num_ips = ctx->addresses_best_num,
7821 .ips = ctx->addresses_best,
7822 .apply_expected = true
7828 .type = WREPL_TYPE_GROUP,
7829 .state = WREPL_STATE_ACTIVE,
7830 .node = WREPL_NODE_B,
7832 .num_ips = ctx->addresses_best_num,
7833 .ips = ctx->addresses_best,
7834 .apply_expected = false
7838 * sgroup,active vs. group,active with different ip(s), unchecked
7841 .line = __location__,
7842 .name = _NBT_NAME("_SA_GA_DI_U", 0x1C, NULL),
7844 .nb_flags = NBT_NM_GROUP,
7846 .num_ips = ctx->addresses_best_num,
7847 .ips = ctx->addresses_best,
7848 .apply_expected = true
7854 .type = WREPL_TYPE_GROUP,
7855 .state = WREPL_STATE_ACTIVE,
7856 .node = WREPL_NODE_B,
7858 .num_ips = ARRAY_SIZE(addresses_B_1),
7859 .ips = addresses_B_1,
7860 .apply_expected = false
7864 * sgroup,active vs. group,tombstone with same ip(s), unchecked
7867 .line = __location__,
7868 .name = _NBT_NAME("_SA_GT_SI_U", 0x1C, NULL),
7870 .nb_flags = NBT_NM_GROUP,
7872 .num_ips = ctx->addresses_best_num,
7873 .ips = ctx->addresses_best,
7874 .apply_expected = true
7880 .type = WREPL_TYPE_GROUP,
7881 .state = WREPL_STATE_TOMBSTONE,
7882 .node = WREPL_NODE_B,
7884 .num_ips = ctx->addresses_best_num,
7885 .ips = ctx->addresses_best,
7886 .apply_expected = false
7890 * sgroup,active vs. group,tombstone with different ip(s), unchecked
7893 .line = __location__,
7894 .name = _NBT_NAME("_SA_GT_DI_U", 0x1C, NULL),
7896 .nb_flags = NBT_NM_GROUP,
7898 .num_ips = ctx->addresses_best_num,
7899 .ips = ctx->addresses_best,
7900 .apply_expected = true
7906 .type = WREPL_TYPE_GROUP,
7907 .state = WREPL_STATE_TOMBSTONE,
7908 .node = WREPL_NODE_B,
7910 .num_ips = ARRAY_SIZE(addresses_B_1),
7911 .ips = addresses_B_1,
7912 .apply_expected = false
7916 * special group vs. multi homed section
7919 * sgroup,active vs. mhomed,active with same ip(s), unchecked
7922 .line = __location__,
7923 .name = _NBT_NAME("_SA_MA_SI_U", 0x1C, NULL),
7925 .nb_flags = NBT_NM_GROUP,
7927 .num_ips = ctx->addresses_best_num,
7928 .ips = ctx->addresses_best,
7929 .apply_expected = true
7935 .type = WREPL_TYPE_MHOMED,
7936 .state = WREPL_STATE_ACTIVE,
7937 .node = WREPL_NODE_B,
7939 .num_ips = ctx->addresses_best_num,
7940 .ips = ctx->addresses_best,
7941 .apply_expected = false
7945 * sgroup,active vs. mhomed,active with different ip(s), unchecked
7948 .line = __location__,
7949 .name = _NBT_NAME("_SA_MA_DI_U", 0x1C, NULL),
7951 .nb_flags = NBT_NM_GROUP,
7953 .num_ips = ctx->addresses_best_num,
7954 .ips = ctx->addresses_best,
7955 .apply_expected = true
7961 .type = WREPL_TYPE_MHOMED,
7962 .state = WREPL_STATE_ACTIVE,
7963 .node = WREPL_NODE_B,
7965 .num_ips = ARRAY_SIZE(addresses_B_1),
7966 .ips = addresses_B_1,
7967 .apply_expected = false
7971 * sgroup,active vs. mhomed,tombstone with same ip(s), unchecked
7974 .line = __location__,
7975 .name = _NBT_NAME("_SA_MT_SI_U", 0x1C, NULL),
7977 .nb_flags = NBT_NM_GROUP,
7979 .num_ips = ctx->addresses_best_num,
7980 .ips = ctx->addresses_best,
7981 .apply_expected = true
7987 .type = WREPL_TYPE_MHOMED,
7988 .state = WREPL_STATE_TOMBSTONE,
7989 .node = WREPL_NODE_B,
7991 .num_ips = ctx->addresses_best_num,
7992 .ips = ctx->addresses_best,
7993 .apply_expected = false
7997 * sgroup,active vs. mhomed,tombstone with different ip(s), unchecked
8000 .line = __location__,
8001 .name = _NBT_NAME("_SA_MT_DI_U", 0x1C, NULL),
8003 .nb_flags = NBT_NM_GROUP,
8005 .num_ips = ctx->addresses_best_num,
8006 .ips = ctx->addresses_best,
8007 .apply_expected = true
8013 .type = WREPL_TYPE_MHOMED,
8014 .state = WREPL_STATE_TOMBSTONE,
8015 .node = WREPL_NODE_B,
8017 .num_ips = ARRAY_SIZE(addresses_B_1),
8018 .ips = addresses_B_1,
8019 .apply_expected = false
8023 * multi homed vs. unique section
8026 * mhomed,active vs. unique,active with same ip(s), unchecked
8029 .line = __location__,
8030 .name = _NBT_NAME("_MA_UA_SI_U", 0x00, NULL),
8034 .num_ips = ctx->addresses_best_num,
8035 .ips = ctx->addresses_best,
8036 .apply_expected = true
8042 .type = WREPL_TYPE_UNIQUE,
8043 .state = WREPL_STATE_ACTIVE,
8044 .node = WREPL_NODE_B,
8046 .num_ips = ctx->addresses_best_num,
8047 .ips = ctx->addresses_best,
8048 .apply_expected = true
8052 * mhomed,active vs. unique,active with different ip(s), positive response
8055 .line = __location__,
8056 .name = _NBT_NAME("_MA_UA_DI_P", 0x00, NULL),
8060 .num_ips = ctx->addresses_best_num,
8061 .ips = ctx->addresses_best,
8062 .apply_expected = true
8069 .type = WREPL_TYPE_UNIQUE,
8070 .state = WREPL_STATE_ACTIVE,
8071 .node = WREPL_NODE_B,
8073 .num_ips = ARRAY_SIZE(addresses_B_1),
8074 .ips = addresses_B_1,
8075 .apply_expected = false
8079 * mhomed,active vs. unique,active with different ip(s), positive response other ips
8082 .line = __location__,
8083 .name = _NBT_NAME("_MA_UA_DI_O", 0x00, NULL),
8087 .num_ips = ctx->addresses_best_num,
8088 .ips = ctx->addresses_best,
8089 .apply_expected = true
8094 .num_ips = ARRAY_SIZE(addresses_A_3_4),
8095 .ips = addresses_A_3_4,
8098 .type = WREPL_TYPE_UNIQUE,
8099 .state = WREPL_STATE_ACTIVE,
8100 .node = WREPL_NODE_B,
8102 .num_ips = ARRAY_SIZE(addresses_B_1),
8103 .ips = addresses_B_1,
8104 .apply_expected = false
8108 * mhomed,active vs. unique,active with different ip(s), negative response
8111 .line = __location__,
8112 .name = _NBT_NAME("_MA_UA_DI_N", 0x00, NULL),
8116 .num_ips = ctx->addresses_best_num,
8117 .ips = ctx->addresses_best,
8118 .apply_expected = true
8125 .type = WREPL_TYPE_UNIQUE,
8126 .state = WREPL_STATE_ACTIVE,
8127 .node = WREPL_NODE_B,
8129 .num_ips = ARRAY_SIZE(addresses_B_1),
8130 .ips = addresses_B_1,
8131 .apply_expected = true
8135 * mhomed,active vs. unique,tombstone with same ip(s), unchecked
8138 .line = __location__,
8139 .name = _NBT_NAME("_MA_UT_SI_U", 0x00, NULL),
8143 .num_ips = ctx->addresses_best_num,
8144 .ips = ctx->addresses_best,
8145 .apply_expected = true
8151 .type = WREPL_TYPE_UNIQUE,
8152 .state = WREPL_STATE_TOMBSTONE,
8153 .node = WREPL_NODE_B,
8155 .num_ips = ctx->addresses_best_num,
8156 .ips = ctx->addresses_best,
8157 .apply_expected = false
8161 * mhomed,active vs. unique,tombstone with different ip(s), unchecked
8164 .line = __location__,
8165 .name = _NBT_NAME("_MA_UT_DI_U", 0x00, NULL),
8169 .num_ips = ctx->addresses_best_num,
8170 .ips = ctx->addresses_best,
8171 .apply_expected = true
8177 .type = WREPL_TYPE_UNIQUE,
8178 .state = WREPL_STATE_TOMBSTONE,
8179 .node = WREPL_NODE_B,
8181 .num_ips = ARRAY_SIZE(addresses_B_1),
8182 .ips = addresses_B_1,
8183 .apply_expected = false
8187 * multi homed vs. normal group section
8190 * mhomed,active vs. group,active with same ip(s), release expected
8193 .line = __location__,
8194 .name = _NBT_NAME("_MA_GA_SI_R", 0x00, NULL),
8198 .num_ips = ctx->addresses_best_num,
8199 .ips = ctx->addresses_best,
8200 .apply_expected = true
8204 .expect_release = true,
8207 .type = WREPL_TYPE_GROUP,
8208 .state = WREPL_STATE_ACTIVE,
8209 .node = WREPL_NODE_B,
8211 .num_ips = ctx->addresses_best_num,
8212 .ips = ctx->addresses_best,
8213 .apply_expected = true
8217 * mhomed,active vs. group,active with different ip(s), release expected
8220 .line = __location__,
8221 .name = _NBT_NAME("_MA_GA_DI_R", 0x00, NULL),
8225 .num_ips = ctx->addresses_best_num,
8226 .ips = ctx->addresses_best,
8227 .apply_expected = true
8231 .expect_release = true,
8234 .type = WREPL_TYPE_GROUP,
8235 .state = WREPL_STATE_ACTIVE,
8236 .node = WREPL_NODE_B,
8238 .num_ips = ARRAY_SIZE(addresses_B_1),
8239 .ips = addresses_B_1,
8240 .apply_expected = true
8244 * mhomed,active vs. group,tombstone with same ip(s), unchecked
8247 .line = __location__,
8248 .name = _NBT_NAME("_MA_GT_SI_U", 0x00, NULL),
8252 .num_ips = ctx->addresses_best_num,
8253 .ips = ctx->addresses_best,
8254 .apply_expected = true
8260 .type = WREPL_TYPE_GROUP,
8261 .state = WREPL_STATE_TOMBSTONE,
8262 .node = WREPL_NODE_B,
8264 .num_ips = ctx->addresses_best_num,
8265 .ips = ctx->addresses_best,
8266 .apply_expected = false
8270 * mhomed,active vs. group,tombstone with different ip(s), unchecked
8273 .line = __location__,
8274 .name = _NBT_NAME("_MA_GT_DI_U", 0x00, NULL),
8278 .num_ips = ctx->addresses_best_num,
8279 .ips = ctx->addresses_best,
8280 .apply_expected = true
8286 .type = WREPL_TYPE_GROUP,
8287 .state = WREPL_STATE_TOMBSTONE,
8288 .node = WREPL_NODE_B,
8290 .num_ips = ARRAY_SIZE(addresses_B_1),
8291 .ips = addresses_B_1,
8292 .apply_expected = false
8296 * multi homed vs. special group section
8299 * mhomed,active vs. sgroup,active with same ip(s), release expected
8302 .line = __location__,
8303 .name = _NBT_NAME("_MA_SA_SI_R", 0x00, NULL),
8307 .num_ips = ctx->addresses_best_num,
8308 .ips = ctx->addresses_best,
8309 .apply_expected = true
8313 .expect_release = true,
8316 .type = WREPL_TYPE_SGROUP,
8317 .state = WREPL_STATE_ACTIVE,
8318 .node = WREPL_NODE_B,
8320 .num_ips = ctx->addresses_best_num,
8321 .ips = ctx->addresses_best,
8322 .apply_expected = true
8326 * mhomed,active vs. group,active with different ip(s), release expected
8329 .line = __location__,
8330 .name = _NBT_NAME("_MA_SA_DI_R", 0x00, NULL),
8334 .num_ips = ctx->addresses_best_num,
8335 .ips = ctx->addresses_best,
8336 .apply_expected = true
8340 .expect_release = true,
8343 .type = WREPL_TYPE_SGROUP,
8344 .state = WREPL_STATE_ACTIVE,
8345 .node = WREPL_NODE_B,
8347 .num_ips = ARRAY_SIZE(addresses_B_1),
8348 .ips = addresses_B_1,
8349 .apply_expected = true
8353 * mhomed,active vs. sgroup,tombstone with same ip(s), unchecked
8356 .line = __location__,
8357 .name = _NBT_NAME("_MA_ST_SI_U", 0x00, NULL),
8361 .num_ips = ctx->addresses_best_num,
8362 .ips = ctx->addresses_best,
8363 .apply_expected = true
8369 .type = WREPL_TYPE_SGROUP,
8370 .state = WREPL_STATE_TOMBSTONE,
8371 .node = WREPL_NODE_B,
8373 .num_ips = ctx->addresses_best_num,
8374 .ips = ctx->addresses_best,
8375 .apply_expected = false
8379 * mhomed,active vs. sgroup,tombstone with different ip(s), unchecked
8382 .line = __location__,
8383 .name = _NBT_NAME("_MA_ST_DI_U", 0x00, NULL),
8387 .num_ips = ctx->addresses_best_num,
8388 .ips = ctx->addresses_best,
8389 .apply_expected = true
8395 .type = WREPL_TYPE_SGROUP,
8396 .state = WREPL_STATE_TOMBSTONE,
8397 .node = WREPL_NODE_B,
8399 .num_ips = ARRAY_SIZE(addresses_B_1),
8400 .ips = addresses_B_1,
8401 .apply_expected = false
8405 * multi homed vs. multi homed section
8408 * mhomed,active vs. mhomed,active with same ip(s), unchecked
8411 .line = __location__,
8412 .name = _NBT_NAME("_MA_MA_SI_U", 0x00, NULL),
8416 .num_ips = ctx->addresses_best_num,
8417 .ips = ctx->addresses_best,
8418 .apply_expected = true
8424 .type = WREPL_TYPE_MHOMED,
8425 .state = WREPL_STATE_ACTIVE,
8426 .node = WREPL_NODE_B,
8428 .num_ips = ctx->addresses_best_num,
8429 .ips = ctx->addresses_best,
8430 .apply_expected = true
8434 * mhomed,active vs. mhomed,active with superset ip(s), unchecked
8437 .line = __location__,
8438 .name = _NBT_NAME("_MA_MA_SP_U", 0x00, NULL),
8442 .num_ips = ctx->addresses_best_num,
8443 .ips = ctx->addresses_best,
8444 .apply_expected = true
8450 .type = WREPL_TYPE_MHOMED,
8451 .state = WREPL_STATE_ACTIVE,
8452 .node = WREPL_NODE_B,
8454 .num_ips = ctx->addresses_all_num,
8455 .ips = ctx->addresses_all,
8456 .apply_expected = true
8460 * mhomed,active vs. mhomed,active with different ip(s), positive response
8463 .line = __location__,
8464 .name = _NBT_NAME("_MA_MA_DI_P", 0x00, NULL),
8468 .num_ips = ctx->addresses_best_num,
8469 .ips = ctx->addresses_best,
8470 .apply_expected = true
8477 .type = WREPL_TYPE_MHOMED,
8478 .state = WREPL_STATE_ACTIVE,
8479 .node = WREPL_NODE_B,
8481 .num_ips = ARRAY_SIZE(addresses_B_3_4),
8482 .ips = addresses_B_3_4,
8483 .apply_expected = false
8487 * mhomed,active vs. mhomed,active with different ip(s), positive response other ips
8490 .line = __location__,
8491 .name = _NBT_NAME("_MA_MA_DI_O", 0x00, NULL),
8495 .num_ips = ctx->addresses_best_num,
8496 .ips = ctx->addresses_best,
8497 .apply_expected = true
8502 .num_ips = ARRAY_SIZE(addresses_A_3_4),
8503 .ips = addresses_A_3_4,
8506 .type = WREPL_TYPE_MHOMED,
8507 .state = WREPL_STATE_ACTIVE,
8508 .node = WREPL_NODE_B,
8510 .num_ips = ARRAY_SIZE(addresses_B_3_4),
8511 .ips = addresses_B_3_4,
8512 .apply_expected = false
8516 * mhomed,active vs. mhomed,active with different ip(s), negative response
8519 .line = __location__,
8520 .name = _NBT_NAME("_MA_MA_DI_N", 0x00, NULL),
8524 .num_ips = ctx->addresses_best_num,
8525 .ips = ctx->addresses_best,
8526 .apply_expected = true
8533 .type = WREPL_TYPE_MHOMED,
8534 .state = WREPL_STATE_ACTIVE,
8535 .node = WREPL_NODE_B,
8537 .num_ips = ARRAY_SIZE(addresses_B_3_4),
8538 .ips = addresses_B_3_4,
8539 .apply_expected = true
8543 * mhomed,active vs. mhomed,tombstone with same ip(s), unchecked
8546 .line = __location__,
8547 .name = _NBT_NAME("_MA_MT_SI_U", 0x00, NULL),
8551 .num_ips = ctx->addresses_best_num,
8552 .ips = ctx->addresses_best,
8553 .apply_expected = true
8559 .type = WREPL_TYPE_MHOMED,
8560 .state = WREPL_STATE_TOMBSTONE,
8561 .node = WREPL_NODE_B,
8563 .num_ips = ctx->addresses_best_num,
8564 .ips = ctx->addresses_best,
8565 .apply_expected = false
8569 * mhomed,active vs. mhomed,tombstone with different ip(s), unchecked
8572 .line = __location__,
8573 .name = _NBT_NAME("_MA_MT_DI_U", 0x00, NULL),
8577 .num_ips = ctx->addresses_best_num,
8578 .ips = ctx->addresses_best,
8579 .apply_expected = true
8585 .type = WREPL_TYPE_MHOMED,
8586 .state = WREPL_STATE_TOMBSTONE,
8587 .node = WREPL_NODE_B,
8589 .num_ips = ARRAY_SIZE(addresses_B_3_4),
8590 .ips = addresses_B_3_4,
8591 .apply_expected = false
8595 * some more multi homed test, including merging
8598 * mhomed,active vs. mhomed,active with superset ip(s), unchecked
8601 .line = __location__,
8602 .section= "Test Replica vs. owned active: some more MHOMED combinations",
8603 .name = _NBT_NAME("_MA_MA_SP_U", 0x00, NULL),
8604 .comment= "C:MHOMED vs. B:ALL => B:ALL",
8605 .skip = (ctx->addresses_all_num < 3),
8609 .num_ips = ctx->addresses_mhomed_num,
8610 .ips = ctx->addresses_mhomed,
8611 .apply_expected = true
8617 .type = WREPL_TYPE_MHOMED,
8618 .state = WREPL_STATE_ACTIVE,
8619 .node = WREPL_NODE_B,
8621 .num_ips = ctx->addresses_all_num,
8622 .ips = ctx->addresses_all,
8623 .apply_expected = true
8627 * mhomed,active vs. mhomed,active with same ips, unchecked
8630 .line = __location__,
8631 .name = _NBT_NAME("_MA_MA_SM_U", 0x00, NULL),
8632 .comment= "C:MHOMED vs. B:MHOMED => B:MHOMED",
8633 .skip = (ctx->addresses_mhomed_num < 2),
8637 .num_ips = ctx->addresses_mhomed_num,
8638 .ips = ctx->addresses_mhomed,
8639 .apply_expected = true
8645 .type = WREPL_TYPE_MHOMED,
8646 .state = WREPL_STATE_ACTIVE,
8647 .node = WREPL_NODE_B,
8649 .num_ips = ctx->addresses_mhomed_num,
8650 .ips = ctx->addresses_mhomed,
8651 .apply_expected = true
8655 * mhomed,active vs. mhomed,active with subset ip(s), positive response
8658 .line = __location__,
8659 .name = _NBT_NAME("_MA_MA_SB_P", 0x00, NULL),
8660 .comment= "C:MHOMED vs. B:BEST (C:MHOMED) => B:MHOMED",
8661 .skip = (ctx->addresses_mhomed_num < 2),
8665 .num_ips = ctx->addresses_mhomed_num,
8666 .ips = ctx->addresses_mhomed,
8667 .apply_expected = true
8674 .type = WREPL_TYPE_MHOMED,
8675 .state = WREPL_STATE_ACTIVE,
8676 .node = WREPL_NODE_B,
8678 .num_ips = ctx->addresses_best_num,
8679 .ips = ctx->addresses_best,
8680 .mhomed_merge = true
8684 * mhomed,active vs. mhomed,active with subset ip(s), positive response, with all addresses
8687 .line = __location__,
8688 .name = _NBT_NAME("_MA_MA_SB_A", 0x00, NULL),
8689 .comment= "C:MHOMED vs. B:BEST (C:ALL) => B:MHOMED",
8690 .skip = (ctx->addresses_all_num < 3),
8694 .num_ips = ctx->addresses_mhomed_num,
8695 .ips = ctx->addresses_mhomed,
8696 .apply_expected = true
8701 .num_ips = ctx->addresses_all_num,
8702 .ips = ctx->addresses_all,
8705 .type = WREPL_TYPE_MHOMED,
8706 .state = WREPL_STATE_ACTIVE,
8707 .node = WREPL_NODE_B,
8709 .num_ips = ctx->addresses_best_num,
8710 .ips = ctx->addresses_best,
8711 .mhomed_merge = true
8715 * mhomed,active vs. mhomed,active with subset ip(s), positive response, with replicas addresses
8716 * TODO: check why the server sends a name release demand for one address?
8717 * the release demand has no effect to the database record...
8720 .line = __location__,
8721 .name = _NBT_NAME("_MA_MA_SB_PRA", 0x00, NULL),
8722 .comment= "C:MHOMED vs. B:BEST (C:BEST) => C:MHOMED",
8723 .skip = (ctx->addresses_all_num < 2),
8727 .num_ips = ctx->addresses_mhomed_num,
8728 .ips = ctx->addresses_mhomed,
8729 .apply_expected = true
8734 .num_ips = ctx->addresses_best_num,
8735 .ips = ctx->addresses_best,
8736 .late_release = true
8739 .type = WREPL_TYPE_MHOMED,
8740 .state = WREPL_STATE_ACTIVE,
8741 .node = WREPL_NODE_B,
8743 .num_ips = ctx->addresses_best_num,
8744 .ips = ctx->addresses_best,
8745 .apply_expected = false
8749 * mhomed,active vs. mhomed,active with subset ip(s), positive response, with other addresses
8752 .line = __location__,
8753 .name = _NBT_NAME("_MA_MA_SB_O", 0x00, NULL),
8754 .comment= "C:MHOMED vs. B:BEST (B:B_3_4) =>C:MHOMED",
8755 .skip = (ctx->addresses_all_num < 2),
8759 .num_ips = ctx->addresses_mhomed_num,
8760 .ips = ctx->addresses_mhomed,
8761 .apply_expected = true
8766 .num_ips = ARRAY_SIZE(addresses_B_3_4),
8767 .ips = addresses_B_3_4,
8770 .type = WREPL_TYPE_MHOMED,
8771 .state = WREPL_STATE_ACTIVE,
8772 .node = WREPL_NODE_B,
8774 .num_ips = ctx->addresses_best_num,
8775 .ips = ctx->addresses_best,
8776 .apply_expected = false
8780 * mhomed,active vs. mhomed,active with subset ip(s), negative response
8783 .line = __location__,
8784 .name = _NBT_NAME("_MA_MA_SB_N", 0x00, NULL),
8785 .comment= "C:MHOMED vs. B:BEST (NEGATIVE) => B:BEST",
8786 .skip = (ctx->addresses_mhomed_num < 2),
8790 .num_ips = ctx->addresses_mhomed_num,
8791 .ips = ctx->addresses_mhomed,
8792 .apply_expected = true
8799 .type = WREPL_TYPE_MHOMED,
8800 .state = WREPL_STATE_ACTIVE,
8801 .node = WREPL_NODE_B,
8803 .num_ips = ctx->addresses_best_num,
8804 .ips = ctx->addresses_best,
8805 .apply_expected = true
8809 * some more multi homed and unique test, including merging
8812 * mhomed,active vs. unique,active with subset ip(s), positive response
8815 .line = __location__,
8816 .section= "Test Replica vs. owned active: some more UNIQUE,MHOMED combinations",
8817 .name = _NBT_NAME("_MA_UA_SB_P", 0x00, NULL),
8818 .comment= "C:MHOMED vs. B:UNIQUE,BEST (C:MHOMED) => B:MHOMED",
8819 .skip = (ctx->addresses_all_num < 2),
8823 .num_ips = ctx->addresses_mhomed_num,
8824 .ips = ctx->addresses_mhomed,
8825 .apply_expected = true
8832 .type = WREPL_TYPE_UNIQUE,
8833 .state = WREPL_STATE_ACTIVE,
8834 .node = WREPL_NODE_B,
8836 .num_ips = ctx->addresses_best_num,
8837 .ips = ctx->addresses_best,
8838 .mhomed_merge = true
8842 * unique,active vs. unique,active with different ip(s), positive response, with replicas address
8843 * TODO: check why the server sends a name release demand for one address?
8844 * the release demand has no effect to the database record...
8847 .line = __location__,
8848 .name = _NBT_NAME("_UA_UA_DI_PRA", 0x00, NULL),
8849 .comment= "C:BEST vs. B:BEST2 (C:BEST2,LR:BEST2) => C:BEST",
8850 .skip = (ctx->addresses_all_num < 2),
8854 .num_ips = ctx->addresses_best_num,
8855 .ips = ctx->addresses_best,
8856 .apply_expected = true
8861 .num_ips = ctx->addresses_best2_num,
8862 .ips = ctx->addresses_best2,
8863 .late_release = true
8866 .type = WREPL_TYPE_UNIQUE,
8867 .state = WREPL_STATE_ACTIVE,
8868 .node = WREPL_NODE_B,
8870 .num_ips = ctx->addresses_best2_num,
8871 .ips = ctx->addresses_best2,
8872 .apply_expected = false,
8876 * unique,active vs. unique,active with different ip(s), positive response, with all addresses
8879 .line = __location__,
8880 .name = _NBT_NAME("_UA_UA_DI_A", 0x00, NULL),
8881 .comment= "C:BEST vs. B:BEST2 (C:ALL) => B:MHOMED",
8882 .skip = (ctx->addresses_all_num < 3),
8886 .num_ips = ctx->addresses_best_num,
8887 .ips = ctx->addresses_best,
8888 .apply_expected = true
8893 .num_ips = ctx->addresses_all_num,
8894 .ips = ctx->addresses_all,
8897 .type = WREPL_TYPE_UNIQUE,
8898 .state = WREPL_STATE_ACTIVE,
8899 .node = WREPL_NODE_B,
8901 .num_ips = ctx->addresses_best2_num,
8902 .ips = ctx->addresses_best2,
8903 .mhomed_merge = true,
8907 * unique,active vs. mhomed,active with different ip(s), positive response, with all addresses
8910 .line = __location__,
8911 .name = _NBT_NAME("_UA_MA_DI_A", 0x00, NULL),
8912 .comment= "C:BEST vs. B:BEST2 (C:ALL) => B:MHOMED",
8913 .skip = (ctx->addresses_all_num < 3),
8917 .num_ips = ctx->addresses_best_num,
8918 .ips = ctx->addresses_best,
8919 .apply_expected = true
8924 .num_ips = ctx->addresses_all_num,
8925 .ips = ctx->addresses_all,
8928 .type = WREPL_TYPE_MHOMED,
8929 .state = WREPL_STATE_ACTIVE,
8930 .node = WREPL_NODE_B,
8932 .num_ips = ctx->addresses_best2_num,
8933 .ips = ctx->addresses_best2,
8934 .mhomed_merge = true,
8938 * special group vs. special group merging section
8941 * sgroup,active vs. sgroup,active with different ip(s)
8944 .line = __location__,
8945 .section= "Test Replica vs. owned active: SGROUP vs. SGROUP tests",
8946 .name = _NBT_NAME("_SA_SA_DI_U", 0x1C, NULL),
8947 .skip = (ctx->addresses_all_num < 3),
8949 .nb_flags = NBT_NM_GROUP,
8951 .num_ips = ctx->addresses_mhomed_num,
8952 .ips = ctx->addresses_mhomed,
8953 .apply_expected = true
8959 .type = WREPL_TYPE_SGROUP,
8960 .state = WREPL_STATE_ACTIVE,
8961 .node = WREPL_NODE_B,
8963 .num_ips = ARRAY_SIZE(addresses_B_3_4),
8964 .ips = addresses_B_3_4,
8965 .sgroup_merge = true
8969 * sgroup,active vs. sgroup,active with same ip(s)
8972 .line = __location__,
8973 .name = _NBT_NAME("_SA_SA_SI_U", 0x1C, NULL),
8974 .skip = (ctx->addresses_all_num < 3),
8976 .nb_flags = NBT_NM_GROUP,
8978 .num_ips = ctx->addresses_mhomed_num,
8979 .ips = ctx->addresses_mhomed,
8980 .apply_expected = true
8986 .type = WREPL_TYPE_SGROUP,
8987 .state = WREPL_STATE_ACTIVE,
8988 .node = WREPL_NODE_B,
8990 .num_ips = ctx->addresses_mhomed_num,
8991 .ips = ctx->addresses_mhomed,
8992 .sgroup_merge = true
8996 * sgroup,active vs. sgroup,active with superset ip(s)
8999 .line = __location__,
9000 .name = _NBT_NAME("_SA_SA_SP_U", 0x1C, NULL),
9001 .skip = (ctx->addresses_all_num < 3),
9003 .nb_flags = NBT_NM_GROUP,
9005 .num_ips = ctx->addresses_mhomed_num,
9006 .ips = ctx->addresses_mhomed,
9007 .apply_expected = true
9013 .type = WREPL_TYPE_SGROUP,
9014 .state = WREPL_STATE_ACTIVE,
9015 .node = WREPL_NODE_B,
9017 .num_ips = ctx->addresses_all_num,
9018 .ips = ctx->addresses_all,
9019 .sgroup_merge = true
9023 * sgroup,active vs. sgroup,active with subset ip(s)
9026 .line = __location__,
9027 .name = _NBT_NAME("_SA_SA_SB_U", 0x1C, NULL),
9028 .skip = (ctx->addresses_all_num < 3),
9030 .nb_flags = NBT_NM_GROUP,
9032 .num_ips = ctx->addresses_mhomed_num,
9033 .ips = ctx->addresses_mhomed,
9034 .apply_expected = true
9040 .type = WREPL_TYPE_SGROUP,
9041 .state = WREPL_STATE_ACTIVE,
9042 .node = WREPL_NODE_B,
9044 .num_ips = ctx->addresses_best_num,
9045 .ips = ctx->addresses_best,
9046 .sgroup_merge = true
9050 * sgroup,active vs. sgroup,tombstone with different ip(s)
9053 .line = __location__,
9054 .name = _NBT_NAME("_SA_ST_DI_U", 0x1C, NULL),
9055 .skip = (ctx->addresses_all_num < 3),
9057 .nb_flags = NBT_NM_GROUP,
9059 .num_ips = ctx->addresses_mhomed_num,
9060 .ips = ctx->addresses_mhomed,
9061 .apply_expected = true
9067 .type = WREPL_TYPE_SGROUP,
9068 .state = WREPL_STATE_TOMBSTONE,
9069 .node = WREPL_NODE_B,
9071 .num_ips = ARRAY_SIZE(addresses_B_3_4),
9072 .ips = addresses_B_3_4,
9073 .apply_expected = false
9077 * sgroup,active vs. sgroup,tombstone with same ip(s)
9080 .line = __location__,
9081 .name = _NBT_NAME("_SA_ST_SI_U", 0x1C, NULL),
9082 .skip = (ctx->addresses_all_num < 3),
9084 .nb_flags = NBT_NM_GROUP,
9086 .num_ips = ctx->addresses_mhomed_num,
9087 .ips = ctx->addresses_mhomed,
9088 .apply_expected = true
9094 .type = WREPL_TYPE_SGROUP,
9095 .state = WREPL_STATE_TOMBSTONE,
9096 .node = WREPL_NODE_B,
9098 .num_ips = ctx->addresses_mhomed_num,
9099 .ips = ctx->addresses_mhomed,
9100 .apply_expected = false
9104 * sgroup,active vs. sgroup,tombstone with superset ip(s)
9107 .line = __location__,
9108 .name = _NBT_NAME("_SA_ST_SP_U", 0x1C, NULL),
9109 .skip = (ctx->addresses_all_num < 3),
9111 .nb_flags = NBT_NM_GROUP,
9113 .num_ips = ctx->addresses_mhomed_num,
9114 .ips = ctx->addresses_mhomed,
9115 .apply_expected = true
9121 .type = WREPL_TYPE_SGROUP,
9122 .state = WREPL_STATE_TOMBSTONE,
9123 .node = WREPL_NODE_B,
9125 .num_ips = ctx->addresses_all_num,
9126 .ips = ctx->addresses_all,
9127 .apply_expected = false
9131 * sgroup,active vs. sgroup,tombstone with subset ip(s)
9134 .line = __location__,
9135 .name = _NBT_NAME("_SA_ST_SB_U", 0x1C, NULL),
9136 .skip = (ctx->addresses_all_num < 3),
9138 .nb_flags = NBT_NM_GROUP,
9140 .num_ips = ctx->addresses_mhomed_num,
9141 .ips = ctx->addresses_mhomed,
9142 .apply_expected = true
9148 .type = WREPL_TYPE_SGROUP,
9149 .state = WREPL_STATE_TOMBSTONE,
9150 .node = WREPL_NODE_B,
9152 .num_ips = ctx->addresses_best_num,
9153 .ips = ctx->addresses_best,
9154 .apply_expected = false
9159 if (!ctx->nbtsock_srv) {
9160 torture_comment(tctx, "SKIP: Test Replica records vs. owned active records: not bound to port[%d]\n",
9161 lp_nbt_port(tctx->lp_ctx));
9165 torture_comment(tctx, "Test Replica records vs. owned active records\n");
9167 for(i=0; ret && i < ARRAY_SIZE(records); i++) {
9169 struct test_conflict_owned_active_vs_replica_struct record = records[i];
9170 uint32_t j, count = 1;
9173 if (records[i].wins.mhomed || records[i].name.type == 0x1C) {
9174 count = records[i].wins.num_ips;
9177 if (records[i].section) {
9178 torture_comment(tctx, "%s\n", records[i].section);
9181 if (records[i].skip) {
9182 torture_comment(tctx, "%s => SKIPPED\n", nbt_name_string(ctx, &records[i].name));
9186 if (records[i].replica.mhomed_merge) {
9187 action = "MHOMED_MERGE";
9188 } else if (records[i].replica.sgroup_merge) {
9189 action = "SGROUP_MERGE";
9190 } else if (records[i].replica.apply_expected) {
9193 action = "NOT REPLACE";
9196 torture_comment(tctx, "%s%s%s => %s\n",
9197 nbt_name_string(ctx, &records[i].name),
9198 (records[i].comment?": ":""),
9199 (records[i].comment?records[i].comment:""),
9202 /* Prepare for multi homed registration */
9203 ZERO_STRUCT(records[i].defend);
9204 records[i].defend.timeout = 10;
9205 records[i].defend.positive = true;
9206 nbt_set_incoming_handler(ctx->nbtsock_srv,
9207 test_conflict_owned_active_vs_replica_handler,
9209 if (ctx->nbtsock_srv2) {
9210 nbt_set_incoming_handler(ctx->nbtsock_srv2,
9211 test_conflict_owned_active_vs_replica_handler,
9218 for (j=0; j < count; j++) {
9219 struct nbt_name_request *req;
9221 name_register->in.name = records[i].name;
9222 name_register->in.dest_addr = ctx->address;
9223 name_register->in.dest_port = lp_nbt_port(tctx->lp_ctx);
9224 name_register->in.address = records[i].wins.ips[j].ip;
9225 name_register->in.nb_flags = records[i].wins.nb_flags;
9226 name_register->in.register_demand= false;
9227 name_register->in.broadcast = false;
9228 name_register->in.multi_homed = records[i].wins.mhomed;
9229 name_register->in.ttl = 300000;
9230 name_register->in.timeout = 70;
9231 name_register->in.retries = 0;
9233 req = nbt_name_register_send(ctx->nbtsock, name_register);
9235 /* push the request on the wire */
9236 event_loop_once(ctx->nbtsock->event_ctx);
9239 * if we register multiple addresses,
9240 * the server will do name queries to see if the old addresses
9243 if (records[i].wins.mhomed && j > 0) {
9244 end = timeval_current_ofs(records[i].defend.timeout,0);
9245 records[i].defend.ret = true;
9246 while (records[i].defend.timeout > 0) {
9247 event_loop_once(ctx->nbtsock_srv->event_ctx);
9248 if (timeval_expired(&end)) break;
9250 ret &= records[i].defend.ret;
9253 status = nbt_name_register_recv(req, ctx, name_register);
9254 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
9255 torture_comment(tctx, "No response from %s for name register\n", ctx->address);
9258 if (!NT_STATUS_IS_OK(status)) {
9259 torture_comment(tctx, "Bad response from %s for name register - %s\n",
9260 ctx->address, nt_errstr(status));
9263 CHECK_VALUE(tctx, name_register->out.rcode, 0);
9264 CHECK_VALUE_STRING(tctx, name_register->out.reply_from, ctx->address);
9265 CHECK_VALUE(tctx, name_register->out.name.type, records[i].name.type);
9266 CHECK_VALUE_STRING(tctx, name_register->out.name.name, records[i].name.name);
9267 CHECK_VALUE_STRING(tctx, name_register->out.name.scope, records[i].name.scope);
9268 CHECK_VALUE_STRING(tctx, name_register->out.reply_addr, records[i].wins.ips[j].ip);
9271 /* Prepare for the current test */
9272 records[i].defend = record.defend;
9273 nbt_set_incoming_handler(ctx->nbtsock_srv,
9274 test_conflict_owned_active_vs_replica_handler,
9276 if (ctx->nbtsock_srv2) {
9277 nbt_set_incoming_handler(ctx->nbtsock_srv2,
9278 test_conflict_owned_active_vs_replica_handler,
9285 wins_name->name = &records[i].name;
9286 wins_name->flags = WREPL_NAME_FLAGS(records[i].replica.type,
9287 records[i].replica.state,
9288 records[i].replica.node,
9289 records[i].replica.is_static);
9290 wins_name->id = ++ctx->b.max_version;
9291 if (wins_name->flags & 2) {
9292 wins_name->addresses.addresses.num_ips = records[i].replica.num_ips;
9293 wins_name->addresses.addresses.ips = discard_const(records[i].replica.ips);
9295 wins_name->addresses.ip = records[i].replica.ips[0].ip;
9297 wins_name->unknown = "255.255.255.255";
9299 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
9302 * wait for the name query, which is handled in
9303 * test_conflict_owned_active_vs_replica_handler()
9305 end = timeval_current_ofs(records[i].defend.timeout,0);
9306 records[i].defend.ret = true;
9307 while (records[i].defend.timeout > 0) {
9308 event_loop_once(ctx->nbtsock_srv->event_ctx);
9309 if (timeval_expired(&end)) break;
9311 ret &= records[i].defend.ret;
9313 if (records[i].defend.late_release) {
9314 records[i].defend = record.defend;
9315 records[i].defend.expect_release = true;
9317 * wait for the name release demand, which is handled in
9318 * test_conflict_owned_active_vs_replica_handler()
9320 end = timeval_current_ofs(records[i].defend.timeout,0);
9321 records[i].defend.ret = true;
9322 while (records[i].defend.timeout > 0) {
9323 event_loop_once(ctx->nbtsock_srv->event_ctx);
9324 if (timeval_expired(&end)) break;
9326 ret &= records[i].defend.ret;
9329 if (records[i].replica.mhomed_merge) {
9330 ret &= test_wrepl_mhomed_merged(tctx, ctx, &ctx->c,
9331 records[i].wins.num_ips, records[i].wins.ips,
9333 records[i].replica.num_ips, records[i].replica.ips,
9335 } else if (records[i].replica.sgroup_merge) {
9336 ret &= test_wrepl_sgroup_merged(tctx, ctx, NULL,
9338 records[i].wins.num_ips, records[i].wins.ips,
9340 records[i].replica.num_ips, records[i].replica.ips,
9343 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name,
9344 records[i].replica.apply_expected);
9347 if (records[i].replica.apply_expected ||
9348 records[i].replica.mhomed_merge) {
9349 wins_name->name = &records[i].name;
9350 wins_name->flags = WREPL_NAME_FLAGS(WREPL_TYPE_UNIQUE,
9351 WREPL_STATE_TOMBSTONE,
9352 WREPL_NODE_B, false);
9353 wins_name->id = ++ctx->b.max_version;
9354 wins_name->addresses.ip = addresses_B_1[0].ip;
9355 wins_name->unknown = "255.255.255.255";
9357 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
9358 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name, true);
9360 for (j=0; j < count; j++) {
9361 struct nbt_name_socket *nbtsock = ctx->nbtsock;
9363 if (ctx->myaddr2 && strcmp(records[i].wins.ips[j].ip, ctx->myaddr2->addr) == 0) {
9364 nbtsock = ctx->nbtsock2;
9367 release->in.name = records[i].name;
9368 release->in.dest_addr = ctx->address;
9369 release->in.dest_port = lp_nbt_port(tctx->lp_ctx);
9370 release->in.address = records[i].wins.ips[j].ip;
9371 release->in.nb_flags = records[i].wins.nb_flags;
9372 release->in.broadcast = false;
9373 release->in.timeout = 30;
9374 release->in.retries = 0;
9376 status = nbt_name_release(nbtsock, ctx, release);
9377 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
9378 torture_comment(tctx, "No response from %s for name release\n", ctx->address);
9381 if (!NT_STATUS_IS_OK(status)) {
9382 torture_comment(tctx, "Bad response from %s for name query - %s\n",
9383 ctx->address, nt_errstr(status));
9386 CHECK_VALUE(tctx, release->out.rcode, 0);
9389 if (records[i].replica.sgroup_merge) {
9390 /* clean up the SGROUP record */
9391 wins_name->name = &records[i].name;
9392 wins_name->flags = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
9394 WREPL_NODE_B, false);
9395 wins_name->id = ++ctx->b.max_version;
9396 wins_name->addresses.addresses.num_ips = 0;
9397 wins_name->addresses.addresses.ips = NULL;
9398 wins_name->unknown = "255.255.255.255";
9399 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
9401 /* take ownership of the SGROUP record */
9402 wins_name->name = &records[i].name;
9403 wins_name->flags = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
9405 WREPL_NODE_B, false);
9406 wins_name->id = ++ctx->b.max_version;
9407 wins_name->addresses.addresses.num_ips = ARRAY_SIZE(addresses_B_1);
9408 wins_name->addresses.addresses.ips = discard_const(addresses_B_1);
9409 wins_name->unknown = "255.255.255.255";
9410 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
9411 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name, true);
9413 /* overwrite the SGROUP record with unique,tombstone */
9414 wins_name->name = &records[i].name;
9415 wins_name->flags = WREPL_NAME_FLAGS(WREPL_TYPE_UNIQUE,
9416 WREPL_STATE_TOMBSTONE,
9417 WREPL_NODE_B, false);
9418 wins_name->id = ++ctx->b.max_version;
9419 wins_name->addresses.ip = addresses_A_1[0].ip;
9420 wins_name->unknown = "255.255.255.255";
9421 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
9422 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name, true);
9427 torture_comment(tctx, "conflict handled wrong or record[%u]: %s\n", i, records[i].line);
9435 #define _NBT_ASSERT(v, correct) do { \
9436 if ((v) != (correct)) { \
9437 printf("(%s) Incorrect value %s=%d - should be %s (%d)\n", \
9438 __location__, #v, v, #correct, correct); \
9443 #define _NBT_ASSERT_STRING(v, correct) do { \
9444 if ( ((!v) && (correct)) || \
9445 ((v) && (!correct)) || \
9446 ((v) && (correct) && strcmp(v,correct) != 0)) { \
9447 printf("(%s) Incorrect value %s=%s - should be %s\n", \
9448 __location__, #v, v, correct); \
9453 static void test_conflict_owned_active_vs_replica_handler_query(struct nbt_name_socket *nbtsock,
9454 struct nbt_name_packet *req_packet,
9455 struct socket_address *src)
9457 struct nbt_name *name;
9458 struct nbt_name_packet *rep_packet;
9459 struct test_conflict_owned_active_vs_replica_struct *rec =
9460 (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private_data;
9462 _NBT_ASSERT(req_packet->qdcount, 1);
9463 _NBT_ASSERT(req_packet->questions[0].question_type, NBT_QTYPE_NETBIOS);
9464 _NBT_ASSERT(req_packet->questions[0].question_class, NBT_QCLASS_IP);
9466 name = &req_packet->questions[0].name;
9468 _NBT_ASSERT(name->type, rec->name.type);
9469 _NBT_ASSERT_STRING(name->name, rec->name.name);
9470 _NBT_ASSERT_STRING(name->scope, rec->name.scope);
9472 _NBT_ASSERT(rec->defend.expect_release, false);
9474 rep_packet = talloc_zero(nbtsock, struct nbt_name_packet);
9475 if (rep_packet == NULL) return;
9477 rep_packet->name_trn_id = req_packet->name_trn_id;
9478 rep_packet->ancount = 1;
9480 rep_packet->answers = talloc_array(rep_packet, struct nbt_res_rec, 1);
9481 if (rep_packet->answers == NULL) return;
9483 rep_packet->answers[0].name = *name;
9484 rep_packet->answers[0].rr_class = NBT_QCLASS_IP;
9485 rep_packet->answers[0].ttl = 0;
9487 if (rec->defend.positive) {
9488 uint32_t i, num_ips;
9489 const struct wrepl_ip *ips;
9491 if (rec->defend.num_ips > 0) {
9492 num_ips = rec->defend.num_ips;
9493 ips = rec->defend.ips;
9495 num_ips = rec->wins.num_ips;
9496 ips = rec->wins.ips;
9499 /* send a positive reply */
9500 rep_packet->operation =
9503 NBT_FLAG_AUTHORITIVE |
9504 NBT_FLAG_RECURSION_DESIRED |
9505 NBT_FLAG_RECURSION_AVAIL;
9507 rep_packet->answers[0].rr_type = NBT_QTYPE_NETBIOS;
9509 rep_packet->answers[0].rdata.netbios.length = num_ips*6;
9510 rep_packet->answers[0].rdata.netbios.addresses =
9511 talloc_array(rep_packet->answers, struct nbt_rdata_address, num_ips);
9512 if (rep_packet->answers[0].rdata.netbios.addresses == NULL) return;
9514 for (i=0; i < num_ips; i++) {
9515 struct nbt_rdata_address *addr =
9516 &rep_packet->answers[0].rdata.netbios.addresses[i];
9517 addr->nb_flags = rec->wins.nb_flags;
9518 addr->ipaddr = ips[i].ip;
9520 DEBUG(2,("Sending positive name query reply for %s to %s:%d\n",
9521 nbt_name_string(rep_packet, name), src->addr, src->port));
9523 /* send a negative reply */
9524 rep_packet->operation =
9527 NBT_FLAG_AUTHORITIVE |
9530 rep_packet->answers[0].rr_type = NBT_QTYPE_NULL;
9532 ZERO_STRUCT(rep_packet->answers[0].rdata);
9534 DEBUG(2,("Sending negative name query reply for %s to %s:%d\n",
9535 nbt_name_string(rep_packet, name), src->addr, src->port));
9538 nbt_name_reply_send(nbtsock, src, rep_packet);
9539 talloc_free(rep_packet);
9541 /* make sure we push the reply to the wire */
9542 while (nbtsock->send_queue) {
9543 event_loop_once(nbtsock->event_ctx);
9547 rec->defend.timeout = 0;
9548 rec->defend.ret = true;
9551 static void test_conflict_owned_active_vs_replica_handler_release(
9552 struct nbt_name_socket *nbtsock,
9553 struct nbt_name_packet *req_packet,
9554 struct socket_address *src)
9556 struct nbt_name *name;
9557 struct nbt_name_packet *rep_packet;
9558 struct test_conflict_owned_active_vs_replica_struct *rec =
9559 (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private_data;
9561 _NBT_ASSERT(req_packet->qdcount, 1);
9562 _NBT_ASSERT(req_packet->questions[0].question_type, NBT_QTYPE_NETBIOS);
9563 _NBT_ASSERT(req_packet->questions[0].question_class, NBT_QCLASS_IP);
9565 name = &req_packet->questions[0].name;
9567 _NBT_ASSERT(name->type, rec->name.type);
9568 _NBT_ASSERT_STRING(name->name, rec->name.name);
9569 _NBT_ASSERT_STRING(name->scope, rec->name.scope);
9571 _NBT_ASSERT(rec->defend.expect_release, true);
9573 rep_packet = talloc_zero(nbtsock, struct nbt_name_packet);
9574 if (rep_packet == NULL) return;
9576 rep_packet->name_trn_id = req_packet->name_trn_id;
9577 rep_packet->ancount = 1;
9578 rep_packet->operation =
9580 NBT_OPCODE_RELEASE |
9581 NBT_FLAG_AUTHORITIVE;
9583 rep_packet->answers = talloc_array(rep_packet, struct nbt_res_rec, 1);
9584 if (rep_packet->answers == NULL) return;
9586 rep_packet->answers[0].name = *name;
9587 rep_packet->answers[0].rr_type = NBT_QTYPE_NETBIOS;
9588 rep_packet->answers[0].rr_class = NBT_QCLASS_IP;
9589 rep_packet->answers[0].ttl = req_packet->additional[0].ttl;
9590 rep_packet->answers[0].rdata = req_packet->additional[0].rdata;
9592 DEBUG(2,("Sending name release reply for %s to %s:%d\n",
9593 nbt_name_string(rep_packet, name), src->addr, src->port));
9595 nbt_name_reply_send(nbtsock, src, rep_packet);
9596 talloc_free(rep_packet);
9598 /* make sure we push the reply to the wire */
9599 while (nbtsock->send_queue) {
9600 event_loop_once(nbtsock->event_ctx);
9604 rec->defend.timeout = 0;
9605 rec->defend.ret = true;
9608 static void test_conflict_owned_active_vs_replica_handler(struct nbt_name_socket *nbtsock,
9609 struct nbt_name_packet *req_packet,
9610 struct socket_address *src)
9612 struct test_conflict_owned_active_vs_replica_struct *rec =
9613 (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private_data;
9615 rec->defend.ret = false;
9617 switch (req_packet->operation & NBT_OPCODE) {
9618 case NBT_OPCODE_QUERY:
9619 test_conflict_owned_active_vs_replica_handler_query(nbtsock, req_packet, src);
9621 case NBT_OPCODE_RELEASE:
9622 test_conflict_owned_active_vs_replica_handler_release(nbtsock, req_packet, src);
9625 printf("%s: unexpected incoming packet\n", __location__);
9631 test WINS replication replica conflicts operations
9633 static bool torture_nbt_winsreplication_replica(struct torture_context *tctx)
9636 struct test_wrepl_conflict_conn *ctx;
9638 const char *address;
9639 struct nbt_name name;
9641 if (!torture_nbt_get_name(tctx, &name, &address))
9644 ctx = test_create_conflict_ctx(tctx, address);
9645 if (!ctx) return false;
9647 ret &= test_conflict_same_owner(tctx, ctx);
9648 ret &= test_conflict_different_owner(tctx, ctx);
9654 test WINS replication owned conflicts operations
9656 static bool torture_nbt_winsreplication_owned(struct torture_context *tctx)
9658 const char *address;
9659 struct nbt_name name;
9661 struct test_wrepl_conflict_conn *ctx;
9663 if (torture_setting_bool(tctx, "quick", false))
9665 "skip NBT-WINSREPLICATION-OWNED test in quick test mode\n");
9667 if (!torture_nbt_get_name(tctx, &name, &address))
9670 ctx = test_create_conflict_ctx(tctx, address);
9671 torture_assert(tctx, ctx != NULL, "Creating context failed");
9673 ret &= test_conflict_owned_released_vs_replica(tctx, ctx);
9674 ret &= test_conflict_owned_active_vs_replica(tctx, ctx);
9680 test simple WINS replication operations
9682 struct torture_suite *torture_nbt_winsreplication(TALLOC_CTX *mem_ctx)
9684 struct torture_suite *suite = torture_suite_create(
9685 mem_ctx, "WINSREPLICATION");
9686 struct torture_tcase *tcase;
9688 tcase = torture_suite_add_simple_test(suite, "assoc_ctx1",
9690 tcase->tests->dangerous = true;
9692 torture_suite_add_simple_test(suite, "assoc_ctx2",
9695 torture_suite_add_simple_test(suite, "wins_replication",
9696 test_wins_replication);
9698 torture_suite_add_simple_test(suite, "replica",
9699 torture_nbt_winsreplication_replica);
9701 torture_suite_add_simple_test(suite, "owned",
9702 torture_nbt_winsreplication_owned);