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