2 Unix SMB/CIFS implementation.
4 POSIX NTVFS backend - 8.3 name routines
6 Copyright (C) Andrew Tridgell 2004
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "system/locale.h"
24 #include "vfs_posix.h"
25 #include "param/param.h"
28 this mangling scheme uses the following format
32 where nnnnn is a base 36 hash, and A represents characters from the original string
34 The hash is taken of the leading part of the long filename, in uppercase
36 for simplicity, we only allow ascii characters in 8.3 names
40 ===============================================================================
43 This file deliberately uses non-multibyte string functions in many places. This
44 is *not* a mistake. This code is multi-byte safe, but it gets this property
45 through some very subtle knowledge of the way multi-byte strings are encoded
46 and the fact that this mangling algorithm only supports ascii characters in
49 please don't convert this file to use the *_m() functions!!
50 ===============================================================================
55 #define M_DEBUG(level, x) DEBUG(level, x)
57 #define M_DEBUG(level, x)
60 /* these flags are used to mark characters in as having particular
62 #define FLAG_BASECHAR 1
64 #define FLAG_ILLEGAL 4
65 #define FLAG_WILDCARD 8
67 /* the "possible" flags are used as a fast way to find possible DOS
69 #define FLAG_POSSIBLE1 16
70 #define FLAG_POSSIBLE2 32
71 #define FLAG_POSSIBLE3 64
72 #define FLAG_POSSIBLE4 128
74 #define DEFAULT_MANGLE_PREFIX 4
76 #define MANGLE_BASECHARS "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
78 #define FLAG_CHECK(c, flag) (ctx->char_flags[(uint8_t)(c)] & (flag))
80 static const char *reserved_names
[] =
81 { "AUX", "CON", "COM1", "COM2", "COM3", "COM4",
82 "LPT1", "LPT2", "LPT3", "NUL", "PRN", NULL
};
85 struct pvfs_mangle_context
{
86 uint8_t char_flags
[256];
88 this determines how many characters are used from the original
89 filename in the 8.3 mangled name. A larger value leads to a weaker
90 hash and more collisions. The largest possible value is 6.
93 uint32_t mangle_modulus
;
95 /* we will use a very simple direct mapped prefix cache. The big
96 advantage of this cache structure is speed and low memory usage
98 The cache is indexed by the low-order bits of the hash, and confirmed by
99 hashing the resulting cache entry to match the known hash
103 uint32_t *prefix_cache_hashes
;
105 /* this is used to reverse the base 36 mapping */
106 unsigned char base_reverse
[256];
111 hash a string of the specified length. The string does not need to be
114 this hash needs to be fast with a low collision rate (what hash doesn't?)
116 static uint32_t mangle_hash(struct pvfs_mangle_context
*ctx
,
117 const char *key
, size_t length
)
119 return pvfs_name_hash(key
, length
) % ctx
->mangle_modulus
;
123 insert an entry into the prefix cache. The string might not be null
125 static void cache_insert(struct pvfs_mangle_context
*ctx
,
126 const char *prefix
, int length
, uint32_t hash
)
128 int i
= hash
% ctx
->cache_size
;
130 if (ctx
->prefix_cache
[i
]) {
131 talloc_free(ctx
->prefix_cache
[i
]);
134 ctx
->prefix_cache
[i
] = talloc_strndup(ctx
->prefix_cache
, prefix
, length
);
135 ctx
->prefix_cache_hashes
[i
] = hash
;
139 lookup an entry in the prefix cache. Return NULL if not found.
141 static const char *cache_lookup(struct pvfs_mangle_context
*ctx
, uint32_t hash
)
143 int i
= hash
% ctx
->cache_size
;
146 if (!ctx
->prefix_cache
[i
] || hash
!= ctx
->prefix_cache_hashes
[i
]) {
150 /* yep, it matched */
151 return ctx
->prefix_cache
[i
];
156 determine if a string is possibly in a mangled format, ignoring
159 In this algorithm, mangled names use only pure ascii characters (no
160 multi-byte) so we can avoid doing a UCS2 conversion
162 static bool is_mangled_component(struct pvfs_mangle_context
*ctx
,
163 const char *name
, size_t len
)
167 M_DEBUG(10,("is_mangled_component %s (len %u) ?\n", name
, (unsigned int)len
));
169 /* check the length */
170 if (len
> 12 || len
< 8)
173 /* the best distinguishing characteristic is the ~ */
177 /* check extension */
181 for (i
=9; name
[i
] && i
< len
; i
++) {
182 if (! FLAG_CHECK(name
[i
], FLAG_ASCII
)) {
188 /* check lead characters */
189 for (i
=0;i
<ctx
->mangle_prefix
;i
++) {
190 if (! FLAG_CHECK(name
[i
], FLAG_ASCII
)) {
195 /* check rest of hash */
196 if (! FLAG_CHECK(name
[7], FLAG_BASECHAR
)) {
199 for (i
=ctx
->mangle_prefix
;i
<6;i
++) {
200 if (! FLAG_CHECK(name
[i
], FLAG_BASECHAR
)) {
205 M_DEBUG(10,("is_mangled_component %s (len %u) -> yes\n", name
, (unsigned int)len
));
213 determine if a string is possibly in a mangled format, ignoring
216 In this algorithm, mangled names use only pure ascii characters (no
217 multi-byte) so we can avoid doing a UCS2 conversion
219 NOTE! This interface must be able to handle a path with unix
220 directory separators. It should return true if any component is
223 static bool is_mangled(struct pvfs_mangle_context
*ctx
, const char *name
)
228 M_DEBUG(10,("is_mangled %s ?\n", name
));
230 for (s
=name
; (p
=strchr(s
, '/')); s
=p
+1) {
231 if (is_mangled_component(ctx
, s
, PTR_DIFF(p
, s
))) {
236 /* and the last part ... */
237 return is_mangled_component(ctx
, s
, strlen(s
));
242 see if a filename is an allowable 8.3 name.
244 we are only going to allow ascii characters in 8.3 names, as this
245 simplifies things greatly (it means that we know the string won't
246 get larger when converted from UNIX to DOS formats)
248 static bool is_8_3(struct pvfs_mangle_context
*ctx
,
249 const char *name
, bool check_case
, bool allow_wildcards
)
254 /* as a special case, the names '.' and '..' are allowable 8.3 names */
255 if (name
[0] == '.') {
256 if (!name
[1] || (name
[1] == '.' && !name
[2])) {
261 /* the simplest test is on the overall length of the
262 filename. Note that we deliberately use the ascii string
263 length (not the multi-byte one) as it is faster, and gives us
264 the result we need in this case. Using strlen_m would not
265 only be slower, it would be incorrect */
270 /* find the '.'. Note that once again we use the non-multibyte
272 dot_p
= strchr(name
, '.');
275 /* if the name doesn't contain a '.' then its length
276 must be less than 8 */
281 int prefix_len
, suffix_len
;
283 /* if it does contain a dot then the prefix must be <=
284 8 and the suffix <= 3 in length */
285 prefix_len
= PTR_DIFF(dot_p
, name
);
286 suffix_len
= len
- (prefix_len
+1);
288 if (prefix_len
> 8 || suffix_len
> 3 || suffix_len
== 0) {
292 /* a 8.3 name cannot contain more than 1 '.' */
293 if (strchr(dot_p
+1, '.')) {
298 /* the length are all OK. Now check to see if the characters themselves are OK */
299 for (i
=0; name
[i
]; i
++) {
300 /* note that we may allow wildcard petterns! */
301 if (!FLAG_CHECK(name
[i
], FLAG_ASCII
|(allow_wildcards
? FLAG_WILDCARD
: 0)) &&
307 /* it is a good 8.3 name */
313 try to find a 8.3 name in the cache, and if found then
314 return the original long name.
316 static char *check_cache(struct pvfs_mangle_context
*ctx
,
317 TALLOC_CTX
*mem_ctx
, const char *name
)
319 uint32_t hash
, multiplier
;
324 /* make sure that this is a mangled name from this cache */
325 if (!is_mangled(ctx
, name
)) {
326 M_DEBUG(10,("check_cache: %s -> not mangled\n", name
));
330 /* we need to extract the hash from the 8.3 name */
331 hash
= ctx
->base_reverse
[(unsigned char)name
[7]];
332 for (multiplier
=36, i
=5;i
>=ctx
->mangle_prefix
;i
--) {
333 uint32_t v
= ctx
->base_reverse
[(unsigned char)name
[i
]];
334 hash
+= multiplier
* v
;
338 /* now look in the prefix cache for that hash */
339 prefix
= cache_lookup(ctx
, hash
);
341 M_DEBUG(10,("check_cache: %s -> %08X -> not found\n", name
, hash
));
345 /* we found it - construct the full name */
346 if (name
[8] == '.') {
347 strncpy(extension
, name
+9, 3);
354 return talloc_asprintf(mem_ctx
, "%s.%s", prefix
, extension
);
357 return talloc_strdup(mem_ctx
, prefix
);
362 look for a DOS reserved name
364 static bool is_reserved_name(struct pvfs_mangle_context
*ctx
, const char *name
)
366 if (FLAG_CHECK(name
[0], FLAG_POSSIBLE1
) &&
367 FLAG_CHECK(name
[1], FLAG_POSSIBLE2
) &&
368 FLAG_CHECK(name
[2], FLAG_POSSIBLE3
) &&
369 FLAG_CHECK(name
[3], FLAG_POSSIBLE4
)) {
370 /* a likely match, scan the lot */
372 for (i
=0; reserved_names
[i
]; i
++) {
373 if (strcasecmp(name
, reserved_names
[i
]) == 0) {
384 See if a filename is a legal long filename.
385 A filename ending in a '.' is not legal unless it's "." or "..". JRA.
387 static bool is_legal_name(struct pvfs_mangle_context
*ctx
, const char *name
)
391 codepoint_t c
= next_codepoint(name
, &c_size
);
392 if (c
== INVALID_CODEPOINT
) {
395 /* all high chars are OK */
400 if (FLAG_CHECK(c
, FLAG_ILLEGAL
)) {
410 the main forward mapping function, which converts a long filename to
413 if need83 is not set then we only do the mangling if the name is illegal
416 if cache83 is not set then we don't cache the result
418 return NULL if we don't need to do any conversion
420 static char *name_map(struct pvfs_mangle_context
*ctx
,
421 const char *name
, bool need83
, bool cache83
)
426 unsigned int extension_length
, i
;
427 unsigned int prefix_len
;
430 const char *basechars
= MANGLE_BASECHARS
;
432 /* reserved names are handled specially */
433 if (!is_reserved_name(ctx
, name
)) {
434 /* if the name is already a valid 8.3 name then we don't need to
436 if (is_8_3(ctx
, name
, false, false)) {
440 /* if the caller doesn't strictly need 8.3 then just check for illegal
442 if (!need83
&& is_legal_name(ctx
, name
)) {
447 /* find the '.' if any */
448 dot_p
= strrchr(name
, '.');
451 /* if the extension contains any illegal characters or
452 is too long or zero length then we treat it as part
454 for (i
=0; i
<4 && dot_p
[i
+1]; i
++) {
455 if (! FLAG_CHECK(dot_p
[i
+1], FLAG_ASCII
)) {
460 if (i
== 0 || i
== 4) dot_p
= NULL
;
463 /* the leading characters in the mangled name is taken from
464 the first characters of the name, if they are ascii otherwise
467 for (i
=0;i
<ctx
->mangle_prefix
&& name
[i
];i
++) {
468 lead_chars
[i
] = name
[i
];
469 if (! FLAG_CHECK(lead_chars
[i
], FLAG_ASCII
)) {
472 lead_chars
[i
] = toupper((unsigned char)lead_chars
[i
]);
474 for (;i
<ctx
->mangle_prefix
;i
++) {
478 /* the prefix is anything up to the first dot */
480 prefix_len
= PTR_DIFF(dot_p
, name
);
482 prefix_len
= strlen(name
);
485 /* the extension of the mangled name is taken from the first 3
486 ascii chars after the dot */
487 extension_length
= 0;
489 for (i
=1; extension_length
< 3 && dot_p
[i
]; i
++) {
490 unsigned char c
= dot_p
[i
];
491 if (FLAG_CHECK(c
, FLAG_ASCII
)) {
492 extension
[extension_length
++] = toupper(c
);
497 /* find the hash for this prefix */
498 v
= hash
= mangle_hash(ctx
, name
, prefix_len
);
500 new_name
= talloc_array(ctx
, char, 13);
501 if (new_name
== NULL
) {
505 /* now form the mangled name. */
506 for (i
=0;i
<ctx
->mangle_prefix
;i
++) {
507 new_name
[i
] = lead_chars
[i
];
509 new_name
[7] = basechars
[v
% 36];
511 for (i
=5; i
>=ctx
->mangle_prefix
; i
--) {
513 new_name
[i
] = basechars
[v
% 36];
516 /* add the extension */
517 if (extension_length
) {
519 memcpy(&new_name
[9], extension
, extension_length
);
520 new_name
[9+extension_length
] = 0;
526 /* put it in the cache */
527 cache_insert(ctx
, name
, prefix_len
, hash
);
530 M_DEBUG(10,("name_map: %s -> %08X -> %s (cache=%d)\n",
531 name
, hash
, new_name
, cache83
));
537 /* initialise the flags table
539 we allow only a very restricted set of characters as 'ascii' in this
540 mangling backend. This isn't a significant problem as modern clients
541 use the 'long' filenames anyway, and those don't have these
544 static void init_tables(struct pvfs_mangle_context
*ctx
)
546 const char *basechars
= MANGLE_BASECHARS
;
548 /* the list of reserved dos names - all of these are illegal */
550 ZERO_STRUCT(ctx
->char_flags
);
552 for (i
=1;i
<128;i
++) {
553 if ((i
>= '0' && i
<= '9') ||
554 (i
>= 'a' && i
<= 'z') ||
555 (i
>= 'A' && i
<= 'Z')) {
556 ctx
->char_flags
[i
] |= (FLAG_ASCII
| FLAG_BASECHAR
);
558 if (strchr("_-$~", i
)) {
559 ctx
->char_flags
[i
] |= FLAG_ASCII
;
562 if (strchr("*\\/?<>|\":", i
)) {
563 ctx
->char_flags
[i
] |= FLAG_ILLEGAL
;
566 if (strchr("*?\"<>", i
)) {
567 ctx
->char_flags
[i
] |= FLAG_WILDCARD
;
571 ZERO_STRUCT(ctx
->base_reverse
);
573 ctx
->base_reverse
[(uint8_t)basechars
[i
]] = i
;
576 /* fill in the reserved names flags. These are used as a very
577 fast filter for finding possible DOS reserved filenames */
578 for (i
=0; reserved_names
[i
]; i
++) {
579 unsigned char c1
, c2
, c3
, c4
;
581 c1
= (unsigned char)reserved_names
[i
][0];
582 c2
= (unsigned char)reserved_names
[i
][1];
583 c3
= (unsigned char)reserved_names
[i
][2];
584 c4
= (unsigned char)reserved_names
[i
][3];
586 ctx
->char_flags
[c1
] |= FLAG_POSSIBLE1
;
587 ctx
->char_flags
[c2
] |= FLAG_POSSIBLE2
;
588 ctx
->char_flags
[c3
] |= FLAG_POSSIBLE3
;
589 ctx
->char_flags
[c4
] |= FLAG_POSSIBLE4
;
590 ctx
->char_flags
[tolower(c1
)] |= FLAG_POSSIBLE1
;
591 ctx
->char_flags
[tolower(c2
)] |= FLAG_POSSIBLE2
;
592 ctx
->char_flags
[tolower(c3
)] |= FLAG_POSSIBLE3
;
593 ctx
->char_flags
[tolower(c4
)] |= FLAG_POSSIBLE4
;
595 ctx
->char_flags
[(unsigned char)'.'] |= FLAG_POSSIBLE4
;
598 ctx
->mangle_modulus
= 1;
599 for (i
=0;i
<(7-ctx
->mangle_prefix
);i
++) {
600 ctx
->mangle_modulus
*= 36;
605 initialise the mangling code
607 NTSTATUS
pvfs_mangle_init(struct pvfs_state
*pvfs
)
609 struct pvfs_mangle_context
*ctx
;
611 ctx
= talloc(pvfs
, struct pvfs_mangle_context
);
613 return NT_STATUS_NO_MEMORY
;
616 /* by default have a max of 512 entries in the cache. */
617 ctx
->cache_size
= lpcfg_parm_int(pvfs
->ntvfs
->ctx
->lp_ctx
, NULL
, "mangle", "cachesize", 512);
619 ctx
->prefix_cache
= talloc_array(ctx
, char *, ctx
->cache_size
);
620 if (ctx
->prefix_cache
== NULL
) {
621 return NT_STATUS_NO_MEMORY
;
623 ctx
->prefix_cache_hashes
= talloc_array(ctx
, uint32_t, ctx
->cache_size
);
624 if (ctx
->prefix_cache_hashes
== NULL
) {
625 return NT_STATUS_NO_MEMORY
;
628 memset(ctx
->prefix_cache
, 0, sizeof(char *) * ctx
->cache_size
);
629 memset(ctx
->prefix_cache_hashes
, 0, sizeof(uint32_t) * ctx
->cache_size
);
631 ctx
->mangle_prefix
= lpcfg_parm_int(pvfs
->ntvfs
->ctx
->lp_ctx
, NULL
, "mangle", "prefix", -1);
632 if (ctx
->mangle_prefix
< 0 || ctx
->mangle_prefix
> 6) {
633 ctx
->mangle_prefix
= DEFAULT_MANGLE_PREFIX
;
638 pvfs
->mangle_ctx
= ctx
;
645 return the short name for a component of a full name
647 char *pvfs_short_name_component(struct pvfs_state
*pvfs
, const char *name
)
649 return name_map(pvfs
->mangle_ctx
, name
, true, true);
654 return the short name for a given entry in a directory
656 const char *pvfs_short_name(struct pvfs_state
*pvfs
, TALLOC_CTX
*mem_ctx
,
657 struct pvfs_filename
*name
)
659 char *p
= strrchr(name
->full_name
, '/');
660 char *ret
= pvfs_short_name_component(pvfs
, p
+1);
664 talloc_steal(mem_ctx
, ret
);
669 lookup a mangled name, returning the original long name if present
672 char *pvfs_mangled_lookup(struct pvfs_state
*pvfs
, TALLOC_CTX
*mem_ctx
,
675 return check_cache(pvfs
->mangle_ctx
, mem_ctx
, name
);
680 look for a DOS reserved name
682 bool pvfs_is_reserved_name(struct pvfs_state
*pvfs
, const char *name
)
684 return is_reserved_name(pvfs
->mangle_ctx
, name
);
689 see if a component of a filename could be a mangled name from our
692 bool pvfs_is_mangled_component(struct pvfs_state
*pvfs
, const char *name
)
694 return is_mangled_component(pvfs
->mangle_ctx
, name
, strlen(name
));