diff options
Diffstat (limited to 'source/smbd/mangle.c')
| -rw-r--r-- | source/smbd/mangle.c | 1401 |
1 files changed, 882 insertions, 519 deletions
diff --git a/source/smbd/mangle.c b/source/smbd/mangle.c index 8f1490c528d..302817efb6b 100644 --- a/source/smbd/mangle.c +++ b/source/smbd/mangle.c @@ -1,8 +1,7 @@ /* - Unix SMB/Netbios implementation. - Version 1.9. - Name mangling - Copyright (C) Andrew Tridgell 1992-1995 + Unix SMB/CIFS implementation. + Name mangling with persistent tdb + Copyright (C) Simo Sorce 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 @@ -19,592 +18,956 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +/**************************************************************************** + Rewritten from scrach in 2001 by Simo Sorce <idra@samba.org> + ****************************************************************************/ + #include "includes.h" -#include "loadparm.h" -extern int DEBUGLEVEL; -extern int case_default; -extern BOOL case_mangle; -/**************************************************************************** -provide a checksum on a string -****************************************************************************/ -int str_checksum(char *s) +/* -------------------------------------------------------------------------- ** + * External Variables... + */ + +extern int case_default; /* Are conforming 8.3 names all upper or lower? */ +extern BOOL case_mangle; /* If true, all chars in 8.3 should be same case. */ + +char magic_char = '~'; + +/* -------------------------------------------------------------------- */ + +#define MANGLE_TDB_VERSION "20010927" +#define MANGLE_TDB_FILE_NAME "mangle.tdb" +#define MANGLED_PREFIX "MANGLED_" +#define LONG_PREFIX "LONG_" +#define COUNTER_PREFIX "COUNTER_" +#define MANGLE_COUNTER_MAX 99 +#define MANGLE_SUFFIX_SIZE 3 /* "~XX" */ + + +static TDB_CONTEXT *mangle_tdb; + +BOOL init_mangle_tdb(void) { - int res = 0; - int c; - int i=0; - while (*s) - { - c = *s; - res ^= (c << (i % 15)) ^ (c >> (15-(i%15))); - s++; i++; - } - return(res); + char *tdbfile; + + tdbfile = lock_path(MANGLE_TDB_FILE_NAME); /* this return a static pstring do not try to free it */ + + /* Open tdb */ + if (!(mangle_tdb = tdb_open_log(tdbfile, 0, TDB_DEFAULT, O_RDWR | O_CREAT, 0600))) + { + DEBUG(0, ("Unable to open Mangle TDB\n")); + return False; + } + + return True; } -/**************************************************************************** -return True if a name is a special msdos reserved name -****************************************************************************/ -static BOOL is_reserved_msdos(char *fname) +/* trasform a unicode string into a dos charset string */ +static int ucs2_to_dos(char *dest, const smb_ucs2_t *src, int dest_len) { - char upperFname[13]; - char *p; - - StrnCpy (upperFname, fname, 12); - - /* lpt1.txt and con.txt etc are also illegal */ - p=strchr(upperFname,'.'); - if (p) - *p='\0'; - strupper (upperFname); - if ((strcmp(upperFname,"CLOCK$") == 0) || - (strcmp(upperFname,"CON") == 0) || - (strcmp(upperFname,"AUX") == 0) || - (strcmp(upperFname,"COM1") == 0) || - (strcmp(upperFname,"COM2") == 0) || - (strcmp(upperFname,"COM3") == 0) || - (strcmp(upperFname,"COM4") == 0) || - (strcmp(upperFname,"LPT1") == 0) || - (strcmp(upperFname,"LPT2") == 0) || - (strcmp(upperFname,"LPT3") == 0) || - (strcmp(upperFname,"NUL") == 0) || - (strcmp(upperFname,"PRN") == 0)) - return (True) ; - - return (False); + int src_len, ret; + + if (dest_len == -1) { + dest_len = sizeof(pstring); + } + + src_len = strlen_w(src)* sizeof(smb_ucs2_t); + + ret = convert_string(CH_UCS2, CH_DOS, src, src_len, dest, dest_len); + if (dest_len) dest[MIN(ret, dest_len-1)] = 0; + + return ret; } +/* trasform in a string that contain only valid chars for win filenames, + not including a '.' */ +static void strvalid(smb_ucs2_t *src) +{ + if (!src || !*src) return; + + while (*src) { + if (!isvalid83_w(*src) || *src == UCS2_CHAR('.')) *src = UCS2_CHAR('_'); + src++; + } +} -/**************************************************************************** -return True if a name is in 8.3 dos format -****************************************************************************/ -BOOL is_8_3(char *fname) +/* return False if something fail and + * return 2 alloced unicode strings that contain prefix and extension + */ +static NTSTATUS mangle_get_prefix(const smb_ucs2_t *ucs2_string, smb_ucs2_t **prefix, smb_ucs2_t **extension) { - int len; - char *dot_pos; - char *slash_pos = strrchr(fname,'/'); - int l; - - if (slash_pos) fname = slash_pos+1; - len = strlen(fname); - - dot_pos = strchr(fname,'.'); - - DEBUG(5,("checking %s for 8.3\n",fname)); - - if (case_mangle) - switch (case_default) - { - case CASE_LOWER: - if (strhasupper(fname)) return(False); - break; - case CASE_UPPER: - if (strhaslower(fname)) return(False); - break; - } - - /* can't be longer than 12 chars */ - if (len == 0 || len > 12) - return(False); - - /* can't be an MS-DOS Special file such as lpt1 or even lpt1.txt */ - if (is_reserved_msdos(fname)) - return(False); - - /* can't contain invalid dos chars */ - /* Windows use the ANSI charset. - But filenames are translated in the PC charset. - This Translation may be more or less relaxed depending - the Windows application. */ - - /* %%% A nice improvment to name mangling would be to translate - filename to ANSI charset on the smb server host */ - - { - char *p = fname; -#ifdef KANJI - dot_pos = 0; - while (*p) - { - if (is_shift_jis (*p)) { - p += 2; - } else if (is_kana (*p)) { - p ++; - } else { - if (*p == '.' && !dot_pos) - dot_pos = (char *) p; - if (!isdoschar(*p)) - return(False); - p++; - } - } -#else - while (*p) - { - if (!isdoschar(*p)) - return(False); - p++; - } -#endif /* KANJI */ - } - - /* no dot and less than 9 means OK */ - if (!dot_pos) - return(len <= 8); - - l = PTR_DIFF(dot_pos,fname); - - /* base must be at least 1 char except special cases . and .. */ - if (l == 0) - return(strcmp(fname,".") == 0 || strcmp(fname,"..") == 0); - - /* base can't be greater than 8 */ - if (l > 8) - return(False); - - if (lp_strip_dot() && - len - l == 1 && - !strchr(dot_pos+1,'.')) - { - *dot_pos = 0; - return(True); - } - - /* extension must be between 1 and 3 */ - if ( (len - l < 2 ) || (len - l > 4) ) - return(False); - - /* extension can't have a dot */ - if (strchr(dot_pos+1,'.')) - return(False); - - /* must be in 8.3 format */ - return(True); + size_t ext_len; + smb_ucs2_t *p; + + *extension = 0; + *prefix = strdup_w(ucs2_string); + if (!*prefix) + { + DEBUG(0,("mangle_get_prefix: out of memory!\n")); + return NT_STATUS_NO_MEMORY; + } + if ((p = strrchr_w(*prefix, UCS2_CHAR('.')))) + { + ext_len = strlen_w(p+1); + if ((ext_len > 0) && (ext_len < 4) && (p != *prefix) && + (NT_STATUS_IS_OK(has_valid_chars(p+1)))) /* check extension */ + { + *p = 0; + *extension = strdup_w(p+1); + if (!*extension) + { + DEBUG(0,("mangle_get_prefix: out of memory!\n")); + SAFE_FREE(*prefix); + return NT_STATUS_NO_MEMORY; + } + } + } + return NT_STATUS_OK; } +/* mangled must contain only the file name, not a path. + and MUST be ZERO terminated */ +smb_ucs2_t *unmangle(const smb_ucs2_t *mangled) +{ + TDB_DATA data, key; + fstring keystr; + fstring mufname; + smb_ucs2_t *pref, *ext, *retstr; + size_t long_len, ext_len, muf_len; + + if (strlen_w(mangled) > 12) return NULL; + if (!strchr_w(mangled, UCS2_CHAR('~'))) return NULL; + + /* if it is a path refuse to proceed */ + if (strchr_w(mangled, UCS2_CHAR('/'))) { + DEBUG(10, ("unmangle: cannot unmangle a path\n")); + return NULL; + } -/* -keep a stack of name mangling results - just -so file moves and copies have a chance of working -*/ -fstring *mangled_stack = NULL; -int mangled_stack_size = 0; -int mangled_stack_len = 0; + if (NT_STATUS_IS_ERR(mangle_get_prefix(mangled, &pref, &ext))) + return NULL; -/**************************************************************************** -create the mangled stack -****************************************************************************/ -void create_mangled_stack(int size) + /* mangled names are stored lowercase only */ + strlower_w(pref); + /* set search key */ + muf_len = ucs2_to_dos(mufname, pref, sizeof(mufname)); + SAFE_FREE(pref); + if (!muf_len) return NULL; + + slprintf(keystr, sizeof(keystr) - 1, "%s%s", MANGLED_PREFIX, mufname); + key.dptr = keystr; + key.dsize = strlen (keystr) + 1; + + /* get the record */ + data = tdb_fetch(mangle_tdb, key); + + if (!data.dptr) /* not found */ + { + DEBUG(5,("unmangle: failed retrieve from db %s\n", tdb_errorstr(mangle_tdb))); + retstr = NULL; + goto done; + } + + if (ext) + { + long_len = (data.dsize / 2) - 1; + ext_len = strlen_w(ext); + retstr = (smb_ucs2_t *)malloc((long_len + ext_len + 2)*sizeof(smb_ucs2_t)); + if (!retstr) + { + DEBUG(0, ("unamngle: out of memory!\n")); + goto done; + } + strncpy_w(retstr, (smb_ucs2_t *)data.dptr, long_len); + retstr[long_len] = UCS2_CHAR('.'); + retstr[long_len + 1] = 0; + strncat_w(retstr, ext, ext_len); + } + else + { + retstr = strdup_w((smb_ucs2_t *)data.dptr); + if (!retstr) + { + DEBUG(0, ("unamngle: out of memory!\n")); + goto done; + } + + } + +done: + SAFE_FREE(data.dptr); + SAFE_FREE(pref); + SAFE_FREE(ext); + + return retstr; +} + +/* unmangled must contain only the file name, not a path. + and MUST be ZERO terminated. + return a new allocated string if the name is yet valid 8.3 + or is mangled successfully. + return null on error. + */ + +smb_ucs2_t *mangle(const smb_ucs2_t *unmangled) { - if (mangled_stack) - { - free(mangled_stack); - mangled_stack_size = 0; - mangled_stack_len = 0; - } - if (size > 0) - mangled_stack = (fstring *)malloc(sizeof(fstring)*size); - if (mangled_stack) mangled_stack_size = size; + TDB_DATA data, key, klock; + pstring keystr; + pstring longname; + fstring keylock; + fstring mufname; + fstring prefix; + BOOL tclock = False; + char suffix[7]; + smb_ucs2_t *mangled = NULL; + smb_ucs2_t *umpref, *ext, *p = NULL; + size_t pref_len, ext_len, ud83_len; + + /* if it is a path refuse to proceed */ + if (strchr_w(unmangled, UCS2_CHAR('/'))) { + DEBUG(10, ("mangle: cannot mangle a path\n")); + return NULL; + } + + /* if it is a valid 8_3 do not mangle again */ + if (NT_STATUS_IS_OK(is_8_3_w(unmangled))) + return NULL; + + if (NT_STATUS_IS_ERR(mangle_get_prefix(unmangled, &umpref, &ext))) + return NULL; + + /* test if the same is yet mangled */ + + /* set search key */ + pull_ucs2(NULL, longname, umpref, sizeof(longname), 0, STR_TERMINATE); + slprintf(keystr, sizeof(keystr)-1, "%s%s", LONG_PREFIX, longname); + key.dptr = keystr; + key.dsize = strlen(keystr) + 1; + + /* get the record */ + data = tdb_fetch (mangle_tdb, key); + if (!data.dptr) /* not found */ + { + smb_ucs2_t temp[9]; + size_t c, pos; + + if (tdb_error(mangle_tdb) != TDB_ERR_NOEXIST) + { + DEBUG(0, ("mangle: database retrieval error: %s\n", + tdb_errorstr(mangle_tdb))); + goto done; + } + + /* if not find the first free possibile mangled name */ + + pos = strlen_w(umpref); + if ((8 - MANGLE_SUFFIX_SIZE) < pos) + pos = 8 - MANGLE_SUFFIX_SIZE; + pos++; + do + { + pos--; + if (pos == 0) + { + DEBUG(0, ("mangle: unable to mangle file name!\n")); + goto done; + } + strncpy_w(temp, umpref, pos); + temp[pos] = 0; + strlower_w(temp); + + /* convert any invalid char into '_' */ + strvalid(temp); + ud83_len = ucs2_to_dos(prefix, temp, sizeof(prefix)); + if (!ud83_len) goto done; + } + while (ud83_len > 8 - MANGLE_SUFFIX_SIZE); + + slprintf(keylock, sizeof(keylock)-1, "%s%s", COUNTER_PREFIX, prefix); + klock.dptr = keylock; + klock.dsize = strlen(keylock) + 1; + + c = 0; + data.dptr = (char *)&c; + data.dsize = sizeof(uint32); + /* try to insert a new counter prefix, if it exist the call will + fail (correct) otherwise it will create a new entry with counter set + to 0 + */ + if(tdb_store(mangle_tdb, klock, data, TDB_INSERT) != TDB_SUCCESS) + { + if (tdb_error(mangle_tdb) != TDB_ERR_EXISTS) + { + DEBUG(0, ("mangle: database store error: %s\n", + tdb_errorstr(mangle_tdb))); + goto done; + } + } + + /* lock the mangle counter for this prefix */ + if (tdb_chainlock(mangle_tdb, klock)) + { + DEBUG(0,("mangle: failed to lock database\n!")); + goto done; + } + tclock = True; + + data = tdb_fetch(mangle_tdb, klock); + if (!data.dptr) + { + DEBUG(0, ("mangle: database retrieval error: %s\n", + tdb_errorstr(mangle_tdb))); + goto done; + } + c = *((uint32 *)data.dptr); + c++; + + if (c > MANGLE_COUNTER_MAX) + { + DEBUG(0, ("mangle: error, counter overflow!\n")); + goto done; + } + + temp[pos] = UCS2_CHAR('~'); + temp[pos+1] = 0; + snprintf(suffix, 7, "%.6d", c); + strncat_wa(temp, &suffix[7 - MANGLE_SUFFIX_SIZE], MANGLE_SUFFIX_SIZE); + + ud83_len = ucs2_to_dos(mufname, temp, sizeof(mufname)); + if (!ud83_len) goto done; + if (ud83_len > 8) + { + DEBUG(0, ("mangle: darn, logic error aborting!\n")); + goto done; + } + + /* store the long entry with mangled key */ + slprintf(keystr, sizeof(keystr)-1, "%s%s", MANGLED_PREFIX, mufname); + key.dptr = keystr; + key.dsize = strlen (keystr) + 1; + data.dsize = (strlen_w(umpref) + 1) * sizeof (smb_ucs2_t); + data.dptr = (void *)umpref; + + if (tdb_store(mangle_tdb, key, data, TDB_INSERT) != TDB_SUCCESS) + { + DEBUG(0, ("mangle: database store error: %s\n", + tdb_errorstr(mangle_tdb))); + goto done; + } + + /* store the mangled entry with long key*/ + pull_ucs2(NULL, longname, umpref, sizeof(longname), 0, STR_TERMINATE); + slprintf(keystr, sizeof(keystr)-1, "%s%s", LONG_PREFIX, longname); + key.dptr = keystr; + key.dsize = strlen (keystr) + 1; + data.dsize = strlen(mufname) + 1; + data.dptr = mufname; + if (tdb_store(mangle_tdb, key, data, TDB_INSERT) != TDB_SUCCESS) + { + DEBUG(0, ("mangle: database store failed: %s\n", + tdb_errorstr(mangle_tdb))); + + /* try to delete the mangled key entry to avoid later inconsistency */ + slprintf(keystr, sizeof(keystr)-1, "%s%s", MANGLED_PREFIX, mufname); + key.dptr = keystr; + key.dsize = strlen (keystr) + 1; + if (!tdb_delete(mangle_tdb, key)) + { + DEBUG(0, ("mangle: severe error, mangled tdb may be inconsistent!\n")); + } + goto done; + } + + p = strdup_w(temp); + if (!p) + { + DEBUG(0,("mangle: out of memory!\n")); + goto done; + } + + data.dptr = (char *)&c; + data.dsize = sizeof(uint32); + /* store the counter */ + if(tdb_store(mangle_tdb, klock, data, TDB_REPLACE) != TDB_SUCCESS) + { + DEBUG(0, ("mangle: database store failed: %s\n", + tdb_errorstr(mangle_tdb))); + /* try to delete the mangled and long key entry to avoid later inconsistency */ + slprintf(keystr, sizeof(keystr)-1, "%s%s", MANGLED_PREFIX, mufname); + key.dptr = keystr; + key.dsize = strlen (keystr) + 1; + if (!tdb_delete(mangle_tdb, key)) + { + DEBUG(0, ("mangle: severe error, mangled tdb may be inconsistent!\n")); + } + slprintf(keystr, sizeof(keystr)-1, "%s%s", LONG_PREFIX, longname); + key.dptr = keystr; + key.dsize = strlen (keystr) + 1; + if (!tdb_delete(mangle_tdb, key)) + { + DEBUG(0, ("mangle: severe error, mangled tdb may be inconsistent!\n")); + } + goto done; + } + + tclock = False; + tdb_chainunlock(mangle_tdb, klock); + } + else /* FOUND */ + { + p = acnv_dosu2(data.dptr); + if (!p) + { + DEBUG(0,("mangle: out of memory!\n")); + goto done; + } + } + + if (ext) + { + pref_len = strlen_w(p); + ext_len = strlen_w(ext); + mangled = (smb_ucs2_t *)malloc((pref_len + ext_len + 2)*sizeof(smb_ucs2_t)); + if (!mangled) + { + DEBUG(0,("mangle: out of memory!\n")); + goto done; + } + strncpy_w (mangled, p, pref_len); + mangled[pref_len] = UCS2_CHAR('.'); + mangled[pref_len + 1] = 0; + strncat_w (mangled, ext, ext_len); + } + else + { + mangled = strdup_w(p); + if (!mangled) + { + DEBUG(0,("mangle: out of memory!\n")); + goto done; + } + } + + /* mangled name are returned in upper or lower case depending on + case_default value */ + strnorm_w(mangled); + +done: + if (tclock) tdb_chainunlock(mangle_tdb, klock); + SAFE_FREE(p); + SAFE_FREE(umpref); + SAFE_FREE(ext); + + return mangled; } -/**************************************************************************** -push a mangled name onto the stack -****************************************************************************/ -static void push_mangled_name(char *s) + +/* non unicode compatibility functions */ + +char *dos_mangle(const char *dos_unmangled) { - int i; - char *p; - - if (!mangled_stack) - return; - - for (i=0;i<mangled_stack_len;i++) - if (strcmp(s,mangled_stack[i]) == 0) - { - array_promote(mangled_stack[0],sizeof(fstring),i); - return; - } - - memmove(mangled_stack[1],mangled_stack[0], - sizeof(fstring)*MIN(mangled_stack_len,mangled_stack_size-1)); - strcpy(mangled_stack[0],s); - p = strrchr(mangled_stack[0],'.'); - if (p && (!strhasupper(p+1)) && (strlen(p+1) < 4)) - *p = 0; - mangled_stack_len = MIN(mangled_stack_size,mangled_stack_len+1); + smb_ucs2_t *in, *out; + char *dos_mangled; + + if (!dos_unmangled || !*dos_unmangled) return NULL; + + in = acnv_dosu2(dos_unmangled); + if (!in) + { + DEBUG(0,("dos_mangle: out of memory!\n")); + return NULL; + } + + out = mangle(in); + if (!out) + { + SAFE_FREE(in); + return NULL; + } + + dos_mangled = acnv_u2dos(out); + if (!dos_mangled) + { + DEBUG(0,("dos_mangle: out of memory!\n")); + goto done; + } + +done: + SAFE_FREE(in); + SAFE_FREE(out); + return dos_mangled; } -/**************************************************************************** -check for a name on the mangled name stack -****************************************************************************/ -BOOL check_mangled_stack(char *s) +char *dos_unmangle(const char *dos_mangled) { - int i; - pstring tmpname; - char extension[5]; - char *p = strrchr(s,'.'); - BOOL check_extension = False; - - extension[0] = 0; - - if (!mangled_stack) return(False); - - if (p) - { - check_extension = True; - StrnCpy(extension,p,4); - strlower(extension); /* XXXXXXX */ - } - - for (i=0;i<mangled_stack_len;i++) - { - strcpy(tmpname,mangled_stack[i]); - mangle_name_83(tmpname); - if (strequal(tmpname,s)) + smb_ucs2_t *in, *out; + char *dos_unmangled; + + if (!dos_mangled || !*dos_mangled) return NULL; + + in = acnv_dosu2(dos_mangled); + if (!in) { - strcpy(s,mangled_stack[i]); - break; + DEBUG(0,("dos_unmangle: out of memory!\n")); + return NULL; } - if (check_extension && !strchr(mangled_stack[i],'.')) + + out = mangle(in); + if (!out) { - strcpy(tmpname,mangled_stack[i]); - strcat(tmpname,extension); - mangle_name_83(tmpname); - if (strequal(tmpname,s)) - { - strcpy(s,mangled_stack[i]); - strcat(s,extension); - break; - } + SAFE_FREE(in); + return NULL; } - } - if (i < mangled_stack_len) - { - DEBUG(3,("Found %s on mangled stack as %s\n",s,mangled_stack[i])); - array_promote(mangled_stack[0],sizeof(fstring),i); - return(True); - } + dos_unmangled = acnv_u2dos(out); + if (!dos_unmangled) + { + DEBUG(0,("dos_unmangle: out of memory!\n")); + goto done; + } - return(False); -} +done: + SAFE_FREE(in); + SAFE_FREE(out); + return dos_unmangled; +} -static char *map_filename(char *s, /* This is null terminated */ - char *pattern, /* This isn't. */ - int len) /* This is the length of pattern. */ +BOOL is_8_3(const char *fname, BOOL check_case) { - static pstring matching_bit; /* The bit of the string which matches */ - /* a * in pattern if indeed there is a * */ - char *sp; /* Pointer into s. */ - char *pp; /* Pointer into p. */ - char *match_start; /* Where the matching bit starts. */ - pstring pat; - - StrnCpy(pat, pattern, len); /* Get pattern into a proper string! */ - strcpy(matching_bit,""); /* Match but no star gets this. */ - pp = pat; /* Initialise the pointers. */ - sp = s; - if ((len == 1) && (*pattern == '*')) { - return NULL; /* Impossible, too ambiguous for */ - /* words! */ - } - - while ((*sp) /* Not the end of the string. */ - && (*pp) /* Not the end of the pattern. */ - && (*sp == *pp) /* The two match. */ - && (*pp != '*')) { /* No wildcard. */ - sp++; /* Keep looking. */ - pp++; - } - if (!*sp && !*pp) /* End of pattern. */ - return matching_bit; /* Simple match. Return empty string. */ - if (*pp == '*') { - pp++; /* Always interrested in the chacter */ - /* after the '*' */ - if (!*pp) { /* It is at the end of the pattern. */ - StrnCpy(matching_bit, s, sp-s); - return matching_bit; - } else { - /* The next character in pattern must match a character further */ - /* along s than sp so look for that character. */ - match_start = sp; - while ((*sp) /* Not the end of s. */ - && (*sp != *pp)) /* Not the same */ - sp++; /* Keep looking. */ - if (!*sp) { /* Got to the end without a match. */ - return NULL; - } else { /* Still hope for a match. */ - /* Now sp should point to a matching character. */ - StrnCpy(matching_bit, match_start, sp-match_start); - /* Back to needing a stright match again. */ - while ((*sp) /* Not the end of the string. */ - && (*pp) /* Not the end of the pattern. */ - && (*sp == *pp)) { /* The two match. */ - sp++; /* Keep looking. */ - pp++; - } - if (!*sp && !*pp) /* Both at end so it matched */ - return matching_bit; - else - return NULL; - } - } - } - return NULL; /* No match. */ + const char *f; + smb_ucs2_t *ucs2name; + NTSTATUS ret = NT_STATUS_UNSUCCESSFUL; + + if (!fname || !*fname) return False; + if ((f = strrchr(fname, '/')) == NULL) f = fname; + else f++; + + DEBUG(10,("is_8_3: testing [%s]\n", f)); + + if (strlen(f) > 12) return False; + + ucs2name = acnv_uxu2(f); + if (!ucs2name) + { + DEBUG(0,("is_8_3: out of memory!\n")); + goto done; + } + + ret = is_8_3_w(ucs2name); + +done: + SAFE_FREE(ucs2name); + + DEBUG(10,("is_8_3: returning -> %s\n", NT_STATUS_IS_OK(ret)?"True":"False")); + + if (NT_STATUS_IS_ERR(ret)) return False; + else return True; } +NTSTATUS is_8_3_w(const smb_ucs2_t *fname) +{ + smb_ucs2_t *pref = 0, *ext = 0; + size_t plen; + NTSTATUS ret = NT_STATUS_UNSUCCESSFUL; -/* this is the magic char used for mangling */ -char magic_char = '~'; + if (!fname || !*fname) return NT_STATUS_INVALID_PARAMETER; + DEBUG(10,("is_8_3_w: testing\n")); /* [%s]\n", fname)); */ -/**************************************************************************** -determine whther is name could be a mangled name -****************************************************************************/ -BOOL is_mangled(char *s) + if (strlen_w(fname) > 12) return NT_STATUS_UNSUCCESSFUL; + + if (strcmp_wa(fname, ".") == 0 || strcmp_wa(fname, "..") == 0) + return NT_STATUS_OK; + + if (NT_STATUS_IS_ERR(is_valid_name(fname))) goto done; + + if (NT_STATUS_IS_ERR(mangle_get_prefix(fname, &pref, &ext))) goto done; + plen = strlen_w(pref); + + if (strchr_wa(pref, '.')) goto done; + if (plen < 1 || plen > 8) goto done; + if (ext) if (strlen_w(ext) > 3) goto done; + + ret = NT_STATUS_OK; + +done: + SAFE_FREE(pref); + SAFE_FREE(ext); + return ret; +} + +NTSTATUS has_valid_chars(const smb_ucs2_t *s) { - char *m = strchr(s,magic_char); - if (!m) return(False); + NTSTATUS ret = NT_STATUS_OK; + + if (!s || !*s) return NT_STATUS_INVALID_PARAMETER; - /* we use two base 36 chars efore the extension */ - if (m[1] == '.' || m[1] == 0 || - m[2] == '.' || m[2] == 0 || - (m[3] != '.' && m[3] != 0)) - return(is_mangled(m+1)); + DEBUG(10,("has_valid_chars: testing\n")); /* [%s]\n", s)); */ + + /* CHECK: this should not be necessary if the ms wild chars + are not valid in valid.dat --- simo */ + if (ms_has_wild_w(s)) return NT_STATUS_UNSUCCESSFUL; + + while (*s) { + if(!isvalid83_w(*s)) return NT_STATUS_UNSUCCESSFUL; + s++; + } - /* it could be */ - return(True); + return ret; } +NTSTATUS is_valid_name(const smb_ucs2_t *fname) +{ + smb_ucs2_t *str, *p; + NTSTATUS ret = NT_STATUS_OK; + if (!fname || !*fname) return NT_STATUS_INVALID_PARAMETER; -/**************************************************************************** -return a base 36 character. v must be from 0 to 35. -****************************************************************************/ -static char base36(int v) + DEBUG(10,("is_valid_name: testing\n")); /* [%s]\n", s)); */ + + if (*fname == UCS2_CHAR('.')) return NT_STATUS_UNSUCCESSFUL; + + ret = has_valid_chars(fname); + if (NT_STATUS_IS_ERR(ret)) return ret; + + str = strdup_w(fname); + p = strchr_w(str, UCS2_CHAR('.')); + if (p) *p = 0; + strupper_w(str); + p = &(str[1]); + + switch(str[0]) + { + case UCS2_CHAR('A'): + if(strcmp_wa(p, "UX") == 0) + ret = NT_STATUS_UNSUCCESSFUL; + break; + case UCS2_CHAR('C'): + if((strcmp_wa(p, "LOCK$") == 0) + || (strcmp_wa(p, "ON") == 0) + || (strcmp_wa(p, "OM1") == 0) + || (strcmp_wa(p, "OM2") == 0) + || (strcmp_wa(p, "OM3") == 0) + || (strcmp_wa(p, "OM4") == 0) + ) + ret = NT_STATUS_UNSUCCESSFUL; + break; + case UCS2_CHAR('L'): + if((strcmp_wa(p, "PT1") == 0) + || (strcmp_wa(p, "PT2") == 0) + || (strcmp_wa(p, "PT3") == 0) + ) + ret = NT_STATUS_UNSUCCESSFUL; + break; + case UCS2_CHAR('N'): + if(strcmp_wa(p, "UL") == 0) + ret = NT_STATUS_UNSUCCESSFUL; + break; + case UCS2_CHAR('P'): + if(strcmp_wa(p, "RN") == 0) + ret = NT_STATUS_UNSUCCESSFUL; + break; + default: + break; + } + + SAFE_FREE(str); + return ret; +} + +BOOL is_mangled(const char *s) { - v = v % 36; - if (v < 10) - return('0'+v); - else /* needed to work around a DEC C compiler bug */ - return('A' + (v-10)); + smb_ucs2_t *u2, *res; + BOOL ret = False; + + DEBUG(10,("is_mangled: testing [%s]\n", s)); + + if (!s || !*s) return False; + if ((strlen(s) > 12) || (!strchr(s, '~'))) return False; + + u2 = acnv_dosu2(s); + if (!u2) + { + DEBUG(0,("is_mangled: out of memory!\n")); + return ret; + } + + res = unmangle(u2); + if (res) ret = True; + SAFE_FREE(res); + SAFE_FREE(u2); + DEBUG(10,("is_mangled: returning [%s]\n", ret?"True":"False")); + return ret; } +NTSTATUS is_mangled_w(const smb_ucs2_t *s) +{ + smb_ucs2_t *res; + NTSTATUS ret = NT_STATUS_UNSUCCESSFUL; + + res = unmangle(s); + if (res) ret = NT_STATUS_OK; + SAFE_FREE(res); + return ret; +} -static void do_fwd_mangled_map(char *s, char *MangledMap) +NTSTATUS path_has_mangled(const smb_ucs2_t *s) { - /* MangledMap is a series of name pairs in () separated by spaces. - * If s matches the first of the pair then the name given is the - * second of the pair. A * means any number of any character and if - * present in the second of the pair as well as the first the - * matching part of the first string takes the place of the * in the - * second. - * - * I wanted this so that we could have RCS files which can be used - * by UNIX and DOS programs. My mapping string is (RCS rcs) which - * converts the UNIX RCS file subdirectory to lowercase thus - * preventing mangling. - */ - char *start=MangledMap; /* Use this to search for mappings. */ - char *end; /* Used to find the end of strings. */ - char *match_string; - pstring new_string; /* Make up the result here. */ - char *np; /* Points into new_string. */ - - DEBUG(5,("Mangled Mapping '%s' map '%s'\n", s, MangledMap)); - while (*start) { - while ((*start) && (*start != '(')) - start++; - start++; /* Skip the ( */ - if (!*start) - continue; /* Always check for the end. */ - end = start; /* Search for the ' ' or a ')' */ - DEBUG(5,("Start of first in pair '%s'\n", start)); - while ((*end) && !((*end == ' ') || (*end == ')'))) - end++; - if (!*end) { - start = end; - continue; /* Always check for the end. */ - } - DEBUG(5,("End of first in pair '%s'\n", end)); - if ((match_string = map_filename(s, start, end-start))) { - DEBUG(5,("Found a match\n")); - /* Found a match. */ - start = end+1; /* Point to start of what it is to become. */ - DEBUG(5,("Start of second in pair '%s'\n", start)); - end = start; - np = new_string; - while ((*end) /* Not the end of string. */ - && (*end != ')') /* Not the end of the pattern. */ - && (*end != '*')) /* Not a wildcard. */ - *np++ = *end++; - if (!*end) { - start = end; - continue; /* Always check for the end. */ - } - if (*end == '*') { - strcpy(np, match_string); - np += strlen(match_string); - end++; /* Skip the '*' */ - while ((*end) /* Not the end of string. */ - && (*end != ')') /* Not the end of the pattern. */ - && (*end != '*')) /* Not a wildcard. */ - *np++ = *end++; - } - if (!*end) { - start = end; - continue; /* Always check for the end. */ - } - *np++ = '\0'; /* NULL terminate it. */ - DEBUG(5,("End of second in pair '%s'\n", end)); - strcpy(s, new_string); /* Substitute with the new name. */ - DEBUG(5,("s is now '%s'\n", s)); - } - start = end; /* Skip a bit which cannot be wanted */ - /* anymore. */ - start++; - } + smb_ucs2_t *p, *f, *b; + NTSTATUS ret = NT_STATUS_UNSUCCESSFUL; + + if (!s || !*s) return NT_STATUS_INVALID_PARAMETER; + + p = strdup_w(s); + if (!p) return NT_STATUS_NO_MEMORY; + trim_string_wa(p, "/", "/"); + f = b = p; + while (b) { + b = strchr_w(f, UCS2_CHAR('/')); + if (b) *b = 0; + if (NT_STATUS_IS_OK(is_mangled_w(f))) { + ret = NT_STATUS_OK; + goto done; + } + f = b + 1; + } +done: + SAFE_FREE(p); + return ret; } -/**************************************************************************** -do the actual mangling to 8.3 format -****************************************************************************/ -void mangle_name_83(char *s) +/* backward compatibility functions */ + +void reset_mangled_cache(void) +{ + DEBUG(10,("reset_mangled_cache: compatibility function, remove me!\n")); +} + +BOOL check_mangled_cache(char *s) { - int csum = str_checksum(s); - char *p; - char extension[4]; - char base[9]; - int baselen = 0; - int extlen = 0; - - extension[0]=0; - base[0]=0; - - p = strrchr(s,'.'); - if (p && (strlen(p+1)<4) ) - { - BOOL all_normal = (strisnormal(p+1)); /* XXXXXXXXX */ - if (all_normal && p[1] != 0) + smb_ucs2_t *u2, *res; + BOOL ret = False; + + DEBUG(10,("check_mangled_cache: I'm so ugly, please remove me!\n")); + DEBUG(10,("check_mangled_cache: testing -> [%s]\n", s)); + + if (!s || !*s) return False; + + u2 = acnv_dosu2(s); + if (!u2) { - *p = 0; - csum = str_checksum(s); - *p = '.'; + DEBUG(0,("check_mangled_cache: out of memory!\n")); + return ret; } - } - - strupper(s); + res = unmangle(u2); + if (res) + { + + ucs2_to_dos (s, res, PSTRING_LEN); + /* We MUST change this brainded interface, + we do not know how many chars will be used + in dos so i guess they will be no more than + double the size of the unicode string + ---simo */ + DEBUG(10,("check_mangled_cache: returning -> [%s]\n", s)); + ret = True; + } + SAFE_FREE(res); + SAFE_FREE(u2); + DEBUG(10,("check_mangled_cache: returning -> %s\n", ret?"True":"False")); + return ret; +} + +void mangle_name_83(char *s) +{ + smb_ucs2_t *u2, *res; - DEBUG(5,("Mangling name %s to ",s)); + DEBUG(10,("mangle_name_83: I'm so ugly, please remove me!\n")); + DEBUG(10,("mangle_name_83: testing -> [%s]\n", s)); - if (p) - { - if (p == s) - strcpy(extension,"___"); - else + if (!s || !*s) return; + + u2 = acnv_dosu2(s); + if (!u2) { - *p++ = 0; - while (*p && extlen < 3) - { - if (isdoschar(*p) && *p != '.') - extension[extlen++] = *p; - p++; - } - extension[extlen] = 0; + DEBUG(0,("mangle_name_83: out of memory!\n")); + return; } - } - - p = s; - while (*p && baselen < 5) - { - if (isdoschar(*p) && *p != '.') - base[baselen++] = *p; - p++; - } - base[baselen] = 0; + res = mangle(u2); + if (res) ucs2_to_dos (s, res, 13); /* ugly, but must be done this way */ + DEBUG(10,("mangle_name_83: returning -> [%s]\n", s)); + SAFE_FREE(res); + SAFE_FREE(u2); +} - csum = csum % (36*36); +BOOL name_map_mangle(char *OutName, BOOL need83, BOOL cache83, int snum) +{ + DEBUG(10,("name_map_mangle: I'm so ugly, please remove me!\n")); - sprintf(s,"%s%c%c%c",base,magic_char,base36(csum/36),base36(csum%36)); + if (!need83) return True; + /* if (is_8_3(OutName, True)) return True; */ + /* Warning: we should check for invalid chars in file name and mangle + if invalid chars found --simo*/ - if (*extension) - { - strcat(s,"."); - strcat(s,extension); - } - DEBUG(5,("%s\n",s)); + mangle_name_83(OutName); + return True; } -/******************************************************************* - work out if a name is illegal, even for long names - ******************************************************************/ -static BOOL illegal_name(char *name) +#if 0 /* TEST_MANGLE_CODE */ + +#define LONG "this_is_a_long_file_name" +#define LONGM "this_~01" +#define SHORT "short" +#define SHORTM "short~01" +#define EXT1 "ex1" +#define EXT2 "e2" +#define EXT3 "3" +#define EXTFAIL "longext" +#define EXTNULL "" + +static void unmangle_test (char *name, char *ext) { - static unsigned char illegal[256]; - static BOOL initialised=False; - unsigned char *s; - - if (!initialised) { - char *ill = "*\\/?<>|\":{}"; - initialised = True; - - bzero((char *)illegal,256); - for (s = (unsigned char *)ill; *s; s++) - illegal[*s] = True; - } - -#ifdef KANJI - for (s = (unsigned char *)name; *s;) { - if (is_shift_jis (*s)) { - s += 2; - } else if (illegal[*s]) { - return(True); - } else { - s++; - } - } -#else - for (s = (unsigned char *)name;*s;s++) - if (illegal[*s]) return(True); -#endif - - - return(False); + smb_ucs2_t ucs2_name[2048]; + smb_ucs2_t *retstr; + pstring unix_name; + + push_ucs2(NULL, ucs2_name, name, sizeof(ucs2_name), STR_TERMINATE); + if (ext) + { + strncat_wa(ucs2_name, ".", 1); + strncat_wa(ucs2_name, ext, strlen(ext) + 1); + } + retstr = unmangle(ucs2_name); + if(retstr) pull_ucs2(NULL, unix_name, retstr, sizeof(unix_name), 0, STR_TERMINATE); + else unix_name[0] = 0; + if (ext) printf ("[%s.%s] ---> [%s]\n", name, ext, unix_name); + else printf ("[%s] ---> [%s]\n", name, unix_name); + SAFE_FREE(retstr); } +static void mangle_test (char *name, char *ext) +{ + smb_ucs2_t ucs2_name[2048]; + smb_ucs2_t *retstr; + pstring unix_name; + + push_ucs2(NULL, ucs2_name, name, sizeof(ucs2_name), STR_TERMINATE); + if (ext) + { + strncat_wa(ucs2_name, ".", 1); + strncat_wa(ucs2_name, ext, strlen(ext) + 1); + } + retstr = mangle(ucs2_name); + if(retstr) pull_ucs2(NULL, unix_name, retstr, sizeof(unix_name), 0, STR_TERMINATE); + else unix_name[0] = 0; + if (ext) printf ("[%s.%s] ---> [%s]\n", name, ext, unix_name); + else printf ("[%s] ---> [%s]\n", name, unix_name); + SAFE_FREE(retstr); +} -/**************************************************************************** -convert a filename to DOS format. return True if successful. -****************************************************************************/ -BOOL name_map_mangle(char *OutName,BOOL need83,int snum) +void mangle_test_code(void) { -#ifdef MANGLE_LONG_FILENAMES - if (!need83 && illegal_name(OutName)) need83 = True; -#endif - - /* apply any name mappings */ - { - char *map = lp_mangled_map(snum); - if (map && *map) - do_fwd_mangled_map(OutName,map); - } - - /* check if it's already in 8.3 format */ - if (need83 && !is_8_3(OutName)) { - if (!lp_manglednames(snum)) return(False); - - /* mangle it into 8.3 */ - push_mangled_name(OutName); - mangle_name_83(OutName); - } - - return(True); + init_mangle_tdb(); + + /* unmangle every */ + printf("Unmangle test 1:\n"); + + unmangle_test (LONG, NULL); + unmangle_test (LONG, EXT1); + unmangle_test (LONG, EXT2); + unmangle_test (LONG, EXT3); + unmangle_test (LONG, EXTFAIL); + unmangle_test (LONG, EXTNULL); + + unmangle_test (LONGM, NULL); + unmangle_test (LONGM, EXT1); + unmangle_test (LONGM, EXT2); + unmangle_test (LONGM, EXT3); + unmangle_test (LONGM, EXTFAIL); + unmangle_test (LONGM, EXTNULL); + + unmangle_test (SHORT, NULL); + unmangle_test (SHORT, EXT1); + unmangle_test (SHORT, EXT2); + unmangle_test (SHORT, EXT3); + unmangle_test (SHORT, EXTFAIL); + unmangle_test (SHORT, EXTNULL); + + unmangle_test (SHORTM, NULL); + unmangle_test (SHORTM, EXT1); + unmangle_test (SHORTM, EXT2); + unmangle_test (SHORTM, EXT3); + unmangle_test (SHORTM, EXTFAIL); + unmangle_test (SHORTM, EXTNULL); + + /* mangle every */ + printf("Mangle test\n"); + + mangle_test (LONG, NULL); + mangle_test (LONG, EXT1); + mangle_test (LONG, EXT2); + mangle_test (LONG, EXT3); + mangle_test (LONG, EXTFAIL); + mangle_test (LONG, EXTNULL); + + mangle_test (LONGM, NULL); + mangle_test (LONGM, EXT1); + mangle_test (LONGM, EXT2); + mangle_test (LONGM, EXT3); + mangle_test (LONGM, EXTFAIL); + mangle_test (LONGM, EXTNULL); + + mangle_test (SHORT, NULL); + mangle_test (SHORT, EXT1); + mangle_test (SHORT, EXT2); + mangle_test (SHORT, EXT3); + mangle_test (SHORT, EXTFAIL); + mangle_test (SHORT, EXTNULL); + + mangle_test (SHORTM, NULL); + mangle_test (SHORTM, EXT1); + mangle_test (SHORTM, EXT2); + mangle_test (SHORTM, EXT3); + mangle_test (SHORTM, EXTFAIL); + mangle_test (SHORTM, EXTNULL); + + /* unmangle again every */ + printf("Unmangle test 2:\n"); + + unmangle_test (LONG, NULL); + unmangle_test (LONG, EXT1); + unmangle_test (LONG, EXT2); + unmangle_test (LONG, EXT3); + unmangle_test (LONG, EXTFAIL); + unmangle_test (LONG, EXTNULL); + + unmangle_test (LONGM, NULL); + unmangle_test (LONGM, EXT1); + unmangle_test (LONGM, EXT2); + unmangle_test (LONGM, EXT3); + unmangle_test (LONGM, EXTFAIL); + unmangle_test (LONGM, EXTNULL); + + unmangle_test (SHORT, NULL); + unmangle_test (SHORT, EXT1); + unmangle_test (SHORT, EXT2); + unmangle_test (SHORT, EXT3); + unmangle_test (SHORT, EXTFAIL); + unmangle_test (SHORT, EXTNULL); + + unmangle_test (SHORTM, NULL); + unmangle_test (SHORTM, EXT1); + unmangle_test (SHORTM, EXT2); + unmangle_test (SHORTM, EXT3); + unmangle_test (SHORTM, EXTFAIL); + unmangle_test (SHORTM, EXTNULL); } +#endif /* TEST_MANGLE_CODE */ |