Make us pass SHORTNAME-TEST.
[ira/wip.git] / source3 / smbd / mangle_hash2.c
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
6    
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.
11    
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.
16    
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 */
20
21 /*
22   this mangling scheme uses the following format
23
24   Annnn~n.AAA
25
26   where nnnnn is a base 36 hash, and A represents characters from the original string
27
28   The hash is taken of the leading part of the long filename, in uppercase
29
30   for simplicity, we only allow ascii characters in 8.3 names
31  */
32
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   */
37
38 /*
39   ===============================================================================
40   NOTE NOTE NOTE!!!
41
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.
47
48   please don't convert this file to use the *_m() functions!!
49   ===============================================================================
50 */
51
52
53 #include "includes.h"
54 #include "smbd/globals.h"
55
56 #if 1
57 #define M_DEBUG(level, x) DEBUG(level, x)
58 #else
59 #define M_DEBUG(level, x)
60 #endif
61
62 /* these flags are used to mark characters in as having particular
63    properties */
64 #define FLAG_BASECHAR 1
65 #define FLAG_ASCII 2
66 #define FLAG_ILLEGAL 4
67 #define FLAG_WILDCARD 8
68
69 /* the "possible" flags are used as a fast way to find possible DOS
70    reserved filenames */
71 #define FLAG_POSSIBLE1 16
72 #define FLAG_POSSIBLE2 32
73 #define FLAG_POSSIBLE3 64
74 #define FLAG_POSSIBLE4 128
75
76 /* by default have a max of 4096 entries in the cache. */
77 #ifndef MANGLE_CACHE_SIZE
78 #define MANGLE_CACHE_SIZE 4096
79 #endif
80
81 #define FNV1_PRIME 0x01000193
82 /*the following number is a fnv1 of the string: idra@samba.org 2002 */
83 #define FNV1_INIT  0xa6b93095
84
85 #define FLAG_CHECK(c, flag) (char_flags[(unsigned char)(c)] & (flag))
86
87 /* these are the characters we use in the 8.3 hash. Must be 36 chars long */
88 static const char basechars[36] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
89 #define base_forward(v) basechars[v]
90
91 /* the list of reserved dos names - all of these are illegal */
92 static const char * const reserved_names[] =
93 { "AUX", "LOCK$", "CON", "COM1", "COM2", "COM3", "COM4",
94   "LPT1", "LPT2", "LPT3", "NUL", "PRN", NULL };
95
96 /* 
97    hash a string of the specified length. The string does not need to be
98    null terminated 
99
100    this hash needs to be fast with a low collision rate (what hash doesn't?)
101 */
102 static unsigned int mangle_hash(const char *key, unsigned int length)
103 {
104         unsigned int value;
105         unsigned int   i;
106         fstring str;
107
108         /* we have to uppercase here to ensure that the mangled name
109            doesn't depend on the case of the long name. Note that this
110            is the only place where we need to use a multi-byte string
111            function */
112         length = MIN(length,sizeof(fstring)-1);
113         strncpy(str, key, length);
114         str[length] = 0;
115         strupper_m(str);
116
117         /* the length of a multi-byte string can change after a strupper_m */
118         length = strlen(str);
119
120         /* Set the initial value from the key size. */
121         for (value = FNV1_INIT, i=0; i < length; i++) {
122                 value *= (unsigned int)FNV1_PRIME;
123                 value ^= (unsigned int)(str[i]);
124         }
125
126         /* note that we force it to a 31 bit hash, to keep within the limits
127            of the 36^6 mangle space */
128         return value & ~0x80000000;  
129 }
130
131 /*
132   insert an entry into the prefix cache. The string might not be null
133   terminated */
134 static void cache_insert(const char *prefix, int length, unsigned int hash)
135 {
136         char *str = SMB_STRNDUP(prefix, length);
137
138         if (str == NULL) {
139                 return;
140         }
141
142         memcache_add(smbd_memcache(), MANGLE_HASH2_CACHE,
143                      data_blob_const(&hash, sizeof(hash)),
144                      data_blob_const(str, length+1));
145         SAFE_FREE(str);
146 }
147
148 /*
149   lookup an entry in the prefix cache. Return NULL if not found.
150 */
151 static char *cache_lookup(TALLOC_CTX *mem_ctx, unsigned int hash)
152 {
153         DATA_BLOB value;
154
155         if (!memcache_lookup(smbd_memcache(), MANGLE_HASH2_CACHE,
156                              data_blob_const(&hash, sizeof(hash)), &value)) {
157                 return NULL;
158         }
159
160         SMB_ASSERT((value.length > 0)
161                    && (value.data[value.length-1] == '\0'));
162
163         return talloc_strdup(mem_ctx, (char *)value.data);
164 }
165
166
167 /* 
168    determine if a string is possibly in a mangled format, ignoring
169    case 
170
171    In this algorithm, mangled names use only pure ascii characters (no
172    multi-byte) so we can avoid doing a UCS2 conversion 
173  */
174 static bool is_mangled_component(const char *name, size_t len)
175 {
176         unsigned int i;
177
178         M_DEBUG(10,("is_mangled_component %s (len %lu) ?\n", name, (unsigned long)len));
179
180         /* check the length */
181         if (len > 12 || len < 8)
182                 return False;
183
184         /* the best distinguishing characteristic is the ~ */
185         if (name[6] != '~')
186                 return False;
187
188         /* check extension */
189         if (len > 8) {
190                 if (name[8] != '.')
191                         return False;
192                 for (i=9; name[i] && i < len; i++) {
193                         if (! FLAG_CHECK(name[i], FLAG_ASCII)) {
194                                 return False;
195                         }
196                 }
197         }
198         
199         /* check lead characters */
200         for (i=0;i<mangle_prefix;i++) {
201                 if (! FLAG_CHECK(name[i], FLAG_ASCII)) {
202                         return False;
203                 }
204         }
205         
206         /* check rest of hash */
207         if (! FLAG_CHECK(name[7], FLAG_BASECHAR)) {
208                 return False;
209         }
210         for (i=mangle_prefix;i<6;i++) {
211                 if (! FLAG_CHECK(name[i], FLAG_BASECHAR)) {
212                         return False;
213                 }
214         }
215
216         M_DEBUG(10,("is_mangled_component %s (len %lu) -> yes\n", name, (unsigned long)len));
217
218         return True;
219 }
220
221
222
223 /* 
224    determine if a string is possibly in a mangled format, ignoring
225    case 
226
227    In this algorithm, mangled names use only pure ascii characters (no
228    multi-byte) so we can avoid doing a UCS2 conversion 
229
230    NOTE! This interface must be able to handle a path with unix
231    directory separators. It should return true if any component is
232    mangled
233  */
234 static bool is_mangled(const char *name, const struct share_params *parm)
235 {
236         const char *p;
237         const char *s;
238
239         M_DEBUG(10,("is_mangled %s ?\n", name));
240
241         for (s=name; (p=strchr(s, '/')); s=p+1) {
242                 if (is_mangled_component(s, PTR_DIFF(p, s))) {
243                         return True;
244                 }
245         }
246         
247         /* and the last part ... */
248         return is_mangled_component(s,strlen(s));
249 }
250
251
252 /* 
253    see if a filename is an allowable 8.3 name to return to the client.
254    Note this is not testing if this is a valid Samba mangled name, so
255    the rules are different for is_mangled.
256
257    we are only going to allow ascii characters in 8.3 names, as this
258    simplifies things greatly (it means that we know the string won't
259    get larger when converted from UNIX to DOS formats)
260 */
261
262 static char force_shortname_chars[] = " +,[];=";
263
264 static bool is_8_3(const char *name, bool check_case, bool allow_wildcards, const struct share_params *p)
265 {
266         int len, i;
267         char *dot_p;
268
269         /* as a special case, the names '.' and '..' are allowable 8.3 names */
270         if (name[0] == '.') {
271                 if (!name[1] || (name[1] == '.' && !name[2])) {
272                         return True;
273                 }
274         }
275
276         /* the simplest test is on the overall length of the
277          filename. Note that we deliberately use the ascii string
278          length (not the multi-byte one) as it is faster, and gives us
279          the result we need in this case. Using strlen_m would not
280          only be slower, it would be incorrect */
281         len = strlen(name);
282         if (len > 12)
283                 return False;
284
285         /* find the '.'. Note that once again we use the non-multibyte
286            function */
287         dot_p = strchr(name, '.');
288
289         if (!dot_p) {
290                 /* if the name doesn't contain a '.' then its length
291                    must be less than 8 */
292                 if (len > 8) {
293                         return False;
294                 }
295         } else {
296                 int prefix_len, suffix_len;
297
298                 /* if it does contain a dot then the prefix must be <=
299                    8 and the suffix <= 3 in length */
300                 prefix_len = PTR_DIFF(dot_p, name);
301                 suffix_len = len - (prefix_len+1);
302
303                 if (prefix_len > 8 || suffix_len > 3 || suffix_len == 0) {
304                         return False;
305                 }
306
307                 /* a 8.3 name cannot contain more than 1 '.' */
308                 if (strchr(dot_p+1, '.')) {
309                         return False;
310                 }
311         }
312
313         /* the length are all OK. Now check to see if the characters themselves are OK */
314         for (i=0; name[i]; i++) {
315                 if (FLAG_CHECK(name[i], FLAG_ILLEGAL)) {
316                         return false;
317                 }
318                 /* note that we may allow wildcard petterns! */
319                 if (!allow_wildcards && FLAG_CHECK(name[i], FLAG_WILDCARD)) {
320                         return false;
321                 }
322                 if (((unsigned char)name[i]) > 0x7e) {
323                         return false;
324                 }
325                 if (strchr(force_shortname_chars, name[i])) {
326                         return false;
327                 }
328         }
329
330         /* it is a good 8.3 name */
331         return True;
332 }
333
334
335 /*
336   reset the mangling cache on a smb.conf reload. This only really makes sense for
337   mangling backends that have parameters in smb.conf, and as this backend doesn't
338   this is a NULL operation
339 */
340 static void mangle_reset(void)
341 {
342         /* noop */
343 }
344
345
346 /*
347   try to find a 8.3 name in the cache, and if found then
348   replace the string with the original long name.
349 */
350 static bool lookup_name_from_8_3(TALLOC_CTX *ctx,
351                         const char *name,
352                         char **pp_out, /* talloced on the given context. */
353                         const struct share_params *p)
354 {
355         unsigned int hash, multiplier;
356         unsigned int i;
357         char *prefix;
358         char extension[4];
359
360         *pp_out = NULL;
361
362         /* make sure that this is a mangled name from this cache */
363         if (!is_mangled(name, p)) {
364                 M_DEBUG(10,("lookup_name_from_8_3: %s -> not mangled\n", name));
365                 return False;
366         }
367
368         /* we need to extract the hash from the 8.3 name */
369         hash = base_reverse[(unsigned char)name[7]];
370         for (multiplier=36, i=5;i>=mangle_prefix;i--) {
371                 unsigned int v = base_reverse[(unsigned char)name[i]];
372                 hash += multiplier * v;
373                 multiplier *= 36;
374         }
375
376         /* now look in the prefix cache for that hash */
377         prefix = cache_lookup(ctx, hash);
378         if (!prefix) {
379                 M_DEBUG(10,("lookup_name_from_8_3: %s -> %08X -> not found\n",
380                                         name, hash));
381                 return False;
382         }
383
384         /* we found it - construct the full name */
385         if (name[8] == '.') {
386                 strncpy(extension, name+9, 3);
387                 extension[3] = 0;
388         } else {
389                 extension[0] = 0;
390         }
391
392         if (extension[0]) {
393                 M_DEBUG(10,("lookup_name_from_8_3: %s -> %s.%s\n",
394                                         name, prefix, extension));
395                 *pp_out = talloc_asprintf(ctx, "%s.%s", prefix, extension);
396         } else {
397                 M_DEBUG(10,("lookup_name_from_8_3: %s -> %s\n", name, prefix));
398                 *pp_out = talloc_strdup(ctx, prefix);
399         }
400
401         TALLOC_FREE(prefix);
402
403         if (!*pp_out) {
404                 M_DEBUG(0,("talloc_fail"));
405                 return False;
406         }
407
408         return True;
409 }
410
411 /*
412   look for a DOS reserved name
413 */
414 static bool is_reserved_name(const char *name)
415 {
416         if (FLAG_CHECK(name[0], FLAG_POSSIBLE1) &&
417             FLAG_CHECK(name[1], FLAG_POSSIBLE2) &&
418             FLAG_CHECK(name[2], FLAG_POSSIBLE3) &&
419             FLAG_CHECK(name[3], FLAG_POSSIBLE4)) {
420                 /* a likely match, scan the lot */
421                 int i;
422                 for (i=0; reserved_names[i]; i++) {
423                         int len = strlen(reserved_names[i]);
424                         /* note that we match on COM1 as well as COM1.foo */
425                         if (strnequal(name, reserved_names[i], len) &&
426                             (name[len] == '.' || name[len] == 0)) {
427                                 return True;
428                         }
429                 }
430         }
431
432         return False;
433 }
434
435 /*
436  See if a filename is a legal long filename.
437  A filename ending in a '.' is not legal unless it's "." or "..". JRA.
438  A filename ending in ' ' is not legal either. See bug id #2769.
439 */
440
441 static bool is_legal_name(const char *name)
442 {
443         const char *dot_pos = NULL;
444         bool alldots = True;
445         size_t numdots = 0;
446
447         while (*name) {
448                 if (((unsigned int)name[0]) > 128 && (name[1] != 0)) {
449                         /* Possible start of mb character. */
450                         char mbc[2];
451                         /*
452                          * Note that if CH_UNIX is utf8 a string may be 3
453                          * bytes, but this is ok as mb utf8 characters don't
454                          * contain embedded ascii bytes. We are really checking
455                          * for mb UNIX asian characters like Japanese (SJIS) here.
456                          * JRA.
457                          */
458                         if (convert_string(CH_UNIX, CH_UTF16LE, name, 2, mbc, 2, False) == 2) {
459                                 /* Was a good mb string. */
460                                 name += 2;
461                                 continue;
462                         }
463                 }
464
465                 if (FLAG_CHECK(name[0], FLAG_ILLEGAL)) {
466                         return False;
467                 }
468                 if (name[0] == '.') {
469                         dot_pos = name;
470                         numdots++;
471                 } else {
472                         alldots = False;
473                 }
474                 if ((name[0] == ' ') && (name[1] == '\0')) {
475                         /* Can't end in ' ' */
476                         return False;
477                 }
478                 name++;
479         }
480
481         if (dot_pos) {
482                 if (alldots && (numdots == 1 || numdots == 2))
483                         return True; /* . or .. is a valid name */
484
485                 /* A valid long name cannot end in '.' */
486                 if (dot_pos[1] == '\0')
487                         return False;
488         }
489         return True;
490 }
491
492 static bool must_mangle(const char *name,
493                         const struct share_params *p)
494 {
495         if (is_reserved_name(name)) {
496                 return True;
497         }
498         return !is_legal_name(name);
499 }
500
501 /*
502   the main forward mapping function, which converts a long filename to 
503   a 8.3 name
504
505   if cache83 is not set then we don't cache the result
506
507 */
508 static bool hash2_name_to_8_3(const char *name,
509                         char new_name[13],
510                         bool cache83,
511                         int default_case,
512                         const struct share_params *p)
513 {
514         char *dot_p;
515         char lead_chars[7];
516         char extension[4];
517         unsigned int extension_length, i;
518         unsigned int prefix_len;
519         unsigned int hash, v;
520
521         /* reserved names are handled specially */
522         if (!is_reserved_name(name)) {
523                 /* if the name is already a valid 8.3 name then we don't need to
524                  * change anything */
525                 if (is_legal_name(name) && is_8_3(name, False, False, p)) {
526                         safe_strcpy(new_name, name, 12);
527                         return True;
528                 }
529         }
530
531         /* find the '.' if any */
532         dot_p = strrchr(name, '.');
533
534         if (dot_p) {
535                 /* if the extension contains any illegal characters or
536                    is too long or zero length then we treat it as part
537                    of the prefix */
538                 for (i=0; i<4 && dot_p[i+1]; i++) {
539                         if (! FLAG_CHECK(dot_p[i+1], FLAG_ASCII)) {
540                                 dot_p = NULL;
541                                 break;
542                         }
543                 }
544                 if (i == 0 || i == 4) {
545                         dot_p = NULL;
546                 }
547         }
548
549         /* the leading characters in the mangled name is taken from
550            the first characters of the name, if they are ascii otherwise
551            '_' is used
552         */
553         for (i=0;i<mangle_prefix && name[i];i++) {
554                 lead_chars[i] = name[i];
555                 if (! FLAG_CHECK(lead_chars[i], FLAG_ASCII)) {
556                         lead_chars[i] = '_';
557                 }
558                 lead_chars[i] = toupper_ascii(lead_chars[i]);
559         }
560         for (;i<mangle_prefix;i++) {
561                 lead_chars[i] = '_';
562         }
563
564         /* the prefix is anything up to the first dot */
565         if (dot_p) {
566                 prefix_len = PTR_DIFF(dot_p, name);
567         } else {
568                 prefix_len = strlen(name);
569         }
570
571         /* the extension of the mangled name is taken from the first 3
572            ascii chars after the dot */
573         extension_length = 0;
574         if (dot_p) {
575                 for (i=1; extension_length < 3 && dot_p[i]; i++) {
576                         char c = dot_p[i];
577                         if (FLAG_CHECK(c, FLAG_ASCII)) {
578                                 extension[extension_length++] =
579                                         toupper_ascii(c);
580                         }
581                 }
582         }
583
584         /* find the hash for this prefix */
585         v = hash = mangle_hash(name, prefix_len);
586
587         /* now form the mangled name. */
588         for (i=0;i<mangle_prefix;i++) {
589                 new_name[i] = lead_chars[i];
590         }
591         new_name[7] = base_forward(v % 36);
592         new_name[6] = '~';
593         for (i=5; i>=mangle_prefix; i--) {
594                 v = v / 36;
595                 new_name[i] = base_forward(v % 36);
596         }
597
598         /* add the extension */
599         if (extension_length) {
600                 new_name[8] = '.';
601                 memcpy(&new_name[9], extension, extension_length);
602                 new_name[9+extension_length] = 0;
603         } else {
604                 new_name[8] = 0;
605         }
606
607         if (cache83) {
608                 /* put it in the cache */
609                 cache_insert(name, prefix_len, hash);
610         }
611
612         M_DEBUG(10,("hash2_name_to_8_3: %s -> %08X -> %s (cache=%d)\n",
613                    name, hash, new_name, cache83));
614
615         return True;
616 }
617
618 /* initialise the flags table
619
620   we allow only a very restricted set of characters as 'ascii' in this
621   mangling backend. This isn't a significant problem as modern clients
622   use the 'long' filenames anyway, and those don't have these
623   restrictions.
624 */
625 static void init_tables(void)
626 {
627         int i;
628
629         memset(char_flags, 0, sizeof(char_flags));
630
631         for (i=1;i<128;i++) {
632                 if (i <= 0x1f) {
633                         /* Control characters. */
634                         char_flags[i] |= FLAG_ILLEGAL;
635                 }
636
637                 if ((i >= '0' && i <= '9') ||
638                     (i >= 'a' && i <= 'z') ||
639                     (i >= 'A' && i <= 'Z')) {
640                         char_flags[i] |=  (FLAG_ASCII | FLAG_BASECHAR);
641                 }
642                 if (strchr("_-$~", i)) {
643                         char_flags[i] |= FLAG_ASCII;
644                 }
645
646                 if (strchr("*\\/?<>|\":", i)) {
647                         char_flags[i] |= FLAG_ILLEGAL;
648                 }
649
650                 if (strchr("*?\"<>", i)) {
651                         char_flags[i] |= FLAG_WILDCARD;
652                 }
653         }
654
655         memset(base_reverse, 0, sizeof(base_reverse));
656         for (i=0;i<36;i++) {
657                 base_reverse[(unsigned char)base_forward(i)] = i;
658         }
659
660         /* fill in the reserved names flags. These are used as a very
661            fast filter for finding possible DOS reserved filenames */
662         for (i=0; reserved_names[i]; i++) {
663                 unsigned char c1, c2, c3, c4;
664
665                 c1 = (unsigned char)reserved_names[i][0];
666                 c2 = (unsigned char)reserved_names[i][1];
667                 c3 = (unsigned char)reserved_names[i][2];
668                 c4 = (unsigned char)reserved_names[i][3];
669
670                 char_flags[c1] |= FLAG_POSSIBLE1;
671                 char_flags[c2] |= FLAG_POSSIBLE2;
672                 char_flags[c3] |= FLAG_POSSIBLE3;
673                 char_flags[c4] |= FLAG_POSSIBLE4;
674                 char_flags[tolower_ascii(c1)] |= FLAG_POSSIBLE1;
675                 char_flags[tolower_ascii(c2)] |= FLAG_POSSIBLE2;
676                 char_flags[tolower_ascii(c3)] |= FLAG_POSSIBLE3;
677                 char_flags[tolower_ascii(c4)] |= FLAG_POSSIBLE4;
678
679                 char_flags[(unsigned char)'.'] |= FLAG_POSSIBLE4;
680         }
681 }
682
683 /*
684   the following provides the abstraction layer to make it easier
685   to drop in an alternative mangling implementation */
686 static const struct mangle_fns mangle_hash2_fns = {
687         mangle_reset,
688         is_mangled,
689         must_mangle,
690         is_8_3,
691         lookup_name_from_8_3,
692         hash2_name_to_8_3
693 };
694
695 /* return the methods for this mangling implementation */
696 const struct mangle_fns *mangle_hash2_init(void)
697 {
698         /* the mangle prefix can only be in the mange 1 to 6 */
699         mangle_prefix = lp_mangle_prefix();
700         if (mangle_prefix > 6) {
701                 mangle_prefix = 6;
702         }
703         if (mangle_prefix < 1) {
704                 mangle_prefix = 1;
705         }
706
707         init_tables();
708         mangle_reset();
709
710         return &mangle_hash2_fns;
711 }
712
713 static void posix_mangle_reset(void)
714 {;}
715
716 static bool posix_is_mangled(const char *s, const struct share_params *p)
717 {
718         return False;
719 }
720
721 static bool posix_must_mangle(const char *s, const struct share_params *p)
722 {
723         return False;
724 }
725
726 static bool posix_is_8_3(const char *fname,
727                         bool check_case,
728                         bool allow_wildcards,
729                         const struct share_params *p)
730 {
731         return False;
732 }
733
734 static bool posix_lookup_name_from_8_3(TALLOC_CTX *ctx,
735                                 const char *in,
736                                 char **out, /* talloced on the given context. */
737                                 const struct share_params *p)
738 {
739         return False;
740 }
741
742 static bool posix_name_to_8_3(const char *in,
743                                 char out[13],
744                                 bool cache83,
745                                 int default_case,
746                                 const struct share_params *p)
747 {
748         memset(out, '\0', 13);
749         return True;
750 }
751
752 /* POSIX paths backend - no mangle. */
753 static const struct mangle_fns posix_mangle_fns = {
754         posix_mangle_reset,
755         posix_is_mangled,
756         posix_must_mangle,
757         posix_is_8_3,
758         posix_lookup_name_from_8_3,
759         posix_name_to_8_3
760 };
761
762 const struct mangle_fns *posix_mangle_init(void)
763 {
764         return &posix_mangle_fns;
765 }