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