2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1992-2002
5 Copyright (C) Simo Sorce 2001
6 Copyright (C) Andrew Bartlett 2002
7 Copyright (C) Jeremy Allison 2007
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "system/filesys.h"
25 #include "smbd/smbd.h"
26 #include "smbd/globals.h"
29 /* -------------------------------------------------------------------------- **
32 * magic_char - This is the magic char used for mangling. It's
33 * global. There is a call to lp_magicchar() in server.c
34 * that is used to override the initial value.
36 * MANGLE_BASE - This is the number of characters we use for name mangling.
38 * basechars - The set characters used for name mangling. This
39 * is static (scope is this file only).
41 * mangle() - Macro used to select a character from basechars (i.e.,
42 * mangle(n) will return the nth digit, modulo MANGLE_BASE).
44 * chartest - array 0..255. The index range is the set of all possible
45 * values of a byte. For each byte value, the content is a
46 * two nibble pair. See BASECHAR_MASK below.
48 * ct_initialized - False until the chartest array has been initialized via
49 * a call to init_chartest().
51 * BASECHAR_MASK - Masks the upper nibble of a one-byte value.
53 * isbasecahr() - Given a character, check the chartest array to see
54 * if that character is in the basechars set. This is
55 * faster than using strchr_m().
59 static const char basechars
[43]="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_-!@#$%";
60 #define MANGLE_BASE (sizeof(basechars)/sizeof(char)-1)
62 #define mangle(V) ((char)(basechars[(V) % MANGLE_BASE]))
63 #define BASECHAR_MASK 0xf0
64 #define isbasechar(C) ( (chartest[ ((C) & 0xff) ]) & BASECHAR_MASK )
66 /* -------------------------------------------------------------------- */
68 static NTSTATUS
has_valid_83_chars(const smb_ucs2_t
*s
, bool allow_wildcards
)
71 return NT_STATUS_INVALID_PARAMETER
;
74 if (!allow_wildcards
&& ms_has_wild_w(s
)) {
75 return NT_STATUS_UNSUCCESSFUL
;
79 if(!isvalid83_w(*s
)) {
80 return NT_STATUS_UNSUCCESSFUL
;
88 static NTSTATUS
has_illegal_chars(const smb_ucs2_t
*s
, bool allow_wildcards
)
90 if (!allow_wildcards
&& ms_has_wild_w(s
)) {
91 return NT_STATUS_UNSUCCESSFUL
;
96 /* Control characters. */
97 return NT_STATUS_UNSUCCESSFUL
;
100 case UCS2_CHAR('\\'):
104 return NT_STATUS_UNSUCCESSFUL
;
112 /* return False if something fail and
113 * return 2 alloced unicode strings that contain prefix and extension
116 static NTSTATUS
mangle_get_prefix(const smb_ucs2_t
*ucs2_string
, smb_ucs2_t
**prefix
,
117 smb_ucs2_t
**extension
, bool allow_wildcards
)
123 *prefix
= strdup_w(ucs2_string
);
125 return NT_STATUS_NO_MEMORY
;
127 if ((p
= strrchr_w(*prefix
, UCS2_CHAR('.')))) {
128 ext_len
= strlen_w(p
+1);
129 if ((ext_len
> 0) && (ext_len
< 4) && (p
!= *prefix
) &&
130 (NT_STATUS_IS_OK(has_valid_83_chars(p
+1,allow_wildcards
)))) /* check extension */ {
132 *extension
= strdup_w(p
+1);
135 return NT_STATUS_NO_MEMORY
;
142 /* ************************************************************************** **
143 * Return NT_STATUS_UNSUCCESSFUL if a name is a special msdos reserved name.
144 * or contains illegal characters.
146 * Input: fname - String containing the name to be tested.
148 * Output: NT_STATUS_UNSUCCESSFUL, if the condition above is true.
150 * Notes: This is a static function called by is_8_3(), below.
152 * ************************************************************************** **
155 static NTSTATUS
is_valid_name(const smb_ucs2_t
*fname
, bool allow_wildcards
, bool only_8_3
)
158 size_t num_ucs2_chars
;
159 NTSTATUS ret
= NT_STATUS_OK
;
161 if (!fname
|| !*fname
)
162 return NT_STATUS_INVALID_PARAMETER
;
164 /* . and .. are valid names. */
165 if (strcmp_wa(fname
, ".")==0 || strcmp_wa(fname
, "..")==0)
169 ret
= has_valid_83_chars(fname
, allow_wildcards
);
170 if (!NT_STATUS_IS_OK(ret
))
174 ret
= has_illegal_chars(fname
, allow_wildcards
);
175 if (!NT_STATUS_IS_OK(ret
))
178 /* Name can't end in '.' or ' ' */
179 num_ucs2_chars
= strlen_w(fname
);
180 if (fname
[num_ucs2_chars
-1] == UCS2_CHAR('.') || fname
[num_ucs2_chars
-1] == UCS2_CHAR(' ')) {
181 return NT_STATUS_UNSUCCESSFUL
;
184 str
= strdup_w(fname
);
186 /* Truncate copy after the first dot. */
187 p
= strchr_w(str
, UCS2_CHAR('.'));
198 if(strcmp_wa(p
, "UX") == 0)
199 ret
= NT_STATUS_UNSUCCESSFUL
;
202 if((strcmp_wa(p
, "LOCK$") == 0)
203 || (strcmp_wa(p
, "ON") == 0)
204 || (strcmp_wa(p
, "OM1") == 0)
205 || (strcmp_wa(p
, "OM2") == 0)
206 || (strcmp_wa(p
, "OM3") == 0)
207 || (strcmp_wa(p
, "OM4") == 0)
209 ret
= NT_STATUS_UNSUCCESSFUL
;
212 if((strcmp_wa(p
, "PT1") == 0)
213 || (strcmp_wa(p
, "PT2") == 0)
214 || (strcmp_wa(p
, "PT3") == 0)
216 ret
= NT_STATUS_UNSUCCESSFUL
;
219 if(strcmp_wa(p
, "UL") == 0)
220 ret
= NT_STATUS_UNSUCCESSFUL
;
223 if(strcmp_wa(p
, "RN") == 0)
224 ret
= NT_STATUS_UNSUCCESSFUL
;
234 static NTSTATUS
is_8_3_w(const smb_ucs2_t
*fname
, bool allow_wildcards
)
236 smb_ucs2_t
*pref
= 0, *ext
= 0;
238 NTSTATUS ret
= NT_STATUS_UNSUCCESSFUL
;
240 if (!fname
|| !*fname
)
241 return NT_STATUS_INVALID_PARAMETER
;
243 if (strlen_w(fname
) > 12)
244 return NT_STATUS_UNSUCCESSFUL
;
246 if (strcmp_wa(fname
, ".") == 0 || strcmp_wa(fname
, "..") == 0)
249 /* Name cannot start with '.' */
250 if (*fname
== UCS2_CHAR('.'))
251 return NT_STATUS_UNSUCCESSFUL
;
253 if (!NT_STATUS_IS_OK(is_valid_name(fname
, allow_wildcards
, True
)))
256 if (!NT_STATUS_IS_OK(mangle_get_prefix(fname
, &pref
, &ext
, allow_wildcards
)))
258 plen
= strlen_w(pref
);
260 if (strchr_wa(pref
, '.'))
262 if (plen
< 1 || plen
> 8)
264 if (ext
&& (strlen_w(ext
) > 3))
275 static bool is_8_3(const char *fname
, bool check_case
, bool allow_wildcards
,
276 const struct share_params
*p
)
279 smb_ucs2_t
*ucs2name
;
280 NTSTATUS ret
= NT_STATUS_UNSUCCESSFUL
;
284 magic_char
= lp_magicchar(p
);
286 if (!fname
|| !*fname
)
288 if ((f
= strrchr(fname
, '/')) == NULL
)
296 if (!push_ucs2_talloc(NULL
, &ucs2name
, f
, &size
)) {
297 DEBUG(0,("is_8_3: internal error push_ucs2_talloc() failed!\n"));
301 ret
= is_8_3_w(ucs2name
, allow_wildcards
);
304 TALLOC_FREE(ucs2name
);
306 if (!NT_STATUS_IS_OK(ret
)) {
313 /* -------------------------------------------------------------------------- **
317 /* ************************************************************************** **
318 * Initialize the static character test array.
324 * Notes: This function changes (loads) the contents of the <chartest>
325 * array. The scope of <chartest> is this file.
327 * ************************************************************************** **
330 static void init_chartest( void )
332 const unsigned char *s
;
334 chartest
= SMB_MALLOC_ARRAY(unsigned char, 256);
336 SMB_ASSERT(chartest
!= NULL
);
337 memset(chartest
, '\0', 256);
339 for( s
= (const unsigned char *)basechars
; *s
; s
++ ) {
340 chartest
[*s
] |= BASECHAR_MASK
;
344 /* ************************************************************************** **
345 * Return True if the name *could be* a mangled name.
347 * Input: s - A path name - in UNIX pathname format.
349 * Output: True if the name matches the pattern described below in the
352 * Notes: The input name is *not* tested for 8.3 compliance. This must be
353 * done separately. This function returns true if the name contains
354 * a magic character followed by excactly two characters from the
355 * basechars list (above), which in turn are followed either by the
356 * nul (end of string) byte or a dot (extension) or by a '/' (end of
359 * ************************************************************************** **
362 static bool is_mangled(const char *s
, const struct share_params
*p
)
367 magic_char
= lp_magicchar(p
);
369 if (chartest
== NULL
) {
373 magic
= strchr_m( s
, magic_char
);
374 while( magic
&& magic
[1] && magic
[2] ) { /* 3 chars, 1st is magic. */
375 if( ('.' == magic
[3] || '/' == magic
[3] || !(magic
[3])) /* Ends with '.' or nul or '/' ? */
376 && isbasechar( toupper_ascii(magic
[1]) ) /* is 2nd char basechar? */
377 && isbasechar( toupper_ascii(magic
[2]) ) ) /* is 3rd char basechar? */
378 return( True
); /* If all above, then true, */
379 magic
= strchr_m( magic
+1, magic_char
); /* else seek next magic. */
384 /***************************************************************************
385 Initializes or clears the mangled cache.
386 ***************************************************************************/
388 static void mangle_reset( void )
390 /* We could close and re-open the tdb here... should we ? The old code did
391 the equivalent... JRA. */
394 /***************************************************************************
395 Add a mangled name into the cache.
396 If the extension of the raw name maps directly to the
397 extension of the mangled name, then we'll store both names
398 *without* extensions. That way, we can provide consistent
399 reverse mangling for all names that match. The test here is
400 a bit more careful than the one done in earlier versions of
403 - the extension must exist on the raw name,
404 - it must be all lower case
405 - it must match the mangled extension (to prove that no
408 **************************************************************************/
410 static void cache_mangled_name( const char mangled_name
[13],
411 const char *raw_name
)
414 char mangled_name_key
[13];
418 /* If the cache isn't initialized, give up. */
419 if( !tdb_mangled_cache
)
422 /* Init the string lengths. */
423 safe_strcpy(mangled_name_key
, mangled_name
, sizeof(mangled_name_key
)-1);
425 /* See if the extensions are unmangled. If so, store the entry
426 * without the extension, thus creating a "group" reverse map.
428 s1
= strrchr( mangled_name_key
, '.' );
429 if( s1
&& (s2
= strrchr( raw_name
, '.' )) ) {
431 while( s1
[i
] && (tolower_ascii( s1
[i
] ) == s2
[i
]) )
433 if( !s1
[i
] && !s2
[i
] ) {
434 /* Truncate at the '.' */
437 * DANGER WILL ROBINSON - this
438 * is changing a const string via
439 * an aliased pointer ! Remember to
440 * put it back once we've used it.
447 /* Allocate a new cache entry. If the allocation fails, just return. */
448 data_val
= string_term_tdb_data(raw_name
);
449 if (tdb_store_bystring(tdb_mangled_cache
, mangled_name_key
, data_val
, TDB_REPLACE
) != 0) {
450 DEBUG(0,("cache_mangled_name: Error storing entry %s -> %s\n", mangled_name_key
, raw_name
));
452 DEBUG(5,("cache_mangled_name: Stored entry %s -> %s\n", mangled_name_key
, raw_name
));
454 /* Restore the change we made to the const string. */
460 /* ************************************************************************** **
461 * Check for a name on the mangled name stack
463 * Input: s - Input *and* output string buffer.
464 * maxlen - space in i/o string buffer.
465 * Output: True if the name was found in the cache, else False.
467 * Notes: If a reverse map is found, the function will overwrite the string
468 * space indicated by the input pointer <s>. This is frightening.
469 * It should be rewritten to return NULL if the long name was not
470 * found, and a pointer to the long name if it was found.
472 * ************************************************************************** **
475 static bool lookup_name_from_8_3(TALLOC_CTX
*ctx
,
477 char **out
, /* talloced on the given context. */
478 const struct share_params
*p
)
481 char *saved_ext
= NULL
;
482 char *s
= talloc_strdup(ctx
, in
);
485 magic_char
= lp_magicchar(p
);
487 /* If the cache isn't initialized, give up. */
488 if(!s
|| !tdb_mangled_cache
) {
493 data_val
= tdb_fetch_bystring(tdb_mangled_cache
, s
);
495 /* If we didn't find the name *with* the extension, try without. */
496 if(data_val
.dptr
== NULL
|| data_val
.dsize
== 0) {
497 char *ext_start
= strrchr( s
, '.' );
499 if((saved_ext
= talloc_strdup(ctx
,ext_start
)) == NULL
) {
505 data_val
= tdb_fetch_bystring(tdb_mangled_cache
, s
);
507 * At this point s is the name without the
508 * extension. We re-add the extension if saved_ext
509 * is not null, before freeing saved_ext.
514 /* Okay, if we haven't found it we're done. */
515 if(data_val
.dptr
== NULL
|| data_val
.dsize
== 0) {
516 TALLOC_FREE(saved_ext
);
521 /* If we *did* find it, we need to talloc it on the given ctx. */
523 *out
= talloc_asprintf(ctx
, "%s%s",
524 (char *)data_val
.dptr
,
527 *out
= talloc_strdup(ctx
, (char *)data_val
.dptr
);
531 TALLOC_FREE(saved_ext
);
532 SAFE_FREE(data_val
.dptr
);
534 return *out
? True
: False
;
537 /*****************************************************************************
538 Do the actual mangling to 8.3 format.
539 *****************************************************************************/
541 static bool to_8_3(char magic_char
, const char *in
, char out
[13], int default_case
)
549 char *s
= SMB_STRDUP(in
);
559 if( p
&& (strlen(p
+1) < (size_t)4) ) {
560 bool all_normal
= ( strisnormal(p
+1, default_case
) ); /* XXXXXXXXX */
562 if( all_normal
&& p
[1] != 0 ) {
564 csum
= str_checksum( s
);
567 csum
= str_checksum(s
);
569 csum
= str_checksum(s
);
575 safe_strcpy( extension
, "___", 3 );
578 while( *p
&& extlen
< 3 ) {
580 extension
[extlen
++] = p
[0];
584 extension
[extlen
] = 0;
590 while( *p
&& baselen
< 5 ) {
591 if (isbasechar(*p
)) {
592 base
[baselen
++] = p
[0];
598 csum
= csum
% (MANGLE_BASE
*MANGLE_BASE
);
600 memcpy(out
, base
, baselen
);
601 out
[baselen
] = magic_char
;
602 out
[baselen
+1] = mangle( csum
/MANGLE_BASE
);
603 out
[baselen
+2] = mangle( csum
);
606 out
[baselen
+3] = '.';
607 safe_strcpy(&out
[baselen
+4], extension
, 3);
614 static bool must_mangle(const char *name
,
615 const struct share_params
*p
)
617 smb_ucs2_t
*name_ucs2
= NULL
;
619 size_t converted_size
;
622 magic_char
= lp_magicchar(p
);
624 if (!push_ucs2_talloc(NULL
, &name_ucs2
, name
, &converted_size
)) {
625 DEBUG(0, ("push_ucs2_talloc failed!\n"));
628 status
= is_valid_name(name_ucs2
, False
, False
);
629 TALLOC_FREE(name_ucs2
);
630 /* We return true if we *must* mangle, so if it's
631 * a valid name (status == OK) then we must return
632 * false. Bug #6939. */
633 return !NT_STATUS_IS_OK(status
);
636 /*****************************************************************************
637 * Convert a filename to DOS format. Return True if successful.
638 * Input: in Incoming name.
642 * cache83 - If False, the mangled name cache will not be updated.
643 * This is usually used to prevent that we overwrite
644 * a conflicting cache entry prematurely, i.e. before
645 * we know whether the client is really interested in the
646 * current name. (See PR#13758). UKD.
648 * ****************************************************************************
651 static bool hash_name_to_8_3(const char *in
,
655 const struct share_params
*p
)
657 smb_ucs2_t
*in_ucs2
= NULL
;
658 size_t converted_size
;
661 magic_char
= lp_magicchar(p
);
663 DEBUG(5,("hash_name_to_8_3( %s, cache83 = %s)\n", in
,
664 cache83
? "True" : "False"));
666 if (!push_ucs2_talloc(NULL
, &in_ucs2
, in
, &converted_size
)) {
667 DEBUG(0, ("push_ucs2_talloc failed!\n"));
671 /* If it's already 8.3, just copy. */
672 if (NT_STATUS_IS_OK(is_valid_name(in_ucs2
, False
, False
)) &&
673 NT_STATUS_IS_OK(is_8_3_w(in_ucs2
, False
))) {
674 TALLOC_FREE(in_ucs2
);
675 safe_strcpy(out
, in
, 12);
679 TALLOC_FREE(in_ucs2
);
680 if (!to_8_3(magic_char
, in
, out
, default_case
)) {
684 cache_mangled_name(out
, in
);
686 DEBUG(5,("hash_name_to_8_3(%s) ==> [%s]\n", in
, out
));
691 the following provides the abstraction layer to make it easier
692 to drop in an alternative mangling implementation
694 static const struct mangle_fns mangle_hash_fns
= {
699 lookup_name_from_8_3
,
703 /* return the methods for this mangling implementation */
704 const struct mangle_fns
*mangle_hash_init(void)
708 /* Create the in-memory tdb using our custom hash function. */
709 tdb_mangled_cache
= tdb_open_ex("mangled_cache", 1031, TDB_INTERNAL
,
710 (O_RDWR
|O_CREAT
), 0644, NULL
, fast_string_hash
);
712 return &mangle_hash_fns
;