Changeset 740 for vendor/current/lib/util

vendor/current/lib/util/asn1.c

-              r597
+              r740
+}
 bool ber_write_OID_String(DATA_BLOB *blob, const char *OID)
+{
         uint_t v, v2;
+bool ber_write_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *OID)
+{
+        unsigned int v, v2;
         const char *p = (const char *)OID;
         char *newp;
         int i;
+        if (!isdigit(*p)) return false;
         v = strtoul(p, &newp, 10);
         if (newp[0] != '.') return false;
         p = newp + 1;
+        if (!isdigit(*p)) return false;
         v2 = strtoul(p, &newp, 10);
         if (newp[0] != '.') return false;
 …
         /*the ber representation can't use more space then the string one */
         *blob = data_blob(NULL, strlen(OID));
+        *blob = data_blob_talloc(mem_ctx, NULL, strlen(OID));
         if (!blob->data) return false;
 …
         i = 1;
         while (*p) {
+                if (!isdigit(*p)) return false;
                 v = strtoul(p, &newp, 10);
                 if (newp[0] == '.') {
                         p = newp + 1;
+                        /* check for empty last component */
+                        if (!*p) return false;
                 } else if (newp[0] == '\0') {
                         p = newp;
 …
+}
+/**
+ * Serialize partial OID string.
+ * Partial OIDs are in the form:
+ *   1:2.5.6:0x81
+ *   1:2.5.6:0x8182
+ */
+bool ber_write_partial_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *partial_oid)
+{
+        TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
+        char *oid = talloc_strdup(tmp_ctx, partial_oid);
+        char *p;
+        /* truncate partial part so ber_write_OID_String() works */
+        p = strchr(oid, ':');
+        if (p) {
+                *p = '\0';
+                p++;
+        }
+        if (!ber_write_OID_String(mem_ctx, blob, oid)) {
+                talloc_free(tmp_ctx);
+                return false;
+        }
+        /* Add partially encoded sub-identifier */
+        if (p) {
+                DATA_BLOB tmp_blob = strhex_to_data_blob(tmp_ctx, p);
+                if (!data_blob_append(mem_ctx, blob, tmp_blob.data,
+                                      tmp_blob.length)) {
+                        talloc_free(tmp_ctx);
+                        return false;
+                }
+        }
+        talloc_free(tmp_ctx);
+        return true;
+}
 /* write an object ID to a ASN1 buffer */
 bool asn1_write_OID(struct asn1_data *data, const char *OID)
 …
         if (!asn1_push_tag(data, ASN1_OID)) return false;
         if (!ber_write_OID_String(&blob, OID)) {
+        if (!ber_write_OID_String(NULL, &blob, OID)) {
                 data->has_error = true;
                 return false;
 …
         return (b == tag);
+}
+/*
+ * just get the needed size the tag would consume
+ */
+bool asn1_peek_tag_needed_size(struct asn1_data *data, uint8_t tag, size_t *size)
+{
+        off_t start_ofs = data->ofs;
+        uint8_t b;
+        size_t taglen = 0;
+        if (data->has_error) {
+                return false;
+        }
+        if (!asn1_read_uint8(data, &b)) {
+                data->ofs = start_ofs;
+                data->has_error = false;
+                return false;
+        }
+        if (b != tag) {
+                data->ofs = start_ofs;
+                data->has_error = false;
+                return false;
+        }
+        if (!asn1_read_uint8(data, &b)) {
+                data->ofs = start_ofs;
+                data->has_error = false;
+                return false;
+        }
+        if (b & 0x80) {
+                int n = b & 0x7f;
+                if (!asn1_read_uint8(data, &b)) {
+                        data->ofs = start_ofs;
+                        data->has_error = false;
+                        return false;
+                }
+                if (n > 4) {
+                        /*
+                         * We should not allow more than 4 bytes
+                         * for the encoding of the tag length.
+                         *
+                         * Otherwise we'd overflow the taglen
+                         * variable on 32 bit systems.
+                         */
+                        data->ofs = start_ofs;
+                        data->has_error = false;
+                        return false;
+                }
+                taglen = b;
+                while (n > 1) {
+                        if (!asn1_read_uint8(data, &b)) {
+                                data->ofs = start_ofs;
+                                data->has_error = false;
+                                return false;
+                        }
+                        taglen = (taglen << 8) | b;
+                        n--;
+                }
+        } else {
+                taglen = b;
+        }
+        *size = (data->ofs - start_ofs) + taglen;
+        data->ofs = start_ofs;
+        data->has_error = false;
+        return true;
+}
 …
+}
+/* read an object ID from a data blob */
+bool ber_read_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, const char **OID)
+/**
+ * Internal implementation for reading binary OIDs
+ * Reading is done as far in the buffer as valid OID
+ * till buffer ends or not valid sub-identifier is found.
+ */
+static bool _ber_read_OID_String_impl(TALLOC_CTX *mem_ctx, DATA_BLOB blob,
+                                      char **OID, size_t *bytes_eaten)
+{
         int i;
         uint8_t *b;
         uint_t v;
+        unsigned int v;
         char *tmp_oid = NULL;
 …
         tmp_oid = talloc_asprintf_append_buffer(tmp_oid, ".%u",  b[0]%40);
         if (!tmp_oid) goto nomem;
+        if (bytes_eaten != NULL) {
+                *bytes_eaten = 0;
+        }
         for(i = 1, v = 0; i < blob.length; i++) {
 …
                         tmp_oid = talloc_asprintf_append_buffer(tmp_oid, ".%u",  v);
                         v = 0;
+                        if (bytes_eaten)
+                                *bytes_eaten = i+1;
+                }
                 if (!tmp_oid) goto nomem;
+        }
-        if (v != 0) {
-                talloc_free(tmp_oid);
-                return false;
+        }
         *OID = tmp_oid;
         return true;
 nomem:
+nomem:
         return false;
+}
+/* read an object ID from a data blob */
+bool ber_read_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, char **OID)
+{
+        size_t bytes_eaten;
+        if (!_ber_read_OID_String_impl(mem_ctx, blob, OID, &bytes_eaten))
+                return false;
+        return (bytes_eaten == blob.length);
+}
+/**
+ * Deserialize partial OID string.
+ * Partial OIDs are in the form:
+ *   1:2.5.6:0x81
+ *   1:2.5.6:0x8182
+ */
+bool ber_read_partial_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob,
+                                 char **partial_oid)
+{
+        size_t bytes_left;
+        size_t bytes_eaten;
+        char *identifier = NULL;
+        char *tmp_oid = NULL;
+        if (!_ber_read_OID_String_impl(mem_ctx, blob, &tmp_oid, &bytes_eaten))
+                return false;
+        if (bytes_eaten < blob.length) {
+                bytes_left = blob.length - bytes_eaten;
+                identifier = hex_encode_talloc(mem_ctx, &blob.data[bytes_eaten], bytes_left);
+                if (!identifier)        goto nomem;
+                *partial_oid = talloc_asprintf_append_buffer(tmp_oid, ":0x%s", identifier);
+                if (!*partial_oid)      goto nomem;
+                TALLOC_FREE(identifier);
+        } else {
+                *partial_oid = tmp_oid;
+        }
+        return true;
+nomem:
+        TALLOC_FREE(identifier);
+        TALLOC_FREE(tmp_oid);
+        return false;
+}
 /* read an object ID from a ASN1 buffer */
 bool asn1_read_OID(struct asn1_data *data, TALLOC_CTX *mem_ctx, const char **OID)
+bool asn1_read_OID(struct asn1_data *data, TALLOC_CTX *mem_ctx, char **OID)
+{
         DATA_BLOB blob;
 …
 bool asn1_check_OID(struct asn1_data *data, const char *OID)
+{
         const char *id;
+        char *id;
         if (!asn1_read_OID(data, data, &id)) return false;
         if (strcmp(id, OID) != 0) {
                 talloc_free(discard_const(id));
                 data->has_error = true;
                 return false;
+        }
         talloc_free(discard_const(id));
+                talloc_free(id);
+                data->has_error = true;
+                return false;
+        }
+        talloc_free(id);
         return true;
+}
 …
         if (size > blob.length) {
                 return STATUS_MORE_ENTRIES;
+        }
+        }
         *packet_size = size;
         return NT_STATUS_OK;
+}
+NTSTATUS asn1_peek_full_tag(DATA_BLOB blob, uint8_t tag, size_t *packet_size)
+{
+        struct asn1_data asn1;
+        size_t size;
+        bool ok;
+        ZERO_STRUCT(asn1);
+        asn1.data = blob.data;
+        asn1.length = blob.length;
+        ok = asn1_peek_tag_needed_size(&asn1, tag, &size);
+        if (!ok) {
+                return NT_STATUS_INVALID_BUFFER_SIZE;
+        }
+        if (size > blob.length) {
+                *packet_size = size;
+                return STATUS_MORE_ENTRIES;
+        }
+        *packet_size = size;
+        return NT_STATUS_OK;
+}

vendor/current/lib/util/asn1.h

-              r414
+              r740
 bool asn1_write_Integer(struct asn1_data *data, int i);
 bool asn1_write_BitString(struct asn1_data *data, const void *p, size_t length, uint8_t padding);
+bool ber_write_OID_String(DATA_BLOB *blob, const char *OID);
+bool ber_write_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *OID);
+bool ber_write_partial_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *partial_oid);
 bool asn1_write_OID(struct asn1_data *data, const char *OID);
 bool asn1_write_OctetString(struct asn1_data *data, const void *p, size_t length);
 …
 bool asn1_read_uint8(struct asn1_data *data, uint8_t *v);
 bool asn1_peek_uint8(struct asn1_data *data, uint8_t *v);
+bool asn1_peek_tag_needed_size(struct asn1_data *data, uint8_t tag, size_t *size);
 bool asn1_peek_tag(struct asn1_data *data, uint8_t tag);
 bool asn1_start_tag(struct asn1_data *data, uint8_t tag);
 bool asn1_end_tag(struct asn1_data *data);
 int asn1_tag_remaining(struct asn1_data *data);
+bool ber_read_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, const char **OID);
+bool asn1_read_OID(struct asn1_data *data, TALLOC_CTX *mem_ctx, const char **OID);
+bool ber_read_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, char **OID);
+bool ber_read_partial_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, char **partial_oid);
+bool asn1_read_OID(struct asn1_data *data, TALLOC_CTX *mem_ctx, char **OID);
 bool asn1_check_OID(struct asn1_data *data, const char *OID);
 bool asn1_read_LDAPString(struct asn1_data *data, TALLOC_CTX *mem_ctx, char **s);
 …
 void asn1_load_nocopy(struct asn1_data *data, uint8_t *buf, size_t len);
 NTSTATUS asn1_full_tag(DATA_BLOB blob, uint8_t tag, size_t *packet_size);
+NTSTATUS asn1_peek_full_tag(DATA_BLOB blob, uint8_t tag, size_t *packet_size);
 #endif /* _ASN_1_H */

vendor/current/lib/util/attr.h

-              r414
+              r740
 #  define UNUSED(param) param
 /** Feel free to add definitions for other compilers here. */
-#endif
-#ifdef HAVE_VISIBILITY_ATTR
-#  define _PUBLIC_ __attribute__((visibility("default")))
-#else
-#  define _PUBLIC_
 #endif
 …
 #endif
+#ifndef FORMAT_ATTRIBUTE
+#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
+/** Use gcc attribute to check printf fns.  a1 is argument to format()
+ * in the above macro.  This is needed to support Heimdal's printf
+ * decorations. Note that some gcc 2.x versions don't handle this
+ * properly, and as such I've used the same minimum from heimdal: GCC 3.1 **/
+#define FORMAT_ATTRIBUTE(a) __attribute__ ((format a))
+#else
+#define FORMAT_ATTRIBUTE(a)
+#endif
+#endif
 #endif /* __UTIL_ATTR_H__ */

vendor/current/lib/util/become_daemon.c

-              r414
+              r740
 ****************************************************************************/
 _PUBLIC_ void become_daemon(bool do_fork, bool no_process_group)
+_PUBLIC_ void become_daemon(bool do_fork, bool no_process_group, bool log_stdout)
+{
         if (do_fork) {
 …
 #endif /* HAVE_SETSID */
+        /* Close fd's 0,1,2. Needed if started by rsh */
+        close_low_fds(false);  /* Don't close stderr, let the debug system
+                                  attach it to the logfile */
+        if (!log_stdout) {
+                /* Close fd's 0,1,2. Needed if started by rsh */
+                close_low_fds(false);  /* Don't close stderr, let the debug system
+                                          attach it to the logfile */
+        }
+}

vendor/current/lib/util/binsearch.h

-              r414
+              r740
         }} } while (0)
+/*
+  like BINARY_ARRAY_SEARCH_P, but assumes that the array is an array
+  of elements, rather than pointers to structures
+  result points to the found structure, or NULL
+ */
+#define BINARY_ARRAY_SEARCH_V(array, array_size, target, comparison_fn, result) do { \
+        int32_t _b, _e; \
+        (result) = NULL; \
+        if (array_size) { for (_b = 0, _e = (array_size)-1; _b <= _e; ) {       \
+                int32_t _i = (_b+_e)/2; \
+                int _r = comparison_fn(target, array[_i]); \
+                if (_r == 0) { (result) = &array[_i]; break; } \
+                if (_r < 0) _e = _i - 1; else _b = _i + 1; \
+        }} } while (0)
 #endif

vendor/current/lib/util/byteorder.h

-              r414
+              r740
 #define CVAL(buf,pos) (((uint8_t *)(buf))[pos])
 #define PVAL(buf,pos) ((uint_t)CVAL(buf,pos))
+#define PVAL(buf,pos) ((unsigned int)CVAL(buf,pos))
 #define SVAL(buf,pos) (PVAL(buf,pos)|PVAL(buf,(pos)+1)<<8)
 …
 #endif
 #define CVAL(buf,pos) ((uint_t)(((const uint8_t *)(buf))[pos]))
+#define CVAL(buf,pos) ((unsigned int)(((const uint8_t *)(buf))[pos]))
 #define CVAL_NC(buf,pos) (((uint8_t *)(buf))[pos]) /* Non-const version of CVAL */
 #define PVAL(buf,pos) (CVAL(buf,pos))
 …
 /* get single value from an SMB buffer */
 #define SVAL(buf,pos) (*(const uint16_t *)((const char *)(buf) + (pos)))
 #define SVAL_NC(buf,pos) (*(uint16_t *)((char *)(buf) + (pos))) /* Non const version of above. */
+#define SVAL_NC(buf,pos) (*(uint16_t *)((void *)((char *)(buf) + (pos)))) /* Non const version of above. */
 #define IVAL(buf,pos) (*(const uint32_t *)((const char *)(buf) + (pos)))
 #define IVAL_NC(buf,pos) (*(uint32_t *)((char *)(buf) + (pos))) /* Non const version of above. */
+#define IVAL_NC(buf,pos) (*(uint32_t *)((void *)((char *)(buf) + (pos)))) /* Non const version of above. */
 #define SVALS(buf,pos) (*(const int16_t *)((const char *)(buf) + (pos)))
 #define SVALS_NC(buf,pos) (*(int16_t *)((char *)(buf) + (pos))) /* Non const version of above. */
+#define SVALS_NC(buf,pos) (*(int16_t *)((void *)((char *)(buf) + (pos)))) /* Non const version of above. */
 #define IVALS(buf,pos) (*(const int32_t *)((const char *)(buf) + (pos)))
 #define IVALS_NC(buf,pos) (*(int32_t *)((char *)(buf) + (pos))) /* Non const version of above. */
+#define IVALS_NC(buf,pos) (*(int32_t *)((void *)((char *)(buf) + (pos)))) /* Non const version of above. */
 /* store single value in an SMB buffer */
 …
 #endif /* not CAREFUL_ALIGNMENT */
-/* now the reverse routines - these are used in nmb packets (mostly) */
-#define SREV(x) ((((x)&0xFF)<<8) | (((x)>>8)&0xFF))
-#define IREV(x) ((SREV(x)<<16) | (SREV((x)>>16)))
-#define RSVAL(buf,pos) SREV(SVAL(buf,pos))
-#define RSVALS(buf,pos) SREV(SVALS(buf,pos))
-#define RIVAL(buf,pos) IREV(IVAL(buf,pos))
-#define RIVALS(buf,pos) IREV(IVALS(buf,pos))
-#define RSSVAL(buf,pos,val) SSVAL(buf,pos,SREV(val))
-#define RSSVALS(buf,pos,val) SSVALS(buf,pos,SREV(val))
-#define RSIVAL(buf,pos,val) SIVAL(buf,pos,IREV(val))
-#define RSIVALS(buf,pos,val) SIVALS(buf,pos,IREV(val))
-/* Alignment macros. */
-#define ALIGN4(p,base) ((p) + ((4 - (PTR_DIFF((p), (base)) & 3)) & 3))
-#define ALIGN2(p,base) ((p) + ((2 - (PTR_DIFF((p), (base)) & 1)) & 1))
-/* macros for accessing SMB protocol elements */
-#define VWV(vwv) ((vwv)*2)
 /* 64 bit macros */
 #define BVAL(p, ofs) (IVAL(p,ofs) | (((uint64_t)IVAL(p,(ofs)+4)) << 32))
 …
 #define SBVALS(p, ofs, v) (SBVAL(p,ofs,(uint64_t)v))
+/* now the reverse routines - these are used in nmb packets (mostly) */
+#define SREV(x) ((((x)&0xFF)<<8) | (((x)>>8)&0xFF))
+#define IREV(x) ((SREV(x)<<16) | (SREV((x)>>16)))
+#define BREV(x) ((IREV(x)<<32) | (IREV((x)>>32)))
+#define RSVAL(buf,pos) SREV(SVAL(buf,pos))
+#define RSVALS(buf,pos) SREV(SVALS(buf,pos))
+#define RIVAL(buf,pos) IREV(IVAL(buf,pos))
+#define RIVALS(buf,pos) IREV(IVALS(buf,pos))
+#define RBVAL(buf,pos) BREV(BVAL(buf,pos))
+#define RBVALS(buf,pos) BREV(BVALS(buf,pos))
+#define RSSVAL(buf,pos,val) SSVAL(buf,pos,SREV(val))
+#define RSSVALS(buf,pos,val) SSVALS(buf,pos,SREV(val))
+#define RSIVAL(buf,pos,val) SIVAL(buf,pos,IREV(val))
+#define RSIVALS(buf,pos,val) SIVALS(buf,pos,IREV(val))
+#define RSBVAL(buf,pos,val) SBVAL(buf,pos,BREV(val))
+#define RSBVALS(buf,pos,val) SBVALS(buf,pos,BREV(val))
+/* Alignment macros. */
+#define ALIGN4(p,base) ((p) + ((4 - (PTR_DIFF((p), (base)) & 3)) & 3))
+#define ALIGN2(p,base) ((p) + ((2 - (PTR_DIFF((p), (base)) & 1)) & 1))
+/* macros for accessing SMB protocol elements */
+#define VWV(vwv) ((vwv)*2)
 #endif /* _BYTEORDER_H */

vendor/current/lib/util/charset/charcnv.c

-              r414
+              r740
  */
-struct smb_iconv_convenience {
-        const char *unix_charset;
-        const char *dos_charset;
-        bool native_iconv;
-        smb_iconv_t conv_handles[NUM_CHARSETS][NUM_CHARSETS];
-};
-/**
- * Return the name of a charset to give to iconv().
- **/
-static const char *charset_name(struct smb_iconv_convenience *ic, charset_t ch)
+{
-        switch (ch) {
-        case CH_UTF16: return "UTF-16LE";
-        case CH_UNIX: return ic->unix_charset;
-        case CH_DOS: return ic->dos_charset;
-        case CH_UTF8: return "UTF8";
-        case CH_UTF16BE: return "UTF-16BE";
-        case CH_UTF16MUNGED: return "UTF16_MUNGED";
-        default:
-        return "ASCII";
+        }
+}
-/**
- re-initialize iconv conversion descriptors
-**/
-static int close_iconv_convenience(struct smb_iconv_convenience *data)
+{
-        unsigned c1, c2;
-        for (c1=0;c1<NUM_CHARSETS;c1++) {
-                for (c2=0;c2<NUM_CHARSETS;c2++) {
-                        if (data->conv_handles[c1][c2] != NULL) {
-                                if (data->conv_handles[c1][c2] != (smb_iconv_t)-1) {
-                                        smb_iconv_close(data->conv_handles[c1][c2]);
+                                }
-                                data->conv_handles[c1][c2] = NULL;
+                        }
+                }
+        }
-        return 0;
+}
-_PUBLIC_ struct smb_iconv_convenience *smb_iconv_convenience_init(TALLOC_CTX *mem_ctx,
-                                                         const char *dos_charset,
-                                                         const char *unix_charset,
-                                                         bool native_iconv)
+{
-        struct smb_iconv_convenience *ret = talloc_zero(mem_ctx,
-                                        struct smb_iconv_convenience);
-        if (ret == NULL) {
-                return NULL;
+        }
-        talloc_set_destructor(ret, close_iconv_convenience);
-        ret->dos_charset = talloc_strdup(ret, dos_charset);
-        ret->unix_charset = talloc_strdup(ret, unix_charset);
-        ret->native_iconv = native_iconv;
-        return ret;
+}
-/*
-  on-demand initialisation of conversion handles
-*/
-static smb_iconv_t get_conv_handle(struct smb_iconv_convenience *ic,
-                                   charset_t from, charset_t to)
+{
-        const char *n1, *n2;
-        static bool initialised;
-        if (initialised == false) {
-                initialised = true;
-#ifdef LC_ALL
-                /* we set back the locale to C to get ASCII-compatible
-                   toupper/lower functions.  For now we do not need
-                   any other POSIX localisations anyway. When we
-                   should really need localized string functions one
-                   day we need to write our own ascii_tolower etc.
-                */
-                setlocale(LC_ALL, "C");
-#endif
+        }
-        if (ic->conv_handles[from][to]) {
-                return ic->conv_handles[from][to];
+        }
-        n1 = charset_name(ic, from);
-        n2 = charset_name(ic, to);
-        ic->conv_handles[from][to] = smb_iconv_open_ex(ic, n2, n1,
-                                                       ic->native_iconv);
-        if (ic->conv_handles[from][to] == (smb_iconv_t)-1) {
-                if ((from == CH_DOS || to == CH_DOS) &&
-                    strcasecmp(charset_name(ic, CH_DOS), "ASCII") != 0) {
-                        DEBUG(0,("dos charset '%s' unavailable - using ASCII\n",
-                                 charset_name(ic, CH_DOS)));
-                        ic->dos_charset = "ASCII";
-                        n1 = charset_name(ic, from);
-                        n2 = charset_name(ic, to);
-                        ic->conv_handles[from][to] =
-                                smb_iconv_open_ex(ic, n2, n1, ic->native_iconv);
+                }
+        }
-        return ic->conv_handles[from][to];
+}
 /**
  * Convert string from one encoding to another, making error checking etc
 …
                                 break;
+                }
+                DEBUG(0,("Conversion error: %s(%s)\n",reason,inbuf));
+                DEBUG(0,("Conversion error: %s - ",reason));
+                dump_data(0, (const uint8_t *) inbuf, i_len);
                 talloc_free(ob);
                 return (size_t)-1;
 …
+}
-/*
-  return the unicode codepoint for the next multi-byte CH_UNIX character
-  in the string
-  also return the number of bytes consumed (which tells the caller
-  how many bytes to skip to get to the next CH_UNIX character)
-  return INVALID_CODEPOINT if the next character cannot be converted
-*/
-_PUBLIC_ codepoint_t next_codepoint_convenience(struct smb_iconv_convenience *ic,
-                                    const char *str, size_t *size)
+{
-        /* it cannot occupy more than 4 bytes in UTF16 format */
-        uint8_t buf[4];
-        smb_iconv_t descriptor;
-        size_t ilen_orig;
-        size_t ilen;
-        size_t olen;
-        char *outbuf;
-        if ((str[0] & 0x80) == 0) {
-                *size = 1;
-                return (codepoint_t)str[0];
+        }
-        /* we assume that no multi-byte character can take
-           more than 5 bytes. This is OK as we only
-           support codepoints up to 1M */
-        ilen_orig = strnlen(str, 5);
-        ilen = ilen_orig;
-        descriptor = get_conv_handle(ic, CH_UNIX, CH_UTF16);
-        if (descriptor == (smb_iconv_t)-1) {
-                *size = 1;
-                return INVALID_CODEPOINT;
+        }
-        /* this looks a little strange, but it is needed to cope
-           with codepoints above 64k */
-        olen = 2;
-        outbuf = (char *)buf;
-        smb_iconv(descriptor, &str, &ilen, &outbuf, &olen);
-        if (olen == 2) {
-                olen = 4;
-                outbuf = (char *)buf;
-                smb_iconv(descriptor,  &str, &ilen, &outbuf, &olen);
-                if (olen == 4) {
-                        /* we didn't convert any bytes */
-                        *size = 1;
-                        return INVALID_CODEPOINT;
+                }
-                olen = 4 - olen;
-        } else {
-                olen = 2 - olen;
+        }
-        *size = ilen_orig - ilen;
-        if (olen == 2) {
-                return (codepoint_t)SVAL(buf, 0);
+        }
-        if (olen == 4) {
-                /* decode a 4 byte UTF16 character manually */
-                return (codepoint_t)0x10000 +
-                        (buf[2] | ((buf[3] & 0x3)<<8) |
-                         (buf[0]<<10) | ((buf[1] & 0x3)<<18));
+        }
-        /* no other length is valid */
-        return INVALID_CODEPOINT;
+}
-/*
-  push a single codepoint into a CH_UNIX string the target string must
-  be able to hold the full character, which is guaranteed if it is at
-  least 5 bytes in size. The caller may pass less than 5 bytes if they
-  are sure the character will fit (for example, you can assume that
-  uppercase/lowercase of a character will not add more than 1 byte)
-  return the number of bytes occupied by the CH_UNIX character, or
-  -1 on failure
-*/
-_PUBLIC_ ssize_t push_codepoint_convenience(struct smb_iconv_convenience *ic,
-                                char *str, codepoint_t c)
+{
-        smb_iconv_t descriptor;
-        uint8_t buf[4];
-        size_t ilen, olen;
-        const char *inbuf;
-        if (c < 128) {
-                *str = c;
-                return 1;
+        }
-        descriptor = get_conv_handle(ic,
-                                     CH_UTF16, CH_UNIX);
-        if (descriptor == (smb_iconv_t)-1) {
-                return -1;
+        }
-        if (c < 0x10000) {
-                ilen = 2;
-                olen = 5;
-                inbuf = (char *)buf;
-                SSVAL(buf, 0, c);
-                smb_iconv(descriptor, &inbuf, &ilen, &str, &olen);
-                if (ilen != 0) {
-                        return -1;
+                }
-                return 5 - olen;
+        }
-        c -= 0x10000;
-        buf[0] = (c>>10) & 0xFF;
-        buf[1] = (c>>18) | 0xd8;
-        buf[2] = c & 0xFF;
-        buf[3] = ((c>>8) & 0x3) | 0xdc;
-        ilen = 4;
-        olen = 5;
-        inbuf = (char *)buf;
-        smb_iconv(descriptor, &inbuf, &ilen, &str, &olen);
-        if (ilen != 0) {
-                return -1;
+        }
-        return 5 - olen;
+}

vendor/current/lib/util/charset/charset.h

-              r587
+              r740
 typedef uint16_t smb_ucs2_t;
+#ifdef WORDS_BIGENDIAN
+#define UCS2_SHIFT 8
+#else
+#define UCS2_SHIFT 0
+#endif
+/* turn a 7 bit character into a ucs2 character */
+#define UCS2_CHAR(c) ((c) << UCS2_SHIFT)
+/* return an ascii version of a ucs2 character */
+#define UCS2_TO_CHAR(c) (((c) >> UCS2_SHIFT) & 0xff)
+/* Copy into a smb_ucs2_t from a possibly unaligned buffer. Return the copied smb_ucs2_t */
+#define COPY_UCS2_CHAR(dest,src) (((unsigned char *)(dest))[0] = ((unsigned char *)(src))[0],\
+                                ((unsigned char *)(dest))[1] = ((unsigned char *)(src))[1], (dest))
 /*
  *   for each charset we have a function that pulls from that charset to
 …
 char *strchr_m(const char *s, char c);
+size_t strlen_m_ext(const char *s, charset_t src_charset, charset_t dst_charset);
+size_t strlen_m_ext_term(const char *s, charset_t src_charset,
+                         charset_t dst_charset);
 size_t strlen_m_term(const char *s);
 size_t strlen_m_term_null(const char *s);
 …
 extern struct smb_iconv_convenience *global_iconv_convenience;
+struct smb_iconv_convenience *get_iconv_convenience(void);
+smb_iconv_t get_conv_handle(struct smb_iconv_convenience *ic,
+                            charset_t from, charset_t to);
+const char *charset_name(struct smb_iconv_convenience *ic, charset_t ch);
+codepoint_t next_codepoint_ext(const char *str, charset_t src_charset,
+                               size_t *size);
 codepoint_t next_codepoint(const char *str, size_t *size);
 ssize_t push_codepoint(char *str, codepoint_t c);
 /* codepoints */
+codepoint_t next_codepoint_convenience_ext(struct smb_iconv_convenience *ic,
+                            const char *str, charset_t src_charset,
+                            size_t *size);
 codepoint_t next_codepoint_convenience(struct smb_iconv_convenience *ic,
                             const char *str, size_t *size);
 ssize_t push_codepoint_convenience(struct smb_iconv_convenience *ic,
                                 char *str, codepoint_t c);
 codepoint_t toupper_m(codepoint_t val);
 codepoint_t tolower_m(codepoint_t val);
+bool islower_m(codepoint_t val);
+bool isupper_m(codepoint_t val);
 int codepoint_cmpi(codepoint_t c1, codepoint_t c2);
 /* Iconv convenience functions */
+struct smb_iconv_convenience *smb_iconv_convenience_init(TALLOC_CTX *mem_ctx,
+                                                         const char *dos_charset,
+                                                         const char *unix_charset,
+                                                         bool native_iconv);
+struct smb_iconv_convenience *smb_iconv_convenience_reinit(TALLOC_CTX *mem_ctx,
+                                                           const char *dos_charset,
+                                                           const char *unix_charset,
+                                                           const char *display_charset,
+                                                           bool native_iconv,
+                                                           struct smb_iconv_convenience *old_ic);
 bool convert_string_convenience(struct smb_iconv_convenience *ic,
 …
 void load_case_tables(void);
+bool charset_register_backend(const void *_funcs);
+void load_case_tables_library(void);
+bool smb_register_charset(const struct charset_functions *funcs_in);
 /*
 …
 NTSTATUS charset_ ## CHARSETNAME ## _init(void)                                                 \
 {                                                                                               \
+        return smb_register_charset(& CHARSETNAME ## _functions);                               \
+}                                                                                               \
+        if (!smb_register_charset(& CHARSETNAME ## _functions)) {       \
+                return NT_STATUS_INTERNAL_ERROR;                        \
+        }                                                               \
+        return NT_STATUS_OK; \
+}                                               \

vendor/current/lib/util/charset/codepoints.c

-              r414
+              r740
 /*
    Unix SMB/CIFS implementation.
+   Samba utility functions
+   Copyright (C) Andrew Tridgell 1992-2001
+   Character set conversion Extensions
+   Copyright (C) Igor Vergeichik <iverg@mail.ru> 2001
+   Copyright (C) Andrew Tridgell 2001
    Copyright (C) Simo Sorce 2001
+   Copyright (C) Jelmer Vernooij 2007
    This program is free software; you can redistribute it and/or modify
 …
    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"
+#include "lib/util/charset/charset.h"
 #include "system/locale.h"
+#include "dynconfig/dynconfig.h"
+#include "dynconfig.h"
+#ifdef strcasecmp
+#undef strcasecmp
+#endif
 /**
 …
 /*******************************************************************
 load the case handling tables
+This is the function that should be called from library code.
 ********************************************************************/
 void load_case_tables(void)
+void load_case_tables_library(void)
+{
         TALLOC_CTX *mem_ctx;
 …
                 smb_panic("No memory for case_tables");
+        }
         upcase_table = map_file(talloc_asprintf(mem_ctx, "%s/upcase.dat", dyn_DATADIR), 0x20000);
         lowcase_table = map_file(talloc_asprintf(mem_ctx, "%s/lowcase.dat", dyn_DATADIR), 0x20000);
+        upcase_table = map_file(talloc_asprintf(mem_ctx, "%s/upcase.dat", get_dyn_CODEPAGEDIR()), 0x20000);
+        lowcase_table = map_file(talloc_asprintf(mem_ctx, "%s/lowcase.dat", get_dyn_CODEPAGEDIR()), 0x20000);
         talloc_free(mem_ctx);
         if (upcase_table == NULL) {
+                /* try also under codepages for testing purposes */
+                upcase_table = map_file("codepages/upcase.dat", 0x20000);
+                if (upcase_table == NULL) {
+                        upcase_table = (void *)-1;
+                }
+                DEBUG(1, ("Failed to load upcase.dat, will use lame ASCII-only case sensitivity rules\n"));
+                upcase_table = (void *)-1;
+        }
         if (lowcase_table == NULL) {
+                /* try also under codepages for testing purposes */
+                lowcase_table = map_file("codepages/lowcase.dat", 0x20000);
+                if (lowcase_table == NULL) {
+                        lowcase_table = (void *)-1;
+                }
+        }
+                DEBUG(1, ("Failed to load lowcase.dat, will use lame ASCII-only case sensitivity rules\n"));
+                lowcase_table = (void *)-1;
+        }
+}
+/*******************************************************************
+load the case handling tables
+This MUST only be called from main() in application code, never from a
+library.  We don't know if the calling program has already done
+setlocale() to another value, and can't tell if they have.
+********************************************************************/
+void load_case_tables(void)
+{
+        /* This is a useful global hook where we can ensure that the
+         * locale is set from the environment.  This is needed so that
+         * we can use LOCALE as a codepage */
+#ifdef HAVE_SETLOCALE
+        setlocale(LC_ALL, "");
+#endif
+        load_case_tables_library();
+}
 …
+        }
         if (upcase_table == NULL) {
                 load_case_tables();
+                load_case_tables_library();
+        }
         if (upcase_table == (void *)-1) {
 …
+        }
         if (lowcase_table == NULL) {
                 load_case_tables();
+                load_case_tables_library();
+        }
         if (lowcase_table == (void *)-1) {
 …
+        }
         return SVAL(lowcase_table, val*2);
+}
+/**
+ If we upper cased this character, would we get the same character?
+**/
+_PUBLIC_ bool islower_m(codepoint_t val)
+{
+        return (toupper_m(val) != val);
+}
+/**
+ If we lower cased this character, would we get the same character?
+**/
+_PUBLIC_ bool isupper_m(codepoint_t val)
+{
+        return (tolower_m(val) != val);
+}
 …
+struct smb_iconv_convenience {
+        TALLOC_CTX *child_ctx;
+        const char *unix_charset;
+        const char *dos_charset;
+        const char *display_charset;
+        bool native_iconv;
+        smb_iconv_t conv_handles[NUM_CHARSETS][NUM_CHARSETS];
+};
+struct smb_iconv_convenience *global_iconv_convenience = NULL;
+struct smb_iconv_convenience *get_iconv_convenience(void)
+{
+        if (global_iconv_convenience == NULL)
+                global_iconv_convenience = smb_iconv_convenience_reinit(talloc_autofree_context(),
+                                                                        "ASCII", "UTF-8", "ASCII", true, NULL);
+        return global_iconv_convenience;
+}
+/**
+ * Return the name of a charset to give to iconv().
+ **/
+const char *charset_name(struct smb_iconv_convenience *ic, charset_t ch)
+{
+        switch (ch) {
+        case CH_UTF16: return "UTF-16LE";
+        case CH_UNIX: return ic->unix_charset;
+        case CH_DOS: return ic->dos_charset;
+        case CH_DISPLAY: return ic->display_charset;
+        case CH_UTF8: return "UTF8";
+        case CH_UTF16BE: return "UTF-16BE";
+        case CH_UTF16MUNGED: return "UTF16_MUNGED";
+        default:
+        return "ASCII";
+        }
+}
+/**
+ re-initialize iconv conversion descriptors
+**/
+static int close_iconv_convenience(struct smb_iconv_convenience *data)
+{
+        unsigned c1, c2;
+        for (c1=0;c1<NUM_CHARSETS;c1++) {
+                for (c2=0;c2<NUM_CHARSETS;c2++) {
+                        if (data->conv_handles[c1][c2] != NULL) {
+                                if (data->conv_handles[c1][c2] != (smb_iconv_t)-1) {
+                                        smb_iconv_close(data->conv_handles[c1][c2]);
+                                }
+                                data->conv_handles[c1][c2] = NULL;
+                        }
+                }
+        }
+        return 0;
+}
+static const char *map_locale(const char *charset)
+{
+        if (strcmp(charset, "LOCALE") != 0) {
+                return charset;
+        }
+#if defined(HAVE_NL_LANGINFO) && defined(CODESET)
+        {
+                const char *ln;
+                smb_iconv_t handle;
+                ln = nl_langinfo(CODESET);
+                if (ln == NULL) {
+                        DEBUG(1,("Unable to determine charset for LOCALE - using ASCII\n"));
+                        return "ASCII";
+                }
+                /* Check whether the charset name is supported
+                   by iconv */
+                handle = smb_iconv_open(ln, "UCS-2LE");
+                if (handle == (smb_iconv_t) -1) {
+                        DEBUG(5,("Locale charset '%s' unsupported, using ASCII instead\n", ln));
+                        return "ASCII";
+                } else {
+                        DEBUG(5,("Substituting charset '%s' for LOCALE\n", ln));
+                        smb_iconv_close(handle);
+                }
+                return ln;
+        }
+#endif
+        return "ASCII";
+}
+/*
+  the old_ic is passed in here as the smb_iconv_convenience structure
+  is used as a global pointer in some places (eg. python modules). We
+  don't want to invalidate those global pointers, but we do want to
+  update them with the right charset information when loadparm
+  runs. To do that we need to re-use the structure pointer, but
+  re-fill the elements in the structure with the updated values
+ */
+_PUBLIC_ struct smb_iconv_convenience *smb_iconv_convenience_reinit(TALLOC_CTX *mem_ctx,
+                                                                    const char *dos_charset,
+                                                                    const char *unix_charset,
+                                                                    const char *display_charset,
+                                                                    bool native_iconv,
+                                                                    struct smb_iconv_convenience *old_ic)
+{
+        struct smb_iconv_convenience *ret;
+        display_charset = map_locale(display_charset);
+        if (old_ic != NULL) {
+                ret = old_ic;
+                close_iconv_convenience(ret);
+                talloc_free(ret->child_ctx);
+                ZERO_STRUCTP(ret);
+        } else {
+                ret = talloc_zero(mem_ctx, struct smb_iconv_convenience);
+        }
+        if (ret == NULL) {
+                return NULL;
+        }
+        /* we use a child context to allow us to free all ptrs without
+           freeing the structure itself */
+        ret->child_ctx = talloc_new(ret);
+        if (ret->child_ctx == NULL) {
+                return NULL;
+        }
+        talloc_set_destructor(ret, close_iconv_convenience);
+        ret->dos_charset = talloc_strdup(ret->child_ctx, dos_charset);
+        ret->unix_charset = talloc_strdup(ret->child_ctx, unix_charset);
+        ret->display_charset = talloc_strdup(ret->child_ctx, display_charset);
+        ret->native_iconv = native_iconv;
+        return ret;
+}
+/*
+  on-demand initialisation of conversion handles
+*/
+smb_iconv_t get_conv_handle(struct smb_iconv_convenience *ic,
+                            charset_t from, charset_t to)
+{
+        const char *n1, *n2;
+        static bool initialised;
+        if (initialised == false) {
+                initialised = true;
+        }
+        if (ic->conv_handles[from][to]) {
+                return ic->conv_handles[from][to];
+        }
+        n1 = charset_name(ic, from);
+        n2 = charset_name(ic, to);
+        ic->conv_handles[from][to] = smb_iconv_open_ex(ic, n2, n1,
+                                                       ic->native_iconv);
+        if (ic->conv_handles[from][to] == (smb_iconv_t)-1) {
+                if ((from == CH_DOS || to == CH_DOS) &&
+                    strcasecmp(charset_name(ic, CH_DOS), "ASCII") != 0) {
+                        DEBUG(0,("dos charset '%s' unavailable - using ASCII\n",
+                                 charset_name(ic, CH_DOS)));
+                        ic->dos_charset = "ASCII";
+                        n1 = charset_name(ic, from);
+                        n2 = charset_name(ic, to);
+                        ic->conv_handles[from][to] =
+                                smb_iconv_open_ex(ic, n2, n1, ic->native_iconv);
+                }
+        }
+        return ic->conv_handles[from][to];
+}
+/**
+ * Return the unicode codepoint for the next character in the input
+ * string in the given src_charset.
+ * The unicode codepoint (codepoint_t) is an unsinged 32 bit value.
+ *
+ * Also return the number of bytes consumed (which tells the caller
+ * how many bytes to skip to get to the next src_charset-character).
+ *
+ * This is implemented (in the non-ascii-case) by first converting the
+ * next character in the input string to UTF16_LE and then calculating
+ * the unicode codepoint from that.
+ *
+ * Return INVALID_CODEPOINT if the next character cannot be converted.
+ */
+_PUBLIC_ codepoint_t next_codepoint_convenience_ext(
+                        struct smb_iconv_convenience *ic,
+                        const char *str, charset_t src_charset,
+                        size_t *bytes_consumed)
+{
+        /* it cannot occupy more than 4 bytes in UTF16 format */
+        uint8_t buf[4];
+        smb_iconv_t descriptor;
+        size_t ilen_orig;
+        size_t ilen;
+        size_t olen;
+        char *outbuf;
+        if ((str[0] & 0x80) == 0) {
+                *bytes_consumed = 1;
+                return (codepoint_t)str[0];
+        }
+        /*
+         * we assume that no multi-byte character can take more than 5 bytes.
+         * This is OK as we only support codepoints up to 1M (U+100000)
+         */
+        ilen_orig = strnlen(str, 5);
+        ilen = ilen_orig;
+        descriptor = get_conv_handle(ic, src_charset, CH_UTF16);
+        if (descriptor == (smb_iconv_t)-1) {
+                *bytes_consumed = 1;
+                return INVALID_CODEPOINT;
+        }
+        /*
+         * this looks a little strange, but it is needed to cope with
+         * codepoints above 64k (U+1000) which are encoded as per RFC2781.
+         */
+        olen = 2;
+        outbuf = (char *)buf;
+        smb_iconv(descriptor, &str, &ilen, &outbuf, &olen);
+        if (olen == 2) {
+                olen = 4;
+                outbuf = (char *)buf;
+                smb_iconv(descriptor,  &str, &ilen, &outbuf, &olen);
+                if (olen == 4) {
+                        /* we didn't convert any bytes */
+                        *bytes_consumed = 1;
+                        return INVALID_CODEPOINT;
+                }
+                olen = 4 - olen;
+        } else {
+                olen = 2 - olen;
+        }
+        *bytes_consumed = ilen_orig - ilen;
+        if (olen == 2) {
+                return (codepoint_t)SVAL(buf, 0);
+        }
+        if (olen == 4) {
+                /* decode a 4 byte UTF16 character manually */
+                return (codepoint_t)0x10000 +
+                        (buf[2] | ((buf[3] & 0x3)<<8) |
+                         (buf[0]<<10) | ((buf[1] & 0x3)<<18));
+        }
+        /* no other length is valid */
+        return INVALID_CODEPOINT;
+}
+/*
+  return the unicode codepoint for the next multi-byte CH_UNIX character
+  in the string
+  also return the number of bytes consumed (which tells the caller
+  how many bytes to skip to get to the next CH_UNIX character)
+  return INVALID_CODEPOINT if the next character cannot be converted
+*/
+_PUBLIC_ codepoint_t next_codepoint_convenience(struct smb_iconv_convenience *ic,
+                                    const char *str, size_t *size)
+{
+        return next_codepoint_convenience_ext(ic, str, CH_UNIX, size);
+}
+/*
+  push a single codepoint into a CH_UNIX string the target string must
+  be able to hold the full character, which is guaranteed if it is at
+  least 5 bytes in size. The caller may pass less than 5 bytes if they
+  are sure the character will fit (for example, you can assume that
+  uppercase/lowercase of a character will not add more than 1 byte)
+  return the number of bytes occupied by the CH_UNIX character, or
+  -1 on failure
+*/
+_PUBLIC_ ssize_t push_codepoint_convenience(struct smb_iconv_convenience *ic,
+                                char *str, codepoint_t c)
+{
+        smb_iconv_t descriptor;
+        uint8_t buf[4];
+        size_t ilen, olen;
+        const char *inbuf;
+        if (c < 128) {
+                *str = c;
+                return 1;
+        }
+        descriptor = get_conv_handle(ic,
+                                     CH_UTF16, CH_UNIX);
+        if (descriptor == (smb_iconv_t)-1) {
+                return -1;
+        }
+        if (c < 0x10000) {
+                ilen = 2;
+                olen = 5;
+                inbuf = (char *)buf;
+                SSVAL(buf, 0, c);
+                smb_iconv(descriptor, &inbuf, &ilen, &str, &olen);
+                if (ilen != 0) {
+                        return -1;
+                }
+                return 5 - olen;
+        }
+        c -= 0x10000;
+        buf[0] = (c>>10) & 0xFF;
+        buf[1] = (c>>18) | 0xd8;
+        buf[2] = c & 0xFF;
+        buf[3] = ((c>>8) & 0x3) | 0xdc;
+        ilen = 4;
+        olen = 5;
+        inbuf = (char *)buf;
+        smb_iconv(descriptor, &inbuf, &ilen, &str, &olen);
+        if (ilen != 0) {
+                return -1;
+        }
+        return 5 - olen;
+}
+_PUBLIC_ codepoint_t next_codepoint_ext(const char *str, charset_t src_charset,
+                                        size_t *size)
+{
+        return next_codepoint_convenience_ext(get_iconv_convenience(), str,
+                                              src_charset, size);
+}
+_PUBLIC_ codepoint_t next_codepoint(const char *str, size_t *size)
+{
+        return next_codepoint_convenience(get_iconv_convenience(), str, size);
+}
+_PUBLIC_ ssize_t push_codepoint(char *str, codepoint_t c)
+{
+        return push_codepoint_convenience(get_iconv_convenience(), str, c);
+}

vendor/current/lib/util/charset/iconv.c

-              r414
+              r740
 #include "system/filesys.h"
+#ifdef strcasecmp
+#undef strcasecmp
+#endif
+#ifdef static_decl_charset
+static_decl_charset;
+#endif
 /**
 …
 static size_t ascii_pull  (void *,const char **, size_t *, char **, size_t *);
 static size_t ascii_push  (void *,const char **, size_t *, char **, size_t *);
+static size_t latin1_push(void *,const char **, size_t *, char **, size_t *);
 static size_t utf8_pull   (void *,const char **, size_t *, char **, size_t *);
 static size_t utf8_push   (void *,const char **, size_t *, char **, size_t *);
 …
         {"ASCII", ascii_pull, ascii_push},
+        {"646", ascii_pull, ascii_push},
+        {"ISO-8859-1", ascii_pull, latin1_push},
         {"UCS2-HEX", ucs2hex_pull, ucs2hex_push}
 };
 …
 static struct charset_functions *charsets = NULL;
+bool charset_register_backend(const void *_funcs)
+{
+        struct charset_functions *funcs = (struct charset_functions *)memdup(_funcs,sizeof(struct charset_functions));
+static struct charset_functions *find_charset_functions(const char *name)
+{
         struct charset_functions *c;
         /* Check whether we already have this charset... */
         for (c = charsets; c != NULL; c = c->next) {
+                if(!strcasecmp(c->name, funcs->name)) {
+                        DEBUG(2, ("Duplicate charset %s, not registering\n", funcs->name));
+                        return false;
+                }
+        }
+                if(strcasecmp(c->name, name) == 0) {
+                        return c;
+                }
+                c = c->next;
+        }
+        return NULL;
+}
+bool smb_register_charset(const struct charset_functions *funcs_in)
+{
+        struct charset_functions *funcs;
+        DEBUG(5, ("Attempting to register new charset %s\n", funcs_in->name));
+        /* Check whether we already have this charset... */
+        if (find_charset_functions(funcs_in->name)) {
+                DEBUG(0, ("Duplicate charset %s, not registering\n", funcs_in->name));
+                return false;
+        }
+        funcs = talloc(NULL, struct charset_functions);
+        if (!funcs) {
+                DEBUG(0, ("Out of memory duplicating charset %s\n", funcs_in->name));
+                return false;
+        }
+        *funcs = *funcs_in;
         funcs->next = funcs->prev = NULL;
+        DEBUG(5, ("Registered charset %s\n", funcs->name));
         DLIST_ADD(charsets, funcs);
         return true;
+}
+static void lazy_initialize_iconv(void)
+{
+        static bool initialized;
+#ifdef static_init_charset
+        if (!initialized) {
+                static_init_charset;
+                initialized = true;
+        }
+#endif
+}
 …
+}
 int smb_iconv_t_destructor(smb_iconv_t hwd)
+{
+static int smb_iconv_t_destructor(smb_iconv_t hwd)
+{
 #ifdef HAVE_NATIVE_ICONV
         if (hwd->cd_pull != NULL && hwd->cd_pull != (iconv_t)-1)
 …
         int i;
+        lazy_initialize_iconv();
         ret = (smb_iconv_t)talloc_named(mem_ctx,
                                         sizeof(*ret),
 …
         if (is_utf16(tocode)) {
                 ret->direct = sys_iconv;
-                /* could be set just above - so we need to close iconv */
-                if (ret->cd_direct != NULL && ret->cd_direct != (iconv_t)-1)
-                        iconv_close(ret->cd_direct);
                 ret->cd_direct = ret->cd_pull;
                 ret->cd_pull = NULL;
 …
 _PUBLIC_ smb_iconv_t smb_iconv_open(const char *tocode, const char *fromcode)
+{
         return smb_iconv_open_ex(talloc_autofree_context(), tocode, fromcode, true);
+        return smb_iconv_open_ex(NULL, tocode, fromcode, true);
+}
 …
+}
+static size_t latin1_push(void *cd, const char **inbuf, size_t *inbytesleft,
+                         char **outbuf, size_t *outbytesleft)
+{
+        int ir_count=0;
+        while (*inbytesleft >= 2 && *outbytesleft >= 1) {
+                (*outbuf)[0] = (*inbuf)[0];
+                if ((*inbuf)[1]) ir_count++;
+                (*inbytesleft)  -= 2;
+                (*outbytesleft) -= 1;
+                (*inbuf)  += 2;
+                (*outbuf) += 1;
+        }
+        if (*inbytesleft == 1) {
+                errno = EINVAL;
+                return -1;
+        }
+        if (*inbytesleft > 1) {
+                errno = E2BIG;
+                return -1;
+        }
+        return ir_count;
+}
 static size_t ucs2hex_pull(void *cd, const char **inbuf, size_t *inbytesleft,
 …
+{
         while (*inbytesleft >= 1 && *outbytesleft >= 2) {
                 uint_t v;
+                unsigned int v;
                 if ((*inbuf)[0] != '@') {

vendor/current/lib/util/charset/tests/charset.c

r414	r740
247	247	struct torture_suite torture_local_charset(TALLOC_CTX mem_ctx)
248	248	{
249		struct torture_suite *suite = torture_suite_create(mem_ctx, "~~CHARSET~~");
	249	struct torture_suite *suite = torture_suite_create(mem_ctx, "charset");
250	250
251	251	torture_suite_add_simple_test(suite, "toupper_m", test_toupper_m);

vendor/current/lib/util/charset/tests/iconv.c

-              r414
+              r740
         iconv_t cd;
         if (!lp_parm_bool(tctx->lp_ctx, NULL, "iconv", "native", true))
+        if (!lpcfg_parm_bool(tctx->lp_ctx, NULL, "iconv", "native", true))
                 torture_skip(tctx, "system iconv disabled - skipping test");
 …
         uint8_t buf1[1000], buf2[1000], buf3[1000];
         size_t outsize1, outsize2, outsize3;
         const char *ptr_in;
+        char *ptr_in;
         char *ptr_out;
         size_t size_in1, size_in2, size_in3;
 …
                                                      charset));
+                }
                 cd2 = smb_iconv_open_ex(test, charset, "UTF-16LE", lp_parm_bool(test->lp_ctx, NULL, "iconv", "native", true));
                 cd3 = smb_iconv_open_ex(test, "UTF-16LE", charset, lp_parm_bool(test->lp_ctx, NULL, "iconv", "native", true));
+                cd2 = smb_iconv_open_ex(test, charset, "UTF-16LE", lpcfg_parm_bool(test->lp_ctx, NULL, "iconv", "native", true));
+                cd3 = smb_iconv_open_ex(test, "UTF-16LE", charset, lpcfg_parm_bool(test->lp_ctx, NULL, "iconv", "native", true));
                 last_charset = charset;
+        }
         /* internal convert to charset - placing result in buf1 */
         ptr_in = (const char *)inbuf;
+        ptr_in = (char *)inbuf;
         ptr_out = (char *)buf1;
         size_in1 = size;
 …
         memset(ptr_out, 0, outsize1);
         errno = 0;
         ret1 = smb_iconv(cd2, &ptr_in, &size_in1, &ptr_out, &outsize1);
+        ret1 = smb_iconv(cd2, (const char **) &ptr_in, &size_in1, &ptr_out, &outsize1);
         errno1 = errno;
         /* system convert to charset - placing result in buf2 */
         ptr_in = (const char *)inbuf;
+        ptr_in = (char *)inbuf;
         ptr_out = (char *)buf2;
         size_in2 = size;
 …
         memset(ptr_out, 0, outsize2);
         errno = 0;
         ret2 = iconv(cd, discard_const_p(char *, &ptr_in), &size_in2, &ptr_out, &outsize2);
+        ret2 = iconv(cd, &ptr_in, &size_in2, &ptr_out, &outsize2);
         errno2 = errno;
 …
         /* convert back to UTF-16, putting result in buf3 */
         size = size - size_in1;
         ptr_in = (const char *)buf1;
+        ptr_in = (char *)buf1;
         ptr_out = (char *)buf3;
         size_in3 = len1;
 …
         memset(ptr_out, 0, outsize3);
         ret3 = smb_iconv(cd3, &ptr_in, &size_in3, &ptr_out, &outsize3);
+        ret3 = smb_iconv(cd3, (const char **) &ptr_in, &size_in3, &ptr_out, &outsize3);
         /* we only internally support the first 1M codepoints */
 …
         codepoint_t c;
         size = push_codepoint_convenience(lp_iconv_convenience(tctx->lp_ctx), (char *)buf, codepoint);
+        size = push_codepoint_convenience(lpcfg_iconv_convenience(tctx->lp_ctx), (char *)buf, codepoint);
         torture_assert(tctx, size != -1 || (codepoint >= 0xd800 && codepoint <= 0x10000),
                        "Invalid Codepoint range");
 …
         buf[size+3] = random();
         c = next_codepoint_convenience(lp_iconv_convenience(tctx->lp_ctx), (char *)buf, &size2);
+        c = next_codepoint_convenience(lpcfg_iconv_convenience(tctx->lp_ctx), (char *)buf, &size2);
         torture_assert(tctx, c == codepoint,
 …
 struct torture_suite *torture_local_iconv(TALLOC_CTX *mem_ctx)
+{
         struct torture_suite *suite = torture_suite_create(mem_ctx, "ICONV");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "iconv");
         torture_suite_add_simple_test(suite, "string2key",

vendor/current/lib/util/charset/util_unistr.c

-              r414
+              r740
 #include "system/locale.h"
-struct smb_iconv_convenience *global_iconv_convenience = NULL;
-static inline struct smb_iconv_convenience *get_iconv_convenience(void)
+{
-        if (global_iconv_convenience == NULL)
-                global_iconv_convenience = smb_iconv_convenience_init(talloc_autofree_context(), "ASCII", "UTF-8", true);
-        return global_iconv_convenience;
+}
 /**
  Case insensitive string compararison
 …
         return *s1 - *s2;
+}
-/**
- * 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;
+}
 …
 /**
+ Count the number of UCS2 characters in a string. Normally this will
+ be the same as the number of bytes in a string for single byte strings,
+ but will be different for multibyte.
+**/
+_PUBLIC_ size_t strlen_m(const char *s)
+ * Calculate the number of units (8 or 16-bit, depending on the
+ * destination charset), that would be needed to convert the input
+ * string which is expected to be in in src_charset encoding to the
+ * destination charset (which should be a unicode charset).
+ */
+_PUBLIC_ size_t strlen_m_ext(const char *s, charset_t src_charset, charset_t dst_charset)
+{
         size_t count = 0;
 …
         while (*s) {
                 size_t c_size;
+                codepoint_t c = next_codepoint_convenience(ic, s, &c_size);
+                if (c < 0x10000) {
+                codepoint_t c = next_codepoint_convenience_ext(ic, s, src_charset, &c_size);
+                s += c_size;
+                switch (dst_charset) {
+                case CH_UTF16LE:
+                case CH_UTF16BE:
+                case CH_UTF16MUNGED:
+                        if (c < 0x10000) {
+                                count += 1;
+                        } else {
+                                count += 2;
+                        }
+                        break;
+                case CH_UTF8:
+                        /*
+                         * this only checks ranges, and does not
+                         * check for invalid codepoints
+                         */
+                        if (c < 0x80) {
+                                count += 1;
+                        } else if (c < 0x800) {
+                                count += 2;
+                        } else if (c < 0x1000) {
+                                count += 3;
+                        } else {
+                                count += 4;
+                        }
+                        break;
+                default:
+                        /*
+                         * non-unicode encoding:
+                         * assume that each codepoint fits into
+                         * one unit in the destination encoding.
+                         */
                         count += 1;
+                } else {
+                        count += 2;
+                }
+                s += c_size;
+                }
+        }
         return count;
+}
+_PUBLIC_ size_t strlen_m_ext_term(const char *s, const charset_t src_charset,
+                                  const charset_t dst_charset)
+{
+        if (!s) {
+                return 0;
+        }
+        return strlen_m_ext(s, src_charset, dst_charset) + 1;
+}
+/**
+ * Calculate the number of 16-bit units that would be needed to convert
+ * the input string which is expected to be in CH_UNIX encoding to UTF16.
+ *
+ * This will be the same as the number of bytes in a string for single
+ * byte strings, but will be different for multibyte.
+ */
+_PUBLIC_ size_t strlen_m(const char *s)
+{
+        return strlen_m_ext(s, CH_UNIX, CH_UTF16LE);
+}
 …
         char *dest;
         struct smb_iconv_convenience *iconv_convenience = get_iconv_convenience();
+        if(src == NULL) {
+                return NULL;
+        }
         /* this takes advantage of the fact that upper/lower can't
 …
+}
-_PUBLIC_ codepoint_t next_codepoint(const char *str, size_t *size)
+{
-        return next_codepoint_convenience(get_iconv_convenience(), str, size);
+}
-_PUBLIC_ ssize_t push_codepoint(char *str, codepoint_t c)
+{
-        return push_codepoint_convenience(get_iconv_convenience(), str, c);
+}

vendor/current/lib/util/data_blob.c

-              r414
+              r740
 _PUBLIC_ DATA_BLOB data_blob_named(const void *p, size_t length, const char *name)
+{
+        return data_blob_talloc_named(NULL, p, length, name);
+}
+/**
+ construct a data blob, using supplied TALLOC_CTX
+**/
+_PUBLIC_ DATA_BLOB data_blob_talloc_named(TALLOC_CTX *mem_ctx, const void *p, size_t length, const char *name)
+{
         DATA_BLOB ret;
 …
         if (p) {
                 ret.data = (uint8_t *)talloc_memdup(NULL, p, length);
+                ret.data = (uint8_t *)talloc_memdup(mem_ctx, p, length);
         } else {
                 ret.data = talloc_array(NULL, uint8_t, length);
+                ret.data = talloc_array(mem_ctx, uint8_t, length);
+        }
         if (ret.data == NULL) {
 …
         talloc_set_name_const(ret.data, name);
         ret.length = length;
-        return ret;
+}
-/**
- construct a data blob, using supplied TALLOC_CTX
-**/
-_PUBLIC_ DATA_BLOB data_blob_talloc_named(TALLOC_CTX *mem_ctx, const void *p, size_t length, const char *name)
+{
-        DATA_BLOB ret = data_blob_named(p, length, name);
-        if (ret.data) {
-                talloc_steal(mem_ctx, ret.data);
+        }
-        return ret;
+}
-/**
- reference a data blob, to the supplied TALLOC_CTX.
- Returns a NULL DATA_BLOB on failure
-**/
-_PUBLIC_ DATA_BLOB data_blob_talloc_reference(TALLOC_CTX *mem_ctx, DATA_BLOB *blob)
+{
-        DATA_BLOB ret = *blob;
-        ret.data = talloc_reference(mem_ctx, blob->data);
-        if (!ret.data) {
-                return data_blob(NULL, 0);
+        }
         return ret;
+}
 …
 print the data_blob as hex string
 **/
 _PUBLIC_ char *data_blob_hex_string(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob)
+_PUBLIC_ char *data_blob_hex_string_lower(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob)
+{
         int i;
 …
+}
+_PUBLIC_ char *data_blob_hex_string_upper(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob)
+{
+        int i;
+        char *hex_string;
+        hex_string = talloc_array(mem_ctx, char, (blob->length*2)+1);
+        if (!hex_string) {
+                return NULL;
+        }
+        for (i = 0; i < blob->length; i++)
+                slprintf(&hex_string[i*2], 3, "%02X", blob->data[i]);
+        hex_string[(blob->length*2)] = '\0';
+        return hex_string;
+}
 /**
   useful for constructing data blobs in test suites, while

vendor/current/lib/util/data_blob.h

-              r414
+              r740
    Unix SMB/CIFS implementation.
    DATA BLOB
+   Copyright (C) Andrew Tridgell 2001
+   Copyright (C) Andrew Bartlett 2001
    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
 …
 /**
- reference a data blob, to the supplied TALLOC_CTX.
- Returns a NULL DATA_BLOB on failure
-**/
-_PUBLIC_ DATA_BLOB data_blob_talloc_reference(TALLOC_CTX *mem_ctx, DATA_BLOB *blob);
-/**
  construct a zero data blob, using supplied TALLOC_CTX.
  use this sparingly as it initialises data - better to initialise
 …
 print the data_blob as hex string
 **/
+_PUBLIC_ char *data_blob_hex_string(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob);
+_PUBLIC_ char *data_blob_hex_string_upper(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob);
+/**
+print the data_blob as hex string
+**/
+_PUBLIC_ char *data_blob_hex_string_lower(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob);
 /**

vendor/current/lib/util/debug.c

-              r414
+              r740
 /*
    Unix SMB/CIFS implementation.
+   Samba debug functions
+   Copyright (C) Andrew Tridgell 2003
+   Copyright (C) James J Myers   2003
+   Samba utility functions
+   Copyright (C) Andrew Tridgell 1992-1998
+   Copyright (C) Elrond               2002
+   Copyright (C) Simo Sorce           2002
    This program is free software; you can redistribute it and/or modify
 …
 #include "includes.h"
 #include "system/filesys.h"
+#include "system/time.h"
+#include "dynconfig/dynconfig.h"
+#include "system/syslog.h"
+#include "lib/util/time.h"
+/* define what facility to use for syslog */
+#ifndef SYSLOG_FACILITY
+#define SYSLOG_FACILITY LOG_DAEMON
+#endif
+/* -------------------------------------------------------------------------- **
+ * Defines...
+ *
+ *  FORMAT_BUFR_MAX - Index of the last byte of the format buffer;
+ *                    format_bufr[FORMAT_BUFR_MAX] should always be reserved
+ *                    for a terminating null byte.
+ */
+#define FORMAT_BUFR_SIZE 1024
+#define FORMAT_BUFR_MAX (FORMAT_BUFR_SIZE - 1)
+/* -------------------------------------------------------------------------- **
+ * This module implements Samba's debugging utility.
+ *
+ * The syntax of a debugging log file is represented as:
+ *
+ *  <debugfile> :== { <debugmsg> }
+ *
+ *  <debugmsg>  :== <debughdr> '\n' <debugtext>
+ *
+ *  <debughdr>  :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
+ *
+ *  <debugtext> :== { <debugline> }
+ *
+ *  <debugline> :== TEXT '\n'
+ *
+ * TEXT     is a string of characters excluding the newline character.
+ * LEVEL    is the DEBUG level of the message (an integer in the range 0..10).
+ * TIME     is a timestamp.
+ * FILENAME is the name of the file from which the debug message was generated.
+ * FUNCTION is the function from which the debug message was generated.
+ *
+ * Basically, what that all means is:
+ *
+ * - A debugging log file is made up of debug messages.
+ *
+ * - Each debug message is made up of a header and text.  The header is
+ *   separated from the text by a newline.
+ *
+ * - The header begins with the timestamp and debug level of the message
+ *   enclosed in brackets.  The filename and function from which the
+ *   message was generated may follow.  The filename is terminated by a
+ *   colon, and the function name is terminated by parenthesis.
+ *
+ * - The message text is made up of zero or more lines, each terminated by
+ *   a newline.
+ */
+/* state variables for the debug system */
+static struct {
+        bool initialized;
+        int fd;   /* The log file handle */
+        enum debug_logtype logtype; /* The type of logging we are doing: eg stdout, file, stderr */
+        const char *prog_name;
+        bool reopening_logs;
+        bool schedule_reopen_logs;
+        struct debug_settings settings;
+        char *debugf;
+} state = {
+        .settings = {
+                .timestamp_logs = true
+        }
+};
+/* -------------------------------------------------------------------------- **
+ * External variables.
+ *
+ *  debugf        - Debug file name.
+ *  DEBUGLEVEL    - System-wide debug message limit.  Messages with message-
+ *                  levels higher than DEBUGLEVEL will not be processed.
+ */
+/*
+   used to check if the user specified a
+   logfile on the command line
+*/
+bool    override_logfile;
+/*
+ * This is to allow reading of DEBUGLEVEL_CLASS before the debug
+ * system has been initialized.
+ */
+static const int debug_class_list_initial[DBGC_MAX_FIXED + 1];
+static int debug_num_classes = 0;
+int     *DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
+/* -------------------------------------------------------------------------- **
+ * Internal variables.
+ *
+ *  debug_count     - Number of debug messages that have been output.
+ *                    Used to check log size.
+ *
+ *  syslog_level    - Internal copy of the message debug level.  Written by
+ *                    dbghdr() and read by Debug1().
+ *
+ *  format_bufr     - Used to format debug messages.  The dbgtext() function
+ *                    prints debug messages to a string, and then passes the
+ *                    string to format_debug_text(), which uses format_bufr
+ *                    to build the formatted output.
+ *
+ *  format_pos      - Marks the first free byte of the format_bufr.
+ *
+ *
+ *  log_overflow    - When this variable is true, never attempt to check the
+ *                    size of the log. This is a hack, so that we can write
+ *                    a message using DEBUG, from open_logs() when we
+ *                    are unable to open a new log file for some reason.
+ */
+static int     debug_count    = 0;
+#ifdef WITH_SYSLOG
+static int     syslog_level   = 0;
+#endif
+static char *format_bufr = NULL;
+static size_t     format_pos     = 0;
+static bool    log_overflow   = false;
+/*
+ * Define all the debug class selection names here. Names *MUST NOT* contain
+ * white space. There must be one name for each DBGC_<class name>, and they
+ * must be in the table in the order of DBGC_<class name>..
+ */
+static const char *default_classname_table[] = {
+        "all",               /* DBGC_ALL; index refs traditional DEBUGLEVEL */
+        "tdb",               /* DBGC_TDB          */
+        "printdrivers",      /* DBGC_PRINTDRIVERS */
+        "lanman",            /* DBGC_LANMAN       */
+        "smb",               /* DBGC_SMB          */
+        "rpc_parse",         /* DBGC_RPC_PARSE    */
+        "rpc_srv",           /* DBGC_RPC_SRV      */
+        "rpc_cli",           /* DBGC_RPC_CLI      */
+        "passdb",            /* DBGC_PASSDB       */
+        "sam",               /* DBGC_SAM          */
+        "auth",              /* DBGC_AUTH         */
+        "winbind",           /* DBGC_WINBIND      */
+        "vfs",               /* DBGC_VFS          */
+        "idmap",             /* DBGC_IDMAP        */
+        "quota",             /* DBGC_QUOTA        */
+        "acls",              /* DBGC_ACLS         */
+        "locking",           /* DBGC_LOCKING      */
+        "msdfs",             /* DBGC_MSDFS        */
+        "dmapi",             /* DBGC_DMAPI        */
+        "registry",          /* DBGC_REGISTRY     */
+        NULL
+};
+static char **classname_table = NULL;
+/* -------------------------------------------------------------------------- **
+ * Functions...
+ */
+static void debug_init(void);
+/***************************************************************************
+ Free memory pointed to by global pointers.
+****************************************************************************/
+void gfree_debugsyms(void)
+{
+        TALLOC_FREE(classname_table);
+        if ( DEBUGLEVEL_CLASS != debug_class_list_initial ) {
+                TALLOC_FREE( DEBUGLEVEL_CLASS );
+                DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
+        }
+        TALLOC_FREE(format_bufr);
+        debug_num_classes = DBGC_MAX_FIXED;
+        state.initialized = false;
+}
+/****************************************************************************
+utility lists registered debug class names's
+****************************************************************************/
+char *debug_list_class_names_and_levels(void)
+{
+        char *buf = NULL;
+        unsigned int i;
+        /* prepare strings */
+        for (i = 0; i < debug_num_classes; i++) {
+                buf = talloc_asprintf_append(buf,
+                                             "%s:%d%s",
+                                             classname_table[i],
+                                             DEBUGLEVEL_CLASS[i],
+                                             i == (debug_num_classes - 1) ? "\n" : " ");
+                if (buf == NULL) {
+                        return NULL;
+                }
+        }
+        return buf;
+}
+/****************************************************************************
+ Utility to translate names to debug class index's (internal version).
+****************************************************************************/
+static int debug_lookup_classname_int(const char* classname)
+{
+        int i;
+        if (!classname) return -1;
+        for (i=0; i < debug_num_classes; i++) {
+                if (strcmp(classname, classname_table[i])==0)
+                        return i;
+        }
+        return -1;
+}
+/****************************************************************************
+ Add a new debug class to the system.
+****************************************************************************/
+int debug_add_class(const char *classname)
+{
+        int ndx;
+        int *new_class_list;
+        char **new_name_list;
+        int default_level;
+        if (!classname)
+                return -1;
+        /* check the init has yet been called */
+        debug_init();
+        ndx = debug_lookup_classname_int(classname);
+        if (ndx >= 0)
+                return ndx;
+        ndx = debug_num_classes;
+        if (DEBUGLEVEL_CLASS == debug_class_list_initial) {
+                /* Initial loading... */
+                new_class_list = NULL;
+        } else {
+                new_class_list = DEBUGLEVEL_CLASS;
+        }
+        default_level = DEBUGLEVEL_CLASS[DBGC_ALL];
+        new_class_list = talloc_realloc(NULL, new_class_list, int, ndx + 1);
+        if (!new_class_list)
+                return -1;
+        DEBUGLEVEL_CLASS = new_class_list;
+        DEBUGLEVEL_CLASS[ndx] = default_level;
+        new_name_list = talloc_realloc(NULL, classname_table, char *, ndx + 1);
+        if (!new_name_list)
+                return -1;
+        classname_table = new_name_list;
+        classname_table[ndx] = talloc_strdup(classname_table, classname);
+        if (! classname_table[ndx])
+                return -1;
+        debug_num_classes = ndx + 1;
+        return ndx;
+}
+/****************************************************************************
+ Utility to translate names to debug class index's (public version).
+****************************************************************************/
+int debug_lookup_classname(const char *classname)
+{
+        int ndx;
+        if (!classname || !*classname)
+                return -1;
+        ndx = debug_lookup_classname_int(classname);
+        if (ndx != -1)
+                return ndx;
+        DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
+                  classname));
+        return debug_add_class(classname);
+}
+/****************************************************************************
+ Dump the current registered debug levels.
+****************************************************************************/
+static void debug_dump_status(int level)
+{
+        int q;
+        DEBUG(level, ("INFO: Current debug levels:\n"));
+        for (q = 0; q < debug_num_classes; q++) {
+                const char *classname = classname_table[q];
+                DEBUGADD(level, ("  %s: %d\n",
+                                 classname,
+                                 DEBUGLEVEL_CLASS[q]));
+        }
+}
+/****************************************************************************
+ parse the debug levels from smbcontrol. Example debug level parameter:
+ printdrivers:7
+****************************************************************************/
+static bool debug_parse_params(char **params)
+{
+        int   i, ndx;
+        char *class_name;
+        char *class_level;
+        if (!params)
+                return false;
+        /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
+         * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
+         */
+        if (isdigit((int)params[0][0])) {
+                DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(params[0]);
+                i = 1; /* start processing at the next params */
+        } else {
+                DEBUGLEVEL_CLASS[DBGC_ALL] = 0;
+                i = 0; /* DBGC_ALL not specified OR class name was included */
+        }
+        /* Array is debug_num_classes long */
+        for (ndx = DBGC_ALL; ndx < debug_num_classes; ndx++) {
+                DEBUGLEVEL_CLASS[ndx] = DEBUGLEVEL_CLASS[DBGC_ALL];
+        }
+        /* Fill in new debug class levels */
+        for (; i < debug_num_classes && params[i]; i++) {
+                char *saveptr;
+                if ((class_name = strtok_r(params[i],":", &saveptr)) &&
+                        (class_level = strtok_r(NULL, "\0", &saveptr)) &&
+            ((ndx = debug_lookup_classname(class_name)) != -1)) {
+                                DEBUGLEVEL_CLASS[ndx] = atoi(class_level);
+                } else {
+                        DEBUG(0,("debug_parse_params: unrecognized debug class name or format [%s]\n", params[i]));
+                        return false;
+                }
+        }
+        return true;
+}
+/****************************************************************************
+ Parse the debug levels from smb.conf. Example debug level string:
+tdb:5 printdrivers:7
+ Note: the 1st param has no "name:" preceeding it.
+****************************************************************************/
+bool debug_parse_levels(const char *params_str)
+{
+        char **params;
+        /* Just in case */
+        debug_init();
+        params = str_list_make(NULL, params_str, NULL);
+        if (debug_parse_params(params)) {
+                debug_dump_status(5);
+                TALLOC_FREE(params);
+                return true;
+        } else {
+                TALLOC_FREE(params);
+                return false;
+        }
+}
+/* setup for logging of talloc warnings */
+static void talloc_log_fn(const char *msg)
+{
+        DEBUG(0,("%s", msg));
+}
+void debug_setup_talloc_log(void)
+{
+        talloc_set_log_fn(talloc_log_fn);
+}
+/****************************************************************************
+Init debugging (one time stuff)
+****************************************************************************/
+static void debug_init(void)
+{
+        const char **p;
+        if (state.initialized)
+                return;
+        state.initialized = true;
+        debug_setup_talloc_log();
+        for(p = default_classname_table; *p; p++) {
+                debug_add_class(*p);
+        }
+        format_bufr = talloc_array(NULL, char, FORMAT_BUFR_SIZE);
+        if (!format_bufr) {
+                smb_panic("debug_init: unable to create buffer");
+        }
+}
+/* This forces in some smb.conf derived values into the debug system.
+ * There are no pointers in this structure, so we can just
+ * structure-assign it in */
+void debug_set_settings(struct debug_settings *settings)
+{
+        state.settings = *settings;
+}
 /**
+ * @file
+ * @brief Debug logging
+ **/
+/**
+ * this global variable determines what messages are printed
+ */
+int _debug_level = 0;
+_PUBLIC_ int *debug_level = &_debug_level;
+static int debug_all_class_hack = 1;
+int *DEBUGLEVEL_CLASS = &debug_all_class_hack; /* For samba 3 */
+static bool debug_all_class_isset_hack = true;
+bool    *DEBUGLEVEL_CLASS_ISSET = &debug_all_class_isset_hack; /* For samba 3 */
+XFILE *dbf = NULL; /* For Samba 3*/
+  control the name of the logfile and whether logging will be to stdout, stderr
+  or a file, and set up syslog
+  new_log indicates the destination for the debug log (an enum in
+  order of precedence - once set to DEBUG_FILE, it is not possible to
+  reset to DEBUG_STDOUT for example.  This makes it easy to override
+  for debug to stderr on the command line, as the smb.conf cannot
+  reset it back to file-based logging
+*/
+void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
+{
+        debug_init();
+        if (state.logtype < new_logtype) {
+                state.logtype = new_logtype;
+        }
+        if (prog_name) {
+                state.prog_name = prog_name;
+        }
+        reopen_logs_internal();
+        if (state.logtype == DEBUG_FILE) {
+#ifdef WITH_SYSLOG
+                const char *p = strrchr_m( prog_name,'/' );
+                if (p)
+                        prog_name = p + 1;
+#ifdef LOG_DAEMON
+                openlog( prog_name, LOG_PID, SYSLOG_FACILITY );
+#else
+                /* for old systems that have no facility codes. */
+                openlog( prog_name, LOG_PID );
+#endif
+#endif
+        }
+}
+/***************************************************************************
+ Set the logfile name.
+**************************************************************************/
+void debug_set_logfile(const char *name)
+{
+        if (name == NULL || *name == 0) {
+                /* this copes with calls when smb.conf is not loaded yet */
+                return;
+        }
+        TALLOC_FREE(state.debugf);
+        state.debugf = talloc_strdup(NULL, name);
+}
+static void debug_close_fd(int fd)
+{
+        if (fd > 2) {
+                close(fd);
+        }
+}
+bool debug_get_output_is_stderr(void)
+{
+        return (state.logtype == DEBUG_DEFAULT_STDERR) || (state.logtype == DEBUG_STDERR);
+}
+/**************************************************************************
+ reopen the log files
+ note that we now do this unconditionally
+ We attempt to open the new debug fp before closing the old. This means
+ if we run out of fd's we just keep using the old fd rather than aborting.
+ Fix from dgibson@linuxcare.com.
+**************************************************************************/
+/**
+  reopen the log file (usually called because the log file name might have changed)
+*/
+bool reopen_logs_internal(void)
+{
+        mode_t oldumask;
+        int new_fd = 0;
+        int old_fd = 0;
+        bool ret = true;
+        char *fname = NULL;
+        if (state.reopening_logs) {
+                return true;
+        }
+        /* Now clear the SIGHUP induced flag */
+        state.schedule_reopen_logs = false;
+        switch (state.logtype) {
+        case DEBUG_STDOUT:
+                debug_close_fd(state.fd);
+                state.fd = 1;
+                return true;
+        case DEBUG_DEFAULT_STDERR:
+        case DEBUG_STDERR:
+                debug_close_fd(state.fd);
+                state.fd = 2;
+                return true;
+        case DEBUG_FILE:
+                break;
+        }
+        oldumask = umask( 022 );
+        fname = state.debugf;
+        if (!fname) {
+                return false;
+        }
+        state.reopening_logs = true;
+        new_fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
+        if (new_fd == -1) {
+                log_overflow = true;
+                DEBUG(0, ("Unable to open new log file '%s': %s\n", state.debugf, strerror(errno)));
+                log_overflow = false;
+                ret = false;
+        } else {
+                old_fd = state.fd;
+                state.fd = new_fd;
+                debug_close_fd(old_fd);
+        }
+        /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
+         * to fix problem where smbd's that generate less
+         * than 100 messages keep growing the log.
+         */
+        force_check_log_size();
+        (void)umask(oldumask);
+        /* Take over stderr to catch output into logs */
+        if (state.fd > 0 && dup2(state.fd, 2) == -1) {
+                close_low_fds(true); /* Close stderr too, if dup2 can't point it
+                                        at the logfile */
+        }
+        state.reopening_logs = false;
+        return ret;
+}
+/**************************************************************************
+ Force a check of the log size.
+ ***************************************************************************/
+void force_check_log_size( void )
+{
+        debug_count = 100;
+}
+_PUBLIC_ void debug_schedule_reopen_logs(void)
+{
+        state.schedule_reopen_logs = true;
+}
+/***************************************************************************
+ Check to see if there is any need to check if the logfile has grown too big.
+**************************************************************************/
+bool need_to_check_log_size( void )
+{
+        int maxlog;
+        if( debug_count < 100)
+                return( false );
+        maxlog = state.settings.max_log_size * 1024;
+        if ( state.fd <=2 || maxlog <= 0 ) {
+                debug_count = 0;
+                return(false);
+        }
+        return( true );
+}
+/**************************************************************************
+ Check to see if the log has grown to be too big.
+ **************************************************************************/
+void check_log_size( void )
+{
+        int         maxlog;
+        struct stat st;
+        /*
+         *  We need to be root to check/change log-file, skip this and let the main
+         *  loop check do a new check as root.
+         */
+        if( geteuid() != 0) {
+                /* We don't check sec_initial_uid() here as it isn't
+                 * available in common code and we don't generally
+                 * want to rotate and the possibly lose logs in
+                 * make test or the build farm */
+                return;
+        }
+        if(log_overflow || (!state.schedule_reopen_logs && !need_to_check_log_size())) {
+                return;
+        }
+        maxlog = state.settings.max_log_size * 1024;
+        if (state.schedule_reopen_logs ||
+           (fstat(state.fd, &st) == 0
+            && st.st_size > maxlog )) {
+                (void)reopen_logs_internal();
+                if (state.fd > 0 && fstat(state.fd, &st) == 0) {
+                        if (st.st_size > maxlog) {
+                                char *name = NULL;
+                                if (asprintf(&name, "%s.old", state.debugf ) < 0) {
+                                        return;
+                                }
+                                (void)rename(state.debugf, name);
+                                if (!reopen_logs_internal()) {
+                                        /* We failed to reopen a log - continue using the old name. */
+                                        (void)rename(name, state.debugf);
+                                }
+                                SAFE_FREE(name);
+                        }
+                }
+        }
+        /*
+         * Here's where we need to panic if state.fd == 0 or -1 (invalid values)
+         */
+        if (state.fd <= 0) {
+                /* This code should only be reached in very strange
+                 * circumstances. If we merely fail to open the new log we
+                 * should stick with the old one. ergo this should only be
+                 * reached when opening the logs for the first time: at
+                 * startup or when the log level is increased from zero.
+                 * -dwg 6 June 2000
+                 */
+                int fd = open( "/dev/console", O_WRONLY, 0);
+                if (fd != -1) {
+                        state.fd = fd;
+                        DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
+                                        state.debugf ));
+                } else {
+                        /*
+                         * We cannot continue without a debug file handle.
+                         */
+                        abort();
+                }
+        }
+        debug_count = 0;
+}
+/*************************************************************************
+ Write an debug message on the debugfile.
+ This is called by dbghdr() and format_debug_text().
+************************************************************************/
+ int Debug1( const char *format_str, ... )
+{
+        va_list ap;
+        int old_errno = errno;
+        debug_count++;
+        if ( state.logtype != DEBUG_FILE ) {
+                va_start( ap, format_str );
+                if (state.fd > 0)
+                        (void)vdprintf( state.fd, format_str, ap );
+                va_end( ap );
+                errno = old_errno;
+                goto done;
+        }
+#ifdef WITH_SYSLOG
+        if( !state.settings.syslog_only)
+#endif
+        {
+                if( state.fd <= 0 ) {
+                        mode_t oldumask = umask( 022 );
+                        int fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644 );
+                        (void)umask( oldumask );
+                        if(fd == -1) {
+                                errno = old_errno;
+                                goto done;
+                        }
+                        state.fd = fd;
+                }
+        }
+#ifdef WITH_SYSLOG
+        if( syslog_level < state.settings.syslog ) {
+                /* map debug levels to syslog() priorities
+                 * note that not all DEBUG(0, ...) calls are
+                 * necessarily errors */
+                static const int priority_map[4] = {
+                        LOG_ERR,     /* 0 */
+                        LOG_WARNING, /* 1 */
+                        LOG_NOTICE,  /* 2 */
+                        LOG_INFO,    /* 3 */
+                };
+                int     priority;
+                char *msgbuf = NULL;
+                int ret;
+                if( syslog_level >= ARRAY_SIZE(priority_map) || syslog_level < 0)
+                        priority = LOG_DEBUG;
+                else
+                        priority = priority_map[syslog_level];
+                /*
+                 * Specify the facility to interoperate with other syslog
+                 * callers (vfs_full_audit for example).
+                 */
+                priority |= SYSLOG_FACILITY;
+                va_start(ap, format_str);
+                ret = vasprintf(&msgbuf, format_str, ap);
+                va_end(ap);
+                if (ret != -1) {
+                        syslog(priority, "%s", msgbuf);
+                }
+                SAFE_FREE(msgbuf);
+        }
+#endif
+        check_log_size();
+#ifdef WITH_SYSLOG
+        if( !state.settings.syslog_only)
+#endif
+        {
+                va_start( ap, format_str );
+                if (state.fd > 0)
+                        (void)vdprintf( state.fd, format_str, ap );
+                va_end( ap );
+        }
+ done:
+        errno = old_errno;
+        return( 0 );
+}
+/**************************************************************************
+ Print the buffer content via Debug1(), then reset the buffer.
+ Input:  none
+ Output: none
+****************************************************************************/
+static void bufr_print( void )
+{
+        format_bufr[format_pos] = '\0';
+        (void)Debug1( "%s", format_bufr );
+        format_pos = 0;
+}
+/***************************************************************************
+ Format the debug message text.
+ Input:  msg - Text to be added to the "current" debug message text.
+ Output: none.
+ Notes:  The purpose of this is two-fold.  First, each call to syslog()
+         (used by Debug1(), see above) generates a new line of syslog
+         output.  This is fixed by storing the partial lines until the
+         newline character is encountered.  Second, printing the debug
+         message lines when a newline is encountered allows us to add
+         spaces, thus indenting the body of the message and making it
+         more readable.
+**************************************************************************/
+static void format_debug_text( const char *msg )
+{
+        size_t i;
+        bool timestamp = (state.logtype == DEBUG_FILE && (state.settings.timestamp_logs));
+        if (!format_bufr) {
+                debug_init();
+        }
+        for( i = 0; msg[i]; i++ ) {
+                /* Indent two spaces at each new line. */
+                if(timestamp && 0 == format_pos) {
+                        format_bufr[0] = format_bufr[1] = ' ';
+                        format_pos = 2;
+                }
+                /* If there's room, copy the character to the format buffer. */
+                if( format_pos < FORMAT_BUFR_MAX )
+                        format_bufr[format_pos++] = msg[i];
+                /* If a newline is encountered, print & restart. */
+                if( '\n' == msg[i] )
+                        bufr_print();
+                /* If the buffer is full dump it out, reset it, and put out a line
+                 * continuation indicator.
+                 */
+                if( format_pos >= FORMAT_BUFR_MAX ) {
+                        bufr_print();
+                        (void)Debug1( " +>\n" );
+                }
+        }
+        /* Just to be safe... */
+        format_bufr[format_pos] = '\0';
+}
+/***************************************************************************
+ Flush debug output, including the format buffer content.
+ Input:  none
+ Output: none
+***************************************************************************/
+void dbgflush( void )
+{
+        bufr_print();
+}
+/***************************************************************************
+ Print a Debug Header.
+ Input:  level - Debug level of the message (not the system-wide debug
+                  level. )
+          cls   - Debuglevel class of the calling module.
+          file  - Pointer to a string containing the name of the file
+                  from which this function was called, or an empty string
+                  if the __FILE__ macro is not implemented.
+          func  - Pointer to a string containing the name of the function
+                  from which this function was called, or an empty string
+                  if the __FUNCTION__ macro is not implemented.
+         line  - line number of the call to dbghdr, assuming __LINE__
+                 works.
+  Output: Always true.  This makes it easy to fudge a call to dbghdr()
+          in a macro, since the function can be called as part of a test.
+          Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
+  Notes:  This function takes care of setting syslog_level.
+****************************************************************************/
+bool dbghdrclass(int level, int cls, const char *location, const char *func)
+{
+        /* Ensure we don't lose any real errno value. */
+        int old_errno = errno;
+        if( format_pos ) {
+                /* This is a fudge.  If there is stuff sitting in the format_bufr, then
+                 * the *right* thing to do is to call
+                 *   format_debug_text( "\n" );
+                 * to write the remainder, and then proceed with the new header.
+                 * Unfortunately, there are several places in the code at which
+                 * the DEBUG() macro is used to build partial lines.  That in mind,
+                 * we'll work under the assumption that an incomplete line indicates
+                 * that a new header is *not* desired.
+                 */
+                return( true );
+        }
+#ifdef WITH_SYSLOG
+        /* Set syslog_level. */
+        syslog_level = level;
+#endif
+        /* Don't print a header if we're logging to stdout. */
+        if ( state.logtype != DEBUG_FILE ) {
+                return( true );
+        }
+        /* Print the header if timestamps are turned on.  If parameters are
+         * not yet loaded, then default to timestamps on.
+         */
+        if( state.settings.timestamp_logs || state.settings.debug_prefix_timestamp) {
+                char header_str[200];
+                header_str[0] = '\0';
+                if( state.settings.debug_pid)
+                        slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)getpid());
+                if( state.settings.debug_uid) {
+                        size_t hs_len = strlen(header_str);
+                        slprintf(header_str + hs_len,
+                        sizeof(header_str) - 1 - hs_len,
+                                ", effective(%u, %u), real(%u, %u)",
+                                (unsigned int)geteuid(), (unsigned int)getegid(),
+                                (unsigned int)getuid(), (unsigned int)getgid());
+                }
+                if (state.settings.debug_class && (cls != DBGC_ALL)) {
+                        size_t hs_len = strlen(header_str);
+                        slprintf(header_str + hs_len,
+                                 sizeof(header_str) -1 - hs_len,
+                                 ", class=%s",
+                                 default_classname_table[cls]);
+                }
+                /* Print it all out at once to prevent split syslog output. */
+                if( state.settings.debug_prefix_timestamp ) {
+                        char *time_str = current_timestring(NULL,
+                                                            state.settings.debug_hires_timestamp);
+                        (void)Debug1( "[%s, %2d%s] ",
+                                      time_str,
+                                      level, header_str);
+                        talloc_free(time_str);
+                } else {
+                        char *time_str = current_timestring(NULL,
+                                                            state.settings.debug_hires_timestamp);
+                        (void)Debug1( "[%s, %2d%s] %s(%s)\n",
+                                      time_str,
+                                      level, header_str, location, func );
+                        talloc_free(time_str);
+                }
+        }
+        errno = old_errno;
+        return( true );
+}
+/***************************************************************************
+ Add text to the body of the "current" debug message via the format buffer.
+  Input:  format_str  - Format string, as used in printf(), et. al.
+          ...         - Variable argument list.
+  ..or..  va_alist    - Old style variable parameter list starting point.
+  Output: Always true.  See dbghdr() for more info, though this is not
+          likely to be used in the same way.
+***************************************************************************/
+ bool dbgtext( const char *format_str, ... )
+{
+        va_list ap;
+        char *msgbuf = NULL;
+        bool ret = true;
+        int res;
+        va_start(ap, format_str);
+        res = vasprintf(&msgbuf, format_str, ap);
+        va_end(ap);
+        if (res != -1) {
+                format_debug_text(msgbuf);
+        } else {
+                ret = false;
+        }
+        SAFE_FREE(msgbuf);
+        return ret;
+}
 /* the registered mutex handlers */
 …
 } debug_handlers;
-/* state variables for the debug system */
-static struct {
-        int fd;
-        enum debug_logtype logtype;
-        const char *prog_name;
-        bool reopening_logs;
-} state;
-static bool reopen_logs_scheduled;
-static bool check_reopen_logs(void)
+{
-        if (state.fd == 0 || reopen_logs_scheduled) {
-                reopen_logs_scheduled = false;
-                reopen_logs();
+        }
-        if (state.fd <= 0)
-                return false;
-        return true;
+}
-_PUBLIC_ void debug_schedule_reopen_logs(void)
+{
-        reopen_logs_scheduled = true;
+}
-static void log_timestring(int level, const char *location, const char *func)
+{
-        char *t = NULL;
-        char *s = NULL;
-        if (!check_reopen_logs()) return;
-        if (state.logtype != DEBUG_FILE) return;
-        t = timestring(NULL, time(NULL));
-        if (!t) return;
-        asprintf(&s, "[%s, %d %s:%s()]\n", t, level, location, func);
-        talloc_free(t);
-        if (!s) return;
-        write(state.fd, s, strlen(s));
-        free(s);
+}
-/**
-  the backend for debug messages. Note that the DEBUG() macro has already
-  ensured that the log level has been met before this is called
-*/
-_PUBLIC_ void dbghdr(int level, const char *location, const char *func)
+{
-        log_timestring(level, location, func);
-        log_task_id();
+}
-_PUBLIC_ void dbghdrclass(int level, int dclass, const char *location, const char *func)
+{
-        /* Simple wrapper, Samba 4 doesn't do debug classes */
-        dbghdr(level, location, func);
+}
-/**
-  the backend for debug messages. Note that the DEBUG() macro has already
-  ensured that the log level has been met before this is called
-  @note You should never have to call this function directly. Call the DEBUG()
-  macro instead.
-*/
-_PUBLIC_ void dbgtext(const char *format, ...)
+{
-        va_list ap;
-        char *s = NULL;
-        if (!check_reopen_logs()) return;
-        va_start(ap, format);
-        vasprintf(&s, format, ap);
-        va_end(ap);
-        write(state.fd, s, strlen(s));
-        free(s);
+}
-_PUBLIC_ const char *logfile = NULL;
-/**
-  reopen the log file (usually called because the log file name might have changed)
-*/
-_PUBLIC_ void reopen_logs(void)
+{
-        char *fname = NULL;
-        int old_fd = state.fd;
-        if (state.reopening_logs) {
-                return;
+        }
-        switch (state.logtype) {
-        case DEBUG_STDOUT:
-                state.fd = 1;
-                break;
-        case DEBUG_STDERR:
-                state.fd = 2;
-                break;
-        case DEBUG_FILE:
-                state.reopening_logs = true;
-                if (logfile && (*logfile) == '/') {
-                        fname = strdup(logfile);
-                } else {
-                        asprintf(&fname, "%s/%s.log", dyn_LOGFILEBASE, state.prog_name);
+                }
-                if (fname) {
-                        int newfd = open(fname, O_CREAT|O_APPEND|O_WRONLY, 0600);
-                        if (newfd == -1) {
-                                DEBUG(1, ("Failed to open new logfile: %s\n", fname));
-                                old_fd = -1;
-                        } else {
-                                state.fd = newfd;
+                        }
-                        free(fname);
-                } else {
-                        DEBUG(1, ("Failed to find name for file-based logfile!\n"));
+                }
-                state.reopening_logs = false;
-                break;
+        }
-        if (old_fd > 2) {
-                close(old_fd);
+        }
+}
-/**
-  control the name of the logfile and whether logging will be to stdout, stderr
-  or a file
-*/
-_PUBLIC_ void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
+{
-        if (state.logtype < new_logtype) {
-                state.logtype = new_logtype;
+        }
-        if (prog_name) {
-                state.prog_name = prog_name;
+        }
-        reopen_logs();
+}
-/**
-   Just run logging to stdout for this program
-*/
-_PUBLIC_ void setup_logging_stdout(void)
+{
-        setup_logging(NULL, DEBUG_STDOUT);
+}
-/**
-  return a string constant containing n tabs
-  no more than 10 tabs are returned
-*/
-_PUBLIC_ const char *do_debug_tab(int n)
+{
-        const char *tabs[] = {"", "\t", "\t\t", "\t\t\t", "\t\t\t\t", "\t\t\t\t\t",
-                              "\t\t\t\t\t\t", "\t\t\t\t\t\t\t", "\t\t\t\t\t\t\t\t",
-                              "\t\t\t\t\t\t\t\t\t", "\t\t\t\t\t\t\t\t\t\t"};
-        return tabs[MIN(n, 10)];
+}
 /**
   log suspicious usage - print comments and backtrace
 …
         if (!debug_handlers.ops.log_task_id) return;
         if (!check_reopen_logs()) return;
+        if (!reopen_logs_internal()) return;
         debug_handlers.ops.log_task_id(state.fd);

vendor/current/lib/util/debug.h

-              r414
+              r740
 /*
    Unix SMB/CIFS implementation.
+   Samba debug defines
+   Copyright (C) Andrew Tridgell 2003
+   SMB debug stuff
+   Copyright (C) Andrew Tridgell 1992-1998
+   Copyright (C) John H Terpstra 1996-1998
+   Copyright (C) Luke Kenneth Casson Leighton 1996-1998
+   Copyright (C) Paul Ashton 1998
    This program is free software; you can redistribute it and/or modify
 …
    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/>.
 */
+#ifndef _SAMBA_DEBUG_H_
+#define _SAMBA_DEBUG_H_
+/**
+ * @file
+ * @brief Debugging macros
+ */
+/* the debug operations structure - contains function pointers to
+   various debug implementations of each operation */
+struct debug_ops {
+        /* function to log (using DEBUG) suspicious usage of data structure */
+        void (*log_suspicious_usage)(const char* from, const char* info);
+        /* function to log (using printf) suspicious usage of data structure.
+         * To be used in circumstances when using DEBUG would cause loop. */
+        void (*print_suspicious_usage)(const char* from, const char* info);
+        /* function to return process/thread id */
+        uint32_t (*get_task_id)(void);
+        /* function to log process/thread id */
+        void (*log_task_id)(int fd);
+};
+#define DEBUGLEVEL *debug_level
+extern int DEBUGLEVEL;
+#define debug_ctx() (_debug_ctx?_debug_ctx:(_debug_ctx=talloc_new(NULL)))
+#define DEBUGLVL(level) ((level) <= DEBUGLEVEL)
+#define _DEBUG(level, body, header) do { \
+        if (DEBUGLVL(level)) { \
+                void* _debug_ctx=NULL; \
+                if (header) { \
+                        dbghdr(level, __location__, __FUNCTION__); \
+                } \
+                dbgtext body; \
+                talloc_free(_debug_ctx); \
+        } \
+} while (0)
+/**
+ * Write to the debug log.
+ */
+#define DEBUG(level, body) _DEBUG(level, body, true)
+/**
+ * Add data to an existing debug log entry.
+ */
+#define DEBUGADD(level, body) _DEBUG(level, body, false)
+/**
+ * Obtain indentation string for the debug log.
+ *
+ * Level specified by n.
+ */
+#define DEBUGTAB(n) do_debug_tab(n)
+#ifndef _DEBUG_H
+#define _DEBUG_H
+/* -------------------------------------------------------------------------- **
+ * Debugging code.  See also debug.c
+ */
+/* the maximum debug level to compile into the code. This assumes a good
+   optimising compiler that can remove unused code
+   for embedded or low-memory systems set this to a value like 2 to get
+   only important messages. This gives *much* smaller binaries
+*/
+#ifndef MAX_DEBUG_LEVEL
+#define MAX_DEBUG_LEVEL 1000
+#endif
+int  Debug1( const char *, ... ) PRINTF_ATTRIBUTE(1,2);
+bool dbgtext( const char *, ... ) PRINTF_ATTRIBUTE(1,2);
+bool dbghdrclass( int level, int cls, const char *location, const char *func);
+bool dbghdr( int level, const char *location, const char *func);
+/*
+ * Redefine DEBUGLEVEL because so we don't have to change every source file
+ * that *unnecessarily* references it.
+ */
+#define DEBUGLEVEL DEBUGLEVEL_CLASS[DBGC_ALL]
+/*
+ * Define all new debug classes here. A class is represented by an entry in
+ * the DEBUGLEVEL_CLASS array. Index zero of this arrray is equivalent to the
+ * old DEBUGLEVEL. Any source file that does NOT add the following lines:
+ *
+ *   #undef  DBGC_CLASS
+ *   #define DBGC_CLASS DBGC_<your class name here>
+ *
+ * at the start of the file (after #include "includes.h") will default to
+ * using index zero, so it will behaive just like it always has.
+ */
+#define DBGC_ALL                0 /* index equivalent to DEBUGLEVEL */
+#define DBGC_TDB                1
+#define DBGC_PRINTDRIVERS       2
+#define DBGC_LANMAN             3
+#define DBGC_SMB                4
+#define DBGC_RPC_PARSE          5
+#define DBGC_RPC_SRV            6
+#define DBGC_RPC_CLI            7
+#define DBGC_PASSDB             8
+#define DBGC_SAM                9
+#define DBGC_AUTH               10
+#define DBGC_WINBIND            11
+#define DBGC_VFS                12
+#define DBGC_IDMAP              13
+#define DBGC_QUOTA              14
+#define DBGC_ACLS               15
+#define DBGC_LOCKING            16
+#define DBGC_MSDFS              17
+#define DBGC_DMAPI              18
+#define DBGC_REGISTRY           19
+/* Always ensure this is updated when new fixed classes area added, to ensure the array in debug.c is the right size */
+#define DBGC_MAX_FIXED          19
+/* So you can define DBGC_CLASS before including debug.h */
+#ifndef DBGC_CLASS
+#define DBGC_CLASS            0     /* override as shown above */
+#endif
+extern int  *DEBUGLEVEL_CLASS;
+/* Debugging macros
+ *
+ * DEBUGLVL()
+ *   If the 'file specific' debug class level >= level OR the system-wide
+ *   DEBUGLEVEL (synomym for DEBUGLEVEL_CLASS[ DBGC_ALL ]) >= level then
+ *   generate a header using the default macros for file, line, and
+ *   function name. Returns True if the debug level was <= DEBUGLEVEL.
+ *
+ *   Example: if( DEBUGLVL( 2 ) ) dbgtext( "Some text.\n" );
+ *
+ * DEBUG()
+ *   If the 'file specific' debug class level >= level OR the system-wide
+ *   DEBUGLEVEL (synomym for DEBUGLEVEL_CLASS[ DBGC_ALL ]) >= level then
+ *   generate a header using the default macros for file, line, and
+ *   function name. Each call to DEBUG() generates a new header *unless* the
+ *   previous debug output was unterminated (i.e. no '\n').
+ *   See debug.c:dbghdr() for more info.
+ *
+ *   Example: DEBUG( 2, ("Some text and a value %d.\n", value) );
+ *
+ * DEBUGC()
+ *   If the 'macro specified' debug class level >= level OR the system-wide
+ *   DEBUGLEVEL (synomym for DEBUGLEVEL_CLASS[ DBGC_ALL ]) >= level then
+ *   generate a header using the default macros for file, line, and
+ *   function name. Each call to DEBUG() generates a new header *unless* the
+ *   previous debug output was unterminated (i.e. no '\n').
+ *   See debug.c:dbghdr() for more info.
+ *
+ *   Example: DEBUGC( DBGC_TDB, 2, ("Some text and a value %d.\n", value) );
+ *
+ *  DEBUGADD(), DEBUGADDC()
+ *    Same as DEBUG() and DEBUGC() except the text is appended to the previous
+ *    DEBUG(), DEBUGC(), DEBUGADD(), DEBUGADDC() with out another interviening
+ *    header.
+ *
+ *    Example: DEBUGADD( 2, ("Some text and a value %d.\n", value) );
+ *             DEBUGADDC( DBGC_TDB, 2, ("Some text and a value %d.\n", value) );
+ *
+ * Note: If the debug class has not be redeined (see above) then the optimizer
+ * will remove the extra conditional test.
+ */
+/*
+ * From talloc.c:
+ */
+/* these macros gain us a few percent of speed on gcc */
+#if (__GNUC__ >= 3)
+/* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
+   as its first argument */
+#ifndef likely
+#define likely(x)   __builtin_expect(!!(x), 1)
+#endif
+#ifndef unlikely
+#define unlikely(x) __builtin_expect(!!(x), 0)
+#endif
+#else
+#ifndef likely
+#define likely(x) (x)
+#endif
+#ifndef unlikely
+#define unlikely(x) (x)
+#endif
+#endif
+#define CHECK_DEBUGLVL( level ) \
+  ( ((level) <= MAX_DEBUG_LEVEL) && \
+    unlikely(DEBUGLEVEL_CLASS[ DBGC_CLASS ] >= (level)))
+#define DEBUGLVL( level ) \
+  ( CHECK_DEBUGLVL(level) \
+   && dbghdrclass( level, DBGC_CLASS, __location__, __FUNCTION__ ) )
+#define DEBUG( level, body ) \
+  (void)( ((level) <= MAX_DEBUG_LEVEL) && \
+          unlikely(DEBUGLEVEL_CLASS[ DBGC_CLASS ] >= (level))           \
+       && (dbghdrclass( level, DBGC_CLASS, __location__, __FUNCTION__ )) \
+       && (dbgtext body) )
+#define DEBUGC( dbgc_class, level, body ) \
+  (void)( ((level) <= MAX_DEBUG_LEVEL) && \
+          unlikely(DEBUGLEVEL_CLASS[ dbgc_class ] >= (level))           \
+       && (dbghdrclass( level, DBGC_CLASS, __location__, __FUNCTION__ )) \
+       && (dbgtext body) )
+#define DEBUGADD( level, body ) \
+  (void)( ((level) <= MAX_DEBUG_LEVEL) && \
+          unlikely(DEBUGLEVEL_CLASS[ DBGC_CLASS ] >= (level))   \
+       && (dbgtext body) )
+#define DEBUGADDC( dbgc_class, level, body ) \
+  (void)( ((level) <= MAX_DEBUG_LEVEL) && \
+          unlikely((DEBUGLEVEL_CLASS[ dbgc_class ] >= (level))) \
+       && (dbgtext body) )
+/* Print a separator to the debug log. */
+#define DEBUGSEP(level)\
+        DEBUG((level),("===============================================================\n"))
+/* The following definitions come from lib/debug.c  */
 /** Possible destinations for the debug log (in order of precedence -
 …
  * the command line, as the smb.conf cannot reset it back to
  * file-based logging */
+enum debug_logtype {DEBUG_STDOUT = 0, DEBUG_FILE = 1, DEBUG_STDERR = 2};
+/**
+  the backend for debug messages. Note that the DEBUG() macro has already
+  ensured that the log level has been met before this is called
+*/
+_PUBLIC_ void dbghdr(int level, const char *location, const char *func);
+_PUBLIC_ void dbghdrclass(int level, int cls, const char *location, const char *func);
+/**
+  reopen the log file (usually called because the log file name might have changed)
+*/
+_PUBLIC_ void reopen_logs(void);
+/**
+ * this global variable determines what messages are printed
+ */
+_PUBLIC_ void debug_schedule_reopen_logs(void);
+/**
+  control the name of the logfile and whether logging will be to stdout, stderr
+  or a file
+*/
+_PUBLIC_ void setup_logging(const char *prog_name, enum debug_logtype new_logtype);
+/**
+   Just run logging to stdout for this program
+*/
+_PUBLIC_ void setup_logging_stdout(void);
+/**
+  return a string constant containing n tabs
+  no more than 10 tabs are returned
+*/
+_PUBLIC_ const char *do_debug_tab(int n);
+enum debug_logtype {DEBUG_DEFAULT_STDERR = 0, DEBUG_STDOUT = 1, DEBUG_FILE = 2, DEBUG_STDERR = 3};
+struct debug_settings {
+        size_t max_log_size;
+        bool syslog;
+        bool syslog_only;
+        bool timestamp_logs;
+        bool debug_prefix_timestamp;
+        bool debug_hires_timestamp;
+        bool debug_pid;
+        bool debug_uid;
+        bool debug_class;
+};
+void setup_logging(const char *prog_name, enum debug_logtype new_logtype);
+void debug_close_dbf(void);
+void gfree_debugsyms(void);
+int debug_add_class(const char *classname);
+int debug_lookup_classname(const char *classname);
+bool debug_parse_levels(const char *params_str);
+void debug_setup_talloc_log(void);
+void debug_set_logfile(const char *name);
+void debug_set_settings(struct debug_settings *settings);
+bool reopen_logs_internal( void );
+void force_check_log_size( void );
+bool need_to_check_log_size( void );
+void check_log_size( void );
+void dbgflush( void );
+bool dbghdrclass(int level, int cls, const char *location, const char *func);
+bool dbghdr(int level, const char *location, const char *func);
+bool debug_get_output_is_stderr(void);
+void debug_schedule_reopen_logs(void);
+char *debug_list_class_names_and_levels(void);
 /**
 …
 _PUBLIC_ void log_task_id(void);
+/* the debug operations structure - contains function pointers to
+   various debug implementations of each operation */
+struct debug_ops {
+        /* function to log (using DEBUG) suspicious usage of data structure */
+        void (*log_suspicious_usage)(const char* from, const char* info);
+        /* function to log (using printf) suspicious usage of data structure.
+         * To be used in circumstances when using DEBUG would cause loop. */
+        void (*print_suspicious_usage)(const char* from, const char* info);
+        /* function to return process/thread id */
+        uint32_t (*get_task_id)(void);
+        /* function to log process/thread id */
+        void (*log_task_id)(int fd);
+};
 /**
   register a set of debug handlers.
 …
 _PUBLIC_ void register_debug_handlers(const char *name, struct debug_ops *ops);
+/**
+  the backend for debug messages. Note that the DEBUG() macro has already
+  ensured that the log level has been met before this is called
+  @note You should never have to call this function directly. Call the DEBUG()
+  macro instead.
+*/
+_PUBLIC_ void dbgtext(const char *format, ...) PRINTF_ATTRIBUTE(1,2);
+struct _XFILE;
+extern struct _XFILE *dbf;
+#endif
+#endif

vendor/current/lib/util/dlinklist.h

-              r414
+              r740
    Unix SMB/CIFS implementation.
    some simple double linked list macros
+   Copyright (C) Andrew Tridgell 1998
+   Copyright (C) Andrew Tridgell 1998-2010
    This program is free software; you can redistribute it and/or modify
 …
 #define _DLINKLIST_H
+/*
+  February 2010 - changed list format to have a prev pointer from the
+  list head. This makes DLIST_ADD_END() O(1) even though we only have
+  one list pointer.
+/* hook into the front of the list */
+  The scheme is as follows:
+) with no entries in the list:
+          list_head == NULL
+) with 1 entry in the list:
+          list_head->next == NULL
+          list_head->prev == list_head
+) with 2 entries in the list:
+          list_head->next == element2
+          list_head->prev == element2
+          element2->prev == list_head
+          element2->next == NULL
+) with N entries in the list:
+          list_head->next == element2
+          list_head->prev == elementN
+          elementN->prev == element{N-1}
+          elementN->next == NULL
+  This allows us to find the tail of the list by using
+  list_head->prev, which means we can add to the end of the list in
+  O(1) time
+  Note that the 'type' arguments below are no longer needed, but
+  are kept for now to prevent an incompatible argument change
+ */
+/*
+   add an element at the front of a list
+*/
 #define DLIST_ADD(list, p) \
 do { \
         if (!(list)) { \
                 (list) = (p); \
                 (p)->next = (p)->prev = NULL; \
+                (p)->prev = (list) = (p);  \
+                (p)->next = NULL; \
         } else { \
+                (p)->prev = (list)->prev; \
                 (list)->prev = (p); \
                 (p)->next = (list); \
-                (p)->prev = NULL; \
                 (list) = (p); \
         }\
+        } \
 } while (0)
+/* remove an element from a list - element doesn't have to be in list. */
+/*
+   remove an element from a list
+   Note that the element doesn't have to be in the list. If it
+   isn't then this is a no-op
+*/
 #define DLIST_REMOVE(list, p) \
 do { \
         if ((p) == (list)) { \
+                if ((p)->next) (p)->next->prev = (p)->prev; \
                 (list) = (p)->next; \
+                if (list) (list)->prev = NULL; \
+        } else if ((list) && (p) == (list)->prev) {     \
+                (p)->prev->next = NULL; \
+                (list)->prev = (p)->prev; \
         } else { \
                 if ((p)->prev) (p)->prev->next = (p)->next; \
                 if ((p)->next) (p)->next->prev = (p)->prev; \
         } \
         if ((p) != (list)) (p)->next = (p)->prev = NULL; \
+        if ((p) != (list)) (p)->next = (p)->prev = NULL;        \
 } while (0)
+/* promote an element to the top of the list */
+#define DLIST_PROMOTE(list, p) \
+/*
+   find the head of the list given any element in it.
+   Note that this costs O(N), so you should avoid this macro
+   if at all possible!
+*/
+#define DLIST_HEAD(p, result_head) \
 do { \
           DLIST_REMOVE(list, p); \
           DLIST_ADD(list, p); \
 } while (0)
+       (result_head) = (p); \
+       while (DLIST_PREV(result_head)) (result_head) = (result_head)->prev; \
+} while(0)
+/* hook into the end of the list - needs the entry type */
+#define DLIST_ADD_END(list, p, type) \
+do { \
+                if (!(list)) { \
+                        (list) = (p); \
+                        (p)->next = (p)->prev = NULL; \
+                } else { \
+                        type tmp; \
+                        for (tmp = (list); tmp->next; tmp = tmp->next) ; \
+                        tmp->next = (p); \
+                        (p)->next = NULL; \
+                        (p)->prev = tmp; \
+                } \
+} while (0)
+/* return the last element in the list */
+#define DLIST_TAIL(list) ((list)?(list)->prev:NULL)
+/* return the previous element in the list. */
+#define DLIST_PREV(p) (((p)->prev && (p)->prev->next != NULL)?(p)->prev:NULL)
 /* insert 'p' after the given element 'el' in a list. If el is NULL then
 …
                 DLIST_ADD(list, p); \
         } else { \
+                p->prev = el; \
+                p->next = el->next; \
+                el->next = p; \
+                if (p->next) p->next->prev = p; \
+                (p)->prev = (el);   \
+                (p)->next = (el)->next;         \
+                (el)->next = (p);               \
+                if ((p)->next) (p)->next->prev = (p);   \
+                if ((list)->prev == (el)) (list)->prev = (p); \
         }\
 } while (0)
+/* demote an element to the end of the list, needs the entry type */
+#define DLIST_DEMOTE(list, p, type) \
+/*
+   add to the end of a list.
+   Note that 'type' is ignored
+*/
+#define DLIST_ADD_END(list, p, type)                    \
 do { \
+                DLIST_REMOVE(list, p); \
+                DLIST_ADD_END(list, p, type); \
+        if (!(list)) { \
+                DLIST_ADD(list, p); \
+        } else { \
+                DLIST_ADD_AFTER(list, p, (list)->prev); \
+        } \
 } while (0)
+/* concatenate two lists - putting all elements of the 2nd list at the
+   end of the first list */
+#define DLIST_CONCATENATE(list1, list2, type) \
+/* promote an element to the from of a list */
+#define DLIST_PROMOTE(list, p) \
 do { \
+                if (!(list1)) { \
+                        (list1) = (list2); \
+                } else { \
+                        type tmp; \
+                        for (tmp = (list1); tmp->next; tmp = tmp->next) ; \
+                        tmp->next = (list2); \
+                        if (list2) { \
+                                (list2)->prev = tmp;    \
+                        } \
+          DLIST_REMOVE(list, p); \
+          DLIST_ADD(list, p); \
+} while (0)
+/*
+   demote an element to the end of a list.
+   Note that 'type' is ignored
+*/
+#define DLIST_DEMOTE(list, p, type)                     \
+do { \
+        DLIST_REMOVE(list, p); \
+        DLIST_ADD_END(list, p, NULL);           \
+} while (0)
+/*
+   concatenate two lists - putting all elements of the 2nd list at the
+   end of the first list.
+   Note that 'type' is ignored
+*/
+#define DLIST_CONCATENATE(list1, list2, type)   \
+do { \
+        if (!(list1)) { \
+                (list1) = (list2); \
+        } else { \
+                (list1)->prev->next = (list2); \
+                if (list2) { \
+                        void *_tmplist = (void *)(list1)->prev; \
+                        (list1)->prev = (list2)->prev; \
+                        (list2)->prev = _tmplist; \
                 } \
+        } \
 } while (0)

vendor/current/lib/util/fault.c

-              r414
+              r740
 #endif
         void *backtrace_stack[BACKTRACE_STACK_SIZE];
         size_t backtrace_size;
+        int backtrace_size;
         char **backtrace_strings;
 …
                 char cmdstring[200];
                 safe_strcpy(cmdstring, panic_action, sizeof(cmdstring));
                 snprintf(pidstr, sizeof(pidstr), "%u", getpid());
+                snprintf(pidstr, sizeof(pidstr), "%d", (int) getpid());
                 all_string_sub(cmdstring, "%PID%", pidstr, sizeof(cmdstring));
                 if (progname) {
 …
 #ifdef SIGABRT
         CatchSignal(SIGABRT,SIGNAL_CAST SIG_DFL);
+        CatchSignal(SIGABRT, SIG_DFL);
 #endif
         abort();
 …
 _PUBLIC_ void fault_setup(const char *pname)
+{
+        if (progname == NULL) {
+                progname = pname;
+        }
+        if (progname != NULL) {
+                return;
+        }
+        progname = pname;
 #ifdef SIGSEGV
         CatchSignal(SIGSEGV,SIGNAL_CAST sig_fault);
+        CatchSignal(SIGSEGV, sig_fault);
 #endif
 #ifdef SIGBUS
         CatchSignal(SIGBUS,SIGNAL_CAST sig_fault);
+        CatchSignal(SIGBUS, sig_fault);
 #endif
 #ifdef SIGABRT
         CatchSignal(SIGABRT,SIGNAL_CAST sig_fault);
+        CatchSignal(SIGABRT, sig_fault);
 #endif
 #ifdef SIGFPE
+        CatchSignal(SIGFPE,SIGNAL_CAST sig_fault);
+#endif
+}
+        CatchSignal(SIGFPE, sig_fault);
+#endif
+}
+/**
+   disable setting up fault handlers
+**/
+_PUBLIC_ void fault_setup_disable(void)
+{
+        progname = "fault disabled";
+}
 /**

vendor/current/lib/util/genrand.c

-              r414
+              r740
 /**
+ * Generate a random text password.
+ */
+_PUBLIC_ char *generate_random_password(TALLOC_CTX *mem_ctx, size_t min, size_t max)
+{
+        char *retstr;
+        /* This list does not include { or } because they cause
+         * problems for our provision (it can create a substring
+         * ${...}, and for Fedora DS (which treats {...} at the start
+         * of a stored password as special
+         *  -- Andrew Bartlett 2010-03-11
+         */
+        const char *c_list = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+_-#.,@$%&!?:;<=>()[]~";
+        size_t len = max;
+        size_t diff;
+        if (min > max) {
+                errno = EINVAL;
+                return NULL;
+        }
+        diff = max - min;
+        if (diff > 0 ) {
+                size_t tmp;
+                generate_random_buffer((uint8_t *)&tmp, sizeof(tmp));
+                tmp %= diff;
+                len = min + tmp;
+        }
+again:
+        retstr = generate_random_str_list(mem_ctx, len, c_list);
+        if (!retstr) return NULL;
+        /* we need to make sure the random string passes basic quality tests
+           or it might be rejected by windows as a password */
+        if (len >= 7 && !check_password_quality(retstr)) {
+                talloc_free(retstr);
+                goto again;
+        }
+        return retstr;
+}
+/**
  * Generate an array of unique text strings all of the same length.
  * The returned string will be allocated.

vendor/current/lib/util/idtree.c

-              r414
+              r740
         int n, m, sh;
         struct idr_layer *p, *pn;
         struct idr_layer *pa[MAX_LEVEL];
         int l, id, oid;
+        struct idr_layer *pa[MAX_LEVEL+1];
+        unsigned int l, id, oid;
         uint32_t bm;
 …
+{
         struct idr_layer *p = idp->top;
         struct idr_layer **pa[MAX_LEVEL];
+        struct idr_layer **pa[1+MAX_LEVEL];
         struct idr_layer ***paa = &pa[0];
         int n;
 …
          * present.  If so, tain't one of ours!
          */
+        if ((id & ~(~0 << MAX_ID_SHIFT)) >> (n + IDR_BITS))
+             return NULL;
+        if (n + IDR_BITS < 31 &&
+            ((id & ~(~0 << MAX_ID_SHIFT)) >> (n + IDR_BITS))) {
+                return NULL;
+        }
         /* Mask off upper bits we don't use for the search. */

vendor/current/lib/util/memory.h

r414	r740
29	29	* always be ignored.
30	30	**/
31		#define SAFE_FREE(x) do { if ((x) != NULL) {free(~~discard_const_p(void *, (x))~~); (x)=NULL;} } while(0)
	31	#define SAFE_FREE(x) do { if ((x) != NULL) {free(x); (x)=NULL;} } while(0)
32	32	#endif
33	33

vendor/current/lib/util/params.c

-              r594
+              r740
   } /* Parse */
 static myFILE *OpenConfFile( const char *FileName )
+static myFILE *OpenConfFile(TALLOC_CTX *mem_ctx, const char *FileName )
   /* ------------------------------------------------------------------------ **
    * Open a configuration file.
 …
   myFILE *ret;
   ret = talloc(talloc_autofree_context(), myFILE);
+  ret = talloc(mem_ctx, myFILE);
   if (!ret) return NULL;
 …
   const char *func = "params.c:pm_process() -";
   InFile = OpenConfFile( FileName );          /* Open the config file. */
+  InFile = OpenConfFile(NULL, FileName); /* Open the config file. */
   if( NULL == InFile )
     return( false );

vendor/current/lib/util/system.c

-              r414
+              r740
         return mypid;
+}
+_PUBLIC_ int sys_getpeereid( int s, uid_t *uid)
+{
+#if defined(HAVE_PEERCRED)
+        struct ucred cred;
+        socklen_t cred_len = sizeof(struct ucred);
+        int ret;
+        ret = getsockopt(s, SOL_SOCKET, SO_PEERCRED, (void *)&cred, &cred_len);
+        if (ret != 0) {
+                return -1;
+        }
+        if (cred_len != sizeof(struct ucred)) {
+                errno = EINVAL;
+                return -1;
+        }
+        *uid = cred.uid;
+        return 0;
+#else
+#if defined(HAVE_GETPEEREID)
+        gid_t gid;
+        return getpeereid(s, uid, &gid);
+#endif
+        errno = ENOSYS;
+        return -1;
+#endif
+}
+_PUBLIC_ int sys_getnameinfo(const struct sockaddr *psa,
+                             int salen,
+                             char *host,
+                             size_t hostlen,
+                             char *service,
+                             size_t servlen,
+                             int flags)
+{
+        /*
+         * For Solaris we must make sure salen is the
+         * correct length for the incoming sa_family.
+         */
+        if (salen == sizeof(struct sockaddr_storage)) {
+                salen = sizeof(struct sockaddr_in);
+#if defined(HAVE_IPV6)
+                if (psa->sa_family == AF_INET6) {
+                        salen = sizeof(struct sockaddr_in6);
+                }
+#endif
+        }
+        return getnameinfo(psa, salen, host, hostlen, service, servlen, flags);
+}
+_PUBLIC_ int sys_connect(int fd, const struct sockaddr * addr)
+{
+        socklen_t salen = (socklen_t)-1;
+        if (addr->sa_family == AF_INET) {
+            salen = sizeof(struct sockaddr_in);
+        } else if (addr->sa_family == AF_UNIX) {
+            salen = sizeof(struct sockaddr_un);
+        }
+#if defined(HAVE_IPV6)
+        else if (addr->sa_family == AF_INET6) {
+            salen = sizeof(struct sockaddr_in6);
+        }
+#endif
+        return connect(fd, addr, salen);
+}

vendor/current/lib/util/talloc_stack.c

-              r427
+              r740
+{
 #if defined(PARANOID_MALLOC_CHECKER)
 #ifdef malloc
 #undef malloc
+#ifdef calloc
+#undef calloc
 #endif
 #endif
         struct talloc_stackframe *ts =
                 (struct talloc_stackframe *)malloc(sizeof(struct talloc_stackframe));
+        struct talloc_stackframe *ts = (struct talloc_stackframe *)calloc(
+, sizeof(struct talloc_stackframe));
 #if defined(PARANOID_MALLOC_CHECKER)
 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
+#define calloc(n, s) __ERROR_DONT_USE_MALLOC_DIRECTLY
 #endif
 …
                 smb_panic("talloc_stackframe_init malloc failed");
+        }
-        ZERO_STRUCTP(ts);
         SMB_THREAD_ONCE(&ts_initialized, talloc_stackframe_init, NULL);
 …
                         break;
+                }
+                talloc_free(ts->talloc_stack[i]);
+                ts->talloc_stack[i] = NULL;
+                TALLOC_FREE(ts->talloc_stack[i]);
+        }

vendor/current/lib/util/talloc_stack.h

r414	r740
36	36	#define _TALLOC_STACK_H
37	37
38		#include ~~"talloc.h"~~
	38	#include <talloc.h>
39	39
40	40	/*

vendor/current/lib/util/tests/data_blob.c

r414	r740
79	79	{
80	80	DATA_BLOB a = data_blob_string_const("\xC\xA\xF\xE");
81		torture_assert_str_equal(tctx, data_blob_hex_string(tctx, &a), "0C0A0F0E", "hex string");
	81	torture_assert_str_equal(tctx, data_blob_hex_string_lower(tctx, &a), "0c0a0f0e", "hex string");
	82	torture_assert_str_equal(tctx, data_blob_hex_string_upper(tctx, &a), "0C0A0F0E", "hex string");
82	83	return true;
83	84	}
…	…
85	86	struct torture_suite torture_local_util_data_blob(TALLOC_CTX mem_ctx)
86	87	{
87		struct torture_suite *suite = torture_suite_create(mem_ctx, "~~DATABLOB~~");
	88	struct torture_suite *suite = torture_suite_create(mem_ctx, "datablob");
88	89
89	90	torture_suite_add_simple_test(suite, "string", test_string);

vendor/current/lib/util/tests/file.c

-              r414
+              r740
 struct torture_suite *torture_local_util_file(TALLOC_CTX *mem_ctx)
+{
         struct torture_suite *suite = torture_suite_create(mem_ctx, "FILE");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "file");
         torture_suite_add_simple_test(suite, "file_load_save",
                                       test_file_load_save);
+        torture_suite_add_simple_test(suite, "afdgets",
+                                      test_afdgets);
+        torture_suite_add_simple_test(suite, "afdgets", test_afdgets);
         return suite;

vendor/current/lib/util/tests/genrand.c

r414	r740
60	60	struct torture_suite torture_local_genrand(TALLOC_CTX mem_ctx)
61	61	{
62		struct torture_suite *suite = torture_suite_create(mem_ctx, "~~GENRAND~~");
	62	struct torture_suite *suite = torture_suite_create(mem_ctx, "genrand");
63	63	torture_suite_add_simple_test(suite, "reseed_callback", test_reseed_callback);
64	64	torture_suite_add_simple_test(suite, "check_password_quality", test_check_password_quality);

vendor/current/lib/util/tests/idtree.c

r414	r740
116	116	struct torture_suite torture_local_idtree(TALLOC_CTX mem_ctx)
117	117	{
118		struct torture_suite *suite = torture_suite_create(mem_ctx, "~~IDTREE~~");
	118	struct torture_suite *suite = torture_suite_create(mem_ctx, "idtree");
119	119	torture_suite_add_simple_test(suite, "idtree", torture_local_idtree_simple);
120	120	return suite;

vendor/current/lib/util/tests/parmlist.c

-              r414
+              r740
         torture_assert_str_equal(tctx, e->value, "mystring", "value");
         e = parmlist_get(pctx, "nonexistant");
         torture_assert(tctx, e == NULL, "nonexistant");
+        e = parmlist_get(pctx, "non-existent");
+        torture_assert(tctx, e == NULL, "non-existent");
         return true;
+}
 …
         torture_assert_str_equal(tctx, "true", ret[0], "ret[0]");
         torture_assert_str_equal(tctx, "false", ret[1], "ret[1]");
         torture_assert(tctx, NULL == parmlist_get_string_list(pctx, "nonexistant", NULL), "nonexistant");
+        torture_assert(tctx, NULL == parmlist_get_string_list(pctx, "non-existent", NULL), "non-existent");
         return true;
 …
 struct torture_suite *torture_local_util_parmlist(TALLOC_CTX *mem_ctx)
+{
         struct torture_suite *suite = torture_suite_create(mem_ctx, "PARMLIST");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "parmlist");
         torture_suite_add_simple_test(suite, "get_int", test_get_int);

vendor/current/lib/util/tests/str.c

r414	r740
95	95	struct torture_suite torture_local_util_str(TALLOC_CTX mem_ctx)
96	96	{
97		struct torture_suite *suite = torture_suite_create(mem_ctx, "~~STR~~");
	97	struct torture_suite *suite = torture_suite_create(mem_ctx, "str");
98	98
99	99	torture_suite_add_simple_test(suite, "string_sub_simple",

vendor/current/lib/util/tests/strlist.c

-              r414
+              r740
 struct test_list_element {
         const char *list_as_string;
         const char *seperators;
+        const char *separators;
         const char *list[5];
 };
 struct test_list_element test_lists_strings[] = {
+const struct test_list_element test_lists_strings[] = {
+        {
                 .list_as_string = "",
 …
                 .list_as_string = "foo bar",
                 .list = { "foo bar", NULL },
                 .seperators = ";"
+                .separators = ";"
         },
+        {
 …
                 .list_as_string = "\"foo bar\",comma;semicolon",
                 .list = { "\"foo bar\",comma", "semicolon", NULL },
                 .seperators = ";"
+                .separators = ";"
+        }
 };
 struct test_list_element test_lists_shell_strings[] = {
+const struct test_list_element test_lists_shell_strings[] = {
+        {
                 .list_as_string = "",
 …
                 .list_as_string = "foo bar",
                 .list = { "foo bar", NULL },
                 .seperators = ";"
+                .separators = ";"
         },
+        {
 …
 };
+static bool test_lists_shell(struct torture_context *tctx,
+                             const void *data)
+static bool test_lists_shell(struct torture_context *tctx, const void *data)
+{
         const struct test_list_element *element = data;
+        const char **ret1, **ret2, *tmp;
+        char **ret1, **ret2, *tmp;
         bool match = true;
         TALLOC_CTX *mem_ctx = tctx;
         ret1 = str_list_make_shell(mem_ctx, element->list_as_string, element->seperators);
+        ret1 = str_list_make_shell(mem_ctx, element->list_as_string, element->separators);
         torture_assert(tctx, ret1, "str_list_make_shell() must not return NULL");
         tmp = str_list_join_shell(mem_ctx, ret1, element->seperators ? *element->seperators : ' ');
         ret2 = str_list_make_shell(mem_ctx, tmp, element->seperators);
+        tmp = str_list_join_shell(mem_ctx, (const char **) ret1, element->separators ? *element->separators : ' ');
+        ret2 = str_list_make_shell(mem_ctx, tmp, element->separators);
         if ((ret1 == NULL || ret2 == NULL) && ret2 != ret1) {
 …
         torture_assert(tctx, match, talloc_asprintf(tctx,
                 "str_list_{make,join}_shell: Error double parsing, first run:\n%s\nSecond run: \n%s", element->list_as_string, tmp));
+        torture_assert(tctx, str_list_equal(ret1, element->list),
+        torture_assert(tctx, str_list_equal((const char * const *) ret1,
+                                            element->list),
                        talloc_asprintf(tctx,
                                        "str_list_make_shell(%s) failed to create correct list",
 …
+{
         const struct test_list_element *element = data;
         char **result;
         result = str_list_make(tctx, element->list_as_string, element->seperators);
+        result = str_list_make(tctx, element->list_as_string, element->separators);
         torture_assert(tctx, result, "str_list_make() must not return NULL");
+        torture_assert(tctx, str_list_equal((const char **)result, element->list),
+        torture_assert(tctx, str_list_equal((const char * const *) result,
+                                            element->list),
                        talloc_asprintf(tctx,
                                        "str_list_make(%s) failed to create correct list",
 …
 static bool test_list_add(struct torture_context *tctx)
+{
         char **result, **result2;
+        const char **result, **result2;
         const char *list[] = {
                 "element_0",
 …
                 NULL
         };
         result = str_list_make(tctx, "element_0, element_1, element_2", NULL);
+        result = (const char **) str_list_make(tctx, "element_0, element_1, element_2", NULL);
         torture_assert(tctx, result, "str_list_make() must not return NULL");
         result2 = str_list_add(result, "element_3");
+        result2 = str_list_add((const char **) result, "element_3");
         torture_assert(tctx, result2, "str_list_add() must not return NULL");
         torture_assert(tctx, str_list_equal(result2, list),
 …
 static bool test_list_add_const(struct torture_context *tctx)
+{
         char **result, **result2;
+        const char **result, **result2;
         const char *list[] = {
                 "element_0",
 …
                 NULL
         };
         result = str_list_make(tctx, "element_0, element_1, element_2", NULL);
+        result = (const char **) str_list_make(tctx, "element_0, element_1, element_2", NULL);
         torture_assert(tctx, result, "str_list_make() must not return NULL");
         result2 = str_list_add_const(result, "element_3");
 …
 static bool test_list_remove(struct torture_context *tctx)
+{
         char **result;
+        const char **result;
         const char *list[] = {
                 "element_0",
 …
                 NULL
         };
         result = str_list_make(tctx, "element_0, element_1, element_2, element_3", NULL);
+        result = (const char **) str_list_make(tctx, "element_0, element_1, element_2, element_3", NULL);
         torture_assert(tctx, result, "str_list_make() must not return NULL");
         str_list_remove(result, "element_2");
 …
 static bool test_list_unique(struct torture_context *tctx)
+{
         char **result;
+        const char **result;
         const char *list[] = {
                 "element_0",
 …
                 NULL
         };
         result = str_list_copy(tctx, list_dup);
+        result = (const char **) str_list_copy(tctx, list_dup);
         /* We must copy the list, as str_list_unique does a talloc_realloc() on it's parameter */
         result = str_list_unique(result);
 …
         const char **list_dup = (const char **)str_list_make_empty(tctx);
         count = lp_parm_int(tctx->lp_ctx, NULL, "list_unique", "count", 9);
         num_dups = lp_parm_int(tctx->lp_ctx, NULL, "list_unique", "dups", 7);
+        count = lpcfg_parm_int(tctx->lp_ctx, NULL, "list_unique", "count", 9);
+        num_dups = lpcfg_parm_int(tctx->lp_ctx, NULL, "list_unique", "dups", 7);
         torture_comment(tctx, "test_list_unique_2() with %d elements and %d dups\n", count, num_dups);
 …
 static bool test_list_append(struct torture_context *tctx)
+{
         char **result;
+        const char **result;
         const char *list[] = {
                 "element_0",
 …
                 NULL
         };
         result = str_list_copy(tctx, list);
+        result = (const char **) str_list_copy(tctx, list);
         torture_assert(tctx, result, "str_list_copy() must not return NULL");
         result = str_list_append(result, list2);
 …
 static bool test_list_append_const(struct torture_context *tctx)
+{
         char **result;
+        const char **result;
         const char *list[] = {
                 "element_0",
 …
                 NULL
         };
         result = str_list_copy(tctx, list);
+        result = (const char **) str_list_copy(tctx, list);
         torture_assert(tctx, result, "str_list_copy() must not return NULL");
         result = str_list_append_const(result, list2);
 …
 struct torture_suite *torture_local_util_strlist(TALLOC_CTX *mem_ctx)
+{
         struct torture_suite *suite = torture_suite_create(mem_ctx, "STRLIST");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "strlist");
         int i;
         for (i = 0; i < ARRAY_SIZE(test_lists_shell_strings); i++) {
+                torture_suite_add_simple_tcase_const(suite, "lists_shell",
+                                test_lists_shell, &test_lists_shell_strings[i]);
+                char *name;
+                name = talloc_asprintf(suite, "lists_shell(%s)",
+                                                           test_lists_shell_strings[i].list_as_string);
+                torture_suite_add_simple_tcase_const(suite, name,
+                        test_lists_shell,  &test_lists_shell_strings[i]);
+        }
         for (i = 0; i < ARRAY_SIZE(test_lists_strings); i++) {
+                torture_suite_add_simple_tcase_const(suite, "lists",
+                                                     test_list_make, &test_lists_strings[i]);
+                char *name;
+                name = talloc_asprintf(suite, "list_make(%s)",
+                                                           test_lists_strings[i].list_as_string);
+                torture_suite_add_simple_tcase_const(suite, name,
+                        test_list_make, &test_lists_strings[i]);
+        }

vendor/current/lib/util/tests/time.c

-              r414
+              r740
         result = timestring(tctx, 42 - (utc_offset < 0 ? utc_offset : 0));
+        torture_assert(tctx, !strncmp(start, result, strlen(start)),
+                                   result);
+        torture_assert(tctx, !strncmp(start, result, strlen(start)), result);
         return true;
+}
 …
 struct torture_suite *torture_local_util_time(TALLOC_CTX *mem_ctx)
+{
         struct torture_suite *suite = torture_suite_create(mem_ctx, "TIME");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "time");
         torture_suite_add_simple_test(suite, "null_time", test_null_time);

vendor/current/lib/util/tevent_ntstatus.c

-              r414
+              r740
 #include "tevent_ntstatus.h"
+bool tevent_req_nterror(struct tevent_req *req, NTSTATUS status)
+#define TEVENT_NTERROR_MAGIC (0x917b5acd)
+bool _tevent_req_nterror(struct tevent_req *req,
+                         NTSTATUS status,
+                         const char *location)
+{
+        return tevent_req_error(req, NT_STATUS_V(status));
+        uint64_t err;
+        if (NT_STATUS_IS_OK(status)) {
+                return false;
+        }
+        /*
+         * I've put this variable here, because I'm not 100% certain
+         * how to correctly assign a 64-bit constant and left-shift it
+         * by 32 bits in a single expression. If anyone knows, feel
+         * free :-)
+         */
+        err = TEVENT_NTERROR_MAGIC;
+        err <<= 32;
+        err |= NT_STATUS_V(status);
+        return _tevent_req_error(req, err, location);
+}
 …
                 break;
         case TEVENT_REQ_USER_ERROR:
+                *status = NT_STATUS(err);
+                if ((err >> 32) != TEVENT_NTERROR_MAGIC) {
+                        abort();
+                }
+                *status = NT_STATUS(err & 0xffffffff);
                 break;
         default:
 …
         return NT_STATUS_OK;
+}
+void tevent_req_simple_finish_ntstatus(struct tevent_req *subreq,
+                                       NTSTATUS subreq_status)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(subreq_status)) {
+                tevent_req_nterror(req, subreq_status);
+                return;
+        }
+        tevent_req_done(req);
+}

vendor/current/lib/util/tevent_ntstatus.h

-              r414
+              r740
 #include <stdbool.h>
 #include "../libcli/util/ntstatus.h"
 #include "../tevent/tevent.h"
+#include <tevent.h>
+bool tevent_req_nterror(struct tevent_req *req, NTSTATUS status);
+bool _tevent_req_nterror(struct tevent_req *req,
+                         NTSTATUS status,
+                         const char *location);
+#define tevent_req_nterror(req, status) \
+        _tevent_req_nterror(req, status, __location__)
 bool tevent_req_is_nterror(struct tevent_req *req, NTSTATUS *pstatus);
 NTSTATUS tevent_req_simple_recv_ntstatus(struct tevent_req *req);
+/*
+ * Helper routine to pass the subreq_ntstatus to the req embedded in
+ * tevent_req_callback_data(subreq), which will be freed.
+ */
+void tevent_req_simple_finish_ntstatus(struct tevent_req *subreq,
+                                       NTSTATUS subreq_status);
 #endif

vendor/current/lib/util/tevent_unix.c

-              r414
+              r740
 */
+#include "../replace/replace.h"
 #include "tevent_unix.h"
-#include "../replace/replace.h"
 bool tevent_req_is_unix_error(struct tevent_req *req, int *perrno)

vendor/current/lib/util/tevent_unix.h

r414	r740
25	25	#define _TEVENT_UNIX_H
26	26
27		#include ~~"../tevent/tevent.h"~~
	27	#include <tevent.h>
28	28
29	29	bool tevent_req_is_unix_error(struct tevent_req req, int perrno);

vendor/current/lib/util/time.c

-              r478
+              r740
    Copyright (C) Andrew Tridgell                1992-2004
    Copyright (C) Stefan (metze) Metzmacher      2002
+   Copyright (C) Jeremy Allison                 2007
+   Copyright (C) Andrew Bartlett                2011
    This program is free software; you can redistribute it and/or modify
 …
+}
+/**
+a wrapper to preferably get the monotonic time
+**/
+_PUBLIC_ void clock_gettime_mono(struct timespec *tp)
+{
+        if (clock_gettime(CUSTOM_CLOCK_MONOTONIC,tp) != 0) {
+                clock_gettime(CLOCK_REALTIME,tp);
+        }
+}
+/**
+a wrapper to preferably get the monotonic time in seconds
+as this is only second resolution we can use the cached
+(and much faster) COARSE clock variant
+**/
+_PUBLIC_ time_t time_mono(time_t *t)
+{
+        struct timespec tp;
+        int rc = -1;
+#ifdef CLOCK_MONOTONIC_COARSE
+        rc = clock_gettime(CLOCK_MONOTONIC_COARSE,&tp);
+#endif
+        if (rc != 0) {
+                clock_gettime_mono(&tp);
+        }
+        if (t != NULL) {
+                *t = tp.tv_sec;
+        }
+        return tp.tv_sec;
+}
 #define TIME_FIXUP_CONSTANT 11644473600LL
 …
 time_t convert_timespec_to_time_t(struct timespec ts)
+{
+        /* Ensure tv_nsec is less than 1sec. */
+        while (ts.tv_nsec > 1000000000) {
+                ts.tv_sec += 1;
+                ts.tv_nsec -= 1000000000;
+        }
         /* 1 ns == 1,000,000,000 - one thousand millionths of a second.
            increment if it's greater than 500 millionth of a second. */
         if (ts.tv_nsec > 500000000) {
                 return ts.tv_sec + 1;
 …
+/****************************************************************************
+ Return the date and time as a string
+****************************************************************************/
+char *timeval_string(TALLOC_CTX *ctx, const struct timeval *tp, bool hires)
+{
+        time_t t;
+        struct tm *tm;
+        t = (time_t)tp->tv_sec;
+        tm = localtime(&t);
+        if (!tm) {
+                if (hires) {
+                        return talloc_asprintf(ctx,
+                                               "%ld.%06ld seconds since the Epoch",
+                                               (long)tp->tv_sec,
+                                               (long)tp->tv_usec);
+                } else {
+                        return talloc_asprintf(ctx,
+                                               "%ld seconds since the Epoch",
+                                               (long)t);
+                }
+        } else {
+#ifdef HAVE_STRFTIME
+                char TimeBuf[60];
+                if (hires) {
+                        strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
+                        return talloc_asprintf(ctx,
+                                               "%s.%06ld", TimeBuf,
+                                               (long)tp->tv_usec);
+                } else {
+                        strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
+                        return talloc_strdup(ctx, TimeBuf);
+                }
+#else
+                if (hires) {
+                        const char *asct = asctime(tm);
+                        return talloc_asprintf(ctx, "%s.%06ld",
+                                        asct ? asct : "unknown",
+                                        (long)tp->tv_usec);
+                } else {
+                        const char *asct = asctime(tm);
+                        return talloc_asprintf(ctx, asct ? asct : "unknown");
+                }
+#endif
+        }
+}
+char *current_timestring(TALLOC_CTX *ctx, bool hires)
+{
+        struct timeval tv;
+        GetTimeOfDay(&tv);
+        return timeval_string(ctx, &tv, hires);
+}
 /**
 return a HTTP/1.0 time string
 …
 #ifdef HAVE_STRFTIME
+        /* some versions of gcc complain about using %c. This is a bug
+           in the gcc warning, not a bug in this code. See a recent
+           strftime() manual page for details.
+         */
+        strftime(tempTime,sizeof(tempTime)-1,"%c %Z",tm);
+        /* Some versions of gcc complain about using some special format
+         * specifiers. This is a bug in gcc, not a bug in this code. See a
+         * recent strftime() manual page for details. */
+        strftime(tempTime,sizeof(tempTime)-1,"%a %b %e %X %Y %Z",tm);
         TimeBuf = talloc_strdup(mem_ctx, tempTime);
 #else
 …
         int64_t sec_diff = tv1->tv_sec - tv2->tv_sec;
         return (sec_diff * 1000000) + (int64_t)(tv1->tv_usec - tv2->tv_usec);
+}
+/**
+  return (tp1 - tp2) in microseconds
+*/
+_PUBLIC_ int64_t nsec_time_diff(const struct timespec *tp1, const struct timespec *tp2)
+{
+        int64_t sec_diff = tp1->tv_sec - tp2->tv_sec;
+        return (sec_diff * 1000000000) + (int64_t)(tp1->tv_nsec - tp2->tv_nsec);
+}

vendor/current/lib/util/time.h

-              r478
+              r740
    Unix SMB/CIFS implementation.
    time utility functions
+   Copyright (C) Andrew Tridgell                1992-2004
+   Copyright (C) Stefan (metze) Metzmacher      2002
+   Copyright (C) Jeremy Allison                 2007
+   Copyright (C) Andrew Bartlett                2011
    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
 …
 /**
+a wrapper to preferably get the monotonic time
+**/
+_PUBLIC_ void clock_gettime_mono(struct timespec *tp);
+/**
+a wrapper to preferably get the monotonic time in s
+**/
+_PUBLIC_ time_t time_mono(time_t *t);
+/**
 interpret an 8 byte "filetime" structure to a time_t
 It's originally in "100ns units since jan 1st 1601"
 …
 /**
+ Return a date and time as a string (optionally with microseconds)
+ format is %Y/%m/%d %H:%M:%S if strftime is available
+**/
+char *timeval_string(TALLOC_CTX *ctx, const struct timeval *tp, bool hires);
+/**
+ Return the current date and time as a string (optionally with microseconds)
+ format is %Y/%m/%d %H:%M:%S if strftime is available
+**/
+char *current_timestring(TALLOC_CTX *ctx, bool hires);
+/**
 return a HTTP/1.0 time string
 **/
 …
 /**
  Return the date and time as a string
+ format is %a %b %e %X %Y %Z
 **/
 _PUBLIC_ char *timestring(TALLOC_CTX *mem_ctx, time_t t);
 …
 */
 _PUBLIC_ int64_t usec_time_diff(const struct timeval *tv1, const struct timeval *tv2);
+/**
+  return (tp1 - tp2) in nanoseconds
+*/
+_PUBLIC_ int64_t nsec_time_diff(const struct timespec *tp1, const struct timespec *tp2);
 /**

vendor/current/lib/util/unix_privs.c

-              r414
+              r740
 #include "includes.h"
 #include "system/filesys.h"
+#include "system/passwd.h"
 #include "../lib/util/unix_privs.h"
+#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
 /**
 …
         return s;
+}
+uid_t root_privileges_original_uid(void *s)
+{
+        struct saved_state *saved = talloc_get_type_abort(s, struct saved_state);
+        return saved->uid;
+}

vendor/current/lib/util/util.c

-              r414
+              r740
 #include "system/filesys.h"
 #include "system/locale.h"
+#include "system/shmem.h"
 #undef malloc
 #undef strcasecmp
 …
 #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
 /**
 …
 **/
+_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
+}
 …
+}
+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;) {
 …
                         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) &&
 …
                             (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;
+                                }
 …
                 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);
+        }
 …
 _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);
+}
 …
+ *
  * 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);
+}
 …
 _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;
 …
         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;
 …
                                 bool ltrim)
+{
         char *s;
         char *saved_s;
+        const char *s;
+        const char *saved_s;
         char *pbuf;
         bool quoted;
 …
+        }
         s = (char *)*ptr;
+        s = *ptr;
         /* default to simple separators */
 …
+}
+/**
+ * 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

vendor/current/lib/util/util.h

-              r414
+              r740
 #define _SAMBA_UTIL_H_
+#if _SAMBA_BUILD_ == 4
+#include "../lib/util/charset/charset.h"
+#endif
+#include "../lib/util/attr.h"
+#include "lib/util/charset/charset.h"
+#include "lib/util/attr.h"
 /* for TALLOC_CTX */
 …
 extern const char *panic_action;
+#include "../lib/util/time.h"
+#include "../lib/util/data_blob.h"
+#include "../lib/util/xfile.h"
+#include "../lib/util/mutex.h"
+#include "../lib/util/byteorder.h"
+#include "../lib/util/talloc_stack.h"
+#include "lib/util/time.h"
+#include "lib/util/data_blob.h"
+#include "lib/util/xfile.h"
+#include "lib/util/byteorder.h"
+#include "lib/util/talloc_stack.h"
 /**
 …
 #endif
-#if _SAMBA_BUILD_ == 4
-#ifdef VALGRIND
-#define strlen(x) valgrind_strlen(x)
-size_t valgrind_strlen(const char *s);
-#endif
-#endif
 #ifndef ABS
 #define ABS(a) ((a)>0?(a):(-(a)))
 #endif
 #include "../lib/util/memory.h"
+#include "lib/util/memory.h"
 /**
 …
 **/
 _PUBLIC_ void fault_setup(const char *pname);
+_PUBLIC_ void fault_setup_disable(void);
 #endif
 …
 _PUBLIC_ pid_t sys_getpid(void);
+_PUBLIC_ int sys_getpeereid( int s, uid_t *uid);
+struct sockaddr;
+_PUBLIC_ int sys_getnameinfo(const struct sockaddr *psa,
+                             int salen,
+                             char *host,
+                             size_t hostlen,
+                             char *service,
+                             size_t servlen,
+                             int flags);
+_PUBLIC_ int sys_connect(int fd, const struct sockaddr * addr);
 /* The following definitions come from lib/util/genrand.c  */
 /**
  Copy any user given reseed data.
 …
 **/
 _PUBLIC_ bool check_password_quality(const char *s);
+/**
+ * Generate a random text password.
+ */
+_PUBLIC_ char *generate_random_password(TALLOC_CTX *mem_ctx, size_t min, size_t max);
 /**
 …
 /**
  * build a null terminated list of strings from an argv-like input string
  * Entries are seperated by spaces and can be enclosed by quotes.
+ * Entries are separated by spaces and can be enclosed by quotes.
  * Does NOT support escaping
  */
 …
  * join a list back to one string
  */
 _PUBLIC_ char *str_list_join(TALLOC_CTX *mem_ctx, const char **list, char seperator);
+_PUBLIC_ char *str_list_join(TALLOC_CTX *mem_ctx, const char **list, char separator);
 /** join a list back to one (shell-like) string; entries
  * seperated by spaces, using quotes where necessary */
+ * separated by spaces, using quotes where necessary */
 _PUBLIC_ char *str_list_join_shell(TALLOC_CTX *mem_ctx, const char **list, char sep);
 …
    Return true if all the elements of the list match exactly.
  */
 _PUBLIC_ bool str_list_equal(const char **list1, const char **list2);
+_PUBLIC_ bool str_list_equal(const char * const *list1, const char * const *list2);
 /**
 …
 _PUBLIC_ const char **str_list_copy_const(TALLOC_CTX *mem_ctx,
                                           const char **list);
+/**
+ * Needed for making an "unconst" list "const"
+ */
+_PUBLIC_ const char **const_str_list(char **list);
 …
 _PUBLIC_ bool large_file_support(const char *path);
+/*
+  compare two files, return true if the two files have the same content
+ */
+bool file_compare(const char *path1, const char *path2);
 /* The following definitions come from lib/util/util.c  */
 …
  Sleep for a specified number of milliseconds.
 **/
 _PUBLIC_ void msleep(unsigned int t);
+_PUBLIC_ void smb_msleep(unsigned int t);
 /**
 …
 **/
 _PUBLIC_ char* get_myname(TALLOC_CTX *mem_ctx);
-/**
- Return true if a string could be a pure IP address.
-**/
-_PUBLIC_ bool is_ipaddress(const char *str);
-/**
- Interpret an internet address or name into an IP address in 4 byte form.
-**/
-_PUBLIC_ uint32_t interpret_addr(const char *str);
-/**
- A convenient addition to interpret_addr().
-**/
-_PUBLIC_ struct in_addr interpret_addr2(const char *str);
-/**
- Check if an IP is the 0.0.0.0.
-**/
-_PUBLIC_ bool is_zero_ip_v4(struct in_addr ip);
-/**
- Are two IPs on the same subnet?
-**/
-_PUBLIC_ bool same_net_v4(struct in_addr ip1,struct in_addr ip2,struct in_addr mask);
-_PUBLIC_ bool is_ipaddress_v4(const char *str);
 /**
 …
 /**
+ * Write dump of binary data to a callback
+ */
+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);
+/**
  * 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
+ * 16 zero bytes in a row are omitted
  */
 _PUBLIC_ void dump_data_skip_zeros(int level, const uint8_t *buf, int len);
 …
 #endif
-/* The following definitions come from lib/util/mutex.c  */
-/**
-  register a set of mutex/rwlock handlers.
-  Should only be called once in the execution of smbd.
-*/
-_PUBLIC_ bool register_mutex_handlers(const char *name, struct mutex_ops *ops);
 /* The following definitions come from lib/util/idtree.c  */
 …
  Become a daemon, discarding the controlling terminal.
 **/
 _PUBLIC_ void become_daemon(bool do_fork, bool no_process_group);
+_PUBLIC_ void become_daemon(bool do_fork, bool no_process_group, bool log_stdout);
 /**
 …
 void print_asc(int level, const uint8_t *buf,int len);
+void print_asc_cb(const uint8_t *buf, int len,
+                  void (*cb)(const char *buf, void *private_data),
+                  void *private_data);
 /**
 …
 bool add_uid_to_array_unique(TALLOC_CTX *mem_ctx, uid_t uid,
                              uid_t **uids, size_t *num_uids);
+                             uid_t **uids, uint32_t *num_uids);
 bool add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
+                             gid_t **gids, size_t *num_gids);
+                             gid_t **gids, uint32_t *num_gids);
+/**
+ * Allocate anonymous shared memory of the given size
+ */
+void *anonymous_shared_allocate(size_t bufsz);
+void anonymous_shared_free(void *ptr);
+/*
+  run a command as a child process, with a timeout.
+  any stdout/stderr from the child will appear in the Samba logs with
+  the specified log levels
+  If callback is set then the callback is called on completion
+  with the return code from the command
+ */
+struct tevent_context;
+struct tevent_req;
+struct tevent_req *samba_runcmd_send(TALLOC_CTX *mem_ctx,
+                                     struct tevent_context *ev,
+                                     struct timeval endtime,
+                                     int stdout_log_level,
+                                     int stderr_log_level,
+                                     const char * const *argv0, ...);
+int samba_runcmd_recv(struct tevent_req *req, int *perrno);
+#ifdef DEVELOPER
+void samba_start_debugger(void);
+#endif
 #endif /* _SAMBA_UTIL_H_ */

vendor/current/lib/util/util_file.c

-              r414
+              r740
 #endif
         if (!p) {
                 p = file_load(fname, &s2, 0, talloc_autofree_context());
+                p = file_load(fname, &s2, 0, NULL);
                 if (!p) return NULL;
                 if (s2 != size) {
 …
+/*
+  compare two files, return true if the two files have the same content
+ */
+bool file_compare(const char *path1, const char *path2)
+{
+        size_t size1, size2;
+        char *p1, *p2;
+        TALLOC_CTX *mem_ctx = talloc_new(NULL);
+        p1 = file_load(path1, &size1, 0, mem_ctx);
+        p2 = file_load(path2, &size2, 0, mem_ctx);
+        if (!p1 || !p2 || size1 != size2) {
+                talloc_free(mem_ctx);
+                return false;
+        }
+        if (memcmp(p1, p2, size1) != 0) {
+                talloc_free(mem_ctx);
+                return false;
+        }
+        talloc_free(mem_ctx);
+        return true;
+}

vendor/current/lib/util/util_id.c

-              r414
+              r740
 bool add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
                              gid_t **gids, size_t *num_gids)
+                             gid_t **gids, uint32_t *num_gids)
+{
         int i;
 …
 bool add_uid_to_array_unique(TALLOC_CTX *mem_ctx, uid_t uid,
                              uid_t **uids, size_t *num_uids)
+                             uid_t **uids, uint32_t *num_uids)
+{
         int i;

vendor/current/lib/util/util_ldb.c

-              r414
+              r740
 #include "includes.h"
 #include "lib/ldb/include/ldb.h"
+#include <ldb.h>
 #include "../lib/util/util_ldb.h"
 /*
   search the sam for the specified attributes - va_list variant
 */
+ * search the LDB for the specified attributes - va_list variant
+ */
 int gendb_search_v(struct ldb_context *ldb,
                    TALLOC_CTX *mem_ctx,
 …
                    const char * const *attrs,
                    const char *format,
                    va_list ap)
+                   va_list ap)
+{
         enum ldb_scope scope = LDB_SCOPE_SUBTREE;
 …
         if (ret == LDB_SUCCESS) {
-                talloc_steal(mem_ctx, res->msgs);
                 DEBUG(6,("gendb_search_v: %s %s -> %d\n",
                          basedn?ldb_dn_get_linearized(basedn):"NULL",
 …
                 ret = res->count;
+                *msgs = res->msgs;
+                if (msgs != NULL) {
+                        *msgs = talloc_steal(mem_ctx, res->msgs);
+                }
                 talloc_free(res);
         } else if (scope == LDB_SCOPE_BASE && ret == LDB_ERR_NO_SUCH_OBJECT) {
                 ret = 0;
                 *msgs = NULL;
+                if (msgs != NULL) *msgs = NULL;
         } else {
                 DEBUG(4,("gendb_search_v: search failed: %s\n",
                                         ldb_errstring(ldb)));
                 ret = -1;
+                if (msgs != NULL) *msgs = NULL;
+        }
 …
 /*
   search the LDB for the specified attributes - varargs variant
 */
+ * search the LDB for the specified attributes - varargs variant
+ */
 int gendb_search(struct ldb_context *ldb,
                  TALLOC_CTX *mem_ctx,
 …
                  struct ldb_message ***res,
                  const char * const *attrs,
                  const char *format, ...)
+                 const char *format, ...)
+{
         va_list ap;
 …
 /*
+  search the LDB for a specified record (by DN)
+*/
+ * search the LDB for a specified record (by DN)
+ */
 int gendb_search_dn(struct ldb_context *ldb,
                  TALLOC_CTX *mem_ctx,
 …
+}
-/*
-  setup some initial ldif in a ldb
-*/
-int gendb_add_ldif(struct ldb_context *ldb, const char *ldif_string)
+{
-        struct ldb_ldif *ldif;
-        int ret;
-        ldif = ldb_ldif_read_string(ldb, &ldif_string);
-        if (ldif == NULL) return -1;
-        ret = ldb_add(ldb, ldif->msg);
-        talloc_free(ldif);
-        return ret;
+}
-char *wrap_casefold(void *context, void *mem_ctx, const char *s, size_t n)
+{
-        return strupper_talloc_n(mem_ctx, s, n);
+}
-/*
-  search the LDB for a single record, with the extended_dn control
-  return LDB_SUCCESS on success, or an ldb error code on error
-  if the search returns 0 entries, return LDB_ERR_NO_SUCH_OBJECT
-  if the search returns more than 1 entry, return LDB_ERR_CONSTRAINT_VIOLATION
-*/
-int gendb_search_single_extended_dn(struct ldb_context *ldb,
-                                    TALLOC_CTX *mem_ctx,
-                                    struct ldb_dn *basedn,
-                                    enum ldb_scope scope,
-                                    struct ldb_message **msg,
-                                    const char * const *attrs,
-                                    const char *format, ...)
+{
-        va_list ap;
-        int ret;
-        struct ldb_request *req;
-        char *filter;
-        TALLOC_CTX *tmp_ctx;
-        struct ldb_result *res;
-        struct ldb_extended_dn_control *ctrl;
-        tmp_ctx = talloc_new(mem_ctx);
-        res = talloc_zero(tmp_ctx, struct ldb_result);
-        if (!res) {
-                return LDB_ERR_OPERATIONS_ERROR;
+        }
-        va_start(ap, format);
-        filter = talloc_vasprintf(tmp_ctx, format, ap);
-        va_end(ap);
-        if (filter == NULL) {
-                talloc_free(tmp_ctx);
-                return LDB_ERR_OPERATIONS_ERROR;
+        }
-        ret = ldb_build_search_req(&req, ldb, tmp_ctx,
-                                   basedn,
-                                   scope,
-                                   filter,
-                                   attrs,
-                                   NULL,
-                                   res,
-                                   ldb_search_default_callback,
-                                   NULL);
-        if (ret != LDB_SUCCESS) {
-                talloc_free(tmp_ctx);
-                return ret;
+        }
-        ctrl = talloc(tmp_ctx, struct ldb_extended_dn_control);
-        if (ctrl == NULL) {
-                talloc_free(tmp_ctx);
-                return LDB_ERR_OPERATIONS_ERROR;
+        }
-        ctrl->type = 1;
-        ret = ldb_request_add_control(req, LDB_CONTROL_EXTENDED_DN_OID, true, ctrl);
-        if (ret != LDB_SUCCESS) {
-                return ret;
+        }
-        ret = ldb_request(ldb, req);
-        if (ret == LDB_SUCCESS) {
-                ret = ldb_wait(req->handle, LDB_WAIT_ALL);
+        }
-        if (ret != LDB_SUCCESS) {
-                talloc_free(tmp_ctx);
-                return ret;
+        }
-        if (res->count == 0) {
-                talloc_free(tmp_ctx);
-                return LDB_ERR_NO_SUCH_OBJECT;
+        }
-        if (res->count > 1) {
-                /* the function is only supposed to return a single entry */
-                DEBUG(0,(__location__ ": More than one return for baseDN %s  filter %s\n",
-                         ldb_dn_get_linearized(basedn), filter));
-                talloc_free(tmp_ctx);
-                return LDB_ERR_CONSTRAINT_VIOLATION;
+        }
-        *msg = talloc_steal(mem_ctx, res->msgs[0]);
-        talloc_free(tmp_ctx);
-        return LDB_SUCCESS;
+}

vendor/current/lib/util/util_ldb.h

-              r414
+              r740
+/*
+   Unix SMB/CIFS implementation.
+   common share info functions
+   Copyright (C) Andrew Tridgell 2004
+   Copyright (C) Tim Potter 2004
+   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/>.
+*/
 #ifndef __LIB_UTIL_UTIL_LDB_H__
 #define __LIB_UTIL_UTIL_LDB_H__
 …
                  struct ldb_message ***res,
                  const char * const *attrs);
-int gendb_add_ldif(struct ldb_context *ldb, const char *ldif_string);
-char *wrap_casefold(void *context, void *mem_ctx, const char *s, size_t n);
-int gendb_search_single_extended_dn(struct ldb_context *ldb,
-                                    TALLOC_CTX *mem_ctx,
-                                    struct ldb_dn *basedn,
-                                    enum ldb_scope scope,
-                                    struct ldb_message **msg,
-                                    const char * const *attrs,
-                                    const char *format, ...)  PRINTF_ATTRIBUTE(7,8);
 #endif /* __LIB_UTIL_UTIL_LDB_H__ */

vendor/current/lib/util/util_net.c

-              r414
+              r740
 #include "system/locale.h"
 #include "system/filesys.h"
+#include "lib/util/util_net.h"
 #undef strcasecmp
 …
 void zero_sockaddr(struct sockaddr_storage *pss)
+{
         memset(pss, '\0', sizeof(*pss));
+        ZERO_STRUCTP(pss);
         /* Ensure we're at least a valid sockaddr-storage. */
         pss->ss_family = AF_INET;
 …
         struct addrinfo hints;
+        memset(&hints, '\0', sizeof(hints));
+        ZERO_STRUCT(hints);
         /* By default make sure it supports TCP. */
         hints.ai_socktype = SOCK_STREAM;
         hints.ai_flags = flags;
         /* Linux man page on getaddinfo() says port will be
            uninitialized when service string in NULL */
+        /* Linux man page on getaddrinfo() says port will be
+           uninitialized when service string is NULL */
         ret = getaddrinfo(str, NULL,
 …
  * Check if a struct sockaddr has an unspecified address.
  */
 bool is_zero_addr(const struct sockaddr *pss)
+{
 #if defined(HAVE_IPV6)
         if (pss->sa_family == AF_INET6) {
+bool is_zero_addr(const struct sockaddr_storage *pss)
+{
+#if defined(HAVE_IPV6)
+        if (pss->ss_family == AF_INET6) {
                 const struct in6_addr *pin6 =
                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
 …
+        }
 #endif
         if (pss->sa_family == AF_INET) {
+        if (pss->ss_family == AF_INET) {
                 const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
                 return is_zero_ip_v4(*pin);
 …
+/****************************************************************************
+ Get a port number in host byte order from a sockaddr_storage.
+****************************************************************************/
+uint16_t get_sockaddr_port(const struct sockaddr_storage *pss)
+{
+        uint16_t port = 0;
+        if (pss->ss_family != AF_INET) {
+#if defined(HAVE_IPV6)
+                /* IPv6 */
+                const struct sockaddr_in6 *sa6 =
+                        (const struct sockaddr_in6 *)pss;
+                port = ntohs(sa6->sin6_port);
+#endif
+        } else {
+                const struct sockaddr_in *sa =
+                        (const struct sockaddr_in *)pss;
+                port = ntohs(sa->sin_port);
+        }
+        return port;
+}
+/****************************************************************************
+ Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
+****************************************************************************/
+char *print_sockaddr_len(char *dest,
+                         size_t destlen,
+                        const struct sockaddr *psa,
+                        socklen_t psalen)
+{
+        if (destlen > 0) {
+                dest[0] = '\0';
+        }
+        (void)sys_getnameinfo(psa,
+                        psalen,
+                        dest, destlen,
+                        NULL, 0,
+                        NI_NUMERICHOST);
+        return dest;
+}
+/****************************************************************************
+ Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
+****************************************************************************/
+char *print_sockaddr(char *dest,
+                        size_t destlen,
+                        const struct sockaddr_storage *psa)
+{
+        return print_sockaddr_len(dest, destlen, (struct sockaddr *)psa,
+                        sizeof(struct sockaddr_storage));
+}
+/****************************************************************************
+ Print out a canonical IPv4 or IPv6 address from a struct sockaddr_storage.
+****************************************************************************/
+char *print_canonical_sockaddr(TALLOC_CTX *ctx,
+                        const struct sockaddr_storage *pss)
+{
+        char addr[INET6_ADDRSTRLEN];
+        char *dest = NULL;
+        int ret;
+        /* Linux getnameinfo() man pages says port is unitialized if
+           service name is NULL. */
+        ret = sys_getnameinfo((const struct sockaddr *)pss,
+                        sizeof(struct sockaddr_storage),
+                        addr, sizeof(addr),
+                        NULL, 0,
+                        NI_NUMERICHOST);
+        if (ret != 0) {
+                return NULL;
+        }
+        if (pss->ss_family != AF_INET) {
+#if defined(HAVE_IPV6)
+                dest = talloc_asprintf(ctx, "[%s]", addr);
+#else
+                return NULL;
+#endif
+        } else {
+                dest = talloc_asprintf(ctx, "%s", addr);
+        }
+        return dest;
+}
+/****************************************************************************
+ Return the port number we've bound to on a socket.
+****************************************************************************/
+int get_socket_port(int fd)
+{
+        struct sockaddr_storage sa;
+        socklen_t length = sizeof(sa);
+        if (fd == -1) {
+                return -1;
+        }
+        if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
+                int level = (errno == ENOTCONN) ? 2 : 0;
+                DEBUG(level, ("getsockname failed. Error was %s\n",
+                               strerror(errno)));
+                return -1;
+        }
+#if defined(HAVE_IPV6)
+        if (sa.ss_family == AF_INET6) {
+                return ntohs(((struct sockaddr_in6 *)&sa)->sin6_port);
+        }
+#endif
+        if (sa.ss_family == AF_INET) {
+                return ntohs(((struct sockaddr_in *)&sa)->sin_port);
+        }
+        return -1;
+}
+/****************************************************************************
+ Return the string of an IP address (IPv4 or IPv6).
+****************************************************************************/
+static const char *get_socket_addr(int fd, char *addr_buf, size_t addr_len)
+{
+        struct sockaddr_storage sa;
+        socklen_t length = sizeof(sa);
+        /* Ok, returning a hard coded IPv4 address
+         * is bogus, but it's just as bogus as a
+         * zero IPv6 address. No good choice here.
+         */
+        strlcpy(addr_buf, "0.0.0.0", addr_len);
+        if (fd == -1) {
+                return addr_buf;
+        }
+        if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
+                DEBUG(0,("getsockname failed. Error was %s\n",
+                        strerror(errno) ));
+                return addr_buf;
+        }
+        return print_sockaddr_len(addr_buf, addr_len, (struct sockaddr *)&sa, length);
+}
+const char *client_socket_addr(int fd, char *addr, size_t addr_len)
+{
+        return get_socket_addr(fd, addr, addr_len);
+}

vendor/current/lib/util/util_net.h

-              r414
+              r740
                                        int flags);
+void set_sockaddr_port(struct sockaddr *psa, uint16_t port);
+/**
+ Check if an IP is the 0.0.0.0.
+**/
+_PUBLIC_ bool is_zero_ip_v4(struct in_addr ip);
+void in_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
+                                 struct in_addr ip);
+#if defined(HAVE_IPV6)
+/**
+ * Convert an IPv6 struct in_addr to a struct sockaddr_storage.
+ */
+void in6_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
+                                  struct in6_addr ip);
+#endif
+/**
+ Are two IPs on the same subnet?
+**/
+_PUBLIC_ bool same_net_v4(struct in_addr ip1,struct in_addr ip2,struct in_addr mask);
+/**
+ Return true if a string could be a pure IP address.
+**/
+_PUBLIC_ bool is_ipaddress(const char *str);
+bool is_broadcast_addr(const struct sockaddr *pss);
+bool is_loopback_ip_v4(struct in_addr ip);
+bool is_loopback_addr(const struct sockaddr *pss);
+bool is_zero_addr(const struct sockaddr_storage *pss);
+void zero_ip_v4(struct in_addr *ip);
+/**
+ Interpret an internet address or name into an IP address in 4 byte form.
+**/
+_PUBLIC_ uint32_t interpret_addr(const char *str);
+/**
+ A convenient addition to interpret_addr().
+**/
+_PUBLIC_ struct in_addr interpret_addr2(const char *str);
+_PUBLIC_ bool is_ipaddress_v4(const char *str);
+bool is_address_any(const struct sockaddr *psa);
+bool same_net(const struct sockaddr *ip1,
+              const struct sockaddr *ip2,
+              const struct sockaddr *mask);
+bool sockaddr_equal(const struct sockaddr *ip1,
+                    const struct sockaddr *ip2);
+bool is_address_any(const struct sockaddr *psa);
+uint16_t get_sockaddr_port(const struct sockaddr_storage *pss);
+char *print_sockaddr_len(char *dest,
+                         size_t destlen,
+                         const struct sockaddr *psa,
+                         socklen_t psalen);
+char *print_sockaddr(char *dest,
+                        size_t destlen,
+                        const struct sockaddr_storage *psa);
+char *print_canonical_sockaddr(TALLOC_CTX *ctx,
+                        const struct sockaddr_storage *pss);
+const char *client_name(int fd);
+int get_socket_port(int fd);
+const char *client_socket_addr(int fd, char *addr, size_t addr_len);
 #endif /* _SAMBA_UTIL_NET_H_ */

vendor/current/lib/util/util_pw.c

-              r414
+              r740
    Safe versions of getpw* calls
+   Copyright (C) Andrew Tridgell 1992-1998
+   Copyright (C) Jeremy Allison  1998-2005
    Copyright (C) Andrew Bartlett 2002
+   Copyright (C) Timur Bakeyev        2005
+   Copyright (C) Bjoern Jacke    2006-2007
    This program is free software; you can redistribute it and/or modify
 …
 #include "includes.h"
+#include "system/passwd.h"
+#include "lib/util/util_pw.h"
+static struct passwd *alloc_copy_passwd(TALLOC_CTX *mem_ctx,
+                                        const struct passwd *from)
+/**************************************************************************
+ Wrappers for setpwent(), getpwent() and endpwent()
+****************************************************************************/
+void sys_setpwent(void)
+{
+        setpwent();
+}
+struct passwd *sys_getpwent(void)
+{
+        return getpwent();
+}
+void sys_endpwent(void)
+{
+        endpwent();
+}
+/**************************************************************************
+ Wrappers for getpwnam(), getpwuid(), getgrnam(), getgrgid()
+****************************************************************************/
+struct passwd *sys_getpwnam(const char *name)
+{
+        return getpwnam(name);
+}
+struct passwd *sys_getpwuid(uid_t uid)
+{
+        return getpwuid(uid);
+}
+struct group *sys_getgrnam(const char *name)
+{
+        return getgrnam(name);
+}
+struct group *sys_getgrgid(gid_t gid)
+{
+        return getgrgid(gid);
+}
+struct passwd *tcopy_passwd(TALLOC_CTX *mem_ctx,
+                            const struct passwd *from)
+{
         struct passwd *ret = talloc_zero(mem_ctx, struct passwd);
 …
+}
 struct passwd *getpwnam_alloc(TALLOC_CTX *mem_ctx, const char *name)
+struct passwd *getpwnam_alloc(TALLOC_CTX *mem_ctx, const char *name)
+{
         struct passwd *temp;
 …
+        }
         return alloc_copy_passwd(mem_ctx, temp);
+        return tcopy_passwd(mem_ctx, temp);
+}
+struct passwd *getpwuid_alloc(TALLOC_CTX *mem_ctx, uid_t uid)
+/****************************************************************************
+ talloc'ed version of getpwuid.
+****************************************************************************/
+struct passwd *getpwuid_alloc(TALLOC_CTX *mem_ctx, uid_t uid)
+{
         struct passwd *temp;
 …
+        }
         return alloc_copy_passwd(mem_ctx, temp);
+        return tcopy_passwd(mem_ctx, temp);
+}

vendor/current/lib/util/util_str.c

-              r414
+              r740
         if (len > maxlength) {
                 DEBUG(0,("ERROR: string overflow by %u (%u - %u) in safe_strcpy [%.50s]\n",
                          (uint_t)(len-maxlength), (unsigned)len, (unsigned)maxlength, src));
+                         (unsigned int)(len-maxlength), (unsigned)len, (unsigned)maxlength, src));
                 len = maxlength;
+        }
 …
         return dest;
+}
-#ifdef VALGRIND
-size_t valgrind_strlen(const char *s)
+{
-        size_t count;
-        for(count = 0; *s++; count++)
+                ;
-        return count;
+}
-#endif
 /**

vendor/current/lib/util/util_strlist.c

-              r414
+              r740
 #include "includes.h"
 #include "system/locale.h"
+#include "lib/util/tsort.h"
 #undef strcasecmp
 …
 /**
  * build a null terminated list of strings from an argv-like input string
  * Entries are seperated by spaces and can be enclosed by quotes.
+ * Entries are separated by spaces and can be enclosed by quotes.
  * Does NOT support escaping
  */
 …
  * join a list back to one string
  */
 _PUBLIC_ char *str_list_join(TALLOC_CTX *mem_ctx, const char **list, char seperator)
+_PUBLIC_ char *str_list_join(TALLOC_CTX *mem_ctx, const char **list, char separator)
+{
         char *ret = NULL;
 …
         for (i = 1; list[i]; i++) {
                 ret = talloc_asprintf_append_buffer(ret, "%c%s", seperator, list[i]);
+                ret = talloc_asprintf_append_buffer(ret, "%c%s", separator, list[i]);
+        }
 …
 /** join a list back to one (shell-like) string; entries
  * seperated by spaces, using quotes where necessary */
+ * separated by spaces, using quotes where necessary */
 _PUBLIC_ char *str_list_join_shell(TALLOC_CTX *mem_ctx, const char **list, char sep)
+{
 …
    Return true if all the elements of the list match exactly.
  */
+_PUBLIC_ bool str_list_equal(const char **list1, const char **list2)
+_PUBLIC_ bool str_list_equal(const char * const *list1,
+                             const char * const *list2)
+{
         int i;
 …
         list2 = (const char **)talloc_memdup(list, list,
                                              sizeof(list[0])*(len+1));
         qsort(list2, len, sizeof(list2[0]), QSORT_CAST list_cmp);
+        TYPESAFE_QSORT(list2, len, list_cmp);
         list[0] = list2[0];
         for (i=j=1;i<len;i++) {
 …
         return ret;
+}
+/**
+ * Needed for making an "unconst" list "const"
+ */
+_PUBLIC_ const char **const_str_list(char **list)
+{
+        return (const char **)list;
+}

vendor/current/lib/util/util_tdb.c

-              r427
+              r740
 #include "includes.h"
 #include "tdb.h"
+#include <tdb.h>
 #include "../lib/util/util_tdb.h"
 …
 /****************************************************************************
  Store a int32_t value by an arbitary blob key, return 0 on success, -1 on failure.
+ Store a int32_t value by an arbitrary blob key, return 0 on success, -1 on failure.
  Input is int32_t in native byte order. Output in tdb is in little-endian.
 ****************************************************************************/
 …
 /****************************************************************************
  Store a uint32_t value by an arbitary blob key, return 0 on success, -1 on failure.
+ Store a uint32_t value by an arbitrary blob key, return 0 on success, -1 on failure.
  Input is uint32_t in native byte order. Output in tdb is in little-endian.
 ****************************************************************************/

vendor/current/lib/util/util_tdb.h

-              r427
+              r740
+/*
+   Unix SMB/CIFS implementation.
+   tdb utility functions
+   Copyright (C) Andrew Tridgell 1992-2006
+   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/>.
+*/
 #ifndef _____LIB_UTIL_UTIL_TDB_H__
 #define _____LIB_UTIL_UTIL_TDB_H__
 /***************************************************************
 …
 /****************************************************************************
  Store a int32_t value by an arbitary blob key, return 0 on success, -1 on failure.
+ Store a int32_t value by an arbitrary blob key, return 0 on success, -1 on failure.
  Input is int32_t in native byte order. Output in tdb is in little-endian.
 ****************************************************************************/
 …
 /****************************************************************************
  Store a uint32_t value by an arbitary blob key, return 0 on success, -1 on failure.
+ Store a uint32_t value by an arbitrary blob key, return 0 on success, -1 on failure.
  Input is uint32_t in native byte order. Output in tdb is in little-endian.
 ****************************************************************************/

vendor/current/lib/util/wrap_xattr.h

-              r414
+              r740
+/*
+   Unix SMB/CIFS implementation.
+   POSIX NTVFS backend - xattr support using filesystem xattrs
+   Copyright (C) Andrew Tridgell 2004
+   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/>.
+*/
 #ifndef __LIB_UTIL_WRAP_XATTR_H__
 #define __LIB_UTIL_WRAP_XATTR_H__

Context Navigation

Legend:

Download in other formats: