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  * ============================================================================
  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 "../lib/util/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 */
 104 static 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 */
 108 static 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 */
 117 static unsigned char char_flags[256];
 118 static 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 */
 127 static 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
 203 static 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
 238 static 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 */
 281 static 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         (void)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 */
 313 static 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 */
 330 static 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  */
 353 static 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  */
 413 static 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
 441 static char force_shortname_chars[] = " +,[];=";
 442
 443 static 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 */
 519 static 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 */
 529 static 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 */
 593 static 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
 620 static 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                         size_t size = 0;
 630                         (void)next_codepoint(name, &size);
 631                         /*
 632                          * Note that we're only looking for multibyte
 633                          * encoding here. No encoding with a length > 1
 634                          * contains invalid characters.
 635                          */
 636                         if (size > 1) {
 637                                 /* Was a mb string. */
 638                                 name += size;
 639                                 continue;
 640                         }
 641                 }
 642
 643                 if (FLAG_CHECK(name[0], FLAG_ILLEGAL)) {
 644                         return False;
 645                 }
 646                 if (name[0] == '.') {
 647                         dot_pos = name;
 648                         numdots++;
 649                 } else {
 650                         alldots = False;
 651                 }
 652                 if ((name[0] == ' ') && (name[1] == '\0')) {
 653                         /* Can't end in ' ' */
 654                         return False;
 655                 }
 656                 name++;
 657         }
 658
 659         if (dot_pos) {
 660                 if (alldots && (numdots == 1 || numdots == 2))
 661                         return True; /* . or .. is a valid name */
 662
 663                 /* A valid long name cannot end in '.' */
 664                 if (dot_pos[1] == '\0')
 665                         return False;
 666         }
 667         return True;
 668 }
 669
 670 static bool must_mangle(const char *name,
 671                         const struct share_params *p)
 672 {
 673         if (is_reserved_name(name)) {
 674                 return True;
 675         }
 676         return !is_legal_name(name);
 677 }
 678
 679 /*
 680   the main forward mapping function, which converts a long filename to
 681   a 8.3 name
 682
 683   if cache83 is not set then we don't cache the result
 684
 685 */
 686 static bool hash2_name_to_8_3(const char *name,
 687                         char new_name[13],
 688                         bool cache83,
 689                         int default_case,
 690                         const struct share_params *p)
 691 {
 692         char *dot_p;
 693         char lead_chars[7];
 694         char extension[4];
 695         unsigned int extension_length, i;
 696         unsigned int prefix_len;
 697         unsigned int hash, v;
 698
 699         /* reserved names are handled specially */
 700         if (!is_reserved_name(name)) {
 701                 /* if the name is already a valid 8.3 name then we don't need to
 702                  * change anything */
 703                 if (is_legal_name(name) && is_8_3(name, False, False, p)) {
 704                         strlcpy(new_name, name, 13);
 705                         return True;
 706                 }
 707         }
 708
 709         /* find the '.' if any */
 710         dot_p = strrchr(name, '.');
 711
 712         if (dot_p) {
 713                 /* if the extension contains any illegal characters or
 714                    is too long or zero length then we treat it as part
 715                    of the prefix */
 716                 for (i=0; i<4 && dot_p[i+1]; i++) {
 717                         if (! FLAG_CHECK(dot_p[i+1], FLAG_ASCII)) {
 718                                 dot_p = NULL;
 719                                 break;
 720                         }
 721                 }
 722                 if (i == 0 || i == 4) {
 723                         dot_p = NULL;
 724                 }
 725         }
 726
 727         /* the leading characters in the mangled name is taken from
 728            the first characters of the name, if they are ascii otherwise
 729            '_' is used
 730         */
 731         for (i=0;i<mangle_prefix && name[i];i++) {
 732                 lead_chars[i] = name[i];
 733                 if (! FLAG_CHECK(lead_chars[i], FLAG_ASCII)) {
 734                         lead_chars[i] = '_';
 735                 }
 736                 lead_chars[i] = toupper_m(lead_chars[i]);
 737         }
 738         for (;i<mangle_prefix;i++) {
 739                 lead_chars[i] = '_';
 740         }
 741
 742         /* the prefix is anything up to the first dot */
 743         if (dot_p) {
 744                 prefix_len = PTR_DIFF(dot_p, name);
 745         } else {
 746                 prefix_len = strlen(name);
 747         }
 748
 749         /* the extension of the mangled name is taken from the first 3
 750            ascii chars after the dot */
 751         extension_length = 0;
 752         if (dot_p) {
 753                 for (i=1; extension_length < 3 && dot_p[i]; i++) {
 754                         char c = dot_p[i];
 755                         if (FLAG_CHECK(c, FLAG_ASCII)) {
 756                                 extension[extension_length++] =
 757                                         toupper_m(c);
 758                         }
 759                 }
 760         }
 761
 762         /* find the hash for this prefix */
 763         v = hash = mangle_hash(name, prefix_len);
 764
 765         /* now form the mangled name. */
 766         for (i=0;i<mangle_prefix;i++) {
 767                 new_name[i] = lead_chars[i];
 768         }
 769         new_name[7] = base_forward(v % 36);
 770         new_name[6] = '~';
 771         for (i=5; i>=mangle_prefix; i--) {
 772                 v = v / 36;
 773                 new_name[i] = base_forward(v % 36);
 774         }
 775
 776         /* add the extension */
 777         if (extension_length) {
 778                 new_name[8] = '.';
 779                 memcpy(&new_name[9], extension, extension_length);
 780                 new_name[9+extension_length] = 0;
 781         } else {
 782                 new_name[8] = 0;
 783         }
 784
 785         if (cache83) {
 786                 /* put it in the cache */
 787                 cache_insert(name, prefix_len, hash);
 788         }
 789
 790         M_DEBUG(10,("hash2_name_to_8_3: %s -> %08X -> %s (cache=%d)\n",
 791                    name, hash, new_name, cache83));
 792
 793         return True;
 794 }
 795
 796 /*
 797   the following provides the abstraction layer to make it easier
 798   to drop in an alternative mangling implementation */
 799 static const struct mangle_fns mangle_hash2_fns = {
 800         mangle_reset,
 801         is_mangled,
 802         must_mangle,
 803         is_8_3,
 804         lookup_name_from_8_3,
 805         hash2_name_to_8_3
 806 };
 807
 808 /* return the methods for this mangling implementation */
 809 const struct mangle_fns *mangle_hash2_init(void)
 810 {
 811         /* the mangle prefix can only be in the mange 1 to 6 */
 812         mangle_prefix = lp_mangle_prefix();
 813         if (mangle_prefix > 6) {
 814                 mangle_prefix = 6;
 815         }
 816         if (mangle_prefix < 1) {
 817                 mangle_prefix = 1;
 818         }
 819
 820 #if DYNAMIC_MANGLE_TABLES
 821         init_tables();
 822 #endif
 823         mangle_reset();
 824
 825         return &mangle_hash2_fns;
 826 }
 827
 828 static void posix_mangle_reset(void)
 829 {;}
 830
 831 static bool posix_is_mangled(const char *s, const struct share_params *p)
 832 {
 833         return False;
 834 }
 835
 836 static bool posix_must_mangle(const char *s, const struct share_params *p)
 837 {
 838         return False;
 839 }
 840
 841 static bool posix_is_8_3(const char *fname,
 842                         bool check_case,
 843                         bool allow_wildcards,
 844                         const struct share_params *p)
 845 {
 846         return False;
 847 }
 848
 849 static bool posix_lookup_name_from_8_3(TALLOC_CTX *ctx,
 850                                 const char *in,
 851                                 char **out, /* talloced on the given context. */
 852                                 const struct share_params *p)
 853 {
 854         return False;
 855 }
 856
 857 static bool posix_name_to_8_3(const char *in,
 858                                 char out[13],
 859                                 bool cache83,
 860                                 int default_case,
 861                                 const struct share_params *p)
 862 {
 863         memset(out, '\0', 13);
 864         return True;
 865 }
 866
 867 /* POSIX paths backend - no mangle. */
 868 static const struct mangle_fns posix_mangle_fns = {
 869         posix_mangle_reset,
 870         posix_is_mangled,
 871         posix_must_mangle,
 872         posix_is_8_3,
 873         posix_lookup_name_from_8_3,
 874         posix_name_to_8_3
 875 };
 876
 877 const struct mangle_fns *posix_mangle_init(void)
 878 {
 879         return &posix_mangle_fns;
 880 }