r4088: Get medieval on our ass about malloc.... :-). Take control of all our allocation

[tprouty/samba.git] / source / smbd / mangle_hash2.c

diff --git a/source/smbd/mangle_hash2.c b/source/smbd/mangle_hash2.c
index 9cd0438d5134425bc7db64cc0656a0ec5f264c3c..4896cfb17be86505531d1b2e3302075846d5c85e 100644 (file)
--- a/source/smbd/mangle_hash2.c
+++ b/source/smbd/mangle_hash2.c
@@ -53,7 +53,7 @@
 
 #include "includes.h"
 
-#if 0
+#if 1
 #define M_DEBUG(level, x) DEBUG(level, x)
 #else
 #define M_DEBUG(level, x)
@@ -119,7 +119,7 @@ static const char *reserved_names[] =
 
    this hash needs to be fast with a low collision rate (what hash doesn't?)
 */
-static u32 mangle_hash(const char *key, unsigned length)
+static u32 mangle_hash(const char *key, unsigned int length)
 {
        u32 value;
        u32   i;
@@ -129,6 +129,7 @@ static u32 mangle_hash(const char *key, unsigned length)
           doesn't depend on the case of the long name. Note that this
           is the only place where we need to use a multi-byte string
           function */
+       length = MIN(length,sizeof(fstring)-1);
        strncpy(str, key, length);
        str[length] = 0;
        strupper_m(str);
@@ -152,13 +153,19 @@ static u32 mangle_hash(const char *key, unsigned length)
  */
 static BOOL cache_init(void)
 {
-       if (prefix_cache) return True;
+       if (prefix_cache) {
+               return True;
+       }
 
-       prefix_cache = calloc(MANGLE_CACHE_SIZE, sizeof(char *));
-       if (!prefix_cache) return False;
+       prefix_cache = SMB_CALLOC_ARRAY(char *,MANGLE_CACHE_SIZE);
+       if (!prefix_cache) {
+               return False;
+       }
 
-       prefix_cache_hashes = calloc(MANGLE_CACHE_SIZE, sizeof(u32));
-       if (!prefix_cache_hashes) return False;
+       prefix_cache_hashes = SMB_CALLOC_ARRAY(u32, MANGLE_CACHE_SIZE);
+       if (!prefix_cache_hashes) {
+               return False;
+       }
 
        return True;
 }
@@ -174,7 +181,7 @@ static void cache_insert(const char *prefix, int length, u32 hash)
                free(prefix_cache[i]);
        }
 
-       prefix_cache[i] = strndup(prefix, length);
+       prefix_cache[i] = SMB_STRNDUP(prefix, length);
        prefix_cache_hashes[i] = hash;
 }
 
@@ -219,7 +226,7 @@ static BOOL is_mangled_component(const char *name, size_t len)
        if (len > 8) {
                if (name[8] != '.')
                        return False;
-               for (i=9; name[i]; i++) {
+               for (i=9; name[i] && i < len; i++) {
                        if (! FLAG_CHECK(name[i], FLAG_ASCII)) {
                                return False;
                        }
@@ -325,7 +332,7 @@ static BOOL is_8_3(const char *name, BOOL check_case, BOOL allow_wildcards)
                prefix_len = PTR_DIFF(dot_p, name);
                suffix_len = len - (prefix_len+1);
 
-               if (prefix_len > 8 || suffix_len > 3) {
+               if (prefix_len > 8 || suffix_len > 3 || suffix_len == 0) {
                        return False;
                }
 
@@ -362,10 +369,8 @@ static void mangle_reset(void)
 /*
   try to find a 8.3 name in the cache, and if found then
   replace the string with the original long name. 
-
-  The filename must be able to hold at least sizeof(fstring) 
 */
-static BOOL check_cache(char *name)
+static BOOL check_cache(char *name, size_t maxlen)
 {
        u32 hash, multiplier;
        unsigned int i;
@@ -403,10 +408,10 @@ static BOOL check_cache(char *name)
 
        if (extension[0]) {
                M_DEBUG(10,("check_cache: %s -> %s.%s\n", name, prefix, extension));
-               slprintf(name, sizeof(fstring), "%s.%s", prefix, extension);
+               slprintf(name, maxlen, "%s.%s", prefix, extension);
        } else {
                M_DEBUG(10,("check_cache: %s -> %s\n", name, prefix));
-               fstrcpy(name, prefix);
+               safe_strcpy(name, prefix, maxlen);
        }
 
        return True;
@@ -427,7 +432,7 @@ static BOOL is_reserved_name(const char *name)
                for (i=0; reserved_names[i]; i++) {
                        int len = strlen(reserved_names[i]);
                        /* note that we match on COM1 as well as COM1.foo */
-                       if (strncasecmp(name, reserved_names[i], len) == 0 &&
+                       if (strnequal(name, reserved_names[i], len) &&
                            (name[len] == '.' || name[len] == 0)) {
                                return True;
                        }
@@ -453,17 +458,13 @@ static BOOL is_legal_name(const char *name)
                        /* Possible start of mb character. */
                        char mbc[2];
                        /*
-                        * We know the following will return 2 bytes. What
-                        * we need to know was if errno was set.
                         * Note that if CH_UNIX is utf8 a string may be 3
                         * bytes, but this is ok as mb utf8 characters don't
                         * contain embedded ascii bytes. We are really checking
                         * for mb UNIX asian characters like Japanese (SJIS) here.
                         * JRA.
                         */
-                       errno = 0;
-                       convert_string(CH_UNIX, CH_UCS2, name, 2, mbc, 2);
-                       if (!errno) {
+                       if (convert_string(CH_UNIX, CH_UCS2, name, 2, mbc, 2, False) == 2) {
                                /* Was a good mb string. */
                                name += 2;
                                continue;
@@ -505,7 +506,7 @@ static BOOL is_legal_name(const char *name)
 
   the name parameter must be able to hold 13 bytes
 */
-static void name_map(fstring name, BOOL need83, BOOL cache83)
+static void name_map(fstring name, BOOL need83, BOOL cache83, int default_case)
 {
        char *dot_p;
        char lead_chars[7];