Use shared util.c.
authorJelmer Vernooij <jelmer@samba.org>
Fri, 17 Oct 2008 10:26:46 +0000 (12:26 +0200)
committerJelmer Vernooij <jelmer@samba.org>
Sat, 18 Oct 2008 12:27:13 +0000 (14:27 +0200)
lib/util/config.mk
lib/util/util.c
lib/util/util_net.c [new file with mode: 0644]
source3/Makefile.in
source3/include/proto.h
source3/lib/util.c
source3/librpc/ndr/util.c

index 6873c1bcc3056be86539d89c816de545aaabc708..aa3c94ccae8da59d6b7935fefec94103bb0086fc 100644 (file)
@@ -18,6 +18,7 @@ LIBSAMBA-UTIL_OBJ_FILES = $(addprefix $(libutilsrcdir)/, \
                util_file.o \
                data_blob.o \
                util.o \
                util_file.o \
                data_blob.o \
                util.o \
+               util_net.o \
                fsusage.o \
                ms_fnmatch.o \
                mutex.o \
                fsusage.o \
                ms_fnmatch.o \
                mutex.o \
index 4c5ae973a13ec9eb0fa8ac9e41424c4c567a2501..fc55629c4c1f1bfc4fd0d4908b36a52c06e8ade5 100644 (file)
 #include "system/network.h"
 #include "system/filesys.h"
 #include "system/locale.h"
 #include "system/network.h"
 #include "system/filesys.h"
 #include "system/locale.h"
+#undef malloc
+#undef strcasecmp
+#undef strdup
+#undef realloc
 
 /**
  * @file
 
 /**
  * @file
@@ -216,113 +220,11 @@ _PUBLIC_ char *get_myname(void)
        return hostname;
 }
 
        return hostname;
 }
 
-/**
- 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?
 **/
 
 /**
  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. */
 {
        /* 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++)
 {
        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.
 **/
 
  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);
        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;
 }
 
 
        return s1;
 }
 
 
+
 /**
  Like strdup but for memory.
 **/
 /**
  Like strdup but for memory.
 **/
diff --git a/lib/util/util_net.c b/lib/util/util_net.c
new file mode 100644 (file)
index 0000000..7718d02
--- /dev/null
@@ -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;
+}
+
+
index 2665b059991fc6f7cfa47497656ba0329a979608..44f06a6caececa6cf71ffb47d49c81f502de967b 100644 (file)
@@ -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/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 \
          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 \
index dd9f022e46662f00b2c1383ad070a0e980948263..c03c34bc28567c4ca34e13ccc8699a819069d9a8 100644 (file)
@@ -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 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 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);
 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);
                        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);
 char *get_mydnsdomname(TALLOC_CTX *ctx);
 int interpret_protocol(const char *str,int def);
 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name);
index 8c2b3feeca9605357377455b4f52277e10f79503..1cdc5c8ac6f7efa1185756320961ce6deb300230 100644 (file)
@@ -439,19 +439,6 @@ bool set_cmdline_auth_info_machine_account_creds(void)
        return true;
 }
 
        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.
 ****************************************************************************/
 /****************************************************************************
  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.
 ********************************************************************/
 
  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)
 {
        SMB_STRUCT_STAT st;
        if (!sbuf)
@@ -565,25 +552,11 @@ bool socket_exist(const char *fname)
        return S_ISSOCK(st.st_mode);
 }
 
        return S_ISSOCK(st.st_mode);
 }
 
-/*******************************************************************
- 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.
 ********************************************************************/
 
 /*******************************************************************
  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;
 {
        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
 }
 
 #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.
 ********************************************************************/
 /*******************************************************************
  Sleep for a specified number of milliseconds.
 ********************************************************************/
@@ -1334,7 +1277,7 @@ void safe_free(void *p)
  Get my own name and IP.
 ****************************************************************************/
 
  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];
 {
        char *p;
        char hostname[HOST_NAME_MAX];
@@ -1549,14 +1492,6 @@ bool process_exists(const struct server_id pid)
 #endif
 }
 
 #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.
 ********************************************************************/
 /*******************************************************************
  Convert a uid into a user name.
 ********************************************************************/
@@ -2002,42 +1937,6 @@ void free_namearray(name_compare_entry *name_array)
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_LOCKING
 
 #undef DBGC_CLASS
 #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
 /****************************************************************************
  Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
  is dealt with in posix.c
@@ -2210,116 +2109,6 @@ enum remote_arch_types get_remote_arch(void)
        return ra_type;
 }
 
        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) ) {
 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;
 }
 
        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
 */
 /*
   vasprintf that aborts on malloc fail
 */
@@ -2575,22 +2292,6 @@ char *smb_xstrndup(const char *s, size_t n)
        return n;
 }
 
        return 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.
 *****************************************************************/
 /*****************************************************************
  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. */
        if (ret == NULL) {
                /* This is cached forever so
                 * use NULL talloc ctx. */
-               ret = get_myname(NULL);
+               ret = talloc_get_myname(NULL);
        }
        return ret;
 }
        }
        return ret;
 }
@@ -2620,7 +2321,7 @@ static char *xx_path(const char *name, const char *rootpath)
        }
        trim_string(fname,"","/");
 
        }
        trim_string(fname,"","/");
 
-       if (!directory_exist(fname,NULL)) {
+       if (!directory_exist_stat(fname,NULL)) {
                mkdir(fname,0755);
        }
 
                mkdir(fname,0755);
        }
 
@@ -3030,25 +2731,6 @@ bool name_to_fqdn(fstring fqdn, const char *name)
        return true;
 }
 
        return true;
 }
 
-/**********************************************************************
- 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
 ***********************************************************************/
 /**********************************************************************
  Append a DATA_BLOB to a talloc'ed object
 ***********************************************************************/
index 427292ac7019819220ad3a7fe64d7c1b77e3cc51..457615ce22320fe2aabb4fdd4fef9f056425e8c0 100644 (file)
@@ -155,20 +155,6 @@ void ndr_print_server_id(struct ndr_print *ndr, const char *name, const struct s
        ndr->depth--;
 }
 
        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");
 _PUBLIC_ void ndr_print_bool(struct ndr_print *ndr, const char *name, const bool b)
 {
        ndr->print(ndr, "%-25s: %s", name, b?"true":"false");