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 58static 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 69static 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*/ 84static 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, wrepl_best_ip(tctx->lp_ctx, address), address); 111 CHECK_STATUS(tctx, status, NT_STATUS_OK); 112 113 status = wrepl_connect(wrepl_socket2, wrepl_best_ip(tctx->lp_ctx, address), address); 114 CHECK_STATUS(tctx, status, NT_STATUS_OK); 115 116 torture_comment(tctx, "Send a start association request (conn1)\n"); 117 status = wrepl_associate(wrepl_socket1, &associate1); 118 CHECK_STATUS(tctx, status, NT_STATUS_OK); 119 120 torture_comment(tctx, "association context (conn1): 0x%x\n", associate1.out.assoc_ctx); 121 122 torture_comment(tctx, "Send a start association request (conn2)\n"); 123 status = wrepl_associate(wrepl_socket2, &associate2); 124 CHECK_STATUS(tctx, status, NT_STATUS_OK); 125 126 torture_comment(tctx, "association context (conn2): 0x%x\n", associate2.out.assoc_ctx); 127 128 torture_comment(tctx, "Send a replication table query, with assoc 1 (conn2), the 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*/ 175static 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, 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*/ 224static 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*/ 242static 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, 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 320struct 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 355static const struct wrepl_ip addresses_A_1[] = { 356 { 357 .owner = TEST_OWNER_A_ADDRESS, 358 .ip = TEST_ADDRESS_A_PREFIX".1" 359 } 360}; 361static const struct wrepl_ip addresses_A_2[] = { 362 { 363 .owner = TEST_OWNER_A_ADDRESS, 364 .ip = TEST_ADDRESS_A_PREFIX".2" 365 } 366}; 367static 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}; 377static 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}; 395static 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}; 413static 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}; 423static 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 442static 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 461static const struct wrepl_ip addresses_B_1[] = { 462 { 463 .owner = TEST_OWNER_B_ADDRESS, 464 .ip = TEST_ADDRESS_B_PREFIX".1" 465 } 466}; 467static const struct wrepl_ip addresses_B_2[] = { 468 { 469 .owner = TEST_OWNER_B_ADDRESS, 470 .ip = TEST_ADDRESS_B_PREFIX".2" 471 } 472}; 473static 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}; 483static 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}; 501static 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 520static 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}; 530static 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 541static 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, 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 708static 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, 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 777static 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 822static 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 899static 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 1008static 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 1180static 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 4971static 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 6648struct 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 6684static 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 6688static 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 9453static 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 9551static 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 9608static 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*/ 9633static 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*/ 9656static 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*/ 9682struct 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} 9706