Changeset 988 for vendor/current/source3/lib/util.c

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

File:

• vendor/current/source3/lib/util.c (modified) (45 diffs)

vendor/current/source3/lib/util.c

@@ -29 +29 @@
 #include "../lib/util/util_pw.h"
 #include "messages.h"
+#include "messages_dgm.h"
 #include "libcli/security/security.h"
-
-extern char *global_clobber_region_function;
-extern unsigned int global_clobber_region_line;
+#include "serverid.h"
+#include "lib/util/sys_rw.h"
+#include "lib/util/sys_rw_data.h"
+#include "lib/util/util_process.h"
+
+#ifdef HAVE_SYS_PRCTL_H
+#include <sys/prctl.h>
+#endif
 
 /* Max allowable allococation - 256mb - 0x10000000 */
@@ -77 +83 @@
 static enum remote_arch_types ra_type = RA_UNKNOWN;
 
-/***********************************************************************
- Definitions for all names.
-***********************************************************************/
-
-static char *smb_scope;
-static int smb_num_netbios_names;
-static char **smb_my_netbios_names;
-
-/***********************************************************************
- 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)
-{
-        gfree_netbios_names();
-        SAFE_FREE( smb_scope );
-        free_netbios_names_array();
-        free_local_machine_name();
-}
-
 void gfree_all( void )
 {
         gfree_names();
         gfree_loadparm();
-        gfree_case_tables();
         gfree_charcnv();
         gfree_interfaces();
@@ -168 +92 @@
 }
 
-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_names: malloc fail.\n" ) );
-                        return False;
-                }
-        }
-
-        if (!set_netbios_aliases(lp_netbios_aliases())) {
-                DEBUG( 0, ( "init_names: 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 );
-}
-
 /*******************************************************************
  Check if a file exists - call vfs_file_exist for samba files.
@@ -288 +131 @@
 }
 
-/*******************************************************************
- Returns the size in bytes of the named file.
-********************************************************************/
-
-SMB_OFF_T get_file_size(char *file_name)
-{
-        SMB_STRUCT_STAT buf;
-        buf.st_ex_size = 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 & FILE_ATTRIBUTE_VOLUME) fstrcat(attrstr,"V");
-        if (mode & FILE_ATTRIBUTE_DIRECTORY) fstrcat(attrstr,"D");
-        if (mode & FILE_ATTRIBUTE_ARCHIVE) fstrcat(attrstr,"A");
-        if (mode & FILE_ATTRIBUTE_HIDDEN) fstrcat(attrstr,"H");
-        if (mode & FILE_ATTRIBUTE_SYSTEM) fstrcat(attrstr,"S");
-        if (mode & FILE_ATTRIBUTE_READONLY) fstrcat(attrstr,"R");
-
-        return talloc_strdup(talloc_tos(), attrstr);
+/****************************************************************************
+ Check two stats have identical dev and ino fields.
+****************************************************************************/
+
+bool check_same_dev_ino(const SMB_STRUCT_STAT *sbuf1,
+                        const SMB_STRUCT_STAT *sbuf2)
+{
+        if (sbuf1->st_ex_dev != sbuf2->st_ex_dev ||
+                        sbuf1->st_ex_ino != sbuf2->st_ex_ino) {
+                return false;
+        }
+        return true;
+}
+
+/****************************************************************************
+ Check if a stat struct is identical for use.
+****************************************************************************/
+
+bool check_same_stat(const SMB_STRUCT_STAT *sbuf1,
+                        const SMB_STRUCT_STAT *sbuf2)
+{
+        if (sbuf1->st_ex_uid != sbuf2->st_ex_uid ||
+                        sbuf1->st_ex_gid != sbuf2->st_ex_gid ||
+                        !check_same_dev_ino(sbuf1, sbuf2)) {
+                return false;
+        }
+        return true;
 }
 
@@ -325 +164 @@
 ********************************************************************/
 
-void show_msg(char *buf)
+void show_msg(const char *buf)
 {
         int i;
@@ -362 +201 @@
                 bcc = MIN(bcc, 512);
 
-        dump_data(10, (uint8 *)smb_buf(buf), bcc);      
-}
-
-/*******************************************************************
- Set the length and marker of an encrypted smb packet.
-********************************************************************/
-
-void smb_set_enclen(char *buf,int len,uint16 enc_ctx_num)
-{
-        _smb_setlen(buf,len);
-
-        SCVAL(buf,4,0xFF);
-        SCVAL(buf,5,'E');
-        SSVAL(buf,6,enc_ctx_num);
-}
-
-/*******************************************************************
- Set the length and marker of an smb packet.
-********************************************************************/
-
-void smb_setlen(char *buf,int len)
-{
-        _smb_setlen_large(buf,len);
-
-        SCVAL(buf,4,0xFF);
-        SCVAL(buf,5,'S');
-        SCVAL(buf,6,'M');
-        SCVAL(buf,7,'B');
+        dump_data(10, (const uint8_t *)smb_buf_const(buf), bcc);
 }
 
@@ -409 +221 @@
 ********************************************************************/
 
-ssize_t message_push_blob(uint8 **outbuf, DATA_BLOB blob)
+ssize_t message_push_blob(uint8_t **outbuf, DATA_BLOB blob)
 {
         size_t newlen = smb_len(*outbuf) + 4 + blob.length;
-        uint8 *tmp;
-
-        if (!(tmp = TALLOC_REALLOC_ARRAY(NULL, *outbuf, uint8, newlen))) {
+        uint8_t *tmp;
+
+        if (!(tmp = talloc_realloc(NULL, *outbuf, uint8_t, newlen))) {
                 DEBUG(0, ("talloc failed\n"));
                 return -1;
@@ -542 +354 @@
 ********************************************************************/
 
-ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos)
+ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, off_t pos)
 {
         size_t total=0;
         ssize_t ret;
 
-        if (pos == (SMB_OFF_T)-1) {
+        if (pos == (off_t)-1) {
                 return write_data(fd, buffer, N);
         }
@@ -569 +381 @@
 #else
         /* Use lseek and write_data. */
-        if (sys_lseek(fd, pos, SEEK_SET) == -1) {
+        if (lseek(fd, pos, SEEK_SET) == -1) {
                 if (errno != ESPIPE) {
                         return -1;
@@ -578 +390 @@
 }
 
+static int reinit_after_fork_pipe[2] = { -1, -1 };
+
+NTSTATUS init_before_fork(void)
+{
+        int ret;
+
+        ret = pipe(reinit_after_fork_pipe);
+        if (ret == -1) {
+                NTSTATUS status;
+
+                status = map_nt_error_from_unix_common(errno);
+
+                DEBUG(0, ("Error creating child_pipe: %s\n",
+                          nt_errstr(status)));
+
+                return status;
+        }
+
+        return NT_STATUS_OK;
+}
+
+/**
+ * Detect died parent by detecting EOF on the pipe
+ */
+static void reinit_after_fork_pipe_handler(struct tevent_context *ev,
+                                           struct tevent_fd *fde,
+                                           uint16_t flags,
+                                           void *private_data)
+{
+        char c;
+
+        if (sys_read(reinit_after_fork_pipe[0], &c, 1) != 1) {
+                /*
+                 * we have reached EOF on stdin, which means the
+                 * parent has exited. Shutdown the server
+                 */
+                (void)kill(getpid(), SIGTERM);
+        }
+}
+
 
 NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
-                           struct event_context *ev_ctx,
-                           struct server_id id,
-                           bool parent_longlived)
+                           struct tevent_context *ev_ctx,
+                           bool parent_longlived,
+                           const char *comment)
 {
         NTSTATUS status = NT_STATUS_OK;
 
-        /* Reset the state of the random
-         * number generation system, so
-         * children do not get the same random
-         * numbers as each other */
-        set_need_random_reseed();
+        if (reinit_after_fork_pipe[1] != -1) {
+                close(reinit_after_fork_pipe[1]);
+                reinit_after_fork_pipe[1] = -1;
+        }
 
         /* 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;
@@ -599 +450 @@
         }
 
-        if (ev_ctx && tevent_re_initialise(ev_ctx) != 0) {
-                smb_panic(__location__ ": Failed to re-initialise event context");
+        if (ev_ctx != NULL) {
+                tevent_set_trace_callback(ev_ctx, NULL, NULL);
+                if (tevent_re_initialise(ev_ctx) != 0) {
+                        smb_panic(__location__ ": Failed to re-initialise event context");
+                }
+        }
+
+        if (reinit_after_fork_pipe[0] != -1) {
+                struct tevent_fd *fde;
+
+                fde = tevent_add_fd(ev_ctx, ev_ctx /* TALLOC_CTX */,
+                                    reinit_after_fork_pipe[0], TEVENT_FD_READ,
+                                    reinit_after_fork_pipe_handler, NULL);
+                if (fde == NULL) {
+                        smb_panic(__location__ ": Failed to add reinit_after_fork pipe event");
+                }
         }
 
@@ -608 +473 @@
                  * fork
                  */
-                status = messaging_reinit(msg_ctx, id);
+                status = messaging_reinit(msg_ctx);
                 if (!NT_STATUS_IS_OK(status)) {
                         DEBUG(0,("messaging_reinit() failed: %s\n",
@@ -614 +479 @@
                 }
         }
+
+        if (comment) {
+                prctl_set_comment(comment);
+        }
+
  done:
         return status;
-}
-
-#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);
 }
 
@@ -766 +493 @@
 
 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
-                        void *element, void *_array, uint32 *num_elements,
+                        void *element, void *_array, uint32_t *num_elements,
                         ssize_t *array_size)
 {
@@ -838 +565 @@
         }
 }
-
-/****************************************************************************
- Interpret a protocol description string, with a default.
-****************************************************************************/
-
-int interpret_protocol(const char *str,int def)
-{
-        if (strequal(str,"NT1"))
-                return(PROTOCOL_NT1);
-        if (strequal(str,"LANMAN2"))
-                return(PROTOCOL_LANMAN2);
-        if (strequal(str,"LANMAN1"))
-                return(PROTOCOL_LANMAN1);
-        if (strequal(str,"CORE"))
-                return(PROTOCOL_CORE);
-        if (strequal(str,"COREPLUS"))
-                return(PROTOCOL_COREPLUS);
-        if (strequal(str,"CORE+"))
-                return(PROTOCOL_COREPLUS);
-
-        DEBUG(0,("Unrecognised protocol level %s\n",str));
-
-        return(def);
-}
-
 
 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
@@ -898 +600 @@
         char *value = NULL;
 
-        char *nis_map = (char *)lp_nis_home_map_name();
+        char *nis_map = (char *)lp_homedir_map();
 
         char buffer[NIS_MAXATTRVAL + 1];
@@ -950 +652 @@
         int nis_result_len;  /* and set this */
         char *nis_domain;     /* yp_get_default_domain inits this */
-        char *nis_map = (char *)lp_nis_home_map_name();
+        char *nis_map = lp_homedir_map(talloc_tos());
 
         if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
@@ -987 +689 @@
 #endif
 
-/****************************************************************************
- Check if a process exists. Does this work on all unixes?
-****************************************************************************/
-
 bool process_exists(const struct server_id pid)
 {
-        if (procid_is_me(&pid)) {
-                return True;
-        }
-
-        if (procid_is_local(&pid)) {
-                return (kill(pid.pid,0) == 0 || errno != ESRCH);
-        }
-
-#ifdef CLUSTER_SUPPORT
-        return ctdbd_process_exists(messaging_ctdbd_connection(),
-                                    pid.vnn, pid.pid);
-#else
-        return False;
-#endif
+        return serverid_exists(&pid);
 }
 
@@ -1088 +773 @@
                 return g;
 
-        grp = sys_getgrnam(name);
+        grp = getgrnam(name);
         if (grp)
                 return(grp->gr_gid);
@@ -1098 +783 @@
 ********************************************************************/
 
-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));
-                } 
-        }
+        DEBUG(0,("PANIC (pid %llu): %s\n",
+                    (unsigned long long)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
 
-        DEBUG(0,("PANIC (pid %llu): %s\n",
-                    (unsigned long long)sys_getpid(), why));
-        log_stack_trace();
-
-        cmd = lp_panic_action();
+        cmd = lp_panic_action(talloc_tos());
         if (cmd && *cmd) {
                 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
@@ -1277 +958 @@
  ********************************************************************/
 
-const char *readdirname(SMB_STRUCT_DIR *p)
-{
-        SMB_STRUCT_DIRENT *ptr;
+const char *readdirname(DIR *p)
+{
+        struct dirent *ptr;
         char *dname;
 
@@ -1285 +966 @@
                 return(NULL);
 
-        ptr = (SMB_STRUCT_DIRENT *)sys_readdir(p);
+        ptr = (struct dirent *)readdir(p);
         if (!ptr)
                 return(NULL);
@@ -1336 +1017 @@
                 } 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;
@@ -1352 +1033 @@
  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
@@ -1359 +1038 @@
 ********************************************************************/
 
-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 *namelist_end;
+        char *nameptr;
         int num_entries = 0;
         int i;
@@ -1368 +1049 @@
         (*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;
+
+        namelist_end = &namelist[strlen(namelist)];
 
         /* We need to make two passes over the string. The
@@ -1376 +1066 @@
         */
 
-        while(*nameptr) {
+        while(nameptr <= namelist_end) {
                 if ( *nameptr == '/' ) {
                         /* cope with multiple (useless) /s) */
@@ -1388 +1078 @@
                 /* find the next '/' or consume remaining */
                 name_end = strchr_m(nameptr, '/');
-                if (name_end == NULL)
-                        name_end = (char *)nameptr + strlen(nameptr);
-
-                /* next segment please */
-                nameptr = name_end + 1;
+                if (name_end == NULL) {
+                        /* Point nameptr at the terminating '\0' */
+                        nameptr += strlen(nameptr);
+                } else {
+                        /* next segment please */
+                        nameptr = name_end + 1;
+                }
                 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) {
+        while(nameptr <= namelist_end) {
                 if ( *nameptr == '/' ) {
                         /* cope with multiple (useless) /s) */
@@ -1419 +1114 @@
                 /* find the next '/' or consume remaining */
                 name_end = strchr_m(nameptr, '/');
-                if (name_end)
+                if (name_end != NULL) {
                         *name_end = '\0';
-                else
-                        name_end = nameptr + strlen(nameptr);
+                }
 
                 (*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;
                 }
 
-                /* next segment please */
-                nameptr = name_end + 1;
+                if (name_end == NULL) {
+                        /* Point nameptr at the terminating '\0' */
+                        nameptr += strlen(nameptr);
+                } else {
+                        /* next segment please */
+                        nameptr = name_end + 1;
+                }
                 i++;
         }
@@ -1437 +1137 @@
         (*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);
 }
 
@@ -1466 +1151 @@
 ****************************************************************************/
 
-bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
-{
-        SMB_STRUCT_FLOCK lock;
+bool fcntl_getlock(int fd, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
+{
+        struct flock lock;
         int ret;
 
@@ -1480 +1165 @@
         lock.l_pid = 0;
 
-        ret = sys_fcntl_ptr(fd,SMB_F_GETLK,&lock);
+        ret = sys_fcntl_ptr(fd,F_GETLK,&lock);
 
         if (ret == -1) {
@@ -1514 +1199 @@
 
         for (n=0; my_netbios_names(n); n++) {
-                if (strequal(my_netbios_names(n), s)) {
+                const char *nbt_name = my_netbios_names(n);
+
+                if (strncasecmp_m(nbt_name, s, MAX_NETBIOSNAME_LEN-1) == 0) {
                         ret=True;
                         break;
@@ -1520 +1207 @@
         }
         DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
-        return(ret);
-}
-
-/*******************************************************************
- Is the name specified our workgroup/domain.
- Returns true if it is equal, false otherwise.
-********************************************************************/
-
-bool is_myworkgroup(const char *s)
-{
-        bool ret = False;
-
-        if (strequal(s, lp_workgroup())) {
-                ret=True;
-        }
-
-        DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s, ret));
         return(ret);
 }
@@ -1653 +1323 @@
 int str_checksum(const char *s)
 {
-        TDB_DATA key = string_tdb_data(s);
+        TDB_DATA key;
+        if (s == NULL)
+                return 0;
+
+        key = (TDB_DATA) { .dptr = discard_const_p(uint8_t, s),
+                           .dsize = strlen(s) };
+
         return tdb_jenkins_hash(&key);
 }
@@ -1803 +1479 @@
 }
 
-/**
- * @brief Returns an absolute path to a file concatenating the provided
- * @a rootpath and @a basename
- *
- * @param name Filename, relative to @a rootpath
- *
- * @retval Pointer to a string containing the full path.
- **/
-
-static char *xx_path(const char *name, const char *rootpath)
-{
-        char *fname = NULL;
-
-        fname = talloc_strdup(talloc_tos(), rootpath);
-        if (!fname) {
-                return NULL;
-        }
-        trim_string(fname,"","/");
-
-        if (!directory_exist(fname)) {
-                if (!mkdir(fname,0755))
-                        DEBUG(1, ("Unable to create directory %s for file %s. "
-                              "Error was %s\n", fname, name, strerror(errno)));
-        }
-
-        return talloc_asprintf(talloc_tos(),
-                                "%s/%s",
-                                fname,
-                                name);
-}
-
-/**
- * @brief Returns an absolute path to a file in the Samba lock directory.
- *
- * @param name File to find, relative to LOCKDIR.
- *
- * @retval Pointer to a talloc'ed string containing the full path.
- **/
-
-char *lock_path(const char *name)
-{
-        return xx_path(name, lp_lockdir());
-}
-
-/**
- * @brief Returns an absolute path to a file in the Samba pid directory.
- *
- * @param name File to find, relative to PIDDIR.
- *
- * @retval Pointer to a talloc'ed string containing the full path.
- **/
-
-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.
- *
- * @param name File to find, relative to STATEDIR.
- *
- * @retval Pointer to a talloc'ed string containing the full path.
- **/
-
-char *state_path(const char *name)
-{
-        return xx_path(name, lp_statedir());
-}
-
-/**
- * @brief Returns an absolute path to a file in the Samba cache directory.
- *
- * @param name File to find, relative to CACHEDIR.
- *
- * @retval Pointer to a talloc'ed string containing the full path.
- **/
-
-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();
+/*****************************************************************
+ Get local hostname and cache result.
+*****************************************************************/
+
+char *myhostname_upper(void)
+{
+        static char *ret;
+        if (ret == NULL) {
+                char *name = get_myname(NULL);
+                if (name == NULL) {
+                        return NULL;
+                }
+                ret = strupper_talloc(NULL, name);
+                talloc_free(name);
+        }
+        return ret;
 }
 
@@ -1960 +1521 @@
         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;
         }
@@ -1978 +1539 @@
 {
         char c;
-
-        if (lp_posix_pathnames()) {
-                /* With posix pathnames no characters are wild. */
-                return False;
-        }
 
         while ((c = *s++)) {
@@ -2179 +1735 @@
                 return false;
         }
-        strlower_m(p2);
-        strlower_m(s2);
+        if (!strlower_m(p2)) {
+                TALLOC_FREE(ctx);
+                return false;
+        }
+        if (!strlower_m(s2)) {
+                TALLOC_FREE(ctx);
+                return false;
+        }
 
         /* Remove any *? and ** from the pattern as they are meaningless */
@@ -2200 +1762 @@
 
 /**********************************************************************
- Converts a name to a fully qualified domain name.
- Returns true if lookup succeeded, false if not (then fqdn is set to name)
- Note we deliberately use gethostbyname here, not getaddrinfo as we want
- to examine the h_aliases and I don't know how to do that with getaddrinfo.
-***********************************************************************/
+  Converts a name to a fully qualified domain name.
+  Returns true if lookup succeeded, false if not (then fqdn is set to name)
+  Uses getaddrinfo() with AI_CANONNAME flag to obtain the official
+  canonical name of the host. getaddrinfo() may use a variety of sources
+  including /etc/hosts to obtain the domainname. It expects aliases in
+  /etc/hosts to NOT be the FQDN. The FQDN should come first.
+************************************************************************/
 
 bool name_to_fqdn(fstring fqdn, const char *name)
 {
         char *full = NULL;
-        struct hostent *hp = gethostbyname(name);
-
-        if (!hp || !hp->h_name || !*hp->h_name) {
+        struct addrinfo hints;
+        struct addrinfo *result;
+        int s;
+
+        /* Configure hints to obtain canonical name */
+
+        memset(&hints, 0, sizeof(struct addrinfo));
+        hints.ai_family = AF_UNSPEC;    /* Allow IPv4 or IPv6 */
+        hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
+        hints.ai_flags = AI_CANONNAME;  /* Get host's FQDN */
+        hints.ai_protocol = 0;          /* Any protocol */
+
+        s = getaddrinfo(name, NULL, &hints, &result);
+        if (s != 0) {
+                DEBUG(1, ("getaddrinfo: %s\n", gai_strerror(s)));
                 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
                 fstrcpy(fqdn, name);
                 return false;
         }
-
-        /* Find out if the fqdn is returned as an alias
+        full = result->ai_canonname;
+
+        /* Find out if the FQDN is returned as an alias
          * to cope with /etc/hosts files where the first
-         * name is not the fqdn but the short name */
-        if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
-                int i;
-                for (i = 0; hp->h_aliases[i]; i++) {
-                        if (strchr_m(hp->h_aliases[i], '.')) {
-                                full = hp->h_aliases[i];
-                                break;
-                        }
-                }
-        }
-        if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
+         * name is not the FQDN but the short name.
+         * getaddrinfo provides no easy way of handling aliases
+         * in /etc/hosts. Users should make sure the FQDN
+         * comes first in /etc/hosts. */
+        if (full && (! strchr_m(full, '.'))) {
                 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, ("    Full qualified domain names (FQDNs) should not be specified\n"));
+                DEBUGADD(1, ("    as an alias in /etc/hosts. FQDN should be the first name\n"));
+                DEBUGADD(1, ("    prior to any aliases.\n"));
+        }
+        if (full && (strcasecmp_m(full, "localhost.localdomain") == 0)) {
+                DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
+                DEBUGADD(1, ("    Specifying the machine hostname for address 127.0.0.1 may lead\n"));
                 DEBUGADD(1, ("    to Kerberos authentication problems as localhost.localdomain\n"));
                 DEBUGADD(1, ("    may end up being used instead of the real machine FQDN.\n"));
-                full = hp->h_name;
-        }
-        if (!full) {
-                full = hp->h_name;
         }
 
         DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
         fstrcpy(fqdn, full);
+        freeaddrinfo(result);           /* No longer needed */
         return true;
 }
 
-/**********************************************************************
- Append a DATA_BLOB to a talloc'ed object
-***********************************************************************/
-
-void *talloc_append_blob(TALLOC_CTX *mem_ctx, void *buf, DATA_BLOB blob)
-{
-        size_t old_size = 0;
-        char *result;
-
-        if (blob.length == 0) {
-                return buf;
-        }
-
-        if (buf != NULL) {
-                old_size = talloc_get_size(buf);
-        }
-
-        result = (char *)TALLOC_REALLOC(mem_ctx, buf, old_size + blob.length);
-        if (result == NULL) {
-                return NULL;
-        }
-
-        memcpy(result + old_size, blob.data, blob.length);
-        return result;
-}
-
-uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
+uint32_t map_share_mode_to_deny_mode(uint32_t share_access, uint32_t private_options)
 {
         switch (share_access & ~FILE_SHARE_DELETE) {
@@ -2289 +1837 @@
         }
 
-        return (uint32)-1;
-}
-
-pid_t procid_to_pid(const struct server_id *proc)
-{
-        return proc->pid;
-}
-
-static uint32 my_vnn = NONCLUSTER_VNN;
-
-void set_my_vnn(uint32 vnn)
-{
-        DEBUG(10, ("vnn pid %d = %u\n", (int)sys_getpid(), (unsigned int)vnn));
-        my_vnn = vnn;
-}
-
-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;
-        result.unique_id = my_unique_id;
-        result.vnn = my_vnn;
-        return result;
-}
-
-struct server_id procid_self(void)
-{
-        return pid_to_procid(sys_getpid());
-}
-
-bool procid_equal(const struct server_id *p1, const struct server_id *p2)
-{
-        if (p1->pid != p2->pid)
-                return False;
-        if (p1->vnn != p2->vnn)
-                return False;
-        return True;
-}
-
-bool cluster_id_equal(const struct server_id *id1,
-                      const struct server_id *id2)
-{
-        return procid_equal(id1, id2);
-}
-
-bool procid_is_me(const struct server_id *pid)
-{
-        if (pid->pid != sys_getpid())
-                return False;
-        if (pid->vnn != my_vnn)
-                return False;
-        return True;
+        return (uint32_t)-1;
 }
 
 struct server_id interpret_pid(const char *pid_string)
 {
-        struct server_id result;
-        int pid;
-        unsigned int vnn;
-        if (sscanf(pid_string, "%u:%d", &vnn, &pid) == 2) {
-                result.vnn = vnn;
-                result.pid = pid;
-        }
-        else if (sscanf(pid_string, "%d", &pid) == 1) {
-                result.vnn = get_my_vnn();
-                result.pid = pid;
-        }
-        else {
-                result.vnn = NONCLUSTER_VNN;
-                result.pid = -1;
-        }
-        /* Assigning to result.pid may have overflowed
-           Map negative pid to -1: i.e. error */
-        if (result.pid < 0) {
-                result.pid = -1;
-        }
-        result.unique_id = 0;
-        return result;
-}
-
-char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
-{
-        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);
-        }
-}
-
-char *procid_str_static(const struct server_id *pid)
-{
-        return procid_str(talloc_tos(), pid);
-}
-
-bool procid_valid(const struct server_id *pid)
-{
-        return (pid->pid != -1);
-}
-
-bool procid_is_local(const struct server_id *pid)
-{
-        return pid->vnn == my_vnn;
-}
-
-/****************************************************************
- Check if offset/length fit into bufsize. Should probably be
- merged with is_offset_safe, but this would require a rewrite
- of lanman.c. Later :-)
-****************************************************************/
-
-bool trans_oob(uint32_t bufsize, uint32_t offset, uint32_t length)
-{
-        if ((offset + length < offset) || (offset + length < length)) {
-                /* wrap */
-                return true;
-        }
-        if ((offset > bufsize) || (offset + length > bufsize)) {
-                /* overflow */
-                return true;
-        }
-        return false;
+        return server_id_from_string(get_my_vnn(), pid_string);
 }
 
@@ -2537 +1952 @@
 }
 
-#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.
-****************************************************************/
-
-#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)
-{
-        void *p;
-
-        if (size == 0) {
-                return NULL;
-        }
-
-        p = talloc_named_const(ctx, size, name);
-
-        if (p) {
-                memset(p, '\0', size);
-        }
-
-        return p;
-}
-
-/*
- *   memdup with a talloc.
- *   - returns NULL if size is zero.
- */
-
-void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
-{
-        void *newp;
-
-        if (size == 0) {
-                return NULL;
-        }
-
-        newp = talloc_named_const(t, size, name);
-        if (newp) {
-                memcpy(newp, p, size);
-        }
-
-        return newp;
-}
-
-/*
- *   alloc an array, checking for integer overflow in the array size.
- *   - returns NULL if count or el_size are zero.
- */
-
-void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
-{
-        if (count >= MAX_TALLOC_SIZE/el_size) {
-                return NULL;
-        }
-
-        if (el_size == 0 || count == 0) {
-                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) {
-                return NULL;
-        }
-
-        if (el_size == 0 || count == 0) {
-                return NULL;
-        }
-
-        return _talloc_zero(ctx, el_size * count, name);
-}
-
-/*
- *   Talloc wrapper that returns NULL if size == 0.
- */
-void *talloc_zeronull(const void *context, size_t size, const char *name)
-{
-        if (size == 0) {
-                return NULL;
-        }
-        return talloc_named_const(context, size, name);
-}
-#endif
-
 /****************************************************************
  strip off leading '\\' from a hostname
@@ -2660 +1970 @@
 
         return s;
-}
-
-bool tevent_req_poll_ntstatus(struct tevent_req *req,
-                              struct tevent_context *ev,
-                              NTSTATUS *status)
-{
-        bool ret = tevent_req_poll(req, ev);
-        if (!ret) {
-                *status = map_nt_error_from_unix(errno);
-        }
-        return ret;
 }
 
@@ -2748 +2047 @@
 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 *paccess_mask,
+                                 uint32_t *pshare_mode,
+                                 uint32_t *pcreate_disposition,
+                                 uint32_t *pcreate_options,
                                  uint32_t *pprivate_flags)
 {
-        uint32 access_mask;
-        uint32 share_mode;
-        uint32 create_disposition;
-        uint32 create_options = FILE_NON_DIRECTORY_FILE;
+        uint32_t access_mask;
+        uint32_t share_mode;
+        uint32_t create_disposition;
+        uint32_t create_options = FILE_NON_DIRECTORY_FILE;
         uint32_t private_flags = 0;
 
@@ -2888 +2187 @@
 
 }
+
+/*************************************************************************
+ Return a talloced copy of a struct security_unix_token. NULL on fail.
+*************************************************************************/
+
+struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
+{
+        struct security_unix_token *cpy;
+
+        cpy = talloc(ctx, struct security_unix_token);
+        if (!cpy) {
+                return NULL;
+        }
+
+        cpy->uid = tok->uid;
+        cpy->gid = tok->gid;
+        cpy->ngroups = tok->ngroups;
+        if (tok->ngroups) {
+                /* Make this a talloc child of cpy. */
+                cpy->groups = (gid_t *)talloc_memdup(
+                        cpy, tok->groups, tok->ngroups * sizeof(gid_t));
+                if (!cpy->groups) {
+                        TALLOC_FREE(cpy);
+                        return NULL;
+                }
+        } else {
+                cpy->groups = NULL;
+        }
+        return cpy;
+}
+
+/****************************************************************************
+ Check that a file matches a particular file type.
+****************************************************************************/
+
+bool dir_check_ftype(uint32_t mode, uint32_t dirtype)
+{
+        uint32_t mask;
+
+        /* Check the "may have" search bits. */
+        if (((mode & ~dirtype) &
+                        (FILE_ATTRIBUTE_HIDDEN |
+                         FILE_ATTRIBUTE_SYSTEM |
+                         FILE_ATTRIBUTE_DIRECTORY)) != 0) {
+                return false;
+        }
+
+        /* Check the "must have" bits,
+           which are the may have bits shifted eight */
+        /* If must have bit is set, the file/dir can
+           not be returned in search unless the matching
+           file attribute is set */
+        mask = ((dirtype >> 8) & (FILE_ATTRIBUTE_DIRECTORY|
+                                    FILE_ATTRIBUTE_ARCHIVE|
+                                   FILE_ATTRIBUTE_READONLY|
+                                     FILE_ATTRIBUTE_HIDDEN|
+                                     FILE_ATTRIBUTE_SYSTEM)); /* & 0x37 */
+        if(mask) {
+                if((mask & (mode & (FILE_ATTRIBUTE_DIRECTORY|
+                                      FILE_ATTRIBUTE_ARCHIVE|
+                                     FILE_ATTRIBUTE_READONLY|
+                                       FILE_ATTRIBUTE_HIDDEN|
+                                        FILE_ATTRIBUTE_SYSTEM))) == mask) {
+                        /* check if matching attribute present */
+                        return true;
+                } else {
+                        return false;
+                }
+        }
+
+        return true;
+}