root/source3/smbd/mangle_hash2.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. mangle_hash
  2. cache_insert
  3. cache_lookup
  4. is_mangled_component
  5. is_mangled
  6. is_8_3
  7. mangle_reset
  8. lookup_name_from_8_3
  9. is_reserved_name
  10. is_legal_name
  11. must_mangle
  12. hash2_name_to_8_3
  13. init_tables
  14. mangle_hash2_init
  15. posix_mangle_reset
  16. posix_is_mangled
  17. posix_must_mangle
  18. posix_is_8_3
  19. posix_lookup_name_from_8_3
  20. posix_name_to_8_3
  21. posix_mangle_init

   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)
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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,
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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,
     /* [<][>][^][v][top][bottom][index][help] */
 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,
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 714 {;}
 715 
 716 static bool posix_is_mangled(const char *s, const struct share_params *p)
     /* [<][>][^][v][top][bottom][index][help] */
 717 {
 718         return False;
 719 }
 720 
 721 static bool posix_must_mangle(const char *s, const struct share_params *p)
     /* [<][>][^][v][top][bottom][index][help] */
 722 {
 723         return False;
 724 }
 725 
 726 static bool posix_is_8_3(const char *fname,
     /* [<][>][^][v][top][bottom][index][help] */
 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,
     /* [<][>][^][v][top][bottom][index][help] */
 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,
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 763 {
 764         return &posix_mangle_fns;
 765 }

/* [<][>][^][v][top][bottom][index][help] */