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