Remove yet more uses of global_loadparm.
[bbaumbach/samba-autobuild/.git] / 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 "libcli/resolve/resolve.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 event_context *ev, struct timed_event *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_BLOB packet_blob_in)
86 {
87         struct wrepl_socket *wrepl_socket = talloc_get_type(private, 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 event_context *ev, struct fd_event *fde, 
127                           uint16_t flags, void *private)
128 {
129         struct wrepl_socket *wrepl_socket = talloc_get_type(private, 
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, NTSTATUS status)
141 {
142         struct wrepl_socket *wrepl_socket = talloc_get_type(private, 
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 event_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         if (event_ctx == NULL) {
176                 wrepl_socket->event.ctx = event_context_init(wrepl_socket);
177         } else {
178                 wrepl_socket->event.ctx = talloc_reference(wrepl_socket, event_ctx);
179         }
180         if (!wrepl_socket->event.ctx) goto failed;
181
182         wrepl_socket->iconv_convenience = iconv_convenience;
183
184         status = socket_create("ip", SOCKET_TYPE_STREAM, &wrepl_socket->sock, 0);
185         if (!NT_STATUS_IS_OK(status)) goto failed;
186
187         talloc_steal(wrepl_socket, wrepl_socket->sock);
188
189         wrepl_socket->request_timeout   = WREPL_SOCKET_REQUEST_TIMEOUT;
190
191         talloc_set_destructor(wrepl_socket, wrepl_socket_destructor);
192
193         return wrepl_socket;
194
195 failed:
196         talloc_free(wrepl_socket);
197         return NULL;
198 }
199
200 /*
201   initialise a wrepl_socket from an already existing connection
202 */
203 struct wrepl_socket *wrepl_socket_merge(TALLOC_CTX *mem_ctx, 
204                                         struct event_context *event_ctx,
205                                         struct socket_context *sock,
206                                         struct packet_context *pack)
207 {
208         struct wrepl_socket *wrepl_socket;
209
210         wrepl_socket = talloc_zero(mem_ctx, struct wrepl_socket);
211         if (wrepl_socket == NULL) goto failed;
212
213         wrepl_socket->event.ctx = talloc_reference(wrepl_socket, event_ctx);
214         if (wrepl_socket->event.ctx == NULL) goto failed;
215
216         wrepl_socket->sock = sock;
217         talloc_steal(wrepl_socket, wrepl_socket->sock);
218
219
220         wrepl_socket->request_timeout   = WREPL_SOCKET_REQUEST_TIMEOUT;
221
222         wrepl_socket->event.fde = event_add_fd(wrepl_socket->event.ctx, wrepl_socket,
223                                                socket_get_fd(wrepl_socket->sock), 
224                                                EVENT_FD_READ,
225                                                wrepl_handler, wrepl_socket);
226         if (wrepl_socket->event.fde == NULL) {
227                 goto failed;
228         }
229
230         wrepl_socket->packet = pack;
231         talloc_steal(wrepl_socket, wrepl_socket->packet);
232         packet_set_private(wrepl_socket->packet, wrepl_socket);
233         packet_set_socket(wrepl_socket->packet, wrepl_socket->sock);
234         packet_set_callback(wrepl_socket->packet, wrepl_finish_recv);
235         packet_set_full_request(wrepl_socket->packet, packet_full_request_u32);
236         packet_set_error_handler(wrepl_socket->packet, wrepl_error);
237         packet_set_event_context(wrepl_socket->packet, wrepl_socket->event.ctx);
238         packet_set_fde(wrepl_socket->packet, wrepl_socket->event.fde);
239         packet_set_serialise(wrepl_socket->packet);
240
241         talloc_set_destructor(wrepl_socket, wrepl_socket_destructor);
242         
243         return wrepl_socket;
244
245 failed:
246         talloc_free(wrepl_socket);
247         return NULL;
248 }
249
250 /*
251   destroy a wrepl_request
252 */
253 static int wrepl_request_destructor(struct wrepl_request *req)
254 {
255         if (req->state == WREPL_REQUEST_RECV) {
256                 DLIST_REMOVE(req->wrepl_socket->recv_queue, req);
257         }
258         req->state = WREPL_REQUEST_ERROR;
259         return 0;
260 }
261
262 /*
263   wait for a request to complete
264 */
265 static NTSTATUS wrepl_request_wait(struct wrepl_request *req)
266 {
267         NT_STATUS_HAVE_NO_MEMORY(req);
268         while (req->state < WREPL_REQUEST_DONE) {
269                 event_loop_once(req->wrepl_socket->event.ctx);
270         }
271         return req->status;
272 }
273
274 struct wrepl_connect_state {
275         struct composite_context *result;
276         struct wrepl_socket *wrepl_socket;
277         struct composite_context *creq;
278 };
279
280 /*
281   handler for winrepl connection completion
282 */
283 static void wrepl_connect_handler(struct composite_context *creq)
284 {
285         struct wrepl_connect_state *state = talloc_get_type(creq->async.private_data, 
286                                             struct wrepl_connect_state);
287         struct wrepl_socket *wrepl_socket = state->wrepl_socket;
288         struct composite_context *result = state->result;
289
290         result->status = socket_connect_recv(state->creq);
291         if (!composite_is_ok(result)) return;
292
293         wrepl_socket->event.fde = event_add_fd(wrepl_socket->event.ctx, wrepl_socket, 
294                                                socket_get_fd(wrepl_socket->sock), 
295                                                EVENT_FD_READ,
296                                                wrepl_handler, wrepl_socket);
297         if (composite_nomem(wrepl_socket->event.fde, result)) return;
298
299         /* setup the stream -> packet parser */
300         wrepl_socket->packet = packet_init(wrepl_socket);
301         if (composite_nomem(wrepl_socket->packet, result)) return;
302         packet_set_private(wrepl_socket->packet, wrepl_socket);
303         packet_set_socket(wrepl_socket->packet, wrepl_socket->sock);
304         packet_set_callback(wrepl_socket->packet, wrepl_finish_recv);
305         packet_set_full_request(wrepl_socket->packet, packet_full_request_u32);
306         packet_set_error_handler(wrepl_socket->packet, wrepl_error);
307         packet_set_event_context(wrepl_socket->packet, wrepl_socket->event.ctx);
308         packet_set_fde(wrepl_socket->packet, wrepl_socket->event.fde);
309         packet_set_serialise(wrepl_socket->packet);
310
311         composite_done(result);
312 }
313
314 /*
315   connect a wrepl_socket to a WINS server
316 */
317 struct composite_context *wrepl_connect_send(struct wrepl_socket *wrepl_socket,
318                                              struct resolve_context *resolve_ctx,
319                                              const char *our_ip, const char *peer_ip)
320 {
321         struct composite_context *result;
322         struct wrepl_connect_state *state;
323         struct socket_address *peer, *us;
324
325         result = talloc_zero(wrepl_socket, struct composite_context);
326         if (!result) return NULL;
327
328         result->state           = COMPOSITE_STATE_IN_PROGRESS;
329         result->event_ctx       = wrepl_socket->event.ctx;
330
331         state = talloc_zero(result, struct wrepl_connect_state);
332         if (composite_nomem(state, result)) return result;
333         result->private_data    = state;
334         state->result           = result;
335         state->wrepl_socket     = wrepl_socket;
336
337         if (!our_ip) {
338                 struct interface *ifaces;
339                 load_interfaces(state, lp_interfaces(global_loadparm), &ifaces);
340                 our_ip = iface_best_ip(ifaces, peer_ip);
341         }
342
343         us = socket_address_from_strings(state, wrepl_socket->sock->backend_name, 
344                                          our_ip, 0);
345         if (composite_nomem(us, result)) return result;
346
347         peer = socket_address_from_strings(state, wrepl_socket->sock->backend_name, 
348                                            peer_ip, WINS_REPLICATION_PORT);
349         if (composite_nomem(peer, result)) return result;
350
351         state->creq = socket_connect_send(wrepl_socket->sock, us, peer,
352                                           0, resolve_ctx,
353                                           wrepl_socket->event.ctx);
354         composite_continue(result, state->creq, wrepl_connect_handler, state);
355         return result;
356 }
357
358 /*
359   connect a wrepl_socket to a WINS server - recv side
360 */
361 NTSTATUS wrepl_connect_recv(struct composite_context *result)
362 {
363         struct wrepl_connect_state *state = talloc_get_type(result->private_data,
364                                             struct wrepl_connect_state);
365         struct wrepl_socket *wrepl_socket = state->wrepl_socket;
366         NTSTATUS status = composite_wait(result);
367
368         if (!NT_STATUS_IS_OK(status)) {
369                 wrepl_socket_dead(wrepl_socket, status);
370         }
371
372         talloc_free(result);
373         return status;
374 }
375
376 /*
377   connect a wrepl_socket to a WINS server - sync API
378 */
379 NTSTATUS wrepl_connect(struct wrepl_socket *wrepl_socket, struct resolve_context *resolve_ctx,
380                        const char *our_ip, const char *peer_ip)
381 {
382         struct composite_context *c_req = wrepl_connect_send(wrepl_socket, resolve_ctx, our_ip, peer_ip);
383         return wrepl_connect_recv(c_req);
384 }
385
386 /* 
387    callback from wrepl_request_trigger() 
388 */
389 static void wrepl_request_trigger_handler(struct event_context *ev, struct timed_event *te,
390                                           struct timeval t, void *ptr)
391 {
392         struct wrepl_request *req = talloc_get_type(ptr, struct wrepl_request);
393         if (req->async.fn) {
394                 req->async.fn(req);
395         }
396 }
397
398 /*
399   trigger an immediate event on a wrepl_request
400   the return value should only be used in wrepl_request_send()
401   this is the only place where req->trigger is true
402 */
403 static struct wrepl_request *wrepl_request_finished(struct wrepl_request *req, NTSTATUS status)
404 {
405         struct timed_event *te;
406
407         if (req->state == WREPL_REQUEST_RECV) {
408                 DLIST_REMOVE(req->wrepl_socket->recv_queue, req);
409         }
410
411         if (!NT_STATUS_IS_OK(status)) {
412                 req->state      = WREPL_REQUEST_ERROR;
413         } else {
414                 req->state      = WREPL_REQUEST_DONE;
415         }
416
417         req->status     = status;
418
419         if (req->trigger) {
420                 req->trigger = false;
421                 /* a zero timeout means immediate */
422                 te = event_add_timed(req->wrepl_socket->event.ctx,
423                                      req, timeval_zero(),
424                                      wrepl_request_trigger_handler, req);
425                 if (!te) {
426                         talloc_free(req);
427                         return NULL;
428                 }
429                 return req;
430         }
431
432         if (req->async.fn) {
433                 req->async.fn(req);
434         }
435         return NULL;
436 }
437
438 struct wrepl_send_ctrl_state {
439         struct wrepl_send_ctrl ctrl;
440         struct wrepl_request *req;
441         struct wrepl_socket *wrepl_sock;
442 };
443
444 static int wrepl_send_ctrl_destructor(struct wrepl_send_ctrl_state *s)
445 {
446         struct wrepl_request *req = s->wrepl_sock->recv_queue;
447
448         /* check if the request is still in WREPL_STATE_RECV,
449          * we need this here because the caller has may called 
450          * talloc_free(req) and wrepl_send_ctrl_state isn't
451          * a talloc child of the request, so our s->req pointer
452          * is maybe invalid!
453          */
454         for (; req; req = req->next) {
455                 if (req == s->req) break;
456         }
457         if (!req) return 0;
458
459         /* here, we need to make sure the async request handler is called
460          * later in the next event_loop and now now
461          */
462         req->trigger = true;
463         wrepl_request_finished(req, NT_STATUS_OK);
464
465         if (s->ctrl.disconnect_after_send) {
466                 wrepl_socket_dead(s->wrepl_sock, NT_STATUS_LOCAL_DISCONNECT);
467         }
468
469         return 0;
470 }
471
472 /*
473   send a generic wins replication request
474 */
475 struct wrepl_request *wrepl_request_send(struct wrepl_socket *wrepl_socket,
476                                          struct wrepl_packet *packet,
477                                          struct wrepl_send_ctrl *ctrl)
478 {
479         struct wrepl_request *req;
480         struct wrepl_wrap wrap;
481         DATA_BLOB blob;
482         NTSTATUS status;
483         enum ndr_err_code ndr_err;
484
485         req = talloc_zero(wrepl_socket, struct wrepl_request);
486         if (!req) return NULL;
487         req->wrepl_socket = wrepl_socket;
488         req->state        = WREPL_REQUEST_RECV;
489         req->trigger      = true;
490
491         DLIST_ADD_END(wrepl_socket->recv_queue, req, struct wrepl_request *);
492         talloc_set_destructor(req, wrepl_request_destructor);
493
494         if (wrepl_socket->dead) {
495                 return wrepl_request_finished(req, NT_STATUS_INVALID_CONNECTION);
496         }
497
498         wrap.packet = *packet;
499         ndr_err = ndr_push_struct_blob(&blob, req, wrepl_socket->iconv_convenience, &wrap, 
500                                        (ndr_push_flags_fn_t)ndr_push_wrepl_wrap);
501         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
502                 status = ndr_map_error2ntstatus(ndr_err);
503                 return wrepl_request_finished(req, status);
504         }
505
506         if (DEBUGLVL(10)) {
507                 DEBUG(10,("Sending WINS packet of length %u\n", 
508                           (unsigned)blob.length));
509                 NDR_PRINT_DEBUG(wrepl_packet, &wrap.packet);
510         }
511
512         if (wrepl_socket->request_timeout > 0) {
513                 req->te = event_add_timed(wrepl_socket->event.ctx, req, 
514                                           timeval_current_ofs(wrepl_socket->request_timeout, 0), 
515                                           wrepl_request_timeout_handler, req);
516                 if (!req->te) return wrepl_request_finished(req, NT_STATUS_NO_MEMORY);
517         }
518
519         if (ctrl && (ctrl->send_only || ctrl->disconnect_after_send)) {
520                 struct wrepl_send_ctrl_state *s = talloc(blob.data, struct wrepl_send_ctrl_state);
521                 if (!s) return wrepl_request_finished(req, NT_STATUS_NO_MEMORY);
522                 s->ctrl         = *ctrl;
523                 s->req          = req;
524                 s->wrepl_sock   = wrepl_socket;
525                 talloc_set_destructor(s, wrepl_send_ctrl_destructor);
526         }
527
528         status = packet_send(wrepl_socket->packet, blob);
529         if (!NT_STATUS_IS_OK(status)) {
530                 return wrepl_request_finished(req, status);
531         }
532
533         req->trigger = false;
534         return req;
535 }
536
537 /*
538   receive a generic WINS replication reply
539 */
540 NTSTATUS wrepl_request_recv(struct wrepl_request *req,
541                             TALLOC_CTX *mem_ctx,
542                             struct wrepl_packet **packet)
543 {
544         NTSTATUS status = wrepl_request_wait(req);
545         if (NT_STATUS_IS_OK(status) && packet) {
546                 *packet = talloc_steal(mem_ctx, req->packet);
547         }
548         talloc_free(req);
549         return status;
550 }
551
552 /*
553   a full WINS replication request/response
554 */
555 NTSTATUS wrepl_request(struct wrepl_socket *wrepl_socket,
556                        TALLOC_CTX *mem_ctx,
557                        struct wrepl_packet *req_packet,
558                        struct wrepl_packet **reply_packet)
559 {
560         struct wrepl_request *req = wrepl_request_send(wrepl_socket, req_packet, NULL);
561         return wrepl_request_recv(req, mem_ctx, reply_packet);
562 }
563
564
565 /*
566   setup an association - send
567 */
568 struct wrepl_request *wrepl_associate_send(struct wrepl_socket *wrepl_socket,
569                                            struct wrepl_associate *io)
570 {
571         struct wrepl_packet *packet;
572         struct wrepl_request *req;
573
574         packet = talloc_zero(wrepl_socket, struct wrepl_packet);
575         if (packet == NULL) return NULL;
576
577         packet->opcode                      = WREPL_OPCODE_BITS;
578         packet->mess_type                   = WREPL_START_ASSOCIATION;
579         packet->message.start.minor_version = 2;
580         packet->message.start.major_version = 5;
581
582         /*
583          * nt4 uses 41 bytes for the start_association call
584          * so do it the same and as we don't know th emeanings of this bytes
585          * we just send zeros and nt4, w2k and w2k3 seems to be happy with this
586          *
587          * if we don't do this nt4 uses an old version of the wins replication protocol
588          * and that would break nt4 <-> samba replication
589          */
590         packet->padding = data_blob_talloc(packet, NULL, 21);
591         if (packet->padding.data == NULL) {
592                 talloc_free(packet);
593                 return NULL;
594         }
595         memset(packet->padding.data, 0, packet->padding.length);
596
597         req = wrepl_request_send(wrepl_socket, packet, NULL);
598
599         talloc_free(packet);
600
601         return req;     
602 }
603
604 /*
605   setup an association - recv
606 */
607 NTSTATUS wrepl_associate_recv(struct wrepl_request *req,
608                               struct wrepl_associate *io)
609 {
610         struct wrepl_packet *packet=NULL;
611         NTSTATUS status;
612         status = wrepl_request_recv(req, req->wrepl_socket, &packet);
613         NT_STATUS_NOT_OK_RETURN(status);
614         if (packet->mess_type != WREPL_START_ASSOCIATION_REPLY) {
615                 status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
616         }
617         if (NT_STATUS_IS_OK(status)) {
618                 io->out.assoc_ctx = packet->message.start_reply.assoc_ctx;
619         }
620         talloc_free(packet);
621         return status;
622 }
623
624 /*
625   setup an association - sync api
626 */
627 NTSTATUS wrepl_associate(struct wrepl_socket *wrepl_socket,
628                          struct wrepl_associate *io)
629 {
630         struct wrepl_request *req = wrepl_associate_send(wrepl_socket, io);
631         return wrepl_associate_recv(req, io);
632 }
633
634
635 /*
636   stop an association - send
637 */
638 struct wrepl_request *wrepl_associate_stop_send(struct wrepl_socket *wrepl_socket,
639                                                 struct wrepl_associate_stop *io)
640 {
641         struct wrepl_packet *packet;
642         struct wrepl_request *req;
643         struct wrepl_send_ctrl ctrl;
644
645         packet = talloc_zero(wrepl_socket, struct wrepl_packet);
646         if (packet == NULL) return NULL;
647
648         packet->opcode                  = WREPL_OPCODE_BITS;
649         packet->assoc_ctx               = io->in.assoc_ctx;
650         packet->mess_type               = WREPL_STOP_ASSOCIATION;
651         packet->message.stop.reason     = io->in.reason;
652
653         ZERO_STRUCT(ctrl);
654         if (io->in.reason == 0) {
655                 ctrl.send_only                  = true;
656                 ctrl.disconnect_after_send      = true;
657         }
658
659         req = wrepl_request_send(wrepl_socket, packet, &ctrl);
660
661         talloc_free(packet);
662
663         return req;     
664 }
665
666 /*
667   stop an association - recv
668 */
669 NTSTATUS wrepl_associate_stop_recv(struct wrepl_request *req,
670                                    struct wrepl_associate_stop *io)
671 {
672         struct wrepl_packet *packet=NULL;
673         NTSTATUS status;
674         status = wrepl_request_recv(req, req->wrepl_socket, &packet);
675         NT_STATUS_NOT_OK_RETURN(status);
676         talloc_free(packet);
677         return status;
678 }
679
680 /*
681   setup an association - sync api
682 */
683 NTSTATUS wrepl_associate_stop(struct wrepl_socket *wrepl_socket,
684                               struct wrepl_associate_stop *io)
685 {
686         struct wrepl_request *req = wrepl_associate_stop_send(wrepl_socket, io);
687         return wrepl_associate_stop_recv(req, io);
688 }
689
690 /*
691   fetch the partner tables - send
692 */
693 struct wrepl_request *wrepl_pull_table_send(struct wrepl_socket *wrepl_socket,
694                                             struct wrepl_pull_table *io)
695 {
696         struct wrepl_packet *packet;
697         struct wrepl_request *req;
698
699         packet = talloc_zero(wrepl_socket, struct wrepl_packet);
700         if (packet == NULL) return NULL;
701
702         packet->opcode                      = WREPL_OPCODE_BITS;
703         packet->assoc_ctx                   = io->in.assoc_ctx;
704         packet->mess_type                   = WREPL_REPLICATION;
705         packet->message.replication.command = WREPL_REPL_TABLE_QUERY;
706
707         req = wrepl_request_send(wrepl_socket, packet, NULL);
708
709         talloc_free(packet);
710
711         return req;     
712 }
713
714
715 /*
716   fetch the partner tables - recv
717 */
718 NTSTATUS wrepl_pull_table_recv(struct wrepl_request *req,
719                                TALLOC_CTX *mem_ctx,
720                                struct wrepl_pull_table *io)
721 {
722         struct wrepl_packet *packet=NULL;
723         NTSTATUS status;
724         struct wrepl_table *table;
725         int i;
726
727         status = wrepl_request_recv(req, req->wrepl_socket, &packet);
728         NT_STATUS_NOT_OK_RETURN(status);
729         if (packet->mess_type != WREPL_REPLICATION) {
730                 status = NT_STATUS_NETWORK_ACCESS_DENIED;
731         } else if (packet->message.replication.command != WREPL_REPL_TABLE_REPLY) {
732                 status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
733         }
734         if (!NT_STATUS_IS_OK(status)) goto failed;
735
736         table = &packet->message.replication.info.table;
737         io->out.num_partners = table->partner_count;
738         io->out.partners = talloc_steal(mem_ctx, table->partners);
739         for (i=0;i<io->out.num_partners;i++) {
740                 talloc_steal(io->out.partners, io->out.partners[i].address);
741         }
742
743 failed:
744         talloc_free(packet);
745         return status;
746 }
747
748
749 /*
750   fetch the partner table - sync api
751 */
752 NTSTATUS wrepl_pull_table(struct wrepl_socket *wrepl_socket,
753                           TALLOC_CTX *mem_ctx,
754                           struct wrepl_pull_table *io)
755 {
756         struct wrepl_request *req = wrepl_pull_table_send(wrepl_socket, io);
757         return wrepl_pull_table_recv(req, mem_ctx, io);
758 }
759
760
761 /*
762   fetch the names for a WINS partner - send
763 */
764 struct wrepl_request *wrepl_pull_names_send(struct wrepl_socket *wrepl_socket,
765                                             struct wrepl_pull_names *io)
766 {
767         struct wrepl_packet *packet;
768         struct wrepl_request *req;
769
770         packet = talloc_zero(wrepl_socket, struct wrepl_packet);
771         if (packet == NULL) return NULL;
772
773         packet->opcode                         = WREPL_OPCODE_BITS;
774         packet->assoc_ctx                      = io->in.assoc_ctx;
775         packet->mess_type                      = WREPL_REPLICATION;
776         packet->message.replication.command    = WREPL_REPL_SEND_REQUEST;
777         packet->message.replication.info.owner = io->in.partner;
778
779         req = wrepl_request_send(wrepl_socket, packet, NULL);
780
781         talloc_free(packet);
782
783         return req;     
784 }
785
786 /*
787   fetch the names for a WINS partner - recv
788 */
789 NTSTATUS wrepl_pull_names_recv(struct wrepl_request *req,
790                                TALLOC_CTX *mem_ctx,
791                                struct wrepl_pull_names *io)
792 {
793         struct wrepl_packet *packet=NULL;
794         NTSTATUS status;
795         int i;
796
797         status = wrepl_request_recv(req, req->wrepl_socket, &packet);
798         NT_STATUS_NOT_OK_RETURN(status);
799         if (packet->mess_type != WREPL_REPLICATION ||
800             packet->message.replication.command != WREPL_REPL_SEND_REPLY) {
801                 status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
802         }
803         if (!NT_STATUS_IS_OK(status)) goto failed;
804
805         io->out.num_names = packet->message.replication.info.reply.num_names;
806
807         io->out.names = talloc_array(packet, struct wrepl_name, io->out.num_names);
808         if (io->out.names == NULL) goto nomem;
809
810         /* convert the list of names and addresses to a sane format */
811         for (i=0;i<io->out.num_names;i++) {
812                 struct wrepl_wins_name *wname = &packet->message.replication.info.reply.names[i];
813                 struct wrepl_name *name = &io->out.names[i];
814
815                 name->name      = *wname->name;
816                 talloc_steal(io->out.names, wname->name);
817                 name->type      = WREPL_NAME_TYPE(wname->flags);
818                 name->state     = WREPL_NAME_STATE(wname->flags);
819                 name->node      = WREPL_NAME_NODE(wname->flags);
820                 name->is_static = WREPL_NAME_IS_STATIC(wname->flags);
821                 name->raw_flags = wname->flags;
822                 name->version_id= wname->id;
823                 name->owner     = talloc_strdup(io->out.names, io->in.partner.address);
824                 if (name->owner == NULL) goto nomem;
825
826                 /* trying to save 1 or 2 bytes on the wire isn't a good idea */
827                 if (wname->flags & 2) {
828                         int j;
829
830                         name->num_addresses = wname->addresses.addresses.num_ips;
831                         name->addresses = talloc_array(io->out.names, 
832                                                        struct wrepl_address, 
833                                                        name->num_addresses);
834                         if (name->addresses == NULL) goto nomem;
835                         for (j=0;j<name->num_addresses;j++) {
836                                 name->addresses[j].owner = 
837                                         talloc_steal(name->addresses, 
838                                                      wname->addresses.addresses.ips[j].owner);
839                                 name->addresses[j].address = 
840                                         talloc_steal(name->addresses, 
841                                                      wname->addresses.addresses.ips[j].ip);
842                         }
843                 } else {
844                         name->num_addresses = 1;
845                         name->addresses = talloc(io->out.names, struct wrepl_address);
846                         if (name->addresses == NULL) goto nomem;
847                         name->addresses[0].owner = talloc_strdup(name->addresses,io->in.partner.address);
848                         if (name->addresses[0].owner == NULL) goto nomem;
849                         name->addresses[0].address = talloc_steal(name->addresses,
850                                                                   wname->addresses.ip);
851                 }
852         }
853
854         talloc_steal(mem_ctx, io->out.names);
855         talloc_free(packet);
856         return NT_STATUS_OK;
857 nomem:
858         status = NT_STATUS_NO_MEMORY;
859 failed:
860         talloc_free(packet);
861         return status;
862 }
863
864
865
866 /*
867   fetch the names for a WINS partner - sync api
868 */
869 NTSTATUS wrepl_pull_names(struct wrepl_socket *wrepl_socket,
870                           TALLOC_CTX *mem_ctx,
871                           struct wrepl_pull_names *io)
872 {
873         struct wrepl_request *req = wrepl_pull_names_send(wrepl_socket, io);
874         return wrepl_pull_names_recv(req, mem_ctx, io);
875 }