Changeset 740 for vendor/current/lib/util/util.c

Timestamp:

Nov 14, 2012, 12:59:34 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to 3.6.0

File:

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

vendor/current/lib/util/util.c

@@ -26 +26 @@
 #include "system/filesys.h"
 #include "system/locale.h"
+#include "system/shmem.h"
+
 #undef malloc
 #undef strcasecmp
@@ -31 +33 @@
 #undef strdup
 #undef realloc
+
+#if defined(UID_WRAPPER)
+#if !defined(UID_WRAPPER_REPLACE) && !defined(UID_WRAPPER_NOT_REPLACE)
+#define UID_WRAPPER_REPLACE
+#include "../uid_wrapper/uid_wrapper.h"
+#endif
+#else
+#define uwrap_enabled() 0
+#endif
 
 /**
@@ -155 +166 @@
 **/
 
-_PUBLIC_ void msleep(unsigned int t)
-{
-        struct timeval tval;  
-
-        tval.tv_sec = t/1000;
-        tval.tv_usec = 1000*(t%1000);
-        /* this should be the real select - do NOT replace
-           with sys_select() */
-        select(0,NULL,NULL,NULL,&tval);
+_PUBLIC_ void smb_msleep(unsigned int t)
+{
+#if defined(HAVE_NANOSLEEP)
+        struct timespec ts;
+        int ret;
+
+        ts.tv_sec = t/1000;
+        ts.tv_nsec = 1000000*(t%1000);
+
+        do {
+                errno = 0;
+                ret = nanosleep(&ts, &ts);
+        } while (ret < 0 && errno == EINTR && (ts.tv_sec > 0 || ts.tv_nsec > 0));
+#else
+        unsigned int tdiff=0;
+        struct timeval tval,t1,t2;
+        fd_set fds;
+
+        GetTimeOfDay(&t1);
+        t2 = t1;
+
+        while (tdiff < t) {
+                tval.tv_sec = (t-tdiff)/1000;
+                tval.tv_usec = 1000*((t-tdiff)%1000);
+
+                /* Never wait for more than 1 sec. */
+                if (tval.tv_sec > 1) {
+                        tval.tv_sec = 1;
+                        tval.tv_usec = 0;
+                }
+
+                FD_ZERO(&fds);
+                errno = 0;
+                select(0,&fds,NULL,NULL,&tval);
+
+                GetTimeOfDay(&t2);
+                if (t2.tv_sec < t1.tv_sec) {
+                        /* Someone adjusted time... */
+                        t1 = t2;
+                }
+
+                tdiff = usec_time_diff(&t2,&t1)/1000;
+        }
+#endif
 }
 
@@ -255 +301 @@
 }
 
+static void debugadd_cb(const char *buf, void *private_data)
+{
+        int *plevel = (int *)private_data;
+        DEBUGADD(*plevel, ("%s", buf));
+}
+
+void print_asc_cb(const uint8_t *buf, int len,
+                  void (*cb)(const char *buf, void *private_data),
+                  void *private_data)
+{
+        int i;
+        char s[2];
+        s[1] = 0;
+
+        for (i=0; i<len; i++) {
+                s[0] = isprint(buf[i]) ? buf[i] : '.';
+                cb(s, private_data);
+        }
+}
+
 void print_asc(int level, const uint8_t *buf,int len)
 {
-        int i;
-        for (i=0;i<len;i++)
-                DEBUGADD(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.
+        print_asc_cb(buf, len, debugadd_cb, &level);
+}
+
+/**
+ * Write dump of binary data to a callback
  */
-static void _dump_data(int level, const uint8_t *buf, int len,
-                       bool omit_zero_bytes)
+void dump_data_cb(const uint8_t *buf, int len,
+                  bool omit_zero_bytes,
+                  void (*cb)(const char *buf, void *private_data),
+                  void *private_data)
 {
         int i=0;
         static const uint8_t empty[16] = { 0, };
         bool skipped = false;
+        char tmp[16];
 
         if (len<=0) return;
-
-        if (!DEBUGLVL(level)) return;
 
         for (i=0;i<len;) {
@@ -291 +354 @@
 
                         if (i<len)  {
-                                DEBUGADD(level,("[%04X] ",i));
+                                snprintf(tmp, sizeof(tmp), "[%04X] ", i);
+                                cb(tmp, private_data);
                         }
                 }
 
-                DEBUGADD(level,("%02X ",(int)buf[i]));
+                snprintf(tmp, sizeof(tmp), "%02X ", (int)buf[i]);
+                cb(tmp, private_data);
                 i++;
-                if (i%8 == 0) DEBUGADD(level,("  "));
+                if (i%8 == 0) {
+                        cb("  ", private_data);
+                }
                 if (i%16 == 0) {
 
-                        print_asc(level,&buf[i-16],8); DEBUGADD(level,(" "));
-                        print_asc(level,&buf[i-8],8); DEBUGADD(level,("\n"));
+                        print_asc_cb(&buf[i-16], 8, cb, private_data);
+                        cb(" ", private_data);
+                        print_asc_cb(&buf[i-8], 8, cb, private_data);
+                        cb("\n", private_data);
 
                         if ((omit_zero_bytes == true) &&
@@ -307 +376 @@
                             (memcmp(&buf[i], &empty, 16) == 0)) {
                                 if (!skipped) {
-                                        DEBUGADD(level,("skipping zero buffer bytes\n"));
+                                        cb("skipping zero buffer bytes\n",
+                                           private_data);
                                         skipped = true;
                                 }
@@ -317 +387 @@
                 int n;
                 n = 16 - (i%16);
-                DEBUGADD(level,(" "));
-                if (n>8) DEBUGADD(level,(" "));
-                while (n--) DEBUGADD(level,("   "));
+                cb(" ", private_data);
+                if (n>8) {
+                        cb(" ", private_data);
+                }
+                while (n--) {
+                        cb("   ", private_data);
+                }
                 n = MIN(8,i%16);
-                print_asc(level,&buf[i-(i%16)],n); DEBUGADD(level,( " " ));
+                print_asc_cb(&buf[i-(i%16)], n, cb, private_data);
+                cb(" ", private_data);
                 n = (i%16) - n;
-                if (n>0) print_asc(level,&buf[i-n],n);
-                DEBUGADD(level,("\n"));
+                if (n>0) {
+                        print_asc_cb(&buf[i-n], n, cb, private_data);
+                }
+                cb("\n", private_data);
         }
 
@@ -336 +413 @@
 _PUBLIC_ void dump_data(int level, const uint8_t *buf, int len)
 {
-        _dump_data(level, buf, len, false);
+        if (!DEBUGLVL(level)) {
+                return;
+        }
+        dump_data_cb(buf, len, false, debugadd_cb, &level);
 }
 
@@ -343 +423 @@
  *
  * The data is only written if the log level is at least level.
- * 16 zero bytes in a row are ommited
+ * 16 zero bytes in a row are omitted
  */
 _PUBLIC_ void dump_data_skip_zeros(int level, const uint8_t *buf, int len)
 {
-        _dump_data(level, buf, len, true);
+        if (!DEBUGLVL(level)) {
+                return;
+        }
+        dump_data_cb(buf, len, true, debugadd_cb, &level);
 }
 
@@ -580 +663 @@
 _PUBLIC_ size_t strhex_to_str(char *p, size_t p_len, const char *strhex, size_t strhex_len)
 {
-        size_t i;
+        size_t i = 0;
         size_t num_chars = 0;
         uint8_t   lonybble, hinybble;
@@ -586 +669 @@
         char           *p1 = NULL, *p2 = NULL;
 
-        for (i = 0; i < strhex_len && strhex[i] != 0; i++) {
-                if (strncasecmp(hexchars, "0x", 2) == 0) {
-                        i++; /* skip two chars */
-                        continue;
-                }
-
+        /* skip leading 0x prefix */
+        if (strncasecmp(strhex, "0x", 2) == 0) {
+                i += 2; /* skip two chars */
+        }
+
+        for (; i < strhex_len && strhex[i] != 0; i++) {
                 if (!(p1 = strchr(hexchars, toupper((unsigned char)strhex[i]))))
                         break;
@@ -765 +848 @@
                                 bool ltrim)
 {
-        char *s;
-        char *saved_s;
+        const char *s;
+        const char *saved_s;
         char *pbuf;
         bool quoted;
@@ -776 +859 @@
         }
 
-        s = (char *)*ptr;
+        s = *ptr;
 
         /* default to simple separators */
@@ -854 +937 @@
 }
 
-
+/**
+ * Get the next token from a string, return False if none found.
+ * Handles double-quotes.
+ *
+ * Based on a routine by GJC@VILLAGE.COM.
+ * Extensively modified by Andrew.Tridgell@anu.edu.au
+ **/
+_PUBLIC_ bool next_token(const char **ptr,char *buff, const char *sep, size_t bufsize)
+{
+        const char *s;
+        bool quoted;
+        size_t len=1;
+
+        if (!ptr)
+                return false;
+
+        s = *ptr;
+
+        /* default to simple separators */
+        if (!sep)
+                sep = " \t\n\r";
+
+        /* find the first non sep char */
+        while (*s && strchr_m(sep,*s))
+                s++;
+
+        /* nothing left? */
+        if (!*s)
+                return false;
+
+        /* copy over the token */
+        for (quoted = false; len < bufsize && *s && (quoted || !strchr_m(sep,*s)); s++) {
+                if (*s == '\"') {
+                        quoted = !quoted;
+                } else {
+                        len++;
+                        *buff++ = *s;
+                }
+        }
+
+        *ptr = (*s) ? s+1 : s;
+        *buff = 0;
+
+        return true;
+}
+
+struct anonymous_shared_header {
+        union {
+                size_t length;
+                uint8_t pad[16];
+        } u;
+};
+
+/* Map a shared memory buffer of at least nelem counters. */
+void *anonymous_shared_allocate(size_t orig_bufsz)
+{
+        void *ptr;
+        void *buf;
+        size_t pagesz = getpagesize();
+        size_t pagecnt;
+        size_t bufsz = orig_bufsz;
+        struct anonymous_shared_header *hdr;
+
+        bufsz += sizeof(*hdr);
+
+        /* round up to full pages */
+        pagecnt = bufsz / pagesz;
+        if (bufsz % pagesz) {
+                pagecnt += 1;
+        }
+        bufsz = pagesz * pagecnt;
+
+        if (orig_bufsz >= bufsz) {
+                /* integer wrap */
+                errno = ENOMEM;
+                return NULL;
+        }
+
+#ifdef MAP_ANON
+        /* BSD */
+        buf = mmap(NULL, bufsz, PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED,
+                        -1 /* fd */, 0 /* offset */);
+#else
+        buf = mmap(NULL, bufsz, PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED,
+                        open("/dev/zero", O_RDWR), 0 /* offset */);
+#endif
+
+        if (buf == MAP_FAILED) {
+                return NULL;
+        }
+
+        hdr = (struct anonymous_shared_header *)buf;
+        hdr->u.length = bufsz;
+
+        ptr = (void *)(&hdr[1]);
+
+        return ptr;
+}
+
+void anonymous_shared_free(void *ptr)
+{
+        struct anonymous_shared_header *hdr;
+
+        if (ptr == NULL) {
+                return;
+        }
+
+        hdr = (struct anonymous_shared_header *)ptr;
+
+        hdr--;
+
+        munmap(hdr, hdr->u.length);
+}
+
+#ifdef DEVELOPER
+/* used when you want a debugger started at a particular point in the
+   code. Mostly useful in code that runs as a child process, where
+   normal gdb attach is harder to organise.
+*/
+void samba_start_debugger(void)
+{
+        char *cmd = NULL;
+        if (asprintf(&cmd, "xterm -e \"gdb --pid %u\"&", getpid()) == -1) {
+                return;
+        }
+        if (system(cmd) == -1) {
+                free(cmd);
+                return;
+        }
+        free(cmd);
+        sleep(2);
+}
+#endif