Use shared util.c.

7 files changed, 196 insertions, 448 deletions

diff --git a/lib/util/config.mk b/lib/util/config.mk
index 6873c1bcc3..aa3c94ccae 100644
--- a/lib/util/config.mk
+++ b/lib/util/config.mk
@@ -18,6 +18,7 @@ LIBSAMBA-UTIL_OBJ_FILES = $(addprefix $(libutilsrcdir)/, \
 		util_file.o \
 		data_blob.o \
 		util.o \
+		util_net.o \
 		fsusage.o \
 		ms_fnmatch.o \
 		mutex.o \
diff --git a/lib/util/util.c b/lib/util/util.c
index 4c5ae973a1..fc55629c4c 100644
--- a/lib/util/util.c
+++ b/lib/util/util.c
@@ -25,6 +25,10 @@
 #include "system/network.h"
 #include "system/filesys.h"
 #include "system/locale.h"
+#undef malloc
+#undef strcasecmp
+#undef strdup
+#undef realloc
 
 /**
  * @file
@@ -217,112 +221,10 @@ _PUBLIC_ char *get_myname(void)
 }
 
 /**
- Return true if a string could be a pure IP address.
-**/
-
-_PUBLIC_ bool is_ipaddress(const char *str)
-{
-	bool pure_address = true;
-	int i;
-
-	if (str == NULL) return false;
-
-	for (i=0; pure_address && str[i]; i++)
-		if (!(isdigit((int)str[i]) || str[i] == '.'))
-			pure_address = false;
-
-	/* Check that a pure number is not misinterpreted as an IP */
-	pure_address = pure_address && (strchr(str, '.') != NULL);
-
-	return pure_address;
-}
-
-/**
- Interpret an internet address or name into an IP address in 4 byte form.
-**/
-_PUBLIC_ uint32_t interpret_addr(const char *str)
-{
-	struct hostent *hp;
-	uint32_t res;
-
-	if (str == NULL || *str == 0 ||
-	    strcmp(str,"0.0.0.0") == 0) {
-		return 0;
-	}
-	if (strcmp(str,"255.255.255.255") == 0) {
-		return 0xFFFFFFFF;
-	}
-	/* recognise 'localhost' as a special name. This fixes problems with
-	   some hosts that don't have localhost in /etc/hosts */
-	if (strcasecmp(str,"localhost") == 0) {
-		str = "127.0.0.1";
-	}
-
-	/* if it's in the form of an IP address then get the lib to interpret it */
-	if (is_ipaddress(str)) {
-		res = inet_addr(str);
-	} else {
-		/* otherwise assume it's a network name of some sort and use 
-			sys_gethostbyname */
-		if ((hp = sys_gethostbyname(str)) == 0) {
-			DEBUG(3,("sys_gethostbyname: Unknown host. %s\n",str));
-			return 0;
-		}
-
-		if(hp->h_addr == NULL) {
-			DEBUG(3,("sys_gethostbyname: host address is invalid for host %s\n",str));
-			return 0;
-		}
-		memcpy((char *)&res,(char *)hp->h_addr, 4);
-	}
-
-	if (res == (uint32_t)-1)
-		return(0);
-
-	return(res);
-}
-
-/**
- A convenient addition to interpret_addr().
-**/
-_PUBLIC_ struct in_addr interpret_addr2(const char *str)
-{
-	struct in_addr ret;
-	uint32_t a = interpret_addr(str);
-	ret.s_addr = a;
-	return ret;
-}
-
-/**
- Check if an IP is the 0.0.0.0.
-**/
-
-_PUBLIC_ bool is_zero_ip(struct in_addr ip)
-{
-	return ip.s_addr == 0;
-}
-
-/**
- Are two IPs on the same subnet?
-**/
-
-_PUBLIC_ bool same_net(struct in_addr ip1, struct in_addr ip2, struct in_addr mask)
-{
-	uint32_t net1,net2,nmask;
-
-	nmask = ntohl(mask.s_addr);
-	net1  = ntohl(ip1.s_addr);
-	net2  = ntohl(ip2.s_addr);
-            
-	return((net1 & nmask) == (net2 & nmask));
-}
-
-
-/**
  Check if a process exists. Does this work on all unixes?
 **/
 
-_PUBLIC_ bool process_exists(pid_t pid)
+_PUBLIC_ bool process_exists_by_pid(pid_t pid)
 {
 	/* Doing kill with a non-positive pid causes messages to be
 	 * sent to places we don't want. */
@@ -381,7 +283,7 @@ _PUBLIC_ bool fcntl_lock(int fd, int op, off_t offset, off_t count, int type)
 }
 
 
-static void print_asc(int level, const uint8_t *buf,int len)
+void print_asc(int level, const uint8_t *buf,int len)
 {
 	int i;
 	for (i=0;i<len;i++)
@@ -509,15 +411,64 @@ _PUBLIC_ void *smb_xmemdup(const void *p, size_t size)
  strdup that aborts on malloc fail.
 **/
 
-_PUBLIC_ char *smb_xstrdup(const char *s)
+char *smb_xstrdup(const char *s)
 {
+#if defined(PARANOID_MALLOC_CHECKER)
+#ifdef strdup
+#undef strdup
+#endif
+#endif
+
+#ifndef HAVE_STRDUP
+#define strdup rep_strdup
+#endif
+
 	char *s1 = strdup(s);
-	if (!s1)
-		smb_panic("smb_xstrdup: malloc fail\n");
+#if defined(PARANOID_MALLOC_CHECKER)
+#ifdef strdup
+#undef strdup
+#endif
+#define strdup(s) __ERROR_DONT_USE_STRDUP_DIRECTLY
+#endif
+	if (!s1) {
+		smb_panic("smb_xstrdup: malloc failed");
+	}
+	return s1;
+
+}
+
+/**
+ strndup that aborts on malloc fail.
+**/
+
+char *smb_xstrndup(const char *s, size_t n)
+{
+#if defined(PARANOID_MALLOC_CHECKER)
+#ifdef strndup
+#undef strndup
+#endif
+#endif
+
+#if (defined(BROKEN_STRNDUP) || !defined(HAVE_STRNDUP))
+#undef HAVE_STRNDUP
+#define strndup rep_strndup
+#endif
+
+	char *s1 = strndup(s, n);
+#if defined(PARANOID_MALLOC_CHECKER)
+#ifdef strndup
+#undef strndup
+#endif
+#define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
+#endif
+	if (!s1) {
+		smb_panic("smb_xstrndup: malloc failed");
+	}
 	return s1;
 }
 
 
+
 /**
  Like strdup but for memory.
 **/
diff --git a/lib/util/util_net.c b/lib/util/util_net.c
new file mode 100644
index 0000000000..7718d0208f
--- /dev/null
+++ b/lib/util/util_net.c
@@ -0,0 +1,128 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Samba utility functions
+   Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
+   Copyright (C) Andrew Tridgell 1992-1998
+   Copyright (C) Jeremy Allison 2001-2002
+   Copyright (C) Simo Sorce 2001
+   Copyright (C) Jim McDonough (jmcd@us.ibm.com)  2003.
+   Copyright (C) James J Myers 2003
+    
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+
+/**
+ Interpret an internet address or name into an IP address in 4 byte form.
+**/
+_PUBLIC_ uint32_t interpret_addr(const char *str)
+{
+	struct hostent *hp;
+	uint32_t res;
+
+	if (str == NULL || *str == 0 ||
+	    strcmp(str,"0.0.0.0") == 0) {
+		return 0;
+	}
+	if (strcmp(str,"255.255.255.255") == 0) {
+		return 0xFFFFFFFF;
+	}
+	/* recognise 'localhost' as a special name. This fixes problems with
+	   some hosts that don't have localhost in /etc/hosts */
+	if (strcasecmp(str,"localhost") == 0) {
+		str = "127.0.0.1";
+	}
+
+	/* if it's in the form of an IP address then get the lib to interpret it */
+	if (is_ipaddress(str)) {
+		res = inet_addr(str);
+	} else {
+		/* otherwise assume it's a network name of some sort and use 
+			sys_gethostbyname */
+		if ((hp = sys_gethostbyname(str)) == 0) {
+			DEBUG(3,("sys_gethostbyname: Unknown host. %s\n",str));
+			return 0;
+		}
+
+		if(hp->h_addr == NULL) {
+			DEBUG(3,("sys_gethostbyname: host address is invalid for host %s\n",str));
+			return 0;
+		}
+		memcpy((char *)&res,(char *)hp->h_addr, 4);
+	}
+
+	if (res == (uint32_t)-1)
+		return(0);
+
+	return(res);
+}
+
+/**
+ A convenient addition to interpret_addr().
+**/
+_PUBLIC_ struct in_addr interpret_addr2(const char *str)
+{
+	struct in_addr ret;
+	uint32_t a = interpret_addr(str);
+	ret.s_addr = a;
+	return ret;
+}
+
+/**
+ Check if an IP is the 0.0.0.0.
+**/
+
+_PUBLIC_ bool is_zero_ip(struct in_addr ip)
+{
+	return ip.s_addr == 0;
+}
+
+/**
+ Are two IPs on the same subnet?
+**/
+
+_PUBLIC_ bool same_net(struct in_addr ip1, struct in_addr ip2, struct in_addr mask)
+{
+	uint32_t net1,net2,nmask;
+
+	nmask = ntohl(mask.s_addr);
+	net1  = ntohl(ip1.s_addr);
+	net2  = ntohl(ip2.s_addr);
+            
+	return((net1 & nmask) == (net2 & nmask));
+}
+
+/**
+ Return true if a string could be a pure IP address.
+**/
+
+_PUBLIC_ bool is_ipaddress(const char *str)
+{
+	bool pure_address = true;
+	int i;
+
+	if (str == NULL) return false;
+
+	for (i=0; pure_address && str[i]; i++)
+		if (!(isdigit((int)str[i]) || str[i] == '.'))
+			pure_address = false;
+
+	/* Check that a pure number is not misinterpreted as an IP */
+	pure_address = pure_address && (strchr(str, '.') != NULL);
+
+	return pure_address;
+}
+
+
diff --git a/source3/Makefile.in b/source3/Makefile.in
index 2665b05999..44f06a6cae 100644
--- a/source3/Makefile.in
+++ b/source3/Makefile.in
@@ -333,7 +333,7 @@ LIB_OBJ = $(LIBSAMBAUTIL_OBJ) \
 	  ../lib/util/xfile.o ../lib/util/util_strlist.o lib/wins_srv.o \
 	  lib/util_str.o lib/clobber.o lib/util_sid.o lib/util_uuid.o \
 	  lib/util_unistr.o ../lib/util/util_file.o lib/util_file.o ../lib/util/data_blob.o \
-	  lib/util.o lib/util_sock.o lib/sock_exec.o lib/util_sec.o \
+	  lib/util.o ../lib/util/util.o lib/util_sock.o lib/sock_exec.o lib/util_sec.o \
 	  lib/substitute.o ../lib/util/fsusage.o lib/dbwrap_util.o \
 	  lib/ms_fnmatch.o lib/select.o lib/errmap_unix.o \
 	  lib/tallocmsg.o lib/dmallocmsg.o libsmb/smb_signing.o \
diff --git a/source3/include/proto.h b/source3/include/proto.h
index dd9f022e46..c03c34bc28 100644
--- a/source3/include/proto.h
+++ b/source3/include/proto.h
@@ -1232,10 +1232,10 @@ const char *tmpdir(void);
 bool add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
 			     gid_t **gids, size_t *num_gids);
 const char *get_numlist(const char *p, uint32 **num, int *count);
-bool file_exist(const char *fname,SMB_STRUCT_STAT *sbuf);
+bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf);
 bool socket_exist(const char *fname);
 time_t file_modtime(const char *fname);
-bool directory_exist(char *dname,SMB_STRUCT_STAT *st);
+bool directory_exist_stat(char *dname,SMB_STRUCT_STAT *st);
 SMB_OFF_T get_file_size(char *file_name);
 char *attrib_string(uint16 mode);
 void show_msg(char *buf);
@@ -1263,7 +1263,7 @@ void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
 			void *element, void *_array, uint32 *num_elements,
 			ssize_t *array_size);
 void safe_free(void *p);
-char *get_myname(TALLOC_CTX *ctx);
+char *get_myname_talloc(TALLOC_CTX *ctx);
 char *get_mydnsdomname(TALLOC_CTX *ctx);
 int interpret_protocol(const char *str,int def);
 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name);
diff --git a/source3/lib/util.c b/source3/lib/util.c
index 8c2b3feeca..1cdc5c8ac6 100644
--- a/source3/lib/util.c
+++ b/source3/lib/util.c
@@ -439,19 +439,6 @@ bool set_cmdline_auth_info_machine_account_creds(void)
 	return true;
 }
 
-/**************************************************************************n
- Find a suitable temporary directory. The result should be copied immediately
- as it may be overwritten by a subsequent call.
-****************************************************************************/
-
-const char *tmpdir(void)
-{
-	char *p;
-	if ((p = getenv("TMPDIR")))
-		return p;
-	return "/tmp";
-}
-
 /****************************************************************************
  Add a gid to an array of gids if it's not already there.
 ****************************************************************************/
@@ -540,7 +527,7 @@ const char *get_numlist(const char *p, uint32 **num, int *count)
  Check if a file exists - call vfs_file_exist for samba files.
 ********************************************************************/
 
-bool file_exist(const char *fname,SMB_STRUCT_STAT *sbuf)
+bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
 {
 	SMB_STRUCT_STAT st;
 	if (!sbuf)
@@ -566,24 +553,10 @@ bool socket_exist(const char *fname)
 }
 
 /*******************************************************************
- Check a files mod time.
-********************************************************************/
-
-time_t file_modtime(const char *fname)
-{
-	SMB_STRUCT_STAT st;
-  
-	if (sys_stat(fname,&st) != 0) 
-		return(0);
-
-	return(st.st_mtime);
-}
-
-/*******************************************************************
  Check if a directory exists.
 ********************************************************************/
 
-bool directory_exist(char *dname,SMB_STRUCT_STAT *st)
+bool directory_exist_stat(char *dname,SMB_STRUCT_STAT *st)
 {
 	SMB_STRUCT_STAT st2;
 	bool ret;
@@ -927,36 +900,6 @@ ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos
 #endif
 }
 
-/****************************************************************************
- Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
- else
-  if SYSV use O_NDELAY
-  if BSD use FNDELAY
-****************************************************************************/
-
-int set_blocking(int fd, bool set)
-{
-	int val;
-#ifdef O_NONBLOCK
-#define FLAG_TO_SET O_NONBLOCK
-#else
-#ifdef SYSV
-#define FLAG_TO_SET O_NDELAY
-#else /* BSD */
-#define FLAG_TO_SET FNDELAY
-#endif
-#endif
-
-	if((val = sys_fcntl_long(fd, F_GETFL, 0)) == -1)
-		return -1;
-	if(set) /* Turn blocking on - ie. clear nonblock flag */
-		val &= ~FLAG_TO_SET;
-	else
-		val |= FLAG_TO_SET;
-	return sys_fcntl_long( fd, F_SETFL, val);
-#undef FLAG_TO_SET
-}
-
 /*******************************************************************
  Sleep for a specified number of milliseconds.
 ********************************************************************/
@@ -1334,7 +1277,7 @@ void safe_free(void *p)
  Get my own name and IP.
 ****************************************************************************/
 
-char *get_myname(TALLOC_CTX *ctx)
+char *talloc_get_myname(TALLOC_CTX *ctx)
 {
 	char *p;
 	char hostname[HOST_NAME_MAX];
@@ -1549,14 +1492,6 @@ bool process_exists(const struct server_id pid)
 #endif
 }
 
-bool process_exists_by_pid(pid_t pid)
-{
-	/* Doing kill with a non-positive pid causes messages to be
-	 * sent to places we don't want. */
-	SMB_ASSERT(pid > 0);
-	return(kill(pid,0) == 0 || errno != ESRCH);
-}
-
 /*******************************************************************
  Convert a uid into a user name.
 ********************************************************************/
@@ -2003,42 +1938,6 @@ void free_namearray(name_compare_entry *name_array)
 #define DBGC_CLASS DBGC_LOCKING
 
 /****************************************************************************
- Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping
- is dealt with in posix.c
- Returns True if the lock was granted, False otherwise.
-****************************************************************************/
-
-bool fcntl_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
-{
-	SMB_STRUCT_FLOCK lock;
-	int ret;
-
-	DEBUG(8,("fcntl_lock fd=%d op=%d offset=%.0f count=%.0f type=%d\n",
-		fd,op,(double)offset,(double)count,type));
-
-	lock.l_type = type;
-	lock.l_whence = SEEK_SET;
-	lock.l_start = offset;
-	lock.l_len = count;
-	lock.l_pid = 0;
-
-	ret = sys_fcntl_ptr(fd,op,&lock);
-
-	if (ret == -1) {
-		int sav = errno;
-		DEBUG(3,("fcntl_lock: lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
-			(double)offset,(double)count,op,type,strerror(errno)));
-		errno = sav;
-		return False;
-	}
-
-	/* everything went OK */
-	DEBUG(8,("fcntl_lock: Lock call successful\n"));
-
-	return True;
-}
-
-/****************************************************************************
  Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
  is dealt with in posix.c
  Returns True if we have information regarding this lock region (and returns
@@ -2210,116 +2109,6 @@ enum remote_arch_types get_remote_arch(void)
 	return ra_type;
 }
 
-void print_asc(int level, const unsigned char *buf,int len)
-{
-	int i;
-	for (i=0;i<len;i++)
-		DEBUG(level,("%c", isprint(buf[i])?buf[i]:'.'));
-}
-
-/**
- * Write dump of binary data to the log file.
- *
- * The data is only written if the log level is at least level.
- */
-static void _dump_data(int level, const uint8_t *buf, int len,
-		       bool omit_zero_bytes)
-{
-	int i=0;
-	const uint8_t empty[16];
-	bool skipped = false;
-
-	if (len<=0) return;
-
-	if (!DEBUGLVL(level)) return;
-
-	memset(&empty, '\0', 16);
-
-	for (i=0;i<len;) {
-
-		if (i%16 == 0) {
-			if ((omit_zero_bytes == true) &&
-			    (i > 0) &&
-			    (len > i+16) &&
-			    (memcmp(&buf[i], &empty, 16) == 0))
-			{
-				i +=16;
-				continue;
-			}
-
-			if (i<len)  {
-				DEBUGADD(level,("[%04X] ",i));
-			}
-		}
-
-		DEBUGADD(level,("%02X ",(int)buf[i]));
-		i++;
-		if (i%8 == 0) DEBUGADD(level,("  "));
-		if (i%16 == 0) {
-
-			print_asc(level,&buf[i-16],8); DEBUGADD(level,(" "));
-			print_asc(level,&buf[i-8],8); DEBUGADD(level,("\n"));
-
-			if ((omit_zero_bytes == true) &&
-			    (len > i+16) &&
-			    (memcmp(&buf[i], &empty, 16) == 0)) {
-				if (!skipped) {
-					DEBUGADD(level,("skipping zero buffer bytes\n"));
-					skipped = true;
-				}
-			}
-		}
-	}
-
-	if (i%16) {
-		int n;
-		n = 16 - (i%16);
-		DEBUGADD(level,(" "));
-		if (n>8) DEBUGADD(level,(" "));
-		while (n--) DEBUGADD(level,("   "));
-		n = MIN(8,i%16);
-		print_asc(level,&buf[i-(i%16)],n); DEBUGADD(level,( " " ));
-		n = (i%16) - n;
-		if (n>0) print_asc(level,&buf[i-n],n);
-		DEBUGADD(level,("\n"));
-	}
-
-}
-
-/**
- * Write dump of binary data to the log file.
- *
- * The data is only written if the log level is at least level.
- */
-_PUBLIC_ void dump_data(int level, const uint8_t *buf, int len)
-{
-	_dump_data(level, buf, len, false);
-}
-
-/**
- * Write dump of binary data to the log file.
- *
- * The data is only written if the log level is at least level.
- * 16 zero bytes in a row are ommited
- */
-_PUBLIC_ void dump_data_skip_zeros(int level, const uint8_t *buf, int len)
-{
-	_dump_data(level, buf, len, true);
-}
-
-
-
-void dump_data_pw(const char *msg, const uchar * data, size_t len)
-{
-#ifdef DEBUG_PASSWORD
-	DEBUG(11, ("%s", msg));
-	if (data != NULL && len > 0)
-	{
-		dump_data(11, data, len);
-	}
-#endif
-}
-
 const char *tab_depth(int level, int depth)
 {
 	if( CHECK_DEBUGLVL(level) ) {
@@ -2484,78 +2273,6 @@ void *smb_xmalloc_array(size_t size, unsigned int count)
 	return p;
 }
 
-/**
- Memdup with smb_panic on fail.
-**/
-
-void *smb_xmemdup(const void *p, size_t size)
-{
-	void *p2;
-	p2 = SMB_XMALLOC_ARRAY(unsigned char,size);
-	memcpy(p2, p, size);
-	return p2;
-}
-
-/**
- strdup that aborts on malloc fail.
-**/
-
-char *smb_xstrdup(const char *s)
-{
-#if defined(PARANOID_MALLOC_CHECKER)
-#ifdef strdup
-#undef strdup
-#endif
-#endif
-
-#ifndef HAVE_STRDUP
-#define strdup rep_strdup
-#endif
-
-	char *s1 = strdup(s);
-#if defined(PARANOID_MALLOC_CHECKER)
-#ifdef strdup
-#undef strdup
-#endif
-#define strdup(s) __ERROR_DONT_USE_STRDUP_DIRECTLY
-#endif
-	if (!s1) {
-		smb_panic("smb_xstrdup: malloc failed");
-	}
-	return s1;
-
-}
-
-/**
- strndup that aborts on malloc fail.
-**/
-
-char *smb_xstrndup(const char *s, size_t n)
-{
-#if defined(PARANOID_MALLOC_CHECKER)
-#ifdef strndup
-#undef strndup
-#endif
-#endif
-
-#if (defined(BROKEN_STRNDUP) || !defined(HAVE_STRNDUP))
-#undef HAVE_STRNDUP
-#define strndup rep_strndup
-#endif
-
-	char *s1 = strndup(s, n);
-#if defined(PARANOID_MALLOC_CHECKER)
-#ifdef strndup
-#undef strndup
-#endif
-#define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
-#endif
-	if (!s1) {
-		smb_panic("smb_xstrndup: malloc failed");
-	}
-	return s1;
-}
-
 /*
   vasprintf that aborts on malloc fail
 */
@@ -2576,22 +2293,6 @@ char *smb_xstrndup(const char *s, size_t n)
 }
 
 /*****************************************************************
- Like strdup but for memory.
-*****************************************************************/
-
-void *memdup(const void *p, size_t size)
-{
-	void *p2;
-	if (size == 0)
-		return NULL;
-	p2 = SMB_MALLOC(size);
-	if (!p2)
-		return NULL;
-	memcpy(p2, p, size);
-	return p2;
-}
-
-/*****************************************************************
  Get local hostname and cache result.
 *****************************************************************/
 
@@ -2601,7 +2302,7 @@ char *myhostname(void)
 	if (ret == NULL) {
 		/* This is cached forever so
 		 * use NULL talloc ctx. */
-		ret = get_myname(NULL);
+		ret = talloc_get_myname(NULL);
 	}
 	return ret;
 }
@@ -2620,7 +2321,7 @@ static char *xx_path(const char *name, const char *rootpath)
 	}
 	trim_string(fname,"","/");
 
-	if (!directory_exist(fname,NULL)) {
+	if (!directory_exist_stat(fname,NULL)) {
 		mkdir(fname,0755);
 	}
 
@@ -3031,25 +2732,6 @@ bool name_to_fqdn(fstring fqdn, const char *name)
 }
 
 /**********************************************************************
- Extension to talloc_get_type: Abort on type mismatch
-***********************************************************************/
-
-void *talloc_check_name_abort(const void *ptr, const char *name)
-{
-	void *result;
-
-	result = talloc_check_name(ptr, name);
-	if (result != NULL)
-		return result;
-
-	DEBUG(0, ("Talloc type mismatch, expected %s, got %s\n",
-		  name, talloc_get_name(ptr)));
-	smb_panic("talloc type mismatch");
-	/* Keep the compiler happy */
-	return NULL;
-}
-
-/**********************************************************************
  Append a DATA_BLOB to a talloc'ed object
 ***********************************************************************/
 
diff --git a/source3/librpc/ndr/util.c b/source3/librpc/ndr/util.c
index 427292ac70..457615ce22 100644
--- a/source3/librpc/ndr/util.c
+++ b/source3/librpc/ndr/util.c
@@ -155,20 +155,6 @@ void ndr_print_server_id(struct ndr_print *ndr, const char *name, const struct s
 	ndr->depth--;
 }
 
-/**
- * see if a range of memory is all zero. A NULL pointer is considered
- * to be all zero 
- */
-bool all_zero(const uint8_t *ptr, size_t size)
- {
-	int i;
-	if (!ptr) return True;
-	for (i=0;i<size;i++) {
-		if (ptr[i]) return False;
-	}
-	return True;
-}
-
 _PUBLIC_ void ndr_print_bool(struct ndr_print *ndr, const char *name, const bool b)
 {
 	ndr->print(ndr, "%-25s: %s", name, b?"true":"false");