source4/libcli/wrepl/winsrepl.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    low level WINS replication client code
   5
   6    Copyright (C) Andrew Tridgell 2005
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "lib/events/events.h"
  25 #include "dlinklist.h"
  26 #include "lib/socket/socket.h"
  27 #include "libcli/wrepl/winsrepl.h"
  28
  29 /*
  30   mark all pending requests as dead - called when a socket error happens
  31 */
  32 static void wrepl_socket_dead(struct wrepl_socket *wrepl_socket, NTSTATUS status)
  33 {
  34         wrepl_socket->dead = True;
  35
  36         if (wrepl_socket->fde) {
  37                 talloc_free(wrepl_socket->fde);
  38                 wrepl_socket->fde = NULL;
  39         }
  40
  41         if (wrepl_socket->sock) {
  42                 talloc_free(wrepl_socket->sock);
  43                 wrepl_socket->sock = NULL;
  44         }
  45
  46         if (NT_STATUS_EQUAL(NT_STATUS_UNSUCCESSFUL, status)) {
  47                 status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
  48         }
  49         while (wrepl_socket->send_queue) {
  50                 struct wrepl_request *req = wrepl_socket->send_queue;
  51                 DLIST_REMOVE(wrepl_socket->send_queue, req);
  52                 req->state = WREPL_REQUEST_ERROR;
  53                 req->status = status;
  54                 if (req->async.fn) {
  55                         req->async.fn(req);
  56                 }
  57         }
  58         while (wrepl_socket->recv_queue) {
  59                 struct wrepl_request *req = wrepl_socket->recv_queue;
  60                 DLIST_REMOVE(wrepl_socket->recv_queue, req);
  61                 req->state = WREPL_REQUEST_ERROR;
  62                 req->status = status;
  63                 if (req->async.fn) {
  64                         req->async.fn(req);
  65                 }
  66         }
  67 }
  68
  69 static void wrepl_request_timeout_handler(struct event_context *ev, struct timed_event *te,
  70                                           struct timeval t, void *ptr)
  71 {
  72         struct wrepl_request *req = talloc_get_type(ptr, struct wrepl_request);
  73         wrepl_socket_dead(req->wrepl_socket, NT_STATUS_IO_TIMEOUT);
  74 }
  75
  76 /*
  77   handle send events
  78 */
  79 static void wrepl_handler_send(struct wrepl_socket *wrepl_socket)
  80 {
  81         while (wrepl_socket->send_queue) {
  82                 struct wrepl_request *req = wrepl_socket->send_queue;
  83                 size_t nsent;
  84                 NTSTATUS status;
  85
  86                 status = socket_send(wrepl_socket->sock, &req->buffer, &nsent, 0);
  87                 if (NT_STATUS_IS_ERR(status)) {
  88                         wrepl_socket_dead(wrepl_socket, status);
  89                         return;
  90                 }
  91                 if (!NT_STATUS_IS_OK(status) || nsent == 0) return;
  92
  93                 req->buffer.data   += nsent;
  94                 req->buffer.length -= nsent;
  95                 if (req->buffer.length != 0) {
  96                         return;
  97                 }
  98
  99                 DLIST_REMOVE(wrepl_socket->send_queue, req);
 100                 DLIST_ADD_END(wrepl_socket->recv_queue, req, struct wrepl_request *);
 101                 req->state = WREPL_REQUEST_RECV;
 102
 103                 EVENT_FD_READABLE(wrepl_socket->fde);
 104         }
 105
 106         EVENT_FD_NOT_WRITEABLE(wrepl_socket->fde);
 107 }
 108
 109
 110 /*
 111   handle recv events
 112 */
 113 static void wrepl_handler_recv(struct wrepl_socket *wrepl_socket)
 114 {
 115         size_t nread;
 116         struct wrepl_request *req = wrepl_socket->recv_queue;
 117         DATA_BLOB blob;
 118
 119         if (req == NULL) {
 120                 NTSTATUS status;
 121
 122                 EVENT_FD_NOT_READABLE(wrepl_socket->fde);
 123
 124                 status = socket_recv(wrepl_socket->sock, NULL, 0, &nread, 0);
 125                 if (NT_STATUS_EQUAL(NT_STATUS_END_OF_FILE,status)) return;
 126                 if (NT_STATUS_IS_ERR(status)) {
 127                         wrepl_socket_dead(wrepl_socket, status);
 128                         return;
 129                 }
 130                 return;
 131         }
 132
 133         if (req->buffer.length == 0) {
 134                 req->buffer = data_blob_talloc(req, NULL, 4);
 135                 if (req->buffer.data == NULL) {
 136                         req->status = NT_STATUS_NO_MEMORY;
 137                         goto failed;
 138                 }
 139                 req->num_read = 0;
 140         }
 141
 142         /* read in the packet length */
 143         if (req->num_read < 4) {
 144                 uint32_t req_length;
 145
 146                 req->status = socket_recv(wrepl_socket->sock,
 147                                           req->buffer.data + req->num_read,
 148                                           4 - req->num_read,
 149                                           &nread, 0);
 150                 if (NT_STATUS_IS_ERR(req->status)) {
 151                         wrepl_socket_dead(wrepl_socket, req->status);
 152                         return;
 153                 }
 154                 if (!NT_STATUS_IS_OK(req->status)) return;
 155
 156                 req->num_read += nread;
 157                 if (req->num_read != 4) return;
 158
 159                 req_length = RIVAL(req->buffer.data, 0) + 4;
 160
 161                 req->buffer.data = talloc_realloc(req, req->buffer.data,
 162                                                   uint8_t, req_length);
 163                 if (req->buffer.data == NULL) {
 164                         req->status = NT_STATUS_NO_MEMORY;
 165                         goto failed;
 166                 }
 167                 req->buffer.length = req_length;
 168         }
 169
 170         /* read in the body */
 171         req->status = socket_recv(wrepl_socket->sock,
 172                                   req->buffer.data + req->num_read,
 173                                   req->buffer.length - req->num_read,
 174                                   &nread, 0);
 175         if (NT_STATUS_IS_ERR(req->status)) {
 176                 wrepl_socket_dead(wrepl_socket, req->status);
 177                 return;
 178         }
 179         if (!NT_STATUS_IS_OK(req->status)) return;
 180
 181         req->num_read += nread;
 182         if (req->num_read != req->buffer.length) return;
 183
 184         req->packet = talloc(req, struct wrepl_packet);
 185         if (req->packet == NULL) {
 186                 req->status = NT_STATUS_NO_MEMORY;
 187                 goto failed;
 188         }
 189
 190         blob.data = req->buffer.data + 4;
 191         blob.length = req->buffer.length - 4;
 192
 193         /* we have a full request - parse it */
 194         req->status = ndr_pull_struct_blob(&blob,
 195                                            req->packet, req->packet,
 196                                            (ndr_pull_flags_fn_t)ndr_pull_wrepl_packet);
 197         if (!NT_STATUS_IS_OK(req->status)) {
 198                 DEBUG(2,("Failed to parse incoming WINS packet - %s\n",
 199                          nt_errstr(req->status)));
 200                 DEBUG(10,("packet length %d\n", (int)req->buffer.length));
 201                 NDR_PRINT_DEBUG(wrepl_packet, req->packet);
 202                 goto failed;
 203         }
 204
 205         if (DEBUGLVL(10)) {
 206                 DEBUG(10,("Received WINS packet of length %d\n", (int)req->buffer.length));
 207                 NDR_PRINT_DEBUG(wrepl_packet, req->packet);
 208         }
 209
 210         DLIST_REMOVE(wrepl_socket->recv_queue, req);
 211         req->state = WREPL_REQUEST_DONE;
 212         if (req->async.fn) {
 213                 req->async.fn(req);
 214         }
 215         return;
 216
 217 failed:
 218         if (req->state == WREPL_REQUEST_RECV) {
 219                 DLIST_REMOVE(wrepl_socket->recv_queue, req);
 220         }
 221         req->state = WREPL_REQUEST_ERROR;
 222         if (req->async.fn) {
 223                 req->async.fn(req);
 224         }
 225 }
 226
 227
 228 /*
 229   handler for winrepl events
 230 */
 231 static void wrepl_handler(struct event_context *ev, struct fd_event *fde,
 232                           uint16_t flags, void *private)
 233 {
 234         struct wrepl_socket *wrepl_socket = talloc_get_type(private,
 235                                                             struct wrepl_socket);
 236         if (flags & EVENT_FD_WRITE) {
 237                 wrepl_handler_send(wrepl_socket);
 238         }
 239         if (flags & EVENT_FD_READ) {
 240                 wrepl_handler_recv(wrepl_socket);
 241         }
 242 }
 243
 244
 245 /*
 246   handler for winrepl connection completion
 247 */
 248 static void wrepl_connect_handler(struct event_context *ev, struct fd_event *fde,
 249                                   uint16_t flags, void *private)
 250 {
 251         struct wrepl_socket *wrepl_socket = talloc_get_type(private,
 252                                                             struct wrepl_socket);
 253         struct wrepl_request *req = wrepl_socket->recv_queue;
 254
 255         talloc_free(wrepl_socket->fde);
 256         wrepl_socket->fde = NULL;
 257
 258         if (req == NULL) return;
 259
 260         req->status = socket_connect_complete(wrepl_socket->sock, 0);
 261         if (NT_STATUS_IS_ERR(req->status)) goto failed;
 262
 263         if (!NT_STATUS_IS_OK(req->status)) return;
 264
 265         wrepl_socket->fde = event_add_fd(wrepl_socket->event_ctx, wrepl_socket,
 266                                          socket_get_fd(wrepl_socket->sock),
 267                                          0,
 268                                          wrepl_handler, wrepl_socket);
 269         if (wrepl_socket->fde == NULL) {
 270                 req->status = NT_STATUS_NO_MEMORY;
 271         }
 272
 273
 274 failed:
 275         DLIST_REMOVE(wrepl_socket->recv_queue, req);
 276         if (!NT_STATUS_IS_OK(req->status)) {
 277                 req->state = WREPL_REQUEST_ERROR;
 278         } else {
 279                 req->state = WREPL_REQUEST_DONE;
 280         }
 281         if (req->async.fn) {
 282                 req->async.fn(req);
 283         }
 284 }
 285
 286 /*
 287   destroy a wrepl_socket destructor
 288 */
 289 static int wrepl_socket_destructor(void *ptr)
 290 {
 291         struct wrepl_socket *sock = talloc_get_type(ptr, struct wrepl_socket);
 292         wrepl_socket_dead(sock, NT_STATUS_CONNECTION_DISCONNECTED);
 293         return 0;
 294 }
 295
 296 /*
 297   initialise a wrepl_socket. The event_ctx is optional, if provided then
 298   operations will use that event context
 299 */
 300 struct wrepl_socket *wrepl_socket_init(TALLOC_CTX *mem_ctx,
 301                                        struct event_context *event_ctx)
 302 {
 303         struct wrepl_socket *wrepl_socket;
 304         NTSTATUS status;
 305
 306         wrepl_socket = talloc(mem_ctx, struct wrepl_socket);
 307         if (wrepl_socket == NULL) goto failed;
 308
 309         if (event_ctx == NULL) {
 310                 wrepl_socket->event_ctx = event_context_init(wrepl_socket);
 311         } else {
 312                 wrepl_socket->event_ctx = talloc_reference(wrepl_socket, event_ctx);
 313         }
 314         if (wrepl_socket->event_ctx == NULL) goto failed;
 315
 316         status = socket_create("ip", SOCKET_TYPE_STREAM, &wrepl_socket->sock, 0);
 317         if (!NT_STATUS_IS_OK(status)) goto failed;
 318
 319         talloc_steal(wrepl_socket, wrepl_socket->sock);
 320
 321         wrepl_socket->send_queue        = NULL;
 322         wrepl_socket->recv_queue        = NULL;
 323         wrepl_socket->request_timeout   = WREPL_SOCKET_REQUEST_TIMEOUT;
 324         wrepl_socket->dead              = False;
 325
 326         wrepl_socket->fde = event_add_fd(wrepl_socket->event_ctx, wrepl_socket,
 327                                          socket_get_fd(wrepl_socket->sock),
 328                                          EVENT_FD_WRITE,
 329                                          wrepl_connect_handler, wrepl_socket);
 330
 331         set_blocking(socket_get_fd(wrepl_socket->sock), False);
 332
 333         talloc_set_destructor(wrepl_socket, wrepl_socket_destructor);
 334
 335         return wrepl_socket;
 336
 337 failed:
 338         talloc_free(wrepl_socket);
 339         return NULL;
 340 }
 341
 342 /*
 343   destroy a wrepl_request
 344 */
 345 static int wrepl_request_destructor(void *ptr)
 346 {
 347         struct wrepl_request *req = talloc_get_type(ptr, struct wrepl_request);
 348         if (req->state == WREPL_REQUEST_SEND) {
 349                 DLIST_REMOVE(req->wrepl_socket->send_queue, req);
 350         }
 351         if (req->state == WREPL_REQUEST_RECV) {
 352                 DLIST_REMOVE(req->wrepl_socket->recv_queue, req);
 353         }
 354         req->state = WREPL_REQUEST_ERROR;
 355         return 0;
 356 }
 357
 358 /*
 359   wait for a request to complete
 360 */
 361 static NTSTATUS wrepl_request_wait(struct wrepl_request *req)
 362 {
 363         NT_STATUS_HAVE_NO_MEMORY(req);
 364         while (req->state < WREPL_REQUEST_DONE) {
 365                 event_loop_once(req->wrepl_socket->event_ctx);
 366         }
 367         return req->status;
 368 }
 369
 370
 371 /*
 372   connect a wrepl_socket to a WINS server
 373 */
 374 struct wrepl_request *wrepl_connect_send(struct wrepl_socket *wrepl_socket,
 375                                          const char *address)
 376 {
 377         struct wrepl_request *req;
 378         NTSTATUS status;
 379
 380         req = talloc_zero(wrepl_socket, struct wrepl_request);
 381         if (req == NULL) goto failed;
 382
 383         req->wrepl_socket = wrepl_socket;
 384         req->state        = WREPL_REQUEST_RECV;
 385
 386         DLIST_ADD(wrepl_socket->recv_queue, req);
 387
 388         talloc_set_destructor(req, wrepl_request_destructor);
 389
 390         status = socket_connect(wrepl_socket->sock, iface_best_ip(address), 0, address,
 391                                 WINS_REPLICATION_PORT, 0);
 392         if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) goto failed;
 393
 394         return req;
 395
 396 failed:
 397         talloc_free(req);
 398         return NULL;
 399 }
 400
 401 /*
 402   connect a wrepl_socket to a WINS server - recv side
 403 */
 404 NTSTATUS wrepl_connect_recv(struct wrepl_request *req)
 405 {
 406         return wrepl_request_wait(req);
 407 }
 408
 409
 410 /*
 411   connect a wrepl_socket to a WINS server - sync API
 412 */
 413 NTSTATUS wrepl_connect(struct wrepl_socket *wrepl_socket, const char *address)
 414 {
 415         struct wrepl_request *req = wrepl_connect_send(wrepl_socket, address);
 416         return wrepl_connect_recv(req);
 417 }
 418
 419 /*
 420    callback from wrepl_request_trigger()
 421 */
 422 static void wrepl_request_trigger_handler(struct event_context *ev, struct timed_event *te,
 423                                           struct timeval t, void *ptr)
 424 {
 425         struct wrepl_request *req = talloc_get_type(ptr, struct wrepl_request);
 426         if (req->async.fn) {
 427                 req->async.fn(req);
 428         }
 429 }
 430
 431 /*
 432   trigger an immediate event on a wrepl_request
 433 */
 434 static void wrepl_request_trigger(struct wrepl_request *req)
 435 {
 436         /* a zero timeout means immediate */
 437         event_add_timed(req->wrepl_socket->event_ctx,
 438                         req, timeval_zero(),
 439                         wrepl_request_trigger_handler, req);
 440 }
 441
 442
 443 /*
 444   send a generic wins replication request
 445 */
 446 struct wrepl_request *wrepl_request_send(struct wrepl_socket *wrepl_socket,
 447                                          struct wrepl_packet *packet)
 448 {
 449         struct wrepl_request *req;
 450         struct wrepl_wrap wrap;
 451
 452         req = talloc_zero(wrepl_socket, struct wrepl_request);
 453         if (req == NULL) goto failed;
 454
 455         if (wrepl_socket->dead) {
 456                 req->wrepl_socket = wrepl_socket;
 457                 req->state        = WREPL_REQUEST_ERROR;
 458                 req->status       = NT_STATUS_INVALID_CONNECTION;
 459                 wrepl_request_trigger(req);
 460                 return req;
 461         }
 462
 463         req->wrepl_socket = wrepl_socket;
 464         req->state        = WREPL_REQUEST_SEND;
 465
 466         wrap.packet = *packet;
 467         req->status = ndr_push_struct_blob(&req->buffer, req, &wrap,
 468                                            (ndr_push_flags_fn_t)ndr_push_wrepl_wrap);
 469         if (!NT_STATUS_IS_OK(req->status)) goto failed;
 470
 471         if (DEBUGLVL(10)) {
 472                 DEBUG(10,("Sending WINS packet of length %d\n", (int)req->buffer.length));
 473                 NDR_PRINT_DEBUG(wrepl_packet, &wrap.packet);
 474         }
 475
 476         DLIST_ADD(wrepl_socket->send_queue, req);
 477
 478         talloc_set_destructor(req, wrepl_request_destructor);
 479
 480         if (wrepl_socket->request_timeout > 0) {
 481                 req->te = event_add_timed(wrepl_socket->event_ctx, req,
 482                                           timeval_current_ofs(wrepl_socket->request_timeout, 0),
 483                                           wrepl_request_timeout_handler, req);
 484         }
 485
 486         EVENT_FD_WRITEABLE(wrepl_socket->fde);
 487
 488         return req;
 489
 490 failed:
 491         talloc_free(req);
 492         return NULL;
 493 }
 494
 495 /*
 496   receive a generic WINS replication reply
 497 */
 498 NTSTATUS wrepl_request_recv(struct wrepl_request *req,
 499                             TALLOC_CTX *mem_ctx,
 500                             struct wrepl_packet **packet)
 501 {
 502         NTSTATUS status = wrepl_request_wait(req);
 503         if (NT_STATUS_IS_OK(status)) {
 504                 *packet = talloc_steal(mem_ctx, req->packet);
 505         }
 506         talloc_free(req);
 507         return status;
 508 }
 509
 510 /*
 511   a full WINS replication request/response
 512 */
 513 NTSTATUS wrepl_request(struct wrepl_socket *wrepl_socket,
 514                        TALLOC_CTX *mem_ctx,
 515                        struct wrepl_packet *req_packet,
 516                        struct wrepl_packet **reply_packet)
 517 {
 518         struct wrepl_request *req = wrepl_request_send(wrepl_socket, req_packet);
 519         return wrepl_request_recv(req, mem_ctx, reply_packet);
 520 }
 521
 522
 523 /*
 524   setup an association - send
 525 */
 526 struct wrepl_request *wrepl_associate_send(struct wrepl_socket *wrepl_socket,
 527                                            struct wrepl_associate *io)
 528 {
 529         struct wrepl_packet *packet;
 530         struct wrepl_request *req;
 531
 532         packet = talloc_zero(wrepl_socket, struct wrepl_packet);
 533         if (packet == NULL) return NULL;
 534
 535         packet->opcode                      = WREPL_OPCODE_BITS;
 536         packet->mess_type                   = WREPL_START_ASSOCIATION;
 537         packet->message.start.minor_version = 2;
 538         packet->message.start.major_version = 5;
 539
 540         req = wrepl_request_send(wrepl_socket, packet);
 541
 542         talloc_free(packet);
 543
 544         return req;
 545 }
 546
 547 /*
 548   setup an association - recv
 549 */
 550 NTSTATUS wrepl_associate_recv(struct wrepl_request *req,
 551                               struct wrepl_associate *io)
 552 {
 553         struct wrepl_packet *packet=NULL;
 554         NTSTATUS status;
 555         status = wrepl_request_recv(req, req->wrepl_socket, &packet);
 556         NT_STATUS_NOT_OK_RETURN(status);
 557         if (packet->mess_type != WREPL_START_ASSOCIATION_REPLY) {
 558                 status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
 559         }
 560         if (NT_STATUS_IS_OK(status)) {
 561                 io->out.assoc_ctx = packet->message.start_reply.assoc_ctx;
 562         }
 563         talloc_free(packet);
 564         return status;
 565 }
 566
 567 /*
 568   setup an association - sync api
 569 */
 570 NTSTATUS wrepl_associate(struct wrepl_socket *wrepl_socket,
 571                          struct wrepl_associate *io)
 572 {
 573         struct wrepl_request *req = wrepl_associate_send(wrepl_socket, io);
 574         return wrepl_associate_recv(req, io);
 575 }
 576
 577
 578 /*
 579   fetch the partner tables - send
 580 */
 581 struct wrepl_request *wrepl_pull_table_send(struct wrepl_socket *wrepl_socket,
 582                                             struct wrepl_pull_table *io)
 583 {
 584         struct wrepl_packet *packet;
 585         struct wrepl_request *req;
 586
 587         packet = talloc_zero(wrepl_socket, struct wrepl_packet);
 588         if (packet == NULL) return NULL;
 589
 590         packet->opcode                      = WREPL_OPCODE_BITS;
 591         packet->assoc_ctx                   = io->in.assoc_ctx;
 592         packet->mess_type                   = WREPL_REPLICATION;
 593         packet->message.replication.command = WREPL_REPL_TABLE_QUERY;
 594
 595         req = wrepl_request_send(wrepl_socket, packet);
 596
 597         talloc_free(packet);
 598
 599         return req;
 600 }
 601
 602
 603 /*
 604   fetch the partner tables - recv
 605 */
 606 NTSTATUS wrepl_pull_table_recv(struct wrepl_request *req,
 607                                TALLOC_CTX *mem_ctx,
 608                                struct wrepl_pull_table *io)
 609 {
 610         struct wrepl_packet *packet=NULL;
 611         NTSTATUS status;
 612         struct wrepl_table *table;
 613         int i;
 614
 615         status = wrepl_request_recv(req, req->wrepl_socket, &packet);
 616         NT_STATUS_NOT_OK_RETURN(status);
 617         if (packet->mess_type != WREPL_REPLICATION) {
 618                 status = NT_STATUS_NETWORK_ACCESS_DENIED;
 619         } else if (packet->message.replication.command != WREPL_REPL_TABLE_REPLY) {
 620                 status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
 621         }
 622         if (!NT_STATUS_IS_OK(status)) goto failed;
 623
 624         table = &packet->message.replication.info.table;
 625         io->out.num_partners = table->partner_count;
 626         io->out.partners = talloc_steal(mem_ctx, table->partners);
 627         for (i=0;i<io->out.num_partners;i++) {
 628                 talloc_steal(io->out.partners, io->out.partners[i].address);
 629         }
 630
 631 failed:
 632         talloc_free(packet);
 633         return status;
 634 }
 635
 636
 637 /*
 638   fetch the partner table - sync api
 639 */
 640 NTSTATUS wrepl_pull_table(struct wrepl_socket *wrepl_socket,
 641                           TALLOC_CTX *mem_ctx,
 642                           struct wrepl_pull_table *io)
 643 {
 644         struct wrepl_request *req = wrepl_pull_table_send(wrepl_socket, io);
 645         return wrepl_pull_table_recv(req, mem_ctx, io);
 646 }
 647
 648
 649 /*
 650   fetch the names for a WINS partner - send
 651 */
 652 struct wrepl_request *wrepl_pull_names_send(struct wrepl_socket *wrepl_socket,
 653                                             struct wrepl_pull_names *io)
 654 {
 655         struct wrepl_packet *packet;
 656         struct wrepl_request *req;
 657
 658         packet = talloc_zero(wrepl_socket, struct wrepl_packet);
 659         if (packet == NULL) return NULL;
 660
 661         packet->opcode                         = WREPL_OPCODE_BITS;
 662         packet->assoc_ctx                      = io->in.assoc_ctx;
 663         packet->mess_type                      = WREPL_REPLICATION;
 664         packet->message.replication.command    = WREPL_REPL_SEND_REQUEST;
 665         packet->message.replication.info.owner = io->in.partner;
 666
 667         req = wrepl_request_send(wrepl_socket, packet);
 668
 669         talloc_free(packet);
 670
 671         return req;
 672 }
 673
 674 /*
 675   fetch the names for a WINS partner - recv
 676 */
 677 NTSTATUS wrepl_pull_names_recv(struct wrepl_request *req,
 678                                TALLOC_CTX *mem_ctx,
 679                                struct wrepl_pull_names *io)
 680 {
 681         struct wrepl_packet *packet=NULL;
 682         NTSTATUS status;
 683         int i;
 684
 685         status = wrepl_request_recv(req, req->wrepl_socket, &packet);
 686         NT_STATUS_NOT_OK_RETURN(status);
 687         if (packet->mess_type != WREPL_REPLICATION ||
 688             packet->message.replication.command != WREPL_REPL_SEND_REPLY) {
 689                 status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
 690         }
 691         if (!NT_STATUS_IS_OK(status)) goto failed;
 692
 693         io->out.num_names = packet->message.replication.info.reply.num_names;
 694
 695         status = NT_STATUS_NO_MEMORY;
 696
 697         io->out.names = talloc_array(packet, struct wrepl_name, io->out.num_names);
 698         if (io->out.names == NULL) goto nomem;
 699
 700         /* convert the list of names and addresses to a sane format */
 701         for (i=0;i<io->out.num_names;i++) {
 702                 struct wrepl_wins_name *wname = &packet->message.replication.info.reply.names[i];
 703                 struct wrepl_name *name = &io->out.names[i];
 704
 705                 name->name      = wname->name;
 706                 talloc_steal(io->out.names, wname->name.name);
 707                 talloc_steal(io->out.names, wname->name.scope);
 708                 name->type      = WREPL_NAME_TYPE(wname->flags);
 709                 name->state     = WREPL_NAME_STATE(wname->flags);
 710                 name->node      = WREPL_NBT_NODE(wname->flags);
 711                 name->is_static = WREPL_NAME_IS_STATIC(wname->flags);
 712                 name->raw_flags = wname->flags;
 713                 name->version_id= wname->id;
 714                 name->owner     = talloc_strdup(io->out.names, io->in.partner.address);
 715                 if (name->owner == NULL) goto nomem;
 716
 717                 /* trying to save 1 or 2 bytes on the wire isn't a good idea */
 718                 if (wname->flags & 2) {
 719                         int j;
 720
 721                         name->num_addresses = wname->addresses.addresses.num_ips;
 722                         name->addresses = talloc_array(io->out.names,
 723                                                        struct wrepl_address,
 724                                                        name->num_addresses);
 725                         if (name->addresses == NULL) goto nomem;
 726                         for (j=0;j<name->num_addresses;j++) {
 727                                 name->addresses[j].owner =
 728                                         talloc_steal(name->addresses,
 729                                                      wname->addresses.addresses.ips[j].owner);
 730                                 name->addresses[j].address =
 731                                         talloc_steal(name->addresses,
 732                                                      wname->addresses.addresses.ips[j].ip);
 733                         }
 734                 } else {
 735                         name->num_addresses = 1;
 736                         name->addresses = talloc(io->out.names, struct wrepl_address);
 737                         if (name->addresses == NULL) goto nomem;
 738                         name->addresses[0].owner = talloc_strdup(name->addresses,io->in.partner.address);
 739                         if (name->addresses[0].owner == NULL) goto nomem;
 740                         name->addresses[0].address = talloc_steal(name->addresses,
 741                                                                   wname->addresses.ip);
 742                 }
 743         }
 744
 745         talloc_steal(mem_ctx, io->out.names);
 746         talloc_free(packet);
 747         return NT_STATUS_OK;
 748 nomem:
 749         status = NT_STATUS_NO_MEMORY;
 750 failed:
 751         talloc_free(packet);
 752         return status;
 753 }
 754
 755
 756
 757 /*
 758   fetch the names for a WINS partner - sync api
 759 */
 760 NTSTATUS wrepl_pull_names(struct wrepl_socket *wrepl_socket,
 761                           TALLOC_CTX *mem_ctx,
 762                           struct wrepl_pull_names *io)
 763 {
 764         struct wrepl_request *req = wrepl_pull_names_send(wrepl_socket, io);
 765         return wrepl_pull_names_recv(req, mem_ctx, io);
 766 }