lib/util: consolidate module loading into common code
[samba.git] / source3 / lib / util.c
index d194c3ae4b1ca0a57f1c11eaa7308fbfdc852dd2..f29568fca02ca3f3e787f3e28ea32936f7048773 100644 (file)
 */
 
 #include "includes.h"
-
-extern char *global_clobber_region_function;
-extern unsigned int global_clobber_region_line;
+#include "system/passwd.h"
+#include "system/filesys.h"
+#include "util_tdb.h"
+#include "ctdbd_conn.h"
+#include "../lib/util/util_pw.h"
+#include "messages.h"
+#include <ccan/hash/hash.h>
+#include "libcli/security/security.h"
+
+#ifdef HAVE_SYS_PRCTL_H
+#include <sys/prctl.h>
+#endif
 
 /* Max allowable allococation - 256mb - 0x10000000 */
 #define MAX_ALLOC_SIZE (1024*1024*256)
@@ -55,473 +64,41 @@ extern unsigned int global_clobber_region_line;
 #endif /* WITH_NISPLUS_HOME */
 #endif /* HAVE_NETGROUP && WITH_AUTOMOUNT */
 
-static enum remote_arch_types ra_type = RA_UNKNOWN;
-
-/***********************************************************************
- Definitions for all names.
-***********************************************************************/
-
-static char *smb_myname;
-static char *smb_myworkgroup;
-static char *smb_scope;
-static int smb_num_netbios_names;
-static char **smb_my_netbios_names;
-
-/***********************************************************************
- Allocate and set myname. Ensure upper case.
-***********************************************************************/
-
-bool set_global_myname(const char *myname)
-{
-       SAFE_FREE(smb_myname);
-       smb_myname = SMB_STRDUP(myname);
-       if (!smb_myname)
-               return False;
-       strupper_m(smb_myname);
-       return True;
-}
-
-const char *global_myname(void)
-{
-       return smb_myname;
-}
+static enum protocol_types Protocol = PROTOCOL_COREPLUS;
 
-/***********************************************************************
- Allocate and set myworkgroup. Ensure upper case.
-***********************************************************************/
-
-bool set_global_myworkgroup(const char *myworkgroup)
+enum protocol_types get_Protocol(void)
 {
-       SAFE_FREE(smb_myworkgroup);
-       smb_myworkgroup = SMB_STRDUP(myworkgroup);
-       if (!smb_myworkgroup)
-               return False;
-       strupper_m(smb_myworkgroup);
-       return True;
+       return Protocol;
 }
 
-const char *lp_workgroup(void)
+void set_Protocol(enum protocol_types  p)
 {
-       return smb_myworkgroup;
+       Protocol = p;
 }
 
-/***********************************************************************
- Allocate and set scope. Ensure upper case.
-***********************************************************************/
-
-bool set_global_scope(const char *scope)
-{
-       SAFE_FREE(smb_scope);
-       smb_scope = SMB_STRDUP(scope);
-       if (!smb_scope)
-               return False;
-       strupper_m(smb_scope);
-       return True;
-}
-
-/*********************************************************************
- Ensure scope is never null string.
-*********************************************************************/
-
-const char *global_scope(void)
-{
-       if (!smb_scope)
-               set_global_scope("");
-       return smb_scope;
-}
-
-static void free_netbios_names_array(void)
-{
-       int i;
-
-       for (i = 0; i < smb_num_netbios_names; i++)
-               SAFE_FREE(smb_my_netbios_names[i]);
-
-       SAFE_FREE(smb_my_netbios_names);
-       smb_num_netbios_names = 0;
-}
-
-static bool allocate_my_netbios_names_array(size_t number)
-{
-       free_netbios_names_array();
-
-       smb_num_netbios_names = number + 1;
-       smb_my_netbios_names = SMB_MALLOC_ARRAY( char *, smb_num_netbios_names );
-
-       if (!smb_my_netbios_names)
-               return False;
-
-       memset(smb_my_netbios_names, '\0', sizeof(char *) * smb_num_netbios_names);
-       return True;
-}
-
-static bool set_my_netbios_names(const char *name, int i)
-{
-       SAFE_FREE(smb_my_netbios_names[i]);
-
-       smb_my_netbios_names[i] = SMB_STRDUP(name);
-       if (!smb_my_netbios_names[i])
-               return False;
-       strupper_m(smb_my_netbios_names[i]);
-       return True;
-}
-
-/***********************************************************************
- Free memory allocated to global objects
-***********************************************************************/
-
-void gfree_names(void)
-{
-       SAFE_FREE( smb_myname );
-       SAFE_FREE( smb_myworkgroup );
-       SAFE_FREE( smb_scope );
-       free_netbios_names_array();
-       free_local_machine_name();
-}
+static enum remote_arch_types ra_type = RA_UNKNOWN;
 
 void gfree_all( void )
 {
        gfree_names();
        gfree_loadparm();
-       gfree_case_tables();
        gfree_charcnv();
        gfree_interfaces();
        gfree_debugsyms();
 }
 
-const char *my_netbios_names(int i)
-{
-       return smb_my_netbios_names[i];
-}
-
-bool set_netbios_aliases(const char **str_array)
-{
-       size_t namecount;
-
-       /* Work out the max number of netbios aliases that we have */
-       for( namecount=0; str_array && (str_array[namecount] != NULL); namecount++ )
-               ;
-
-       if ( global_myname() && *global_myname())
-               namecount++;
-
-       /* Allocate space for the netbios aliases */
-       if (!allocate_my_netbios_names_array(namecount))
-               return False;
-
-       /* Use the global_myname string first */
-       namecount=0;
-       if ( global_myname() && *global_myname()) {
-               set_my_netbios_names( global_myname(), namecount );
-               namecount++;
-       }
-
-       if (str_array) {
-               size_t i;
-               for ( i = 0; str_array[i] != NULL; i++) {
-                       size_t n;
-                       bool duplicate = False;
-
-                       /* Look for duplicates */
-                       for( n=0; n<namecount; n++ ) {
-                               if( strequal( str_array[i], my_netbios_names(n) ) ) {
-                                       duplicate = True;
-                                       break;
-                               }
-                       }
-                       if (!duplicate) {
-                               if (!set_my_netbios_names(str_array[i], namecount))
-                                       return False;
-                               namecount++;
-                       }
-               }
-       }
-       return True;
-}
-
-/****************************************************************************
-  Common name initialization code.
-****************************************************************************/
-
-bool init_names(void)
-{
-       int n;
-
-       if (global_myname() == NULL || *global_myname() == '\0') {
-               if (!set_global_myname(myhostname())) {
-                       DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
-                       return False;
-               }
-       }
-
-       if (!set_netbios_aliases(lp_netbios_aliases())) {
-               DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
-               return False;
-       }
-
-       set_local_machine_name(global_myname(),false);
-
-       DEBUG( 5, ("Netbios name list:-\n") );
-       for( n=0; my_netbios_names(n); n++ ) {
-               DEBUGADD( 5, ("my_netbios_names[%d]=\"%s\"\n",
-                                       n, my_netbios_names(n) ) );
-       }
-
-       return( True );
-}
-
-/**************************************************************************n
-  Code to cope with username/password auth options from the commandline.
-  Used mainly in client tools.
-****************************************************************************/
-
-struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx)
-{
-       struct user_auth_info *result;
-
-       result = TALLOC_ZERO_P(mem_ctx, struct user_auth_info);
-       if (result == NULL) {
-               return NULL;
-       }
-
-       result->signing_state = Undefined;
-       return result;
-}
-
-const char *get_cmdline_auth_info_username(const struct user_auth_info *auth_info)
-{
-       if (!auth_info->username) {
-               return "";
-       }
-       return auth_info->username;
-}
-
-void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
-                                   const char *username)
-{
-       TALLOC_FREE(auth_info->username);
-       auth_info->username = talloc_strdup(auth_info, username);
-       if (!auth_info->username) {
-               exit(ENOMEM);
-       }
-}
-
-const char *get_cmdline_auth_info_domain(const struct user_auth_info *auth_info)
-{
-       if (!auth_info->domain) {
-               return "";
-       }
-       return auth_info->domain;
-}
-
-void set_cmdline_auth_info_domain(struct user_auth_info *auth_info,
-                                 const char *domain)
-{
-       TALLOC_FREE(auth_info->domain);
-       auth_info->domain = talloc_strdup(auth_info, domain);
-       if (!auth_info->domain) {
-               exit(ENOMEM);
-       }
-}
-
-const char *get_cmdline_auth_info_password(const struct user_auth_info *auth_info)
-{
-       if (!auth_info->password) {
-               return "";
-       }
-       return auth_info->password;
-}
-
-void set_cmdline_auth_info_password(struct user_auth_info *auth_info,
-                                   const char *password)
-{
-       TALLOC_FREE(auth_info->password);
-       if (password == NULL) {
-               password = "";
-       }
-       auth_info->password = talloc_strdup(auth_info, password);
-       if (!auth_info->password) {
-               exit(ENOMEM);
-       }
-       auth_info->got_pass = true;
-}
-
-bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
-                                        const char *arg)
-{
-       auth_info->signing_state = -1;
-       if (strequal(arg, "off") || strequal(arg, "no") ||
-                       strequal(arg, "false")) {
-               auth_info->signing_state = false;
-       } else if (strequal(arg, "on") || strequal(arg, "yes") ||
-                       strequal(arg, "true") || strequal(arg, "auto")) {
-               auth_info->signing_state = true;
-       } else if (strequal(arg, "force") || strequal(arg, "required") ||
-                       strequal(arg, "forced")) {
-               auth_info->signing_state = Required;
-       } else {
-               return false;
-       }
-       return true;
-}
-
-int get_cmdline_auth_info_signing_state(const struct user_auth_info *auth_info)
-{
-       return auth_info->signing_state;
-}
-
-void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
-                                       bool b)
-{
-        auth_info->use_kerberos = b;
-}
-
-bool get_cmdline_auth_info_use_kerberos(const struct user_auth_info *auth_info)
-{
-       return auth_info->use_kerberos;
-}
-
-void set_cmdline_auth_info_fallback_after_kerberos(struct user_auth_info *auth_info,
-                                       bool b)
-{
-       auth_info->fallback_after_kerberos = b;
-}
-
-bool get_cmdline_auth_info_fallback_after_kerberos(const struct user_auth_info *auth_info)
-{
-       return auth_info->fallback_after_kerberos;
-}
-
-/* This should only be used by lib/popt_common.c JRA */
-void set_cmdline_auth_info_use_krb5_ticket(struct user_auth_info *auth_info)
-{
-       auth_info->use_kerberos = true;
-       auth_info->got_pass = true;
-}
-
-/* This should only be used by lib/popt_common.c JRA */
-void set_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info)
-{
-       auth_info->smb_encrypt = true;
-}
-
-void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
-{
-       auth_info->use_machine_account = true;
-}
-
-bool get_cmdline_auth_info_got_pass(const struct user_auth_info *auth_info)
-{
-       return auth_info->got_pass;
-}
-
-bool get_cmdline_auth_info_smb_encrypt(const struct user_auth_info *auth_info)
-{
-       return auth_info->smb_encrypt;
-}
-
-bool get_cmdline_auth_info_use_machine_account(const struct user_auth_info *auth_info)
-{
-       return auth_info->use_machine_account;
-}
-
-struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx,
-                                                 const struct user_auth_info *src)
-{
-       struct user_auth_info *result;
-
-       result = user_auth_info_init(mem_ctx);
-       if (result == NULL) {
-               return NULL;
-       }
-
-       *result = *src;
-
-       result->username = talloc_strdup(
-               result, get_cmdline_auth_info_username(src));
-       result->password = talloc_strdup(
-               result, get_cmdline_auth_info_password(src));
-       if ((result->username == NULL) || (result->password == NULL)) {
-               TALLOC_FREE(result);
-               return NULL;
-       }
-
-       return result;
-}
-
-bool set_cmdline_auth_info_machine_account_creds(struct user_auth_info *auth_info)
-{
-       char *pass = NULL;
-       char *account = NULL;
-
-       if (!get_cmdline_auth_info_use_machine_account(auth_info)) {
-               return false;
-       }
-
-       if (!secrets_init()) {
-               d_printf("ERROR: Unable to open secrets database\n");
-               return false;
-       }
-
-       if (asprintf(&account, "%s$@%s", global_myname(), lp_realm()) < 0) {
-               return false;
-       }
-
-       pass = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
-       if (!pass) {
-               d_printf("ERROR: Unable to fetch machine password for "
-                       "%s in domain %s\n",
-                       account, lp_workgroup());
-               SAFE_FREE(account);
-               return false;
-       }
-
-       set_cmdline_auth_info_username(auth_info, account);
-       set_cmdline_auth_info_password(auth_info, pass);
-
-       SAFE_FREE(account);
-       SAFE_FREE(pass);
-
-       return true;
-}
-
-/****************************************************************************
- Ensure we have a password if one not given.
-****************************************************************************/
-
-void set_cmdline_auth_info_getpass(struct user_auth_info *auth_info)
-{
-       char *label = NULL;
-       char *pass;
-       TALLOC_CTX *frame;
-
-       if (get_cmdline_auth_info_got_pass(auth_info) ||
-                       get_cmdline_auth_info_use_kerberos(auth_info)) {
-               /* Already got one... */
-               return;
-       }
-
-       frame = talloc_stackframe();
-       label = talloc_asprintf(frame, "Enter %s's password: ",
-                       get_cmdline_auth_info_username(auth_info));
-       pass = getpass(label);
-       if (pass) {
-               set_cmdline_auth_info_password(auth_info, pass);
-       }
-       TALLOC_FREE(frame);
-}
-
 /*******************************************************************
  Check if a file exists - call vfs_file_exist for samba files.
 ********************************************************************/
 
-bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
+bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf,
+                    bool fake_dir_create_times)
 {
        SMB_STRUCT_STAT st;
        if (!sbuf)
                sbuf = &st;
 
-       if (sys_stat(fname,sbuf) != 0) 
+       if (sys_stat(fname, sbuf, fake_dir_create_times) != 0)
                return(False);
 
        return((S_ISREG(sbuf->st_ex_mode)) || (S_ISFIFO(sbuf->st_ex_mode)));
@@ -534,33 +111,12 @@ bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
 bool socket_exist(const char *fname)
 {
        SMB_STRUCT_STAT st;
-       if (sys_stat(fname,&st) != 0) 
+       if (sys_stat(fname, &st, false) != 0)
                return(False);
 
        return S_ISSOCK(st.st_ex_mode);
 }
 
-/*******************************************************************
- Check if a directory exists.
-********************************************************************/
-
-bool directory_exist_stat(char *dname,SMB_STRUCT_STAT *st)
-{
-       SMB_STRUCT_STAT st2;
-       bool ret;
-
-       if (!st)
-               st = &st2;
-
-       if (sys_stat(dname,st) != 0) 
-               return(False);
-
-       ret = S_ISDIR(st->st_ex_mode);
-       if(!ret)
-               errno = ENOTDIR;
-       return ret;
-}
-
 /*******************************************************************
  Returns the size in bytes of the named given the stat struct.
 ********************************************************************/
@@ -578,36 +134,16 @@ SMB_OFF_T get_file_size(char *file_name)
 {
        SMB_STRUCT_STAT buf;
        buf.st_ex_size = 0;
-       if(sys_stat(file_name,&buf) != 0)
+       if (sys_stat(file_name, &buf, false) != 0)
                return (SMB_OFF_T)-1;
        return get_file_size_stat(&buf);
 }
 
-/*******************************************************************
- Return a string representing an attribute for a file.
-********************************************************************/
-
-char *attrib_string(uint16 mode)
-{
-       fstring attrstr;
-
-       attrstr[0] = 0;
-
-       if (mode & aVOLID) fstrcat(attrstr,"V");
-       if (mode & aDIR) fstrcat(attrstr,"D");
-       if (mode & aARCH) fstrcat(attrstr,"A");
-       if (mode & aHIDDEN) fstrcat(attrstr,"H");
-       if (mode & aSYSTEM) fstrcat(attrstr,"S");
-       if (mode & aRONLY) fstrcat(attrstr,"R");          
-
-       return talloc_strdup(talloc_tos(), attrstr);
-}
-
 /*******************************************************************
  Show a smb message structure.
 ********************************************************************/
 
-void show_msg(char *buf)
+void show_msg(const char *buf)
 {
        int i;
        int bcc=0;
@@ -644,7 +180,7 @@ void show_msg(char *buf)
        if (DEBUGLEVEL < 50)
                bcc = MIN(bcc, 512);
 
-       dump_data(10, (uint8 *)smb_buf(buf), bcc);      
+       dump_data(10, (const uint8 *)smb_buf_const(buf), bcc);
 }
 
 /*******************************************************************
@@ -696,7 +232,7 @@ ssize_t message_push_blob(uint8 **outbuf, DATA_BLOB blob)
        size_t newlen = smb_len(*outbuf) + 4 + blob.length;
        uint8 *tmp;
 
-       if (!(tmp = TALLOC_REALLOC_ARRAY(NULL, *outbuf, uint8, newlen))) {
+       if (!(tmp = talloc_realloc(NULL, *outbuf, uint8, newlen))) {
                DEBUG(0, ("talloc failed\n"));
                return -1;
        }
@@ -860,59 +396,11 @@ ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos
 #endif
 }
 
-/*******************************************************************
- Sleep for a specified number of milliseconds.
-********************************************************************/
-
-void smb_msleep(unsigned int t)
-{
-#if defined(HAVE_NANOSLEEP)
-       struct timespec tval;
-       int ret;
-
-       tval.tv_sec = t/1000;
-       tval.tv_nsec = 1000000*(t%1000);
-
-       do {
-               errno = 0;
-               ret = nanosleep(&tval, &tval);
-       } while (ret < 0 && errno == EINTR && (tval.tv_sec > 0 || tval.tv_nsec > 0));
-#else
-       unsigned int tdiff=0;
-       struct timeval tval,t1,t2;  
-       fd_set fds;
-
-       GetTimeOfDay(&t1);
-       t2 = t1;
-
-       while (tdiff < t) {
-               tval.tv_sec = (t-tdiff)/1000;
-               tval.tv_usec = 1000*((t-tdiff)%1000);
-
-               /* Never wait for more than 1 sec. */
-               if (tval.tv_sec > 1) {
-                       tval.tv_sec = 1; 
-                       tval.tv_usec = 0;
-               }
-
-               FD_ZERO(&fds);
-               errno = 0;
-               sys_select_intr(0,&fds,NULL,NULL,&tval);
-
-               GetTimeOfDay(&t2);
-               if (t2.tv_sec < t1.tv_sec) {
-                       /* Someone adjusted time... */
-                       t1 = t2;
-               }
-
-               tdiff = TvalDiff(&t1,&t2);
-       }
-#endif
-}
 
 NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
-                      struct event_context *ev_ctx,
-                      bool parent_longlived)
+                          struct event_context *ev_ctx,
+                          struct server_id id,
+                          bool parent_longlived)
 {
        NTSTATUS status = NT_STATUS_OK;
 
@@ -923,14 +411,14 @@ NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
        set_need_random_reseed();
 
        /* tdb needs special fork handling */
-       if (tdb_reopen_all(parent_longlived ? 1 : 0) == -1) {
+       if (tdb_reopen_all(parent_longlived ? 1 : 0) != 0) {
                DEBUG(0,("tdb_reopen_all failed.\n"));
                status = NT_STATUS_OPEN_FAILED;
                goto done;
        }
 
-       if (ev_ctx) {
-               event_context_reinit(ev_ctx);
+       if (ev_ctx && tevent_re_initialise(ev_ctx) != 0) {
+               smb_panic(__location__ ": Failed to re-initialise event context");
        }
 
        if (msg_ctx) {
@@ -938,7 +426,7 @@ NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
                 * For clustering, we need to re-init our ctdbd connection after the
                 * fork
                 */
-               status = messaging_reinit(msg_ctx);
+               status = messaging_reinit(msg_ctx, id);
                if (!NT_STATUS_IS_OK(status)) {
                        DEBUG(0,("messaging_reinit() failed: %s\n",
                                 nt_errstr(status)));
@@ -948,167 +436,6 @@ NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
        return status;
 }
 
-/****************************************************************************
- Put up a yes/no prompt.
-****************************************************************************/
-
-bool yesno(const char *p)
-{
-       char ans[20];
-       printf("%s",p);
-
-       if (!fgets(ans,sizeof(ans)-1,stdin))
-               return(False);
-
-       if (*ans == 'y' || *ans == 'Y')
-               return(True);
-
-       return(False);
-}
-
-#if defined(PARANOID_MALLOC_CHECKER)
-
-/****************************************************************************
- Internal malloc wrapper. Externally visible.
-****************************************************************************/
-
-void *malloc_(size_t size)
-{
-       if (size == 0) {
-               return NULL;
-       }
-#undef malloc
-       return malloc(size);
-#define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
-}
-
-/****************************************************************************
- Internal calloc wrapper. Not externally visible.
-****************************************************************************/
-
-static void *calloc_(size_t count, size_t size)
-{
-       if (size == 0 || count == 0) {
-               return NULL;
-       }
-#undef calloc
-       return calloc(count, size);
-#define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
-}
-
-/****************************************************************************
- Internal realloc wrapper. Not externally visible.
-****************************************************************************/
-
-static void *realloc_(void *ptr, size_t size)
-{
-#undef realloc
-       return realloc(ptr, size);
-#define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
-}
-
-#endif /* PARANOID_MALLOC_CHECKER */
-
-/****************************************************************************
- Type-safe memalign
-****************************************************************************/
-
-void *memalign_array(size_t el_size, size_t align, unsigned int count)
-{
-       if (count >= MAX_ALLOC_SIZE/el_size) {
-               return NULL;
-       }
-
-       return sys_memalign(align, el_size*count);
-}
-
-/****************************************************************************
- Type-safe calloc.
-****************************************************************************/
-
-void *calloc_array(size_t size, size_t nmemb)
-{
-       if (nmemb >= MAX_ALLOC_SIZE/size) {
-               return NULL;
-       }
-       if (size == 0 || nmemb == 0) {
-               return NULL;
-       }
-#if defined(PARANOID_MALLOC_CHECKER)
-       return calloc_(nmemb, size);
-#else
-       return calloc(nmemb, size);
-#endif
-}
-
-/****************************************************************************
- Expand a pointer to be a particular size.
- Note that this version of Realloc has an extra parameter that decides
- whether to free the passed in storage on allocation failure or if the
- new size is zero.
-
- This is designed for use in the typical idiom of :
-
- p = SMB_REALLOC(p, size)
- if (!p) {
-    return error;
- }
-
- and not to have to keep track of the old 'p' contents to free later, nor
- to worry if the size parameter was zero. In the case where NULL is returned
- we guarentee that p has been freed.
-
- If free later semantics are desired, then pass 'free_old_on_error' as False which
- guarentees that the old contents are not freed on error, even if size == 0. To use
- this idiom use :
-
- tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
- if (!tmp) {
-    SAFE_FREE(p);
-    return error;
- } else {
-    p = tmp;
- }
-
- Changes were instigated by Coverity error checking. JRA.
-****************************************************************************/
-
-void *Realloc(void *p, size_t size, bool free_old_on_error)
-{
-       void *ret=NULL;
-
-       if (size == 0) {
-               if (free_old_on_error) {
-                       SAFE_FREE(p);
-               }
-               DEBUG(2,("Realloc asked for 0 bytes\n"));
-               return NULL;
-       }
-
-#if defined(PARANOID_MALLOC_CHECKER)
-       if (!p) {
-               ret = (void *)malloc_(size);
-       } else {
-               ret = (void *)realloc_(p,size);
-       }
-#else
-       if (!p) {
-               ret = (void *)malloc(size);
-       } else {
-               ret = (void *)realloc(p,size);
-       }
-#endif
-
-       if (!ret) {
-               if (free_old_on_error && p) {
-                       SAFE_FREE(p);
-               }
-               DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size));
-       }
-
-       return(ret);
-}
-
 /****************************************************************************
  (Hopefully) efficient array append.
 ****************************************************************************/
@@ -1310,6 +637,9 @@ char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
        if ((nis_error = yp_match(nis_domain, nis_map, user_name,
                                        strlen(user_name), &nis_result,
                                        &nis_result_len)) == 0) {
+               if (nis_result_len > 0 && nis_result[nis_result_len] == '\n') {
+                       nis_result[nis_result_len] = '\0';
+               }
                value = talloc_strdup(ctx, nis_result);
                if (!value) {
                        return NULL;
@@ -1347,8 +677,8 @@ bool process_exists(const struct server_id pid)
        }
 
 #ifdef CLUSTER_SUPPORT
-       return ctdbd_process_exists(messaging_ctdbd_connection(), pid.vnn,
-                                   pid.pid);
+       return ctdbd_process_exists(messaging_ctdbd_connection(),
+                                   pid.vnn, pid.pid);
 #else
        return False;
 #endif
@@ -1405,7 +735,7 @@ uid_t nametouid(const char *name)
        char *p;
        uid_t u;
 
-       pass = getpwnam_alloc(talloc_autofree_context(), name);
+       pass = Get_Pwnam_alloc(talloc_tos(), name);
        if (pass) {
                u = pass->pw_uid;
                TALLOC_FREE(pass);
@@ -1443,26 +773,22 @@ gid_t nametogid(const char *name)
  Something really nasty happened - panic !
 ********************************************************************/
 
-void smb_panic(const char *const why)
+void smb_panic_s3(const char *why)
 {
        char *cmd;
-       int result;
-
-#ifdef DEVELOPER
-       {
-
-               if (global_clobber_region_function) {
-                       DEBUG(0,("smb_panic: clobber_region() last called from [%s(%u)]\n",
-                                        global_clobber_region_function,
-                                        global_clobber_region_line));
-               } 
-       }
-#endif
+       int result;
 
        DEBUG(0,("PANIC (pid %llu): %s\n",
                    (unsigned long long)sys_getpid(), why));
        log_stack_trace();
 
+#if defined(HAVE_PRCTL) && defined(PR_SET_PTRACER)
+       /*
+        * Make sure all children can attach a debugger.
+        */
+       prctl(PR_SET_PTRACER, getpid(), 0, 0, 0);
+#endif
+
        cmd = lp_panic_action();
        if (cmd && *cmd) {
                DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
@@ -1654,8 +980,7 @@ const char *readdirname(SMB_STRUCT_DIR *p)
  of a path matches a (possibly wildcarded) entry in a namelist.
 ********************************************************************/
 
-bool is_in_path(const char *name, name_compare_entry *namelist,
-               enum protocol_types proto, bool case_sensitive)
+bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive)
 {
        const char *last_component;
 
@@ -1676,14 +1001,13 @@ bool is_in_path(const char *name, name_compare_entry *namelist,
 
        for(; namelist->name != NULL; namelist++) {
                if(namelist->is_wild) {
-                       if (mask_match(last_component, namelist->name,
-                                      proto, case_sensitive)) {
+                       if (mask_match(last_component, namelist->name, case_sensitive)) {
                                DEBUG(8,("is_in_path: mask match succeeded\n"));
                                return True;
                        }
                } else {
                        if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
-                                               (!case_sensitive && (StrCaseCmp(last_component, namelist->name) == 0))) {
+                                               (!case_sensitive && (strcasecmp_m(last_component, namelist->name) == 0))) {
                                DEBUG(8,("is_in_path: match succeeded\n"));
                                return True;
                        }
@@ -1699,24 +1023,30 @@ bool is_in_path(const char *name, name_compare_entry *namelist,
  passing to is_in_path(). We do this for
  speed so we can pre-parse all the names in the list 
  and don't do it for each call to is_in_path().
- namelist is modified here and is assumed to be 
- a copy owned by the caller.
  We also check if the entry contains a wildcard to
  remove a potentially expensive call to mask_match
  if possible.
 ********************************************************************/
 
-void set_namearray(name_compare_entry **ppname_array, const char *namelist)
+void set_namearray(name_compare_entry **ppname_array, const char *namelist_in)
 {
        char *name_end;
-       char *nameptr = (char *)namelist;
+       char *namelist;
+       char *nameptr;
        int num_entries = 0;
        int i;
 
        (*ppname_array) = NULL;
 
-       if((nameptr == NULL ) || ((nameptr != NULL) && (*nameptr == '\0'))) 
+       if((namelist_in == NULL ) || ((namelist_in != NULL) && (*namelist_in == '\0'))) 
+               return;
+
+       namelist = talloc_strdup(talloc_tos(), namelist_in);
+       if (namelist == NULL) {
+               DEBUG(0,("set_namearray: talloc fail\n"));
                return;
+       }
+       nameptr = namelist;
 
        /* We need to make two passes over the string. The
                first to count the number of elements, the second
@@ -1743,16 +1073,19 @@ void set_namearray(name_compare_entry **ppname_array, const char *namelist)
                num_entries++;
        }
 
-       if(num_entries == 0)
+       if(num_entries == 0) {
+               talloc_free(namelist);
                return;
+       }
 
        if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
                DEBUG(0,("set_namearray: malloc fail\n"));
+               talloc_free(namelist);
                return;
        }
 
        /* Now copy out the names */
-       nameptr = (char *)namelist;
+       nameptr = namelist;
        i = 0;
        while(*nameptr) {
                if ( *nameptr == '/' ) {
@@ -1774,6 +1107,7 @@ void set_namearray(name_compare_entry **ppname_array, const char *namelist)
                (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
                if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
                        DEBUG(0,("set_namearray: malloc fail (1)\n"));
+                       talloc_free(namelist);
                        return;
                }
 
@@ -1784,25 +1118,10 @@ void set_namearray(name_compare_entry **ppname_array, const char *namelist)
 
        (*ppname_array)[i].name = NULL;
 
+       talloc_free(namelist);
        return;
 }
 
-/****************************************************************************
- Routine to free a namearray.
-****************************************************************************/
-
-void free_namearray(name_compare_entry *name_array)
-{
-       int i;
-
-       if(name_array == NULL)
-               return;
-
-       for(i=0; name_array[i].name!=NULL; i++)
-               SAFE_FREE(name_array[i].name);
-       SAFE_FREE(name_array);
-}
-
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_LOCKING
 
@@ -1959,6 +1278,9 @@ void set_remote_arch(enum remote_arch_types type)
        case RA_CIFSFS:
                remote_arch_str = "CIFSFS";
                break;
+       case RA_OSX:
+               remote_arch_str = "OSX";
+               break;
        default:
                ra_type = RA_UNKNOWN;
                remote_arch_str = "UNKNOWN";
@@ -1997,17 +1319,9 @@ const char *tab_depth(int level, int depth)
 
 int str_checksum(const char *s)
 {
-       int res = 0;
-       int c;
-       int i=0;
-
-       while(*s) {
-               c = *s;
-               res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
-               s++;
-               i++;
-       }
-       return(res);
+       if (s == NULL)
+               return 0;
+       return hash(s, strlen(s), 0);
 }
 
 /*****************************************************************
@@ -2151,9 +1465,23 @@ char *myhostname(void)
 {
        static char *ret;
        if (ret == NULL) {
-               /* This is cached forever so
-                * use talloc_autofree_context() ctx. */
-               ret = get_myname(talloc_autofree_context());
+               ret = get_myname(NULL);
+       }
+       return ret;
+}
+
+/*****************************************************************
+ Get local hostname and cache result.
+*****************************************************************/
+
+char *myhostname_upper(void)
+{
+       char *name;
+       static char *ret;
+       if (ret == NULL) {
+               name = get_myname(talloc_tos());
+               ret = strupper_talloc(NULL, name);
+               talloc_free(name);
        }
        return ret;
 }
@@ -2215,45 +1543,6 @@ char *pid_path(const char *name)
        return xx_path(name, lp_piddir());
 }
 
-/**
- * @brief Returns an absolute path to a file in the Samba lib directory.
- *
- * @param name File to find, relative to LIBDIR.
- *
- * @retval Pointer to a string containing the full path.
- **/
-
-char *lib_path(const char *name)
-{
-       return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_LIBDIR(), name);
-}
-
-/**
- * @brief Returns an absolute path to a file in the Samba modules directory.
- *
- * @param name File to find, relative to MODULESDIR.
- *
- * @retval Pointer to a string containing the full path.
- **/
-
-char *modules_path(const char *name)
-{
-       return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_MODULESDIR(), name);
-}
-
-/**
- * @brief Returns an absolute path to a file in the Samba data directory.
- *
- * @param name File to find, relative to CODEPAGEDIR.
- *
- * @retval Pointer to a talloc'ed string containing the full path.
- **/
-
-char *data_path(const char *name)
-{
-       return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_CODEPAGEDIR(), name);
-}
-
 /**
  * @brief Returns an absolute path to a file in the Samba state directory.
  *
@@ -2280,17 +1569,6 @@ char *cache_path(const char *name)
        return xx_path(name, lp_cachedir());
 }
 
-/**
- * @brief Returns the platform specific shared library extension.
- *
- * @retval Pointer to a const char * containing the extension.
- **/
-
-const char *shlib_ext(void)
-{
-       return get_dyn_SHLIBEXT();
-}
-
 /*******************************************************************
  Given a filename - get its directory name
 ********************************************************************/
@@ -2315,7 +1593,7 @@ bool parent_dirname(TALLOC_CTX *mem_ctx, const char *dir, char **parent,
 
        len = p-dir;
 
-       if (!(*parent = (char *)TALLOC_MEMDUP(mem_ctx, dir, len+1))) {
+       if (!(*parent = (char *)talloc_memdup(mem_ctx, dir, len+1))) {
                return False;
        }
        (*parent)[len] = '\0';
@@ -2374,16 +1652,14 @@ bool ms_has_wild_w(const smb_ucs2_t *s)
  of the ".." name.
 *******************************************************************/
 
-bool mask_match(const char *string, const char *pattern,
-               enum protocol_types proto, bool is_case_sensitive)
+bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
 {
        if (ISDOTDOT(string))
                string = ".";
        if (ISDOT(pattern))
                return False;
 
-       return ms_fnmatch(pattern, string, proto <= PROTOCOL_LANMAN2,
-                         is_case_sensitive) == 0;
+       return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
 }
 
 /*******************************************************************
@@ -2407,11 +1683,10 @@ bool mask_match_search(const char *string, const char *pattern, bool is_case_sen
  on each.  Returns True if any of the patterns match.
 *******************************************************************/
 
-bool mask_match_list(const char *string, char **list, int listLen,
-                    enum protocol_types proto, bool is_case_sensitive)
+bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
 {
        while (listLen-- > 0) {
-               if (mask_match(string, *list++, proto, is_case_sensitive))
+               if (mask_match(string, *list++, is_case_sensitive))
                        return True;
        }
        return False;
@@ -2587,7 +1862,7 @@ bool name_to_fqdn(fstring fqdn, const char *name)
                        }
                }
        }
-       if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
+       if (full && (strcasecmp_m(full, "localhost.localdomain") == 0)) {
                DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
                DEBUGADD(1, ("    Specifing the machine hostname for address 127.0.0.1 may lead\n"));
                DEBUGADD(1, ("    to Kerberos authentication problems as localhost.localdomain\n"));
@@ -2668,13 +1943,20 @@ uint32 get_my_vnn(void)
        return my_vnn;
 }
 
+static uint64_t my_unique_id = 0;
+
+void set_my_unique_id(uint64_t unique_id)
+{
+       my_unique_id = unique_id;
+}
+
 struct server_id pid_to_procid(pid_t pid)
 {
        struct server_id result;
        result.pid = pid;
-#ifdef CLUSTER_SUPPORT
+       result.task_id = 0;
+       result.unique_id = my_unique_id;
        result.vnn = my_vnn;
-#endif
        return result;
 }
 
@@ -2683,19 +1965,14 @@ struct server_id procid_self(void)
        return pid_to_procid(sys_getpid());
 }
 
-struct server_id server_id_self(void)
-{
-       return procid_self();
-}
-
 bool procid_equal(const struct server_id *p1, const struct server_id *p2)
 {
        if (p1->pid != p2->pid)
                return False;
-#ifdef CLUSTER_SUPPORT
+       if (p1->task_id != p2->task_id)
+               return False;
        if (p1->vnn != p2->vnn)
                return False;
-#endif
        return True;
 }
 
@@ -2709,101 +1986,60 @@ bool procid_is_me(const struct server_id *pid)
 {
        if (pid->pid != sys_getpid())
                return False;
-#ifdef CLUSTER_SUPPORT
+       if (pid->task_id != 0)
+               return False;
        if (pid->vnn != my_vnn)
                return False;
-#endif
        return True;
 }
 
 struct server_id interpret_pid(const char *pid_string)
 {
        struct server_id result;
-       int pid;
-#ifdef CLUSTER_SUPPORT
-       unsigned int vnn;
-       if (sscanf(pid_string, "%u:%d", &vnn, &pid) == 2) {
+       unsigned long long pid;
+       unsigned int vnn, task_id = 0;
+
+       ZERO_STRUCT(result);
+
+       /* We accept various forms with 1, 2 or 3 component forms
+        * because the server_id_str() can print different forms, and
+        * we want backwards compatibility for scripts that may call
+        * smbclient. */
+       if (sscanf(pid_string, "%u:%llu.%u", &vnn, &pid, &task_id) == 3) {
                result.vnn = vnn;
                result.pid = pid;
-       }
-       else if (sscanf(pid_string, "%d", &pid) == 1) {
+               result.task_id = task_id;
+       } else if (sscanf(pid_string, "%u:%llu", &vnn, &pid) == 2) {
+               result.vnn = vnn;
+               result.pid = pid;
+               result.task_id = 0;
+       } else if (sscanf(pid_string, "%llu.%u", &pid, &task_id) == 2) {
                result.vnn = get_my_vnn();
                result.pid = pid;
-       }
-       else {
-               result.vnn = NONCLUSTER_VNN;
-               result.pid = -1;
-       }
-#else
-       if (sscanf(pid_string, "%d", &pid) != 1) {
-               result.pid = -1;
-       } else {
+               result.task_id = task_id;
+       } else if (sscanf(pid_string, "%llu", &pid) == 1) {
+               result.vnn = get_my_vnn();
                result.pid = pid;
-       }
-#endif
-       /* Assigning to result.pid may have overflowed
-          Map negative pid to -1: i.e. error */
-       if (result.pid < 0) {
-               result.pid = -1;
+       } else {
+               result.vnn = NONCLUSTER_VNN;
+               result.pid = (uint64_t)-1;
        }
        return result;
 }
 
-char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
-{
-#ifdef CLUSTER_SUPPORT
-       if (pid->vnn == NONCLUSTER_VNN) {
-               return talloc_asprintf(mem_ctx,
-                               "%d",
-                               (int)pid->pid);
-       }
-       else {
-               return talloc_asprintf(mem_ctx,
-                                       "%u:%d",
-                                       (unsigned)pid->vnn,
-                                       (int)pid->pid);
-       }
-#else
-       return talloc_asprintf(mem_ctx,
-                       "%d",
-                       (int)pid->pid);
-#endif
-}
-
 char *procid_str_static(const struct server_id *pid)
 {
-       return procid_str(talloc_tos(), pid);
+       return server_id_str(talloc_tos(), pid);
 }
 
 bool procid_valid(const struct server_id *pid)
 {
-       return (pid->pid != -1);
+       return (pid->pid != (uint64_t)-1);
 }
 
 bool procid_is_local(const struct server_id *pid)
 {
-#ifdef CLUSTER_SUPPORT
        return pid->vnn == my_vnn;
-#else
-       return True;
-#endif
-}
-
-int this_is_smp(void)
-{
-#if defined(HAVE_SYSCONF)
-
-#if defined(SYSCONF_SC_NPROC_ONLN)
-        return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
-#elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
-        return (sysconf(_SC_NPROCESSORS_ONLN) > 1) ? 1 : 0;
-#else
-       return 0;
-#endif
-
-#else
-       return 0;
-#endif
 }
 
 /****************************************************************
@@ -2932,155 +2168,258 @@ void split_domain_user(TALLOC_CTX *mem_ctx,
        }
 }
 
-#if 0
-
-Disable these now we have checked all code paths and ensured
-NULL returns on zero request. JRA.
-
 /****************************************************************
- talloc wrapper functions that guarentee a null pointer return
- if size == 0.
+ strip off leading '\\' from a hostname
 ****************************************************************/
 
-#ifndef MAX_TALLOC_SIZE
-#define MAX_TALLOC_SIZE 0x10000000
-#endif
-
-/*
- *    talloc and zero memory.
- *    - returns NULL if size is zero.
- */
-
-void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
+const char *strip_hostname(const char *s)
 {
-       void *p;
-
-       if (size == 0) {
+       if (!s) {
                return NULL;
        }
 
-       p = talloc_named_const(ctx, size, name);
-
-       if (p) {
-               memset(p, '\0', size);
+       if (strlen_m(s) < 3) {
+               return s;
        }
 
-       return p;
-}
+       if (s[0] == '\\') s++;
+       if (s[0] == '\\') s++;
 
-/*
- *   memdup with a talloc.
- *   - returns NULL if size is zero.
- */
+       return s;
+}
 
-void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
+bool tevent_req_poll_ntstatus(struct tevent_req *req,
+                             struct tevent_context *ev,
+                             NTSTATUS *status)
 {
-       void *newp;
-
-       if (size == 0) {
-               return NULL;
+       bool ret = tevent_req_poll(req, ev);
+       if (!ret) {
+               *status = map_nt_error_from_unix(errno);
        }
+       return ret;
+}
 
-       newp = talloc_named_const(t, size, name);
-       if (newp) {
-               memcpy(newp, p, size);
+bool any_nt_status_not_ok(NTSTATUS err1, NTSTATUS err2, NTSTATUS *result)
+{
+       if (!NT_STATUS_IS_OK(err1)) {
+               *result = err1;
+               return true;
        }
+       if (!NT_STATUS_IS_OK(err2)) {
+               *result = err2;
+               return true;
+       }
+       return false;
+}
 
-       return newp;
+int timeval_to_msec(struct timeval t)
+{
+       return t.tv_sec * 1000 + (t.tv_usec+999) / 1000;
 }
 
-/*
- *   alloc an array, checking for integer overflow in the array size.
- *   - returns NULL if count or el_size are zero.
- */
+/*******************************************************************
+ Check a given DOS pathname is valid for a share.
+********************************************************************/
 
-void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
+char *valid_share_pathname(TALLOC_CTX *ctx, const char *dos_pathname)
 {
-       if (count >= MAX_TALLOC_SIZE/el_size) {
+       char *ptr = NULL;
+
+       if (!dos_pathname) {
                return NULL;
        }
 
-       if (el_size == 0 || count == 0) {
+       ptr = talloc_strdup(ctx, dos_pathname);
+       if (!ptr) {
                return NULL;
        }
-
-       return talloc_named_const(ctx, el_size * count, name);
-}
-
-/*
- *   alloc an zero array, checking for integer overflow in the array size
- *   - returns NULL if count or el_size are zero.
- */
-
-void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
-{
-       if (count >= MAX_TALLOC_SIZE/el_size) {
+       /* Convert any '\' paths to '/' */
+       unix_format(ptr);
+       ptr = unix_clean_name(ctx, ptr);
+       if (!ptr) {
                return NULL;
        }
 
-       if (el_size == 0 || count == 0) {
+       /* NT is braindead - it wants a C: prefix to a pathname ! So strip it. */
+       if (strlen(ptr) > 2 && ptr[1] == ':' && ptr[0] != '/')
+               ptr += 2;
+
+       /* Only absolute paths allowed. */
+       if (*ptr != '/')
                return NULL;
-       }
 
-       return _talloc_zero(ctx, el_size * count, name);
+       return ptr;
 }
 
-/*
- *   Talloc wrapper that returns NULL if size == 0.
- */
-void *talloc_zeronull(const void *context, size_t size, const char *name)
+/*******************************************************************
+ Return True if the filename is one of the special executable types.
+********************************************************************/
+
+bool is_executable(const char *fname)
 {
-       if (size == 0) {
-               return NULL;
+       if ((fname = strrchr_m(fname,'.'))) {
+               if (strequal(fname,".com") ||
+                   strequal(fname,".dll") ||
+                   strequal(fname,".exe") ||
+                   strequal(fname,".sym")) {
+                       return True;
+               }
        }
-       return talloc_named_const(context, size, name);
+       return False;
 }
-#endif
 
-bool is_valid_policy_hnd(const struct policy_handle *hnd)
-{
-       struct policy_handle tmp;
-       ZERO_STRUCT(tmp);
-       return (memcmp(&tmp, hnd, sizeof(tmp)) != 0);
-}
+/****************************************************************************
+ Open a file with a share mode - old openX method - map into NTCreate.
+****************************************************************************/
 
-bool policy_hnd_equal(const struct policy_handle *hnd1,
-                     const struct policy_handle *hnd2)
-{
-       if (!hnd1 || !hnd2) {
-               return false;
+bool map_open_params_to_ntcreate(const char *smb_base_fname,
+                                int deny_mode, int open_func,
+                                uint32 *paccess_mask,
+                                uint32 *pshare_mode,
+                                uint32 *pcreate_disposition,
+                                uint32 *pcreate_options,
+                                uint32_t *pprivate_flags)
+{
+       uint32 access_mask;
+       uint32 share_mode;
+       uint32 create_disposition;
+       uint32 create_options = FILE_NON_DIRECTORY_FILE;
+       uint32_t private_flags = 0;
+
+       DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
+                 "open_func = 0x%x\n",
+                 smb_base_fname, (unsigned int)deny_mode,
+                 (unsigned int)open_func ));
+
+       /* Create the NT compatible access_mask. */
+       switch (GET_OPENX_MODE(deny_mode)) {
+               case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
+               case DOS_OPEN_RDONLY:
+                       access_mask = FILE_GENERIC_READ;
+                       break;
+               case DOS_OPEN_WRONLY:
+                       access_mask = FILE_GENERIC_WRITE;
+                       break;
+               case DOS_OPEN_RDWR:
+               case DOS_OPEN_FCB:
+                       access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
+                       break;
+               default:
+                       DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
+                                 (unsigned int)GET_OPENX_MODE(deny_mode)));
+                       return False;
        }
 
-       return (memcmp(hnd1, hnd2, sizeof(*hnd1)) == 0);
-}
+       /* Create the NT compatible create_disposition. */
+       switch (open_func) {
+               case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
+                       create_disposition = FILE_CREATE;
+                       break;
 
-/****************************************************************
- strip off leading '\\' from a hostname
-****************************************************************/
+               case OPENX_FILE_EXISTS_OPEN:
+                       create_disposition = FILE_OPEN;
+                       break;
 
-const char *strip_hostname(const char *s)
-{
-       if (!s) {
-               return NULL;
+               case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
+                       create_disposition = FILE_OPEN_IF;
+                       break;
+
+               case OPENX_FILE_EXISTS_TRUNCATE:
+                       create_disposition = FILE_OVERWRITE;
+                       break;
+
+               case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
+                       create_disposition = FILE_OVERWRITE_IF;
+                       break;
+
+               default:
+                       /* From samba4 - to be confirmed. */
+                       if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
+                               create_disposition = FILE_CREATE;
+                               break;
+                       }
+                       DEBUG(10,("map_open_params_to_ntcreate: bad "
+                                 "open_func 0x%x\n", (unsigned int)open_func));
+                       return False;
        }
 
-       if (strlen_m(s) < 3) {
-               return s;
+       /* Create the NT compatible share modes. */
+       switch (GET_DENY_MODE(deny_mode)) {
+               case DENY_ALL:
+                       share_mode = FILE_SHARE_NONE;
+                       break;
+
+               case DENY_WRITE:
+                       share_mode = FILE_SHARE_READ;
+                       break;
+
+               case DENY_READ:
+                       share_mode = FILE_SHARE_WRITE;
+                       break;
+
+               case DENY_NONE:
+                       share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
+                       break;
+
+               case DENY_DOS:
+                       private_flags |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
+                       if (is_executable(smb_base_fname)) {
+                               share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
+                       } else {
+                               if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
+                                       share_mode = FILE_SHARE_READ;
+                               } else {
+                                       share_mode = FILE_SHARE_NONE;
+                               }
+                       }
+                       break;
+
+               case DENY_FCB:
+                       private_flags |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
+                       share_mode = FILE_SHARE_NONE;
+                       break;
+
+               default:
+                       DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
+                               (unsigned int)GET_DENY_MODE(deny_mode) ));
+                       return False;
        }
 
-       if (s[0] == '\\') s++;
-       if (s[0] == '\\') s++;
+       DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
+                 "share_mode = 0x%x, create_disposition = 0x%x, "
+                 "create_options = 0x%x private_flags = 0x%x\n",
+                 smb_base_fname,
+                 (unsigned int)access_mask,
+                 (unsigned int)share_mode,
+                 (unsigned int)create_disposition,
+                 (unsigned int)create_options,
+                 (unsigned int)private_flags));
+
+       if (paccess_mask) {
+               *paccess_mask = access_mask;
+       }
+       if (pshare_mode) {
+               *pshare_mode = share_mode;
+       }
+       if (pcreate_disposition) {
+               *pcreate_disposition = create_disposition;
+       }
+       if (pcreate_options) {
+               *pcreate_options = create_options;
+       }
+       if (pprivate_flags) {
+               *pprivate_flags = private_flags;
+       }
+
+       return True;
 
-       return s;
 }
 
-bool tevent_req_poll_ntstatus(struct tevent_req *req,
-                             struct tevent_context *ev,
-                             NTSTATUS *status)
+
+void init_modules(void)
 {
-       bool ret = tevent_req_poll(req, ev);
-       if (!ret) {
-               *status = map_nt_error_from_unix(errno);
-       }
-       return ret;
+       /* FIXME: This can cause undefined symbol errors :
+        *  smb_register_vfs() isn't available in nmbd, for example */
+       if(lp_preload_modules())
+               smb_load_modules(lp_preload_modules());
 }