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
6704 #if METZE_NEEDS_TO_LOOK_AT_THIS_ONE
6706 * unique,active vs. unique,active with same ip(s), unchecked
6709 .line = __location__,
6710 .name = _NBT_NAME("_UA_UA_SI_U", 0x00, NULL),
6714 .num_ips = ctx->addresses_best_num,
6715 .ips = ctx->addresses_best,
6716 .apply_expected = true
6722 .type = WREPL_TYPE_UNIQUE,
6723 .state = WREPL_STATE_ACTIVE,
6724 .node = WREPL_NODE_B,
6726 .num_ips = ctx->addresses_best_num,
6727 .ips = ctx->addresses_best,
6728 .apply_expected = true
6733 * unique,active vs. unique,active with different ip(s), positive response
6736 .line = __location__,
6737 .name = _NBT_NAME("_UA_UA_DI_P", 0x00, NULL),
6741 .num_ips = ctx->addresses_best_num,
6742 .ips = ctx->addresses_best,
6743 .apply_expected = true
6750 .type = WREPL_TYPE_UNIQUE,
6751 .state = WREPL_STATE_ACTIVE,
6752 .node = WREPL_NODE_B,
6754 .num_ips = ARRAY_SIZE(addresses_B_1),
6755 .ips = addresses_B_1,
6756 .apply_expected = false
6760 * unique,active vs. unique,active with different ip(s), positive response other ips
6763 .line = __location__,
6764 .name = _NBT_NAME("_UA_UA_DI_O", 0x00, NULL),
6768 .num_ips = ctx->addresses_best_num,
6769 .ips = ctx->addresses_best,
6770 .apply_expected = true
6775 .num_ips = ARRAY_SIZE(addresses_A_3_4),
6776 .ips = addresses_A_3_4,
6779 .type = WREPL_TYPE_UNIQUE,
6780 .state = WREPL_STATE_ACTIVE,
6781 .node = WREPL_NODE_B,
6783 .num_ips = ARRAY_SIZE(addresses_B_1),
6784 .ips = addresses_B_1,
6785 .apply_expected = false
6789 * unique,active vs. unique,active with different ip(s), negative response
6792 .line = __location__,
6793 .name = _NBT_NAME("_UA_UA_DI_N", 0x00, NULL),
6797 .num_ips = ctx->addresses_best_num,
6798 .ips = ctx->addresses_best,
6799 .apply_expected = true
6806 .type = WREPL_TYPE_UNIQUE,
6807 .state = WREPL_STATE_ACTIVE,
6808 .node = WREPL_NODE_B,
6810 .num_ips = ARRAY_SIZE(addresses_B_1),
6811 .ips = addresses_B_1,
6812 .apply_expected = true
6816 * unique,active vs. unique,tombstone with same ip(s), unchecked
6819 .line = __location__,
6820 .name = _NBT_NAME("_UA_UT_SI_U", 0x00, NULL),
6824 .num_ips = ctx->addresses_best_num,
6825 .ips = ctx->addresses_best,
6826 .apply_expected = true
6832 .type = WREPL_TYPE_UNIQUE,
6833 .state = WREPL_STATE_TOMBSTONE,
6834 .node = WREPL_NODE_B,
6836 .num_ips = ctx->addresses_best_num,
6837 .ips = ctx->addresses_best,
6838 .apply_expected = false
6842 * unique,active vs. unique,tombstone with different ip(s), unchecked
6845 .line = __location__,
6846 .name = _NBT_NAME("_UA_UT_DI_U", 0x00, NULL),
6850 .num_ips = ctx->addresses_best_num,
6851 .ips = ctx->addresses_best,
6852 .apply_expected = true
6858 .type = WREPL_TYPE_UNIQUE,
6859 .state = WREPL_STATE_TOMBSTONE,
6860 .node = WREPL_NODE_B,
6862 .num_ips = ARRAY_SIZE(addresses_B_1),
6863 .ips = addresses_B_1,
6864 .apply_expected = false
6868 * unique vs. group section
6871 * unique,active vs. group,active with same ip(s), release expected
6874 .line = __location__,
6875 .name = _NBT_NAME("_UA_GA_SI_R", 0x00, NULL),
6879 .num_ips = ctx->addresses_best_num,
6880 .ips = ctx->addresses_best,
6881 .apply_expected = true
6885 .expect_release = true,
6888 .type = WREPL_TYPE_GROUP,
6889 .state = WREPL_STATE_ACTIVE,
6890 .node = WREPL_NODE_B,
6892 .num_ips = ctx->addresses_best_num,
6893 .ips = ctx->addresses_best,
6894 .apply_expected = true
6898 * unique,active vs. group,active with different ip(s), release expected
6901 .line = __location__,
6902 .name = _NBT_NAME("_UA_GA_DI_R", 0x00, NULL),
6906 .num_ips = ctx->addresses_best_num,
6907 .ips = ctx->addresses_best,
6908 .apply_expected = true
6912 .expect_release = true,
6915 .type = WREPL_TYPE_GROUP,
6916 .state = WREPL_STATE_ACTIVE,
6917 .node = WREPL_NODE_B,
6919 .num_ips = ARRAY_SIZE(addresses_B_1),
6920 .ips = addresses_B_1,
6921 .apply_expected = true
6925 * unique,active vs. group,tombstone with same ip(s), unchecked
6928 .line = __location__,
6929 .name = _NBT_NAME("_UA_GT_SI_U", 0x00, NULL),
6933 .num_ips = ctx->addresses_best_num,
6934 .ips = ctx->addresses_best,
6935 .apply_expected = true
6941 .type = WREPL_TYPE_GROUP,
6942 .state = WREPL_STATE_TOMBSTONE,
6943 .node = WREPL_NODE_B,
6945 .num_ips = ctx->addresses_best_num,
6946 .ips = ctx->addresses_best,
6947 .apply_expected = false
6951 * unique,active vs. group,tombstone with different ip(s), unchecked
6954 .line = __location__,
6955 .name = _NBT_NAME("_UA_GT_DI_U", 0x00, NULL),
6959 .num_ips = ctx->addresses_best_num,
6960 .ips = ctx->addresses_best,
6961 .apply_expected = true
6967 .type = WREPL_TYPE_GROUP,
6968 .state = WREPL_STATE_TOMBSTONE,
6969 .node = WREPL_NODE_B,
6971 .num_ips = ARRAY_SIZE(addresses_B_1),
6972 .ips = addresses_B_1,
6973 .apply_expected = false
6977 * unique vs. special group section
6980 * unique,active vs. sgroup,active with same ip(s), release expected
6983 .line = __location__,
6984 .name = _NBT_NAME("_UA_SA_SI_R", 0x00, NULL),
6988 .num_ips = ctx->addresses_best_num,
6989 .ips = ctx->addresses_best,
6990 .apply_expected = true
6994 .expect_release = true,
6997 .type = WREPL_TYPE_SGROUP,
6998 .state = WREPL_STATE_ACTIVE,
6999 .node = WREPL_NODE_B,
7001 .num_ips = ctx->addresses_best_num,
7002 .ips = ctx->addresses_best,
7003 .apply_expected = true
7007 * unique,active vs. group,active with different ip(s), release expected
7010 .line = __location__,
7011 .name = _NBT_NAME("_UA_SA_DI_R", 0x00, NULL),
7015 .num_ips = ctx->addresses_best_num,
7016 .ips = ctx->addresses_best,
7017 .apply_expected = true
7021 .expect_release = true,
7024 .type = WREPL_TYPE_SGROUP,
7025 .state = WREPL_STATE_ACTIVE,
7026 .node = WREPL_NODE_B,
7028 .num_ips = ARRAY_SIZE(addresses_B_1),
7029 .ips = addresses_B_1,
7030 .apply_expected = true
7034 * unique,active vs. sgroup,tombstone with same ip(s), unchecked
7037 .line = __location__,
7038 .name = _NBT_NAME("_UA_ST_SI_U", 0x00, NULL),
7042 .num_ips = ctx->addresses_best_num,
7043 .ips = ctx->addresses_best,
7044 .apply_expected = true
7050 .type = WREPL_TYPE_SGROUP,
7051 .state = WREPL_STATE_TOMBSTONE,
7052 .node = WREPL_NODE_B,
7054 .num_ips = ctx->addresses_best_num,
7055 .ips = ctx->addresses_best,
7056 .apply_expected = false
7060 * unique,active vs. sgroup,tombstone with different ip(s), unchecked
7063 .line = __location__,
7064 .name = _NBT_NAME("_UA_ST_DI_U", 0x00, NULL),
7068 .num_ips = ctx->addresses_best_num,
7069 .ips = ctx->addresses_best,
7070 .apply_expected = true
7076 .type = WREPL_TYPE_SGROUP,
7077 .state = WREPL_STATE_TOMBSTONE,
7078 .node = WREPL_NODE_B,
7080 .num_ips = ARRAY_SIZE(addresses_B_1),
7081 .ips = addresses_B_1,
7082 .apply_expected = false
7086 * unique vs. multi homed section
7089 * unique,active vs. mhomed,active with same ip(s), unchecked
7092 .line = __location__,
7093 .name = _NBT_NAME("_UA_MA_SI_U", 0x00, NULL),
7097 .num_ips = ctx->addresses_best_num,
7098 .ips = ctx->addresses_best,
7099 .apply_expected = true
7105 .type = WREPL_TYPE_MHOMED,
7106 .state = WREPL_STATE_ACTIVE,
7107 .node = WREPL_NODE_B,
7109 .num_ips = ctx->addresses_best_num,
7110 .ips = ctx->addresses_best,
7111 .apply_expected = true
7115 * unique,active vs. mhomed,active with superset ip(s), unchecked
7118 .line = __location__,
7119 .name = _NBT_NAME("_UA_MA_SP_U", 0x00, NULL),
7123 .num_ips = ctx->addresses_best_num,
7124 .ips = ctx->addresses_best,
7125 .apply_expected = true
7131 .type = WREPL_TYPE_MHOMED,
7132 .state = WREPL_STATE_ACTIVE,
7133 .node = WREPL_NODE_B,
7135 .num_ips = ctx->addresses_all_num,
7136 .ips = ctx->addresses_all,
7137 .apply_expected = true
7141 * unique,active vs. mhomed,active with different ip(s), positive response
7144 .line = __location__,
7145 .name = _NBT_NAME("_UA_MA_DI_P", 0x00, NULL),
7149 .num_ips = ctx->addresses_best_num,
7150 .ips = ctx->addresses_best,
7151 .apply_expected = true
7158 .type = WREPL_TYPE_MHOMED,
7159 .state = WREPL_STATE_ACTIVE,
7160 .node = WREPL_NODE_B,
7162 .num_ips = ARRAY_SIZE(addresses_B_3_4),
7163 .ips = addresses_B_3_4,
7164 .apply_expected = false
7168 * unique,active vs. mhomed,active with different ip(s), positive response other ips
7171 .line = __location__,
7172 .name = _NBT_NAME("_UA_MA_DI_O", 0x00, NULL),
7176 .num_ips = ctx->addresses_best_num,
7177 .ips = ctx->addresses_best,
7178 .apply_expected = true
7183 .num_ips = ARRAY_SIZE(addresses_A_3_4),
7184 .ips = addresses_A_3_4,
7187 .type = WREPL_TYPE_MHOMED,
7188 .state = WREPL_STATE_ACTIVE,
7189 .node = WREPL_NODE_B,
7191 .num_ips = ARRAY_SIZE(addresses_B_3_4),
7192 .ips = addresses_B_3_4,
7193 .apply_expected = false
7197 * unique,active vs. mhomed,active with different ip(s), negative response
7200 .line = __location__,
7201 .name = _NBT_NAME("_UA_MA_DI_N", 0x00, NULL),
7205 .num_ips = ctx->addresses_best_num,
7206 .ips = ctx->addresses_best,
7207 .apply_expected = true
7214 .type = WREPL_TYPE_MHOMED,
7215 .state = WREPL_STATE_ACTIVE,
7216 .node = WREPL_NODE_B,
7218 .num_ips = ARRAY_SIZE(addresses_B_3_4),
7219 .ips = addresses_B_3_4,
7220 .apply_expected = true
7224 * unique,active vs. mhomed,tombstone with same ip(s), unchecked
7227 .line = __location__,
7228 .name = _NBT_NAME("_UA_MT_SI_U", 0x00, NULL),
7232 .num_ips = ctx->addresses_best_num,
7233 .ips = ctx->addresses_best,
7234 .apply_expected = true
7240 .type = WREPL_TYPE_MHOMED,
7241 .state = WREPL_STATE_TOMBSTONE,
7242 .node = WREPL_NODE_B,
7244 .num_ips = ctx->addresses_best_num,
7245 .ips = ctx->addresses_best,
7246 .apply_expected = false
7250 * unique,active vs. mhomed,tombstone with different ip(s), unchecked
7253 .line = __location__,
7254 .name = _NBT_NAME("_UA_MT_DI_U", 0x00, NULL),
7258 .num_ips = ctx->addresses_best_num,
7259 .ips = ctx->addresses_best,
7260 .apply_expected = true
7266 .type = WREPL_TYPE_MHOMED,
7267 .state = WREPL_STATE_TOMBSTONE,
7268 .node = WREPL_NODE_B,
7270 .num_ips = ARRAY_SIZE(addresses_B_3_4),
7271 .ips = addresses_B_3_4,
7272 .apply_expected = false
7276 * normal group vs. unique section
7279 * group,active vs. unique,active with same ip(s), unchecked
7282 .line = __location__,
7283 .name = _NBT_NAME("_GA_UA_SI_U", 0x00, NULL),
7285 .nb_flags = NBT_NM_GROUP,
7287 .num_ips = ctx->addresses_best_num,
7288 .ips = ctx->addresses_best,
7289 .apply_expected = true
7295 .type = WREPL_TYPE_UNIQUE,
7296 .state = WREPL_STATE_ACTIVE,
7297 .node = WREPL_NODE_B,
7299 .num_ips = ctx->addresses_best_num,
7300 .ips = ctx->addresses_best,
7301 .apply_expected = false
7305 * group,active vs. unique,active with different ip(s), unchecked
7308 .line = __location__,
7309 .name = _NBT_NAME("_GA_UA_DI_U", 0x00, NULL),
7311 .nb_flags = NBT_NM_GROUP,
7313 .num_ips = ctx->addresses_best_num,
7314 .ips = ctx->addresses_best,
7315 .apply_expected = true
7321 .type = WREPL_TYPE_UNIQUE,
7322 .state = WREPL_STATE_ACTIVE,
7323 .node = WREPL_NODE_B,
7325 .num_ips = ARRAY_SIZE(addresses_B_1),
7326 .ips = addresses_B_1,
7327 .apply_expected = false
7331 * group,active vs. unique,tombstone with same ip(s), unchecked
7334 .line = __location__,
7335 .name = _NBT_NAME("_GA_UT_SI_U", 0x00, NULL),
7337 .nb_flags = NBT_NM_GROUP,
7339 .num_ips = ctx->addresses_best_num,
7340 .ips = ctx->addresses_best,
7341 .apply_expected = true
7347 .type = WREPL_TYPE_UNIQUE,
7348 .state = WREPL_STATE_TOMBSTONE,
7349 .node = WREPL_NODE_B,
7351 .num_ips = ctx->addresses_best_num,
7352 .ips = ctx->addresses_best,
7353 .apply_expected = false
7357 * group,active vs. unique,tombstone with different ip(s), unchecked
7360 .line = __location__,
7361 .name = _NBT_NAME("_GA_UT_DI_U", 0x00, NULL),
7363 .nb_flags = NBT_NM_GROUP,
7365 .num_ips = ctx->addresses_best_num,
7366 .ips = ctx->addresses_best,
7367 .apply_expected = true
7373 .type = WREPL_TYPE_UNIQUE,
7374 .state = WREPL_STATE_TOMBSTONE,
7375 .node = WREPL_NODE_B,
7377 .num_ips = ARRAY_SIZE(addresses_B_1),
7378 .ips = addresses_B_1,
7379 .apply_expected = false
7383 * normal group vs. normal group section
7386 * group,active vs. group,active with same ip(s), unchecked
7389 .line = __location__,
7390 .name = _NBT_NAME("_GA_GA_SI_U", 0x00, NULL),
7392 .nb_flags = NBT_NM_GROUP,
7394 .num_ips = ctx->addresses_best_num,
7395 .ips = ctx->addresses_best,
7396 .apply_expected = true
7402 .type = WREPL_TYPE_GROUP,
7403 .state = WREPL_STATE_ACTIVE,
7404 .node = WREPL_NODE_B,
7406 .num_ips = ctx->addresses_best_num,
7407 .ips = ctx->addresses_best,
7408 .apply_expected = true
7412 * group,active vs. group,active with different ip(s), unchecked
7415 .line = __location__,
7416 .name = _NBT_NAME("_GA_GA_DI_U", 0x00, NULL),
7418 .nb_flags = NBT_NM_GROUP,
7420 .num_ips = ctx->addresses_best_num,
7421 .ips = ctx->addresses_best,
7422 .apply_expected = true
7428 .type = WREPL_TYPE_GROUP,
7429 .state = WREPL_STATE_ACTIVE,
7430 .node = WREPL_NODE_B,
7432 .num_ips = ARRAY_SIZE(addresses_B_1),
7433 .ips = addresses_B_1,
7434 .apply_expected = true
7438 * group,active vs. group,tombstone with same ip(s), unchecked
7441 .line = __location__,
7442 .name = _NBT_NAME("_GA_GT_SI_U", 0x00, NULL),
7444 .nb_flags = NBT_NM_GROUP,
7446 .num_ips = ctx->addresses_best_num,
7447 .ips = ctx->addresses_best,
7448 .apply_expected = true
7454 .type = WREPL_TYPE_GROUP,
7455 .state = WREPL_STATE_TOMBSTONE,
7456 .node = WREPL_NODE_B,
7458 .num_ips = ctx->addresses_best_num,
7459 .ips = ctx->addresses_best,
7460 .apply_expected = false
7464 * group,active vs. group,tombstone with different ip(s), unchecked
7467 .line = __location__,
7468 .name = _NBT_NAME("_GA_GT_DI_U", 0x00, NULL),
7470 .nb_flags = NBT_NM_GROUP,
7472 .num_ips = ctx->addresses_best_num,
7473 .ips = ctx->addresses_best,
7474 .apply_expected = true
7480 .type = WREPL_TYPE_GROUP,
7481 .state = WREPL_STATE_TOMBSTONE,
7482 .node = WREPL_NODE_B,
7484 .num_ips = ARRAY_SIZE(addresses_B_1),
7485 .ips = addresses_B_1,
7486 .apply_expected = false
7490 * normal group vs. special group section
7493 * group,active vs. sgroup,active with same ip(s), unchecked
7496 .line = __location__,
7497 .name = _NBT_NAME("_GA_SA_SI_U", 0x00, NULL),
7499 .nb_flags = NBT_NM_GROUP,
7501 .num_ips = ctx->addresses_best_num,
7502 .ips = ctx->addresses_best,
7503 .apply_expected = true
7509 .type = WREPL_TYPE_SGROUP,
7510 .state = WREPL_STATE_ACTIVE,
7511 .node = WREPL_NODE_B,
7513 .num_ips = ctx->addresses_best_num,
7514 .ips = ctx->addresses_best,
7515 .apply_expected = false
7519 * group,active vs. sgroup,active with different ip(s), unchecked
7522 .line = __location__,
7523 .name = _NBT_NAME("_GA_SA_DI_U", 0x00, NULL),
7525 .nb_flags = NBT_NM_GROUP,
7527 .num_ips = ctx->addresses_best_num,
7528 .ips = ctx->addresses_best,
7529 .apply_expected = true
7535 .type = WREPL_TYPE_SGROUP,
7536 .state = WREPL_STATE_ACTIVE,
7537 .node = WREPL_NODE_B,
7539 .num_ips = ARRAY_SIZE(addresses_B_3_4),
7540 .ips = addresses_B_3_4,
7541 .apply_expected = false
7545 * group,active vs. sgroup,tombstone with same ip(s), unchecked
7548 .line = __location__,
7549 .name = _NBT_NAME("_GA_ST_SI_U", 0x00, NULL),
7551 .nb_flags = NBT_NM_GROUP,
7553 .num_ips = ctx->addresses_best_num,
7554 .ips = ctx->addresses_best,
7555 .apply_expected = true
7561 .type = WREPL_TYPE_SGROUP,
7562 .state = WREPL_STATE_TOMBSTONE,
7563 .node = WREPL_NODE_B,
7565 .num_ips = ctx->addresses_best_num,
7566 .ips = ctx->addresses_best,
7567 .apply_expected = false
7571 * group,active vs. sgroup,tombstone with different ip(s), unchecked
7574 .line = __location__,
7575 .name = _NBT_NAME("_GA_ST_DI_U", 0x00, NULL),
7577 .nb_flags = NBT_NM_GROUP,
7579 .num_ips = ctx->addresses_best_num,
7580 .ips = ctx->addresses_best,
7581 .apply_expected = true
7587 .type = WREPL_TYPE_SGROUP,
7588 .state = WREPL_STATE_TOMBSTONE,
7589 .node = WREPL_NODE_B,
7591 .num_ips = ARRAY_SIZE(addresses_B_3_4),
7592 .ips = addresses_B_3_4,
7593 .apply_expected = false
7597 * normal group vs. multi homed section
7600 * group,active vs. mhomed,active with same ip(s), unchecked
7603 .line = __location__,
7604 .name = _NBT_NAME("_GA_MA_SI_U", 0x00, NULL),
7606 .nb_flags = NBT_NM_GROUP,
7608 .num_ips = ctx->addresses_best_num,
7609 .ips = ctx->addresses_best,
7610 .apply_expected = true
7616 .type = WREPL_TYPE_MHOMED,
7617 .state = WREPL_STATE_ACTIVE,
7618 .node = WREPL_NODE_B,
7620 .num_ips = ctx->addresses_best_num,
7621 .ips = ctx->addresses_best,
7622 .apply_expected = false
7626 * group,active vs. mhomed,active with different ip(s), unchecked
7629 .line = __location__,
7630 .name = _NBT_NAME("_GA_MA_DI_U", 0x00, NULL),
7632 .nb_flags = NBT_NM_GROUP,
7634 .num_ips = ctx->addresses_best_num,
7635 .ips = ctx->addresses_best,
7636 .apply_expected = true
7642 .type = WREPL_TYPE_MHOMED,
7643 .state = WREPL_STATE_ACTIVE,
7644 .node = WREPL_NODE_B,
7646 .num_ips = ARRAY_SIZE(addresses_B_3_4),
7647 .ips = addresses_B_3_4,
7648 .apply_expected = false
7652 * group,active vs. mhomed,tombstone with same ip(s), unchecked
7655 .line = __location__,
7656 .name = _NBT_NAME("_GA_MT_SI_U", 0x00, NULL),
7658 .nb_flags = NBT_NM_GROUP,
7660 .num_ips = ctx->addresses_best_num,
7661 .ips = ctx->addresses_best,
7662 .apply_expected = true
7668 .type = WREPL_TYPE_MHOMED,
7669 .state = WREPL_STATE_TOMBSTONE,
7670 .node = WREPL_NODE_B,
7672 .num_ips = ctx->addresses_best_num,
7673 .ips = ctx->addresses_best,
7674 .apply_expected = false
7678 * group,active vs. mhomed,tombstone with different ip(s), unchecked
7681 .line = __location__,
7682 .name = _NBT_NAME("_GA_MT_DI_U", 0x00, NULL),
7684 .nb_flags = NBT_NM_GROUP,
7686 .num_ips = ctx->addresses_best_num,
7687 .ips = ctx->addresses_best,
7688 .apply_expected = true
7694 .type = WREPL_TYPE_MHOMED,
7695 .state = WREPL_STATE_TOMBSTONE,
7696 .node = WREPL_NODE_B,
7698 .num_ips = ARRAY_SIZE(addresses_B_3_4),
7699 .ips = addresses_B_3_4,
7700 .apply_expected = false
7704 * special group vs. unique section
7707 * sgroup,active vs. unique,active with same ip(s), unchecked
7710 .line = __location__,
7711 .name = _NBT_NAME("_SA_UA_SI_U", 0x1C, NULL),
7713 .nb_flags = NBT_NM_GROUP,
7715 .num_ips = ctx->addresses_best_num,
7716 .ips = ctx->addresses_best,
7717 .apply_expected = true
7723 .type = WREPL_TYPE_UNIQUE,
7724 .state = WREPL_STATE_ACTIVE,
7725 .node = WREPL_NODE_B,
7727 .num_ips = ctx->addresses_best_num,
7728 .ips = ctx->addresses_best,
7729 .apply_expected = false
7733 * sgroup,active vs. unique,active with different ip(s), unchecked
7736 .line = __location__,
7737 .name = _NBT_NAME("_SA_UA_DI_U", 0x1C, NULL),
7739 .nb_flags = NBT_NM_GROUP,
7741 .num_ips = ctx->addresses_best_num,
7742 .ips = ctx->addresses_best,
7743 .apply_expected = true
7749 .type = WREPL_TYPE_UNIQUE,
7750 .state = WREPL_STATE_ACTIVE,
7751 .node = WREPL_NODE_B,
7753 .num_ips = ARRAY_SIZE(addresses_B_1),
7754 .ips = addresses_B_1,
7755 .apply_expected = false
7759 * sgroup,active vs. unique,tombstone with same ip(s), unchecked
7762 .line = __location__,
7763 .name = _NBT_NAME("_SA_UT_SI_U", 0x1C, NULL),
7765 .nb_flags = NBT_NM_GROUP,
7767 .num_ips = ctx->addresses_best_num,
7768 .ips = ctx->addresses_best,
7769 .apply_expected = true
7775 .type = WREPL_TYPE_UNIQUE,
7776 .state = WREPL_STATE_TOMBSTONE,
7777 .node = WREPL_NODE_B,
7779 .num_ips = ctx->addresses_best_num,
7780 .ips = ctx->addresses_best,
7781 .apply_expected = false
7785 * sgroup,active vs. unique,tombstone with different ip(s), unchecked
7788 .line = __location__,
7789 .name = _NBT_NAME("_SA_UT_DI_U", 0x1C, NULL),
7791 .nb_flags = NBT_NM_GROUP,
7793 .num_ips = ctx->addresses_best_num,
7794 .ips = ctx->addresses_best,
7795 .apply_expected = true
7801 .type = WREPL_TYPE_UNIQUE,
7802 .state = WREPL_STATE_TOMBSTONE,
7803 .node = WREPL_NODE_B,
7805 .num_ips = ARRAY_SIZE(addresses_B_1),
7806 .ips = addresses_B_1,
7807 .apply_expected = false
7811 * special group vs. normal group section
7814 * sgroup,active vs. group,active with same ip(s), unchecked
7817 .line = __location__,
7818 .name = _NBT_NAME("_SA_GA_SI_U", 0x1C, NULL),
7820 .nb_flags = NBT_NM_GROUP,
7822 .num_ips = ctx->addresses_best_num,
7823 .ips = ctx->addresses_best,
7824 .apply_expected = true
7830 .type = WREPL_TYPE_GROUP,
7831 .state = WREPL_STATE_ACTIVE,
7832 .node = WREPL_NODE_B,
7834 .num_ips = ctx->addresses_best_num,
7835 .ips = ctx->addresses_best,
7836 .apply_expected = false
7840 * sgroup,active vs. group,active with different ip(s), unchecked
7843 .line = __location__,
7844 .name = _NBT_NAME("_SA_GA_DI_U", 0x1C, NULL),
7846 .nb_flags = NBT_NM_GROUP,
7848 .num_ips = ctx->addresses_best_num,
7849 .ips = ctx->addresses_best,
7850 .apply_expected = true
7856 .type = WREPL_TYPE_GROUP,
7857 .state = WREPL_STATE_ACTIVE,
7858 .node = WREPL_NODE_B,
7860 .num_ips = ARRAY_SIZE(addresses_B_1),
7861 .ips = addresses_B_1,
7862 .apply_expected = false
7866 * sgroup,active vs. group,tombstone with same ip(s), unchecked
7869 .line = __location__,
7870 .name = _NBT_NAME("_SA_GT_SI_U", 0x1C, NULL),
7872 .nb_flags = NBT_NM_GROUP,
7874 .num_ips = ctx->addresses_best_num,
7875 .ips = ctx->addresses_best,
7876 .apply_expected = true
7882 .type = WREPL_TYPE_GROUP,
7883 .state = WREPL_STATE_TOMBSTONE,
7884 .node = WREPL_NODE_B,
7886 .num_ips = ctx->addresses_best_num,
7887 .ips = ctx->addresses_best,
7888 .apply_expected = false
7892 * sgroup,active vs. group,tombstone with different ip(s), unchecked
7895 .line = __location__,
7896 .name = _NBT_NAME("_SA_GT_DI_U", 0x1C, NULL),
7898 .nb_flags = NBT_NM_GROUP,
7900 .num_ips = ctx->addresses_best_num,
7901 .ips = ctx->addresses_best,
7902 .apply_expected = true
7908 .type = WREPL_TYPE_GROUP,
7909 .state = WREPL_STATE_TOMBSTONE,
7910 .node = WREPL_NODE_B,
7912 .num_ips = ARRAY_SIZE(addresses_B_1),
7913 .ips = addresses_B_1,
7914 .apply_expected = false
7918 * special group vs. multi homed section
7921 * sgroup,active vs. mhomed,active with same ip(s), unchecked
7924 .line = __location__,
7925 .name = _NBT_NAME("_SA_MA_SI_U", 0x1C, NULL),
7927 .nb_flags = NBT_NM_GROUP,
7929 .num_ips = ctx->addresses_best_num,
7930 .ips = ctx->addresses_best,
7931 .apply_expected = true
7937 .type = WREPL_TYPE_MHOMED,
7938 .state = WREPL_STATE_ACTIVE,
7939 .node = WREPL_NODE_B,
7941 .num_ips = ctx->addresses_best_num,
7942 .ips = ctx->addresses_best,
7943 .apply_expected = false
7947 * sgroup,active vs. mhomed,active with different ip(s), unchecked
7950 .line = __location__,
7951 .name = _NBT_NAME("_SA_MA_DI_U", 0x1C, NULL),
7953 .nb_flags = NBT_NM_GROUP,
7955 .num_ips = ctx->addresses_best_num,
7956 .ips = ctx->addresses_best,
7957 .apply_expected = true
7963 .type = WREPL_TYPE_MHOMED,
7964 .state = WREPL_STATE_ACTIVE,
7965 .node = WREPL_NODE_B,
7967 .num_ips = ARRAY_SIZE(addresses_B_1),
7968 .ips = addresses_B_1,
7969 .apply_expected = false
7973 * sgroup,active vs. mhomed,tombstone with same ip(s), unchecked
7976 .line = __location__,
7977 .name = _NBT_NAME("_SA_MT_SI_U", 0x1C, NULL),
7979 .nb_flags = NBT_NM_GROUP,
7981 .num_ips = ctx->addresses_best_num,
7982 .ips = ctx->addresses_best,
7983 .apply_expected = true
7989 .type = WREPL_TYPE_MHOMED,
7990 .state = WREPL_STATE_TOMBSTONE,
7991 .node = WREPL_NODE_B,
7993 .num_ips = ctx->addresses_best_num,
7994 .ips = ctx->addresses_best,
7995 .apply_expected = false
7999 * sgroup,active vs. mhomed,tombstone with different ip(s), unchecked
8002 .line = __location__,
8003 .name = _NBT_NAME("_SA_MT_DI_U", 0x1C, NULL),
8005 .nb_flags = NBT_NM_GROUP,
8007 .num_ips = ctx->addresses_best_num,
8008 .ips = ctx->addresses_best,
8009 .apply_expected = true
8015 .type = WREPL_TYPE_MHOMED,
8016 .state = WREPL_STATE_TOMBSTONE,
8017 .node = WREPL_NODE_B,
8019 .num_ips = ARRAY_SIZE(addresses_B_1),
8020 .ips = addresses_B_1,
8021 .apply_expected = false
8025 * multi homed vs. unique section
8028 * mhomed,active vs. unique,active with same ip(s), unchecked
8031 .line = __location__,
8032 .name = _NBT_NAME("_MA_UA_SI_U", 0x00, NULL),
8036 .num_ips = ctx->addresses_best_num,
8037 .ips = ctx->addresses_best,
8038 .apply_expected = true
8044 .type = WREPL_TYPE_UNIQUE,
8045 .state = WREPL_STATE_ACTIVE,
8046 .node = WREPL_NODE_B,
8048 .num_ips = ctx->addresses_best_num,
8049 .ips = ctx->addresses_best,
8050 .apply_expected = true
8054 * mhomed,active vs. unique,active with different ip(s), positive response
8057 .line = __location__,
8058 .name = _NBT_NAME("_MA_UA_DI_P", 0x00, NULL),
8062 .num_ips = ctx->addresses_best_num,
8063 .ips = ctx->addresses_best,
8064 .apply_expected = true
8071 .type = WREPL_TYPE_UNIQUE,
8072 .state = WREPL_STATE_ACTIVE,
8073 .node = WREPL_NODE_B,
8075 .num_ips = ARRAY_SIZE(addresses_B_1),
8076 .ips = addresses_B_1,
8077 .apply_expected = false
8081 * mhomed,active vs. unique,active with different ip(s), positive response other ips
8084 .line = __location__,
8085 .name = _NBT_NAME("_MA_UA_DI_O", 0x00, NULL),
8089 .num_ips = ctx->addresses_best_num,
8090 .ips = ctx->addresses_best,
8091 .apply_expected = true
8096 .num_ips = ARRAY_SIZE(addresses_A_3_4),
8097 .ips = addresses_A_3_4,
8100 .type = WREPL_TYPE_UNIQUE,
8101 .state = WREPL_STATE_ACTIVE,
8102 .node = WREPL_NODE_B,
8104 .num_ips = ARRAY_SIZE(addresses_B_1),
8105 .ips = addresses_B_1,
8106 .apply_expected = false
8110 * mhomed,active vs. unique,active with different ip(s), negative response
8113 .line = __location__,
8114 .name = _NBT_NAME("_MA_UA_DI_N", 0x00, NULL),
8118 .num_ips = ctx->addresses_best_num,
8119 .ips = ctx->addresses_best,
8120 .apply_expected = true
8127 .type = WREPL_TYPE_UNIQUE,
8128 .state = WREPL_STATE_ACTIVE,
8129 .node = WREPL_NODE_B,
8131 .num_ips = ARRAY_SIZE(addresses_B_1),
8132 .ips = addresses_B_1,
8133 .apply_expected = true
8137 * mhomed,active vs. unique,tombstone with same ip(s), unchecked
8140 .line = __location__,
8141 .name = _NBT_NAME("_MA_UT_SI_U", 0x00, NULL),
8145 .num_ips = ctx->addresses_best_num,
8146 .ips = ctx->addresses_best,
8147 .apply_expected = true
8153 .type = WREPL_TYPE_UNIQUE,
8154 .state = WREPL_STATE_TOMBSTONE,
8155 .node = WREPL_NODE_B,
8157 .num_ips = ctx->addresses_best_num,
8158 .ips = ctx->addresses_best,
8159 .apply_expected = false
8163 * mhomed,active vs. unique,tombstone with different ip(s), unchecked
8166 .line = __location__,
8167 .name = _NBT_NAME("_MA_UT_DI_U", 0x00, NULL),
8171 .num_ips = ctx->addresses_best_num,
8172 .ips = ctx->addresses_best,
8173 .apply_expected = true
8179 .type = WREPL_TYPE_UNIQUE,
8180 .state = WREPL_STATE_TOMBSTONE,
8181 .node = WREPL_NODE_B,
8183 .num_ips = ARRAY_SIZE(addresses_B_1),
8184 .ips = addresses_B_1,
8185 .apply_expected = false
8189 * multi homed vs. normal group section
8192 * mhomed,active vs. group,active with same ip(s), release expected
8195 .line = __location__,
8196 .name = _NBT_NAME("_MA_GA_SI_R", 0x00, NULL),
8200 .num_ips = ctx->addresses_best_num,
8201 .ips = ctx->addresses_best,
8202 .apply_expected = true
8206 .expect_release = true,
8209 .type = WREPL_TYPE_GROUP,
8210 .state = WREPL_STATE_ACTIVE,
8211 .node = WREPL_NODE_B,
8213 .num_ips = ctx->addresses_best_num,
8214 .ips = ctx->addresses_best,
8215 .apply_expected = true
8219 * mhomed,active vs. group,active with different ip(s), release expected
8222 .line = __location__,
8223 .name = _NBT_NAME("_MA_GA_DI_R", 0x00, NULL),
8227 .num_ips = ctx->addresses_best_num,
8228 .ips = ctx->addresses_best,
8229 .apply_expected = true
8233 .expect_release = true,
8236 .type = WREPL_TYPE_GROUP,
8237 .state = WREPL_STATE_ACTIVE,
8238 .node = WREPL_NODE_B,
8240 .num_ips = ARRAY_SIZE(addresses_B_1),
8241 .ips = addresses_B_1,
8242 .apply_expected = true
8246 * mhomed,active vs. group,tombstone with same ip(s), unchecked
8249 .line = __location__,
8250 .name = _NBT_NAME("_MA_GT_SI_U", 0x00, NULL),
8254 .num_ips = ctx->addresses_best_num,
8255 .ips = ctx->addresses_best,
8256 .apply_expected = true
8262 .type = WREPL_TYPE_GROUP,
8263 .state = WREPL_STATE_TOMBSTONE,
8264 .node = WREPL_NODE_B,
8266 .num_ips = ctx->addresses_best_num,
8267 .ips = ctx->addresses_best,
8268 .apply_expected = false
8272 * mhomed,active vs. group,tombstone with different ip(s), unchecked
8275 .line = __location__,
8276 .name = _NBT_NAME("_MA_GT_DI_U", 0x00, NULL),
8280 .num_ips = ctx->addresses_best_num,
8281 .ips = ctx->addresses_best,
8282 .apply_expected = true
8288 .type = WREPL_TYPE_GROUP,
8289 .state = WREPL_STATE_TOMBSTONE,
8290 .node = WREPL_NODE_B,
8292 .num_ips = ARRAY_SIZE(addresses_B_1),
8293 .ips = addresses_B_1,
8294 .apply_expected = false
8298 * multi homed vs. special group section
8301 * mhomed,active vs. sgroup,active with same ip(s), release expected
8304 .line = __location__,
8305 .name = _NBT_NAME("_MA_SA_SI_R", 0x00, NULL),
8309 .num_ips = ctx->addresses_best_num,
8310 .ips = ctx->addresses_best,
8311 .apply_expected = true
8315 .expect_release = true,
8318 .type = WREPL_TYPE_SGROUP,
8319 .state = WREPL_STATE_ACTIVE,
8320 .node = WREPL_NODE_B,
8322 .num_ips = ctx->addresses_best_num,
8323 .ips = ctx->addresses_best,
8324 .apply_expected = true
8328 * mhomed,active vs. group,active with different ip(s), release expected
8331 .line = __location__,
8332 .name = _NBT_NAME("_MA_SA_DI_R", 0x00, NULL),
8336 .num_ips = ctx->addresses_best_num,
8337 .ips = ctx->addresses_best,
8338 .apply_expected = true
8342 .expect_release = true,
8345 .type = WREPL_TYPE_SGROUP,
8346 .state = WREPL_STATE_ACTIVE,
8347 .node = WREPL_NODE_B,
8349 .num_ips = ARRAY_SIZE(addresses_B_1),
8350 .ips = addresses_B_1,
8351 .apply_expected = true
8355 * mhomed,active vs. sgroup,tombstone with same ip(s), unchecked
8358 .line = __location__,
8359 .name = _NBT_NAME("_MA_ST_SI_U", 0x00, NULL),
8363 .num_ips = ctx->addresses_best_num,
8364 .ips = ctx->addresses_best,
8365 .apply_expected = true
8371 .type = WREPL_TYPE_SGROUP,
8372 .state = WREPL_STATE_TOMBSTONE,
8373 .node = WREPL_NODE_B,
8375 .num_ips = ctx->addresses_best_num,
8376 .ips = ctx->addresses_best,
8377 .apply_expected = false
8381 * mhomed,active vs. sgroup,tombstone with different ip(s), unchecked
8384 .line = __location__,
8385 .name = _NBT_NAME("_MA_ST_DI_U", 0x00, NULL),
8389 .num_ips = ctx->addresses_best_num,
8390 .ips = ctx->addresses_best,
8391 .apply_expected = true
8397 .type = WREPL_TYPE_SGROUP,
8398 .state = WREPL_STATE_TOMBSTONE,
8399 .node = WREPL_NODE_B,
8401 .num_ips = ARRAY_SIZE(addresses_B_1),
8402 .ips = addresses_B_1,
8403 .apply_expected = false
8407 * multi homed vs. multi homed section
8410 * mhomed,active vs. mhomed,active with same ip(s), unchecked
8413 .line = __location__,
8414 .name = _NBT_NAME("_MA_MA_SI_U", 0x00, NULL),
8418 .num_ips = ctx->addresses_best_num,
8419 .ips = ctx->addresses_best,
8420 .apply_expected = true
8426 .type = WREPL_TYPE_MHOMED,
8427 .state = WREPL_STATE_ACTIVE,
8428 .node = WREPL_NODE_B,
8430 .num_ips = ctx->addresses_best_num,
8431 .ips = ctx->addresses_best,
8432 .apply_expected = true
8436 * mhomed,active vs. mhomed,active with superset ip(s), unchecked
8439 .line = __location__,
8440 .name = _NBT_NAME("_MA_MA_SP_U", 0x00, NULL),
8444 .num_ips = ctx->addresses_best_num,
8445 .ips = ctx->addresses_best,
8446 .apply_expected = true
8452 .type = WREPL_TYPE_MHOMED,
8453 .state = WREPL_STATE_ACTIVE,
8454 .node = WREPL_NODE_B,
8456 .num_ips = ctx->addresses_all_num,
8457 .ips = ctx->addresses_all,
8458 .apply_expected = true
8462 * mhomed,active vs. mhomed,active with different ip(s), positive response
8465 .line = __location__,
8466 .name = _NBT_NAME("_MA_MA_DI_P", 0x00, NULL),
8470 .num_ips = ctx->addresses_best_num,
8471 .ips = ctx->addresses_best,
8472 .apply_expected = true
8479 .type = WREPL_TYPE_MHOMED,
8480 .state = WREPL_STATE_ACTIVE,
8481 .node = WREPL_NODE_B,
8483 .num_ips = ARRAY_SIZE(addresses_B_3_4),
8484 .ips = addresses_B_3_4,
8485 .apply_expected = false
8489 * mhomed,active vs. mhomed,active with different ip(s), positive response other ips
8492 .line = __location__,
8493 .name = _NBT_NAME("_MA_MA_DI_O", 0x00, NULL),
8497 .num_ips = ctx->addresses_best_num,
8498 .ips = ctx->addresses_best,
8499 .apply_expected = true
8504 .num_ips = ARRAY_SIZE(addresses_A_3_4),
8505 .ips = addresses_A_3_4,
8508 .type = WREPL_TYPE_MHOMED,
8509 .state = WREPL_STATE_ACTIVE,
8510 .node = WREPL_NODE_B,
8512 .num_ips = ARRAY_SIZE(addresses_B_3_4),
8513 .ips = addresses_B_3_4,
8514 .apply_expected = false
8518 * mhomed,active vs. mhomed,active with different ip(s), negative response
8521 .line = __location__,
8522 .name = _NBT_NAME("_MA_MA_DI_N", 0x00, NULL),
8526 .num_ips = ctx->addresses_best_num,
8527 .ips = ctx->addresses_best,
8528 .apply_expected = true
8535 .type = WREPL_TYPE_MHOMED,
8536 .state = WREPL_STATE_ACTIVE,
8537 .node = WREPL_NODE_B,
8539 .num_ips = ARRAY_SIZE(addresses_B_3_4),
8540 .ips = addresses_B_3_4,
8541 .apply_expected = true
8545 * mhomed,active vs. mhomed,tombstone with same ip(s), unchecked
8548 .line = __location__,
8549 .name = _NBT_NAME("_MA_MT_SI_U", 0x00, NULL),
8553 .num_ips = ctx->addresses_best_num,
8554 .ips = ctx->addresses_best,
8555 .apply_expected = true
8561 .type = WREPL_TYPE_MHOMED,
8562 .state = WREPL_STATE_TOMBSTONE,
8563 .node = WREPL_NODE_B,
8565 .num_ips = ctx->addresses_best_num,
8566 .ips = ctx->addresses_best,
8567 .apply_expected = false
8571 * mhomed,active vs. mhomed,tombstone with different ip(s), unchecked
8574 .line = __location__,
8575 .name = _NBT_NAME("_MA_MT_DI_U", 0x00, NULL),
8579 .num_ips = ctx->addresses_best_num,
8580 .ips = ctx->addresses_best,
8581 .apply_expected = true
8587 .type = WREPL_TYPE_MHOMED,
8588 .state = WREPL_STATE_TOMBSTONE,
8589 .node = WREPL_NODE_B,
8591 .num_ips = ARRAY_SIZE(addresses_B_3_4),
8592 .ips = addresses_B_3_4,
8593 .apply_expected = false
8597 * some more multi homed test, including merging
8600 * mhomed,active vs. mhomed,active with superset ip(s), unchecked
8603 .line = __location__,
8604 .section= "Test Replica vs. owned active: some more MHOMED combinations",
8605 .name = _NBT_NAME("_MA_MA_SP_U", 0x00, NULL),
8606 .comment= "C:MHOMED vs. B:ALL => B:ALL",
8607 .skip = (ctx->addresses_all_num < 3),
8611 .num_ips = ctx->addresses_mhomed_num,
8612 .ips = ctx->addresses_mhomed,
8613 .apply_expected = true
8619 .type = WREPL_TYPE_MHOMED,
8620 .state = WREPL_STATE_ACTIVE,
8621 .node = WREPL_NODE_B,
8623 .num_ips = ctx->addresses_all_num,
8624 .ips = ctx->addresses_all,
8625 .apply_expected = true
8629 * mhomed,active vs. mhomed,active with same ips, unchecked
8632 .line = __location__,
8633 .name = _NBT_NAME("_MA_MA_SM_U", 0x00, NULL),
8634 .comment= "C:MHOMED vs. B:MHOMED => B:MHOMED",
8635 .skip = (ctx->addresses_mhomed_num < 2),
8639 .num_ips = ctx->addresses_mhomed_num,
8640 .ips = ctx->addresses_mhomed,
8641 .apply_expected = true
8647 .type = WREPL_TYPE_MHOMED,
8648 .state = WREPL_STATE_ACTIVE,
8649 .node = WREPL_NODE_B,
8651 .num_ips = ctx->addresses_mhomed_num,
8652 .ips = ctx->addresses_mhomed,
8653 .apply_expected = true
8657 * mhomed,active vs. mhomed,active with subset ip(s), positive response
8660 .line = __location__,
8661 .name = _NBT_NAME("_MA_MA_SB_P", 0x00, NULL),
8662 .comment= "C:MHOMED vs. B:BEST (C:MHOMED) => B:MHOMED",
8663 .skip = (ctx->addresses_mhomed_num < 2),
8667 .num_ips = ctx->addresses_mhomed_num,
8668 .ips = ctx->addresses_mhomed,
8669 .apply_expected = true
8676 .type = WREPL_TYPE_MHOMED,
8677 .state = WREPL_STATE_ACTIVE,
8678 .node = WREPL_NODE_B,
8680 .num_ips = ctx->addresses_best_num,
8681 .ips = ctx->addresses_best,
8682 .mhomed_merge = true
8686 * mhomed,active vs. mhomed,active with subset ip(s), positive response, with all addresses
8689 .line = __location__,
8690 .name = _NBT_NAME("_MA_MA_SB_A", 0x00, NULL),
8691 .comment= "C:MHOMED vs. B:BEST (C:ALL) => B:MHOMED",
8692 .skip = (ctx->addresses_all_num < 3),
8696 .num_ips = ctx->addresses_mhomed_num,
8697 .ips = ctx->addresses_mhomed,
8698 .apply_expected = true
8703 .num_ips = ctx->addresses_all_num,
8704 .ips = ctx->addresses_all,
8707 .type = WREPL_TYPE_MHOMED,
8708 .state = WREPL_STATE_ACTIVE,
8709 .node = WREPL_NODE_B,
8711 .num_ips = ctx->addresses_best_num,
8712 .ips = ctx->addresses_best,
8713 .mhomed_merge = true
8717 * mhomed,active vs. mhomed,active with subset ip(s), positive response, with replicas addresses
8718 * TODO: check why the server sends a name release demand for one address?
8719 * the release demand has no effect to the database record...
8722 .line = __location__,
8723 .name = _NBT_NAME("_MA_MA_SB_PRA", 0x00, NULL),
8724 .comment= "C:MHOMED vs. B:BEST (C:BEST) => C:MHOMED",
8725 .skip = (ctx->addresses_all_num < 2),
8729 .num_ips = ctx->addresses_mhomed_num,
8730 .ips = ctx->addresses_mhomed,
8731 .apply_expected = true
8736 .num_ips = ctx->addresses_best_num,
8737 .ips = ctx->addresses_best,
8738 .late_release = true
8741 .type = WREPL_TYPE_MHOMED,
8742 .state = WREPL_STATE_ACTIVE,
8743 .node = WREPL_NODE_B,
8745 .num_ips = ctx->addresses_best_num,
8746 .ips = ctx->addresses_best,
8747 .apply_expected = false
8751 * mhomed,active vs. mhomed,active with subset ip(s), positive response, with other addresses
8754 .line = __location__,
8755 .name = _NBT_NAME("_MA_MA_SB_O", 0x00, NULL),
8756 .comment= "C:MHOMED vs. B:BEST (B:B_3_4) =>C:MHOMED",
8757 .skip = (ctx->addresses_all_num < 2),
8761 .num_ips = ctx->addresses_mhomed_num,
8762 .ips = ctx->addresses_mhomed,
8763 .apply_expected = true
8768 .num_ips = ARRAY_SIZE(addresses_B_3_4),
8769 .ips = addresses_B_3_4,
8772 .type = WREPL_TYPE_MHOMED,
8773 .state = WREPL_STATE_ACTIVE,
8774 .node = WREPL_NODE_B,
8776 .num_ips = ctx->addresses_best_num,
8777 .ips = ctx->addresses_best,
8778 .apply_expected = false
8782 * mhomed,active vs. mhomed,active with subset ip(s), negative response
8785 .line = __location__,
8786 .name = _NBT_NAME("_MA_MA_SB_N", 0x00, NULL),
8787 .comment= "C:MHOMED vs. B:BEST (NEGATIVE) => B:BEST",
8788 .skip = (ctx->addresses_mhomed_num < 2),
8792 .num_ips = ctx->addresses_mhomed_num,
8793 .ips = ctx->addresses_mhomed,
8794 .apply_expected = true
8801 .type = WREPL_TYPE_MHOMED,
8802 .state = WREPL_STATE_ACTIVE,
8803 .node = WREPL_NODE_B,
8805 .num_ips = ctx->addresses_best_num,
8806 .ips = ctx->addresses_best,
8807 .apply_expected = true
8811 * some more multi homed and unique test, including merging
8814 * mhomed,active vs. unique,active with subset ip(s), positive response
8817 .line = __location__,
8818 .section= "Test Replica vs. owned active: some more UNIQUE,MHOMED combinations",
8819 .name = _NBT_NAME("_MA_UA_SB_P", 0x00, NULL),
8820 .comment= "C:MHOMED vs. B:UNIQUE,BEST (C:MHOMED) => B:MHOMED",
8821 .skip = (ctx->addresses_all_num < 2),
8825 .num_ips = ctx->addresses_mhomed_num,
8826 .ips = ctx->addresses_mhomed,
8827 .apply_expected = true
8834 .type = WREPL_TYPE_UNIQUE,
8835 .state = WREPL_STATE_ACTIVE,
8836 .node = WREPL_NODE_B,
8838 .num_ips = ctx->addresses_best_num,
8839 .ips = ctx->addresses_best,
8840 .mhomed_merge = true
8844 * unique,active vs. unique,active with different ip(s), positive response, with replicas address
8845 * TODO: check why the server sends a name release demand for one address?
8846 * the release demand has no effect to the database record...
8849 .line = __location__,
8850 .name = _NBT_NAME("_UA_UA_DI_PRA", 0x00, NULL),
8851 .comment= "C:BEST vs. B:BEST2 (C:BEST2,LR:BEST2) => C:BEST",
8852 .skip = (ctx->addresses_all_num < 2),
8856 .num_ips = ctx->addresses_best_num,
8857 .ips = ctx->addresses_best,
8858 .apply_expected = true
8863 .num_ips = ctx->addresses_best2_num,
8864 .ips = ctx->addresses_best2,
8865 .late_release = true
8868 .type = WREPL_TYPE_UNIQUE,
8869 .state = WREPL_STATE_ACTIVE,
8870 .node = WREPL_NODE_B,
8872 .num_ips = ctx->addresses_best2_num,
8873 .ips = ctx->addresses_best2,
8874 .apply_expected = false,
8878 * unique,active vs. unique,active with different ip(s), positive response, with all addresses
8881 .line = __location__,
8882 .name = _NBT_NAME("_UA_UA_DI_A", 0x00, NULL),
8883 .comment= "C:BEST vs. B:BEST2 (C:ALL) => B:MHOMED",
8884 .skip = (ctx->addresses_all_num < 3),
8888 .num_ips = ctx->addresses_best_num,
8889 .ips = ctx->addresses_best,
8890 .apply_expected = true
8895 .num_ips = ctx->addresses_all_num,
8896 .ips = ctx->addresses_all,
8899 .type = WREPL_TYPE_UNIQUE,
8900 .state = WREPL_STATE_ACTIVE,
8901 .node = WREPL_NODE_B,
8903 .num_ips = ctx->addresses_best2_num,
8904 .ips = ctx->addresses_best2,
8905 .mhomed_merge = true,
8909 * unique,active vs. mhomed,active with different ip(s), positive response, with all addresses
8912 .line = __location__,
8913 .name = _NBT_NAME("_UA_MA_DI_A", 0x00, NULL),
8914 .comment= "C:BEST vs. B:BEST2 (C:ALL) => B:MHOMED",
8915 .skip = (ctx->addresses_all_num < 3),
8919 .num_ips = ctx->addresses_best_num,
8920 .ips = ctx->addresses_best,
8921 .apply_expected = true
8926 .num_ips = ctx->addresses_all_num,
8927 .ips = ctx->addresses_all,
8930 .type = WREPL_TYPE_MHOMED,
8931 .state = WREPL_STATE_ACTIVE,
8932 .node = WREPL_NODE_B,
8934 .num_ips = ctx->addresses_best2_num,
8935 .ips = ctx->addresses_best2,
8936 .mhomed_merge = true,
8940 * special group vs. special group merging section
8943 * sgroup,active vs. sgroup,active with different ip(s)
8946 .line = __location__,
8947 .section= "Test Replica vs. owned active: SGROUP vs. SGROUP tests",
8948 .name = _NBT_NAME("_SA_SA_DI_U", 0x1C, NULL),
8949 .skip = (ctx->addresses_all_num < 3),
8951 .nb_flags = NBT_NM_GROUP,
8953 .num_ips = ctx->addresses_mhomed_num,
8954 .ips = ctx->addresses_mhomed,
8955 .apply_expected = true
8961 .type = WREPL_TYPE_SGROUP,
8962 .state = WREPL_STATE_ACTIVE,
8963 .node = WREPL_NODE_B,
8965 .num_ips = ARRAY_SIZE(addresses_B_3_4),
8966 .ips = addresses_B_3_4,
8967 .sgroup_merge = true
8972 * sgroup,active vs. sgroup,active with same ip(s)
8975 .line = __location__,
8976 .name = _NBT_NAME("_SA_SA_SI_U", 0x1C, NULL),
8977 .skip = (ctx->addresses_all_num < 3),
8979 .nb_flags = NBT_NM_GROUP,
8981 .num_ips = ctx->addresses_mhomed_num,
8982 .ips = ctx->addresses_mhomed,
8983 .apply_expected = true
8989 .type = WREPL_TYPE_SGROUP,
8990 .state = WREPL_STATE_ACTIVE,
8991 .node = WREPL_NODE_B,
8993 .num_ips = ctx->addresses_mhomed_num,
8994 .ips = ctx->addresses_mhomed,
8995 .sgroup_merge = true
8999 * sgroup,active vs. sgroup,active with superset ip(s)
9002 .line = __location__,
9003 .name = _NBT_NAME("_SA_SA_SP_U", 0x1C, NULL),
9004 .skip = (ctx->addresses_all_num < 3),
9006 .nb_flags = NBT_NM_GROUP,
9008 .num_ips = ctx->addresses_mhomed_num,
9009 .ips = ctx->addresses_mhomed,
9010 .apply_expected = true
9016 .type = WREPL_TYPE_SGROUP,
9017 .state = WREPL_STATE_ACTIVE,
9018 .node = WREPL_NODE_B,
9020 .num_ips = ctx->addresses_all_num,
9021 .ips = ctx->addresses_all,
9022 .sgroup_merge = true
9026 * sgroup,active vs. sgroup,active with subset ip(s)
9029 .line = __location__,
9030 .name = _NBT_NAME("_SA_SA_SB_U", 0x1C, NULL),
9031 .skip = (ctx->addresses_all_num < 3),
9033 .nb_flags = NBT_NM_GROUP,
9035 .num_ips = ctx->addresses_mhomed_num,
9036 .ips = ctx->addresses_mhomed,
9037 .apply_expected = true
9043 .type = WREPL_TYPE_SGROUP,
9044 .state = WREPL_STATE_ACTIVE,
9045 .node = WREPL_NODE_B,
9047 .num_ips = ctx->addresses_best_num,
9048 .ips = ctx->addresses_best,
9049 .sgroup_merge = true
9053 * sgroup,active vs. sgroup,tombstone with different ip(s)
9056 .line = __location__,
9057 .name = _NBT_NAME("_SA_ST_DI_U", 0x1C, NULL),
9058 .skip = (ctx->addresses_all_num < 3),
9060 .nb_flags = NBT_NM_GROUP,
9062 .num_ips = ctx->addresses_mhomed_num,
9063 .ips = ctx->addresses_mhomed,
9064 .apply_expected = true
9070 .type = WREPL_TYPE_SGROUP,
9071 .state = WREPL_STATE_TOMBSTONE,
9072 .node = WREPL_NODE_B,
9074 .num_ips = ARRAY_SIZE(addresses_B_3_4),
9075 .ips = addresses_B_3_4,
9076 .apply_expected = false
9080 * sgroup,active vs. sgroup,tombstone with same ip(s)
9083 .line = __location__,
9084 .name = _NBT_NAME("_SA_ST_SI_U", 0x1C, NULL),
9085 .skip = (ctx->addresses_all_num < 3),
9087 .nb_flags = NBT_NM_GROUP,
9089 .num_ips = ctx->addresses_mhomed_num,
9090 .ips = ctx->addresses_mhomed,
9091 .apply_expected = true
9097 .type = WREPL_TYPE_SGROUP,
9098 .state = WREPL_STATE_TOMBSTONE,
9099 .node = WREPL_NODE_B,
9101 .num_ips = ctx->addresses_mhomed_num,
9102 .ips = ctx->addresses_mhomed,
9103 .apply_expected = false
9107 * sgroup,active vs. sgroup,tombstone with superset ip(s)
9110 .line = __location__,
9111 .name = _NBT_NAME("_SA_ST_SP_U", 0x1C, NULL),
9112 .skip = (ctx->addresses_all_num < 3),
9114 .nb_flags = NBT_NM_GROUP,
9116 .num_ips = ctx->addresses_mhomed_num,
9117 .ips = ctx->addresses_mhomed,
9118 .apply_expected = true
9124 .type = WREPL_TYPE_SGROUP,
9125 .state = WREPL_STATE_TOMBSTONE,
9126 .node = WREPL_NODE_B,
9128 .num_ips = ctx->addresses_all_num,
9129 .ips = ctx->addresses_all,
9130 .apply_expected = false
9134 * sgroup,active vs. sgroup,tombstone with subset ip(s)
9137 .line = __location__,
9138 .name = _NBT_NAME("_SA_ST_SB_U", 0x1C, NULL),
9139 .skip = (ctx->addresses_all_num < 3),
9141 .nb_flags = NBT_NM_GROUP,
9143 .num_ips = ctx->addresses_mhomed_num,
9144 .ips = ctx->addresses_mhomed,
9145 .apply_expected = true
9151 .type = WREPL_TYPE_SGROUP,
9152 .state = WREPL_STATE_TOMBSTONE,
9153 .node = WREPL_NODE_B,
9155 .num_ips = ctx->addresses_best_num,
9156 .ips = ctx->addresses_best,
9157 .apply_expected = false
9163 if (!ctx->nbtsock_srv) {
9164 torture_comment(tctx, "SKIP: Test Replica records vs. owned active records: not bound to port[%d]\n",
9165 lp_nbt_port(tctx->lp_ctx));
9169 torture_comment(tctx, "Test Replica records vs. owned active records\n");
9171 for(i=0; ret && i < ARRAY_SIZE(records); i++) {
9173 struct test_conflict_owned_active_vs_replica_struct record = records[i];
9174 uint32_t j, count = 1;
9177 if (records[i].wins.mhomed || records[i].name.type == 0x1C) {
9178 count = records[i].wins.num_ips;
9181 if (records[i].section) {
9182 torture_comment(tctx, "%s\n", records[i].section);
9185 if (records[i].skip) {
9186 torture_comment(tctx, "%s => SKIPPED\n", nbt_name_string(ctx, &records[i].name));
9190 if (records[i].replica.mhomed_merge) {
9191 action = "MHOMED_MERGE";
9192 } else if (records[i].replica.sgroup_merge) {
9193 action = "SGROUP_MERGE";
9194 } else if (records[i].replica.apply_expected) {
9197 action = "NOT REPLACE";
9200 torture_comment(tctx, "%s%s%s => %s\n",
9201 nbt_name_string(ctx, &records[i].name),
9202 (records[i].comment?": ":""),
9203 (records[i].comment?records[i].comment:""),
9206 /* Prepare for multi homed registration */
9207 ZERO_STRUCT(records[i].defend);
9208 records[i].defend.timeout = 10;
9209 records[i].defend.positive = true;
9210 nbt_set_incoming_handler(ctx->nbtsock_srv,
9211 test_conflict_owned_active_vs_replica_handler,
9213 if (ctx->nbtsock_srv2) {
9214 nbt_set_incoming_handler(ctx->nbtsock_srv2,
9215 test_conflict_owned_active_vs_replica_handler,
9222 for (j=0; j < count; j++) {
9223 struct nbt_name_request *req;
9225 name_register->in.name = records[i].name;
9226 name_register->in.dest_addr = ctx->address;
9227 name_register->in.dest_port = lp_nbt_port(tctx->lp_ctx);
9228 name_register->in.address = records[i].wins.ips[j].ip;
9229 name_register->in.nb_flags = records[i].wins.nb_flags;
9230 name_register->in.register_demand= false;
9231 name_register->in.broadcast = false;
9232 name_register->in.multi_homed = records[i].wins.mhomed;
9233 name_register->in.ttl = 300000;
9234 name_register->in.timeout = 70;
9235 name_register->in.retries = 0;
9237 req = nbt_name_register_send(ctx->nbtsock, name_register);
9239 /* push the request on the wire */
9240 event_loop_once(ctx->nbtsock->event_ctx);
9243 * if we register multiple addresses,
9244 * the server will do name queries to see if the old addresses
9247 if (records[i].wins.mhomed && j > 0) {
9248 end = timeval_current_ofs(records[i].defend.timeout,0);
9249 records[i].defend.ret = true;
9250 while (records[i].defend.timeout > 0) {
9251 event_loop_once(ctx->nbtsock_srv->event_ctx);
9252 if (timeval_expired(&end)) break;
9254 ret &= records[i].defend.ret;
9257 status = nbt_name_register_recv(req, ctx, name_register);
9258 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
9259 torture_comment(tctx, "No response from %s for name register\n", ctx->address);
9262 if (!NT_STATUS_IS_OK(status)) {
9263 torture_comment(tctx, "Bad response from %s for name register - %s\n",
9264 ctx->address, nt_errstr(status));
9267 CHECK_VALUE(tctx, name_register->out.rcode, 0);
9268 CHECK_VALUE_STRING(tctx, name_register->out.reply_from, ctx->address);
9269 CHECK_VALUE(tctx, name_register->out.name.type, records[i].name.type);
9270 CHECK_VALUE_STRING(tctx, name_register->out.name.name, records[i].name.name);
9271 CHECK_VALUE_STRING(tctx, name_register->out.name.scope, records[i].name.scope);
9272 CHECK_VALUE_STRING(tctx, name_register->out.reply_addr, records[i].wins.ips[j].ip);
9275 /* Prepare for the current test */
9276 records[i].defend = record.defend;
9277 nbt_set_incoming_handler(ctx->nbtsock_srv,
9278 test_conflict_owned_active_vs_replica_handler,
9280 if (ctx->nbtsock_srv2) {
9281 nbt_set_incoming_handler(ctx->nbtsock_srv2,
9282 test_conflict_owned_active_vs_replica_handler,
9289 wins_name->name = &records[i].name;
9290 wins_name->flags = WREPL_NAME_FLAGS(records[i].replica.type,
9291 records[i].replica.state,
9292 records[i].replica.node,
9293 records[i].replica.is_static);
9294 wins_name->id = ++ctx->b.max_version;
9295 if (wins_name->flags & 2) {
9296 wins_name->addresses.addresses.num_ips = records[i].replica.num_ips;
9297 wins_name->addresses.addresses.ips = discard_const(records[i].replica.ips);
9299 wins_name->addresses.ip = records[i].replica.ips[0].ip;
9301 wins_name->unknown = "255.255.255.255";
9303 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
9306 * wait for the name query, which is handled in
9307 * test_conflict_owned_active_vs_replica_handler()
9309 end = timeval_current_ofs(records[i].defend.timeout,0);
9310 records[i].defend.ret = true;
9311 while (records[i].defend.timeout > 0) {
9312 event_loop_once(ctx->nbtsock_srv->event_ctx);
9313 if (timeval_expired(&end)) break;
9315 ret &= records[i].defend.ret;
9317 if (records[i].defend.late_release) {
9318 records[i].defend = record.defend;
9319 records[i].defend.expect_release = true;
9321 * wait for the name release demand, which is handled in
9322 * test_conflict_owned_active_vs_replica_handler()
9324 end = timeval_current_ofs(records[i].defend.timeout,0);
9325 records[i].defend.ret = true;
9326 while (records[i].defend.timeout > 0) {
9327 event_loop_once(ctx->nbtsock_srv->event_ctx);
9328 if (timeval_expired(&end)) break;
9330 ret &= records[i].defend.ret;
9333 if (records[i].replica.mhomed_merge) {
9334 ret &= test_wrepl_mhomed_merged(tctx, ctx, &ctx->c,
9335 records[i].wins.num_ips, records[i].wins.ips,
9337 records[i].replica.num_ips, records[i].replica.ips,
9339 } else if (records[i].replica.sgroup_merge) {
9340 ret &= test_wrepl_sgroup_merged(tctx, ctx, NULL,
9342 records[i].wins.num_ips, records[i].wins.ips,
9344 records[i].replica.num_ips, records[i].replica.ips,
9347 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name,
9348 records[i].replica.apply_expected);
9351 if (records[i].replica.apply_expected ||
9352 records[i].replica.mhomed_merge) {
9353 wins_name->name = &records[i].name;
9354 wins_name->flags = WREPL_NAME_FLAGS(WREPL_TYPE_UNIQUE,
9355 WREPL_STATE_TOMBSTONE,
9356 WREPL_NODE_B, false);
9357 wins_name->id = ++ctx->b.max_version;
9358 wins_name->addresses.ip = addresses_B_1[0].ip;
9359 wins_name->unknown = "255.255.255.255";
9361 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
9362 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name, true);
9364 for (j=0; j < count; j++) {
9365 struct nbt_name_socket *nbtsock = ctx->nbtsock;
9367 if (ctx->myaddr2 && strcmp(records[i].wins.ips[j].ip, ctx->myaddr2->addr) == 0) {
9368 nbtsock = ctx->nbtsock2;
9371 release->in.name = records[i].name;
9372 release->in.dest_addr = ctx->address;
9373 release->in.dest_port = lp_nbt_port(tctx->lp_ctx);
9374 release->in.address = records[i].wins.ips[j].ip;
9375 release->in.nb_flags = records[i].wins.nb_flags;
9376 release->in.broadcast = false;
9377 release->in.timeout = 30;
9378 release->in.retries = 0;
9380 status = nbt_name_release(nbtsock, ctx, release);
9381 if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
9382 torture_comment(tctx, "No response from %s for name release\n", ctx->address);
9385 if (!NT_STATUS_IS_OK(status)) {
9386 torture_comment(tctx, "Bad response from %s for name query - %s\n",
9387 ctx->address, nt_errstr(status));
9390 CHECK_VALUE(tctx, release->out.rcode, 0);
9393 if (records[i].replica.sgroup_merge) {
9394 /* clean up the SGROUP record */
9395 wins_name->name = &records[i].name;
9396 wins_name->flags = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
9398 WREPL_NODE_B, false);
9399 wins_name->id = ++ctx->b.max_version;
9400 wins_name->addresses.addresses.num_ips = 0;
9401 wins_name->addresses.addresses.ips = NULL;
9402 wins_name->unknown = "255.255.255.255";
9403 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
9405 /* take ownership of the SGROUP record */
9406 wins_name->name = &records[i].name;
9407 wins_name->flags = WREPL_NAME_FLAGS(WREPL_TYPE_SGROUP,
9409 WREPL_NODE_B, false);
9410 wins_name->id = ++ctx->b.max_version;
9411 wins_name->addresses.addresses.num_ips = ARRAY_SIZE(addresses_B_1);
9412 wins_name->addresses.addresses.ips = discard_const(addresses_B_1);
9413 wins_name->unknown = "255.255.255.255";
9414 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
9415 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name, true);
9417 /* overwrite the SGROUP record with unique,tombstone */
9418 wins_name->name = &records[i].name;
9419 wins_name->flags = WREPL_NAME_FLAGS(WREPL_TYPE_UNIQUE,
9420 WREPL_STATE_TOMBSTONE,
9421 WREPL_NODE_B, false);
9422 wins_name->id = ++ctx->b.max_version;
9423 wins_name->addresses.ip = addresses_A_1[0].ip;
9424 wins_name->unknown = "255.255.255.255";
9425 ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
9426 ret &= test_wrepl_is_applied(tctx, ctx, &ctx->b, wins_name, true);
9431 torture_comment(tctx, "conflict handled wrong or record[%u]: %s\n", i, records[i].line);
9439 #define _NBT_ASSERT(v, correct) do { \
9440 if ((v) != (correct)) { \
9441 printf("(%s) Incorrect value %s=%d - should be %s (%d)\n", \
9442 __location__, #v, v, #correct, correct); \
9447 #define _NBT_ASSERT_STRING(v, correct) do { \
9448 if ( ((!v) && (correct)) || \
9449 ((v) && (!correct)) || \
9450 ((v) && (correct) && strcmp(v,correct) != 0)) { \
9451 printf("(%s) Incorrect value %s=%s - should be %s\n", \
9452 __location__, #v, v, correct); \
9457 static void test_conflict_owned_active_vs_replica_handler_query(struct nbt_name_socket *nbtsock,
9458 struct nbt_name_packet *req_packet,
9459 struct socket_address *src)
9461 struct nbt_name *name;
9462 struct nbt_name_packet *rep_packet;
9463 struct test_conflict_owned_active_vs_replica_struct *rec =
9464 (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private;
9466 _NBT_ASSERT(req_packet->qdcount, 1);
9467 _NBT_ASSERT(req_packet->questions[0].question_type, NBT_QTYPE_NETBIOS);
9468 _NBT_ASSERT(req_packet->questions[0].question_class, NBT_QCLASS_IP);
9470 name = &req_packet->questions[0].name;
9472 _NBT_ASSERT(name->type, rec->name.type);
9473 _NBT_ASSERT_STRING(name->name, rec->name.name);
9474 _NBT_ASSERT_STRING(name->scope, rec->name.scope);
9476 _NBT_ASSERT(rec->defend.expect_release, false);
9478 rep_packet = talloc_zero(nbtsock, struct nbt_name_packet);
9479 if (rep_packet == NULL) return;
9481 rep_packet->name_trn_id = req_packet->name_trn_id;
9482 rep_packet->ancount = 1;
9484 rep_packet->answers = talloc_array(rep_packet, struct nbt_res_rec, 1);
9485 if (rep_packet->answers == NULL) return;
9487 rep_packet->answers[0].name = *name;
9488 rep_packet->answers[0].rr_class = NBT_QCLASS_IP;
9489 rep_packet->answers[0].ttl = 0;
9491 if (rec->defend.positive) {
9492 uint32_t i, num_ips;
9493 const struct wrepl_ip *ips;
9495 if (rec->defend.num_ips > 0) {
9496 num_ips = rec->defend.num_ips;
9497 ips = rec->defend.ips;
9499 num_ips = rec->wins.num_ips;
9500 ips = rec->wins.ips;
9503 /* send a positive reply */
9504 rep_packet->operation =
9507 NBT_FLAG_AUTHORITIVE |
9508 NBT_FLAG_RECURSION_DESIRED |
9509 NBT_FLAG_RECURSION_AVAIL;
9511 rep_packet->answers[0].rr_type = NBT_QTYPE_NETBIOS;
9513 rep_packet->answers[0].rdata.netbios.length = num_ips*6;
9514 rep_packet->answers[0].rdata.netbios.addresses =
9515 talloc_array(rep_packet->answers, struct nbt_rdata_address, num_ips);
9516 if (rep_packet->answers[0].rdata.netbios.addresses == NULL) return;
9518 for (i=0; i < num_ips; i++) {
9519 struct nbt_rdata_address *addr =
9520 &rep_packet->answers[0].rdata.netbios.addresses[i];
9521 addr->nb_flags = rec->wins.nb_flags;
9522 addr->ipaddr = ips[i].ip;
9524 DEBUG(2,("Sending positive name query reply for %s to %s:%d\n",
9525 nbt_name_string(rep_packet, name), src->addr, src->port));
9527 /* send a negative reply */
9528 rep_packet->operation =
9531 NBT_FLAG_AUTHORITIVE |
9534 rep_packet->answers[0].rr_type = NBT_QTYPE_NULL;
9536 ZERO_STRUCT(rep_packet->answers[0].rdata);
9538 DEBUG(2,("Sending negative name query reply for %s to %s:%d\n",
9539 nbt_name_string(rep_packet, name), src->addr, src->port));
9542 nbt_name_reply_send(nbtsock, src, rep_packet);
9543 talloc_free(rep_packet);
9545 /* make sure we push the reply to the wire */
9546 event_loop_once(nbtsock->event_ctx);
9549 rec->defend.timeout = 0;
9550 rec->defend.ret = true;
9553 static void test_conflict_owned_active_vs_replica_handler_release(
9554 struct nbt_name_socket *nbtsock,
9555 struct nbt_name_packet *req_packet,
9556 struct socket_address *src)
9558 struct nbt_name *name;
9559 struct nbt_name_packet *rep_packet;
9560 struct test_conflict_owned_active_vs_replica_struct *rec =
9561 (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private;
9563 _NBT_ASSERT(req_packet->qdcount, 1);
9564 _NBT_ASSERT(req_packet->questions[0].question_type, NBT_QTYPE_NETBIOS);
9565 _NBT_ASSERT(req_packet->questions[0].question_class, NBT_QCLASS_IP);
9567 name = &req_packet->questions[0].name;
9569 _NBT_ASSERT(name->type, rec->name.type);
9570 _NBT_ASSERT_STRING(name->name, rec->name.name);
9571 _NBT_ASSERT_STRING(name->scope, rec->name.scope);
9573 _NBT_ASSERT(rec->defend.expect_release, true);
9575 rep_packet = talloc_zero(nbtsock, struct nbt_name_packet);
9576 if (rep_packet == NULL) return;
9578 rep_packet->name_trn_id = req_packet->name_trn_id;
9579 rep_packet->ancount = 1;
9580 rep_packet->operation =
9582 NBT_OPCODE_RELEASE |
9583 NBT_FLAG_AUTHORITIVE;
9585 rep_packet->answers = talloc_array(rep_packet, struct nbt_res_rec, 1);
9586 if (rep_packet->answers == NULL) return;
9588 rep_packet->answers[0].name = *name;
9589 rep_packet->answers[0].rr_type = NBT_QTYPE_NETBIOS;
9590 rep_packet->answers[0].rr_class = NBT_QCLASS_IP;
9591 rep_packet->answers[0].ttl = req_packet->additional[0].ttl;
9592 rep_packet->answers[0].rdata = req_packet->additional[0].rdata;
9594 DEBUG(2,("Sending name release reply for %s to %s:%d\n",
9595 nbt_name_string(rep_packet, name), src->addr, src->port));
9597 nbt_name_reply_send(nbtsock, src, rep_packet);
9598 talloc_free(rep_packet);
9600 /* make sure we push the reply to the wire */
9601 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;
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);