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 3 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, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "lib/events/events.h"
  24 #include "../lib/util/dlinklist.h"
  25 #include "lib/socket/socket.h"
  26 #include "libcli/wrepl/winsrepl.h"
  27 #include "librpc/gen_ndr/ndr_winsrepl.h"
  28 #include "lib/stream/packet.h"
  29 #include "libcli/composite/composite.h"
  30 #include "system/network.h"
  31 #include "lib/socket/netif.h"
  32 #include "param/param.h"
  33 #include "lib/util/tevent_ntstatus.h"
  34
  35 static struct wrepl_request *wrepl_request_finished(struct wrepl_request *req, NTSTATUS status);
  36
  37 /*
  38   mark all pending requests as dead - called when a socket error happens
  39 */
  40 static void wrepl_socket_dead(struct wrepl_socket *wrepl_socket, NTSTATUS status)
  41 {
  42         wrepl_socket->dead = true;
  43
  44         if (wrepl_socket->packet) {
  45                 packet_recv_disable(wrepl_socket->packet);
  46                 packet_set_fde(wrepl_socket->packet, NULL);
  47                 packet_set_socket(wrepl_socket->packet, NULL);
  48         }
  49
  50         if (wrepl_socket->event.fde) {
  51                 talloc_free(wrepl_socket->event.fde);
  52                 wrepl_socket->event.fde = NULL;
  53         }
  54
  55         if (wrepl_socket->sock) {
  56                 talloc_free(wrepl_socket->sock);
  57                 wrepl_socket->sock = NULL;
  58         }
  59
  60         if (NT_STATUS_EQUAL(NT_STATUS_UNSUCCESSFUL, status)) {
  61                 status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
  62         }
  63         while (wrepl_socket->recv_queue) {
  64                 struct wrepl_request *req = wrepl_socket->recv_queue;
  65                 DLIST_REMOVE(wrepl_socket->recv_queue, req);
  66                 wrepl_request_finished(req, status);
  67         }
  68
  69         talloc_set_destructor(wrepl_socket, NULL);
  70         if (wrepl_socket->free_skipped) {
  71                 talloc_free(wrepl_socket);
  72         }
  73 }
  74
  75 static void wrepl_request_timeout_handler(struct tevent_context *ev, struct tevent_timer *te,
  76                                           struct timeval t, void *ptr)
  77 {
  78         struct wrepl_request *req = talloc_get_type(ptr, struct wrepl_request);
  79         wrepl_socket_dead(req->wrepl_socket, NT_STATUS_IO_TIMEOUT);
  80 }
  81
  82 /*
  83   handle recv events
  84 */
  85 static NTSTATUS wrepl_finish_recv(void *private_data, DATA_BLOB packet_blob_in)
  86 {
  87         struct wrepl_socket *wrepl_socket = talloc_get_type(private_data, struct wrepl_socket);
  88         struct wrepl_request *req = wrepl_socket->recv_queue;
  89         DATA_BLOB blob;
  90         enum ndr_err_code ndr_err;
  91
  92         if (!req) {
  93                 DEBUG(1,("Received unexpected WINS packet of length %u!\n",
  94                          (unsigned)packet_blob_in.length));
  95                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
  96         }
  97
  98         req->packet = talloc(req, struct wrepl_packet);
  99         NT_STATUS_HAVE_NO_MEMORY(req->packet);
 100
 101         blob.data = packet_blob_in.data + 4;
 102         blob.length = packet_blob_in.length - 4;
 103
 104         /* we have a full request - parse it */
 105         ndr_err = ndr_pull_struct_blob(&blob, req->packet, wrepl_socket->iconv_convenience, req->packet,
 106                                        (ndr_pull_flags_fn_t)ndr_pull_wrepl_packet);
 107         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 108                 NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
 109                 wrepl_request_finished(req, status);
 110                 return NT_STATUS_OK;
 111         }
 112
 113         if (DEBUGLVL(10)) {
 114                 DEBUG(10,("Received WINS packet of length %u\n",
 115                           (unsigned)packet_blob_in.length));
 116                 NDR_PRINT_DEBUG(wrepl_packet, req->packet);
 117         }
 118
 119         wrepl_request_finished(req, NT_STATUS_OK);
 120         return NT_STATUS_OK;
 121 }
 122
 123 /*
 124   handler for winrepl events
 125 */
 126 static void wrepl_handler(struct tevent_context *ev, struct tevent_fd *fde,
 127                           uint16_t flags, void *private_data)
 128 {
 129         struct wrepl_socket *wrepl_socket = talloc_get_type(private_data,
 130                                                             struct wrepl_socket);
 131         if (flags & EVENT_FD_READ) {
 132                 packet_recv(wrepl_socket->packet);
 133                 return;
 134         }
 135         if (flags & EVENT_FD_WRITE) {
 136                 packet_queue_run(wrepl_socket->packet);
 137         }
 138 }
 139
 140 static void wrepl_error(void *private_data, NTSTATUS status)
 141 {
 142         struct wrepl_socket *wrepl_socket = talloc_get_type(private_data,
 143                                                             struct wrepl_socket);
 144         wrepl_socket_dead(wrepl_socket, status);
 145 }
 146
 147
 148 /*
 149   destroy a wrepl_socket destructor
 150 */
 151 static int wrepl_socket_destructor(struct wrepl_socket *sock)
 152 {
 153         if (sock->dead) {
 154                 sock->free_skipped = true;
 155                 return -1;
 156         }
 157         wrepl_socket_dead(sock, NT_STATUS_LOCAL_DISCONNECT);
 158         return 0;
 159 }
 160
 161 /*
 162   initialise a wrepl_socket. The event_ctx is optional, if provided then
 163   operations will use that event context
 164 */
 165 struct wrepl_socket *wrepl_socket_init(TALLOC_CTX *mem_ctx,
 166                                        struct tevent_context *event_ctx,
 167                                        struct smb_iconv_convenience *iconv_convenience)
 168 {
 169         struct wrepl_socket *wrepl_socket;
 170         NTSTATUS status;
 171
 172         wrepl_socket = talloc_zero(mem_ctx, struct wrepl_socket);
 173         if (!wrepl_socket) return NULL;
 174
 175         wrepl_socket->event.ctx = event_ctx;
 176         if (!wrepl_socket->event.ctx) goto failed;
 177
 178         wrepl_socket->iconv_convenience = iconv_convenience;
 179
 180         status = socket_create("ip", SOCKET_TYPE_STREAM, &wrepl_socket->sock, 0);
 181         if (!NT_STATUS_IS_OK(status)) goto failed;
 182
 183         talloc_steal(wrepl_socket, wrepl_socket->sock);
 184
 185         wrepl_socket->request_timeout   = WREPL_SOCKET_REQUEST_TIMEOUT;
 186
 187         talloc_set_destructor(wrepl_socket, wrepl_socket_destructor);
 188
 189         return wrepl_socket;
 190
 191 failed:
 192         talloc_free(wrepl_socket);
 193         return NULL;
 194 }
 195
 196 /*
 197   initialise a wrepl_socket from an already existing connection
 198 */
 199 struct wrepl_socket *wrepl_socket_merge(TALLOC_CTX *mem_ctx,
 200                                         struct tevent_context *event_ctx,
 201                                         struct socket_context *sock,
 202                                         struct packet_context *pack)
 203 {
 204         struct wrepl_socket *wrepl_socket;
 205
 206         wrepl_socket = talloc_zero(mem_ctx, struct wrepl_socket);
 207         if (wrepl_socket == NULL) goto failed;
 208
 209         wrepl_socket->event.ctx = event_ctx;
 210         if (wrepl_socket->event.ctx == NULL) goto failed;
 211
 212         wrepl_socket->sock = sock;
 213         talloc_steal(wrepl_socket, wrepl_socket->sock);
 214
 215
 216         wrepl_socket->request_timeout   = WREPL_SOCKET_REQUEST_TIMEOUT;
 217
 218         wrepl_socket->event.fde = event_add_fd(wrepl_socket->event.ctx, wrepl_socket,
 219                                                socket_get_fd(wrepl_socket->sock),
 220                                                EVENT_FD_READ,
 221                                                wrepl_handler, wrepl_socket);
 222         if (wrepl_socket->event.fde == NULL) {
 223                 goto failed;
 224         }
 225
 226         wrepl_socket->packet = pack;
 227         talloc_steal(wrepl_socket, wrepl_socket->packet);
 228         packet_set_private(wrepl_socket->packet, wrepl_socket);
 229         packet_set_socket(wrepl_socket->packet, wrepl_socket->sock);
 230         packet_set_callback(wrepl_socket->packet, wrepl_finish_recv);
 231         packet_set_full_request(wrepl_socket->packet, packet_full_request_u32);
 232         packet_set_error_handler(wrepl_socket->packet, wrepl_error);
 233         packet_set_event_context(wrepl_socket->packet, wrepl_socket->event.ctx);
 234         packet_set_fde(wrepl_socket->packet, wrepl_socket->event.fde);
 235         packet_set_serialise(wrepl_socket->packet);
 236
 237         talloc_set_destructor(wrepl_socket, wrepl_socket_destructor);
 238
 239         return wrepl_socket;
 240
 241 failed:
 242         talloc_free(wrepl_socket);
 243         return NULL;
 244 }
 245
 246 /*
 247   destroy a wrepl_request
 248 */
 249 static int wrepl_request_destructor(struct wrepl_request *req)
 250 {
 251         if (req->state == WREPL_REQUEST_RECV) {
 252                 DLIST_REMOVE(req->wrepl_socket->recv_queue, req);
 253         }
 254         req->state = WREPL_REQUEST_ERROR;
 255         return 0;
 256 }
 257
 258 /*
 259   wait for a request to complete
 260 */
 261 static NTSTATUS wrepl_request_wait(struct wrepl_request *req)
 262 {
 263         NT_STATUS_HAVE_NO_MEMORY(req);
 264         while (req->state < WREPL_REQUEST_DONE) {
 265                 event_loop_once(req->wrepl_socket->event.ctx);
 266         }
 267         return req->status;
 268 }
 269
 270 const char *wrepl_best_ip(struct loadparm_context *lp_ctx, const char *peer_ip)
 271 {
 272         struct interface *ifaces;
 273         load_interfaces(lp_ctx, lp_interfaces(lp_ctx), &ifaces);
 274         return iface_best_ip(ifaces, peer_ip);
 275 }
 276
 277 struct wrepl_connect_state {
 278         struct wrepl_socket *wrepl_socket;
 279 };
 280
 281 static void wrepl_connect_handler(struct composite_context *creq);
 282
 283 struct tevent_req *wrepl_connect_send(TALLOC_CTX *mem_ctx,
 284                                       struct tevent_context *ev,
 285                                       struct wrepl_socket *wrepl_socket,
 286                                       const char *our_ip, const char *peer_ip)
 287 {
 288         struct tevent_req *req;
 289         struct wrepl_connect_state *state;
 290         struct composite_context *subreq;
 291         struct socket_address *peer, *us;
 292
 293         req = tevent_req_create(mem_ctx, &state,
 294                                 struct wrepl_connect_state);
 295         if (req == NULL) {
 296                 return NULL;
 297         }
 298
 299         state->wrepl_socket     = wrepl_socket;
 300
 301         us = socket_address_from_strings(state, wrepl_socket->sock->backend_name,
 302                                          our_ip, 0);
 303         if (tevent_req_nomem(us, req)) {
 304                 return tevent_req_post(req, ev);
 305         }
 306
 307         peer = socket_address_from_strings(state, wrepl_socket->sock->backend_name,
 308                                            peer_ip, WINS_REPLICATION_PORT);
 309         if (tevent_req_nomem(peer, req)) {
 310                 return tevent_req_post(req, ev);
 311         }
 312
 313         subreq = socket_connect_send(wrepl_socket->sock, us, peer,
 314                                      0, wrepl_socket->event.ctx);
 315         if (tevent_req_nomem(subreq, req)) {
 316                 return tevent_req_post(req, ev);
 317         }
 318
 319         subreq->async.fn = wrepl_connect_handler;
 320         subreq->async.private_data = req;
 321
 322         return req;
 323 }
 324
 325 static void wrepl_connect_handler(struct composite_context *subreq)
 326 {
 327         struct tevent_req *req = talloc_get_type_abort(subreq->async.private_data,
 328                                  struct tevent_req);
 329         struct wrepl_connect_state *state = tevent_req_data(req,
 330                                             struct wrepl_connect_state);
 331         struct wrepl_socket *wrepl_socket = state->wrepl_socket;
 332         NTSTATUS status;
 333
 334         status = socket_connect_recv(subreq);
 335         if (!NT_STATUS_IS_OK(status)) {
 336                 tevent_req_nterror(req, status);
 337                 return;
 338         }
 339
 340         wrepl_socket->event.fde = event_add_fd(wrepl_socket->event.ctx, wrepl_socket,
 341                                                socket_get_fd(wrepl_socket->sock),
 342                                                EVENT_FD_READ,
 343                                                wrepl_handler, wrepl_socket);
 344         if (tevent_req_nomem(wrepl_socket->event.fde, req)) {
 345                 return;
 346         }
 347
 348         /* setup the stream -> packet parser */
 349         wrepl_socket->packet = packet_init(wrepl_socket);
 350         if (tevent_req_nomem(wrepl_socket->packet, req)) {
 351                 return;
 352         }
 353         packet_set_private(wrepl_socket->packet, wrepl_socket);
 354         packet_set_socket(wrepl_socket->packet, wrepl_socket->sock);
 355         packet_set_callback(wrepl_socket->packet, wrepl_finish_recv);
 356         packet_set_full_request(wrepl_socket->packet, packet_full_request_u32);
 357         packet_set_error_handler(wrepl_socket->packet, wrepl_error);
 358         packet_set_event_context(wrepl_socket->packet, wrepl_socket->event.ctx);
 359         packet_set_fde(wrepl_socket->packet, wrepl_socket->event.fde);
 360         packet_set_serialise(wrepl_socket->packet);
 361
 362         tevent_req_done(req);
 363 }
 364
 365 /*
 366   connect a wrepl_socket to a WINS server - recv side
 367 */
 368 NTSTATUS wrepl_connect_recv(struct tevent_req *req)
 369 {
 370         struct wrepl_connect_state *state = tevent_req_data(req,
 371                                             struct wrepl_connect_state);
 372         struct wrepl_socket *wrepl_socket = state->wrepl_socket;
 373         NTSTATUS status;
 374
 375         if (tevent_req_is_nterror(req, &status)) {
 376                 wrepl_socket_dead(wrepl_socket, status);
 377                 tevent_req_received(req);
 378                 return status;
 379         }
 380
 381         tevent_req_received(req);
 382         return NT_STATUS_OK;
 383 }
 384
 385 /*
 386   connect a wrepl_socket to a WINS server - sync API
 387 */
 388 NTSTATUS wrepl_connect(struct wrepl_socket *wrepl_socket,
 389                        const char *our_ip, const char *peer_ip)
 390 {
 391         struct tevent_req *subreq;
 392         bool ok;
 393         NTSTATUS status;
 394
 395         subreq = wrepl_connect_send(wrepl_socket, wrepl_socket->event.ctx,
 396                                     wrepl_socket, our_ip, peer_ip);
 397         NT_STATUS_HAVE_NO_MEMORY(subreq);
 398
 399         ok = tevent_req_poll(subreq, wrepl_socket->event.ctx);
 400         if (!ok) {
 401                 TALLOC_FREE(subreq);
 402                 return NT_STATUS_INTERNAL_ERROR;
 403         }
 404
 405         status = wrepl_connect_recv(subreq);
 406         TALLOC_FREE(subreq);
 407         NT_STATUS_NOT_OK_RETURN(status);
 408
 409         return NT_STATUS_OK;
 410 }
 411
 412 /*
 413    callback from wrepl_request_trigger()
 414 */
 415 static void wrepl_request_trigger_handler(struct tevent_context *ev, struct tevent_timer *te,
 416                                           struct timeval t, void *ptr)
 417 {
 418         struct wrepl_request *req = talloc_get_type(ptr, struct wrepl_request);
 419         if (req->async.fn) {
 420                 req->async.fn(req);
 421         }
 422 }
 423
 424 /*
 425   trigger an immediate event on a wrepl_request
 426   the return value should only be used in wrepl_request_send()
 427   this is the only place where req->trigger is true
 428 */
 429 static struct wrepl_request *wrepl_request_finished(struct wrepl_request *req, NTSTATUS status)
 430 {
 431         struct tevent_timer *te;
 432
 433         if (req->state == WREPL_REQUEST_RECV) {
 434                 DLIST_REMOVE(req->wrepl_socket->recv_queue, req);
 435         }
 436
 437         if (!NT_STATUS_IS_OK(status)) {
 438                 req->state      = WREPL_REQUEST_ERROR;
 439         } else {
 440                 req->state      = WREPL_REQUEST_DONE;
 441         }
 442
 443         req->status     = status;
 444
 445         if (req->trigger) {
 446                 req->trigger = false;
 447                 /* a zero timeout means immediate */
 448                 te = event_add_timed(req->wrepl_socket->event.ctx,
 449                                      req, timeval_zero(),
 450                                      wrepl_request_trigger_handler, req);
 451                 if (!te) {
 452                         talloc_free(req);
 453                         return NULL;
 454                 }
 455                 return req;
 456         }
 457
 458         if (req->async.fn) {
 459                 req->async.fn(req);
 460         }
 461         return NULL;
 462 }
 463
 464 struct wrepl_send_ctrl_state {
 465         struct wrepl_send_ctrl ctrl;
 466         struct wrepl_request *req;
 467         struct wrepl_socket *wrepl_sock;
 468 };
 469
 470 static int wrepl_send_ctrl_destructor(struct wrepl_send_ctrl_state *s)
 471 {
 472         struct wrepl_request *req = s->wrepl_sock->recv_queue;
 473
 474         /* check if the request is still in WREPL_STATE_RECV,
 475          * we need this here because the caller has may called
 476          * talloc_free(req) and wrepl_send_ctrl_state isn't
 477          * a talloc child of the request, so our s->req pointer
 478          * is maybe invalid!
 479          */
 480         for (; req; req = req->next) {
 481                 if (req == s->req) break;
 482         }
 483         if (!req) return 0;
 484
 485         /* here, we need to make sure the async request handler is called
 486          * later in the next event_loop and now now
 487          */
 488         req->trigger = true;
 489         wrepl_request_finished(req, NT_STATUS_OK);
 490
 491         if (s->ctrl.disconnect_after_send) {
 492                 wrepl_socket_dead(s->wrepl_sock, NT_STATUS_LOCAL_DISCONNECT);
 493         }
 494
 495         return 0;
 496 }
 497
 498 /*
 499   send a generic wins replication request
 500 */
 501 struct wrepl_request *wrepl_request_send(struct wrepl_socket *wrepl_socket,
 502                                          struct wrepl_packet *packet,
 503                                          struct wrepl_send_ctrl *ctrl)
 504 {
 505         struct wrepl_request *req;
 506         struct wrepl_wrap wrap;
 507         DATA_BLOB blob;
 508         NTSTATUS status;
 509         enum ndr_err_code ndr_err;
 510
 511         req = talloc_zero(wrepl_socket, struct wrepl_request);
 512         if (!req) return NULL;
 513         req->wrepl_socket = wrepl_socket;
 514         req->state        = WREPL_REQUEST_RECV;
 515         req->trigger      = true;
 516
 517         DLIST_ADD_END(wrepl_socket->recv_queue, req, struct wrepl_request *);
 518         talloc_set_destructor(req, wrepl_request_destructor);
 519
 520         if (wrepl_socket->dead) {
 521                 return wrepl_request_finished(req, NT_STATUS_INVALID_CONNECTION);
 522         }
 523
 524         wrap.packet = *packet;
 525         ndr_err = ndr_push_struct_blob(&blob, req, wrepl_socket->iconv_convenience, &wrap,
 526                                        (ndr_push_flags_fn_t)ndr_push_wrepl_wrap);
 527         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 528                 status = ndr_map_error2ntstatus(ndr_err);
 529                 return wrepl_request_finished(req, status);
 530         }
 531
 532         if (DEBUGLVL(10)) {
 533                 DEBUG(10,("Sending WINS packet of length %u\n",
 534                           (unsigned)blob.length));
 535                 NDR_PRINT_DEBUG(wrepl_packet, &wrap.packet);
 536         }
 537
 538         if (wrepl_socket->request_timeout > 0) {
 539                 req->te = event_add_timed(wrepl_socket->event.ctx, req,
 540                                           timeval_current_ofs(wrepl_socket->request_timeout, 0),
 541                                           wrepl_request_timeout_handler, req);
 542                 if (!req->te) return wrepl_request_finished(req, NT_STATUS_NO_MEMORY);
 543         }
 544
 545         if (ctrl && (ctrl->send_only || ctrl->disconnect_after_send)) {
 546                 struct wrepl_send_ctrl_state *s = talloc(blob.data, struct wrepl_send_ctrl_state);
 547                 if (!s) return wrepl_request_finished(req, NT_STATUS_NO_MEMORY);
 548                 s->ctrl         = *ctrl;
 549                 s->req          = req;
 550                 s->wrepl_sock   = wrepl_socket;
 551                 talloc_set_destructor(s, wrepl_send_ctrl_destructor);
 552         }
 553
 554         status = packet_send(wrepl_socket->packet, blob);
 555         if (!NT_STATUS_IS_OK(status)) {
 556                 return wrepl_request_finished(req, status);
 557         }
 558
 559         req->trigger = false;
 560         return req;
 561 }
 562
 563 /*
 564   receive a generic WINS replication reply
 565 */
 566 NTSTATUS wrepl_request_recv(struct wrepl_request *req,
 567                             TALLOC_CTX *mem_ctx,
 568                             struct wrepl_packet **packet)
 569 {
 570         NTSTATUS status = wrepl_request_wait(req);
 571         if (NT_STATUS_IS_OK(status) && packet) {
 572                 *packet = talloc_steal(mem_ctx, req->packet);
 573         }
 574         talloc_free(req);
 575         return status;
 576 }
 577
 578 /*
 579   a full WINS replication request/response
 580 */
 581 NTSTATUS wrepl_request(struct wrepl_socket *wrepl_socket,
 582                        TALLOC_CTX *mem_ctx,
 583                        struct wrepl_packet *req_packet,
 584                        struct wrepl_packet **reply_packet)
 585 {
 586         struct wrepl_request *req = wrepl_request_send(wrepl_socket, req_packet, NULL);
 587         return wrepl_request_recv(req, mem_ctx, reply_packet);
 588 }
 589
 590
 591 struct wrepl_associate_state {
 592         struct wrepl_packet packet;
 593         uint32_t assoc_ctx;
 594         uint16_t major_version;
 595 };
 596
 597 static void wrepl_associate_done(struct wrepl_request *subreq);
 598
 599 struct tevent_req *wrepl_associate_send(TALLOC_CTX *mem_ctx,
 600                                         struct tevent_context *ev,
 601                                         struct wrepl_socket *wrepl_socket,
 602                                         const struct wrepl_associate *io)
 603 {
 604         struct tevent_req *req;
 605         struct wrepl_associate_state *state;
 606         struct wrepl_request *subreq;
 607
 608         if (wrepl_socket->event.ctx != ev) {
 609                 /* TODO: remove wrepl_socket->event.ctx !!! */
 610                 smb_panic("wrepl_associate_send event context mismatch!");
 611                 return NULL;
 612         }
 613
 614         req = tevent_req_create(mem_ctx, &state,
 615                                 struct wrepl_associate_state);
 616         if (req == NULL) {
 617                 return NULL;
 618         };
 619
 620         state->packet.opcode                            = WREPL_OPCODE_BITS;
 621         state->packet.mess_type                         = WREPL_START_ASSOCIATION;
 622         state->packet.message.start.minor_version       = 2;
 623         state->packet.message.start.major_version       = 5;
 624
 625         /*
 626          * nt4 uses 41 bytes for the start_association call
 627          * so do it the same and as we don't know th emeanings of this bytes
 628          * we just send zeros and nt4, w2k and w2k3 seems to be happy with this
 629          *
 630          * if we don't do this nt4 uses an old version of the wins replication protocol
 631          * and that would break nt4 <-> samba replication
 632          */
 633         state->packet.padding   = data_blob_talloc(state, NULL, 21);
 634         if (tevent_req_nomem(state->packet.padding.data, req)) {
 635                 return tevent_req_post(req, ev);
 636         }
 637         memset(state->packet.padding.data, 0, state->packet.padding.length);
 638
 639         subreq = wrepl_request_send(wrepl_socket, &state->packet, NULL);
 640         if (tevent_req_nomem(subreq, req)) {
 641                 return tevent_req_post(req, ev);
 642         }
 643         subreq->async.fn = wrepl_associate_done;
 644         subreq->async.private_data = req;
 645
 646         return req;
 647 }
 648
 649 static void wrepl_associate_done(struct wrepl_request *subreq)
 650 {
 651         struct tevent_req *req = talloc_get_type_abort(subreq->async.private_data,
 652                                  struct tevent_req);
 653         struct wrepl_associate_state *state = tevent_req_data(req,
 654                                               struct wrepl_associate_state);
 655         NTSTATUS status;
 656         struct wrepl_packet *packet;
 657
 658         status = wrepl_request_recv(subreq, state, &packet);
 659         if (!NT_STATUS_IS_OK(status)) {
 660                 tevent_req_nterror(req, status);
 661                 return;
 662         }
 663
 664         if (packet->mess_type != WREPL_START_ASSOCIATION_REPLY) {
 665                 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
 666                 return;
 667         }
 668
 669         state->assoc_ctx = packet->message.start_reply.assoc_ctx;
 670         state->major_version = packet->message.start_reply.major_version;
 671
 672         tevent_req_done(req);
 673 }
 674
 675 /*
 676   setup an association - recv
 677 */
 678 NTSTATUS wrepl_associate_recv(struct tevent_req *req,
 679                               struct wrepl_associate *io)
 680 {
 681         struct wrepl_associate_state *state = tevent_req_data(req,
 682                                               struct wrepl_associate_state);
 683         NTSTATUS status;
 684
 685         if (tevent_req_is_nterror(req, &status)) {
 686                 tevent_req_received(req);
 687                 return status;
 688         }
 689
 690         io->out.assoc_ctx = state->assoc_ctx;
 691         io->out.major_version = state->major_version;
 692
 693         tevent_req_received(req);
 694         return NT_STATUS_OK;
 695 }
 696
 697 /*
 698   setup an association - sync api
 699 */
 700 NTSTATUS wrepl_associate(struct wrepl_socket *wrepl_socket,
 701                          struct wrepl_associate *io)
 702 {
 703         struct tevent_req *subreq;
 704         bool ok;
 705         NTSTATUS status;
 706
 707         subreq = wrepl_associate_send(wrepl_socket, wrepl_socket->event.ctx,
 708                                       wrepl_socket, io);
 709         NT_STATUS_HAVE_NO_MEMORY(subreq);
 710
 711         ok = tevent_req_poll(subreq, wrepl_socket->event.ctx);
 712         if (!ok) {
 713                 TALLOC_FREE(subreq);
 714                 return NT_STATUS_INTERNAL_ERROR;
 715         }
 716
 717         status = wrepl_associate_recv(subreq, io);
 718         TALLOC_FREE(subreq);
 719         NT_STATUS_NOT_OK_RETURN(status);
 720
 721         return NT_STATUS_OK;
 722 }
 723
 724 /*
 725   stop an association - send
 726 */
 727 struct wrepl_request *wrepl_associate_stop_send(struct wrepl_socket *wrepl_socket,
 728                                                 struct wrepl_associate_stop *io)
 729 {
 730         struct wrepl_packet *packet;
 731         struct wrepl_request *req;
 732         struct wrepl_send_ctrl ctrl;
 733
 734         packet = talloc_zero(wrepl_socket, struct wrepl_packet);
 735         if (packet == NULL) return NULL;
 736
 737         packet->opcode                  = WREPL_OPCODE_BITS;
 738         packet->assoc_ctx               = io->in.assoc_ctx;
 739         packet->mess_type               = WREPL_STOP_ASSOCIATION;
 740         packet->message.stop.reason     = io->in.reason;
 741
 742         ZERO_STRUCT(ctrl);
 743         if (io->in.reason == 0) {
 744                 ctrl.send_only                  = true;
 745                 ctrl.disconnect_after_send      = true;
 746         }
 747
 748         req = wrepl_request_send(wrepl_socket, packet, &ctrl);
 749
 750         talloc_free(packet);
 751
 752         return req;
 753 }
 754
 755 /*
 756   stop an association - recv
 757 */
 758 NTSTATUS wrepl_associate_stop_recv(struct wrepl_request *req,
 759                                    struct wrepl_associate_stop *io)
 760 {
 761         struct wrepl_packet *packet=NULL;
 762         NTSTATUS status;
 763         status = wrepl_request_recv(req, req->wrepl_socket, &packet);
 764         NT_STATUS_NOT_OK_RETURN(status);
 765         talloc_free(packet);
 766         return status;
 767 }
 768
 769 /*
 770   setup an association - sync api
 771 */
 772 NTSTATUS wrepl_associate_stop(struct wrepl_socket *wrepl_socket,
 773                               struct wrepl_associate_stop *io)
 774 {
 775         struct wrepl_request *req = wrepl_associate_stop_send(wrepl_socket, io);
 776         return wrepl_associate_stop_recv(req, io);
 777 }
 778
 779 struct wrepl_pull_table_state {
 780         struct wrepl_packet packet;
 781         uint32_t num_partners;
 782         struct wrepl_wins_owner *partners;
 783 };
 784
 785 static void wrepl_pull_table_done(struct wrepl_request *subreq);
 786
 787 struct tevent_req *wrepl_pull_table_send(TALLOC_CTX *mem_ctx,
 788                                          struct tevent_context *ev,
 789                                          struct wrepl_socket *wrepl_socket,
 790                                          const struct wrepl_pull_table *io)
 791 {
 792         struct tevent_req *req;
 793         struct wrepl_pull_table_state *state;
 794         struct wrepl_request *subreq;
 795
 796         if (wrepl_socket->event.ctx != ev) {
 797                 /* TODO: remove wrepl_socket->event.ctx !!! */
 798                 smb_panic("wrepl_pull_table_send event context mismatch!");
 799                 return NULL;
 800         }
 801
 802         req = tevent_req_create(mem_ctx, &state,
 803                                 struct wrepl_pull_table_state);
 804         if (req == NULL) {
 805                 return NULL;
 806         };
 807
 808         state->packet.opcode                            = WREPL_OPCODE_BITS;
 809         state->packet.assoc_ctx                         = io->in.assoc_ctx;
 810         state->packet.mess_type                         = WREPL_REPLICATION;
 811         state->packet.message.replication.command       = WREPL_REPL_TABLE_QUERY;
 812
 813         subreq = wrepl_request_send(wrepl_socket, &state->packet, NULL);
 814         if (tevent_req_nomem(subreq, req)) {
 815                 return tevent_req_post(req, ev);
 816         }
 817         subreq->async.fn = wrepl_pull_table_done;
 818         subreq->async.private_data = req;
 819
 820         return req;
 821 }
 822
 823 static void wrepl_pull_table_done(struct wrepl_request *subreq)
 824 {
 825         struct tevent_req *req = talloc_get_type_abort(subreq->async.private_data,
 826                                  struct tevent_req);
 827         struct wrepl_pull_table_state *state = tevent_req_data(req,
 828                                                struct wrepl_pull_table_state);
 829         NTSTATUS status;
 830         struct wrepl_packet *packet;
 831         struct wrepl_table *table;
 832
 833         status = wrepl_request_recv(subreq, state, &packet);
 834         if (!NT_STATUS_IS_OK(status)) {
 835                 tevent_req_nterror(req, status);
 836                 return;
 837         }
 838
 839         if (packet->mess_type != WREPL_REPLICATION) {
 840                 tevent_req_nterror(req, NT_STATUS_NETWORK_ACCESS_DENIED);
 841                 return;
 842         }
 843
 844         if (packet->message.replication.command != WREPL_REPL_TABLE_REPLY) {
 845                 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
 846                 return;
 847         }
 848
 849         table = &packet->message.replication.info.table;
 850
 851         state->num_partners = table->partner_count;
 852         state->partners = talloc_move(state, &table->partners);
 853
 854         tevent_req_done(req);
 855 }
 856
 857 /*
 858   fetch the partner tables - recv
 859 */
 860 NTSTATUS wrepl_pull_table_recv(struct tevent_req *req,
 861                                TALLOC_CTX *mem_ctx,
 862                                struct wrepl_pull_table *io)
 863 {
 864         struct wrepl_pull_table_state *state = tevent_req_data(req,
 865                                                struct wrepl_pull_table_state);
 866         NTSTATUS status;
 867
 868         if (tevent_req_is_nterror(req, &status)) {
 869                 tevent_req_received(req);
 870                 return status;
 871         }
 872
 873         io->out.num_partners = state->num_partners;
 874         io->out.partners = talloc_move(mem_ctx, &state->partners);
 875
 876         tevent_req_received(req);
 877         return NT_STATUS_OK;
 878 }
 879
 880 /*
 881   fetch the partner table - sync api
 882 */
 883 NTSTATUS wrepl_pull_table(struct wrepl_socket *wrepl_socket,
 884                           TALLOC_CTX *mem_ctx,
 885                           struct wrepl_pull_table *io)
 886 {
 887         struct tevent_req *subreq;
 888         bool ok;
 889         NTSTATUS status;
 890
 891         subreq = wrepl_pull_table_send(mem_ctx, wrepl_socket->event.ctx,
 892                                        wrepl_socket, io);
 893         NT_STATUS_HAVE_NO_MEMORY(subreq);
 894
 895         ok = tevent_req_poll(subreq, wrepl_socket->event.ctx);
 896         if (!ok) {
 897                 TALLOC_FREE(subreq);
 898                 return NT_STATUS_INTERNAL_ERROR;
 899         }
 900
 901         status = wrepl_pull_table_recv(subreq, mem_ctx, io);
 902         TALLOC_FREE(subreq);
 903         NT_STATUS_NOT_OK_RETURN(status);
 904
 905         return NT_STATUS_OK;
 906 }
 907
 908
 909 struct wrepl_pull_names_state {
 910         struct {
 911                 const struct wrepl_pull_names *io;
 912         } caller;
 913         struct wrepl_packet packet;
 914         uint32_t num_names;
 915         struct wrepl_name *names;
 916 };
 917
 918 static void wrepl_pull_names_done(struct wrepl_request *subreq);
 919
 920 struct tevent_req *wrepl_pull_names_send(TALLOC_CTX *mem_ctx,
 921                                          struct tevent_context *ev,
 922                                          struct wrepl_socket *wrepl_socket,
 923                                          const struct wrepl_pull_names *io)
 924 {
 925         struct tevent_req *req;
 926         struct wrepl_pull_names_state *state;
 927         struct wrepl_request *subreq;
 928
 929         if (wrepl_socket->event.ctx != ev) {
 930                 /* TODO: remove wrepl_socket->event.ctx !!! */
 931                 smb_panic("wrepl_pull_names_send event context mismatch!");
 932                 return NULL;
 933         }
 934
 935         req = tevent_req_create(mem_ctx, &state,
 936                                 struct wrepl_pull_names_state);
 937         if (req == NULL) {
 938                 return NULL;
 939         };
 940         state->caller.io = io;
 941
 942         state->packet.opcode                            = WREPL_OPCODE_BITS;
 943         state->packet.assoc_ctx                         = io->in.assoc_ctx;
 944         state->packet.mess_type                         = WREPL_REPLICATION;
 945         state->packet.message.replication.command       = WREPL_REPL_SEND_REQUEST;
 946         state->packet.message.replication.info.owner    = io->in.partner;
 947
 948         subreq = wrepl_request_send(wrepl_socket, &state->packet, NULL);
 949         if (tevent_req_nomem(subreq, req)) {
 950                 return tevent_req_post(req, ev);
 951         }
 952         subreq->async.fn = wrepl_pull_names_done;
 953         subreq->async.private_data = req;
 954
 955         return req;
 956 }
 957
 958 static void wrepl_pull_names_done(struct wrepl_request *subreq)
 959 {
 960         struct tevent_req *req = talloc_get_type_abort(subreq->async.private_data,
 961                                  struct tevent_req);
 962         struct wrepl_pull_names_state *state = tevent_req_data(req,
 963                                                struct wrepl_pull_names_state);
 964         NTSTATUS status;
 965         struct wrepl_packet *packet;
 966         uint32_t i;
 967
 968         status = wrepl_request_recv(subreq, state, &packet);
 969         if (!NT_STATUS_IS_OK(status)) {
 970                 tevent_req_nterror(req, status);
 971                 return;
 972         }
 973
 974         if (packet->mess_type != WREPL_REPLICATION) {
 975                 tevent_req_nterror(req, NT_STATUS_NETWORK_ACCESS_DENIED);
 976                 return;
 977         }
 978
 979         if (packet->message.replication.command != WREPL_REPL_SEND_REPLY) {
 980                 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
 981                 return;
 982         }
 983
 984         state->num_names = packet->message.replication.info.reply.num_names;
 985
 986         state->names = talloc_array(state, struct wrepl_name, state->num_names);
 987         if (tevent_req_nomem(state->names, req)) {
 988                 return;
 989         }
 990
 991         /* convert the list of names and addresses to a sane format */
 992         for (i=0; i < state->num_names; i++) {
 993                 struct wrepl_wins_name *wname = &packet->message.replication.info.reply.names[i];
 994                 struct wrepl_name *name = &state->names[i];
 995
 996                 name->name      = *wname->name;
 997                 talloc_steal(state->names, wname->name);
 998                 name->type      = WREPL_NAME_TYPE(wname->flags);
 999                 name->state     = WREPL_NAME_STATE(wname->flags);
1000                 name->node      = WREPL_NAME_NODE(wname->flags);
1001                 name->is_static = WREPL_NAME_IS_STATIC(wname->flags);
1002                 name->raw_flags = wname->flags;
1003                 name->version_id= wname->id;
1004                 name->owner     = talloc_strdup(state->names,
1005                                                 state->caller.io->in.partner.address);
1006                 if (tevent_req_nomem(name->owner, req)) {
1007                         return;
1008                 }
1009
1010                 /* trying to save 1 or 2 bytes on the wire isn't a good idea */
1011                 if (wname->flags & 2) {
1012                         uint32_t j;
1013
1014                         name->num_addresses = wname->addresses.addresses.num_ips;
1015                         name->addresses = talloc_array(state->names,
1016                                                        struct wrepl_address,
1017                                                        name->num_addresses);
1018                         if (tevent_req_nomem(name->addresses, req)) {
1019                                 return;
1020                         }
1021
1022                         for (j=0;j<name->num_addresses;j++) {
1023                                 name->addresses[j].owner =
1024                                         talloc_move(name->addresses,
1025                                                     &wname->addresses.addresses.ips[j].owner);
1026                                 name->addresses[j].address =
1027                                         talloc_move(name->addresses,
1028                                                     &wname->addresses.addresses.ips[j].ip);
1029                         }
1030                 } else {
1031                         name->num_addresses = 1;
1032                         name->addresses = talloc_array(state->names,
1033                                                        struct wrepl_address,
1034                                                        name->num_addresses);
1035                         if (tevent_req_nomem(name->addresses, req)) {
1036                                 return;
1037                         }
1038
1039                         name->addresses[0].owner = talloc_strdup(name->addresses, name->owner);
1040                         if (tevent_req_nomem(name->addresses[0].owner, req)) {
1041                                 return;
1042                         }
1043                         name->addresses[0].address = talloc_move(name->addresses,
1044                                                                  &wname->addresses.ip);
1045                 }
1046         }
1047
1048         tevent_req_done(req);
1049 }
1050
1051 /*
1052   fetch the names for a WINS partner - recv
1053 */
1054 NTSTATUS wrepl_pull_names_recv(struct tevent_req *req,
1055                                TALLOC_CTX *mem_ctx,
1056                                struct wrepl_pull_names *io)
1057 {
1058         struct wrepl_pull_names_state *state = tevent_req_data(req,
1059                                                struct wrepl_pull_names_state);
1060         NTSTATUS status;
1061
1062         if (tevent_req_is_nterror(req, &status)) {
1063                 tevent_req_received(req);
1064                 return status;
1065         }
1066
1067         io->out.num_names = state->num_names;
1068         io->out.names = talloc_move(mem_ctx, &state->names);
1069
1070         tevent_req_received(req);
1071         return NT_STATUS_OK;
1072 }
1073
1074
1075
1076 /*
1077   fetch the names for a WINS partner - sync api
1078 */
1079 NTSTATUS wrepl_pull_names(struct wrepl_socket *wrepl_socket,
1080                           TALLOC_CTX *mem_ctx,
1081                           struct wrepl_pull_names *io)
1082 {
1083         struct tevent_req *subreq;
1084         bool ok;
1085         NTSTATUS status;
1086
1087         subreq = wrepl_pull_names_send(mem_ctx, wrepl_socket->event.ctx,
1088                                        wrepl_socket, io);
1089         NT_STATUS_HAVE_NO_MEMORY(subreq);
1090
1091         ok = tevent_req_poll(subreq, wrepl_socket->event.ctx);
1092         if (!ok) {
1093                 TALLOC_FREE(subreq);
1094                 return NT_STATUS_INTERNAL_ERROR;
1095         }
1096
1097         status = wrepl_pull_names_recv(subreq, mem_ctx, io);
1098         TALLOC_FREE(subreq);
1099         NT_STATUS_NOT_OK_RETURN(status);
1100
1101         return NT_STATUS_OK;
1102 }