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