| blob | f0a4e3420713f0925ea286fe15d78df051941906 |
1 /*
2 Unix SMB/CIFS implementation.
3 new hash based name mangling implementation
4 Copyright (C) Andrew Tridgell 2002
5 Copyright (C) Simo Sorce 2002
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
21 /*
22 this mangling scheme uses the following format
24 Annnn~n.AAA
26 where nnnnn is a base 36 hash, and A represents characters from the original string
28 The hash is taken of the leading part of the long filename, in uppercase
30 for simplicity, we only allow ascii characters in 8.3 names
31 */
33 /* hash alghorithm changed to FNV1 by idra@samba.org (Simo Sorce).
34 * see http://www.isthe.com/chongo/tech/comp/fnv/index.html for a
35 * discussion on Fowler / Noll / Vo (FNV) Hash by one of it's authors
36 */
38 /*
39 ===============================================================================
40 NOTE NOTE NOTE!!!
42 This file deliberately uses non-multibyte string functions in many places. This
43 is *not* a mistake. This code is multi-byte safe, but it gets this property
44 through some very subtle knowledge of the way multi-byte strings are encoded
45 and the fact that this mangling algorithm only supports ascii characters in
46 8.3 names.
48 please don't convert this file to use the *_m() functions!!
49 ===============================================================================
50 */
52 /*
53 * ============================================================================
54 * Whenever you change anything in the FLAG_ or other fields,
55 * re-initialize the tables char_flags and base_reverse by running the
56 * init_tables() routine once and dump its results. To do this, a
57 * single smbd run with
58 *
59 * #define DYNAMIC_MANGLE_TABLES 1
60 *
61 * and debug level 10 should be sufficient.
62 * ============================================================================
63 */
71 #if 1
72 #define M_DEBUG(level, x) DEBUG(level, x)
73 #else
74 #define M_DEBUG(level, x)
75 #endif
77 /* these flags are used to mark characters in as having particular
78 properties */
79 #define FLAG_BASECHAR 1
80 #define FLAG_ASCII 2
81 #define FLAG_ILLEGAL 4
82 #define FLAG_WILDCARD 8
84 /* the "possible" flags are used as a fast way to find possible DOS
85 reserved filenames */
86 #define FLAG_POSSIBLE1 16
87 #define FLAG_POSSIBLE2 32
88 #define FLAG_POSSIBLE3 64
89 #define FLAG_POSSIBLE4 128
91 /* by default have a max of 4096 entries in the cache. */
92 #ifndef MANGLE_CACHE_SIZE
93 #define MANGLE_CACHE_SIZE 4096
94 #endif
96 #define FNV1_PRIME 0x01000193
97 /*the following number is a fnv1 of the string: idra@samba.org 2002 */
98 #define FNV1_INIT 0xa6b93095
100 #define FLAG_CHECK(c, flag) (char_flags[(unsigned char)(c)] & (flag))
102 /* these are the characters we use in the 8.3 hash. Must be 36 chars long */
104 #define base_forward(v) basechars[v]
106 /* the list of reserved dos names - all of these are illegal */
111 #define DYNAMIC_MANGLE_TABLES 0
113 #if DYNAMIC_MANGLE_TABLES
115 /* these tables are used to provide fast tests for characters */
119 /* initialise the flags table
121 we allow only a very restricted set of characters as 'ascii' in this
122 mangling backend. This isn't a significant problem as modern clients
123 use the 'long' filenames anyway, and those don't have these
124 restrictions.
125 */
127 {
134 /* Control characters. */
136 }
142 }
145 }
149 }
153 }
154 }
159 }
161 /* fill in the reserved names flags. These are used as a very
162 fast filter for finding possible DOS reserved filenames */
181 }
183 #if 0
189 #endif
190 }
192 #else
194 /*
195 * These tables were initialized by a single run of the above
196 * init_tables() routine, dumping the tables and a simple emacs macro.
197 *
198 * Technically we could leave out the 0's at the end of the array
199 * initializers, but I'll leave it in: less surprise.
200 */
235 };
270 };
272 #endif
274 /*
275 hash a string of the specified length. The string does not need to be
276 null terminated
278 this hash needs to be fast with a low collision rate (what hash doesn't?)
279 */
281 {
284 fstring str;
286 /* we have to uppercase here to ensure that the mangled name
287 doesn't depend on the case of the long name. Note that this
288 is the only place where we need to use a multi-byte string
289 function */
295 /* the length of a multi-byte string can change after a strupper_m */
298 /* Set the initial value from the key size. */
302 }
304 /* note that we force it to a 31 bit hash, to keep within the limits
305 of the 36^6 mangle space */
307 }
309 /*
310 insert an entry into the prefix cache. The string might not be null
311 terminated */
313 {
318 }
324 }
326 /*
327 lookup an entry in the prefix cache. Return NULL if not found.
328 */
330 {
331 DATA_BLOB value;
336 }
342 }
345 /*
346 determine if a string is possibly in a mangled format, ignoring
347 case
349 In this algorithm, mangled names use only pure ascii characters (no
350 multi-byte) so we can avoid doing a UCS2 conversion
351 */
353 {
358 /* check the length */
362 /* the best distinguishing characteristic is the ~ */
366 /* check extension */
373 }
374 }
375 }
377 /* check lead characters */
381 }
382 }
384 /* check rest of hash */
387 }
391 }
392 }
397 }
401 /*
402 determine if a string is possibly in a mangled format, ignoring
403 case
405 In this algorithm, mangled names use only pure ascii characters (no
406 multi-byte) so we can avoid doing a UCS2 conversion
408 NOTE! This interface must be able to handle a path with unix
409 directory separators. It should return true if any component is
410 mangled
411 */
413 {
422 }
423 }
425 /* and the last part ... */
427 }
430 /*
431 see if a filename is an allowable 8.3 name to return to the client.
432 Note this is not testing if this is a valid Samba mangled name, so
433 the rules are different for is_mangled.
435 we are only going to allow ascii characters in 8.3 names, as this
436 simplifies things greatly (it means that we know the string won't
437 get larger when converted from UNIX to DOS formats)
438 */
442 static bool is_8_3(const char *name, bool check_case, bool allow_wildcards, const struct share_params *p)
443 {
447 /* as a special case, the names '.' and '..' are allowable 8.3 names */
451 }
452 }
454 /* the simplest test is on the overall length of the
455 filename. Note that we deliberately use the ascii string
456 length (not the multi-byte one) as it is faster, and gives us
457 the result we need in this case. Using strlen_m would not
458 only be slower, it would be incorrect */
463 /* find the '.'. Note that once again we use the non-multibyte
464 function */
468 /* if the name doesn't contain a '.' then its length
469 must be less than 8 */
472 }
476 /* if it does contain a dot then the prefix must be <=
477 8 and the suffix <= 3 in length */
483 }
485 /* a 8.3 name cannot contain more than 1 '.' */
488 }
489 }
491 /* the length are all OK. Now check to see if the characters themselves are OK */
495 }
496 /* note that we may allow wildcard petterns! */
499 }
502 }
505 }
506 }
508 /* it is a good 8.3 name */
510 }
513 /*
514 reset the mangling cache on a smb.conf reload. This only really makes sense for
515 mangling backends that have parameters in smb.conf, and as this backend doesn't
516 this is a NULL operation
517 */
519 {
520 /* noop */
521 }
524 /*
525 try to find a 8.3 name in the cache, and if found then
526 replace the string with the original long name.
527 */
532 {
540 /* make sure that this is a mangled name from this cache */
544 }
546 /* we need to extract the hash from the 8.3 name */
552 }
554 /* now look in the prefix cache for that hash */
560 }
562 /* we found it - construct the full name */
568 }
577 }
584 }
587 }
589 /*
590 look for a DOS reserved name
591 */
593 {
598 /* a likely match, scan the lot */
602 /* note that we match on COM1 as well as COM1.foo */
606 }
607 }
608 }
611 }
613 /*
614 See if a filename is a legal long filename.
615 A filename ending in a '.' is not legal unless it's "." or "..". JRA.
616 A filename ending in ' ' is not legal either. See bug id #2769.
617 */
620 {
627 /* Possible start of mb character. */
629 /*
630 * Note that if CH_UNIX is utf8 a string may be 3
631 * bytes, but this is ok as mb utf8 characters don't
632 * contain embedded ascii bytes. We are really checking
633 * for mb UNIX asian characters like Japanese (SJIS) here.
634 * JRA.
635 */
637 /* Was a good mb string. */
640 }
641 }
645 }
648 numdots++;
651 }
653 /* Can't end in ' ' */
655 }
656 name++;
657 }
663 /* A valid long name cannot end in '.' */
666 }
668 }
672 {
675 }
677 }
679 /*
680 the main forward mapping function, which converts a long filename to
681 a 8.3 name
683 if cache83 is not set then we don't cache the result
685 */
691 {
699 /* reserved names are handled specially */
701 /* if the name is already a valid 8.3 name then we don't need to
702 * change anything */
706 }
707 }
709 /* find the '.' if any */
713 /* if the extension contains any illegal characters or
714 is too long or zero length then we treat it as part
715 of the prefix */
720 }
721 }
724 }
725 }
727 /* the leading characters in the mangled name is taken from
728 the first characters of the name, if they are ascii otherwise
729 '_' is used
730 */
735 }
737 }
740 }
742 /* the prefix is anything up to the first dot */
747 }
749 /* the extension of the mangled name is taken from the first 3
750 ascii chars after the dot */
758 }
759 }
760 }
762 /* find the hash for this prefix */
765 /* now form the mangled name. */
768 }
774 }
776 /* add the extension */
783 }
786 /* put it in the cache */
788 }
794 }
796 /*
797 the following provides the abstraction layer to make it easier
798 to drop in an alternative mangling implementation */
800 mangle_reset,
801 is_mangled,
802 must_mangle,
803 is_8_3,
804 lookup_name_from_8_3,
805 hash2_name_to_8_3
806 };
808 /* return the methods for this mangling implementation */
810 {
811 /* the mangle prefix can only be in the mange 1 to 6 */
815 }
818 }
820 #if DYNAMIC_MANGLE_TABLES
822 #endif
826 }
829 {;}
832 {
834 }
837 {
839 }
845 {
847 }
853 {
855 }
862 {
865 }
867 /* POSIX paths backend - no mangle. */
869 posix_mangle_reset,
870 posix_is_mangled,
871 posix_must_mangle,
872 posix_is_8_3,
873 posix_lookup_name_from_8_3,
874 posix_name_to_8_3
875 };
878 {
880 }