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