source: vendor/3.6.9/source3/smbd/mangle_hash2.c

Last change on this file was 740, checked in by Silvan Scherrer, 13 years ago

Samba Server: update vendor to 3.6.0
File size: 23.8 KB
Line 
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 * ============================================================================
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 */
64
65
66#include "includes.h"
67#include "smbd/smbd.h"
68#include "smbd/globals.h"
69#include "memcache.h"
70#include "mangle.h"
71
72#if 1
73#define M_DEBUG(level, x) DEBUG(level, x)
74#else
75#define M_DEBUG(level, x)
76#endif
77
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
84
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
91
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
96
97#define FNV1_PRIME 0x01000193
98/*the following number is a fnv1 of the string: idra@samba.org 2002 */
99#define FNV1_INIT 0xa6b93095
100
101#define FLAG_CHECK(c, flag) (char_flags[(unsigned char)(c)] & (flag))
102
103/* these are the characters we use in the 8.3 hash. Must be 36 chars long */
104static const char basechars[36] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
105#define base_forward(v) basechars[v]
106
107/* the list of reserved dos names - all of these are illegal */
108static const char * const reserved_names[] =
109{ "AUX", "LOCK$", "CON", "COM1", "COM2", "COM3", "COM4",
110 "LPT1", "LPT2", "LPT3", "NUL", "PRN", NULL };
111
112#define DYNAMIC_MANGLE_TABLES 0
113
114#if DYNAMIC_MANGLE_TABLES
115
116/* these tables are used to provide fast tests for characters */
117static unsigned char char_flags[256];
118static unsigned char base_reverse[256];
119
120/* initialise the flags table
121
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*/
127static void init_tables(void)
128{
129 int i;
130
131 memset(char_flags, 0, sizeof(char_flags));
132
133 for (i=1;i<128;i++) {
134 if (i <= 0x1f) {
135 /* Control characters. */
136 char_flags[i] |= FLAG_ILLEGAL;
137 }
138
139 if ((i >= '0' && i <= '9') ||
140 (i >= 'a' && i <= 'z') ||
141 (i >= 'A' && i <= 'Z')) {
142 char_flags[i] |= (FLAG_ASCII | FLAG_BASECHAR);
143 }
144 if (strchr("_-$~", i)) {
145 char_flags[i] |= FLAG_ASCII;
146 }
147
148 if (strchr("*\\/?<>|\":", i)) {
149 char_flags[i] |= FLAG_ILLEGAL;
150 }
151
152 if (strchr("*?\"<>", i)) {
153 char_flags[i] |= FLAG_WILDCARD;
154 }
155 }
156
157 memset(base_reverse, 0, sizeof(base_reverse));
158 for (i=0;i<36;i++) {
159 base_reverse[(unsigned char)base_forward(i)] = i;
160 }
161
162 /* fill in the reserved names flags. These are used as a very
163 fast filter for finding possible DOS reserved filenames */
164 for (i=0; reserved_names[i]; i++) {
165 unsigned char c1, c2, c3, c4;
166
167 c1 = (unsigned char)reserved_names[i][0];
168 c2 = (unsigned char)reserved_names[i][1];
169 c3 = (unsigned char)reserved_names[i][2];
170 c4 = (unsigned char)reserved_names[i][3];
171
172 char_flags[c1] |= FLAG_POSSIBLE1;
173 char_flags[c2] |= FLAG_POSSIBLE2;
174 char_flags[c3] |= FLAG_POSSIBLE3;
175 char_flags[c4] |= FLAG_POSSIBLE4;
176 char_flags[tolower_m(c1)] |= FLAG_POSSIBLE1;
177 char_flags[tolower_m(c2)] |= FLAG_POSSIBLE2;
178 char_flags[tolower_m(c3)] |= FLAG_POSSIBLE3;
179 char_flags[tolower_m(c4)] |= FLAG_POSSIBLE4;
180
181 char_flags[(unsigned char)'.'] |= FLAG_POSSIBLE4;
182 }
183
184#if 0
185 DEBUG(10, ("char_flags\n"));
186 dump_data(10, char_flags, sizeof(char_flags));
187
188 DEBUG(10, ("base_reverse\n"));
189 dump_data(10, base_reverse, sizeof(base_reverse));
190#endif
191}
192
193#else
194
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 */
202
203static uint8_t char_flags[256] = {
204 0x80, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
205 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
206 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
207 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
208 0x00, 0x00, 0x0C, 0x00, 0x02, 0x00, 0x00, 0x00,
209 0x00, 0x00, 0x0C, 0x00, 0x00, 0x02, 0x80, 0x04,
210 0x03, 0x83, 0x83, 0x83, 0x83, 0x03, 0x03, 0x03,
211 0x03, 0x03, 0x04, 0x00, 0x0C, 0x00, 0x0C, 0x0C,
212 0x00, 0x13, 0x03, 0x53, 0x03, 0x03, 0x03, 0x03,
213 0x03, 0x03, 0x03, 0x83, 0x53, 0x43, 0x53, 0x23,
214 0x33, 0x03, 0x23, 0x03, 0x43, 0x23, 0x03, 0x03,
215 0x43, 0x03, 0x03, 0x00, 0x04, 0x00, 0x00, 0x02,
216 0x00, 0x13, 0x03, 0x53, 0x03, 0x03, 0x03, 0x03,
217 0x03, 0x03, 0x03, 0x83, 0x53, 0x43, 0x53, 0x23,
218 0x33, 0x03, 0x23, 0x03, 0x43, 0x23, 0x03, 0x03,
219 0x43, 0x03, 0x03, 0x00, 0x04, 0x00, 0x02, 0x00,
220 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
221 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
222 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
223 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
224 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
225 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
226 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
227 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
228 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
229 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
230 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
231 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
232 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
233 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
234 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
235 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
236};
237
238static uint8_t base_reverse[256] = {
239 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
240 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
241 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
242 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
243 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
244 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
245 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
246 0x08, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
247 0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
248 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
249 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
250 0x21, 0x22, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00,
251 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
252 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
253 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
254 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
255 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
256 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
257 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
258 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
259 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
260 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
261 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
262 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
263 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
264 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
265 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
266 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
267 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
268 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
269 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
270 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
271};
272
273#endif
274
275/*
276 hash a string of the specified length. The string does not need to be
277 null terminated
278
279 this hash needs to be fast with a low collision rate (what hash doesn't?)
280*/
281static unsigned int mangle_hash(const char *key, unsigned int length)
282{
283 unsigned int value;
284 unsigned int i;
285 fstring str;
286
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 */
291 length = MIN(length,sizeof(fstring)-1);
292 strncpy(str, key, length);
293 str[length] = 0;
294 strupper_m(str);
295
296 /* the length of a multi-byte string can change after a strupper_m */
297 length = strlen(str);
298
299 /* Set the initial value from the key size. */
300 for (value = FNV1_INIT, i=0; i < length; i++) {
301 value *= (unsigned int)FNV1_PRIME;
302 value ^= (unsigned int)(str[i]);
303 }
304
305 /* note that we force it to a 31 bit hash, to keep within the limits
306 of the 36^6 mangle space */
307 return value & ~0x80000000;
308}
309
310/*
311 insert an entry into the prefix cache. The string might not be null
312 terminated */
313static void cache_insert(const char *prefix, int length, unsigned int hash)
314{
315 char *str = SMB_STRNDUP(prefix, length);
316
317 if (str == NULL) {
318 return;
319 }
320
321 memcache_add(smbd_memcache(), MANGLE_HASH2_CACHE,
322 data_blob_const(&hash, sizeof(hash)),
323 data_blob_const(str, length+1));
324 SAFE_FREE(str);
325}
326
327/*
328 lookup an entry in the prefix cache. Return NULL if not found.
329*/
330static char *cache_lookup(TALLOC_CTX *mem_ctx, unsigned int hash)
331{
332 DATA_BLOB value;
333
334 if (!memcache_lookup(smbd_memcache(), MANGLE_HASH2_CACHE,
335 data_blob_const(&hash, sizeof(hash)), &value)) {
336 return NULL;
337 }
338
339 SMB_ASSERT((value.length > 0)
340 && (value.data[value.length-1] == '\0'));
341
342 return talloc_strdup(mem_ctx, (char *)value.data);
343}
344
345
346/*
347 determine if a string is possibly in a mangled format, ignoring
348 case
349
350 In this algorithm, mangled names use only pure ascii characters (no
351 multi-byte) so we can avoid doing a UCS2 conversion
352 */
353static bool is_mangled_component(const char *name, size_t len)
354{
355 unsigned int i;
356
357 M_DEBUG(10,("is_mangled_component %s (len %lu) ?\n", name, (unsigned long)len));
358
359 /* check the length */
360 if (len > 12 || len < 8)
361 return False;
362
363 /* the best distinguishing characteristic is the ~ */
364 if (name[6] != '~')
365 return False;
366
367 /* check extension */
368 if (len > 8) {
369 if (name[8] != '.')
370 return False;
371 for (i=9; name[i] && i < len; i++) {
372 if (! FLAG_CHECK(name[i], FLAG_ASCII)) {
373 return False;
374 }
375 }
376 }
377
378 /* check lead characters */
379 for (i=0;i<mangle_prefix;i++) {
380 if (! FLAG_CHECK(name[i], FLAG_ASCII)) {
381 return False;
382 }
383 }
384
385 /* check rest of hash */
386 if (! FLAG_CHECK(name[7], FLAG_BASECHAR)) {
387 return False;
388 }
389 for (i=mangle_prefix;i<6;i++) {
390 if (! FLAG_CHECK(name[i], FLAG_BASECHAR)) {
391 return False;
392 }
393 }
394
395 M_DEBUG(10,("is_mangled_component %s (len %lu) -> yes\n", name, (unsigned long)len));
396
397 return True;
398}
399
400
401
402/*
403 determine if a string is possibly in a mangled format, ignoring
404 case
405
406 In this algorithm, mangled names use only pure ascii characters (no
407 multi-byte) so we can avoid doing a UCS2 conversion
408
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 */
413static bool is_mangled(const char *name, const struct share_params *parm)
414{
415 const char *p;
416 const char *s;
417
418 M_DEBUG(10,("is_mangled %s ?\n", name));
419
420 for (s=name; (p=strchr(s, '/')); s=p+1) {
421 if (is_mangled_component(s, PTR_DIFF(p, s))) {
422 return True;
423 }
424 }
425
426 /* and the last part ... */
427 return is_mangled_component(s,strlen(s));
428}
429
430
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.
435
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*/
440
441static char force_shortname_chars[] = " +,[];=";
442
443static bool is_8_3(const char *name, bool check_case, bool allow_wildcards, const struct share_params *p)
444{
445 int len, i;
446 char *dot_p;
447
448 /* as a special case, the names '.' and '..' are allowable 8.3 names */
449 if (name[0] == '.') {
450 if (!name[1] || (name[1] == '.' && !name[2])) {
451 return True;
452 }
453 }
454
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 */
460 len = strlen(name);
461 if (len > 12)
462 return False;
463
464 /* find the '.'. Note that once again we use the non-multibyte
465 function */
466 dot_p = strchr(name, '.');
467
468 if (!dot_p) {
469 /* if the name doesn't contain a '.' then its length
470 must be less than 8 */
471 if (len > 8) {
472 return False;
473 }
474 } else {
475 int prefix_len, suffix_len;
476
477 /* if it does contain a dot then the prefix must be <=
478 8 and the suffix <= 3 in length */
479 prefix_len = PTR_DIFF(dot_p, name);
480 suffix_len = len - (prefix_len+1);
481
482 if (prefix_len > 8 || suffix_len > 3 || suffix_len == 0) {
483 return False;
484 }
485
486 /* a 8.3 name cannot contain more than 1 '.' */
487 if (strchr(dot_p+1, '.')) {
488 return False;
489 }
490 }
491
492 /* the length are all OK. Now check to see if the characters themselves are OK */
493 for (i=0; name[i]; i++) {
494 if (FLAG_CHECK(name[i], FLAG_ILLEGAL)) {
495 return false;
496 }
497 /* note that we may allow wildcard petterns! */
498 if (!allow_wildcards && FLAG_CHECK(name[i], FLAG_WILDCARD)) {
499 return false;
500 }
501 if (((unsigned char)name[i]) > 0x7e) {
502 return false;
503 }
504 if (strchr(force_shortname_chars, name[i])) {
505 return false;
506 }
507 }
508
509 /* it is a good 8.3 name */
510 return True;
511}
512
513
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*/
519static void mangle_reset(void)
520{
521 /* noop */
522}
523
524
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*/
529static bool lookup_name_from_8_3(TALLOC_CTX *ctx,
530 const char *name,
531 char **pp_out, /* talloced on the given context. */
532 const struct share_params *p)
533{
534 unsigned int hash, multiplier;
535 unsigned int i;
536 char *prefix;
537 char extension[4];
538
539 *pp_out = NULL;
540
541 /* make sure that this is a mangled name from this cache */
542 if (!is_mangled(name, p)) {
543 M_DEBUG(10,("lookup_name_from_8_3: %s -> not mangled\n", name));
544 return False;
545 }
546
547 /* we need to extract the hash from the 8.3 name */
548 hash = base_reverse[(unsigned char)name[7]];
549 for (multiplier=36, i=5;i>=mangle_prefix;i--) {
550 unsigned int v = base_reverse[(unsigned char)name[i]];
551 hash += multiplier * v;
552 multiplier *= 36;
553 }
554
555 /* now look in the prefix cache for that hash */
556 prefix = cache_lookup(ctx, hash);
557 if (!prefix) {
558 M_DEBUG(10,("lookup_name_from_8_3: %s -> %08X -> not found\n",
559 name, hash));
560 return False;
561 }
562
563 /* we found it - construct the full name */
564 if (name[8] == '.') {
565 strncpy(extension, name+9, 3);
566 extension[3] = 0;
567 } else {
568 extension[0] = 0;
569 }
570
571 if (extension[0]) {
572 M_DEBUG(10,("lookup_name_from_8_3: %s -> %s.%s\n",
573 name, prefix, extension));
574 *pp_out = talloc_asprintf(ctx, "%s.%s", prefix, extension);
575 } else {
576 M_DEBUG(10,("lookup_name_from_8_3: %s -> %s\n", name, prefix));
577 *pp_out = talloc_strdup(ctx, prefix);
578 }
579
580 TALLOC_FREE(prefix);
581
582 if (!*pp_out) {
583 M_DEBUG(0,("talloc_fail"));
584 return False;
585 }
586
587 return True;
588}
589
590/*
591 look for a DOS reserved name
592*/
593static bool is_reserved_name(const char *name)
594{
595 if (FLAG_CHECK(name[0], FLAG_POSSIBLE1) &&
596 FLAG_CHECK(name[1], FLAG_POSSIBLE2) &&
597 FLAG_CHECK(name[2], FLAG_POSSIBLE3) &&
598 FLAG_CHECK(name[3], FLAG_POSSIBLE4)) {
599 /* a likely match, scan the lot */
600 int i;
601 for (i=0; reserved_names[i]; i++) {
602 int len = strlen(reserved_names[i]);
603 /* note that we match on COM1 as well as COM1.foo */
604 if (strnequal(name, reserved_names[i], len) &&
605 (name[len] == '.' || name[len] == 0)) {
606 return True;
607 }
608 }
609 }
610
611 return False;
612}
613
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*/
619
620static bool is_legal_name(const char *name)
621{
622 const char *dot_pos = NULL;
623 bool alldots = True;
624 size_t numdots = 0;
625
626 while (*name) {
627 if (((unsigned int)name[0]) > 128 && (name[1] != 0)) {
628 /* Possible start of mb character. */
629 char mbc[2];
630 /*
631 * Note that if CH_UNIX is utf8 a string may be 3
632 * bytes, but this is ok as mb utf8 characters don't
633 * contain embedded ascii bytes. We are really checking
634 * for mb UNIX asian characters like Japanese (SJIS) here.
635 * JRA.
636 */
637 if (convert_string(CH_UNIX, CH_UTF16LE, name, 2, mbc, 2, False) == 2) {
638 /* Was a good mb string. */
639 name += 2;
640 continue;
641 }
642 }
643
644 if (FLAG_CHECK(name[0], FLAG_ILLEGAL)) {
645 return False;
646 }
647 if (name[0] == '.') {
648 dot_pos = name;
649 numdots++;
650 } else {
651 alldots = False;
652 }
653 if ((name[0] == ' ') && (name[1] == '\0')) {
654 /* Can't end in ' ' */
655 return False;
656 }
657 name++;
658 }
659
660 if (dot_pos) {
661 if (alldots && (numdots == 1 || numdots == 2))
662 return True; /* . or .. is a valid name */
663
664 /* A valid long name cannot end in '.' */
665 if (dot_pos[1] == '\0')
666 return False;
667 }
668 return True;
669}
670
671static bool must_mangle(const char *name,
672 const struct share_params *p)
673{
674 if (is_reserved_name(name)) {
675 return True;
676 }
677 return !is_legal_name(name);
678}
679
680/*
681 the main forward mapping function, which converts a long filename to
682 a 8.3 name
683
684 if cache83 is not set then we don't cache the result
685
686*/
687static bool hash2_name_to_8_3(const char *name,
688 char new_name[13],
689 bool cache83,
690 int default_case,
691 const struct share_params *p)
692{
693 char *dot_p;
694 char lead_chars[7];
695 char extension[4];
696 unsigned int extension_length, i;
697 unsigned int prefix_len;
698 unsigned int hash, v;
699
700 /* reserved names are handled specially */
701 if (!is_reserved_name(name)) {
702 /* if the name is already a valid 8.3 name then we don't need to
703 * change anything */
704 if (is_legal_name(name) && is_8_3(name, False, False, p)) {
705 safe_strcpy(new_name, name, 12);
706 return True;
707 }
708 }
709
710 /* find the '.' if any */
711 dot_p = strrchr(name, '.');
712
713 if (dot_p) {
714 /* if the extension contains any illegal characters or
715 is too long or zero length then we treat it as part
716 of the prefix */
717 for (i=0; i<4 && dot_p[i+1]; i++) {
718 if (! FLAG_CHECK(dot_p[i+1], FLAG_ASCII)) {
719 dot_p = NULL;
720 break;
721 }
722 }
723 if (i == 0 || i == 4) {
724 dot_p = NULL;
725 }
726 }
727
728 /* the leading characters in the mangled name is taken from
729 the first characters of the name, if they are ascii otherwise
730 '_' is used
731 */
732 for (i=0;i<mangle_prefix && name[i];i++) {
733 lead_chars[i] = name[i];
734 if (! FLAG_CHECK(lead_chars[i], FLAG_ASCII)) {
735 lead_chars[i] = '_';
736 }
737 lead_chars[i] = toupper_m(lead_chars[i]);
738 }
739 for (;i<mangle_prefix;i++) {
740 lead_chars[i] = '_';
741 }
742
743 /* the prefix is anything up to the first dot */
744 if (dot_p) {
745 prefix_len = PTR_DIFF(dot_p, name);
746 } else {
747 prefix_len = strlen(name);
748 }
749
750 /* the extension of the mangled name is taken from the first 3
751 ascii chars after the dot */
752 extension_length = 0;
753 if (dot_p) {
754 for (i=1; extension_length < 3 && dot_p[i]; i++) {
755 char c = dot_p[i];
756 if (FLAG_CHECK(c, FLAG_ASCII)) {
757 extension[extension_length++] =
758 toupper_m(c);
759 }
760 }
761 }
762
763 /* find the hash for this prefix */
764 v = hash = mangle_hash(name, prefix_len);
765
766 /* now form the mangled name. */
767 for (i=0;i<mangle_prefix;i++) {
768 new_name[i] = lead_chars[i];
769 }
770 new_name[7] = base_forward(v % 36);
771 new_name[6] = '~';
772 for (i=5; i>=mangle_prefix; i--) {
773 v = v / 36;
774 new_name[i] = base_forward(v % 36);
775 }
776
777 /* add the extension */
778 if (extension_length) {
779 new_name[8] = '.';
780 memcpy(&new_name[9], extension, extension_length);
781 new_name[9+extension_length] = 0;
782 } else {
783 new_name[8] = 0;
784 }
785
786 if (cache83) {
787 /* put it in the cache */
788 cache_insert(name, prefix_len, hash);
789 }
790
791 M_DEBUG(10,("hash2_name_to_8_3: %s -> %08X -> %s (cache=%d)\n",
792 name, hash, new_name, cache83));
793
794 return True;
795}
796
797/*
798 the following provides the abstraction layer to make it easier
799 to drop in an alternative mangling implementation */
800static const struct mangle_fns mangle_hash2_fns = {
801 mangle_reset,
802 is_mangled,
803 must_mangle,
804 is_8_3,
805 lookup_name_from_8_3,
806 hash2_name_to_8_3
807};
808
809/* return the methods for this mangling implementation */
810const struct mangle_fns *mangle_hash2_init(void)
811{
812 /* the mangle prefix can only be in the mange 1 to 6 */
813 mangle_prefix = lp_mangle_prefix();
814 if (mangle_prefix > 6) {
815 mangle_prefix = 6;
816 }
817 if (mangle_prefix < 1) {
818 mangle_prefix = 1;
819 }
820
821#if DYNAMIC_MANGLE_TABLES
822 init_tables();
823#endif
824 mangle_reset();
825
826 return &mangle_hash2_fns;
827}
828
829static void posix_mangle_reset(void)
830{;}
831
832static bool posix_is_mangled(const char *s, const struct share_params *p)
833{
834 return False;
835}
836
837static bool posix_must_mangle(const char *s, const struct share_params *p)
838{
839 return False;
840}
841
842static bool posix_is_8_3(const char *fname,
843 bool check_case,
844 bool allow_wildcards,
845 const struct share_params *p)
846{
847 return False;
848}
849
850static bool posix_lookup_name_from_8_3(TALLOC_CTX *ctx,
851 const char *in,
852 char **out, /* talloced on the given context. */
853 const struct share_params *p)
854{
855 return False;
856}
857
858static bool posix_name_to_8_3(const char *in,
859 char out[13],
860 bool cache83,
861 int default_case,
862 const struct share_params *p)
863{
864 memset(out, '\0', 13);
865 return True;
866}
867
868/* POSIX paths backend - no mangle. */
869static const struct mangle_fns posix_mangle_fns = {
870 posix_mangle_reset,
871 posix_is_mangled,
872 posix_must_mangle,
873 posix_is_8_3,
874 posix_lookup_name_from_8_3,
875 posix_name_to_8_3
876};
877
878const struct mangle_fns *posix_mangle_init(void)
879{
880 return &posix_mangle_fns;
881}
Note: See TracBrowser for help on using the repository browser.