smbd/mangle_hash2.c

ソースコードを見る。

関数
static unsigned int	mangle_hash (const char *key, unsigned int length)
static BOOL	cache_init (void)
static void	cache_insert (const char *prefix, int length, unsigned int hash)
static const char *	cache_lookup (unsigned int hash)
static BOOL	is_mangled_component (const char *name, size_t len)
static BOOL	is_mangled (const char *name, const struct share_params *parm)
static BOOL	is_8_3 (const char *name, BOOL check_case, BOOL allow_wildcards, const struct share_params *p)
static void	mangle_reset (void)
static BOOL	check_cache (char *name, size_t maxlen, const struct share_params *p)
static BOOL	is_reserved_name (const char *name)
static BOOL	is_legal_name (const char *name)
static void	name_map (fstring name, BOOL need83, BOOL cache83, int default_case, const struct share_params *p)
static void	init_tables (void)
mangle_fns *	mangle_hash2_init (void)
static void	posix_mangle_reset (void)
static BOOL	posix_is_mangled (const char *s, const struct share_params *p)
static BOOL	posix_is_8_3 (const char *fname, BOOL check_case, BOOL allow_wildcards, const struct share_params *p)
static BOOL	posix_check_cache (char *s, size_t maxlen, const struct share_params *p)
static void	posix_name_map (char *OutName, BOOL need83, BOOL cache83, int default_case, const struct share_params *p)
mangle_fns *	posix_mangle_init (void)
変数
static unsigned char	char_flags [256]
static unsigned	mangle_prefix
static char **	prefix_cache
static unsigned int *	prefix_cache_hashes
static const char *	basechars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
static unsigned char	base_reverse [256]
static const char *	reserved_names []
static struct mangle_fns	mangle_fns
static struct mangle_fns	posix_mangle_fns

---

関数

static unsigned int mangle_hash	(	const char *	key,
		unsigned int	length
	)			[static]

mangle_hash2.c の 122 行で定義されています。

参照先 strupper_m().

参照元 name_map().

{
        unsigned int value;
        unsigned int   i;
        fstring str;

        /* we have to uppercase here to ensure that the mangled name
           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);

        /* the length of a multi-byte string can change after a strupper_m */
        length = strlen(str);

        /* Set the initial value from the key size. */
        for (value = FNV1_INIT, i=0; i < length; i++) {
                value *= (unsigned int)FNV1_PRIME;
                value ^= (unsigned int)(str[i]);
        }

        /* note that we force it to a 31 bit hash, to keep within the limits
           of the 36^6 mangle space */
        return value & ~0x80000000;  
}

static BOOL cache_init

(

void

)

[static]

mangle_hash2.c の 154 行で定義されています。

参照先 prefix_cache・prefix_cache_hashes.

参照元 mangle_hash2_init().

{
        if (prefix_cache) {
                return True;
        }

        prefix_cache = SMB_CALLOC_ARRAY(char *,MANGLE_CACHE_SIZE);
        if (!prefix_cache) {
                return False;
        }

        prefix_cache_hashes = SMB_CALLOC_ARRAY(unsigned int, MANGLE_CACHE_SIZE);
        if (!prefix_cache_hashes) {
                return False;
        }

        return True;
}

static void cache_insert	(	const char *	prefix,
		int	length,
		unsigned int	hash
	)			[static]

mangle_hash2.c の 176 行で定義されています。

参照先 prefix_cache・prefix_cache_hashes.

参照元 name_map().

{
        int i = hash % MANGLE_CACHE_SIZE;

        if (prefix_cache[i]) {
                free(prefix_cache[i]);
        }

        prefix_cache[i] = SMB_STRNDUP(prefix, length);
        prefix_cache_hashes[i] = hash;
}

static const char* cache_lookup

(

unsigned int

hash

)

[static]

mangle_hash2.c の 191 行で定義されています。

参照先 prefix_cache・prefix_cache_hashes.

参照元 check_cache().

{
        int i = hash % MANGLE_CACHE_SIZE;

        if (!prefix_cache[i] || hash != prefix_cache_hashes[i]) {
                return NULL;
        }

        /* yep, it matched */
        return prefix_cache[i];
}

static BOOL is_mangled_component	(	const char *	name,
		size_t	len
	)			[static]

mangle_hash2.c の 211 行で定義されています。

参照先 mangle_prefix.

参照元 is_mangled().

{
        unsigned int i;

        M_DEBUG(10,("is_mangled_component %s (len %lu) ?\n", name, (unsigned long)len));

        /* check the length */
        if (len > 12 || len < 8)
                return False;

        /* the best distinguishing characteristic is the ~ */
        if (name[6] != '~')
                return False;

        /* check extension */
        if (len > 8) {
                if (name[8] != '.')
                        return False;
                for (i=9; name[i] && i < len; i++) {
                        if (! FLAG_CHECK(name[i], FLAG_ASCII)) {
                                return False;
                        }
                }
        }
        
        /* check lead characters */
        for (i=0;i<mangle_prefix;i++) {
                if (! FLAG_CHECK(name[i], FLAG_ASCII)) {
                        return False;
                }
        }
        
        /* check rest of hash */
        if (! FLAG_CHECK(name[7], FLAG_BASECHAR)) {
                return False;
        }
        for (i=mangle_prefix;i<6;i++) {
                if (! FLAG_CHECK(name[i], FLAG_BASECHAR)) {
                        return False;
                }
        }

        M_DEBUG(10,("is_mangled_component %s (len %lu) -> yes\n", name, (unsigned long)len));

        return True;
}

static BOOL is_mangled	(	const char *	name,
		const struct share_params *	parm
	)			[static]

mangle_hash2.c の 271 行で定義されています。

参照先 is_mangled_component().

{
        const char *p;
        const char *s;

        M_DEBUG(10,("is_mangled %s ?\n", name));

        for (s=name; (p=strchr(s, '/')); s=p+1) {
                if (is_mangled_component(s, PTR_DIFF(p, s))) {
                        return True;
                }
        }
        
        /* and the last part ... */
        return is_mangled_component(s,strlen(s));
}

static BOOL is_8_3	(	const char *	name,
		BOOL	check_case,
		BOOL	allow_wildcards,
		const struct share_params *	p
	)			[static]

mangle_hash2.c の 296 行で定義されています。

参照先 len.

{
        int len, i;
        char *dot_p;

        /* as a special case, the names '.' and '..' are allowable 8.3 names */
        if (name[0] == '.') {
                if (!name[1] || (name[1] == '.' && !name[2])) {
                        return True;
                }
        }

        /* the simplest test is on the overall length of the
         filename. Note that we deliberately use the ascii string
         length (not the multi-byte one) as it is faster, and gives us
         the result we need in this case. Using strlen_m would not
         only be slower, it would be incorrect */
        len = strlen(name);
        if (len > 12)
                return False;

        /* find the '.'. Note that once again we use the non-multibyte
           function */
        dot_p = strchr(name, '.');

        if (!dot_p) {
                /* if the name doesn't contain a '.' then its length
                   must be less than 8 */
                if (len > 8) {
                        return False;
                }
        } else {
                int prefix_len, suffix_len;

                /* if it does contain a dot then the prefix must be <=
                   8 and the suffix <= 3 in length */
                prefix_len = PTR_DIFF(dot_p, name);
                suffix_len = len - (prefix_len+1);

                if (prefix_len > 8 || suffix_len > 3 || suffix_len == 0) {
                        return False;
                }

                /* a 8.3 name cannot contain more than 1 '.' */
                if (strchr(dot_p+1, '.')) {
                        return False;
                }
        }

        /* the length are all OK. Now check to see if the characters themselves are OK */
        for (i=0; name[i]; i++) {
                /* note that we may allow wildcard petterns! */
                if (!FLAG_CHECK(name[i], FLAG_ASCII|(allow_wildcards ? FLAG_WILDCARD : 0)) && name[i] != '.') {
                        return False;
                }
        }

        /* it is a good 8.3 name */
        return True;
}

static void mangle_reset

(

void

)

[static]

mangle_hash2.c の 363 行で定義されています。

{
        /* noop */
}

static BOOL check_cache	(	char *	name,
		size_t	maxlen,
		const struct share_params *	p
	)			[static]

mangle_hash2.c の 373 行で定義されています。

参照先 base_reverse・cache_lookup()・is_mangled()・mangle_prefix.

{
        unsigned int hash, multiplier;
        unsigned int i;
        const char *prefix;
        char extension[4];

        /* make sure that this is a mangled name from this cache */
        if (!is_mangled(name, p)) {
                M_DEBUG(10,("check_cache: %s -> not mangled\n", name));
                return False;
        }

        /* we need to extract the hash from the 8.3 name */
        hash = base_reverse[(unsigned char)name[7]];
        for (multiplier=36, i=5;i>=mangle_prefix;i--) {
                unsigned int v = base_reverse[(unsigned char)name[i]];
                hash += multiplier * v;
                multiplier *= 36;
        }

        /* now look in the prefix cache for that hash */
        prefix = cache_lookup(hash);
        if (!prefix) {
                M_DEBUG(10,("check_cache: %s -> %08X -> not found\n", name, hash));
                return False;
        }

        /* we found it - construct the full name */
        if (name[8] == '.') {
                strncpy(extension, name+9, 3);
                extension[3] = 0;
        } else {
                extension[0] = 0;
        }

        if (extension[0]) {
                M_DEBUG(10,("check_cache: %s -> %s.%s\n", name, prefix, extension));
                slprintf(name, maxlen, "%s.%s", prefix, extension);
        } else {
                M_DEBUG(10,("check_cache: %s -> %s\n", name, prefix));
                safe_strcpy(name, prefix, maxlen);
        }

        return True;
}

static BOOL is_reserved_name

(

const char *

name

)

[static]

mangle_hash2.c の 424 行で定義されています。

参照先 len・reserved_names・strnequal().

参照元 name_map().

{
        if (FLAG_CHECK(name[0], FLAG_POSSIBLE1) &&
            FLAG_CHECK(name[1], FLAG_POSSIBLE2) &&
            FLAG_CHECK(name[2], FLAG_POSSIBLE3) &&
            FLAG_CHECK(name[3], FLAG_POSSIBLE4)) {
                /* a likely match, scan the lot */
                int i;
                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 (strnequal(name, reserved_names[i], len) &&
                            (name[len] == '.' || name[len] == 0)) {
                                return True;
                        }
                }
        }

        return False;
}

static BOOL is_legal_name

(

const char *

name

)

[static]

mangle_hash2.c の 451 行で定義されています。

参照先 CH_UNIX・CH_UTF16LE・convert_string().

参照元 name_map().

{
        const char *dot_pos = NULL;
        BOOL alldots = True;
        size_t numdots = 0;

        while (*name) {
                if (((unsigned int)name[0]) > 128 && (name[1] != 0)) {
                        /* Possible start of mb character. */
                        char mbc[2];
                        /*
                         * 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.
                         */
                        if (convert_string(CH_UNIX, CH_UTF16LE, name, 2, mbc, 2, False) == 2) {
                                /* Was a good mb string. */
                                name += 2;
                                continue;
                        }
                }

                if (FLAG_CHECK(name[0], FLAG_ILLEGAL)) {
                        return False;
                }
                if (name[0] == '.') {
                        dot_pos = name;
                        numdots++;
                } else {
                        alldots = False;
                }
                if ((name[0] == ' ') && (name[1] == '\0')) {
                        /* Can't end in ' ' */
                        return False;
                }
                name++;
        }

        if (dot_pos) {
                if (alldots && (numdots == 1 || numdots == 2))
                        return True; /* . or .. is a valid name */

                /* A valid long name cannot end in '.' */
                if (dot_pos[1] == '\0')
                        return False;
        }
        return True;
}

static void name_map	(	fstring	name,
		BOOL	need83,
		BOOL	cache83,
		int	default_case,
		const struct share_params *	p
	)			[static]

mangle_hash2.c の 513 行で定義されています。

参照先 c・cache_insert()・is_8_3()・is_legal_name()・is_reserved_name()・mangle_hash()・mangle_prefix・toupper_ascii().

{
        char *dot_p;
        char lead_chars[7];
        char extension[4];
        unsigned int extension_length, i;
        unsigned int prefix_len;
        unsigned int hash, v;
        char new_name[13];

        /* reserved names are handled specially */
        if (!is_reserved_name(name)) {
                /* if the name is already a valid 8.3 name then we don't need to 
                   do anything */
                if (is_8_3(name, False, False, p)) {
                        return;
                }

                /* if the caller doesn't strictly need 8.3 then just check for illegal 
                   filenames */
                if (!need83 && is_legal_name(name)) {
                        return;
                }
        }

        /* find the '.' if any */
        dot_p = strrchr(name, '.');

        if (dot_p) {
                /* if the extension contains any illegal characters or
                   is too long or zero length then we treat it as part
                   of the prefix */
                for (i=0; i<4 && dot_p[i+1]; i++) {
                        if (! FLAG_CHECK(dot_p[i+1], FLAG_ASCII)) {
                                dot_p = NULL;
                                break;
                        }
                }
                if (i == 0 || i == 4) dot_p = NULL;
        }

        /* the leading characters in the mangled name is taken from
           the first characters of the name, if they are ascii otherwise
           '_' is used
        */
        for (i=0;i<mangle_prefix && name[i];i++) {
                lead_chars[i] = name[i];
                if (! FLAG_CHECK(lead_chars[i], FLAG_ASCII)) {
                        lead_chars[i] = '_';
                }
                lead_chars[i] = toupper_ascii(lead_chars[i]);
        }
        for (;i<mangle_prefix;i++) {
                lead_chars[i] = '_';
        }

        /* the prefix is anything up to the first dot */
        if (dot_p) {
                prefix_len = PTR_DIFF(dot_p, name);
        } else {
                prefix_len = strlen(name);
        }

        /* the extension of the mangled name is taken from the first 3
           ascii chars after the dot */
        extension_length = 0;
        if (dot_p) {
                for (i=1; extension_length < 3 && dot_p[i]; i++) {
                        char c = dot_p[i];
                        if (FLAG_CHECK(c, FLAG_ASCII)) {
                                extension[extension_length++] = toupper_ascii(c);
                        }
                }
        }
           
        /* find the hash for this prefix */
        v = hash = mangle_hash(name, prefix_len);

        /* now form the mangled name. */
        for (i=0;i<mangle_prefix;i++) {
                new_name[i] = lead_chars[i];
        }
        new_name[7] = base_forward(v % 36);
        new_name[6] = '~';      
        for (i=5; i>=mangle_prefix; i--) {
                v = v / 36;
                new_name[i] = base_forward(v % 36);
        }

        /* add the extension */
        if (extension_length) {
                new_name[8] = '.';
                memcpy(&new_name[9], extension, extension_length);
                new_name[9+extension_length] = 0;
        } else {
                new_name[8] = 0;
        }

        if (cache83) {
                /* put it in the cache */
                cache_insert(name, prefix_len, hash);
        }

        M_DEBUG(10,("name_map: %s -> %08X -> %s (cache=%d)\n", 
                   name, hash, new_name, cache83));

        /* and overwrite the old name */
        fstrcpy(name, new_name);

        /* all done, we've managed to mangle it */
}

static void init_tables

(

void

)

[static]

mangle_hash2.c の 633 行で定義されています。

参照先 base_reverse・char_flags・reserved_names・tolower_ascii().

参照元 mangle_hash2_init().

{
        int i;

        memset(char_flags, 0, sizeof(char_flags));

        for (i=1;i<128;i++) {
                if (i <= 0x1f) {
                        /* Control characters. */
                        char_flags[i] |= FLAG_ILLEGAL;
                }

                if ((i >= '0' && i <= '9') || 
                    (i >= 'a' && i <= 'z') || 
                    (i >= 'A' && i <= 'Z')) {
                        char_flags[i] |=  (FLAG_ASCII | FLAG_BASECHAR);
                }
                if (strchr("_-$~", i)) {
                        char_flags[i] |= FLAG_ASCII;
                }

                if (strchr("*\\/?<>|\":", i)) {
                        char_flags[i] |= FLAG_ILLEGAL;
                }

                if (strchr("*?\"<>", i)) {
                        char_flags[i] |= FLAG_WILDCARD;
                }
        }

        memset(base_reverse, 0, sizeof(base_reverse));
        for (i=0;i<36;i++) {
                base_reverse[(unsigned char)base_forward(i)] = i;
        }       

        /* fill in the reserved names flags. These are used as a very
           fast filter for finding possible DOS reserved filenames */
        for (i=0; reserved_names[i]; i++) {
                unsigned char c1, c2, c3, c4;

                c1 = (unsigned char)reserved_names[i][0];
                c2 = (unsigned char)reserved_names[i][1];
                c3 = (unsigned char)reserved_names[i][2];
                c4 = (unsigned char)reserved_names[i][3];

                char_flags[c1] |= FLAG_POSSIBLE1;
                char_flags[c2] |= FLAG_POSSIBLE2;
                char_flags[c3] |= FLAG_POSSIBLE3;
                char_flags[c4] |= FLAG_POSSIBLE4;
                char_flags[tolower_ascii(c1)] |= FLAG_POSSIBLE1;
                char_flags[tolower_ascii(c2)] |= FLAG_POSSIBLE2;
                char_flags[tolower_ascii(c3)] |= FLAG_POSSIBLE3;
                char_flags[tolower_ascii(c4)] |= FLAG_POSSIBLE4;

                char_flags[(unsigned char)'.'] |= FLAG_POSSIBLE4;
        }
}

struct mangle_fns* mangle_hash2_init

(

void

)

mangle_hash2.c の 703 行で定義されています。

参照先 cache_init()・init_tables()・mangle_fns・mangle_prefix・mangle_reset().

{
        /* the mangle prefix can only be in the mange 1 to 6 */
        mangle_prefix = lp_mangle_prefix();
        if (mangle_prefix > 6) {
                mangle_prefix = 6;
        }
        if (mangle_prefix < 1) {
                mangle_prefix = 1;
        }

        init_tables();
        mangle_reset();

        if (!cache_init()) {
                return NULL;
        }

        return &mangle_fns;
}

static void posix_mangle_reset

(

void

)

[static]

mangle_hash2.c の 724 行で定義されています。

{;}

static BOOL posix_is_mangled	(	const char *	s,
		const struct share_params *	p
	)			[static]

mangle_hash2.c の 727 行で定義されています。

{
        return False;
}

static BOOL posix_is_8_3	(	const char *	fname,
		BOOL	check_case,
		BOOL	allow_wildcards,
		const struct share_params *	p
	)			[static]

mangle_hash2.c の 732 行で定義されています。

{
        return False;
}

static BOOL posix_check_cache	(	char *	s,
		size_t	maxlen,
		const struct share_params *	p
	)			[static]

mangle_hash2.c の 737 行で定義されています。

{
        return False;
}

static void posix_name_map	(	char *	OutName,
		BOOL	need83,
		BOOL	cache83,
		int	default_case,
		const struct share_params *	p
	)			[static]

mangle_hash2.c の 742 行で定義されています。

{
        if (need83) {
                memset(OutName, '\0', 13);
        }
}

struct mangle_fns* posix_mangle_init

(

void

)

mangle_hash2.c の 758 行で定義されています。

参照先 posix_mangle_fns.

{
        return &posix_mangle_fns;
}

---

変数

unsigned char char_flags[256] [static]

mangle_hash2.c の 86 行で定義されています。

参照元 init_tables().

unsigned mangle_prefix [static]

mangle_hash2.c の 95 行で定義されています。

参照元 check_cache()・is_mangled_component()・mangle_hash2_init()・name_map().

char** prefix_cache [static]

mangle_hash2.c の 103 行で定義されています。

参照元 cache_init()・cache_insert()・cache_lookup().

unsigned int* prefix_cache_hashes [static]

mangle_hash2.c の 104 行で定義されています。

参照元 cache_init()・cache_insert()・cache_lookup().

const char* basechars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" [static]

mangle_hash2.c の 107 行で定義されています。

unsigned char base_reverse[256] [static]

mangle_hash2.c の 108 行で定義されています。

参照元 check_cache()・init_tables().

const char* reserved_names[] [static]

初期値:

 
{ "AUX", "LOCK$", "CON", "COM1", "COM2", "COM3", "COM4",
  "LPT1", "LPT2", "LPT3", "NUL", "PRN", NULL }

mangle_hash2.c の 112 行で定義されています。

参照元 init_tables()・is_reserved_name().

struct mangle_fns mangle_fns [static]

初期値:

 {
        mangle_reset,
        is_mangled,
        is_8_3,
        check_cache,
        name_map
}

mangle_hash2.c の 694 行で定義されています。

struct mangle_fns posix_mangle_fns [static]

初期値:

 {
        posix_mangle_reset,
        posix_is_mangled,
        posix_is_8_3,
        posix_check_cache,
        posix_name_map
}

mangle_hash2.c の 750 行で定義されています。

参照元 posix_mangle_init().

---