[GLUE] Rsync SAMBA_3_2_0 SVN r25598 in order to create the v3-2-test branch.

(This used to be commit 5c6c8e1fe93f340005110a7833946191659d88ab)

20 files changed, 389 insertions, 1164 deletions

diff --git a/source3/smbd/aio.c b/source3/smbd/aio.c
index 49855796b7..6ee0fe16e1 100644
--- a/source3/smbd/aio.c
+++ b/source3/smbd/aio.c
@@ -48,10 +48,8 @@ static struct aio_extra *aio_list_head;
  of the aio_read call.
 *****************************************************************************/
 
-static struct aio_extra *create_aio_ex_read(files_struct *fsp,
-						size_t buflen,
-						uint16 mid,
-						const uint8 *inbuf)
+static struct aio_extra *create_aio_ex_read(files_struct *fsp, size_t buflen,
+					    uint16 mid)
 {
 	struct aio_extra *aio_ex = SMB_MALLOC_P(struct aio_extra);
 
@@ -67,14 +65,6 @@ static struct aio_extra *create_aio_ex_read(files_struct *fsp,
 		SAFE_FREE(aio_ex);
 		return NULL;
 	}
-	/* Save the first 8 bytes of inbuf for possible enc data. */
-	aio_ex->inbuf = SMB_MALLOC_ARRAY(char, 8);
-	if (!aio_ex->inbuf) {
-		SAFE_FREE(aio_ex->outbuf);
-		SAFE_FREE(aio_ex);
-		return NULL;
-	}
-	memcpy(aio_ex->inbuf, inbuf, 8);
 	DLIST_ADD(aio_list_head, aio_ex);
 	aio_ex->fsp = fsp;
 	aio_ex->read_req = True;
@@ -240,14 +230,13 @@ BOOL schedule_aio_read_and_X(connection_struct *conn,
 
 	bufsize = smb_size + 12 * 2 + smb_maxcnt;
 
-	if (!(aio_ex = create_aio_ex_read(fsp, bufsize, req->mid,
-					  req->inbuf))) {
+	if ((aio_ex = create_aio_ex_read(fsp, bufsize, req->mid)) == NULL) {
 		DEBUG(10,("schedule_aio_read_and_X: malloc fail.\n"));
 		return False;
 	}
 
 	construct_reply_common((char *)req->inbuf, aio_ex->outbuf);
-	set_message((char *)req->inbuf, aio_ex->outbuf, 12, 0, True);
+	set_message(aio_ex->outbuf, 12, 0, True);
 	SCVAL(aio_ex->outbuf,smb_vwv0,0xFF); /* Never a chained reply. */
 
 	a = &aio_ex->acb;
@@ -292,6 +281,7 @@ BOOL schedule_aio_write_and_X(connection_struct *conn,
 	struct aio_extra *aio_ex;
 	SMB_STRUCT_AIOCB *a;
 	size_t inbufsize, outbufsize;
+	BOOL write_through = BITSETW(req->inbuf+smb_vwv7,0);
 	size_t min_aio_write_size = lp_aio_write_size(SNUM(conn));
 
 	if (!min_aio_write_size || (numtowrite < min_aio_write_size)) {
@@ -359,7 +349,22 @@ BOOL schedule_aio_write_and_X(connection_struct *conn,
 		return False;
 	}
 
-	srv_defer_sign_response(aio_ex->mid);
+	if (!write_through && !lp_syncalways(SNUM(fsp->conn))
+	    && fsp->aio_write_behind) {
+		/* Lie to the client and immediately claim we finished the
+		 * write. */
+	        SSVAL(aio_ex->outbuf,smb_vwv2,numtowrite);
+                SSVAL(aio_ex->outbuf,smb_vwv4,(numtowrite>>16)&1);
+		show_msg(aio_ex->outbuf);
+		if (!send_smb(smbd_server_fd(),aio_ex->outbuf)) {
+			exit_server_cleanly("handle_aio_write: send_smb "
+					    "failed.");
+		}
+		DEBUG(10,("schedule_aio_write_and_X: scheduled aio_write "
+			  "behind for file %s\n", fsp->fsp_name ));
+	} else {
+		srv_defer_sign_response(aio_ex->mid);
+	}
 	outstanding_aio_calls++;
 
 	DEBUG(10,("schedule_aio_write_and_X: scheduled aio_write for file "
@@ -382,7 +387,6 @@ static int handle_aio_read_complete(struct aio_extra *aio_ex)
 	int ret = 0;
 	int outsize;
 	char *outbuf = aio_ex->outbuf;
-	char *inbuf = aio_ex->inbuf;
 	char *data = smb_buf(outbuf);
 	ssize_t nread = SMB_VFS_AIO_RETURN(aio_ex->fsp,&aio_ex->acb);
 
@@ -406,7 +410,7 @@ static int handle_aio_read_complete(struct aio_extra *aio_ex)
 		outsize = (UNIXERROR(ERRDOS,ERRnoaccess));
 		ret = errno;
 	} else {
-		outsize = set_message(inbuf,outbuf,12,nread,False);
+		outsize = set_message(outbuf,12,nread,False);
 		SSVAL(outbuf,smb_vwv2,0xFFFF); /* Remaining - must be * -1. */
 		SSVAL(outbuf,smb_vwv5,nread);
 		SSVAL(outbuf,smb_vwv6,smb_offset(data,outbuf));
@@ -419,7 +423,7 @@ static int handle_aio_read_complete(struct aio_extra *aio_ex)
 			    (int)aio_ex->acb.aio_nbytes, (int)nread ) );
 
 	}
-	smb_setlen(inbuf,outbuf,outsize - 4);
+	smb_setlen(outbuf,outsize - 4);
 	show_msg(outbuf);
 	if (!send_smb(smbd_server_fd(),outbuf)) {
 		exit_server_cleanly("handle_aio_read_complete: send_smb "
@@ -444,10 +448,34 @@ static int handle_aio_write_complete(struct aio_extra *aio_ex)
 	int ret = 0;
 	files_struct *fsp = aio_ex->fsp;
 	char *outbuf = aio_ex->outbuf;
-	char *inbuf = aio_ex->inbuf;
 	ssize_t numtowrite = aio_ex->acb.aio_nbytes;
 	ssize_t nwritten = SMB_VFS_AIO_RETURN(fsp,&aio_ex->acb);
 
+	if (fsp->aio_write_behind) {
+		if (nwritten != numtowrite) {
+			if (nwritten == -1) {
+				DEBUG(5,("handle_aio_write_complete: "
+					 "aio_write_behind failed ! File %s "
+					 "is corrupt ! Error %s\n",
+					 fsp->fsp_name, strerror(errno) ));
+				ret = errno;
+			} else {
+				DEBUG(0,("handle_aio_write_complete: "
+					 "aio_write_behind failed ! File %s "
+					 "is corrupt ! Wanted %u bytes but "
+					 "only wrote %d\n", fsp->fsp_name,
+					 (unsigned int)numtowrite,
+					 (int)nwritten ));
+				ret = EIO;
+			}
+		} else {
+			DEBUG(10,("handle_aio_write_complete: "
+				  "aio_write_behind completed for file %s\n",
+				  fsp->fsp_name ));
+		}
+		return 0;
+	}
+
 	/* We don't need outsize or set_message here as we've already set the
 	   fixed size length when we set up the aio call. */
 
@@ -590,6 +618,115 @@ int process_aio_queue(void)
 }
 
 /****************************************************************************
+ We're doing write behind and the client closed the file. Wait up to 30
+ seconds (my arbitrary choice) for the aio to complete. Return 0 if all writes
+ completed, errno to return if not.
+*****************************************************************************/
+
+#define SMB_TIME_FOR_AIO_COMPLETE_WAIT 29
+
+int wait_for_aio_completion(files_struct *fsp)
+{
+	struct aio_extra *aio_ex;
+	const SMB_STRUCT_AIOCB **aiocb_list;
+	int aio_completion_count = 0;
+	time_t start_time = time(NULL);
+	int seconds_left;
+
+	for (seconds_left = SMB_TIME_FOR_AIO_COMPLETE_WAIT;
+	     seconds_left >= 0;) {
+		int err = 0;
+		int i;
+		struct timespec ts;
+
+		aio_completion_count = 0;
+		for( aio_ex = aio_list_head; aio_ex; aio_ex = aio_ex->next) {
+			if (aio_ex->fsp == fsp) {
+				aio_completion_count++;
+			}
+		}
+
+		if (!aio_completion_count) {
+			return 0;
+		}
+
+		DEBUG(3,("wait_for_aio_completion: waiting for %d aio events "
+			 "to complete.\n", aio_completion_count ));
+
+		aiocb_list = SMB_MALLOC_ARRAY(const SMB_STRUCT_AIOCB *,
+					      aio_completion_count);
+		if (!aiocb_list) {
+			return ENOMEM;
+		}
+
+		for( i = 0, aio_ex = aio_list_head;
+		     aio_ex;
+		     aio_ex = aio_ex->next) {
+			if (aio_ex->fsp == fsp) {
+				aiocb_list[i++] = &aio_ex->acb;
+			}
+		}
+
+		/* Now wait up to seconds_left for completion. */
+		ts.tv_sec = seconds_left;
+		ts.tv_nsec = 0;
+
+		DEBUG(10,("wait_for_aio_completion: %d events, doing a wait "
+			  "of %d seconds.\n",
+			  aio_completion_count, seconds_left ));
+
+		err = SMB_VFS_AIO_SUSPEND(fsp, aiocb_list,
+					  aio_completion_count, &ts);
+
+		DEBUG(10,("wait_for_aio_completion: returned err = %d, "
+			  "errno = %s\n", err, strerror(errno) ));
+		
+		if (err == -1 && errno == EAGAIN) {
+			DEBUG(0,("wait_for_aio_completion: aio_suspend timed "
+				 "out waiting for %d events after a wait of "
+				 "%d seconds\n", aio_completion_count,
+				 seconds_left));
+			/* Timeout. */
+			cancel_aio_by_fsp(fsp);
+			SAFE_FREE(aiocb_list);
+			return EIO;
+		}
+
+		/* One or more events might have completed - process them if
+		 * so. */
+		for( i = 0; i < aio_completion_count; i++) {
+			uint16 mid = aiocb_list[i]->aio_sigevent.sigev_value.sival_int;
+
+			aio_ex = find_aio_ex(mid);
+
+			if (!aio_ex) {
+				DEBUG(0, ("wait_for_aio_completion: mid %u "
+					  "doesn't match an aio record\n",
+					  (unsigned int)mid ));
+				continue;
+			}
+
+			if (!handle_aio_completed(aio_ex, &err)) {
+				continue;
+			}
+			delete_aio_ex(aio_ex);
+		}
+
+		SAFE_FREE(aiocb_list);
+		seconds_left = SMB_TIME_FOR_AIO_COMPLETE_WAIT
+			- (time(NULL) - start_time);
+	}
+
+	/* We timed out - we don't know why. Return ret if already an error,
+	 * else EIO. */
+	DEBUG(10,("wait_for_aio_completion: aio_suspend timed out waiting "
+		  "for %d events\n",
+		  aio_completion_count));
+
+	return EIO;
+}
+
+/****************************************************************************
  Cancel any outstanding aio requests. The client doesn't care about the reply.
 *****************************************************************************/
 
@@ -645,4 +782,8 @@ void cancel_aio_by_fsp(files_struct *fsp)
 {
 }
 
+BOOL wait_for_aio_completion(files_struct *fsp)
+{
+	return True;
+}
 #endif
diff --git a/source3/smbd/close.c b/source3/smbd/close.c
index aee1c92f7b..ae45aaa6da 100644
--- a/source3/smbd/close.c
+++ b/source3/smbd/close.c
@@ -345,16 +345,28 @@ static NTSTATUS close_normal_file(files_struct *fsp, enum file_close_type close_
 	NTSTATUS status = NT_STATUS_OK;
 	NTSTATUS saved_status1 = NT_STATUS_OK;
 	NTSTATUS saved_status2 = NT_STATUS_OK;
+	NTSTATUS saved_status3 = NT_STATUS_OK;
 	connection_struct *conn = fsp->conn;
 
-	cancel_aio_by_fsp(fsp);
+	if (fsp->aio_write_behind) {
+		/*
+	 	 * If we're finishing write behind on a close we can get a write
+		 * error here, we must remember this.
+		 */
+		int ret = wait_for_aio_completion(fsp);
+		if (ret) {
+			saved_status1 = map_nt_error_from_unix(ret);
+		}
+	} else {
+		cancel_aio_by_fsp(fsp);
+	}
  
 	/*
 	 * If we're flushing on a close we can get a write
 	 * error here, we must remember this.
 	 */
 
-	saved_status1 = close_filestruct(fsp);
+	saved_status2 = close_filestruct(fsp);
 
 	if (fsp->print_file) {
 		print_fsp_end(fsp, close_type);
@@ -368,7 +380,7 @@ static NTSTATUS close_normal_file(files_struct *fsp, enum file_close_type close_
 
 	if (fsp->fh->ref_count == 1) {
 		/* Should we return on error here... ? */
-		saved_status2 = close_remove_share_mode(fsp, close_type);
+		saved_status3 = close_remove_share_mode(fsp, close_type);
 	}
 
 	if(fsp->oplock_type) {
@@ -399,6 +411,8 @@ static NTSTATUS close_normal_file(files_struct *fsp, enum file_close_type close_
 			status = saved_status1;
 		} else if (!NT_STATUS_IS_OK(saved_status2)) {
 			status = saved_status2;
+		} else if (!NT_STATUS_IS_OK(saved_status3)) {
+			status = saved_status3;
 		}
 	}
 
diff --git a/source3/smbd/conn.c b/source3/smbd/conn.c
index f9befb84d2..50a71edf9d 100644
--- a/source3/smbd/conn.c
+++ b/source3/smbd/conn.c
@@ -285,6 +285,7 @@ void conn_free_internal(connection_struct *conn)
 	free_namearray(conn->veto_list);
 	free_namearray(conn->hide_list);
 	free_namearray(conn->veto_oplock_list);
+	free_namearray(conn->aio_write_behind_list);
 	
 	string_free(&conn->user);
 	string_free(&conn->dirpath);
diff --git a/source3/smbd/connection.c b/source3/smbd/connection.c
index 4b807f7b90..65b7c352c5 100644
--- a/source3/smbd/connection.c
+++ b/source3/smbd/connection.c
@@ -83,19 +83,9 @@ static int count_fn(struct db_record *rec,
 		}
 		return 0;
 	}
- 
-	if (cs->name) {
-		/* We are counting all the connections to a given share. */
-		if (strequal(crec->servicename, cs->name)) {
-			cs->curr_connections++;
-		}
-	} else {
-		/* We are counting all the connections. Static registrations
-		 * like the lpq backgroud process and the smbd daemon process
-		 * have a cnum of -1, so won't be counted here.
-		 */
+
+	if (strequal(crec->servicename, cs->name))
 		cs->curr_connections++;
-	}
 
 	return 0;
 }
@@ -121,29 +111,13 @@ int count_current_connections( const char *sharename, BOOL clear  )
 	if (connections_forall(count_fn, &cs) == -1) {
 		DEBUG(0,("count_current_connections: traverse of "
 			 "connections.tdb failed\n"));
-		DEBUGADD(0, ("count_current_connections: connection count of %d might not be accurate",
-			    cs.curr_connections));
+		return False;
 	}
 
-	/* If the traverse failed part-way through, we at least return
-	 * as many connections as we had already counted. If it failed
-	 * right at the start, we will return 0, which is about all we
-	 * can do anywway.
-	 */
-
 	return cs.curr_connections;
 }
 
 /****************************************************************************
- Count the number of connections open across all shares.
-****************************************************************************/
-
-int count_all_current_connections(void)
-{
-	return count_current_connections(NULL, True /* clear stale entries */);
-}
-
-/****************************************************************************
  Claim an entry in the connections database.
 ****************************************************************************/
 
diff --git a/source3/smbd/error.c b/source3/smbd/error.c
index 143417dce3..6cb63f0c49 100644
--- a/source3/smbd/error.c
+++ b/source3/smbd/error.c
@@ -28,7 +28,7 @@ extern uint32 global_client_caps;
  Create an error packet from errno.
 ****************************************************************************/
 
-int unix_error_packet(const char *inbuf,char *outbuf,int def_class,uint32 def_code, NTSTATUS def_status, int line, const char *file)
+int unix_error_packet(char *outbuf,int def_class,uint32 def_code, NTSTATUS def_status, int line, const char *file)
 {
 	int eclass=def_class;
 	int ecode=def_code;
@@ -49,7 +49,7 @@ int unix_error_packet(const char *inbuf,char *outbuf,int def_class,uint32 def_co
 		}
 	}
 
-	return error_packet(inbuf,outbuf,eclass,ecode,ntstatus,line,file);
+	return error_packet(outbuf,eclass,ecode,ntstatus,line,file);
 }
 
 BOOL use_nt_status(void)
@@ -109,9 +109,9 @@ void error_packet_set(char *outbuf, uint8 eclass, uint32 ecode, NTSTATUS ntstatu
 	}
 }
 
-int error_packet(const char *inbuf, char *outbuf, uint8 eclass, uint32 ecode, NTSTATUS ntstatus, int line, const char *file)
+int error_packet(char *outbuf, uint8 eclass, uint32 ecode, NTSTATUS ntstatus, int line, const char *file)
 {
-	int outsize = set_message(inbuf,outbuf,0,0,True);
+	int outsize = set_message(outbuf,0,0,True);
 	error_packet_set(outbuf, eclass, ecode, ntstatus, line, file);
 	return outsize;
 }
diff --git a/source3/smbd/files.c b/source3/smbd/files.c
index f3740da328..179963dae9 100644
--- a/source3/smbd/files.c
+++ b/source3/smbd/files.c
@@ -558,6 +558,7 @@ NTSTATUS dup_file_fsp(files_struct *fsp,
 	dup_fsp->modified = fsp->modified;
 	dup_fsp->is_directory = fsp->is_directory;
 	dup_fsp->is_stat = fsp->is_stat;
+	dup_fsp->aio_write_behind = fsp->aio_write_behind;
         string_set(&dup_fsp->fsp_name,fsp->fsp_name);
 
 	*result = dup_fsp;
diff --git a/source3/smbd/notify.c b/source3/smbd/notify.c
index da80c25407..b8c5085b41 100644
--- a/source3/smbd/notify.c
+++ b/source3/smbd/notify.c
@@ -131,11 +131,10 @@ static BOOL notify_marshall_changes(int num_changes,
 static void change_notify_reply_packet(const uint8 *request_buf,
 				       NTSTATUS error_code)
 {
-	const char *inbuf = (char *)request_buf;
 	char outbuf[smb_size+38];
 
 	memset(outbuf, '\0', sizeof(outbuf));
-	construct_reply_common(inbuf, outbuf);
+	construct_reply_common((char *)request_buf, outbuf);
 
 	ERROR_NT(error_code);
 
@@ -143,7 +142,7 @@ static void change_notify_reply_packet(const uint8 *request_buf,
 	 * Seems NT needs a transact command with an error code
 	 * in it. This is a longer packet than a simple error.
 	 */
-	set_message(inbuf,outbuf,18,0,False);
+	set_message(outbuf,18,0,False);
 
 	show_msg(outbuf);
 	if (!send_smb(smbd_server_fd(),outbuf))
@@ -187,7 +186,7 @@ void change_notify_reply(const uint8 *request_buf, uint32 max_param,
 	 * We're only interested in the header fields here
 	 */
 
-	smb_setlen(NULL, (char *)tmp_request, smb_size);
+	smb_setlen((char *)tmp_request, smb_size);
 	SCVAL(tmp_request, smb_wct, 0);
 
 	init_smb_request(req, tmp_request);
diff --git a/source3/smbd/open.c b/source3/smbd/open.c
index c2d7807158..fbc6f9ab64 100644
--- a/source3/smbd/open.c
+++ b/source3/smbd/open.c
@@ -387,6 +387,10 @@ static NTSTATUS open_file(files_struct *fsp,
 	fsp->sent_oplock_break = NO_BREAK_SENT;
 	fsp->is_directory = False;
 	fsp->is_stat = False;
+	if (conn->aio_write_behind_list &&
+	    is_in_path(path, conn->aio_write_behind_list, conn->case_sensitive)) {
+		fsp->aio_write_behind = True;
+	}
 
 	string_set(&fsp->fsp_name, path);
 	fsp->wcp = NULL; /* Write cache pointer. */
diff --git a/source3/smbd/oplock.c b/source3/smbd/oplock.c
index a5f74b89d0..9ac9d76284 100644
--- a/source3/smbd/oplock.c
+++ b/source3/smbd/oplock.c
@@ -253,7 +253,7 @@ static char *new_break_smb_message(TALLOC_CTX *mem_ctx,
 	}
 
 	memset(result,'\0',smb_size);
-	set_message(NULL,result,8,0,True);
+	set_message(result,8,0,True);
 	SCVAL(result,smb_com,SMBlockingX);
 	SSVAL(result,smb_tid,fsp->conn->cnum);
 	SSVAL(result,smb_pid,0xFFFF);
diff --git a/source3/smbd/pipes.c b/source3/smbd/pipes.c
index 9906bfb45b..da43a29767 100644
--- a/source3/smbd/pipes.c
+++ b/source3/smbd/pipes.c
@@ -291,7 +291,7 @@ void reply_pipe_read_and_X(struct smb_request *req)
 		return;
 	}
 
-	set_message(NULL, (char *)req->outbuf, 12, nread, False);
+	set_message((char *)req->outbuf, 12, nread, False);
   
 	SSVAL(req->outbuf,smb_vwv5,nread);
 	SSVAL(req->outbuf,smb_vwv6,smb_offset(data,req->outbuf));
diff --git a/source3/smbd/process.c b/source3/smbd/process.c
index 29b942de81..7faf26af25 100644
--- a/source3/smbd/process.c
+++ b/source3/smbd/process.c
@@ -91,8 +91,8 @@ void init_smb_request(struct smb_request *req, const uint8 *inbuf)
 static struct pending_message_list *deferred_open_queue;
 
 /****************************************************************************
- Function to push a message onto the tail of a linked list of smb messages
- ready for processing.
+ Function to push a message onto the tail of a linked list of smb messages ready
+ for processing.
 ****************************************************************************/
 
 static BOOL push_queued_message(struct smb_request *req,
@@ -148,7 +148,7 @@ void remove_deferred_open_smb_message(uint16 mid)
 
 	for (pml = deferred_open_queue; pml; pml = pml->next) {
 		if (mid == SVAL(pml->buf.data,smb_mid)) {
-			DEBUG(10,("remove_deferred_open_smb_message: "
+			DEBUG(10,("remove_sharing_violation_open_smb_message: "
 				  "deleting mid %u len %u\n",
 				  (unsigned int)mid,
 				  (unsigned int)pml->buf.length ));
@@ -171,11 +171,11 @@ void schedule_deferred_open_smb_message(uint16 mid)
 
 	for (pml = deferred_open_queue; pml; pml = pml->next) {
 		uint16 msg_mid = SVAL(pml->buf.data,smb_mid);
-		DEBUG(10, ("schedule_deferred_open_smb_message: [%d] "
-			   "msg_mid = %u\n", i++, (unsigned int)msg_mid ));
+		DEBUG(10,("schedule_deferred_open_smb_message: [%d] msg_mid = %u\n", i++,
+			(unsigned int)msg_mid ));
 		if (mid == msg_mid) {
-			DEBUG(10, ("schedule_deferred_open_smb_message: "
-				   "scheduling mid %u\n", mid));
+			DEBUG(10,("schedule_deferred_open_smb_message: scheduling mid %u\n",
+				mid ));
 			pml->end_time.tv_sec = 0;
 			pml->end_time.tv_usec = 0;
 			DLIST_PROMOTE(deferred_open_queue, pml);
@@ -183,8 +183,8 @@ void schedule_deferred_open_smb_message(uint16 mid)
 		}
 	}
 
-	DEBUG(10, ("schedule_deferred_open_smb_message: failed to find "
-		   "message mid %u\n", mid ));
+	DEBUG(10,("schedule_deferred_open_smb_message: failed to find message mid %u\n",
+		mid ));
 }
 
 /****************************************************************************
@@ -932,8 +932,7 @@ void reply_outbuf(struct smb_request *req, uint8 num_words, uint32 num_bytes)
 	}
 
 	construct_reply_common((char *)req->inbuf, (char *)req->outbuf);
-	set_message((char *)req->inbuf, (char *)req->outbuf,
-		    num_words, num_bytes, False);
+	set_message((char *)req->outbuf, num_words, num_bytes, False);
 	/*
 	 * Zero out the word area, the caller has to take care of the bcc area
 	 * himself
@@ -1226,8 +1225,8 @@ void remove_from_common_flags2(uint32 v)
 
 void construct_reply_common(const char *inbuf, char *outbuf)
 {
-	set_message(inbuf,outbuf,0,0,False);
-
+	set_message(outbuf,0,0,False);
+	
 	SCVAL(outbuf,smb_com,CVAL(inbuf,smb_com));
 	SIVAL(outbuf,smb_rcls,0);
 	SCVAL(outbuf,smb_flg, FLAG_REPLY | (CVAL(inbuf,smb_flg) & FLAG_CASELESS_PATHNAMES)); 
@@ -1341,7 +1340,7 @@ void chain_reply(struct smb_request *req)
 	}
 
 	/* And set it in the header. */
-	smb_setlen(inbuf, inbuf2, new_size - 4);
+	smb_setlen(inbuf2, new_size - 4);
 
 	DEBUG(3,("Chained message\n"));
 	show_msg(inbuf2);
@@ -1428,7 +1427,7 @@ void chain_reply(struct smb_request *req)
 		memset(outbuf + outsize, 0, outsize_padded - outsize);
 	}
 
-	smb_setlen(NULL, outbuf, outsize2 + chain_size - 4);
+	smb_setlen(outbuf, outsize2 + chain_size - 4);
 
 	/*
 	 * restore the saved data, being careful not to overwrite any data
diff --git a/source3/smbd/reply.c b/source3/smbd/reply.c
index e27272f0dd..7c44216aea 100644
--- a/source3/smbd/reply.c
+++ b/source3/smbd/reply.c
@@ -402,7 +402,7 @@ void reply_special(char *inbuf)
 	
 	memset(outbuf, '\0', sizeof(outbuf));
 
-	smb_setlen(inbuf,outbuf,0);
+	smb_setlen(outbuf,0);
 	
 	switch (msg_type) {
 	case 0x81: /* session request */
@@ -1645,8 +1645,8 @@ void reply_open(connection_struct *conn, struct smb_request *req)
 
 	if (!NT_STATUS_IS_OK(status)) {
 		if (open_was_deferred(req->mid)) {
-			END_PROFILE(SMBopen);
 			/* We have re-scheduled this call. */
+			END_PROFILE(SMBopen);
 			return;
 		}
 		reply_openerror(req, status);
@@ -2040,7 +2040,7 @@ void reply_mknew(connection_struct *conn, struct smb_request *req)
 			/* We have re-scheduled this call. */
 			return;
 		}
-		reply_nterror(req, status);
+		reply_openerror(req, status);
 		return;
 	}
 
@@ -3017,7 +3017,7 @@ Returning short read of maximum allowed for compatibility with Windows 2000.\n",
 		return;
 	}
 	
-	set_message(NULL, (char *)req->outbuf, 5, nread+3, False);
+	set_message((char *)req->outbuf, 5, nread+3, False);
 
 	SSVAL(req->outbuf,smb_vwv0,nread);
 	SSVAL(req->outbuf,smb_vwv5,nread+3);
@@ -3104,7 +3104,7 @@ Returning short read of maximum allowed for compatibility with Windows 2000.\n",
 		return;
 	}
 
-	set_message(NULL, (char *)req->outbuf, 5, nread+3, False);
+	set_message((char *)req->outbuf, 5, nread+3, False);
 
 	SSVAL(req->outbuf,smb_vwv0,nread);
 	SSVAL(req->outbuf,smb_vwv5,nread+3);
@@ -3122,14 +3122,12 @@ Returning short read of maximum allowed for compatibility with Windows 2000.\n",
  Setup readX header.
 ****************************************************************************/
 
-static int setup_readX_header(const uint8 *inbuf, uint8 *outbuf,
-			      size_t smb_maxcnt)
+static int setup_readX_header(char *outbuf, size_t smb_maxcnt)
 {
 	int outsize;
 	char *data;
 
-	outsize = set_message((char *)inbuf, (char *)outbuf,12,smb_maxcnt,
-			      False);
+	outsize = set_message(outbuf,12,smb_maxcnt,False);
 	data = smb_buf(outbuf);
 
 	memset(outbuf+smb_vwv0,'\0',24); /* valgrind init. */
@@ -3192,7 +3190,7 @@ static void send_file_readX(connection_struct *conn, struct smb_request *req,
 		header = data_blob_const(headerbuf, sizeof(headerbuf));
 
 		construct_reply_common((char *)req->inbuf, (char *)headerbuf);
-		setup_readX_header(req->inbuf, headerbuf, smb_maxcnt);
+		setup_readX_header((char *)headerbuf, smb_maxcnt);
 
 		if ((nread = SMB_VFS_SENDFILE( smbd_server_fd(), fsp, fsp->fh->fd, &header, startpos, smb_maxcnt)) == -1) {
 			/* Returning ENOSYS means no data at all was sent. Do this as a normal read. */
@@ -3243,7 +3241,7 @@ normal_read:
 		uint8 headerbuf[smb_size + 2*12];
 
 		construct_reply_common((char *)req->inbuf, (char *)headerbuf);
-		setup_readX_header(req->inbuf, headerbuf, smb_maxcnt);
+		setup_readX_header((char *)headerbuf, smb_maxcnt);
 
 		/* Send out the header. */
 		if (write_data(smbd_server_fd(), (char *)headerbuf,
@@ -3270,7 +3268,7 @@ normal_read:
 			return;
 		}
 
-		setup_readX_header(req->inbuf, req->outbuf, nread);
+		setup_readX_header((char *)req->outbuf, nread);
 
 		DEBUG( 3, ( "send_file_readX fnum=%d max=%d nread=%d\n",
 			fsp->fnum, (int)smb_maxcnt, (int)nread ) );
@@ -3334,8 +3332,8 @@ void reply_read_and_X(connection_struct *conn, struct smb_request *req)
 				END_PROFILE(SMBreadX);
 				return;
 			}
-			/* We currently don't do this on signed or sealed data. */
-			if (srv_is_signing_active() || srv_encryption_on()) {
+			/* We currently don't do this on signed data. */
+			if (srv_is_signing_active()) {
 				reply_nterror(req, NT_STATUS_NOT_SUPPORTED);
 				END_PROFILE(SMBreadX);
 				return;
@@ -3526,7 +3524,7 @@ void reply_writebraw(connection_struct *conn, struct smb_request *req)
 	 * it to send more bytes */
 
 	memcpy(buf, req->inbuf, smb_size);
-	outsize = set_message(NULL,buf,
+	outsize = set_message(buf,
 			Protocol>PROTOCOL_COREPLUS?1:0,0,True);
 	SCVAL(buf,smb_com,SMBwritebraw);
 	SSVALS(buf,smb_vwv0,0xFFFF);
diff --git a/source3/smbd/seal.c b/source3/smbd/seal.c
deleted file mode 100644
index 0276e34002..0000000000
--- a/source3/smbd/seal.c
+++ /dev/null
@@ -1,703 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   SMB Transport encryption (sealing) code - server code.
-   Copyright (C) Jeremy Allison 2007.
-   
-   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 3 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, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "includes.h"
-
-/******************************************************************************
- Server side encryption.
-******************************************************************************/
-
-/******************************************************************************
- Global server state.
-******************************************************************************/
-
-struct smb_srv_trans_enc_ctx {
-	struct smb_trans_enc_state *es;
-	AUTH_NTLMSSP_STATE *auth_ntlmssp_state; /* Must be kept in sync with pointer in ec->ntlmssp_state. */
-};
-
-static struct smb_srv_trans_enc_ctx *partial_srv_trans_enc_ctx;
-static struct smb_srv_trans_enc_ctx *srv_trans_enc_ctx;
-
-/******************************************************************************
- Is server encryption on ?
-******************************************************************************/
-
-BOOL srv_encryption_on(void)
-{
-	if (srv_trans_enc_ctx) {
-		return common_encryption_on(srv_trans_enc_ctx->es);
-	}
-	return False;
-}
-
-/******************************************************************************
- Create an auth_ntlmssp_state and ensure pointer copy is correct.
-******************************************************************************/
-
-static NTSTATUS make_auth_ntlmssp(struct smb_srv_trans_enc_ctx *ec)
-{
-	NTSTATUS status = auth_ntlmssp_start(&ec->auth_ntlmssp_state);
-	if (!NT_STATUS_IS_OK(status)) {
-		return nt_status_squash(status);
-	}
-
-	/*
-	 * We must remember to update the pointer copy for the common
-	 * functions after any auth_ntlmssp_start/auth_ntlmssp_end.
-	 */
-	ec->es->s.ntlmssp_state = ec->auth_ntlmssp_state->ntlmssp_state;
-	return status;
-}
-
-/******************************************************************************
- Destroy an auth_ntlmssp_state and ensure pointer copy is correct.
-******************************************************************************/
-
-static void destroy_auth_ntlmssp(struct smb_srv_trans_enc_ctx *ec)
-{
-	/*
-	 * We must remember to update the pointer copy for the common
-	 * functions after any auth_ntlmssp_start/auth_ntlmssp_end.
-	 */
-
-	if (ec->auth_ntlmssp_state) {
-		auth_ntlmssp_end(&ec->auth_ntlmssp_state);
-		/* The auth_ntlmssp_end killed this already. */
-		ec->es->s.ntlmssp_state = NULL;
-	}
-}
-
-#if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
-
-/******************************************************************************
- Import a name.
-******************************************************************************/
-
-static NTSTATUS get_srv_gss_creds(const char *service,
-				const char *name,
-				gss_cred_usage_t cred_type,
-				gss_cred_id_t *p_srv_cred)
-{
-	OM_uint32 ret;
-	OM_uint32 min;
-	gss_name_t srv_name;
-	gss_buffer_desc input_name;
-	char *host_princ_s = NULL;
-	NTSTATUS status = NT_STATUS_OK;
-
-	gss_OID_desc nt_hostbased_service =
-	{10, CONST_DISCARD(char *,"\x2a\x86\x48\x86\xf7\x12\x01\x02\x01\x04")};
-
-	asprintf(&host_princ_s, "%s@%s", service, name);
-	if (host_princ_s == NULL) {
-		return NT_STATUS_NO_MEMORY;
-	}
-
-	input_name.value = host_princ_s;
-	input_name.length = strlen(host_princ_s) + 1;
-
-	ret = gss_import_name(&min,
-				&input_name,
-				&nt_hostbased_service,
-				&srv_name);
-
-	DEBUG(10,("get_srv_gss_creds: imported name %s\n",
-		host_princ_s ));
-
-	if (ret != GSS_S_COMPLETE) {
-		SAFE_FREE(host_princ_s);
-		return map_nt_error_from_gss(ret, min);
-	}
-
-	/*
-	 * We're accessing the krb5.keytab file here.
- 	 * ensure we have permissions to do so.
- 	 */
-	become_root();
-
-	ret = gss_acquire_cred(&min,
-				srv_name,
-				GSS_C_INDEFINITE,
-				GSS_C_NULL_OID_SET,
-				cred_type,
-				p_srv_cred,
-				NULL,
-				NULL);
-	unbecome_root();
-
-	if (ret != GSS_S_COMPLETE) {
-		ADS_STATUS adss = ADS_ERROR_GSS(ret, min);
-		DEBUG(10,("get_srv_gss_creds: gss_acquire_cred failed with %s\n",
-			ads_errstr(adss)));
-		status = map_nt_error_from_gss(ret, min);
-	}
-
-	SAFE_FREE(host_princ_s);
-	gss_release_name(&min, &srv_name);
-	return status;
-}
-
-/******************************************************************************
- Create a gss state.
- Try and get the cifs/server@realm principal first, then fall back to
- host/server@realm.
-******************************************************************************/
-
-static NTSTATUS make_auth_gss(struct smb_srv_trans_enc_ctx *ec)
-{
-	NTSTATUS status;
-	gss_cred_id_t srv_cred;
-	fstring fqdn;
-
-	name_to_fqdn(fqdn, global_myname());
-	strlower_m(fqdn);
-
-	status = get_srv_gss_creds("cifs", fqdn, GSS_C_ACCEPT, &srv_cred);
-	if (!NT_STATUS_IS_OK(status)) {
-		status = get_srv_gss_creds("host", fqdn, GSS_C_ACCEPT, &srv_cred);
-		if (!NT_STATUS_IS_OK(status)) {
-			return nt_status_squash(status);
-		}
-	}
-
-	ec->es->s.gss_state = SMB_MALLOC_P(struct smb_tran_enc_state_gss);
-	if (!ec->es->s.gss_state) {
-		OM_uint32 min;
-		gss_release_cred(&min, &srv_cred);
-		return NT_STATUS_NO_MEMORY;
-	}
-	ZERO_STRUCTP(ec->es->s.gss_state);
-	ec->es->s.gss_state->creds = srv_cred;
-
-	/* No context yet. */
-	ec->es->s.gss_state->gss_ctx = GSS_C_NO_CONTEXT;
-
-	return NT_STATUS_OK;
-}
-#endif
-
-/******************************************************************************
- Shutdown a server encryption context.
-******************************************************************************/
-
-static void srv_free_encryption_context(struct smb_srv_trans_enc_ctx **pp_ec)
-{
-	struct smb_srv_trans_enc_ctx *ec = *pp_ec;
-
-	if (!ec) {
-		return;
-	}
-
-	if (ec->es) {
-		switch (ec->es->smb_enc_type) {
-			case SMB_TRANS_ENC_NTLM:
-				destroy_auth_ntlmssp(ec);
-				break;
-#if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
-			case SMB_TRANS_ENC_GSS:
-				break;
-#endif
-		}
-		common_free_encryption_state(&ec->es);
-	}
-
-	SAFE_FREE(ec);
-	*pp_ec = NULL;
-}
-
-/******************************************************************************
- Create a server encryption context.
-******************************************************************************/
-
-static NTSTATUS make_srv_encryption_context(enum smb_trans_enc_type smb_enc_type, struct smb_srv_trans_enc_ctx **pp_ec)
-{
-	struct smb_srv_trans_enc_ctx *ec;
-
-	*pp_ec = NULL;
-
-	ec = SMB_MALLOC_P(struct smb_srv_trans_enc_ctx);
-	if (!ec) {
-		return NT_STATUS_NO_MEMORY;
-	}
-	ZERO_STRUCTP(partial_srv_trans_enc_ctx);
-	ec->es = SMB_MALLOC_P(struct smb_trans_enc_state);
-	if (!ec->es) {
-		SAFE_FREE(ec);
-		return NT_STATUS_NO_MEMORY;
-	}
-	ZERO_STRUCTP(ec->es);
-	ec->es->smb_enc_type = smb_enc_type;
-	switch (smb_enc_type) {
-		case SMB_TRANS_ENC_NTLM:
-			{
-				NTSTATUS status = make_auth_ntlmssp(ec);
-				if (!NT_STATUS_IS_OK(status)) {
-					srv_free_encryption_context(&ec);
-					return status;
-				}
-			}
-			break;
-
-#if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
-		case SMB_TRANS_ENC_GSS:
-			/* Acquire our credentials by calling gss_acquire_cred here. */
-			{
-				NTSTATUS status = make_auth_gss(ec);
-				if (!NT_STATUS_IS_OK(status)) {
-					srv_free_encryption_context(&ec);
-					return status;
-				}
-			}
-			break;
-#endif
-		default:
-			srv_free_encryption_context(&ec);
-			return NT_STATUS_INVALID_PARAMETER;
-	}
-	*pp_ec = ec;
-	return NT_STATUS_OK;
-}
-
-/******************************************************************************
- Free an encryption-allocated buffer.
-******************************************************************************/
-
-void srv_free_enc_buffer(char *buf)
-{
-	/* We know this is an smb buffer, and we
-	 * didn't malloc, only copy, for a keepalive,
-	 * so ignore session keepalives. */
-
-	if(CVAL(buf,0) == SMBkeepalive) {
-		return;
-	}
-
-	if (srv_trans_enc_ctx) {
-		common_free_enc_buffer(srv_trans_enc_ctx->es, buf);
-	}
-}
-
-/******************************************************************************
- Decrypt an incoming buffer.
-******************************************************************************/
-
-NTSTATUS srv_decrypt_buffer(char *buf)
-{
-	/* Ignore session keepalives. */
-	if(CVAL(buf,0) == SMBkeepalive) {
-		return NT_STATUS_OK;
-	}
-
-	if (srv_trans_enc_ctx) {
-		return common_decrypt_buffer(srv_trans_enc_ctx->es, buf);
-	}
-
-	return NT_STATUS_OK;
-}
-
-/******************************************************************************
- Encrypt an outgoing buffer. Return the encrypted pointer in buf_out.
-******************************************************************************/
-
-NTSTATUS srv_encrypt_buffer(char *buf, char **buf_out)
-{
-	*buf_out = buf;
-
-	/* Ignore session keepalives. */
-	if(CVAL(buf,0) == SMBkeepalive) {
-		return NT_STATUS_OK;
-	}
-
-	if (srv_trans_enc_ctx) {
-		return common_encrypt_buffer(srv_trans_enc_ctx->es, buf, buf_out);
-	}
-	/* Not encrypting. */
-	return NT_STATUS_OK;
-}
-
-/******************************************************************************
- Do the gss encryption negotiation. Parameters are in/out.
- Until success we do everything on the partial enc ctx.
-******************************************************************************/
-
-#if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
-static NTSTATUS srv_enc_spnego_gss_negotiate(unsigned char **ppdata, size_t *p_data_size, DATA_BLOB secblob)
-{
-	OM_uint32 ret;
-	OM_uint32 min;
-	OM_uint32 flags = 0;
-	gss_buffer_desc in_buf, out_buf;
-	struct smb_tran_enc_state_gss *gss_state;
-	DATA_BLOB auth_reply = data_blob_null;
-	DATA_BLOB response = data_blob_null;
-	NTSTATUS status;
-
-	if (!partial_srv_trans_enc_ctx) {
-		status = make_srv_encryption_context(SMB_TRANS_ENC_GSS, &partial_srv_trans_enc_ctx);
-		if (!NT_STATUS_IS_OK(status)) {
-			return status;
-		}
-	}
-
-	gss_state = partial_srv_trans_enc_ctx->es->s.gss_state;
-
-	in_buf.value = secblob.data;
-	in_buf.length = secblob.length;
-
-	out_buf.value = NULL;
-	out_buf.length = 0;
-
-	become_root();
-
-	ret = gss_accept_sec_context(&min,
-				&gss_state->gss_ctx,
-				gss_state->creds,
-				&in_buf,
-				GSS_C_NO_CHANNEL_BINDINGS,
-				NULL,
-				NULL,		/* Ignore oids. */
-				&out_buf,	/* To return. */
-				&flags,
-				NULL,		/* Ingore time. */
-				NULL);		/* Ignore delegated creds. */
-	unbecome_root();
-
-	status = gss_err_to_ntstatus(ret, min);
-	if (ret != GSS_S_COMPLETE && ret != GSS_S_CONTINUE_NEEDED) {
-		return status;
-	}
-
-	/* Ensure we've got sign+seal available. */
-	if (ret == GSS_S_COMPLETE) {
-		if ((flags & (GSS_C_INTEG_FLAG|GSS_C_CONF_FLAG|GSS_C_REPLAY_FLAG|GSS_C_SEQUENCE_FLAG)) !=
-				(GSS_C_INTEG_FLAG|GSS_C_CONF_FLAG|GSS_C_REPLAY_FLAG|GSS_C_SEQUENCE_FLAG)) {
-			DEBUG(0,("srv_enc_spnego_gss_negotiate: quality of service not good enough "
-				"for SMB sealing.\n"));
-			gss_release_buffer(&min, &out_buf);
-			return NT_STATUS_ACCESS_DENIED;
-		}
-	}
-
-	auth_reply = data_blob(out_buf.value, out_buf.length);
-	gss_release_buffer(&min, &out_buf);
-
-	/* Wrap in SPNEGO. */
-	response = spnego_gen_auth_response(&auth_reply, status, OID_KERBEROS5);
-	data_blob_free(&auth_reply);
-
-	SAFE_FREE(*ppdata);
-	*ppdata = response.data;
-	*p_data_size = response.length;
-
-	return status;
-}
-#endif
-
-/******************************************************************************
- Do the NTLM SPNEGO (or raw) encryption negotiation. Parameters are in/out.
- Until success we do everything on the partial enc ctx.
-******************************************************************************/
-
-static NTSTATUS srv_enc_ntlm_negotiate(unsigned char **ppdata, size_t *p_data_size, DATA_BLOB secblob, BOOL spnego_wrap)
-{
-	NTSTATUS status;
-	DATA_BLOB chal = data_blob_null;
-	DATA_BLOB response = data_blob_null;
-
-	status = make_srv_encryption_context(SMB_TRANS_ENC_NTLM, &partial_srv_trans_enc_ctx);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
-	}
-
-	status = auth_ntlmssp_update(partial_srv_trans_enc_ctx->auth_ntlmssp_state, secblob, &chal);
-
-	/* status here should be NT_STATUS_MORE_PROCESSING_REQUIRED
-	 * for success ... */
-
-	if (spnego_wrap) {
-		response = spnego_gen_auth_response(&chal, status, OID_NTLMSSP);
-		data_blob_free(&chal);
-	} else {
-		/* Return the raw blob. */
-		response = chal;
-	}
-
-	SAFE_FREE(*ppdata);
-	*ppdata = response.data;
-	*p_data_size = response.length;
-	return status;
-}
-
-/******************************************************************************
- Do the SPNEGO encryption negotiation. Parameters are in/out.
- Based off code in smbd/sesssionsetup.c
- Until success we do everything on the partial enc ctx.
-******************************************************************************/
-
-static NTSTATUS srv_enc_spnego_negotiate(connection_struct *conn,
-					unsigned char **ppdata,
-					size_t *p_data_size,
-					unsigned char **pparam,
-					size_t *p_param_size)
-{
-	NTSTATUS status;
-	DATA_BLOB blob = data_blob_null;
-	DATA_BLOB secblob = data_blob_null;
-	BOOL got_kerberos_mechanism = False;
-
-	blob = data_blob_const(*ppdata, *p_data_size);
-
-	status = parse_spnego_mechanisms(blob, &secblob, &got_kerberos_mechanism);
-	if (!NT_STATUS_IS_OK(status)) {
-		return nt_status_squash(status);
-	}
-
-	/* We should have no partial context at this point. */
-
-	srv_free_encryption_context(&partial_srv_trans_enc_ctx);
-
-#if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
-	if (got_kerberos_mechanism && lp_use_kerberos_keytab() ) {
-		status = srv_enc_spnego_gss_negotiate(ppdata, p_data_size, secblob);
-	} else 
-#endif
-	{
-		status = srv_enc_ntlm_negotiate(ppdata, p_data_size, secblob, True);
-	}
-
-	data_blob_free(&secblob);
-
-	if (!NT_STATUS_EQUAL(status,NT_STATUS_MORE_PROCESSING_REQUIRED) && !NT_STATUS_IS_OK(status)) {
-		srv_free_encryption_context(&partial_srv_trans_enc_ctx);
-		return nt_status_squash(status);
-	}
-
-	if (NT_STATUS_IS_OK(status)) {
-		/* Return the context we're using for this encryption state. */
-		if (!(*pparam = SMB_MALLOC_ARRAY(unsigned char, 2))) {
-			return NT_STATUS_NO_MEMORY;
-		}
-		SSVAL(*pparam,0,partial_srv_trans_enc_ctx->es->enc_ctx_num);
-		*p_param_size = 2;
-	}
-
-	return status;
-}
-
-/******************************************************************************
- Complete a SPNEGO encryption negotiation. Parameters are in/out.
- We only get this for a NTLM auth second stage.
-******************************************************************************/
-
-static NTSTATUS srv_enc_spnego_ntlm_auth(connection_struct *conn,
-					unsigned char **ppdata,
-					size_t *p_data_size,
-					unsigned char **pparam,
-					size_t *p_param_size)
-{
-	NTSTATUS status;
-	DATA_BLOB blob = data_blob_null;
-	DATA_BLOB auth = data_blob_null;
-	DATA_BLOB auth_reply = data_blob_null;
-	DATA_BLOB response = data_blob_null;
-	struct smb_srv_trans_enc_ctx *ec = partial_srv_trans_enc_ctx;
-
-	/* We must have a partial context here. */
-
-	if (!ec || !ec->es || ec->auth_ntlmssp_state == NULL || ec->es->smb_enc_type != SMB_TRANS_ENC_NTLM) {
-		srv_free_encryption_context(&partial_srv_trans_enc_ctx);
-		return NT_STATUS_INVALID_PARAMETER;
-	}
-
-	blob = data_blob_const(*ppdata, *p_data_size);
-	if (!spnego_parse_auth(blob, &auth)) {
-		srv_free_encryption_context(&partial_srv_trans_enc_ctx);
-		return NT_STATUS_INVALID_PARAMETER;
-	}
-
-	status = auth_ntlmssp_update(ec->auth_ntlmssp_state, auth, &auth_reply);
-	data_blob_free(&auth);
-
-	response = spnego_gen_auth_response(&auth_reply, status, OID_NTLMSSP);
-	data_blob_free(&auth_reply);
-
-	if (NT_STATUS_IS_OK(status)) {
-		/* Return the context we're using for this encryption state. */
-		if (!(*pparam = SMB_MALLOC_ARRAY(unsigned char, 2))) {
-			return NT_STATUS_NO_MEMORY;
-		}
-		SSVAL(*pparam,0,ec->es->enc_ctx_num);
-		*p_param_size = 2;
-	}
-
-	SAFE_FREE(*ppdata);
-	*ppdata = response.data;
-	*p_data_size = response.length;
-	return status;
-}
-
-/******************************************************************************
- Raw NTLM encryption negotiation. Parameters are in/out.
- This function does both steps.
-******************************************************************************/
-
-static NTSTATUS srv_enc_raw_ntlm_auth(connection_struct *conn,
-					unsigned char **ppdata,
-					size_t *p_data_size,
-					unsigned char **pparam,
-					size_t *p_param_size)
-{
-	NTSTATUS status;
-	DATA_BLOB blob = data_blob_const(*ppdata, *p_data_size);
-	DATA_BLOB response = data_blob_null;
-	struct smb_srv_trans_enc_ctx *ec;
-
-	if (!partial_srv_trans_enc_ctx) {
-		/* This is the initial step. */
-		status = srv_enc_ntlm_negotiate(ppdata, p_data_size, blob, False);
-		if (!NT_STATUS_EQUAL(status,NT_STATUS_MORE_PROCESSING_REQUIRED) && !NT_STATUS_IS_OK(status)) {
-			srv_free_encryption_context(&partial_srv_trans_enc_ctx);
-			return nt_status_squash(status);
-		}
-		return status;
-	}
-
-	ec = partial_srv_trans_enc_ctx;
-	if (!ec || !ec->es || ec->auth_ntlmssp_state == NULL || ec->es->smb_enc_type != SMB_TRANS_ENC_NTLM) {
-		srv_free_encryption_context(&partial_srv_trans_enc_ctx);
-		return NT_STATUS_INVALID_PARAMETER;
-	}
-
-	/* Second step. */
-	status = auth_ntlmssp_update(partial_srv_trans_enc_ctx->auth_ntlmssp_state, blob, &response);
-
-	if (NT_STATUS_IS_OK(status)) {
-		/* Return the context we're using for this encryption state. */
-		if (!(*pparam = SMB_MALLOC_ARRAY(unsigned char, 2))) {
-			return NT_STATUS_NO_MEMORY;
-		}
-		SSVAL(*pparam,0,ec->es->enc_ctx_num);
-		*p_param_size = 2;
-	}
-
-	/* Return the raw blob. */
-	SAFE_FREE(*ppdata);
-	*ppdata = response.data;
-	*p_data_size = response.length;
-	return status;
-}
-
-/******************************************************************************
- Do the SPNEGO encryption negotiation. Parameters are in/out.
-******************************************************************************/
-
-NTSTATUS srv_request_encryption_setup(connection_struct *conn,
-					unsigned char **ppdata,
-					size_t *p_data_size,
-					unsigned char **pparam,
-					size_t *p_param_size)
-{
-	unsigned char *pdata = *ppdata;
-
-	SAFE_FREE(*pparam);
-	*p_param_size = 0;
-
-	if (*p_data_size < 1) {
-		return NT_STATUS_INVALID_PARAMETER;
-	}
-
-	if (pdata[0] == ASN1_APPLICATION(0)) {
-		/* its a negTokenTarg packet */
-		return srv_enc_spnego_negotiate(conn, ppdata, p_data_size, pparam, p_param_size);
-	}
-
-	if (pdata[0] == ASN1_CONTEXT(1)) {
-		/* It's an auth packet */
-		return srv_enc_spnego_ntlm_auth(conn, ppdata, p_data_size, pparam, p_param_size);
-	}
-
-	/* Maybe it's a raw unwrapped auth ? */
-	if (*p_data_size < 7) {
-		return NT_STATUS_INVALID_PARAMETER;
-	}
-
-	if (strncmp((char *)pdata, "NTLMSSP", 7) == 0) {
-		return srv_enc_raw_ntlm_auth(conn, ppdata, p_data_size, pparam, p_param_size);
-	}
-
-	DEBUG(1,("srv_request_encryption_setup: Unknown packet\n"));
-
-	return NT_STATUS_LOGON_FAILURE;
-}
-
-/******************************************************************************
- Negotiation was successful - turn on server-side encryption.
-******************************************************************************/
-
-static NTSTATUS check_enc_good(struct smb_srv_trans_enc_ctx *ec)
-{
-	if (!ec || !ec->es) {
-		return NT_STATUS_LOGON_FAILURE;
-	}
-
-	if (ec->es->smb_enc_type == SMB_TRANS_ENC_NTLM) {
-		if ((ec->es->s.ntlmssp_state->neg_flags & (NTLMSSP_NEGOTIATE_SIGN|NTLMSSP_NEGOTIATE_SEAL)) !=
-				(NTLMSSP_NEGOTIATE_SIGN|NTLMSSP_NEGOTIATE_SEAL)) {
-			return NT_STATUS_INVALID_PARAMETER;
-		}
-	}
-	/* Todo - check gssapi case. */
-
-	return NT_STATUS_OK;
-}
-
-/******************************************************************************
- Negotiation was successful - turn on server-side encryption.
-******************************************************************************/
-
-NTSTATUS srv_encryption_start(connection_struct *conn)
-{
-	NTSTATUS status;
-
-	/* Check that we are really doing sign+seal. */
-	status = check_enc_good(partial_srv_trans_enc_ctx);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
-	}
-	/* Throw away the context we're using currently (if any). */
-	srv_free_encryption_context(&srv_trans_enc_ctx);
-
-	/* Steal the partial pointer. Deliberate shallow copy. */
-	srv_trans_enc_ctx = partial_srv_trans_enc_ctx;
-	srv_trans_enc_ctx->es->enc_on = True;
-
-	partial_srv_trans_enc_ctx = NULL;
-	return NT_STATUS_OK;
-}
-
-/******************************************************************************
- Shutdown all server contexts.
-******************************************************************************/
-
-void server_encryption_shutdown(void)
-{
-	srv_free_encryption_context(&partial_srv_trans_enc_ctx);
-	srv_free_encryption_context(&srv_trans_enc_ctx);
-}
diff --git a/source3/smbd/server.c b/source3/smbd/server.c
index 72eeb7ee6a..0f47a550e9 100644
--- a/source3/smbd/server.c
+++ b/source3/smbd/server.c
@@ -4,7 +4,6 @@
    Copyright (C) Andrew Tridgell		1992-1998
    Copyright (C) Martin Pool			2002
    Copyright (C) Jelmer Vernooij		2002-2003
-   Copyright (C) James Peach			2007
    
    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
@@ -294,33 +293,25 @@ static BOOL allowable_number_of_smbd_processes(void)
 }
 
 /****************************************************************************
- Are we idle enough that we could safely exit?
-****************************************************************************/
-
-static BOOL smbd_is_idle(void)
-{
-	/* Currently we define "idle" as having no client connections. */
-	return count_all_current_connections() == 0;
-}
-
-/****************************************************************************
  Open the socket communication.
 ****************************************************************************/
 
-static BOOL open_sockets_smbd(enum smb_server_mode server_mode, const char *smb_ports)
+static BOOL open_sockets_smbd(BOOL is_daemon, BOOL interactive, const char *smb_ports)
 {
+	int num_interfaces = iface_count();
 	int num_sockets = 0;
 	int fd_listenset[FD_SETSIZE];
 	fd_set listen_set;
 	int s;
 	int maxfd = 0;
 	int i;
-	struct timeval idle_timeout = timeval_zero();
+	char *ports;
 
-	if (server_mode == SERVER_MODE_INETD) {
+	if (!is_daemon) {
 		return open_sockets_inetd();
 	}
 
+		
 #ifdef HAVE_ATEXIT
 	{
 		static int atexit_set;
@@ -333,21 +324,116 @@ static BOOL open_sockets_smbd(enum smb_server_mode server_mode, const char *smb_
 
 	/* Stop zombies */
 	CatchSignal(SIGCLD, sig_cld);
-
+				
 	FD_ZERO(&listen_set);
 
-	/* At this point, it doesn't matter what daemon mode we are in, we
-	 * need some sockets to listen on.
-	 */
-	num_sockets = smbd_sockinit(smb_ports, fd_listenset, &idle_timeout);
-	if (num_sockets == 0) {
-		return False;
+	/* use a reasonable default set of ports - listing on 445 and 139 */
+	if (!smb_ports) {
+		ports = lp_smb_ports();
+		if (!ports || !*ports) {
+			ports = smb_xstrdup(SMB_PORTS);
+		} else {
+			ports = smb_xstrdup(ports);
+		}
+	} else {
+		ports = smb_xstrdup(smb_ports);
 	}
 
-	for (i = 0; i < num_sockets; ++i) {
-		FD_SET(fd_listenset[i], &listen_set);
-		maxfd = MAX(maxfd, fd_listenset[i]);
-	}
+	if (lp_interfaces() && lp_bind_interfaces_only()) {
+		/* We have been given an interfaces line, and been 
+		   told to only bind to those interfaces. Create a
+		   socket per interface and bind to only these.
+		*/
+		
+		/* Now open a listen socket for each of the
+		   interfaces. */
+		for(i = 0; i < num_interfaces; i++) {
+			struct in_addr *ifip = iface_n_ip(i);
+			fstring tok;
+			const char *ptr;
+
+			if(ifip == NULL) {
+				DEBUG(0,("open_sockets_smbd: interface %d has NULL IP address !\n", i));
+				continue;
+			}
+
+			for (ptr=ports; next_token(&ptr, tok, " \t,", sizeof(tok)); ) {
+				unsigned port = atoi(tok);
+				if (port == 0 || port > 0xffff) {
+					continue;
+				}
+				s = fd_listenset[num_sockets] = open_socket_in(SOCK_STREAM, port, 0, ifip->s_addr, True);
+				if(s == -1)
+					return False;
+
+				/* ready to listen */
+				set_socket_options(s,"SO_KEEPALIVE"); 
+				set_socket_options(s,user_socket_options);
+     
+				/* Set server socket to non-blocking for the accept. */
+				set_blocking(s,False); 
+ 
+				if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
+					DEBUG(0,("listen: %s\n",strerror(errno)));
+					close(s);
+					return False;
+				}
+				FD_SET(s,&listen_set);
+				maxfd = MAX( maxfd, s);
+
+				num_sockets++;
+				if (num_sockets >= FD_SETSIZE) {
+					DEBUG(0,("open_sockets_smbd: Too many sockets to bind to\n"));
+					return False;
+				}
+			}
+		}
+	} else {
+		/* Just bind to 0.0.0.0 - accept connections
+		   from anywhere. */
+
+		fstring tok;
+		const char *ptr;
+
+		num_interfaces = 1;
+		
+		for (ptr=ports; next_token(&ptr, tok, " \t,", sizeof(tok)); ) {
+			unsigned port = atoi(tok);
+			if (port == 0 || port > 0xffff) continue;
+			/* open an incoming socket */
+			s = open_socket_in(SOCK_STREAM, port, 0,
+					   interpret_addr(lp_socket_address()),True);
+			if (s == -1)
+				return(False);
+		
+			/* ready to listen */
+			set_socket_options(s,"SO_KEEPALIVE"); 
+			set_socket_options(s,user_socket_options);
+			
+			/* Set server socket to non-blocking for the accept. */
+			set_blocking(s,False); 
+ 
+			if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
+				DEBUG(0,("open_sockets_smbd: listen: %s\n",
+					 strerror(errno)));
+				close(s);
+				return False;
+			}
+
+			fd_listenset[num_sockets] = s;
+			FD_SET(s,&listen_set);
+			maxfd = MAX( maxfd, s);
+
+			num_sockets++;
+
+			if (num_sockets >= FD_SETSIZE) {
+				DEBUG(0,("open_sockets_smbd: Too many sockets to bind to\n"));
+				return False;
+			}
+		}
+	} 
+
+	SAFE_FREE(ports);
 
 
 	/* Setup the main smbd so that we can get messages. Note that
@@ -380,7 +466,7 @@ static BOOL open_sockets_smbd(enum smb_server_mode server_mode, const char *smb_
 	   for each incoming connection */
 	DEBUG(2,("waiting for a connection\n"));
 	while (1) {
-		struct timeval now;
+		struct timeval now, idle_timeout;
 		fd_set r_fds, w_fds;
 		int num;
 		
@@ -396,6 +482,8 @@ static BOOL open_sockets_smbd(enum smb_server_mode server_mode, const char *smb_
 			}
 		}
 
+		idle_timeout = timeval_zero();
+
 		memcpy((char *)&r_fds, (char *)&listen_set, 
 		       sizeof(listen_set));
 		FD_ZERO(&w_fds);
@@ -405,21 +493,9 @@ static BOOL open_sockets_smbd(enum smb_server_mode server_mode, const char *smb_
 					 &r_fds, &w_fds, &idle_timeout,
 					 &maxfd);
 
-		if (timeval_is_zero(&idle_timeout)) {
-			num = sys_select(maxfd + 1, &r_fds, &w_fds,
-					NULL, NULL);
-		} else {
-			num = sys_select(maxfd + 1, &r_fds, &w_fds,
-					NULL, &idle_timeout);
-
-			/* If the idle timeout fired and we are idle, exit
-			 * gracefully. We expect to be running under a process
-			 * controller that will restart us if necessry.
-			 */
-			if (num == 0 && smbd_is_idle()) {
-				exit_server_cleanly("idle timeout");
-			}
-		}
+		num = sys_select(maxfd+1,&r_fds,&w_fds,NULL,
+				 timeval_is_zero(&idle_timeout) ?
+				 NULL : &idle_timeout);
 
 		if (num == -1 && errno == EINTR) {
 			if (got_sig_term) {
@@ -436,7 +512,7 @@ static BOOL open_sockets_smbd(enum smb_server_mode server_mode, const char *smb_
 
 			continue;
 		}
-
+		
 		if (run_events(smbd_event_context(), num, &r_fds, &w_fds)) {
 			continue;
 		}
@@ -476,13 +552,8 @@ static BOOL open_sockets_smbd(enum smb_server_mode server_mode, const char *smb_
 			/* Ensure child is set to blocking mode */
 			set_blocking(smbd_server_fd(),True);
 
-			/* In interactive mode, return with a connected socket.
-			 * Foreground and daemon modes should fork worker
-			 * processes.
-			 */
-			if (server_mode == SERVER_MODE_INTERACTIVE) {
+			if (smbd_server_fd() != -1 && interactive)
 				return True;
-			}
 			
 			if (allowable_number_of_smbd_processes() &&
 			    smbd_server_fd() != -1 &&
@@ -694,8 +765,6 @@ static void exit_server_common(enum server_exit_reason how,
 	locking_end();
 	printing_end();
 
-	server_encryption_shutdown();
-
 	if (how != SERVER_EXIT_NORMAL) {
 		int oldlevel = DEBUGLEVEL;
 
@@ -804,26 +873,23 @@ extern void build_options(BOOL screen);
  int main(int argc,const char *argv[])
 {
 	/* shall I run as a daemon */
-	BOOL no_process_group = False;
-	BOOL log_stdout = False;
-	const char *ports = NULL;
-	const char *profile_level = NULL;
+	static BOOL is_daemon = False;
+	static BOOL interactive = False;
+	static BOOL Fork = True;
+	static BOOL no_process_group = False;
+	static BOOL log_stdout = False;
+	static char *ports = NULL;
+	static char *profile_level = NULL;
 	int opt;
 	poptContext pc;
 	BOOL print_build_options = False;
 
-	enum smb_server_mode server_mode = SERVER_MODE_DAEMON;
-
 	struct poptOption long_options[] = {
 	POPT_AUTOHELP
-	{"daemon", 'D', POPT_ARG_VAL, &server_mode, SERVER_MODE_DAEMON,
-		"Become a daemon (default)" },
-	{"interactive", 'i', POPT_ARG_VAL, &server_mode, SERVER_MODE_INTERACTIVE,
-		"Run interactive (not a daemon)"},
-	{"foreground", 'F', POPT_ARG_VAL, &server_mode, SERVER_MODE_FOREGROUND,
-		"Run daemon in foreground (for daemontools, etc.)" },
-	{"no-process-group", '\0', POPT_ARG_VAL, &no_process_group, True,
-		"Don't create a new process group" },
+	{"daemon", 'D', POPT_ARG_VAL, &is_daemon, True, "Become a daemon (default)" },
+	{"interactive", 'i', POPT_ARG_VAL, &interactive, True, "Run interactive (not a daemon)"},
+	{"foreground", 'F', POPT_ARG_VAL, &Fork, False, "Run daemon in foreground (for daemontools, etc.)" },
+	{"no-process-group", '\0', POPT_ARG_VAL, &no_process_group, True, "Don't create a new process group" },
 	{"log-stdout", 'S', POPT_ARG_VAL, &log_stdout, True, "Log to stdout" },
 	{"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
 	{"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
@@ -870,14 +936,16 @@ extern void build_options(BOOL screen);
 
 	set_remote_machine_name("smbd", False);
 
-	if (server_mode == SERVER_MODE_INTERACTIVE) {
+	if (interactive) {
+		Fork = False;
 		log_stdout = True;
-		if (DEBUGLEVEL >= 9) {
-			talloc_enable_leak_report();
-		}
 	}
 
-	if (log_stdout && server_mode == SERVER_MODE_DAEMON) {
+	if (interactive && (DEBUGLEVEL >= 9)) {
+		talloc_enable_leak_report();
+	}
+
+	if (log_stdout && Fork) {
 		DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
 		exit(1);
 	}
@@ -967,19 +1035,21 @@ extern void build_options(BOOL screen);
 
 	DEBUG(3,( "loaded services\n"));
 
-	if (is_a_socket(0)) {
-		if (server_mode == SERVER_MODE_DAEMON) {
-			DEBUG(0,("standard input is a socket, "
-				    "assuming -F option\n"));
-		}
-		server_mode = SERVER_MODE_INETD;
+	if (!is_daemon && !is_a_socket(0)) {
+		if (!interactive)
+			DEBUG(0,("standard input is not a socket, assuming -D option\n"));
+
+		/*
+		 * Setting is_daemon here prevents us from eventually calling
+		 * the open_sockets_inetd()
+		 */
+
+		is_daemon = True;
 	}
 
-	if (server_mode == SERVER_MODE_DAEMON) {
+	if (is_daemon && !interactive) {
 		DEBUG( 3, ( "Becoming a daemon.\n" ) );
-		become_daemon(True, no_process_group);
-	} else if (server_mode == SERVER_MODE_FOREGROUND) {
-		become_daemon(False, no_process_group);
+		become_daemon(Fork, no_process_group);
 	}
 
 #if HAVE_SETPGID
@@ -987,18 +1057,15 @@ extern void build_options(BOOL screen);
 	 * If we're interactive we want to set our own process group for
 	 * signal management.
 	 */
-	if (server_mode == SERVER_MODE_INTERACTIVE && !no_process_group) {
+	if (interactive && !no_process_group)
 		setpgid( (pid_t)0, (pid_t)0);
-	}
 #endif
 
 	if (!directory_exist(lp_lockdir(), NULL))
 		mkdir(lp_lockdir(), 0755);
 
-	if (server_mode != SERVER_MODE_INETD &&
-	    server_mode != SERVER_MODE_INTERACTIVE) {
+	if (is_daemon)
 		pidfile_create("smbd");
-	}
 
 	/* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
 
@@ -1052,10 +1119,9 @@ extern void build_options(BOOL screen);
 	   running as a daemon -- bad things will happen if
 	   smbd is launched via inetd and we fork a copy of 
 	   ourselves here */
-	if (server_mode != SERVER_MODE_INETD &&
-	    server_mode != SERVER_MODE_INTERACTIVE) {
+
+	if ( is_daemon && !interactive )
 		start_background_queue(); 
-	}
 
 	/* Always attempt to initialize DMAPI. We will only use it later if
 	 * lp_dmapi_support is set on the share, but we need a single global
@@ -1063,9 +1129,8 @@ extern void build_options(BOOL screen);
 	 */
 	dmapi_init_session();
 
-	if (!open_sockets_smbd(server_mode, ports)) {
+	if (!open_sockets_smbd(is_daemon, interactive, ports))
 		exit(1);
-	}
 
 	/*
 	 * everything after this point is run after the fork()
@@ -1078,8 +1143,7 @@ extern void build_options(BOOL screen);
 	/* Possibly reload the services file. Only worth doing in
 	 * daemon mode. In inetd mode, we know we only just loaded this.
 	 */
-	if (server_mode != SERVER_MODE_INETD &&
-	    server_mode != SERVER_MODE_INTERACTIVE) {
+	if (is_daemon) {
 		reload_services(True);
 	}
 
diff --git a/source3/smbd/service.c b/source3/smbd/service.c
index 4daa2924a2..1c46e3776c 100644
--- a/source3/smbd/service.c
+++ b/source3/smbd/service.c
@@ -312,14 +312,7 @@ static int load_registry_service(const char *servicename)
 		TALLOC_FREE(value);
 	}
 
-	if (!service_ok(res)) {
-		/* this is actually never reached, since 
-		 * service_ok only returns False if the service
-		 * entry does not have a service name, and we _know_
-		 * we do have a service name here... */
-		res = -1;
-	}
-
+	res = 0;
  error:
 
 	TALLOC_FREE(key);
@@ -409,6 +402,10 @@ int find_service(fstring service)
 	if (iService < 0) {
 	}
 
+	if (iService < 0) {
+		iService = load_registry_service(service);
+	}
+
 	/* Is it a usershare service ? */
 	if (iService < 0 && *lp_usershare_path()) {
 		/* Ensure the name is canonicalized. */
@@ -444,10 +441,6 @@ int find_service(fstring service)
 		}
 	}
 
-	if (iService < 0) {
-		iService = load_registry_service(service);
-	}
-
 	if (iService >= 0) {
 		if (!VALID_SNUM(iService)) {
 			DEBUG(0,("Invalid snum %d for %s\n",iService, service));
@@ -789,6 +782,7 @@ static connection_struct *make_connection_snum(int snum, user_struct *vuser,
 	conn->veto_list = NULL;
 	conn->hide_list = NULL;
 	conn->veto_oplock_list = NULL;
+	conn->aio_write_behind_list = NULL;
 	string_set(&conn->dirpath,"");
 	string_set(&conn->user,user);
 
diff --git a/source3/smbd/session.c b/source3/smbd/session.c
index c7cdf41fb5..8dd321fad7 100644
--- a/source3/smbd/session.c
+++ b/source3/smbd/session.c
@@ -201,12 +201,9 @@ BOOL session_claim(user_struct *vuser)
 			       sessionid.id_str, sessionid.id_num);
 	}
 
-	TALLOC_FREE(rec);
-
 	vuser->session_keystr = talloc_strdup(vuser, keystr);
 	if (!vuser->session_keystr) {
-		DEBUG(0, ("session_claim:  talloc_strdup() failed for "
-			  "session_keystr\n"));
+		DEBUG(0, ("session_claim:  talloc_strdup() failed for session_keystr\n"));
 		return False;
 	}
 	return True;
diff --git a/source3/smbd/sockinit.c b/source3/smbd/sockinit.c
deleted file mode 100644
index 598bbd1bda..0000000000
--- a/source3/smbd/sockinit.c
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
-   Unix SMB/CIFS implementation.
-
-   Copyright (C) Andrew Tridgell		1992-1998
-   Copyright (C) James Peach			2007
-
-   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 3 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, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "includes.h"
-#include "smb_launchd.h"
-
-extern pstring user_socket_options;
-
-static int init_sockets_smbd(const char *smb_ports, int listenset[FD_SETSIZE])
-{
-	int num_interfaces = iface_count();
-	char * ports;
-	int num_sockets = 0;
-	int i, s;
-
-	/* use a reasonable default set of ports - listing on 445 and 139 */
-	if (!smb_ports) {
-		ports = lp_smb_ports();
-		if (!ports || !*ports) {
-			ports = smb_xstrdup(SMB_PORTS);
-		} else {
-			ports = smb_xstrdup(ports);
-		}
-	} else {
-		ports = smb_xstrdup(smb_ports);
-	}
-
-	if (lp_interfaces() && lp_bind_interfaces_only()) {
-		/* We have been given an interfaces line, and been
-		   told to only bind to those interfaces. Create a
-		   socket per interface and bind to only these.
-		*/
-
-		/* Now open a listen socket for each of the
-		   interfaces. */
-		for(i = 0; i < num_interfaces; i++) {
-			struct in_addr *ifip = iface_n_ip(i);
-			fstring tok;
-			const char *ptr;
-
-			if(ifip == NULL) {
-				DEBUG(0,("init_sockets_smbd: interface %d has "
-					"NULL IP address !\n", i));
-				continue;
-			}
-
-			for (ptr=ports; next_token(&ptr, tok, " \t,",
-						sizeof(tok)); ) {
-				unsigned port = atoi(tok);
-				if (port == 0 || port > 0xffff) {
-					continue;
-				}
-				s = listenset[num_sockets] =
-					open_socket_in(SOCK_STREAM,
-							port,
-							0,
-							ifip->s_addr,
-							True);
-				if(s == -1)
-					return 0;
-
-				/* ready to listen */
-				set_socket_options(s,"SO_KEEPALIVE");
-				set_socket_options(s,user_socket_options);
-
-				/* Set server socket to non-blocking
-				 * for the accept. */
-				set_blocking(s,False);
-
-				if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
-					DEBUG(0,("listen: %s\n",
-						strerror(errno)));
-					close(s);
-					return 0;
-				}
-
-				num_sockets++;
-				if (num_sockets >= FD_SETSIZE) {
-					DEBUG(0,("init_sockets_smbd: "
-					"Too many sockets to bind to\n"));
-					return 0;
-				}
-			}
-		}
-	} else {
-		/* Just bind to 0.0.0.0 - accept connections
-		   from anywhere. */
-
-		fstring tok;
-		const char *ptr;
-
-		num_interfaces = 1;
-
-		for (ptr=ports; next_token(&ptr, tok, " \t,", sizeof(tok)); ) {
-			unsigned port = atoi(tok);
-			if (port == 0  || port > 0xffff) continue;
-			/* open an incoming socket */
-			s = open_socket_in(SOCK_STREAM, port, 0,
-					   interpret_addr(lp_socket_address()),
-					   True);
-			if (s == -1)
-				return 0;
-
-			/* ready to listen */
-			set_socket_options(s,"SO_KEEPALIVE");
-			set_socket_options(s,user_socket_options);
-
-			/* Set server socket to non-blocking for the accept. */
-			set_blocking(s,False);
-
-			if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
-				DEBUG(0,("init_sockets_smbd: listen: %s\n",
-					 strerror(errno)));
-				close(s);
-				return 0;
-			}
-
-			listenset[num_sockets] = s;
-			num_sockets++;
-
-			if (num_sockets >= FD_SETSIZE) {
-				DEBUG(0,("init_sockets_smbd: "
-					"Too many sockets to bind to\n"));
-				return 0;
-			}
-		}
-	}
-
-	SAFE_FREE(ports);
-	return num_sockets;
-}
-
-static int init_sockets_launchd(const struct smb_launch_info *linfo,
-				const char * smb_ports,
-				int listenset[FD_SETSIZE])
-{
-	int num_sockets;
-	int i;
-
-	/* The launchd service configuration does not have to provide sockets,
-	 * even though it's basically useless without it.
-	 */
-	if (!linfo->num_sockets) {
-		return init_sockets_smbd(smb_ports, listenset);
-	}
-
-	/* Make sure we don't get more sockets than we can handle. */
-	num_sockets = MIN(FD_SETSIZE, linfo->num_sockets);
-	memcpy(listenset, linfo->socket_list, num_sockets * sizeof(int));
-
-	/* Get the sockets ready. This could be hoisted into
-	 * open_sockets_smbd(), but the order of socket operations might
-	 * matter for some platforms, so this approach seems less risky.
-	 *	--jpeach
-	 */
-	for (i = 0; i < num_sockets; ++i) {
-		set_socket_options(listenset[i], "SO_KEEPALIVE");
-		set_socket_options(listenset[i], user_socket_options);
-
-		/* Set server socket to non-blocking for the accept. */
-		set_blocking(listenset[i], False);
-	}
-
-	return num_sockets;
-}
-
-/* This function is responsible for opening (or retrieving) all the sockets we
- * smbd will be listening on. It should apply all the configured socket options
- * and return the number of valid sockets in listenset.
- */
-int smbd_sockinit(const char *cmdline_ports, int listenset[FD_SETSIZE],
-			struct timeval *idle)
-{
-	int num_sockets;
-	struct smb_launch_info linfo;
-
-	ZERO_STRUCTP(idle);
-
-	if (smb_launchd_checkin(&linfo)) {
-		/* We are running under launchd and launchd has
-		 * opened some sockets for us.
-		 */
-		num_sockets = init_sockets_launchd(&linfo,
-					    cmdline_ports,
-					    listenset);
-		idle->tv_sec = linfo.idle_timeout_secs;
-		smb_launchd_checkout(&linfo);
-	} else {
-		num_sockets = init_sockets_smbd(cmdline_ports,
-					    listenset);
-	}
-
-	return num_sockets;
-}
diff --git a/source3/smbd/srvstr.c b/source3/smbd/srvstr.c
index fbcf249ffb..68e61033ae 100644
--- a/source3/smbd/srvstr.c
+++ b/source3/smbd/srvstr.c
@@ -79,7 +79,7 @@ ssize_t message_push_string(uint8 **outbuf, const char *str, int flags)
 		DEBUG(0, ("srvstr_push failed\n"));
 		return -1;
 	}
-	set_message_bcc(NULL, (char *)tmp, smb_buflen(tmp) + result);
+	set_message_bcc((char *)tmp, smb_buflen(tmp) + result);
 
 	*outbuf = tmp;
 
diff --git a/source3/smbd/trans2.c b/source3/smbd/trans2.c
index ada4868bf8..7392271b48 100644
--- a/source3/smbd/trans2.c
+++ b/source3/smbd/trans2.c
@@ -2733,9 +2733,7 @@ cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned
 					CIFS_UNIX_FCNTL_LOCKS_CAP|
 					CIFS_UNIX_EXTATTR_CAP|
 					CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP|
-					/* Ensure we don't do this on signed or sealed data. */
-					(srv_is_signing_active() ? 0 : CIFS_UNIX_LARGE_READ_CAP)
-					)));
+					CIFS_UNIX_LARGE_READ_CAP)));
 			break;
 
 		case SMB_QUERY_POSIX_FS_INFO:
@@ -2986,51 +2984,6 @@ cap_low = 0x%x, cap_high = 0x%x\n",
 				}
 				break;
 			}
-		case SMB_REQUEST_TRANSPORT_ENCRYPTION:
-			{
-				NTSTATUS status;
-				size_t param_len = 0;
-				size_t data_len = total_data;
-
-				if (!lp_unix_extensions()) {
-					reply_nterror(
-						req, NT_STATUS_INVALID_LEVEL);
-					return;
-				}
-
-				DEBUG( 4,("call_trans2setfsinfo: request transport encrption.\n"));
-
-				status = srv_request_encryption_setup(conn,
-									(unsigned char **)ppdata,
-									&data_len,
-									(unsigned char **)pparams,
-									&param_len
-									);
-
-				if (!NT_STATUS_IS_OK(status)) {
-					/*
-					 * TODO: Check
-					 * MORE_PROCESSING_REQUIRED, this used
-					 * to have special handling here.
-					 */
-					reply_nterror(req, status);
-					return;
-				}
-
-				send_trans2_replies(req,
-						    *pparams, param_len,
-						    *ppdata, data_len,
-						    max_data_bytes);
-
-				if (NT_STATUS_IS_OK(status)) {
-					/* Server-side transport encryption is now *on*. */
-					status = srv_encryption_start(conn);
-					if (!NT_STATUS_IS_OK(status)) {
-						exit_server_cleanly("Failure in setting up encrypted transport");
-					}
-				}
-				return;
-			}
 		case SMB_FS_QUOTA_INFORMATION:
 			{
 				files_struct *fsp = NULL;
diff --git a/source3/smbd/utmp.c b/source3/smbd/utmp.c
index 7f43740754..52174c4d83 100644
--- a/source3/smbd/utmp.c
+++ b/source3/smbd/utmp.c
@@ -220,13 +220,13 @@ static void uw_pathname(pstring fname, const char *uw_name, const char *uw_defau
 	}
 
 	/* For u-files and non-explicit w-dir, look for "utmp dir" */
-	if (strlen(dirname) == 0) {
+	if (dirname == 0 || strlen(dirname) == 0) {
 		pstrcpy(dirname,lp_utmpdir());
 		trim_char(dirname,'\0','/');
 	}
 
 	/* If explicit directory above, use it */
-	if (strlen(dirname) != 0) {
+	if (dirname != 0 && strlen(dirname) != 0) {
 		pstrcpy(fname, dirname);
 		pstrcat(fname, "/");
 		pstrcat(fname, uw_name);