r8380: adding missing files

3 files changed, 1307 insertions, 0 deletions

diff --git a/source/registry/reg_dynamic.c b/source/registry/reg_dynamic.c
new file mode 100644
index 00000000000..7f8f664ec6e
--- /dev/null
+++ b/source/registry/reg_dynamic.c
@@ -0,0 +1,152 @@
+/* 
+ *  Unix SMB/CIFS implementation.
+ *  Virtual Windows Registry Layer
+ *  Copyright (C) Gerald Carter                     2002-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.
+ */
+
+/* Implementation of registry frontend view functions. */
+
+#include "includes.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_RPC_SRV
+
+struct reg_dyn_values {
+	const char *path;
+	int (*fetch_values) ( REGVAL_CTR *val );
+};
+
+/***********************************************************************
+***********************************************************************/
+
+static int netlogon_params( REGVAL_CTR *regvals )
+{
+	uint32 dwValue;
+	
+	if ( !account_policy_get(AP_REFUSE_MACHINE_PW_CHANGE, &dwValue) )
+		dwValue = 0;
+		
+	regval_ctr_addvalue( regvals, "RefusePasswordChange", REG_DWORD,
+		(char*)&dwValue, sizeof(dwValue) );
+
+	return regval_ctr_numvals( regvals );
+}
+
+/***********************************************************************
+***********************************************************************/
+
+static int prod_options( REGVAL_CTR *regvals )
+{
+	const char              *value_ascii = "";
+	fstring                 value;
+	int                     value_length;
+	
+	switch (lp_server_role()) {
+		case ROLE_DOMAIN_PDC:
+		case ROLE_DOMAIN_BDC:
+			value_ascii = "LanmanNT";
+			break;
+		case ROLE_STANDALONE:
+			value_ascii = "ServerNT";
+			break;
+		case ROLE_DOMAIN_MEMBER:
+			value_ascii = "WinNT";
+			break;
+	}
+		
+	value_length = push_ucs2( value, value, value_ascii, sizeof(value), 
+		STR_TERMINATE|STR_NOALIGN );
+	regval_ctr_addvalue( regvals, "ProductType", REG_SZ, value, 
+		value_length );
+	
+	return regval_ctr_numvals( regvals );
+}
+
+/***********************************************************************
+***********************************************************************/
+
+static int tcpip_params( REGVAL_CTR *regvals )
+{
+	fstring                 value;
+	int                     value_length;
+	char   			*hname;
+	fstring 		mydomainname;
+	
+
+	hname = myhostname();
+	value_length = push_ucs2( value, value, hname, sizeof(value), STR_TERMINATE|STR_NOALIGN);		
+	regval_ctr_addvalue( regvals, "Hostname",REG_SZ, value, value_length );
+	
+	get_mydnsdomname( mydomainname );		
+	value_length = push_ucs2( value, value, mydomainname, sizeof(value), STR_TERMINATE|STR_NOALIGN);		
+	regval_ctr_addvalue( regvals, "Domain", REG_SZ, value, value_length );
+		
+	return regval_ctr_numvals( regvals );
+}
+
+
+/***********************************************************************
+ Structure holding the registry paths and pointers to the value 
+ enumeration functions
+***********************************************************************/
+
+static struct reg_dyn_values dynamic_values[] = {
+	{ "HKLM/SYSTEM/CURRENTCONTROLSET/SERVICES/NETLOGON/PARAMETERS", &netlogon_params  },
+	{ "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRODUCTOPTIONS",       &prod_options     },
+	{ "HKLM/SYSTEM/CURRENTCONTROLSET/SERVICES/TCPIP/PARAMETERS",    &tcpip_params     },
+	{ NULL, NULL }
+};
+
+/***********************************************************************
+***********************************************************************/
+
+int fetch_dynamic_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
+{
+	int i;
+	pstring path;
+	
+	pstrcpy( path, key->name );
+	normalize_reg_path( path );
+	
+	for ( i=0; dynamic_values[i].path; i++ ) {
+		if ( strcmp( path, dynamic_values[i].path ) == 0 )
+			return dynamic_values[i].fetch_values( val );
+	}
+	
+	return -1;
+}
+
+/***********************************************************************
+***********************************************************************/
+
+BOOL check_dynamic_reg_values( REGISTRY_KEY *key )
+{
+	int i;
+	pstring path;
+	
+	pstrcpy( path, key->name );
+	normalize_reg_path( path );
+	
+	for ( i=0; dynamic_values[i].path; i++ ) {
+		/* can't write to dynamic keys */
+		if ( strcmp( path, dynamic_values[i].path ) == 0 )
+			return True;
+	}
+	
+	return False;
+}
+
diff --git a/source/sam/idmap_ad.c b/source/sam/idmap_ad.c
new file mode 100644
index 00000000000..47e349483dd
--- /dev/null
+++ b/source/sam/idmap_ad.c
@@ -0,0 +1,407 @@
+/*
+ *  idmap_ad: map between Active Directory and RFC 2307 or "Services for Unix" (SFU) Accounts
+ *
+ * Unix SMB/CIFS implementation.
+ *
+ * Winbind ADS backend functions
+ *
+ * Copyright (C) Andrew Tridgell 2001
+ * Copyright (C) Andrew Bartlett <abartlet@samba.org> 2003
+ * Copyright (C) Gerald (Jerry) Carter 2004
+ * Copyright (C) Luke Howard 2001-2004
+ *
+ * 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"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_IDMAP
+
+#ifndef ATTR_UIDNUMBER
+#define ATTR_UIDNUMBER ADS_ATTR_SFU_UIDNUMBER_OID
+#endif
+
+#ifndef ATTR_GIDNUMBER
+#define ATTR_GIDNUMBER ADS_ATTR_SFU_GIDNUMBER_OID
+#endif
+
+#define WINBIND_CCACHE_NAME "MEMORY:winbind_ccache"
+
+NTSTATUS init_module(void);
+
+static ADS_STRUCT *ad_idmap_ads = NULL;
+static char *ad_idmap_uri = NULL;
+
+static char *attr_uidnumber = NULL;
+static char *attr_gidnumber = NULL;
+
+static BOOL ad_idmap_check_attr_mapping(ADS_STRUCT *ads)
+{
+	if (attr_uidnumber != NULL && attr_gidnumber != NULL) {
+		return True;
+	}
+
+	if (use_nss_info("sfu")) {
+	
+		if (!ads_check_sfu_mapping(ads)) {
+			DEBUG(0,("ad_idmap_check_attr_mapping: failed to check for SFU schema\n"));
+			return False;
+		}
+
+		attr_uidnumber = SMB_STRDUP(ads->schema.sfu_uidnumber_attr);
+		attr_gidnumber = SMB_STRDUP(ads->schema.sfu_gidnumber_attr);
+
+	} else {
+		attr_uidnumber = SMB_STRDUP("uidNumber");
+		attr_gidnumber = SMB_STRDUP("gidNumber");
+	}
+
+	return True;
+}
+
+static ADS_STRUCT *ad_idmap_cached_connection(void)
+{
+	ADS_STRUCT *ads;
+	ADS_STATUS status;
+	BOOL local = False;
+
+#ifdef ADS_AUTH_EXTERNAL_BIND
+	local = ((strncmp(ad_idmap_uri, "ldapi://", sizeof("ldapi://") - 1)) == 0);
+#endif /* ADS_AUTH_EXTERNAL_BIND */
+
+	if (ad_idmap_ads != NULL) {
+		ads = ad_idmap_ads;
+
+		/* check for a valid structure */
+
+		DEBUG(7, ("Current tickets expire at %d, time is now %d\n",
+			  (uint32) ads->auth.expire, (uint32) time(NULL)));
+		if ( ads->config.realm && (ads->auth.expire > time(NULL))) {
+			return ads;
+		} else {
+			/* we own this ADS_STRUCT so make sure it goes away */
+			ads->is_mine = True;
+			ads_destroy( &ads );
+			ads_kdestroy(WINBIND_CCACHE_NAME);
+			ad_idmap_ads = NULL;
+		}
+	}
+
+	if (!local) {
+		/* we don't want this to affect the users ccache */
+		setenv("KRB5CCNAME", WINBIND_CCACHE_NAME, 1);
+	}
+
+	ads = ads_init(NULL, NULL, NULL);
+	if (!ads) {
+		DEBUG(1,("ads_init failed\n"));
+		return NULL;
+	}
+
+	/* if ad_imap_uri is not empty we try to connect to
+	 * the given URI in smb.conf. Else try to connect to
+	 * one of the DCs
+	 */
+	if (*ad_idmap_uri != '\0') {
+		ads->server.ldap_uri = SMB_STRDUP(ad_idmap_uri);
+		if (ads->server.ldap_uri == NULL) {
+			return NULL;
+		}
+	}
+	else {
+		ads->server.ldap_uri    = NULL;
+		ads->server.ldap_server = NULL;
+	}
+
+#ifdef ADS_AUTH_EXTERNAL_BIND
+	if (local)
+		ads->auth.flags |= ADS_AUTH_EXTERNAL_BIND;
+	else
+#endif
+	{
+		/* the machine acct password might have change - fetch it every time */
+		SAFE_FREE(ads->auth.password);
+		ads->auth.password = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
+
+		SAFE_FREE(ads->auth.realm);
+		ads->auth.realm = SMB_STRDUP(lp_realm());
+	}
+
+	status = ads_connect(ads);
+	if (!ADS_ERR_OK(status)) {
+		DEBUG(1, ("ad_idmap_init: failed to connect to AD\n"));
+		ads_destroy(&ads);
+		return NULL;
+	}
+
+	ads->is_mine = False;
+
+	if (!ad_idmap_check_attr_mapping(ads)) {
+		DEBUG(1, ("ad_idmap_init: failed to check attribute mapping\n"));
+		return NULL;
+	}
+
+	ad_idmap_ads = ads;
+	return ads;
+}
+
+static NTSTATUS ad_idmap_init(char *uri)
+{
+	ad_idmap_uri = SMB_STRDUP(uri);
+	if (ad_idmap_uri == NULL) {
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS ad_idmap_get_sid_from_id(DOM_SID *sid, unid_t unid, int id_type)
+{
+	ADS_STATUS rc;
+	NTSTATUS status = NT_STATUS_NONE_MAPPED;
+	const char *attrs[] = { "objectSid", NULL };
+	void *res = NULL;
+	void *msg = NULL;
+	char *expr = NULL;
+	fstring sid_string;
+	int count;
+	ADS_STRUCT *ads;
+
+	if (sid == NULL) {
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	ads = ad_idmap_cached_connection();
+	if (ads == NULL) {
+		DEBUG(1, ("ad_idmap_get_id_from_sid ADS uninitialized\n"));
+		return NT_STATUS_NOT_SUPPORTED;
+	}
+
+	switch (id_type & ID_TYPEMASK) {
+		case ID_USERID:
+			if (asprintf(&expr, "(&(|(sAMAccountType=%d)(sAMAccountType=%d)(sAMAccountType=%d))(%s=%d))",
+				ATYPE_NORMAL_ACCOUNT, ATYPE_WORKSTATION_TRUST, ATYPE_INTERDOMAIN_TRUST,
+				ATTR_UIDNUMBER, (int)unid.uid) == -1) {
+				return NT_STATUS_NO_MEMORY;
+			}
+			break;
+		case ID_GROUPID:
+			if (asprintf(&expr, "(&(|(sAMAccountType=%d)(sAMAccountType=%d))(%s=%d))",
+				ATYPE_SECURITY_GLOBAL_GROUP, ATYPE_SECURITY_LOCAL_GROUP,
+				ATTR_GIDNUMBER, (int)unid.gid) == -1) {
+				return NT_STATUS_NO_MEMORY;
+			}
+			break;
+		default:
+			return NT_STATUS_INVALID_PARAMETER;
+			break;
+	}
+
+	rc = ads_search_retry(ads, &res, expr, attrs);
+	free(expr);
+	if (!ADS_ERR_OK(rc)) {
+		DEBUG(1, ("ad_idmap_get_sid_from_id: ads_search: %s\n", ads_errstr(rc)));
+		goto done;
+	}
+
+	count = ads_count_replies(ads, res);
+	if (count == 0) {
+		DEBUG(1, ("ad_idmap_get_sid_from_id: ads_count_replies: no results\n"));
+		goto done;
+	} else if (count != 1) {
+		DEBUG(1, ("ad_idmap_get_sid_from_id: ads_count_replies: incorrect cardinality\n"));
+		goto done;
+	}
+
+	msg = ads_first_entry(ads, res);
+	if (msg == NULL) {
+		DEBUG(1, ("ad_idmap_get_sid_from_id: ads_first_entry: could not retrieve search result\n"));
+		goto done;
+	}
+
+	if (!ads_pull_sid(ads, msg, "objectSid", sid)) {
+		DEBUG(1, ("ad_idmap_get_sid_from_id: ads_pull_sid: could not retrieve SID from entry\n"));
+		goto done;
+	}
+
+	status = NT_STATUS_OK;
+	DEBUG(1, ("ad_idmap_get_sid_from_id mapped POSIX %s %d to SID [%s]\n",
+		(id_type == ID_GROUPID) ? "GID" : "UID", (int)unid.uid,
+		sid_to_string(sid_string, sid)));
+
+done:
+	if (res != NULL) {
+		ads_msgfree(ads, res);
+	}
+
+	return status;
+}
+
+static NTSTATUS ad_idmap_get_id_from_sid(unid_t *unid, int *id_type, const DOM_SID *sid)
+{
+	ADS_STATUS rc;
+	NTSTATUS status = NT_STATUS_NONE_MAPPED;
+	const char *attrs[] = { "sAMAccountType", ATTR_UIDNUMBER, ATTR_GIDNUMBER, NULL };
+	void *res = NULL;
+	void *msg = NULL;
+	char *expr = NULL;
+	uint32 atype, uid;
+	char *sidstr;
+	fstring sid_string;
+	int count;
+	ADS_STRUCT *ads;
+
+	if (unid == NULL) {
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	ads = ad_idmap_cached_connection();
+	if (ads == NULL) {
+		DEBUG(1, ("ad_idmap_get_id_from_sid ADS uninitialized\n"));
+		return NT_STATUS_NOT_SUPPORTED;
+	}
+
+	sidstr = sid_binstring(sid);
+	if (asprintf(&expr, "(objectSid=%s)", sidstr) == -1) {
+		free(sidstr);
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	rc = ads_search_retry(ads, &res, expr, attrs);
+	free(sidstr);
+	free(expr);
+	if (!ADS_ERR_OK(rc)) {
+		DEBUG(1, ("ad_idmap_get_id_from_sid: ads_search: %s\n", ads_errstr(rc)));
+		goto done;
+	}
+
+	count = ads_count_replies(ads, res);
+	if (count == 0) {
+		DEBUG(1, ("ad_idmap_get_id_from_sid: ads_count_replies: no results\n"));
+		goto done;
+	} else if (count != 1) {
+		DEBUG(1, ("ad_idmap_get_id_from_sid: ads_count_replies: incorrect cardinality\n"));
+		goto done;
+	}
+
+	msg = ads_first_entry(ads, res);
+	if (msg == NULL) {
+		DEBUG(1, ("ad_idmap_get_id_from_sid: ads_first_entry: could not retrieve search result\n"));
+		goto done;
+	}
+
+	if (!ads_pull_uint32(ads, msg, "sAMAccountType", &atype)) {
+		DEBUG(1, ("ad_idmap_get_id_from_sid: ads_pull_uint32: could not read SAM account type\n"));
+		goto done;
+	}
+
+	switch (atype & 0xF0000000) {
+	case ATYPE_SECURITY_GLOBAL_GROUP:
+	case ATYPE_SECURITY_LOCAL_GROUP:
+		*id_type = ID_GROUPID;
+		break;
+	case ATYPE_NORMAL_ACCOUNT:
+	case ATYPE_WORKSTATION_TRUST:
+	case ATYPE_INTERDOMAIN_TRUST:
+		*id_type = ID_USERID;
+		break;
+	default:
+		DEBUG(1, ("ad_idmap_get_id_from_sid: unrecognized SAM account type %08x\n", atype));
+		goto done;
+		break;
+	}
+
+	if (!ads_pull_uint32(ads, msg, (*id_type == ID_GROUPID) ? attr_gidnumber : attr_uidnumber, &uid)) {
+		DEBUG(1, ("ad_idmap_get_id_from_sid: ads_pull_uint32: could not read attribute '%s'\n",
+			(*id_type == ID_GROUPID) ? attr_gidnumber : attr_uidnumber));
+		goto done;
+	}
+
+	unid->uid = (uid_t)uid;
+
+	status = NT_STATUS_OK;
+	DEBUG(1, ("ad_idmap_get_id_from_sid mapped SID [%s] to POSIX %s %d\n",
+		sid_to_string(sid_string, sid),
+		(*id_type == ID_GROUPID) ? "GID" : "UID", uid));
+
+done:
+	if (res != NULL) {
+		ads_msgfree(ads, res);
+	}
+
+	return status;
+
+}
+
+static NTSTATUS ad_idmap_set_mapping(const DOM_SID *sid, unid_t id, int id_type)
+{
+	/* Not supported, and probably won't be... */
+	/* (It's not particularly feasible with a single-master model.) */
+
+	return NT_STATUS_NOT_IMPLEMENTED;
+}
+
+static NTSTATUS ad_idmap_close(void)
+{
+	ADS_STRUCT *ads = ad_idmap_ads;
+
+	if (ads != NULL) {
+		/* we own this ADS_STRUCT so make sure it goes away */
+		ads->is_mine = True;
+		ads_destroy( &ads );
+		ad_idmap_ads = NULL;
+	}
+
+	SAFE_FREE(attr_uidnumber);
+	SAFE_FREE(attr_gidnumber);
+	
+	return NT_STATUS_OK;
+}
+
+/* New for beta3 */
+static NTSTATUS ad_idmap_allocate_rid(uint32 *rid, int rid_type)
+{
+	return NT_STATUS_NOT_IMPLEMENTED;
+}
+
+static NTSTATUS ad_idmap_allocate_id(unid_t *id, int id_type)
+{
+	return NT_STATUS_NOT_IMPLEMENTED;
+}
+
+static void ad_idmap_status(void)
+{
+	DEBUG(0, ("AD IDMAP Status not available\n"));
+}
+
+static struct idmap_methods ad_methods = {
+	ad_idmap_init,
+	ad_idmap_allocate_rid,
+	ad_idmap_allocate_id,
+	ad_idmap_get_sid_from_id,
+	ad_idmap_get_id_from_sid,
+	ad_idmap_set_mapping,
+	ad_idmap_close,
+	ad_idmap_status
+};
+
+
+/* support for new authentication subsystem */
+NTSTATUS init_module(void)
+{
+	return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION, "ad", &ad_methods);
+}
+
diff --git a/source/smbd/aio.c b/source/smbd/aio.c
new file mode 100644
index 00000000000..7910ee5a7aa
--- /dev/null
+++ b/source/smbd/aio.c
@@ -0,0 +1,748 @@
+/*
+   Unix SMB/Netbios implementation.
+   Version 3.0
+   async_io read handling using POSIX async io.
+   Copyright (C) Jeremy Allison 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"
+
+#if defined(WITH_AIO)
+
+/* The signal we'll use to signify aio done. */
+#ifndef RT_SIGNAL_AIO
+#define RT_SIGNAL_AIO (SIGRTMIN+3)
+#endif
+
+/****************************************************************************
+ The buffer we keep around whilst an aio request is in process.
+*****************************************************************************/
+
+struct aio_extra {
+	struct aio_extra *next, *prev;
+	SMB_STRUCT_AIOCB acb;
+	files_struct *fsp;
+	BOOL read_req;
+	uint16 mid;
+	char *inbuf;
+	char *outbuf;
+};
+
+static struct aio_extra *aio_list_head;
+
+/****************************************************************************
+ Create the extended aio struct we must keep around for the lifetime
+ of the aio_read call.
+*****************************************************************************/
+
+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);
+
+	if (!aio_ex) {
+		return NULL;
+	}
+	ZERO_STRUCTP(aio_ex);
+	/* The output buffer stored in the aio_ex is the start of
+	   the smb return buffer. The buffer used in the acb
+	   is the start of the reply data portion of that buffer. */
+	aio_ex->outbuf = SMB_MALLOC_ARRAY(char, buflen);
+	if (!aio_ex->outbuf) {
+		SAFE_FREE(aio_ex);
+		return NULL;
+	}
+	DLIST_ADD(aio_list_head, aio_ex);
+	aio_ex->fsp = fsp;
+	aio_ex->read_req = True;
+	aio_ex->mid = mid;
+	return aio_ex;
+}
+
+/****************************************************************************
+ Create the extended aio struct we must keep around for the lifetime
+ of the aio_write call.
+*****************************************************************************/
+
+static struct aio_extra *create_aio_ex_write(files_struct *fsp, size_t outbuflen, uint16 mid)
+{
+	struct aio_extra *aio_ex = SMB_MALLOC_P(struct aio_extra);
+
+	if (!aio_ex) {
+		return NULL;
+	}
+	ZERO_STRUCTP(aio_ex);
+
+	/* We need space for an output reply of outbuflen bytes. */
+	aio_ex->outbuf = SMB_MALLOC_ARRAY(char, outbuflen);
+	if (!aio_ex->outbuf) {
+		SAFE_FREE(aio_ex);
+		return NULL;
+	}
+	/* Steal the input buffer containing the write data from the main SMB call. */
+	/* We must re-allocate a new one here. */
+	if (NewInBuffer(&aio_ex->inbuf) == NULL) {
+		SAFE_FREE(aio_ex->outbuf);
+		SAFE_FREE(aio_ex);
+		return NULL;
+	}
+
+	/* aio_ex->inbuf now contains the stolen old InBuf containing the data to write. */
+
+	DLIST_ADD(aio_list_head, aio_ex);
+	aio_ex->fsp = fsp;
+	aio_ex->read_req = False;
+	aio_ex->mid = mid;
+	return aio_ex;
+}
+
+/****************************************************************************
+ Delete the extended aio struct.
+*****************************************************************************/
+
+static void delete_aio_ex(struct aio_extra *aio_ex)
+{
+	DLIST_REMOVE(aio_list_head, aio_ex);
+	/* Safe to do as we've removed ourselves from the in use list first. */
+	free_InBuffer(aio_ex->inbuf);
+
+	SAFE_FREE(aio_ex->outbuf);
+	SAFE_FREE(aio_ex);
+}
+
+/****************************************************************************
+ Given the aiocb struct find the extended aio struct containing it.
+*****************************************************************************/
+
+static struct aio_extra *find_aio_ex(uint16 mid)
+{
+	struct aio_extra *p;
+
+	for( p = aio_list_head; p; p = p->next) {
+		if (mid == p->mid) {
+			return p;
+		}
+	}
+	return NULL;
+}
+
+/****************************************************************************
+ We can have these many aio buffers in flight.
+*****************************************************************************/
+
+#define AIO_PENDING_SIZE 10
+static sig_atomic_t signals_received;
+static int outstanding_aio_calls;
+static uint16 aio_pending_array[AIO_PENDING_SIZE];
+
+/****************************************************************************
+ Signal handler when an aio request completes.
+*****************************************************************************/
+
+static void signal_handler(int sig, siginfo_t *info, void *unused)
+{
+	if (signals_received < AIO_PENDING_SIZE - 1) {
+		aio_pending_array[signals_received] = *(uint16 *)(info->si_value.sival_ptr);
+		signals_received++;
+	} /* Else signal is lost. */
+	sys_select_signal(RT_SIGNAL_AIO);
+}
+
+/****************************************************************************
+ Is there a signal waiting ?
+*****************************************************************************/
+
+BOOL aio_finished(void)
+{
+	return (signals_received != 0);
+}
+
+/****************************************************************************
+ Initialize the signal handler for aio read/write.
+*****************************************************************************/
+
+void initialize_async_io_handler(void)
+{
+	struct sigaction act;
+
+	ZERO_STRUCT(act);
+	act.sa_sigaction = signal_handler;
+	act.sa_flags = SA_SIGINFO;
+	sigemptyset( &act.sa_mask );
+	if (sigaction(RT_SIGNAL_AIO, &act, NULL) != 0) {
+                DEBUG(0,("Failed to setup RT_SIGNAL_AIO handler\n"));
+        }
+
+	/* the signal can start off blocked due to a bug in bash */
+	BlockSignals(False, RT_SIGNAL_AIO);
+}
+
+/****************************************************************************
+ Set up an aio request from a SMBreadX call.
+*****************************************************************************/
+
+BOOL schedule_aio_read_and_X(connection_struct *conn,
+			     char *inbuf, char *outbuf,
+			     int length, int len_outbuf,
+			     files_struct *fsp, SMB_OFF_T startpos,
+			     size_t smb_maxcnt)
+{
+	struct aio_extra *aio_ex;
+	SMB_STRUCT_AIOCB *a;
+	size_t bufsize;
+	size_t min_aio_read_size = lp_aio_read_size(SNUM(conn));
+
+	if (!min_aio_read_size || (smb_maxcnt < min_aio_read_size)) {
+		/* Too small a read for aio request. */
+		DEBUG(10,("schedule_aio_read_and_X: read size (%u) too small "
+			  "for minimum aio_read of %u\n",
+			  (unsigned int)smb_maxcnt,
+			  (unsigned int)min_aio_read_size ));
+		return False;
+	}
+
+	/* Only do this on non-chained and non-chaining reads not using the write cache. */
+        if (chain_size !=0 || (CVAL(inbuf,smb_vwv0) != 0xFF) || (lp_write_cache_size(SNUM(conn)) != 0) ) {
+		return False;
+	}
+
+	if (outstanding_aio_calls >= AIO_PENDING_SIZE) {
+		DEBUG(10,("schedule_aio_read_and_X: Already have %d aio activities outstanding.\n",
+			  outstanding_aio_calls ));
+		return False;
+	}
+
+	/* The following is safe from integer wrap as we've already
+	   checked smb_maxcnt is 128k or less. */
+	bufsize = PTR_DIFF(smb_buf(outbuf),outbuf) + smb_maxcnt;
+
+	if ((aio_ex = create_aio_ex_read(fsp, bufsize, SVAL(inbuf,smb_mid))) == NULL) {
+		DEBUG(10,("schedule_aio_read_and_X: malloc fail.\n"));
+		return False;
+	}
+
+	/* Copy the SMB header already setup in outbuf. */
+	memcpy(aio_ex->outbuf, outbuf, smb_buf(outbuf) - outbuf);
+	SCVAL(aio_ex->outbuf,smb_vwv0,0xFF); /* Never a chained reply. */
+
+	a = &aio_ex->acb;
+
+	/* Now set up the aio record for the read call. */
+	
+	a->aio_fildes = fsp->fd;
+	a->aio_buf = smb_buf(aio_ex->outbuf);
+	a->aio_nbytes = smb_maxcnt;
+	a->aio_offset = startpos;
+	a->aio_sigevent.sigev_notify = SIGEV_SIGNAL;
+	a->aio_sigevent.sigev_signo  = RT_SIGNAL_AIO;
+	a->aio_sigevent.sigev_value.sival_ptr = (void *)&aio_ex->mid;
+
+	if (SMB_VFS_AIO_READ(fsp,a) == -1) {
+		DEBUG(0,("schedule_aio_read_and_X: aio_read failed. Error %s\n",
+			strerror(errno) ));
+		delete_aio_ex(aio_ex);
+		return False;
+	}
+
+	DEBUG(10,("schedule_aio_read_and_X: scheduled aio_read for file %s, offset %.0f, len = %u (mid = %u)\n",
+		fsp->fsp_name, (double)startpos, (unsigned int)smb_maxcnt, (unsigned int)aio_ex->mid ));
+
+	srv_defer_sign_response(aio_ex->mid);
+	outstanding_aio_calls++;
+	return True;
+}
+
+/****************************************************************************
+ Set up an aio request from a SMBwriteX call.
+*****************************************************************************/
+
+BOOL schedule_aio_write_and_X(connection_struct *conn,
+				char *inbuf, char *outbuf,
+				int length, int len_outbuf,
+				files_struct *fsp, char *data,
+				SMB_OFF_T startpos,
+				size_t numtowrite)
+{
+	struct aio_extra *aio_ex;
+	SMB_STRUCT_AIOCB *a;
+	size_t outbufsize;
+	BOOL write_through = BITSETW(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)) {
+		/* Too small a write for aio request. */
+		DEBUG(10,("schedule_aio_write_and_X: write size (%u) too small "
+			  "for minimum aio_write of %u\n",
+			  (unsigned int)numtowrite,
+			  (unsigned int)min_aio_write_size ));
+		return False;
+	}
+
+	/* Only do this on non-chained and non-chaining reads not using the write cache. */
+        if (chain_size !=0 || (CVAL(inbuf,smb_vwv0) != 0xFF) || (lp_write_cache_size(SNUM(conn)) != 0) ) {
+		return False;
+	}
+
+	if (outstanding_aio_calls >= AIO_PENDING_SIZE) {
+		DEBUG(3,("schedule_aio_write_and_X: Already have %d aio activities outstanding.\n",
+			  outstanding_aio_calls ));
+		DEBUG(10,("schedule_aio_write_and_X: failed to schedule aio_write for file %s, offset %.0f, len = %u (mid = %u)\n",
+			fsp->fsp_name, (double)startpos, (unsigned int)numtowrite, (unsigned int)SVAL(inbuf,smb_mid) ));
+		return False;
+	}
+
+	outbufsize = smb_len(outbuf) + 4;
+	if ((aio_ex = create_aio_ex_write(fsp, outbufsize, SVAL(inbuf,smb_mid))) == NULL) {
+		DEBUG(0,("schedule_aio_write_and_X: malloc fail.\n"));
+		return False;
+	}
+
+	/* Paranioa.... */
+	SMB_ASSERT(aio_ex->inbuf == inbuf);
+
+	/* Copy the SMB header already setup in outbuf. */
+	memcpy(aio_ex->outbuf, outbuf, outbufsize);
+	SCVAL(aio_ex->outbuf,smb_vwv0,0xFF); /* Never a chained reply. */
+
+	a = &aio_ex->acb;
+
+	/* Now set up the aio record for the write call. */
+	
+	a->aio_fildes = fsp->fd;
+	a->aio_buf = data; /* As we've stolen inbuf this points within inbuf. */
+	a->aio_nbytes = numtowrite;
+	a->aio_offset = startpos;
+	a->aio_sigevent.sigev_notify = SIGEV_SIGNAL;
+	a->aio_sigevent.sigev_signo  = RT_SIGNAL_AIO;
+	a->aio_sigevent.sigev_value.sival_ptr = (void *)&aio_ex->mid;
+
+	if (SMB_VFS_AIO_WRITE(fsp,a) == -1) {
+		DEBUG(3,("schedule_aio_wrote_and_X: aio_write failed. Error %s\n",
+			strerror(errno) ));
+		/* Replace global InBuf as we're going to do a normal write. */
+		set_InBuffer(aio_ex->inbuf);
+		aio_ex->inbuf = NULL;
+		delete_aio_ex(aio_ex);
+		return False;
+	}
+
+	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("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 %s, \
+offset %.0f, len = %u (mid = %u) outstanding_aio_calls = %d\n",
+		fsp->fsp_name, (double)startpos, (unsigned int)numtowrite, (unsigned int)aio_ex->mid, outstanding_aio_calls ));
+
+	return True;
+}
+
+
+/****************************************************************************
+ Complete the read and return the data or error back to the client.
+ Returns errno or zero if all ok.
+*****************************************************************************/
+
+static int handle_aio_read_complete(struct aio_extra *aio_ex)
+{
+	int ret = 0;
+	int outsize;
+	char *outbuf = aio_ex->outbuf;
+	char *data = smb_buf(outbuf);
+	ssize_t nread = SMB_VFS_AIO_RETURN(aio_ex->fsp,&aio_ex->acb);
+
+	if (nread < 0) {
+		/* We're relying here on the fact that if the fd is
+		   closed then the aio will complete and aio_return
+		   will return an error. Hopefully this is
+		   true.... JRA. */
+
+		/* If errno is ECANCELED then don't return anything to the client. */
+		if (errno == ECANCELED) {
+			srv_cancel_sign_response(aio_ex->mid);
+			return 0;
+		}
+
+		DEBUG( 3,( "handle_aio_read_complete: file %s nread == -1. Error = %s\n",
+			aio_ex->fsp->fsp_name, strerror(errno) ));
+
+		outsize = (UNIXERROR(ERRDOS,ERRnoaccess));
+		ret = errno;
+	} else {
+		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));
+		SSVAL(outbuf,smb_vwv7,((nread >> 16) & 1));
+		SSVAL(smb_buf(outbuf),-2,nread);
+
+		DEBUG( 3, ( "handle_aio_read_complete file %s max=%d nread=%d\n",
+			aio_ex->fsp->fsp_name,
+			aio_ex->acb.aio_nbytes, (int)nread ) );
+
+	}
+	smb_setlen(outbuf,outsize - 4);
+	show_msg(outbuf);
+	if (!send_smb(smbd_server_fd(),outbuf)) {
+		exit_server("handle_aio_read_complete: send_smb failed.");
+	}
+
+	DEBUG(10,("handle_aio_read_complete: scheduled aio_read completed for file %s, offset %.0f, len = %u\n",
+		aio_ex->fsp->fsp_name, (double)aio_ex->acb.aio_offset, (unsigned int)nread ));
+
+	return ret;
+}
+
+/****************************************************************************
+ Complete the write and return the data or error back to the client.
+ Returns errno or zero if all ok.
+*****************************************************************************/
+
+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;
+	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. */
+
+	if(nwritten == -1) {
+		DEBUG( 3,( "handle_aio_write: file %s wanted %u bytes. nwritten == %d. Error = %s\n",
+			fsp->fsp_name, (unsigned int)numtowrite,
+			(int)nwritten, strerror(errno) ));
+
+		/* If errno is ECANCELED then don't return anything to the client. */
+		if (errno == ECANCELED) {
+			srv_cancel_sign_response(aio_ex->mid);
+			return 0;
+		}
+
+		UNIXERROR(ERRHRD,ERRdiskfull);
+		ret = errno;
+        } else {
+		BOOL write_through = BITSETW(aio_ex->inbuf+smb_vwv7,0);
+
+        	SSVAL(outbuf,smb_vwv2,nwritten);
+		SSVAL(outbuf,smb_vwv4,(nwritten>>16)&1);
+		if (nwritten < (ssize_t)numtowrite) {
+			SCVAL(outbuf,smb_rcls,ERRHRD);
+			SSVAL(outbuf,smb_err,ERRdiskfull);
+		}
+                                                                                                                                  
+		DEBUG(3,("handle_aio_write: fnum=%d num=%d wrote=%d\n", fsp->fnum, (int)numtowrite, (int)nwritten));
+		if (lp_syncalways(SNUM(fsp->conn)) || write_through) {
+			sync_file(fsp->conn,fsp);
+		}
+	}
+
+	show_msg(outbuf);
+	if (!send_smb(smbd_server_fd(),outbuf)) {
+		exit_server("handle_aio_write: send_smb failed.");
+	}
+
+	DEBUG(10,("handle_aio_write_complete: scheduled aio_write completed for file %s, offset %.0f, requested %u, written = %u\n",
+		fsp->fsp_name, (double)aio_ex->acb.aio_offset, (unsigned int)numtowrite, (unsigned int)nwritten ));
+
+	return ret;
+}
+
+/****************************************************************************
+ Handle any aio completion. Returns True if finished (and sets *perr if err was non-zero),
+ False if not.
+*****************************************************************************/
+
+static BOOL handle_aio_completed(struct aio_extra *aio_ex, int *perr)
+{
+	int err;
+
+	/* Ensure the operation has really completed. */
+	if (SMB_VFS_AIO_ERROR(aio_ex->fsp, &aio_ex->acb) == EINPROGRESS) {
+		DEBUG(10,( "handle_aio_completed: operation mid %u still in process for file %s\n",
+			aio_ex->mid, aio_ex->fsp->fsp_name ));
+		return False;
+	}
+
+	if (aio_ex->read_req) {
+		err = handle_aio_read_complete(aio_ex);
+	} else {
+		err = handle_aio_write_complete(aio_ex);
+	}
+
+	if (err) {
+		*perr = err; /* Only save non-zero errors. */
+	}
+
+	return True;
+}
+
+/****************************************************************************
+ Handle any aio completion inline.
+ Returns non-zero errno if fail or zero if all ok.
+*****************************************************************************/
+
+int process_aio_queue(void)
+{
+	int i;
+	int ret = 0;
+
+	BlockSignals(True, RT_SIGNAL_AIO);
+
+	DEBUG(10,("process_aio_queue: signals_received = %d\n", (int)signals_received));
+	DEBUG(10,("process_aio_queue: outstanding_aio_calls = %d\n", outstanding_aio_calls));
+
+	if (!signals_received) {
+		BlockSignals(False, RT_SIGNAL_AIO);
+		return 0;
+	}
+
+	/* Drain all the complete aio_reads. */
+	for (i = 0; i < signals_received; i++) {
+		uint16 mid = aio_pending_array[i];
+		files_struct *fsp = NULL;
+		struct aio_extra *aio_ex = find_aio_ex(mid);
+
+		if (!aio_ex) {
+			DEBUG(3,("process_aio_queue: Can't find record to match mid %u.\n",
+				(unsigned int)mid));
+			srv_cancel_sign_response(mid);
+			continue;
+		}
+
+		fsp = aio_ex->fsp;
+		if (fsp == NULL) {
+			/* file was closed whilst I/O was outstanding. Just ignore. */
+			DEBUG( 3,( "process_aio_queue: file closed whilst aio outstanding.\n"));
+			srv_cancel_sign_response(mid);
+			continue;
+		}
+
+		if (!handle_aio_completed(aio_ex, &ret)) {
+			continue;
+		}
+
+		delete_aio_ex(aio_ex);
+	}
+
+	outstanding_aio_calls -= signals_received;
+	signals_received = 0;
+	BlockSignals(False, RT_SIGNAL_AIO);
+	return ret;
+}
+
+/****************************************************************************
+ 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
+
+BOOL 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;
+	int ret = 0;
+
+	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 ret;
+		}
+
+		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 False;
+		}
+
+		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 ret ? ret : EIO;
+		}
+
+		/* One or more events might have completed - process them if so. */
+		for( i = 0; i < aio_completion_count; i++) {
+			uint16 mid = *(uint16 *)aiocb_list[i]->aio_sigevent.sigev_value.sival_ptr;
+
+			aio_ex = find_aio_ex(mid);
+
+			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 ret ? ret : EIO;
+}
+
+/****************************************************************************
+ Cancel any outstanding aio requests. The client doesn't care about the reply.
+*****************************************************************************/
+
+void cancel_aio_by_fsp(files_struct *fsp)
+{
+	struct aio_extra *aio_ex;
+
+	for( aio_ex = aio_list_head; aio_ex; aio_ex = aio_ex->next) {
+		if (aio_ex->fsp == fsp) {
+			/* Don't delete the aio_extra record as we may have completed
+			   and don't yet know it. Just do the aio_cancel call and return. */
+			SMB_VFS_AIO_CANCEL(fsp,fsp->fd, &aio_ex->acb);
+			aio_ex->fsp = NULL; /* fsp will be closed when we return. */
+		}
+	}
+}
+
+/****************************************************************************
+ Check if a buffer was stolen for aio use.
+*****************************************************************************/
+
+BOOL aio_inbuffer_in_use(char *inbuf)
+{
+	struct aio_extra *aio_ex;
+
+	for( aio_ex = aio_list_head; aio_ex; aio_ex = aio_ex->next) {
+		if (aio_ex->inbuf == inbuf) {
+			return True;
+		}
+	}
+	return False;
+}
+#else
+BOOL aio_finished(void)
+{
+	return False;
+}
+
+void initialize_async_io_handler(void)
+{
+}
+
+int process_aio_queue(void)
+{
+	return False;
+}
+
+BOOL schedule_aio_read_and_X(connection_struct *conn,
+			     char *inbuf, char *outbuf,
+			     int length, int len_outbuf,
+			     files_struct *fsp, SMB_OFF_T startpos,
+			     size_t smb_maxcnt)
+{
+	return False;
+}
+
+BOOL schedule_aio_write_and_X(connection_struct *conn,
+                                char *inbuf, char *outbuf,
+                                int length, int len_outbuf,
+                                files_struct *fsp, char *data,
+                                SMB_OFF_T startpos,
+                                size_t numtowrite)
+{
+	return False;
+}
+
+void cancel_aio_by_fsp(files_struct *fsp)
+{
+}
+
+BOOL wait_for_aio_completion(files_struct *fsp)
+{
+	return True;
+}
+
+BOOL aio_inbuffer_in_use(char *ptr)
+{
+	return False;
+}
+#endif