source3/smbd/mangle_hash.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Name mangling
   4    Copyright (C) Andrew Tridgell 1992-2002
   5    Copyright (C) Simo Sorce 2001
   6    Copyright (C) Andrew Bartlett 2002
   7
   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 2 of the License, or
  11    (at your option) any later version.
  12
  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.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23
  24 /* -------------------------------------------------------------------------- **
  25  * Notable problems...
  26  *
  27  *  March/April 1998  CRH
  28  *  - Many of the functions in this module overwrite string buffers passed to
  29  *    them.  This causes a variety of problems and is, generally speaking,
  30  *    dangerous and scarry.  See the kludge notes in name_map()
  31  *    below.
  32  *  - It seems that something is calling name_map() twice.  The
  33  *    first call is probably some sort of test.  Names which contain
  34  *    illegal characters are being doubly mangled.  I'm not sure, but
  35  *    I'm guessing the problem is in server.c.
  36  *
  37  * -------------------------------------------------------------------------- **
  38  */
  39
  40 /* -------------------------------------------------------------------------- **
  41  * History...
  42  *
  43  *  March/April 1998  CRH
  44  *  Updated a bit.  Rewrote is_mangled() to be a bit more selective.
  45  *  Rewrote the mangled name cache.  Added comments here and there.
  46  *  &c.
  47  * -------------------------------------------------------------------------- **
  48  */
  49
  50 #include "includes.h"
  51
  52
  53 /* -------------------------------------------------------------------------- **
  54  * External Variables...
  55  */
  56
  57 extern int case_default;    /* Are conforming 8.3 names all upper or lower?   */
  58 extern BOOL case_mangle;    /* If true, all chars in 8.3 should be same case. */
  59
  60 /* -------------------------------------------------------------------------- **
  61  * Other stuff...
  62  *
  63  * magic_char     - This is the magic char used for mangling.  It's
  64  *                  global.  There is a call to lp_magicchar() in server.c
  65  *                  that is used to override the initial value.
  66  *
  67  * MANGLE_BASE    - This is the number of characters we use for name mangling.
  68  *
  69  * basechars      - The set characters used for name mangling.  This
  70  *                  is static (scope is this file only).
  71  *
  72  * mangle()       - Macro used to select a character from basechars (i.e.,
  73  *                  mangle(n) will return the nth digit, modulo MANGLE_BASE).
  74  *
  75  * chartest       - array 0..255.  The index range is the set of all possible
  76  *                  values of a byte.  For each byte value, the content is a
  77  *                  two nibble pair.  See BASECHAR_MASK and ILLEGAL_MASK,
  78  *                  below.
  79  *
  80  * ct_initialized - False until the chartest array has been initialized via
  81  *                  a call to init_chartest().
  82  *
  83  * BASECHAR_MASK  - Masks the upper nibble of a one-byte value.
  84  *
  85  * ILLEGAL_MASK   - Masks the lower nibble of a one-byte value.
  86  *
  87  * isbasecahr()   - Given a character, check the chartest array to see
  88  *                  if that character is in the basechars set.  This is
  89  *                  faster than using strchr_m().
  90  *
  91  * isillegal()    - Given a character, check the chartest array to see
  92  *                  if that character is in the illegal characters set.
  93  *                  This is faster than using strchr_m().
  94  *
  95  * mangled_cache  - Cache header used for storing mangled -> original
  96  *                  reverse maps.
  97  *
  98  * mc_initialized - False until the mangled_cache structure has been
  99  *                  initialized via a call to reset_mangled_cache().
 100  *
 101  * MANGLED_CACHE_MAX_ENTRIES - Default maximum number of entries for the
 102  *                  cache.  A value of 0 indicates "infinite".
 103  *
 104  * MANGLED_CACHE_MAX_MEMORY  - Default maximum amount of memory for the
 105  *                  cache.  When the cache was kept as an array of 256
 106  *                  byte strings, the default cache size was 50 entries.
 107  *                  This required a fixed 12.5Kbytes of memory.  The
 108  *                  mangled stack parameter is no longer used (though
 109  *                  this might change).  We're now using a fixed 16Kbyte
 110  *                  maximum cache size.  This will probably be much more
 111  *                  than 50 entries.
 112  */
 113
 114 char magic_char = '~';
 115
 116 static char basechars[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_-!@#$%";
 117 #define MANGLE_BASE       (sizeof(basechars)/sizeof(char)-1)
 118
 119 static unsigned char chartest[256]  = { 0 };
 120 static BOOL          ct_initialized = False;
 121
 122 #define mangle(V) ((char)(basechars[(V) % MANGLE_BASE]))
 123 #define BASECHAR_MASK 0xf0
 124 #define ILLEGAL_MASK  0x0f
 125 #define isbasechar(C) ( (chartest[ ((C) & 0xff) ]) & BASECHAR_MASK )
 126 #define isillegal(C) ( (chartest[ ((C) & 0xff) ]) & ILLEGAL_MASK )
 127
 128 static ubi_cacheRoot mangled_cache[1] =  { { { 0, 0, 0, 0 }, 0, 0, 0, 0, 0, 0 } };
 129 static BOOL          mc_initialized   = False;
 130 #define MANGLED_CACHE_MAX_ENTRIES 1024
 131 #define MANGLED_CACHE_MAX_MEMORY 0
 132
 133 /* -------------------------------------------------------------------------- **
 134  * External Variables...
 135  */
 136
 137 extern int case_default;    /* Are conforming 8.3 names all upper or lower?   */
 138 extern BOOL case_mangle;    /* If true, all chars in 8.3 should be same case. */
 139
 140 /* -------------------------------------------------------------------- */
 141
 142 static NTSTATUS has_valid_chars(const smb_ucs2_t *s, BOOL allow_wildcards)
 143 {
 144         if (!s || !*s)
 145                 return NT_STATUS_INVALID_PARAMETER;
 146
 147         /* CHECK: this should not be necessary if the ms wild chars
 148            are not valid in valid.dat  --- simo */
 149         if (!allow_wildcards && ms_has_wild_w(s))
 150                 return NT_STATUS_UNSUCCESSFUL;
 151
 152         while (*s) {
 153                 if(!isvalid83_w(*s))
 154                         return NT_STATUS_UNSUCCESSFUL;
 155                 s++;
 156         }
 157
 158         return NT_STATUS_OK;
 159 }
 160
 161 /* return False if something fail and
 162  * return 2 alloced unicode strings that contain prefix and extension
 163  */
 164
 165 static NTSTATUS mangle_get_prefix(const smb_ucs2_t *ucs2_string, smb_ucs2_t **prefix,
 166                 smb_ucs2_t **extension, BOOL allow_wildcards)
 167 {
 168         size_t ext_len;
 169         smb_ucs2_t *p;
 170
 171         *extension = 0;
 172         *prefix = strdup_w(ucs2_string);
 173         if (!*prefix) {
 174                 return NT_STATUS_NO_MEMORY;
 175         }
 176         if ((p = strrchr_w(*prefix, UCS2_CHAR('.')))) {
 177                 ext_len = strlen_w(p+1);
 178                 if ((ext_len > 0) && (ext_len < 4) && (p != *prefix) &&
 179                     (NT_STATUS_IS_OK(has_valid_chars(p+1,allow_wildcards)))) /* check extension */ {
 180                         *p = 0;
 181                         *extension = strdup_w(p+1);
 182                         if (!*extension) {
 183                                 SAFE_FREE(*prefix);
 184                                 return NT_STATUS_NO_MEMORY;
 185                         }
 186                 }
 187         }
 188         return NT_STATUS_OK;
 189 }
 190
 191 /* ************************************************************************** **
 192  * Return NT_STATUS_UNSUCCESSFUL if a name is a special msdos reserved name.
 193  *
 194  *  Input:  fname - String containing the name to be tested.
 195  *
 196  *  Output: NT_STATUS_UNSUCCESSFUL, if the name matches one of the list of reserved names.
 197  *
 198  *  Notes:  This is a static function called by is_8_3(), below.
 199  *
 200  * ************************************************************************** **
 201  */
 202
 203 static NTSTATUS is_valid_name(const smb_ucs2_t *fname, BOOL allow_wildcards)
 204 {
 205         smb_ucs2_t *str, *p;
 206         NTSTATUS ret = NT_STATUS_OK;
 207
 208         if (!fname || !*fname)
 209                 return NT_STATUS_INVALID_PARAMETER;
 210
 211         /* . and .. are valid names. */
 212         if (strcmp_wa(fname, ".")==0 || strcmp_wa(fname, "..")==0)
 213                 return NT_STATUS_OK;
 214
 215         /* Name cannot start with '.' */
 216         if (*fname == UCS2_CHAR('.'))
 217                 return NT_STATUS_UNSUCCESSFUL;
 218
 219         ret = has_valid_chars(fname, allow_wildcards);
 220         if (!NT_STATUS_IS_OK(ret))
 221                 return ret;
 222
 223         str = strdup_w(fname);
 224         p = strchr_w(str, UCS2_CHAR('.'));
 225         if (p && p[1] == UCS2_CHAR(0)) {
 226                 /* Name cannot end in '.' */
 227                 SAFE_FREE(str);
 228                 return NT_STATUS_UNSUCCESSFUL;
 229         }
 230         if (p)
 231                 *p = 0;
 232         strupper_w(str);
 233         p = &(str[1]);
 234
 235         switch(str[0])
 236         {
 237         case UCS2_CHAR('A'):
 238                 if(strcmp_wa(p, "UX") == 0)
 239                         ret = NT_STATUS_UNSUCCESSFUL;
 240                 break;
 241         case UCS2_CHAR('C'):
 242                 if((strcmp_wa(p, "LOCK$") == 0)
 243                 || (strcmp_wa(p, "ON") == 0)
 244                 || (strcmp_wa(p, "OM1") == 0)
 245                 || (strcmp_wa(p, "OM2") == 0)
 246                 || (strcmp_wa(p, "OM3") == 0)
 247                 || (strcmp_wa(p, "OM4") == 0)
 248                 )
 249                         ret = NT_STATUS_UNSUCCESSFUL;
 250                 break;
 251         case UCS2_CHAR('L'):
 252                 if((strcmp_wa(p, "PT1") == 0)
 253                 || (strcmp_wa(p, "PT2") == 0)
 254                 || (strcmp_wa(p, "PT3") == 0)
 255                 )
 256                         ret = NT_STATUS_UNSUCCESSFUL;
 257                 break;
 258         case UCS2_CHAR('N'):
 259                 if(strcmp_wa(p, "UL") == 0)
 260                         ret = NT_STATUS_UNSUCCESSFUL;
 261                 break;
 262         case UCS2_CHAR('P'):
 263                 if(strcmp_wa(p, "RN") == 0)
 264                         ret = NT_STATUS_UNSUCCESSFUL;
 265                 break;
 266         default:
 267                 break;
 268         }
 269
 270         SAFE_FREE(str);
 271         return ret;
 272 }
 273
 274 static NTSTATUS is_8_3_w(const smb_ucs2_t *fname, BOOL allow_wildcards)
 275 {
 276         smb_ucs2_t *pref = 0, *ext = 0;
 277         size_t plen;
 278         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 279
 280         if (!fname || !*fname)
 281                 return NT_STATUS_INVALID_PARAMETER;
 282
 283         if (strlen_w(fname) > 12)
 284                 return NT_STATUS_UNSUCCESSFUL;
 285
 286         if (strcmp_wa(fname, ".") == 0 || strcmp_wa(fname, "..") == 0)
 287                 return NT_STATUS_OK;
 288
 289         if (!NT_STATUS_IS_OK(is_valid_name(fname, allow_wildcards)))
 290                 goto done;
 291
 292         if (!NT_STATUS_IS_OK(mangle_get_prefix(fname, &pref, &ext, allow_wildcards)))
 293                 goto done;
 294         plen = strlen_w(pref);
 295
 296         if (strchr_wa(pref, '.'))
 297                 goto done;
 298         if (plen < 1 || plen > 8)
 299                 goto done;
 300         if (ext && (strlen_w(ext) > 3))
 301                 goto done;
 302
 303         ret = NT_STATUS_OK;
 304
 305 done:
 306         SAFE_FREE(pref);
 307         SAFE_FREE(ext);
 308         return ret;
 309 }
 310
 311 static BOOL is_8_3(const char *fname, BOOL check_case, BOOL allow_wildcards)
 312 {
 313         const char *f;
 314         smb_ucs2_t *ucs2name;
 315         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 316
 317         if (!fname || !*fname)
 318                 return False;
 319         if ((f = strrchr(fname, '/')) == NULL)
 320                 f = fname;
 321         else
 322                 f++;
 323
 324         if (strlen(f) > 12)
 325                 return False;
 326
 327         ucs2name = acnv_uxu2(f);
 328         if (!ucs2name) {
 329                 DEBUG(0,("is_8_3: internal error acnv_uxu2() failed!\n"));
 330                 goto done;
 331         }
 332
 333         ret = is_8_3_w(ucs2name, allow_wildcards);
 334
 335 done:
 336         SAFE_FREE(ucs2name);
 337
 338         if (!NT_STATUS_IS_OK(ret)) {
 339                 return False;
 340         }
 341
 342         return True;
 343 }
 344
 345
 346
 347 /* -------------------------------------------------------------------------- **
 348  * Functions...
 349  */
 350
 351 /* ************************************************************************** **
 352  * Initialize the static character test array.
 353  *
 354  *  Input:  none
 355  *
 356  *  Output: none
 357  *
 358  *  Notes:  This function changes (loads) the contents of the <chartest>
 359  *          array.  The scope of <chartest> is this file.
 360  *
 361  * ************************************************************************** **
 362  */
 363 static void init_chartest( void )
 364 {
 365         const char          *illegalchars = "*\\/?<>|\":";
 366         const unsigned char *s;
 367
 368         memset( (char *)chartest, '\0', 256 );
 369
 370         for( s = (const unsigned char *)illegalchars; *s; s++ )
 371                 chartest[*s] = ILLEGAL_MASK;
 372
 373         for( s = (const unsigned char *)basechars; *s; s++ )
 374                 chartest[*s] |= BASECHAR_MASK;
 375
 376         ct_initialized = True;
 377 }
 378
 379 /* ************************************************************************** **
 380  * Return True if the name *could be* a mangled name.
 381  *
 382  *  Input:  s - A path name - in UNIX pathname format.
 383  *
 384  *  Output: True if the name matches the pattern described below in the
 385  *          notes, else False.
 386  *
 387  *  Notes:  The input name is *not* tested for 8.3 compliance.  This must be
 388  *          done separately.  This function returns true if the name contains
 389  *          a magic character followed by excactly two characters from the
 390  *          basechars list (above), which in turn are followed either by the
 391  *          nul (end of string) byte or a dot (extension) or by a '/' (end of
 392  *          a directory name).
 393  *
 394  * ************************************************************************** **
 395  */
 396 static BOOL is_mangled(const char *s)
 397 {
 398         char *magic;
 399
 400         if( !ct_initialized )
 401                 init_chartest();
 402
 403         magic = strchr_m( s, magic_char );
 404         while( magic && magic[1] && magic[2] ) {         /* 3 chars, 1st is magic. */
 405                 if( ('.' == magic[3] || '/' == magic[3] || !(magic[3]))          /* Ends with '.' or nul or '/' ?  */
 406                                 && isbasechar( toupper(magic[1]) )           /* is 2nd char basechar?  */
 407                                 && isbasechar( toupper(magic[2]) ) )         /* is 3rd char basechar?  */
 408                         return( True );                           /* If all above, then true, */
 409                 magic = strchr_m( magic+1, magic_char );      /*    else seek next magic. */
 410         }
 411         return( False );
 412 }
 413
 414 /* ************************************************************************** **
 415  * Compare two cache keys and return a value indicating their ordinal
 416  * relationship.
 417  *
 418  *  Input:  ItemPtr - Pointer to a comparison key.  In this case, this will
 419  *                    be a mangled name string.
 420  *          NodePtr - Pointer to a node in the cache.  The node structure
 421  *                    will be followed in memory by a mangled name string.
 422  *
 423  *  Output: A signed integer, as follows:
 424  *            (x < 0)  <==> Key1 less than Key2
 425  *            (x == 0) <==> Key1 equals Key2
 426  *            (x > 0)  <==> Key1 greater than Key2
 427  *
 428  *  Notes:  This is a ubiqx-style comparison routine.  See ubi_BinTree for
 429  *          more info.
 430  *
 431  * ************************************************************************** **
 432  */
 433 static signed int cache_compare( ubi_btItemPtr ItemPtr, ubi_btNodePtr NodePtr )
 434 {
 435         char *Key1 = (char *)ItemPtr;
 436         char *Key2 = (char *)(((ubi_cacheEntryPtr)NodePtr) + 1);
 437
 438         return( StrCaseCmp( Key1, Key2 ) );
 439 }
 440
 441 /* ************************************************************************** **
 442  * Free a cache entry.
 443  *
 444  *  Input:  WarrenZevon - Pointer to the entry that is to be returned to
 445  *                        Nirvana.
 446  *  Output: none.
 447  *
 448  *  Notes:  This function gets around the possibility that the standard
 449  *          free() function may be implemented as a macro, or other evil
 450  *          subversions (oh, so much fun).
 451  *
 452  * ************************************************************************** **
 453  */
 454 static void cache_free_entry( ubi_trNodePtr WarrenZevon )
 455 {
 456         ZERO_STRUCTP(WarrenZevon);
 457         SAFE_FREE( WarrenZevon );
 458 }
 459
 460 /* ************************************************************************** **
 461  * Initializes or clears the mangled cache.
 462  *
 463  *  Input:  none.
 464  *  Output: none.
 465  *
 466  *  Notes:  There is a section below that is commented out.  It shows how
 467  *          one might use lp_ calls to set the maximum memory and entry size
 468  *          of the cache.  You might also want to remove the constants used
 469  *          in ubi_cacheInit() and replace them with lp_ calls.  If so, then
 470  *          the calls to ubi_cacheSetMax*() would be moved into the else
 471  *          clause.  Another option would be to pass in the max_entries and
 472  *          max_memory values as parameters.  crh 09-Apr-1998.
 473  *
 474  * ************************************************************************** **
 475  */
 476
 477 static void mangle_reset( void )
 478 {
 479         if( !mc_initialized ) {
 480                 (void)ubi_cacheInit( mangled_cache,
 481                                 cache_compare,
 482                                 cache_free_entry,
 483                                 MANGLED_CACHE_MAX_ENTRIES,
 484                                 MANGLED_CACHE_MAX_MEMORY );
 485                 mc_initialized = True;
 486         } else {
 487                 (void)ubi_cacheClear( mangled_cache );
 488         }
 489
 490         /*
 491         (void)ubi_cacheSetMaxEntries( mangled_cache, lp_mangled_cache_entries() );
 492         (void)ubi_cacheSetMaxMemory(  mangled_cache, lp_mangled_cache_memory() );
 493         */
 494 }
 495
 496 /* ************************************************************************** **
 497  * Add a mangled name into the cache.
 498  *
 499  *  Notes:  If the mangled cache has not been initialized, then the
 500  *          function will simply fail.  It could initialize the cache,
 501  *          but that's not the way it was done before I changed the
 502  *          cache mechanism, so I'm sticking with the old method.
 503  *
 504  *          If the extension of the raw name maps directly to the
 505  *          extension of the mangled name, then we'll store both names
 506  *          *without* extensions.  That way, we can provide consistent
 507  *          reverse mangling for all names that match.  The test here is
 508  *          a bit more careful than the one done in earlier versions of
 509  *          mangle.c:
 510  *
 511  *            - the extension must exist on the raw name,
 512  *            - it must be all lower case
 513  *            - it must match the mangled extension (to prove that no
 514  *              mangling occurred).
 515  *
 516  *  crh 07-Apr-1998
 517  *
 518  * ************************************************************************** **
 519  */
 520 static void cache_mangled_name( char *mangled_name, char *raw_name )
 521 {
 522         ubi_cacheEntryPtr new_entry;
 523         char             *s1;
 524         char             *s2;
 525         size_t               mangled_len;
 526         size_t               raw_len;
 527         size_t               i;
 528
 529         /* If the cache isn't initialized, give up. */
 530         if( !mc_initialized )
 531                 return;
 532
 533         /* Init the string lengths. */
 534         mangled_len = strlen( mangled_name );
 535         raw_len     = strlen( raw_name );
 536
 537         /* See if the extensions are unmangled.  If so, store the entry
 538          * without the extension, thus creating a "group" reverse map.
 539          */
 540         s1 = strrchr( mangled_name, '.' );
 541         if( s1 && (s2 = strrchr( raw_name, '.' )) ) {
 542                 i = 1;
 543                 while( s1[i] && (tolower( s1[i] ) == s2[i]) )
 544                         i++;
 545                 if( !s1[i] && !s2[i] ) {
 546                         mangled_len -= i;
 547                         raw_len     -= i;
 548                 }
 549         }
 550
 551         /* Allocate a new cache entry.  If the allocation fails, just return. */
 552         i = sizeof( ubi_cacheEntry ) + mangled_len + raw_len + 2;
 553         new_entry = malloc( i );
 554         if( !new_entry )
 555                 return;
 556
 557         /* Fill the new cache entry, and add it to the cache. */
 558         s1 = (char *)(new_entry + 1);
 559         s2 = (char *)&(s1[mangled_len + 1]);
 560         safe_strcpy( s1, mangled_name, mangled_len );
 561         safe_strcpy( s2, raw_name,     raw_len );
 562         ubi_cachePut( mangled_cache, i, new_entry, s1 );
 563 }
 564
 565 /* ************************************************************************** **
 566  * Check for a name on the mangled name stack
 567  *
 568  *  Input:  s - Input *and* output string buffer.
 569  *
 570  *  Output: True if the name was found in the cache, else False.
 571  *
 572  *  Notes:  If a reverse map is found, the function will overwrite the string
 573  *          space indicated by the input pointer <s>.  This is frightening.
 574  *          It should be rewritten to return NULL if the long name was not
 575  *          found, and a pointer to the long name if it was found.
 576  *
 577  * ************************************************************************** **
 578  */
 579
 580 static BOOL check_cache( char *s )
 581 {
 582         ubi_cacheEntryPtr FoundPtr;
 583         char             *ext_start = NULL;
 584         char             *found_name;
 585         char             *saved_ext = NULL;
 586
 587         /* If the cache isn't initialized, give up. */
 588         if( !mc_initialized )
 589                 return( False );
 590
 591         FoundPtr = ubi_cacheGet( mangled_cache, (ubi_trItemPtr)s );
 592
 593         /* If we didn't find the name *with* the extension, try without. */
 594         if( !FoundPtr ) {
 595                 ext_start = strrchr( s, '.' );
 596                 if( ext_start ) {
 597                         if((saved_ext = strdup(ext_start)) == NULL)
 598                                 return False;
 599
 600                         *ext_start = '\0';
 601                         FoundPtr = ubi_cacheGet( mangled_cache, (ubi_trItemPtr)s );
 602                         /*
 603                          * At this point s is the name without the
 604                          * extension. We re-add the extension if saved_ext
 605                          * is not null, before freeing saved_ext.
 606                          */
 607                 }
 608         }
 609
 610         /* Okay, if we haven't found it we're done. */
 611         if( !FoundPtr ) {
 612                 if(saved_ext) {
 613                         /* Replace the saved_ext as it was truncated. */
 614                         (void)pstrcat( s, saved_ext );
 615                         SAFE_FREE(saved_ext);
 616                 }
 617                 return( False );
 618         }
 619
 620         /* If we *did* find it, we need to copy it into the string buffer. */
 621         found_name = (char *)(FoundPtr + 1);
 622         found_name += (strlen( found_name ) + 1);
 623
 624         (void)pstrcpy( s, found_name );
 625         if( saved_ext ) {
 626                 /* Replace the saved_ext as it was truncated. */
 627                 (void)pstrcat( s, saved_ext );
 628                 SAFE_FREE(saved_ext);
 629         }
 630
 631         return( True );
 632 }
 633
 634 /*****************************************************************************
 635  * do the actual mangling to 8.3 format
 636  * the buffer must be able to hold 13 characters (including the null)
 637  *****************************************************************************
 638  */
 639 static void to_8_3(char *s)
 640 {
 641         int csum;
 642         char *p;
 643         char extension[4];
 644         char base[9];
 645         int baselen = 0;
 646         int extlen = 0;
 647
 648         extension[0] = 0;
 649         base[0] = 0;
 650
 651         p = strrchr(s,'.');
 652         if( p && (strlen(p+1) < (size_t)4) ) {
 653                 BOOL all_normal = ( strisnormal(p+1) ); /* XXXXXXXXX */
 654
 655                 if( all_normal && p[1] != 0 ) {
 656                         *p = 0;
 657                         csum = str_checksum( s );
 658                         *p = '.';
 659                 } else
 660                         csum = str_checksum(s);
 661         } else
 662                 csum = str_checksum(s);
 663
 664         strupper_m( s );
 665
 666         if( p ) {
 667                 if( p == s )
 668                         safe_strcpy( extension, "___", 3 );
 669                 else {
 670                         *p++ = 0;
 671                         while( *p && extlen < 3 ) {
 672                                 if ( *p != '.') {
 673                                         extension[extlen++] = p[0];
 674                                 }
 675                                 p++;
 676                         }
 677                         extension[extlen] = 0;
 678                 }
 679         }
 680
 681         p = s;
 682
 683         while( *p && baselen < 5 ) {
 684                 if (*p != '.') {
 685                         base[baselen++] = p[0];
 686                 }
 687                 p++;
 688         }
 689         base[baselen] = 0;
 690
 691         csum = csum % (MANGLE_BASE*MANGLE_BASE);
 692
 693         (void)slprintf(s, 12, "%s%c%c%c",
 694                 base, magic_char, mangle( csum/MANGLE_BASE ), mangle( csum ) );
 695
 696         if( *extension ) {
 697                 (void)pstrcat( s, "." );
 698                 (void)pstrcat( s, extension );
 699         }
 700 }
 701
 702 /*****************************************************************************
 703  * Convert a filename to DOS format.  Return True if successful.
 704  *
 705  *  Input:  OutName - Source *and* destination buffer.
 706  *
 707  *                    NOTE that OutName must point to a memory space that
 708  *                    is at least 13 bytes in size!
 709  *
 710  *          need83  - If False, name mangling will be skipped unless the
 711  *                    name contains illegal characters.  Mapping will still
 712  *                    be done, if appropriate.  This is probably used to
 713  *                    signal that a client does not require name mangling,
 714  *                    thus skipping the name mangling even on shares which
 715  *                    have name-mangling turned on.
 716  *          cache83 - If False, the mangled name cache will not be updated.
 717  *                    This is usually used to prevent that we overwrite
 718  *                    a conflicting cache entry prematurely, i.e. before
 719  *                    we know whether the client is really interested in the
 720  *                    current name.  (See PR#13758).  UKD.
 721  *
 722  *  Output: Returns False only if the name wanted mangling but the share does
 723  *          not have name mangling turned on.
 724  *
 725  * ****************************************************************************
 726  */
 727
 728 static void name_map(char *OutName, BOOL need83, BOOL cache83)
 729 {
 730         smb_ucs2_t *OutName_ucs2;
 731         DEBUG(5,("name_map( %s, need83 = %s, cache83 = %s)\n", OutName,
 732                  need83 ? "True" : "False", cache83 ? "True" : "False"));
 733
 734         if (push_ucs2_allocate(&OutName_ucs2, OutName) == (size_t)-1) {
 735                 DEBUG(0, ("push_ucs2_allocate failed!\n"));
 736                 return;
 737         }
 738
 739         if( !need83 && !NT_STATUS_IS_OK(is_valid_name(OutName_ucs2, False)))
 740                 need83 = True;
 741
 742         /* check if it's already in 8.3 format */
 743         if (need83 && !NT_STATUS_IS_OK(is_8_3_w(OutName_ucs2, False))) {
 744                 char *tmp = NULL;
 745
 746                 /* mangle it into 8.3 */
 747                 if (cache83)
 748                         tmp = strdup(OutName);
 749
 750                 to_8_3(OutName);
 751
 752                 if(tmp != NULL) {
 753                         cache_mangled_name(OutName, tmp);
 754                         SAFE_FREE(tmp);
 755                 }
 756         }
 757
 758         DEBUG(5,("name_map() ==> [%s]\n", OutName));
 759         SAFE_FREE(OutName_ucs2);
 760 }
 761
 762 /*
 763   the following provides the abstraction layer to make it easier
 764   to drop in an alternative mangling implementation
 765 */
 766 static struct mangle_fns mangle_fns = {
 767         is_mangled,
 768         is_8_3,
 769         mangle_reset,
 770         check_cache,
 771         name_map
 772 };
 773
 774 /* return the methods for this mangling implementation */
 775 struct mangle_fns *mangle_hash_init(void)
 776 {
 777         mangle_reset();
 778
 779         return &mangle_fns;
 780 }