From 94a8893bf4bd131b9c588215967d5ab900af84aa Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Fri, 14 Oct 2005 13:02:00 +0000
Subject: r11048:  r10539@SERNOX:  metze | 2005-09-27 14:59:47 +0200  fix the
 build for changes from SAMBA_4_0 branch

 metze
 r10541@SERNOX:  metze | 2005-09-27 15:05:33 +0200
 use a transaction when we allocate a new version

 metze
 r10549@SERNOX:  metze | 2005-09-27 18:58:37 +0200
 - add first start of wins pull replication
 - we not yet apply records to our database but we fetch them correct form our partners
   (we need conflict handling for this)
 - we also need to filter out our own records!

 metze
 r10568@SERNOX:  metze | 2005-09-28 11:33:04 +0200
 move composite helpers to a seperate file, create a a seperate file for the conflict resolving logic

 metze
 r10571@SERNOX:  metze | 2005-09-28 12:00:17 +0200
 add forward declarations...to fix the build

 metze
 r10612@SERNOX:  metze | 2005-09-29 16:11:06 +0200
 we have a nbt_name now, and don't need to parse it

 metze
 r10614@SERNOX:  metze | 2005-09-29 16:38:35 +0200
 filter out our own records

 metze
 r10620@SERNOX:  metze | 2005-09-29 18:07:08 +0200
 - handle mutliple addresses in WREPL_REPL_SEND_REPLY
 - make strings always valid talloc pointers

 metze
 r10621@SERNOX:  metze | 2005-09-29 18:09:41 +0200
 use debug level 2

 metze
 r10622@SERNOX:  metze | 2005-09-29 18:48:05 +0200
 - add one more debug message when we reply no record
 - fix min max logic

 metze
 r10623@SERNOX:  metze | 2005-09-29 20:49:06 +0200
 build fixes...

 metze
 r10629@SERNOX:  metze | 2005-09-30 00:11:41 +0200
 - use seperate attributes for type, state, nodetype, is_static

 ... the winserver.c code needs some more updates to correctly,
 create special group and multihomed registrations...

 metze
 r10640@SERNOX:  metze | 2005-09-30 04:07:34 +0200
 - add some short path for the composite helper functions
   they will be used in the next commit

 metze
 r10642@SERNOX:  metze | 2005-09-30 06:29:06 +0200
 fix the build

 metze
 r10655@SERNOX:  metze | 2005-09-30 17:36:49 +0200
 - implement the WREPL_REPL_UPDATE* and WREPL_REPL_INFORM*
   this includes the connection fliping into a client connection
   for WREPL_REPL_UPDATE*

 NOTE: I not yet found out how to get the w2k server to use INFORM against samba4
       it uses inform against w2k and w2k3 but UPDATE against nt4 and samba4

 what's left now is to be able to initiate INFORM and UPDATE requests to notify
 our pull partners

 metze
 r10727@SERNOX:  metze | 2005-10-05 14:11:05 +0200
 fix the build

 metze
 r10770@SERNOX:  metze | 2005-10-06 16:56:01 +0200
 - move the table filling to a seperate function, will be reused later
 - fix the build, wrepl_nbt_name fixes
 - remove state -> update_state

 metze
 r10771@SERNOX:  metze | 2005-10-06 17:04:48 +0200
 add a function to create a wreplsrv_in_connection from a client connection

 metze
 r10772@SERNOX:  metze | 2005-10-06 17:13:51 +0200
 - make the connection code more generic to handle the pull cached connection,
   push cached connection or given connections
 - when we don't use a cached connection, disconnection when a pull_cycle is done
 - fix the build and use the configured source ip

 metze
 r10773@SERNOX:  metze | 2005-10-06 17:18:49 +0200
 - add composite functions for push notification

 metze
 r10774@SERNOX:  metze | 2005-10-06 17:23:46 +0200
 - use periodic push notifycation, this is just for now
   as it needs to be configurable and and be triggered when the local database
   has changes since the last notify
 - I also need to work out how to decide if the partner supports
   persistent connections and WREPL_REPL_INFORM* messages

 metze
 r10923@SERNOX:  metze | 2005-10-12 16:52:34 +0200
 fix the build becuse of conflicts with main SAMBA_4_0 tree

 metze
(This used to be commit 6d97dd6e50423758d081459ec551f4e04dfd818d)
---
 source4/wrepl_server/wrepl_out_helpers.c | 1043 ++++++++++++++++++++++++++++++
 1 file changed, 1043 insertions(+)
 create mode 100644 source4/wrepl_server/wrepl_out_helpers.c

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
new file mode 100644
index 0000000000..217bb87d48
--- /dev/null
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -0,0 +1,1043 @@
+/* 
+   Unix SMB/CIFS implementation.
+   
+   WINS Replication server
+   
+   Copyright (C) Stefan Metzmacher	2005
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+#include "dlinklist.h"
+#include "lib/events/events.h"
+#include "lib/socket/socket.h"
+#include "smbd/service_task.h"
+#include "smbd/service_stream.h"
+#include "lib/messaging/irpc.h"
+#include "librpc/gen_ndr/ndr_winsrepl.h"
+#include "wrepl_server/wrepl_server.h"
+#include "wrepl_server/wrepl_out_helpers.h"
+#include "nbt_server/wins/winsdb.h"
+#include "ldb/include/ldb.h"
+#include "libcli/composite/composite.h"
+#include "libcli/wrepl/winsrepl.h"
+
+enum wreplsrv_out_connect_stage {
+	WREPLSRV_OUT_CONNECT_STAGE_WAIT_SOCKET,
+	WREPLSRV_OUT_CONNECT_STAGE_WAIT_ASSOC_CTX,
+	WREPLSRV_OUT_CONNECT_STAGE_DONE
+};
+
+struct wreplsrv_out_connect_state {
+	enum wreplsrv_out_connect_stage stage;
+	struct composite_context *c;
+	struct wrepl_request *req;
+	struct wrepl_associate assoc_io;
+	enum winsrepl_partner_type type;
+	struct wreplsrv_out_connection *wreplconn;
+};
+
+static void wreplsrv_out_connect_handler(struct wrepl_request *req);
+
+static NTSTATUS wreplsrv_out_connect_wait_socket(struct wreplsrv_out_connect_state *state)
+{
+	NTSTATUS status;
+
+	status = wrepl_connect_recv(state->req);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	state->req = wrepl_associate_send(state->wreplconn->sock, &state->assoc_io);
+	NT_STATUS_HAVE_NO_MEMORY(state->req);
+
+	state->req->async.fn		= wreplsrv_out_connect_handler;
+	state->req->async.private	= state;
+
+	state->stage = WREPLSRV_OUT_CONNECT_STAGE_WAIT_ASSOC_CTX;
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS wreplsrv_out_connect_wait_assoc_ctx(struct wreplsrv_out_connect_state *state)
+{
+	NTSTATUS status;
+
+	status = wrepl_associate_recv(state->req, &state->assoc_io);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	state->wreplconn->assoc_ctx.peer_ctx = state->assoc_io.out.assoc_ctx;
+
+	if (state->type == WINSREPL_PARTNER_PUSH) {
+		state->wreplconn->partner->push.wreplconn = state->wreplconn;
+		talloc_steal(state->wreplconn->partner, state->wreplconn);
+	} else if (state->type == WINSREPL_PARTNER_PULL) {
+		state->wreplconn->partner->pull.wreplconn = state->wreplconn;
+		talloc_steal(state->wreplconn->partner, state->wreplconn);
+	}
+
+	state->stage = WREPLSRV_OUT_CONNECT_STAGE_DONE;
+
+	return NT_STATUS_OK;
+}
+
+static void wreplsrv_out_connect_handler(struct wrepl_request *req)
+{
+	struct wreplsrv_out_connect_state *state = talloc_get_type(req->async.private,
+						   struct wreplsrv_out_connect_state);
+	struct composite_context *c = state->c;
+
+	switch (state->stage) {
+	case WREPLSRV_OUT_CONNECT_STAGE_WAIT_SOCKET:
+		c->status = wreplsrv_out_connect_wait_socket(state);
+		break;
+	case WREPLSRV_OUT_CONNECT_STAGE_WAIT_ASSOC_CTX:
+		c->status = wreplsrv_out_connect_wait_assoc_ctx(state);
+		c->state  = COMPOSITE_STATE_DONE;
+		break;
+	case WREPLSRV_OUT_CONNECT_STAGE_DONE:
+		c->status = NT_STATUS_INTERNAL_ERROR;
+	}
+
+	if (!NT_STATUS_IS_OK(c->status)) {
+		c->state = COMPOSITE_STATE_ERROR;
+	}
+
+	if (c->state >= COMPOSITE_STATE_DONE && c->async.fn) {
+		c->async.fn(c);
+	}
+}
+
+static struct composite_context *wreplsrv_out_connect_send(struct wreplsrv_partner *partner,
+							   enum winsrepl_partner_type type,
+							   struct wreplsrv_out_connection *wreplconn)
+{
+	struct composite_context *c = NULL;
+	struct wreplsrv_service *service = partner->service;
+	struct wreplsrv_out_connect_state *state = NULL;
+	struct wreplsrv_out_connection **wreplconnp = &wreplconn;
+	BOOL cached_connection = False;
+
+	c = talloc_zero(partner, struct composite_context);
+	if (!c) goto failed;
+
+	state = talloc_zero(c, struct wreplsrv_out_connect_state);
+	if (!state) goto failed;
+	state->c	= c;
+	state->type	= type;
+
+	c->state	= COMPOSITE_STATE_IN_PROGRESS;
+	c->event_ctx	= service->task->event_ctx;
+	c->private_data	= state;
+
+	if (type == WINSREPL_PARTNER_PUSH) {
+		cached_connection	= True;
+		wreplconn		= partner->push.wreplconn;
+		wreplconnp		= &partner->push.wreplconn;
+	} else if (type == WINSREPL_PARTNER_PULL) {
+		cached_connection	= True;
+		wreplconn		= partner->pull.wreplconn;
+		wreplconnp		= &partner->pull.wreplconn;
+	}
+
+	/* we have a connection already, so use it */
+	if (wreplconn) {
+		if (!wreplconn->sock->dead) {
+			state->stage	= WREPLSRV_OUT_CONNECT_STAGE_DONE;
+			state->wreplconn= wreplconn;
+			composite_trigger_done(c);
+			return c;
+		} else if (!cached_connection) {
+			state->stage	= WREPLSRV_OUT_CONNECT_STAGE_DONE;
+			state->wreplconn= NULL;
+			composite_trigger_done(c);
+			return c;
+		} else {
+			talloc_free(wreplconn);
+			*wreplconnp = NULL;
+		}
+	}
+
+	wreplconn = talloc_zero(state, struct wreplsrv_out_connection);
+	if (!wreplconn) goto failed;
+
+	wreplconn->service	= service;
+	wreplconn->partner	= partner;
+	wreplconn->sock		= wrepl_socket_init(wreplconn, service->task->event_ctx);
+	if (!wreplconn->sock) goto failed;
+
+	state->stage	= WREPLSRV_OUT_CONNECT_STAGE_WAIT_SOCKET;
+	state->wreplconn= wreplconn;
+	state->req	= wrepl_connect_send(wreplconn->sock,
+					     partner->our_address,
+					     partner->address);
+	if (!state->req) goto failed;
+
+	state->req->async.fn		= wreplsrv_out_connect_handler;
+	state->req->async.private	= state;
+
+	return c;
+failed:
+	talloc_free(c);
+	return NULL;
+}
+
+static NTSTATUS wreplsrv_out_connect_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
+					  struct wreplsrv_out_connection **wreplconn)
+{
+	NTSTATUS status;
+
+	status = composite_wait(c);
+
+	if (NT_STATUS_IS_OK(status)) {
+		struct wreplsrv_out_connect_state *state = talloc_get_type(c->private_data,
+							   struct wreplsrv_out_connect_state);
+		if (state->wreplconn) {
+			*wreplconn = talloc_reference(mem_ctx, state->wreplconn);
+			if (!*wreplconn) status = NT_STATUS_NO_MEMORY;
+		} else {
+			status = NT_STATUS_INVALID_CONNECTION;
+		}
+	}
+
+	talloc_free(c);
+	return status;
+	
+}
+
+enum wreplsrv_pull_table_stage {
+	WREPLSRV_PULL_TABLE_STAGE_WAIT_CONNECTION,
+	WREPLSRV_PULL_TABLE_STAGE_WAIT_TABLE_REPLY,
+	WREPLSRV_PULL_TABLE_STAGE_DONE
+};
+
+struct wreplsrv_pull_table_state {
+	enum wreplsrv_pull_table_stage stage;
+	struct composite_context *c;
+	struct wrepl_request *req;
+	struct wrepl_pull_table table_io;
+	struct wreplsrv_pull_table_io *io;
+	struct composite_context *creq;
+	struct wreplsrv_out_connection *wreplconn;
+};
+
+static void wreplsrv_pull_table_handler_req(struct wrepl_request *req);
+
+static NTSTATUS wreplsrv_pull_table_wait_connection(struct wreplsrv_pull_table_state *state)
+{
+	NTSTATUS status;
+
+	status = wreplsrv_out_connect_recv(state->creq, state, &state->wreplconn);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	state->table_io.in.assoc_ctx = state->wreplconn->assoc_ctx.peer_ctx;
+	state->req = wrepl_pull_table_send(state->wreplconn->sock, &state->table_io);
+	NT_STATUS_HAVE_NO_MEMORY(state->req);
+
+	state->req->async.fn		= wreplsrv_pull_table_handler_req;
+	state->req->async.private	= state;
+
+	state->stage = WREPLSRV_PULL_TABLE_STAGE_WAIT_TABLE_REPLY;
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS wreplsrv_pull_table_wait_table_reply(struct wreplsrv_pull_table_state *state)
+{
+	NTSTATUS status;
+
+	status = wrepl_pull_table_recv(state->req, state, &state->table_io);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	state->stage = WREPLSRV_PULL_TABLE_STAGE_DONE;
+
+	return NT_STATUS_OK;
+}
+
+static void wreplsrv_pull_table_handler(struct wreplsrv_pull_table_state *state)
+{
+	struct composite_context *c = state->c;
+
+	switch (state->stage) {
+	case WREPLSRV_PULL_TABLE_STAGE_WAIT_CONNECTION:
+		c->status = wreplsrv_pull_table_wait_connection(state);
+		break;
+	case WREPLSRV_PULL_TABLE_STAGE_WAIT_TABLE_REPLY:
+		c->status = wreplsrv_pull_table_wait_table_reply(state);
+		c->state  = COMPOSITE_STATE_DONE;
+		break;
+	case WREPLSRV_PULL_TABLE_STAGE_DONE:
+		c->status = NT_STATUS_INTERNAL_ERROR;
+	}
+
+	if (!NT_STATUS_IS_OK(c->status)) {
+		c->state = COMPOSITE_STATE_ERROR;
+	}
+
+	if (c->state >= COMPOSITE_STATE_DONE && c->async.fn) {
+		c->async.fn(c);
+	}
+}
+
+static void wreplsrv_pull_table_handler_creq(struct composite_context *creq)
+{
+	struct wreplsrv_pull_table_state *state = talloc_get_type(creq->async.private_data,
+						  struct wreplsrv_pull_table_state);
+	wreplsrv_pull_table_handler(state);
+	return;
+}
+
+static void wreplsrv_pull_table_handler_req(struct wrepl_request *req)
+{
+	struct wreplsrv_pull_table_state *state = talloc_get_type(req->async.private,
+						  struct wreplsrv_pull_table_state);
+	wreplsrv_pull_table_handler(state);
+	return;
+}
+
+struct composite_context *wreplsrv_pull_table_send(TALLOC_CTX *mem_ctx, struct wreplsrv_pull_table_io *io)
+{
+	struct composite_context *c = NULL;
+	struct wreplsrv_service *service = io->in.partner->service;
+	struct wreplsrv_pull_table_state *state = NULL;
+
+	c = talloc_zero(mem_ctx, struct composite_context);
+	if (!c) goto failed;
+
+	state = talloc_zero(c, struct wreplsrv_pull_table_state);
+	if (!state) goto failed;
+	state->c	= c;
+	state->io	= io;
+
+	c->state	= COMPOSITE_STATE_IN_PROGRESS;
+	c->event_ctx	= service->task->event_ctx;
+	c->private_data	= state;
+
+	if (io->in.num_owners) {
+		state->table_io.out.num_partners	= io->in.num_owners;
+		state->table_io.out.partners		= io->in.owners;
+		state->stage				= WREPLSRV_PULL_TABLE_STAGE_DONE;
+		composite_trigger_done(c);
+		return c;
+	}
+
+	state->stage    = WREPLSRV_PULL_TABLE_STAGE_WAIT_CONNECTION;
+	state->creq	= wreplsrv_out_connect_send(io->in.partner, WINSREPL_PARTNER_PULL, NULL);
+	if (!state->creq) goto failed;
+
+	state->creq->async.fn		= wreplsrv_pull_table_handler_creq;
+	state->creq->async.private_data	= state;
+
+	return c;
+failed:
+	talloc_free(c);
+	return NULL;
+}
+
+NTSTATUS wreplsrv_pull_table_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
+				  struct wreplsrv_pull_table_io *io)
+{
+	NTSTATUS status;
+
+	status = composite_wait(c);
+
+	if (NT_STATUS_IS_OK(status)) {
+		struct wreplsrv_pull_table_state *state = talloc_get_type(c->private_data,
+							  struct wreplsrv_pull_table_state);
+		io->out.num_owners	= state->table_io.out.num_partners;
+		io->out.owners		= state->table_io.out.partners;
+		talloc_reference(mem_ctx, state->table_io.out.partners);
+	}
+
+	talloc_free(c);
+	return status;	
+}
+
+enum wreplsrv_pull_names_stage {
+	WREPLSRV_PULL_NAMES_STAGE_WAIT_CONNECTION,
+	WREPLSRV_PULL_NAMES_STAGE_WAIT_SEND_REPLY,
+	WREPLSRV_PULL_NAMES_STAGE_DONE
+};
+
+struct wreplsrv_pull_names_state {
+	enum wreplsrv_pull_names_stage stage;
+	struct composite_context *c;
+	struct wrepl_request *req;
+	struct wrepl_pull_names pull_io;
+	struct wreplsrv_pull_names_io *io;
+	struct composite_context *creq;
+	struct wreplsrv_out_connection *wreplconn;
+};
+
+static void wreplsrv_pull_names_handler_req(struct wrepl_request *req);
+
+static NTSTATUS wreplsrv_pull_names_wait_connection(struct wreplsrv_pull_names_state *state)
+{
+	NTSTATUS status;
+
+	status = wreplsrv_out_connect_recv(state->creq, state, &state->wreplconn);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	state->pull_io.in.assoc_ctx	= state->wreplconn->assoc_ctx.peer_ctx;
+	state->pull_io.in.partner	= state->io->in.owner;
+	state->req = wrepl_pull_names_send(state->wreplconn->sock, &state->pull_io);
+	NT_STATUS_HAVE_NO_MEMORY(state->req);
+
+	state->req->async.fn		= wreplsrv_pull_names_handler_req;
+	state->req->async.private	= state;
+
+	state->stage = WREPLSRV_PULL_NAMES_STAGE_WAIT_SEND_REPLY;
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS wreplsrv_pull_names_wait_send_reply(struct wreplsrv_pull_names_state *state)
+{
+	NTSTATUS status;
+
+	status = wrepl_pull_names_recv(state->req, state, &state->pull_io);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	state->stage = WREPLSRV_PULL_NAMES_STAGE_DONE;
+
+	return NT_STATUS_OK;
+}
+
+static void wreplsrv_pull_names_handler(struct wreplsrv_pull_names_state *state)
+{
+	struct composite_context *c = state->c;
+
+	switch (state->stage) {
+	case WREPLSRV_PULL_NAMES_STAGE_WAIT_CONNECTION:
+		c->status = wreplsrv_pull_names_wait_connection(state);
+		break;
+	case WREPLSRV_PULL_NAMES_STAGE_WAIT_SEND_REPLY:
+		c->status = wreplsrv_pull_names_wait_send_reply(state);
+		c->state  = COMPOSITE_STATE_DONE;
+		break;
+	case WREPLSRV_PULL_NAMES_STAGE_DONE:
+		c->status = NT_STATUS_INTERNAL_ERROR;
+	}
+
+	if (!NT_STATUS_IS_OK(c->status)) {
+		c->state = COMPOSITE_STATE_ERROR;
+	}
+
+	if (c->state >= COMPOSITE_STATE_DONE && c->async.fn) {
+		c->async.fn(c);
+	}
+}
+
+static void wreplsrv_pull_names_handler_creq(struct composite_context *creq)
+{
+	struct wreplsrv_pull_names_state *state = talloc_get_type(creq->async.private_data,
+						  struct wreplsrv_pull_names_state);
+	wreplsrv_pull_names_handler(state);
+	return;
+}
+
+static void wreplsrv_pull_names_handler_req(struct wrepl_request *req)
+{
+	struct wreplsrv_pull_names_state *state = talloc_get_type(req->async.private,
+						  struct wreplsrv_pull_names_state);
+	wreplsrv_pull_names_handler(state);
+	return;
+}
+
+struct composite_context *wreplsrv_pull_names_send(TALLOC_CTX *mem_ctx, struct wreplsrv_pull_names_io *io)
+{
+	struct composite_context *c = NULL;
+	struct wreplsrv_service *service = io->in.partner->service;
+	struct wreplsrv_pull_names_state *state = NULL;
+	enum winsrepl_partner_type partner_type = WINSREPL_PARTNER_PULL;
+
+	if (io->in.wreplconn) partner_type = WINSREPL_PARTNER_NONE;
+
+	c = talloc_zero(mem_ctx, struct composite_context);
+	if (!c) goto failed;
+
+	state = talloc_zero(c, struct wreplsrv_pull_names_state);
+	if (!state) goto failed;
+	state->c	= c;
+	state->io	= io;
+
+	c->state	= COMPOSITE_STATE_IN_PROGRESS;
+	c->event_ctx	= service->task->event_ctx;
+	c->private_data	= state;
+
+	state->stage	= WREPLSRV_PULL_NAMES_STAGE_WAIT_CONNECTION;
+	state->creq	= wreplsrv_out_connect_send(io->in.partner, partner_type, io->in.wreplconn);
+	if (!state->creq) goto failed;
+
+	state->creq->async.fn		= wreplsrv_pull_names_handler_creq;
+	state->creq->async.private_data	= state;
+
+	return c;
+failed:
+	talloc_free(c);
+	return NULL;
+}
+
+NTSTATUS wreplsrv_pull_names_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
+				  struct wreplsrv_pull_names_io *io)
+{
+	NTSTATUS status;
+
+	status = composite_wait(c);
+
+	if (NT_STATUS_IS_OK(status)) {
+		struct wreplsrv_pull_names_state *state = talloc_get_type(c->private_data,
+							  struct wreplsrv_pull_names_state);
+		io->out.num_names	= state->pull_io.out.num_names;
+		io->out.names		= state->pull_io.out.names;
+		talloc_reference(mem_ctx, state->pull_io.out.names);
+	}
+
+	talloc_free(c);
+	return status;
+	
+}
+
+enum wreplsrv_pull_cycle_stage {
+	WREPLSRV_PULL_CYCLE_STAGE_WAIT_TABLE_REPLY,
+	WREPLSRV_PULL_CYCLE_STAGE_WAIT_SEND_REPLIES,
+	WREPLSRV_PULL_CYCLE_STAGE_WAIT_STOP_ASSOC,
+	WREPLSRV_PULL_CYCLE_STAGE_DONE
+};
+
+struct wreplsrv_pull_cycle_state {
+	enum wreplsrv_pull_cycle_stage stage;
+	struct composite_context *c;
+	struct wreplsrv_pull_cycle_io *io;
+	struct wreplsrv_pull_table_io table_io;
+	uint32_t current;
+	struct wreplsrv_pull_names_io names_io;
+	struct composite_context *creq;
+	struct wrepl_associate_stop assoc_stop_io;
+	struct wrepl_request *req;
+};
+
+static void wreplsrv_pull_cycle_handler_creq(struct composite_context *creq);
+static void wreplsrv_pull_cycle_handler_req(struct wrepl_request *req);
+
+static NTSTATUS wreplsrv_pull_cycle_next_owner_do_work(struct wreplsrv_pull_cycle_state *state)
+{
+	struct wreplsrv_owner *current_owner;
+	struct wreplsrv_owner *local_owner;
+	uint32_t i;
+	uint64_t old_max_version = 0;
+	BOOL do_pull = False;
+
+	for (i=state->current; i < state->table_io.out.num_owners; i++) {
+		current_owner = wreplsrv_find_owner(state->io->in.partner->pull.table,
+						    state->table_io.out.owners[i].address);
+
+		local_owner = wreplsrv_find_owner(state->io->in.partner->service->table,
+						  state->table_io.out.owners[i].address);
+		/*
+		 * this means we are ourself the current owner,
+		 * and we don't want replicate ourself
+		 */
+		if (!current_owner) continue;
+
+		/*
+		 * this means we don't have any records of this owner
+		 * so fetch them
+		 */
+		if (!local_owner) {
+			do_pull		= True;
+			
+			break;
+		}
+
+		/*
+		 * this means the remote partner has some new records of this owner
+		 * fetch them
+		 */
+		if (current_owner->owner.max_version > local_owner->owner.max_version) {
+			do_pull		= True;
+			old_max_version	= local_owner->owner.max_version;
+			break;
+		}
+	}
+	state->current = i;
+
+	if (do_pull) {
+		state->names_io.in.partner		= state->io->in.partner;
+		state->names_io.in.wreplconn		= state->io->in.wreplconn;
+		state->names_io.in.owner		= current_owner->owner;
+		state->names_io.in.owner.min_version	= old_max_version;
+		state->creq = wreplsrv_pull_names_send(state, &state->names_io);
+		NT_STATUS_HAVE_NO_MEMORY(state->creq);
+
+		state->creq->async.fn		= wreplsrv_pull_cycle_handler_creq;
+		state->creq->async.private_data	= state;
+
+		return STATUS_MORE_ENTRIES;
+	}
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS wreplsrv_pull_cycle_next_owner_wrapper(struct wreplsrv_pull_cycle_state *state)
+{
+	NTSTATUS status;
+
+	status = wreplsrv_pull_cycle_next_owner_do_work(state);
+	if (NT_STATUS_IS_OK(status)) {
+		state->stage = WREPLSRV_PULL_CYCLE_STAGE_DONE;
+	} else if (NT_STATUS_EQUAL(STATUS_MORE_ENTRIES, status)) {
+		state->stage = WREPLSRV_PULL_CYCLE_STAGE_WAIT_SEND_REPLIES;
+		status = NT_STATUS_OK;
+	}
+
+	if (state->stage == WREPLSRV_PULL_CYCLE_STAGE_DONE && state->io->in.wreplconn) {
+		state->assoc_stop_io.in.assoc_ctx	= state->io->in.wreplconn->assoc_ctx.peer_ctx;
+		state->assoc_stop_io.in.reason		= 0;
+		state->req = wrepl_associate_stop_send(state->io->in.wreplconn->sock, &state->assoc_stop_io);
+		NT_STATUS_HAVE_NO_MEMORY(state->req);
+
+		state->req->async.fn		= wreplsrv_pull_cycle_handler_req;
+		state->req->async.private	= state;
+
+		state->stage = WREPLSRV_PULL_CYCLE_STAGE_WAIT_STOP_ASSOC;
+	}
+
+	return status;
+}
+
+static NTSTATUS wreplsrv_pull_cycle_wait_table_reply(struct wreplsrv_pull_cycle_state *state)
+{
+	NTSTATUS status;
+	uint32_t i;
+
+	status = wreplsrv_pull_table_recv(state->creq, state, &state->table_io);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	/* update partner table */
+	for (i=0; i < state->table_io.out.num_owners; i++) {
+		BOOL is_our_addr;
+
+		is_our_addr = wreplsrv_is_our_address(state->io->in.partner->service,
+						      state->table_io.out.owners[i].address);
+		if (is_our_addr) continue;
+
+		status = wreplsrv_add_table(state->io->in.partner->service,
+					    state->io->in.partner, 
+					    &state->io->in.partner->pull.table,
+					    state->table_io.out.owners[i].address,
+					    state->table_io.out.owners[i].max_version);
+		NT_STATUS_NOT_OK_RETURN(status);
+	}
+
+	status = wreplsrv_pull_cycle_next_owner_wrapper(state);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	return status;
+}
+
+static NTSTATUS wreplsrv_pull_cycle_apply_records(struct wreplsrv_pull_cycle_state *state)
+{
+	NTSTATUS status;
+
+	status = wreplsrv_apply_records(state->io->in.partner, &state->names_io);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	talloc_free(state->names_io.out.names);
+	ZERO_STRUCT(state->names_io);
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS wreplsrv_pull_cycle_wait_send_replies(struct wreplsrv_pull_cycle_state *state)
+{
+	NTSTATUS status;
+
+	status = wreplsrv_pull_names_recv(state->creq, state, &state->names_io);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	/*
+	 * TODO: this should maybe an async call,
+	 *       because we may need some network access
+	 *       for conflict resolving
+	 */
+	status = wreplsrv_pull_cycle_apply_records(state);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	status = wreplsrv_pull_cycle_next_owner_wrapper(state);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	return status;
+}
+
+static NTSTATUS wreplsrv_pull_cycle_wait_stop_assoc(struct wreplsrv_pull_cycle_state *state)
+{
+	NTSTATUS status;
+
+	status = wrepl_associate_stop_recv(state->req, &state->assoc_stop_io);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	state->stage = WREPLSRV_PULL_CYCLE_STAGE_DONE;
+
+	return status;
+}
+
+static void wreplsrv_pull_cycle_handler(struct wreplsrv_pull_cycle_state *state)
+{
+	struct composite_context *c = state->c;
+
+	switch (state->stage) {
+	case WREPLSRV_PULL_CYCLE_STAGE_WAIT_TABLE_REPLY:
+		c->status = wreplsrv_pull_cycle_wait_table_reply(state);
+		break;
+	case WREPLSRV_PULL_CYCLE_STAGE_WAIT_SEND_REPLIES:
+		c->status = wreplsrv_pull_cycle_wait_send_replies(state);
+		break;
+	case WREPLSRV_PULL_CYCLE_STAGE_WAIT_STOP_ASSOC:
+		c->status = wreplsrv_pull_cycle_wait_stop_assoc(state);
+		break;
+	case WREPLSRV_PULL_CYCLE_STAGE_DONE:
+		c->status = NT_STATUS_INTERNAL_ERROR;
+	}
+
+	if (state->stage == WREPLSRV_PULL_CYCLE_STAGE_DONE) {
+		c->state  = COMPOSITE_STATE_DONE;
+	}
+
+	if (!NT_STATUS_IS_OK(c->status)) {
+		c->state = COMPOSITE_STATE_ERROR;
+	}
+
+	if (c->state >= COMPOSITE_STATE_DONE && c->async.fn) {
+		c->async.fn(c);
+	}
+}
+
+static void wreplsrv_pull_cycle_handler_creq(struct composite_context *creq)
+{
+	struct wreplsrv_pull_cycle_state *state = talloc_get_type(creq->async.private_data,
+						  struct wreplsrv_pull_cycle_state);
+	wreplsrv_pull_cycle_handler(state);
+	return;
+}
+
+static void wreplsrv_pull_cycle_handler_req(struct wrepl_request *req)
+{
+	struct wreplsrv_pull_cycle_state *state = talloc_get_type(req->async.private,
+						  struct wreplsrv_pull_cycle_state);
+	wreplsrv_pull_cycle_handler(state);
+	return;
+}
+
+struct composite_context *wreplsrv_pull_cycle_send(TALLOC_CTX *mem_ctx, struct wreplsrv_pull_cycle_io *io)
+{
+	struct composite_context *c = NULL;
+	struct wreplsrv_service *service = io->in.partner->service;
+	struct wreplsrv_pull_cycle_state *state = NULL;
+
+	c = talloc_zero(mem_ctx, struct composite_context);
+	if (!c) goto failed;
+
+	state = talloc_zero(c, struct wreplsrv_pull_cycle_state);
+	if (!state) goto failed;
+	state->c	= c;
+	state->io	= io;
+
+	c->state	= COMPOSITE_STATE_IN_PROGRESS;
+	c->event_ctx	= service->task->event_ctx;
+	c->private_data	= state;
+
+	state->stage	= WREPLSRV_PULL_CYCLE_STAGE_WAIT_TABLE_REPLY;
+	state->table_io.in.partner	= io->in.partner;
+	state->table_io.in.num_owners	= io->in.num_owners;
+	state->table_io.in.owners	= io->in.owners;
+	state->creq = wreplsrv_pull_table_send(state, &state->table_io);
+	if (!state->creq) goto failed;
+
+	state->creq->async.fn		= wreplsrv_pull_cycle_handler_creq;
+	state->creq->async.private_data	= state;
+
+	return c;
+failed:
+	talloc_free(c);
+	return NULL;
+}
+
+NTSTATUS wreplsrv_pull_cycle_recv(struct composite_context *c)
+{
+	NTSTATUS status;
+
+	status = composite_wait(c);
+
+	talloc_free(c);
+	return status;
+}
+
+enum wreplsrv_push_notify_stage {
+	WREPLSRV_PUSH_NOTIFY_STAGE_WAIT_CONNECT,
+	WREPLSRV_PUSH_NOTIFY_STAGE_WAIT_UPDATE,
+	WREPLSRV_PUSH_NOTIFY_STAGE_DONE
+};
+
+struct wreplsrv_push_notify_state {
+	enum wreplsrv_push_notify_stage stage;
+	struct composite_context *c;
+	struct wreplsrv_push_notify_io *io;
+	enum wrepl_replication_cmd command;
+	BOOL full_table;
+	struct wrepl_request *req;
+	struct wrepl_packet req_packet;
+	struct wrepl_packet *rep_packet;
+	struct composite_context *creq;
+	struct wreplsrv_out_connection *wreplconn;
+};
+
+static void wreplsrv_push_notify_handler_creq(struct composite_context *creq);
+static void wreplsrv_push_notify_handler_req(struct wrepl_request *req);
+
+static NTSTATUS wreplsrv_push_notify_update(struct wreplsrv_push_notify_state *state)
+{
+	struct wreplsrv_service *service = state->io->in.partner->service;
+	struct wrepl_packet *req = &state->req_packet;
+	struct wrepl_replication *repl_out = &state->req_packet.message.replication;
+	struct wrepl_table *table_out = &state->req_packet.message.replication.info.table;
+	struct wreplsrv_in_connection *wrepl_in;
+	NTSTATUS status;
+	struct socket_context *sock;
+	struct data_blob_list_item *update_rep;
+	const char *our_ip;
+	DATA_BLOB update_blob;
+
+	req->opcode	= WREPL_OPCODE_BITS;
+	req->assoc_ctx	= state->wreplconn->assoc_ctx.peer_ctx;
+	req->mess_type	= WREPL_REPLICATION;
+
+	repl_out->command = state->command;
+
+	our_ip = socket_get_my_addr(state->wreplconn->sock->sock, state);
+	NT_STATUS_HAVE_NO_MEMORY(our_ip);
+
+	status = wreplsrv_fill_wrepl_table(service, state, table_out,
+					   our_ip, our_ip, state->full_table);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	state->req = wrepl_request_send(state->wreplconn->sock, req);
+	NT_STATUS_HAVE_NO_MEMORY(state->req);
+
+	sock = state->wreplconn->sock->sock;
+	talloc_steal(state, state->wreplconn->sock->sock);
+	state->wreplconn->sock->sock = NULL;
+
+	update_blob = state->req->buffer;
+	talloc_steal(state, state->req->buffer.data);
+
+	talloc_free(state->wreplconn->sock);
+	state->wreplconn->sock = NULL;
+
+	status = wreplsrv_in_connection_merge(state->io->in.partner,
+					      sock, &wrepl_in);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	wrepl_in->assoc_ctx.peer_ctx	= state->wreplconn->assoc_ctx.peer_ctx;
+	wrepl_in->assoc_ctx.our_ctx	= 0;
+
+	update_rep = talloc(wrepl_in, struct data_blob_list_item);
+	NT_STATUS_HAVE_NO_MEMORY(update_rep);
+
+	update_rep->blob = update_blob;
+	talloc_steal(update_rep, update_blob.data);
+
+	talloc_free(state->wreplconn);
+	state->wreplconn = NULL;
+
+	if (!wrepl_in->send_queue) {
+		EVENT_FD_WRITEABLE(wrepl_in->conn->event.fde);
+	}
+	DLIST_ADD_END(wrepl_in->send_queue, update_rep, struct data_blob_list_item *);
+
+	state->stage = WREPLSRV_PUSH_NOTIFY_STAGE_DONE;
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS wreplsrv_push_notify_inform(struct wreplsrv_push_notify_state *state)
+{
+	struct wreplsrv_service *service = state->io->in.partner->service;
+	struct wrepl_packet *req = &state->req_packet;
+	struct wrepl_replication *repl_out = &state->req_packet.message.replication;
+	struct wrepl_table *table_out = &state->req_packet.message.replication.info.table;
+	NTSTATUS status;
+	const char *our_ip;
+
+	req->opcode	= WREPL_OPCODE_BITS;
+	req->assoc_ctx	= state->wreplconn->assoc_ctx.peer_ctx;
+	req->mess_type	= WREPL_REPLICATION;
+
+	repl_out->command = state->command;
+
+	our_ip = socket_get_my_addr(state->wreplconn->sock->sock, state);
+	NT_STATUS_HAVE_NO_MEMORY(our_ip);
+
+	status = wreplsrv_fill_wrepl_table(service, state, table_out,
+					   our_ip, our_ip, state->full_table);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	state->req = wrepl_request_send(state->wreplconn->sock, req);
+	NT_STATUS_HAVE_NO_MEMORY(state->req);
+
+	/* we won't get a reply to a inform message */
+	state->req->send_only		= True;
+	state->req->async.fn		= wreplsrv_push_notify_handler_req;
+	state->req->async.private	= state;
+
+	state->stage = WREPLSRV_PUSH_NOTIFY_STAGE_WAIT_UPDATE;
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS wreplsrv_push_notify_wait_connect(struct wreplsrv_push_notify_state *state)
+{
+	NTSTATUS status;
+
+	status = wreplsrv_out_connect_recv(state->creq, state, &state->wreplconn);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	switch (state->command) {
+	case WREPL_REPL_UPDATE:
+		state->full_table = True;
+		return wreplsrv_push_notify_update(state);
+	case WREPL_REPL_UPDATE2:
+		state->full_table = False;
+		return wreplsrv_push_notify_update(state);
+	case WREPL_REPL_INFORM:
+		state->full_table = True;
+		return wreplsrv_push_notify_inform(state);
+	case WREPL_REPL_INFORM2:
+		state->full_table = False;
+		return wreplsrv_push_notify_inform(state);
+	default:
+		return NT_STATUS_INTERNAL_ERROR;
+	}
+
+	return NT_STATUS_INTERNAL_ERROR;
+}
+
+static NTSTATUS wreplsrv_push_notify_wait_update(struct wreplsrv_push_notify_state *state)
+{
+	return NT_STATUS_FOOBAR;
+}
+
+static void wreplsrv_push_notify_handler(struct wreplsrv_push_notify_state *state)
+{
+	struct composite_context *c = state->c;
+
+	switch (state->stage) {
+	case WREPLSRV_PUSH_NOTIFY_STAGE_WAIT_CONNECT:
+		c->status = wreplsrv_push_notify_wait_connect(state);
+		break;
+	case WREPLSRV_PUSH_NOTIFY_STAGE_WAIT_UPDATE:
+		c->status = wreplsrv_push_notify_wait_update(state);
+		break;
+	case WREPLSRV_PUSH_NOTIFY_STAGE_DONE:
+		c->status = NT_STATUS_INTERNAL_ERROR;
+	}
+
+	if (state->stage == WREPLSRV_PUSH_NOTIFY_STAGE_DONE) {
+		c->state  = COMPOSITE_STATE_DONE;
+	}
+
+	if (!NT_STATUS_IS_OK(c->status)) {
+		c->state = COMPOSITE_STATE_ERROR;
+	}
+
+	if (c->state >= COMPOSITE_STATE_DONE && c->async.fn) {
+		c->async.fn(c);
+	}
+}
+
+static void wreplsrv_push_notify_handler_creq(struct composite_context *creq)
+{
+	struct wreplsrv_push_notify_state *state = talloc_get_type(creq->async.private_data,
+						   struct wreplsrv_push_notify_state);
+	wreplsrv_push_notify_handler(state);
+	return;
+}
+
+static void wreplsrv_push_notify_handler_req(struct wrepl_request *req)
+{
+	struct wreplsrv_push_notify_state *state = talloc_get_type(req->async.private,
+						   struct wreplsrv_push_notify_state);
+	wreplsrv_push_notify_handler(state);
+	return;
+}
+
+struct composite_context *wreplsrv_push_notify_send(TALLOC_CTX *mem_ctx, struct wreplsrv_push_notify_io *io)
+{
+	struct composite_context *c = NULL;
+	struct wreplsrv_service *service = io->in.partner->service;
+	struct wreplsrv_push_notify_state *state = NULL;
+	enum winsrepl_partner_type partner_type;
+
+	c = talloc_zero(mem_ctx, struct composite_context);
+	if (!c) goto failed;
+
+	state = talloc_zero(c, struct wreplsrv_push_notify_state);
+	if (!state) goto failed;
+	state->c	= c;
+	state->io	= io;
+
+	if (io->in.inform) {
+		/* we can cache the connection in partner->push->wreplconn */
+		partner_type = WINSREPL_PARTNER_PUSH;
+		if (io->in.propagate) {
+			state->command	= WREPL_REPL_INFORM2;
+		} else {
+			state->command	= WREPL_REPL_INFORM;
+		}
+	} else {
+		/* we can NOT cache the connection */
+		partner_type = WINSREPL_PARTNER_NONE;
+		if (io->in.propagate) {
+			state->command	= WREPL_REPL_UPDATE2;
+		} else {
+			state->command	= WREPL_REPL_UPDATE;
+		}	
+	}
+
+	c->state	= COMPOSITE_STATE_IN_PROGRESS;
+	c->event_ctx	= service->task->event_ctx;
+	c->private_data	= state;
+
+	state->stage	= WREPLSRV_PUSH_NOTIFY_STAGE_WAIT_CONNECT;
+	state->creq	= wreplsrv_out_connect_send(io->in.partner, partner_type, NULL);
+	if (!state->creq) goto failed;
+
+	state->creq->async.fn		= wreplsrv_push_notify_handler_creq;
+	state->creq->async.private_data	= state;
+
+	return c;
+failed:
+	talloc_free(c);
+	return NULL;
+}
+
+NTSTATUS wreplsrv_push_notify_recv(struct composite_context *c)
+{
+	NTSTATUS status;
+
+	status = composite_wait(c);
+
+	talloc_free(c);
+	return status;
+}
-- 
cgit 


From e7d4f5555fddd24a4bd09c56c89ec690c0bc2c85 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Wed, 23 Nov 2005 11:37:54 +0000
Subject: r11878: don't get only newer records than the last one we got

metze
(This used to be commit 52b1cdae9e21f7cbf4d1411adc2ce44ca3d85bba)
---
 source4/wrepl_server/wrepl_out_helpers.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index 217bb87d48..36d189a4d0 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -577,7 +577,7 @@ static NTSTATUS wreplsrv_pull_cycle_next_owner_do_work(struct wreplsrv_pull_cycl
 		state->names_io.in.partner		= state->io->in.partner;
 		state->names_io.in.wreplconn		= state->io->in.wreplconn;
 		state->names_io.in.owner		= current_owner->owner;
-		state->names_io.in.owner.min_version	= old_max_version;
+		state->names_io.in.owner.min_version	= old_max_version + 1;
 		state->creq = wreplsrv_pull_names_send(state, &state->names_io);
 		NT_STATUS_HAVE_NO_MEMORY(state->creq);
 
-- 
cgit 


From 111a920fdb92ccef32f89b2f992bdd3051e5ac54 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 8 Dec 2005 01:13:45 +0000
Subject: r12116: got rid of composite_trigger_done() and
 composite_trigger_error(), and instead make the normal composite_done() and
 composite_error() functions automatically trigger a delayed callback if the
 caller has had no opportunity to setup a async callback

this removes one of the common mistakes in writing a composite function
(This used to be commit f9413ce792ded682e05134b66d433eeec293e6f1)
---
 source4/wrepl_server/wrepl_out_helpers.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index 36d189a4d0..c7c6f55767 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -156,12 +156,12 @@ static struct composite_context *wreplsrv_out_connect_send(struct wreplsrv_partn
 		if (!wreplconn->sock->dead) {
 			state->stage	= WREPLSRV_OUT_CONNECT_STAGE_DONE;
 			state->wreplconn= wreplconn;
-			composite_trigger_done(c);
+			composite_done(c);
 			return c;
 		} else if (!cached_connection) {
 			state->stage	= WREPLSRV_OUT_CONNECT_STAGE_DONE;
 			state->wreplconn= NULL;
-			composite_trigger_done(c);
+			composite_done(c);
 			return c;
 		} else {
 			talloc_free(wreplconn);
@@ -328,7 +328,7 @@ struct composite_context *wreplsrv_pull_table_send(TALLOC_CTX *mem_ctx, struct w
 		state->table_io.out.num_partners	= io->in.num_owners;
 		state->table_io.out.partners		= io->in.owners;
 		state->stage				= WREPLSRV_PULL_TABLE_STAGE_DONE;
-		composite_trigger_done(c);
+		composite_done(c);
 		return c;
 	}
 
-- 
cgit 


From 36acd6e79c8cb881b9c333313402d993a6d0f511 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Mon, 12 Dec 2005 21:31:42 +0000
Subject: r12200: - move the the winsreplication client and server code to the
 packet_context   system - this needs to be in one big patch, because of the
 merging code,   that changes client in server connections and the other way
 around - use socket_connect_send/_recv() in the client code

metze
(This used to be commit f0105b7fcdc3032d22444a1973927fff2dd9a06f)
---
 source4/wrepl_server/wrepl_out_helpers.c | 105 ++++++++++++++++++++++---------
 1 file changed, 74 insertions(+), 31 deletions(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index c7c6f55767..d19c38bfb8 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -45,24 +45,26 @@ struct wreplsrv_out_connect_state {
 	enum wreplsrv_out_connect_stage stage;
 	struct composite_context *c;
 	struct wrepl_request *req;
+	struct composite_context *c_req;
 	struct wrepl_associate assoc_io;
 	enum winsrepl_partner_type type;
 	struct wreplsrv_out_connection *wreplconn;
 };
 
-static void wreplsrv_out_connect_handler(struct wrepl_request *req);
+static void wreplsrv_out_connect_handler_creq(struct composite_context *c_req);
+static void wreplsrv_out_connect_handler_req(struct wrepl_request *req);
 
 static NTSTATUS wreplsrv_out_connect_wait_socket(struct wreplsrv_out_connect_state *state)
 {
 	NTSTATUS status;
 
-	status = wrepl_connect_recv(state->req);
+	status = wrepl_connect_recv(state->c_req);
 	NT_STATUS_NOT_OK_RETURN(status);
 
 	state->req = wrepl_associate_send(state->wreplconn->sock, &state->assoc_io);
 	NT_STATUS_HAVE_NO_MEMORY(state->req);
 
-	state->req->async.fn		= wreplsrv_out_connect_handler;
+	state->req->async.fn		= wreplsrv_out_connect_handler_req;
 	state->req->async.private	= state;
 
 	state->stage = WREPLSRV_OUT_CONNECT_STAGE_WAIT_ASSOC_CTX;
@@ -92,10 +94,8 @@ static NTSTATUS wreplsrv_out_connect_wait_assoc_ctx(struct wreplsrv_out_connect_
 	return NT_STATUS_OK;
 }
 
-static void wreplsrv_out_connect_handler(struct wrepl_request *req)
+static void wreplsrv_out_connect_handler(struct wreplsrv_out_connect_state *state)
 {
-	struct wreplsrv_out_connect_state *state = talloc_get_type(req->async.private,
-						   struct wreplsrv_out_connect_state);
 	struct composite_context *c = state->c;
 
 	switch (state->stage) {
@@ -119,6 +119,22 @@ static void wreplsrv_out_connect_handler(struct wrepl_request *req)
 	}
 }
 
+static void wreplsrv_out_connect_handler_creq(struct composite_context *creq)
+{
+	struct wreplsrv_out_connect_state *state = talloc_get_type(creq->async.private_data,
+						   struct wreplsrv_out_connect_state);
+	wreplsrv_out_connect_handler(state);
+	return;
+}
+
+static void wreplsrv_out_connect_handler_req(struct wrepl_request *req)
+{
+	struct wreplsrv_out_connect_state *state = talloc_get_type(req->async.private,
+						   struct wreplsrv_out_connect_state);
+	wreplsrv_out_connect_handler(state);
+	return;
+}
+
 static struct composite_context *wreplsrv_out_connect_send(struct wreplsrv_partner *partner,
 							   enum winsrepl_partner_type type,
 							   struct wreplsrv_out_connection *wreplconn)
@@ -179,13 +195,13 @@ static struct composite_context *wreplsrv_out_connect_send(struct wreplsrv_partn
 
 	state->stage	= WREPLSRV_OUT_CONNECT_STAGE_WAIT_SOCKET;
 	state->wreplconn= wreplconn;
-	state->req	= wrepl_connect_send(wreplconn->sock,
+	state->c_req	= wrepl_connect_send(wreplconn->sock,
 					     partner->our_address,
 					     partner->address);
-	if (!state->req) goto failed;
+	if (!state->c_req) goto failed;
 
-	state->req->async.fn		= wreplsrv_out_connect_handler;
-	state->req->async.private	= state;
+	state->c_req->async.fn			= wreplsrv_out_connect_handler_creq;
+	state->c_req->async.private_data	= state;
 
 	return c;
 failed:
@@ -796,6 +812,7 @@ struct wreplsrv_push_notify_state {
 	struct wreplsrv_push_notify_io *io;
 	enum wrepl_replication_cmd command;
 	BOOL full_table;
+	struct wrepl_send_ctrl ctrl;
 	struct wrepl_request *req;
 	struct wrepl_packet req_packet;
 	struct wrepl_packet *rep_packet;
@@ -815,10 +832,11 @@ static NTSTATUS wreplsrv_push_notify_update(struct wreplsrv_push_notify_state *s
 	struct wreplsrv_in_connection *wrepl_in;
 	NTSTATUS status;
 	struct socket_context *sock;
-	struct data_blob_list_item *update_rep;
+	struct packet_context *packet;
+	uint16_t fde_flags;
 	const char *our_ip;
-	DATA_BLOB update_blob;
 
+	/* prepare the outgoing request */
 	req->opcode	= WREPL_OPCODE_BITS;
 	req->assoc_ctx	= state->wreplconn->assoc_ctx.peer_ctx;
 	req->mess_type	= WREPL_REPLICATION;
@@ -832,40 +850,64 @@ static NTSTATUS wreplsrv_push_notify_update(struct wreplsrv_push_notify_state *s
 					   our_ip, our_ip, state->full_table);
 	NT_STATUS_NOT_OK_RETURN(status);
 
-	state->req = wrepl_request_send(state->wreplconn->sock, req);
+	/* queue the request */
+	state->req = wrepl_request_send(state->wreplconn->sock, req, NULL);
 	NT_STATUS_HAVE_NO_MEMORY(state->req);
 
+	/*
+	 * now we need to convert the wrepl_socket (client connection)
+	 * into a wreplsrv_in_connection (server connection), because
+	 * we'll act as a server on this connection after the WREPL_REPL_UPDATE*
+	 * message is received by the peer.
+	 */
+
+	/* steal the socket_context */
 	sock = state->wreplconn->sock->sock;
-	talloc_steal(state, state->wreplconn->sock->sock);
 	state->wreplconn->sock->sock = NULL;
+	talloc_steal(state, sock);
 
-	update_blob = state->req->buffer;
-	talloc_steal(state, state->req->buffer.data);
+	/* 
+	 * steal the packet_context
+	 * note the request DATA_BLOB we just send on the
+	 * wrepl_socket (client connection) is still unter the 
+	 * packet context and will be send to the wire
+	 */
+	packet = state->wreplconn->sock->packet;
+	state->wreplconn->sock->packet = NULL;
+	talloc_steal(state, packet);
+
+	/*
+	 * get the fde_flags of the old fde event,
+	 * so that we can later set the same flags to the new one
+	 */
+	fde_flags = event_get_fd_flags(state->wreplconn->sock->event.fde);
 
+	/*
+	 * free the wrepl_socket (client connection)
+	 */
 	talloc_free(state->wreplconn->sock);
 	state->wreplconn->sock = NULL;
 
+	/*
+	 * now create a wreplsrv_in_connection,
+	 * on which we act as server
+	 *
+	 * NOTE: sock and packet will be stolen by
+	 *       wreplsrv_in_connection_merge()
+	 */
 	status = wreplsrv_in_connection_merge(state->io->in.partner,
-					      sock, &wrepl_in);
+					      sock, packet, &wrepl_in);
 	NT_STATUS_NOT_OK_RETURN(status);
 
+	event_set_fd_flags(wrepl_in->conn->event.fde, fde_flags);
+
 	wrepl_in->assoc_ctx.peer_ctx	= state->wreplconn->assoc_ctx.peer_ctx;
 	wrepl_in->assoc_ctx.our_ctx	= 0;
 
-	update_rep = talloc(wrepl_in, struct data_blob_list_item);
-	NT_STATUS_HAVE_NO_MEMORY(update_rep);
-
-	update_rep->blob = update_blob;
-	talloc_steal(update_rep, update_blob.data);
-
+	/* now we can free the wreplsrv_out_connection */
 	talloc_free(state->wreplconn);
 	state->wreplconn = NULL;
 
-	if (!wrepl_in->send_queue) {
-		EVENT_FD_WRITEABLE(wrepl_in->conn->event.fde);
-	}
-	DLIST_ADD_END(wrepl_in->send_queue, update_rep, struct data_blob_list_item *);
-
 	state->stage = WREPLSRV_PUSH_NOTIFY_STAGE_DONE;
 
 	return NT_STATUS_OK;
@@ -893,11 +935,12 @@ static NTSTATUS wreplsrv_push_notify_inform(struct wreplsrv_push_notify_state *s
 					   our_ip, our_ip, state->full_table);
 	NT_STATUS_NOT_OK_RETURN(status);
 
-	state->req = wrepl_request_send(state->wreplconn->sock, req);
+	/* we won't get a reply to a inform message */
+	state->ctrl.send_only		= True;
+
+	state->req = wrepl_request_send(state->wreplconn->sock, req, &state->ctrl);
 	NT_STATUS_HAVE_NO_MEMORY(state->req);
 
-	/* we won't get a reply to a inform message */
-	state->req->send_only		= True;
 	state->req->async.fn		= wreplsrv_push_notify_handler_req;
 	state->req->async.private	= state;
 
-- 
cgit 


From b1e50046657fcb8877b9199919f252f99ea701a0 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Wed, 14 Dec 2005 19:07:53 +0000
Subject: r12241: fix the inform push notifies

metze
(This used to be commit 626d0e6fe508603f5f28b88fd18ff5d71a4660ca)
---
 source4/wrepl_server/wrepl_out_helpers.c | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index d19c38bfb8..b990880fff 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -802,7 +802,7 @@ NTSTATUS wreplsrv_pull_cycle_recv(struct composite_context *c)
 
 enum wreplsrv_push_notify_stage {
 	WREPLSRV_PUSH_NOTIFY_STAGE_WAIT_CONNECT,
-	WREPLSRV_PUSH_NOTIFY_STAGE_WAIT_UPDATE,
+	WREPLSRV_PUSH_NOTIFY_STAGE_WAIT_INFORM,
 	WREPLSRV_PUSH_NOTIFY_STAGE_DONE
 };
 
@@ -944,7 +944,7 @@ static NTSTATUS wreplsrv_push_notify_inform(struct wreplsrv_push_notify_state *s
 	state->req->async.fn		= wreplsrv_push_notify_handler_req;
 	state->req->async.private	= state;
 
-	state->stage = WREPLSRV_PUSH_NOTIFY_STAGE_WAIT_UPDATE;
+	state->stage = WREPLSRV_PUSH_NOTIFY_STAGE_WAIT_INFORM;
 
 	return NT_STATUS_OK;
 }
@@ -976,9 +976,15 @@ static NTSTATUS wreplsrv_push_notify_wait_connect(struct wreplsrv_push_notify_st
 	return NT_STATUS_INTERNAL_ERROR;
 }
 
-static NTSTATUS wreplsrv_push_notify_wait_update(struct wreplsrv_push_notify_state *state)
+static NTSTATUS wreplsrv_push_notify_wait_inform(struct wreplsrv_push_notify_state *state)
 {
-	return NT_STATUS_FOOBAR;
+	NTSTATUS status;
+
+	status =  wrepl_request_recv(state->req, state, NULL);
+	NT_STATUS_NOT_OK_RETURN(status);
+
+	state->stage = WREPLSRV_PUSH_NOTIFY_STAGE_DONE;
+	return status;
 }
 
 static void wreplsrv_push_notify_handler(struct wreplsrv_push_notify_state *state)
@@ -989,8 +995,8 @@ static void wreplsrv_push_notify_handler(struct wreplsrv_push_notify_state *stat
 	case WREPLSRV_PUSH_NOTIFY_STAGE_WAIT_CONNECT:
 		c->status = wreplsrv_push_notify_wait_connect(state);
 		break;
-	case WREPLSRV_PUSH_NOTIFY_STAGE_WAIT_UPDATE:
-		c->status = wreplsrv_push_notify_wait_update(state);
+	case WREPLSRV_PUSH_NOTIFY_STAGE_WAIT_INFORM:
+		c->status = wreplsrv_push_notify_wait_inform(state);
 		break;
 	case WREPLSRV_PUSH_NOTIFY_STAGE_DONE:
 		c->status = NT_STATUS_INTERNAL_ERROR;
-- 
cgit 


From d4de4c2d210d2e8c9b5aedf70695594809ad6a0b Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Fri, 30 Dec 2005 13:16:54 +0000
Subject: r12608: Remove some unused #include lines. (This used to be commit
 70e7449318aa0e9d2639c76730a7d1683b2f4981)

---
 source4/wrepl_server/wrepl_out_helpers.c | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index b990880fff..3b69b40fa0 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -21,17 +21,13 @@
 */
 
 #include "includes.h"
-#include "dlinklist.h"
 #include "lib/events/events.h"
 #include "lib/socket/socket.h"
 #include "smbd/service_task.h"
 #include "smbd/service_stream.h"
-#include "lib/messaging/irpc.h"
 #include "librpc/gen_ndr/ndr_winsrepl.h"
 #include "wrepl_server/wrepl_server.h"
 #include "wrepl_server/wrepl_out_helpers.h"
-#include "nbt_server/wins/winsdb.h"
-#include "ldb/include/ldb.h"
 #include "libcli/composite/composite.h"
 #include "libcli/wrepl/winsrepl.h"
 
-- 
cgit 


From b75ed7d7ac9b3d5beca71926a15cfec5e3a0092c Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Mon, 2 Jan 2006 17:19:09 +0000
Subject: r12677: get rid of the special cases for the local wins owner table
 entry, the call to winsdb_get_maxVersion() is moved into place.

This allows us to fetch records with the owner address that matches
our local_owner address, this is important if the restart with an empty wins.ldb.
w2k3 does this in the same way when you remove the database files from disk and restart
the WINS-Service.

metze
(This used to be commit e43de87d06614206a858e1102cd82e7f02163bba)
---
 source4/wrepl_server/wrepl_out_helpers.c | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index 3b69b40fa0..738d89a55b 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -552,10 +552,12 @@ static NTSTATUS wreplsrv_pull_cycle_next_owner_do_work(struct wreplsrv_pull_cycl
 	BOOL do_pull = False;
 
 	for (i=state->current; i < state->table_io.out.num_owners; i++) {
-		current_owner = wreplsrv_find_owner(state->io->in.partner->pull.table,
+		current_owner = wreplsrv_find_owner(state->io->in.partner->service,
+						    state->io->in.partner->pull.table,
 						    state->table_io.out.owners[i].address);
 
-		local_owner = wreplsrv_find_owner(state->io->in.partner->service->table,
+		local_owner = wreplsrv_find_owner(state->io->in.partner->service,
+						  state->io->in.partner->service->table,
 						  state->table_io.out.owners[i].address);
 		/*
 		 * this means we are ourself the current owner,
@@ -639,12 +641,6 @@ static NTSTATUS wreplsrv_pull_cycle_wait_table_reply(struct wreplsrv_pull_cycle_
 
 	/* update partner table */
 	for (i=0; i < state->table_io.out.num_owners; i++) {
-		BOOL is_our_addr;
-
-		is_our_addr = wreplsrv_is_our_address(state->io->in.partner->service,
-						      state->table_io.out.owners[i].address);
-		if (is_our_addr) continue;
-
 		status = wreplsrv_add_table(state->io->in.partner->service,
 					    state->io->in.partner, 
 					    &state->io->in.partner->pull.table,
@@ -843,7 +839,7 @@ static NTSTATUS wreplsrv_push_notify_update(struct wreplsrv_push_notify_state *s
 	NT_STATUS_HAVE_NO_MEMORY(our_ip);
 
 	status = wreplsrv_fill_wrepl_table(service, state, table_out,
-					   our_ip, our_ip, state->full_table);
+					   our_ip, state->full_table);
 	NT_STATUS_NOT_OK_RETURN(status);
 
 	/* queue the request */
@@ -928,7 +924,7 @@ static NTSTATUS wreplsrv_push_notify_inform(struct wreplsrv_push_notify_state *s
 	NT_STATUS_HAVE_NO_MEMORY(our_ip);
 
 	status = wreplsrv_fill_wrepl_table(service, state, table_out,
-					   our_ip, our_ip, state->full_table);
+					   our_ip, state->full_table);
 	NT_STATUS_NOT_OK_RETURN(status);
 
 	/* we won't get a reply to a inform message */
-- 
cgit 


From 63d718e243fd03e6ea24c47e7442975ec088a5b5 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Tue, 3 Jan 2006 17:27:33 +0000
Subject: r12696: Reduce the size of include/structs.h (This used to be commit
 63917616016133c623fc6ff59454bc313ee7dd8f)

---
 source4/wrepl_server/wrepl_out_helpers.c | 1 -
 1 file changed, 1 deletion(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index 738d89a55b..b0cf039281 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -27,7 +27,6 @@
 #include "smbd/service_stream.h"
 #include "librpc/gen_ndr/ndr_winsrepl.h"
 #include "wrepl_server/wrepl_server.h"
-#include "wrepl_server/wrepl_out_helpers.h"
 #include "libcli/composite/composite.h"
 #include "libcli/wrepl/winsrepl.h"
 
-- 
cgit 


From f0e3a0312d77086015e5662494b6be24a51b0091 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Mon, 9 Jan 2006 17:03:17 +0000
Subject: r12796: use the correct address as initiator

metze
(This used to be commit ba97e7c06af6f919a66622c1a6b6e58980ab2b9e)
---
 source4/wrepl_server/wrepl_out_helpers.c | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index b0cf039281..dbcddf859c 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -27,6 +27,7 @@
 #include "smbd/service_stream.h"
 #include "librpc/gen_ndr/ndr_winsrepl.h"
 #include "wrepl_server/wrepl_server.h"
+#include "nbt_server/wins/winsdb.h"
 #include "libcli/composite/composite.h"
 #include "libcli/wrepl/winsrepl.h"
 
@@ -825,7 +826,6 @@ static NTSTATUS wreplsrv_push_notify_update(struct wreplsrv_push_notify_state *s
 	struct socket_context *sock;
 	struct packet_context *packet;
 	uint16_t fde_flags;
-	const char *our_ip;
 
 	/* prepare the outgoing request */
 	req->opcode	= WREPL_OPCODE_BITS;
@@ -834,11 +834,8 @@ static NTSTATUS wreplsrv_push_notify_update(struct wreplsrv_push_notify_state *s
 
 	repl_out->command = state->command;
 
-	our_ip = socket_get_my_addr(state->wreplconn->sock->sock, state);
-	NT_STATUS_HAVE_NO_MEMORY(our_ip);
-
 	status = wreplsrv_fill_wrepl_table(service, state, table_out,
-					   our_ip, state->full_table);
+					   service->wins_db->local_owner, state->full_table);
 	NT_STATUS_NOT_OK_RETURN(status);
 
 	/* queue the request */
@@ -911,7 +908,6 @@ static NTSTATUS wreplsrv_push_notify_inform(struct wreplsrv_push_notify_state *s
 	struct wrepl_replication *repl_out = &state->req_packet.message.replication;
 	struct wrepl_table *table_out = &state->req_packet.message.replication.info.table;
 	NTSTATUS status;
-	const char *our_ip;
 
 	req->opcode	= WREPL_OPCODE_BITS;
 	req->assoc_ctx	= state->wreplconn->assoc_ctx.peer_ctx;
@@ -919,11 +915,8 @@ static NTSTATUS wreplsrv_push_notify_inform(struct wreplsrv_push_notify_state *s
 
 	repl_out->command = state->command;
 
-	our_ip = socket_get_my_addr(state->wreplconn->sock->sock, state);
-	NT_STATUS_HAVE_NO_MEMORY(our_ip);
-
 	status = wreplsrv_fill_wrepl_table(service, state, table_out,
-					   our_ip, state->full_table);
+					   service->wins_db->local_owner, state->full_table);
 	NT_STATUS_NOT_OK_RETURN(status);
 
 	/* we won't get a reply to a inform message */
-- 
cgit 


From 8528016978b084213ef53d66e1b6e831b1a01acc Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Thu, 16 Mar 2006 00:23:11 +0000
Subject: r14464: Don't include ndr_BASENAME.h files unless strictly required,
 instead try to include just the BASENAME.h files (containing only structs)
 (This used to be commit 3dd477ca5147f28a962b8437e2611a8222d706bd)

---
 source4/wrepl_server/wrepl_out_helpers.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index dbcddf859c..e1dca20671 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -25,7 +25,7 @@
 #include "lib/socket/socket.h"
 #include "smbd/service_task.h"
 #include "smbd/service_stream.h"
-#include "librpc/gen_ndr/ndr_winsrepl.h"
+#include "librpc/gen_ndr/winsrepl.h"
 #include "wrepl_server/wrepl_server.h"
 #include "nbt_server/wins/winsdb.h"
 #include "libcli/composite/composite.h"
-- 
cgit 


From c53c91963aaa717c9c612715bd3f01a5a6d76b35 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Thu, 20 Apr 2006 11:42:03 +0000
Subject: r15147: make some more stuff static

metze
(This used to be commit c49ac7f40d366aad3701623dd36568efb88eccb5)
---
 source4/wrepl_server/wrepl_out_helpers.c | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index e1dca20671..8be6cab85e 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -228,6 +228,18 @@ static NTSTATUS wreplsrv_out_connect_recv(struct composite_context *c, TALLOC_CT
 	
 }
 
+struct wreplsrv_pull_table_io {
+	struct {
+		struct wreplsrv_partner *partner;
+		uint32_t num_owners;
+		struct wrepl_wins_owner *owners;
+	} in;
+	struct {
+		uint32_t num_owners;
+		struct wrepl_wins_owner *owners;
+	} out;
+};
+
 enum wreplsrv_pull_table_stage {
 	WREPLSRV_PULL_TABLE_STAGE_WAIT_CONNECTION,
 	WREPLSRV_PULL_TABLE_STAGE_WAIT_TABLE_REPLY,
@@ -318,7 +330,7 @@ static void wreplsrv_pull_table_handler_req(struct wrepl_request *req)
 	return;
 }
 
-struct composite_context *wreplsrv_pull_table_send(TALLOC_CTX *mem_ctx, struct wreplsrv_pull_table_io *io)
+static struct composite_context *wreplsrv_pull_table_send(TALLOC_CTX *mem_ctx, struct wreplsrv_pull_table_io *io)
 {
 	struct composite_context *c = NULL;
 	struct wreplsrv_service *service = io->in.partner->service;
@@ -357,8 +369,8 @@ failed:
 	return NULL;
 }
 
-NTSTATUS wreplsrv_pull_table_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
-				  struct wreplsrv_pull_table_io *io)
+static NTSTATUS wreplsrv_pull_table_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
+					 struct wreplsrv_pull_table_io *io)
 {
 	NTSTATUS status;
 
-- 
cgit 


From 0082a4ce97c0a4484c1868babb965b172ff3d689 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Thu, 20 Apr 2006 12:00:38 +0000
Subject: r15148: make wreplsrv_pull_names static

metze
(This used to be commit ce3d4ec0f67ecf7a403fb7d46ed5f6dc0b2bc275)
---
 source4/wrepl_server/wrepl_out_helpers.c | 23 +++++++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index 8be6cab85e..968c2fdc37 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -388,6 +388,18 @@ static NTSTATUS wreplsrv_pull_table_recv(struct composite_context *c, TALLOC_CTX
 	return status;	
 }
 
+struct wreplsrv_pull_names_io {
+	struct {
+		struct wreplsrv_partner *partner;
+		struct wreplsrv_out_connection *wreplconn;
+		struct wrepl_wins_owner owner;
+	} in;
+	struct {
+		uint32_t num_names;
+		struct wrepl_name *names;
+	} out;
+};
+
 enum wreplsrv_pull_names_stage {
 	WREPLSRV_PULL_NAMES_STAGE_WAIT_CONNECTION,
 	WREPLSRV_PULL_NAMES_STAGE_WAIT_SEND_REPLY,
@@ -479,7 +491,7 @@ static void wreplsrv_pull_names_handler_req(struct wrepl_request *req)
 	return;
 }
 
-struct composite_context *wreplsrv_pull_names_send(TALLOC_CTX *mem_ctx, struct wreplsrv_pull_names_io *io)
+static struct composite_context *wreplsrv_pull_names_send(TALLOC_CTX *mem_ctx, struct wreplsrv_pull_names_io *io)
 {
 	struct composite_context *c = NULL;
 	struct wreplsrv_service *service = io->in.partner->service;
@@ -513,8 +525,8 @@ failed:
 	return NULL;
 }
 
-NTSTATUS wreplsrv_pull_names_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
-				  struct wreplsrv_pull_names_io *io)
+static NTSTATUS wreplsrv_pull_names_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
+					 struct wreplsrv_pull_names_io *io)
 {
 	NTSTATUS status;
 
@@ -671,7 +683,10 @@ static NTSTATUS wreplsrv_pull_cycle_apply_records(struct wreplsrv_pull_cycle_sta
 {
 	NTSTATUS status;
 
-	status = wreplsrv_apply_records(state->io->in.partner, &state->names_io);
+	status = wreplsrv_apply_records(state->io->in.partner,
+					&state->names_io.in.owner,
+					state->names_io.out.num_names,
+					state->names_io.out.names);
 	NT_STATUS_NOT_OK_RETURN(status);
 
 	talloc_free(state->names_io.out.names);
-- 
cgit 


From 0ee52751f3fba0fc73360696bb15ece0a10f64b7 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 10 Sep 2006 11:32:42 +0000
Subject: r18331: fixed a warning (This used to be commit
 997ed10bf540cc99da1bab5e53634beb3b239253)

---
 source4/wrepl_server/wrepl_out_helpers.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index 968c2fdc37..ff2dd12cd5 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -569,7 +569,7 @@ static void wreplsrv_pull_cycle_handler_req(struct wrepl_request *req);
 
 static NTSTATUS wreplsrv_pull_cycle_next_owner_do_work(struct wreplsrv_pull_cycle_state *state)
 {
-	struct wreplsrv_owner *current_owner;
+	struct wreplsrv_owner *current_owner=NULL;
 	struct wreplsrv_owner *local_owner;
 	uint32_t i;
 	uint64_t old_max_version = 0;
-- 
cgit 


From 0479a2f1cbae51fcd8dbdc3c148c808421fb4d25 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 10 Jul 2007 02:07:03 +0000
Subject: r23792: convert Samba4 to GPLv3

There are still a few tidyups of old FSF addresses to come (in both s3
and s4). More commits soon.
(This used to be commit fcf38a38ac691abd0fa51b89dc951a08e89fdafa)
---
 source4/wrepl_server/wrepl_out_helpers.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index ff2dd12cd5..9675c5abd0 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -7,7 +7,7 @@
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
@@ -16,8 +16,7 @@
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "includes.h"
-- 
cgit 


From af0a85bc30223d65f09dc57dea4427a7773d6ddb Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sat, 6 Oct 2007 21:48:28 +0000
Subject: r25549: Convert to standard bool type. (This used to be commit
 318bf1f7441678860adfff5cdb0d3d2448e58f4b)

---
 source4/wrepl_server/wrepl_out_helpers.c | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index 9675c5abd0..2599ef4d09 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -138,7 +138,7 @@ static struct composite_context *wreplsrv_out_connect_send(struct wreplsrv_partn
 	struct wreplsrv_service *service = partner->service;
 	struct wreplsrv_out_connect_state *state = NULL;
 	struct wreplsrv_out_connection **wreplconnp = &wreplconn;
-	BOOL cached_connection = False;
+	bool cached_connection = false;
 
 	c = talloc_zero(partner, struct composite_context);
 	if (!c) goto failed;
@@ -153,11 +153,11 @@ static struct composite_context *wreplsrv_out_connect_send(struct wreplsrv_partn
 	c->private_data	= state;
 
 	if (type == WINSREPL_PARTNER_PUSH) {
-		cached_connection	= True;
+		cached_connection	= true;
 		wreplconn		= partner->push.wreplconn;
 		wreplconnp		= &partner->push.wreplconn;
 	} else if (type == WINSREPL_PARTNER_PULL) {
-		cached_connection	= True;
+		cached_connection	= true;
 		wreplconn		= partner->pull.wreplconn;
 		wreplconnp		= &partner->pull.wreplconn;
 	}
@@ -572,7 +572,7 @@ static NTSTATUS wreplsrv_pull_cycle_next_owner_do_work(struct wreplsrv_pull_cycl
 	struct wreplsrv_owner *local_owner;
 	uint32_t i;
 	uint64_t old_max_version = 0;
-	BOOL do_pull = False;
+	bool do_pull = false;
 
 	for (i=state->current; i < state->table_io.out.num_owners; i++) {
 		current_owner = wreplsrv_find_owner(state->io->in.partner->service,
@@ -593,7 +593,7 @@ static NTSTATUS wreplsrv_pull_cycle_next_owner_do_work(struct wreplsrv_pull_cycl
 		 * so fetch them
 		 */
 		if (!local_owner) {
-			do_pull		= True;
+			do_pull		= true;
 			
 			break;
 		}
@@ -603,7 +603,7 @@ static NTSTATUS wreplsrv_pull_cycle_next_owner_do_work(struct wreplsrv_pull_cycl
 		 * fetch them
 		 */
 		if (current_owner->owner.max_version > local_owner->owner.max_version) {
-			do_pull		= True;
+			do_pull		= true;
 			old_max_version	= local_owner->owner.max_version;
 			break;
 		}
@@ -829,7 +829,7 @@ struct wreplsrv_push_notify_state {
 	struct composite_context *c;
 	struct wreplsrv_push_notify_io *io;
 	enum wrepl_replication_cmd command;
-	BOOL full_table;
+	bool full_table;
 	struct wrepl_send_ctrl ctrl;
 	struct wrepl_request *req;
 	struct wrepl_packet req_packet;
@@ -946,7 +946,7 @@ static NTSTATUS wreplsrv_push_notify_inform(struct wreplsrv_push_notify_state *s
 	NT_STATUS_NOT_OK_RETURN(status);
 
 	/* we won't get a reply to a inform message */
-	state->ctrl.send_only		= True;
+	state->ctrl.send_only		= true;
 
 	state->req = wrepl_request_send(state->wreplconn->sock, req, &state->ctrl);
 	NT_STATUS_HAVE_NO_MEMORY(state->req);
@@ -968,16 +968,16 @@ static NTSTATUS wreplsrv_push_notify_wait_connect(struct wreplsrv_push_notify_st
 
 	switch (state->command) {
 	case WREPL_REPL_UPDATE:
-		state->full_table = True;
+		state->full_table = true;
 		return wreplsrv_push_notify_update(state);
 	case WREPL_REPL_UPDATE2:
-		state->full_table = False;
+		state->full_table = false;
 		return wreplsrv_push_notify_update(state);
 	case WREPL_REPL_INFORM:
-		state->full_table = True;
+		state->full_table = true;
 		return wreplsrv_push_notify_inform(state);
 	case WREPL_REPL_INFORM2:
-		state->full_table = False;
+		state->full_table = false;
 		return wreplsrv_push_notify_inform(state);
 	default:
 		return NT_STATUS_INTERNAL_ERROR;
-- 
cgit 


From f055893ca571fbeac3675c02344c7cc53106bea1 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 10 Dec 2007 18:41:55 +0100
Subject: r26382: Remove more uses of global_loadparm. (This used to be commit
 6d4c59853481855c232e7cf97264a391f40af2b5)

---
 source4/wrepl_server/wrepl_out_helpers.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index 2599ef4d09..f809095f22 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -29,6 +29,7 @@
 #include "nbt_server/wins/winsdb.h"
 #include "libcli/composite/composite.h"
 #include "libcli/wrepl/winsrepl.h"
+#include "libcli/resolve/resolve.h"
 
 enum wreplsrv_out_connect_stage {
 	WREPLSRV_OUT_CONNECT_STAGE_WAIT_SOCKET,
@@ -191,6 +192,7 @@ static struct composite_context *wreplsrv_out_connect_send(struct wreplsrv_partn
 	state->stage	= WREPLSRV_OUT_CONNECT_STAGE_WAIT_SOCKET;
 	state->wreplconn= wreplconn;
 	state->c_req	= wrepl_connect_send(wreplconn->sock,
+					     lp_resolve_context(service->task->lp_ctx),
 					     partner->our_address,
 					     partner->address);
 	if (!state->c_req) goto failed;
@@ -379,8 +381,7 @@ static NTSTATUS wreplsrv_pull_table_recv(struct composite_context *c, TALLOC_CTX
 		struct wreplsrv_pull_table_state *state = talloc_get_type(c->private_data,
 							  struct wreplsrv_pull_table_state);
 		io->out.num_owners	= state->table_io.out.num_partners;
-		io->out.owners		= state->table_io.out.partners;
-		talloc_reference(mem_ctx, state->table_io.out.partners);
+		io->out.owners		= talloc_reference(mem_ctx, state->table_io.out.partners);
 	}
 
 	talloc_free(c);
@@ -535,8 +536,7 @@ static NTSTATUS wreplsrv_pull_names_recv(struct composite_context *c, TALLOC_CTX
 		struct wreplsrv_pull_names_state *state = talloc_get_type(c->private_data,
 							  struct wreplsrv_pull_names_state);
 		io->out.num_names	= state->pull_io.out.num_names;
-		io->out.names		= state->pull_io.out.names;
-		talloc_reference(mem_ctx, state->pull_io.out.names);
+		io->out.names		= talloc_reference(mem_ctx, state->pull_io.out.names);
 	}
 
 	talloc_free(c);
-- 
cgit 


From c38c2765d1059b33f044a42c6555f3d10d339911 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Thu, 21 Feb 2008 17:17:37 +0100
Subject: Remove yet more uses of global_loadparm. (This used to be commit
 e01c1e87c0fe9709df7eb5b863f7ce85564174cd)

---
 source4/wrepl_server/wrepl_out_helpers.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index f809095f22..72d55985bb 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -30,6 +30,7 @@
 #include "libcli/composite/composite.h"
 #include "libcli/wrepl/winsrepl.h"
 #include "libcli/resolve/resolve.h"
+#include "param/param.h"
 
 enum wreplsrv_out_connect_stage {
 	WREPLSRV_OUT_CONNECT_STAGE_WAIT_SOCKET,
@@ -186,7 +187,7 @@ static struct composite_context *wreplsrv_out_connect_send(struct wreplsrv_partn
 
 	wreplconn->service	= service;
 	wreplconn->partner	= partner;
-	wreplconn->sock		= wrepl_socket_init(wreplconn, service->task->event_ctx);
+	wreplconn->sock		= wrepl_socket_init(wreplconn, service->task->event_ctx, lp_iconv_convenience(service->task->lp_ctx));
 	if (!wreplconn->sock) goto failed;
 
 	state->stage	= WREPLSRV_OUT_CONNECT_STAGE_WAIT_SOCKET;
-- 
cgit 


From 4590432d6290fd1c21a27ec5e6643d455e4fec69 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Thu, 21 Feb 2008 18:43:02 +0100
Subject: Remove another global_loadparm instance. (This used to be commit
 ccb29c0b463f5ccb53553f0a1c411ad77a84482a)

---
 source4/wrepl_server/wrepl_out_helpers.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/wrepl_server/wrepl_out_helpers.c')

diff --git a/source4/wrepl_server/wrepl_out_helpers.c b/source4/wrepl_server/wrepl_out_helpers.c
index 72d55985bb..12605196ab 100644
--- a/source4/wrepl_server/wrepl_out_helpers.c
+++ b/source4/wrepl_server/wrepl_out_helpers.c
@@ -194,7 +194,7 @@ static struct composite_context *wreplsrv_out_connect_send(struct wreplsrv_partn
 	state->wreplconn= wreplconn;
 	state->c_req	= wrepl_connect_send(wreplconn->sock,
 					     lp_resolve_context(service->task->lp_ctx),
-					     partner->our_address,
+					     partner->our_address?partner->our_address:wrepl_best_ip(service->task->lp_ctx, partner->address),
 					     partner->address);
 	if (!state->c_req) goto failed;
 
-- 
cgit