| blob | 655c72745a47c13e8f15817cd88daf790f790b8d |
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 */
72 #if 1
73 #define M_DEBUG(level, x) DEBUG(level, x)
74 #else
75 #define M_DEBUG(level, x)
76 #endif
78 /* these flags are used to mark characters in as having particular
79 properties */
80 #define FLAG_BASECHAR 1
81 #define FLAG_ASCII 2
82 #define FLAG_ILLEGAL 4
83 #define FLAG_WILDCARD 8
85 /* the "possible" flags are used as a fast way to find possible DOS
86 reserved filenames */
87 #define FLAG_POSSIBLE1 16
88 #define FLAG_POSSIBLE2 32
89 #define FLAG_POSSIBLE3 64
90 #define FLAG_POSSIBLE4 128
92 /* by default have a max of 4096 entries in the cache. */
93 #ifndef MANGLE_CACHE_SIZE
94 #define MANGLE_CACHE_SIZE 4096
95 #endif
97 #define FNV1_PRIME 0x01000193
98 /*the following number is a fnv1 of the string: idra@samba.org 2002 */
99 #define FNV1_INIT 0xa6b93095
101 #define FLAG_CHECK(c, flag) (char_flags[(unsigned char)(c)] & (flag))
103 /* these are the characters we use in the 8.3 hash. Must be 36 chars long */
105 #define base_forward(v) basechars[v]
107 /* the list of reserved dos names - all of these are illegal */
112 #define DYNAMIC_MANGLE_TABLES 0
114 #if DYNAMIC_MANGLE_TABLES
116 /* these tables are used to provide fast tests for characters */
120 /* initialise the flags table
122 we allow only a very restricted set of characters as 'ascii' in this
123 mangling backend. This isn't a significant problem as modern clients
124 use the 'long' filenames anyway, and those don't have these
125 restrictions.
126 */
128 {
135 /* Control characters. */
137 }
143 }
146 }
150 }
154 }
155 }
160 }
162 /* fill in the reserved names flags. These are used as a very
163 fast filter for finding possible DOS reserved filenames */
182 }
184 #if 0
190 #endif
191 }
193 #else
195 /*
196 * These tables were initialized by a single run of the above
197 * init_tables() routine, dumping the tables and a simple emacs macro.
198 *
199 * Technically we could leave out the 0's at the end of the array
200 * initializers, but I'll leave it in: less surprise.
201 */
236 };
271 };
273 #endif
275 /*
276 hash a string of the specified length. The string does not need to be
277 null terminated
279 this hash needs to be fast with a low collision rate (what hash doesn't?)
280 */
282 {
285 fstring str;
287 /* we have to uppercase here to ensure that the mangled name
288 doesn't depend on the case of the long name. Note that this
289 is the only place where we need to use a multi-byte string
290 function */
296 /* the length of a multi-byte string can change after a strupper_m */
299 /* Set the initial value from the key size. */
303 }
305 /* note that we force it to a 31 bit hash, to keep within the limits
306 of the 36^6 mangle space */
308 }
310 /*
311 insert an entry into the prefix cache. The string might not be null
312 terminated */
314 {
319 }
325 }
327 /*
328 lookup an entry in the prefix cache. Return NULL if not found.
329 */
331 {
332 DATA_BLOB value;
337 }
343 }
346 /*
347 determine if a string is possibly in a mangled format, ignoring
348 case
350 In this algorithm, mangled names use only pure ascii characters (no
351 multi-byte) so we can avoid doing a UCS2 conversion
352 */
354 {
359 /* check the length */
363 /* the best distinguishing characteristic is the ~ */
367 /* check extension */
374 }
375 }
376 }
378 /* check lead characters */
382 }
383 }
385 /* check rest of hash */
388 }
392 }
393 }
398 }
402 /*
403 determine if a string is possibly in a mangled format, ignoring
404 case
406 In this algorithm, mangled names use only pure ascii characters (no
407 multi-byte) so we can avoid doing a UCS2 conversion
409 NOTE! This interface must be able to handle a path with unix
410 directory separators. It should return true if any component is
411 mangled
412 */
414 {
423 }
424 }
426 /* and the last part ... */
428 }
431 /*
432 see if a filename is an allowable 8.3 name to return to the client.
433 Note this is not testing if this is a valid Samba mangled name, so
434 the rules are different for is_mangled.
436 we are only going to allow ascii characters in 8.3 names, as this
437 simplifies things greatly (it means that we know the string won't
438 get larger when converted from UNIX to DOS formats)
439 */
443 static bool is_8_3(const char *name, bool check_case, bool allow_wildcards, const struct share_params *p)
444 {
448 /* as a special case, the names '.' and '..' are allowable 8.3 names */
452 }
453 }
455 /* the simplest test is on the overall length of the
456 filename. Note that we deliberately use the ascii string
457 length (not the multi-byte one) as it is faster, and gives us
458 the result we need in this case. Using strlen_m would not
459 only be slower, it would be incorrect */
464 /* find the '.'. Note that once again we use the non-multibyte
465 function */
469 /* if the name doesn't contain a '.' then its length
470 must be less than 8 */
473 }
477 /* if it does contain a dot then the prefix must be <=
478 8 and the suffix <= 3 in length */
484 }
486 /* a 8.3 name cannot contain more than 1 '.' */
489 }
490 }
492 /* the length are all OK. Now check to see if the characters themselves are OK */
496 }
497 /* note that we may allow wildcard petterns! */
500 }
503 }
506 }
507 }
509 /* it is a good 8.3 name */
511 }
514 /*
515 reset the mangling cache on a smb.conf reload. This only really makes sense for
516 mangling backends that have parameters in smb.conf, and as this backend doesn't
517 this is a NULL operation
518 */
520 {
521 /* noop */
522 }
525 /*
526 try to find a 8.3 name in the cache, and if found then
527 replace the string with the original long name.
528 */
533 {
541 /* make sure that this is a mangled name from this cache */
545 }
547 /* we need to extract the hash from the 8.3 name */
553 }
555 /* now look in the prefix cache for that hash */
561 }
563 /* we found it - construct the full name */
569 }
578 }
585 }
588 }
590 /*
591 look for a DOS reserved name
592 */
594 {
599 /* a likely match, scan the lot */
603 /* note that we match on COM1 as well as COM1.foo */
607 }
608 }
609 }
612 }
614 /*
615 See if a filename is a legal long filename.
616 A filename ending in a '.' is not legal unless it's "." or "..". JRA.
617 A filename ending in ' ' is not legal either. See bug id #2769.
618 */
621 {
628 /* Possible start of mb character. */
631 /*
632 * Note that if CH_UNIX is utf8 a string may be 3
633 * bytes, but this is ok as mb utf8 characters don't
634 * contain embedded ascii bytes. We are really checking
635 * for mb UNIX asian characters like Japanese (SJIS) here.
636 * JRA.
637 */
640 /* Was a good mb string. */
643 }
644 }
645 }
649 }
652 numdots++;
655 }
657 /* Can't end in ' ' */
659 }
660 name++;
661 }
667 /* A valid long name cannot end in '.' */
670 }
672 }
676 {
679 }
681 }
683 /*
684 the main forward mapping function, which converts a long filename to
685 a 8.3 name
687 if cache83 is not set then we don't cache the result
689 */
695 {
703 /* reserved names are handled specially */
705 /* if the name is already a valid 8.3 name then we don't need to
706 * change anything */
710 }
711 }
713 /* find the '.' if any */
717 /* if the extension contains any illegal characters or
718 is too long or zero length then we treat it as part
719 of the prefix */
724 }
725 }
728 }
729 }
731 /* the leading characters in the mangled name is taken from
732 the first characters of the name, if they are ascii otherwise
733 '_' is used
734 */
739 }
741 }
744 }
746 /* the prefix is anything up to the first dot */
751 }
753 /* the extension of the mangled name is taken from the first 3
754 ascii chars after the dot */
762 }
763 }
764 }
766 /* find the hash for this prefix */
769 /* now form the mangled name. */
772 }
778 }
780 /* add the extension */
787 }
790 /* put it in the cache */
792 }
798 }
800 /*
801 the following provides the abstraction layer to make it easier
802 to drop in an alternative mangling implementation */
804 mangle_reset,
805 is_mangled,
806 must_mangle,
807 is_8_3,
808 lookup_name_from_8_3,
809 hash2_name_to_8_3
810 };
812 /* return the methods for this mangling implementation */
814 {
815 /* the mangle prefix can only be in the mange 1 to 6 */
819 }
822 }
824 #if DYNAMIC_MANGLE_TABLES
826 #endif
830 }
833 {;}
836 {
838 }
841 {
843 }
849 {
851 }
857 {
859 }
866 {
869 }
871 /* POSIX paths backend - no mangle. */
873 posix_mangle_reset,
874 posix_is_mangled,
875 posix_must_mangle,
876 posix_is_8_3,
877 posix_lookup_name_from_8_3,
878 posix_name_to_8_3
879 };
882 {
884 }