source/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         size_t size;
 317
 318         if (!fname || !*fname)
 319                 return False;
 320         if ((f = strrchr(fname, '/')) == NULL)
 321                 f = fname;
 322         else
 323                 f++;
 324
 325         if (strlen(f) > 12)
 326                 return False;
 327
 328         size = push_ucs2_allocate(&ucs2name, f);
 329         if (size == (size_t)-1) {
 330                 DEBUG(0,("is_8_3: internal error push_ucs2_allocate() failed!\n"));
 331                 goto done;
 332         }
 333
 334         ret = is_8_3_w(ucs2name, allow_wildcards);
 335
 336 done:
 337         SAFE_FREE(ucs2name);
 338
 339         if (!NT_STATUS_IS_OK(ret)) {
 340                 return False;
 341         }
 342
 343         return True;
 344 }
 345
 346
 347
 348 /* -------------------------------------------------------------------------- **
 349  * Functions...
 350  */
 351
 352 /* ************************************************************************** **
 353  * Initialize the static character test array.
 354  *
 355  *  Input:  none
 356  *
 357  *  Output: none
 358  *
 359  *  Notes:  This function changes (loads) the contents of the <chartest>
 360  *          array.  The scope of <chartest> is this file.
 361  *
 362  * ************************************************************************** **
 363  */
 364 static void init_chartest( void )
 365 {
 366         const char          *illegalchars = "*\\/?<>|\":";
 367         const unsigned char *s;
 368
 369         memset( (char *)chartest, '\0', 256 );
 370
 371         for( s = (const unsigned char *)illegalchars; *s; s++ )
 372                 chartest[*s] = ILLEGAL_MASK;
 373
 374         for( s = (const unsigned char *)basechars; *s; s++ )
 375                 chartest[*s] |= BASECHAR_MASK;
 376
 377         ct_initialized = True;
 378 }
 379
 380 /* ************************************************************************** **
 381  * Return True if the name *could be* a mangled name.
 382  *
 383  *  Input:  s - A path name - in UNIX pathname format.
 384  *
 385  *  Output: True if the name matches the pattern described below in the
 386  *          notes, else False.
 387  *
 388  *  Notes:  The input name is *not* tested for 8.3 compliance.  This must be
 389  *          done separately.  This function returns true if the name contains
 390  *          a magic character followed by excactly two characters from the
 391  *          basechars list (above), which in turn are followed either by the
 392  *          nul (end of string) byte or a dot (extension) or by a '/' (end of
 393  *          a directory name).
 394  *
 395  * ************************************************************************** **
 396  */
 397 static BOOL is_mangled(const char *s)
 398 {
 399         char *magic;
 400
 401         if( !ct_initialized )
 402                 init_chartest();
 403
 404         magic = strchr_m( s, magic_char );
 405         while( magic && magic[1] && magic[2] ) {         /* 3 chars, 1st is magic. */
 406                 if( ('.' == magic[3] || '/' == magic[3] || !(magic[3]))          /* Ends with '.' or nul or '/' ?  */
 407                                 && isbasechar( toupper(magic[1]) )           /* is 2nd char basechar?  */
 408                                 && isbasechar( toupper(magic[2]) ) )         /* is 3rd char basechar?  */
 409                         return( True );                           /* If all above, then true, */
 410                 magic = strchr_m( magic+1, magic_char );      /*    else seek next magic. */
 411         }
 412         return( False );
 413 }
 414
 415 /* ************************************************************************** **
 416  * Compare two cache keys and return a value indicating their ordinal
 417  * relationship.
 418  *
 419  *  Input:  ItemPtr - Pointer to a comparison key.  In this case, this will
 420  *                    be a mangled name string.
 421  *          NodePtr - Pointer to a node in the cache.  The node structure
 422  *                    will be followed in memory by a mangled name string.
 423  *
 424  *  Output: A signed integer, as follows:
 425  *            (x < 0)  <==> Key1 less than Key2
 426  *            (x == 0) <==> Key1 equals Key2
 427  *            (x > 0)  <==> Key1 greater than Key2
 428  *
 429  *  Notes:  This is a ubiqx-style comparison routine.  See ubi_BinTree for
 430  *          more info.
 431  *
 432  * ************************************************************************** **
 433  */
 434 static signed int cache_compare( ubi_btItemPtr ItemPtr, ubi_btNodePtr NodePtr )
 435 {
 436         char *Key1 = (char *)ItemPtr;
 437         char *Key2 = (char *)(((ubi_cacheEntryPtr)NodePtr) + 1);
 438
 439         return( StrCaseCmp( Key1, Key2 ) );
 440 }
 441
 442 /* ************************************************************************** **
 443  * Free a cache entry.
 444  *
 445  *  Input:  WarrenZevon - Pointer to the entry that is to be returned to
 446  *                        Nirvana.
 447  *  Output: none.
 448  *
 449  *  Notes:  This function gets around the possibility that the standard
 450  *          free() function may be implemented as a macro, or other evil
 451  *          subversions (oh, so much fun).
 452  *
 453  * ************************************************************************** **
 454  */
 455 static void cache_free_entry( ubi_trNodePtr WarrenZevon )
 456 {
 457         ZERO_STRUCTP(WarrenZevon);
 458         SAFE_FREE( WarrenZevon );
 459 }
 460
 461 /* ************************************************************************** **
 462  * Initializes or clears the mangled cache.
 463  *
 464  *  Input:  none.
 465  *  Output: none.
 466  *
 467  *  Notes:  There is a section below that is commented out.  It shows how
 468  *          one might use lp_ calls to set the maximum memory and entry size
 469  *          of the cache.  You might also want to remove the constants used
 470  *          in ubi_cacheInit() and replace them with lp_ calls.  If so, then
 471  *          the calls to ubi_cacheSetMax*() would be moved into the else
 472  *          clause.  Another option would be to pass in the max_entries and
 473  *          max_memory values as parameters.  crh 09-Apr-1998.
 474  *
 475  * ************************************************************************** **
 476  */
 477
 478 static void mangle_reset( void )
 479 {
 480         if( !mc_initialized ) {
 481                 (void)ubi_cacheInit( mangled_cache,
 482                                 cache_compare,
 483                                 cache_free_entry,
 484                                 MANGLED_CACHE_MAX_ENTRIES,
 485                                 MANGLED_CACHE_MAX_MEMORY );
 486                 mc_initialized = True;
 487         } else {
 488                 (void)ubi_cacheClear( mangled_cache );
 489         }
 490
 491         /*
 492         (void)ubi_cacheSetMaxEntries( mangled_cache, lp_mangled_cache_entries() );
 493         (void)ubi_cacheSetMaxMemory(  mangled_cache, lp_mangled_cache_memory() );
 494         */
 495 }
 496
 497 /* ************************************************************************** **
 498  * Add a mangled name into the cache.
 499  *
 500  *  Notes:  If the mangled cache has not been initialized, then the
 501  *          function will simply fail.  It could initialize the cache,
 502  *          but that's not the way it was done before I changed the
 503  *          cache mechanism, so I'm sticking with the old method.
 504  *
 505  *          If the extension of the raw name maps directly to the
 506  *          extension of the mangled name, then we'll store both names
 507  *          *without* extensions.  That way, we can provide consistent
 508  *          reverse mangling for all names that match.  The test here is
 509  *          a bit more careful than the one done in earlier versions of
 510  *          mangle.c:
 511  *
 512  *            - the extension must exist on the raw name,
 513  *            - it must be all lower case
 514  *            - it must match the mangled extension (to prove that no
 515  *              mangling occurred).
 516  *
 517  *  crh 07-Apr-1998
 518  *
 519  * ************************************************************************** **
 520  */
 521 static void cache_mangled_name( char *mangled_name, char *raw_name )
 522 {
 523         ubi_cacheEntryPtr new_entry;
 524         char             *s1;
 525         char             *s2;
 526         size_t               mangled_len;
 527         size_t               raw_len;
 528         size_t               i;
 529
 530         /* If the cache isn't initialized, give up. */
 531         if( !mc_initialized )
 532                 return;
 533
 534         /* Init the string lengths. */
 535         mangled_len = strlen( mangled_name );
 536         raw_len     = strlen( raw_name );
 537
 538         /* See if the extensions are unmangled.  If so, store the entry
 539          * without the extension, thus creating a "group" reverse map.
 540          */
 541         s1 = strrchr( mangled_name, '.' );
 542         if( s1 && (s2 = strrchr( raw_name, '.' )) ) {
 543                 i = 1;
 544                 while( s1[i] && (tolower( s1[i] ) == s2[i]) )
 545                         i++;
 546                 if( !s1[i] && !s2[i] ) {
 547                         mangled_len -= i;
 548                         raw_len     -= i;
 549                 }
 550         }
 551
 552         /* Allocate a new cache entry.  If the allocation fails, just return. */
 553         i = sizeof( ubi_cacheEntry ) + mangled_len + raw_len + 2;
 554         new_entry = malloc( i );
 555         if( !new_entry )
 556                 return;
 557
 558         /* Fill the new cache entry, and add it to the cache. */
 559         s1 = (char *)(new_entry + 1);
 560         s2 = (char *)&(s1[mangled_len + 1]);
 561         safe_strcpy( s1, mangled_name, mangled_len );
 562         safe_strcpy( s2, raw_name,     raw_len );
 563         ubi_cachePut( mangled_cache, i, new_entry, s1 );
 564 }
 565
 566 /* ************************************************************************** **
 567  * Check for a name on the mangled name stack
 568  *
 569  *  Input:  s - Input *and* output string buffer.
 570  *
 571  *  Output: True if the name was found in the cache, else False.
 572  *
 573  *  Notes:  If a reverse map is found, the function will overwrite the string
 574  *          space indicated by the input pointer <s>.  This is frightening.
 575  *          It should be rewritten to return NULL if the long name was not
 576  *          found, and a pointer to the long name if it was found.
 577  *
 578  * ************************************************************************** **
 579  */
 580
 581 static BOOL check_cache( char *s )
 582 {
 583         ubi_cacheEntryPtr FoundPtr;
 584         char             *ext_start = NULL;
 585         char             *found_name;
 586         char             *saved_ext = NULL;
 587
 588         /* If the cache isn't initialized, give up. */
 589         if( !mc_initialized )
 590                 return( False );
 591
 592         FoundPtr = ubi_cacheGet( mangled_cache, (ubi_trItemPtr)s );
 593
 594         /* If we didn't find the name *with* the extension, try without. */
 595         if( !FoundPtr ) {
 596                 ext_start = strrchr( s, '.' );
 597                 if( ext_start ) {
 598                         if((saved_ext = strdup(ext_start)) == NULL)
 599                                 return False;
 600
 601                         *ext_start = '\0';
 602                         FoundPtr = ubi_cacheGet( mangled_cache, (ubi_trItemPtr)s );
 603                         /*
 604                          * At this point s is the name without the
 605                          * extension. We re-add the extension if saved_ext
 606                          * is not null, before freeing saved_ext.
 607                          */
 608                 }
 609         }
 610
 611         /* Okay, if we haven't found it we're done. */
 612         if( !FoundPtr ) {
 613                 if(saved_ext) {
 614                         /* Replace the saved_ext as it was truncated. */
 615                         (void)pstrcat( s, saved_ext );
 616                         SAFE_FREE(saved_ext);
 617                 }
 618                 return( False );
 619         }
 620
 621         /* If we *did* find it, we need to copy it into the string buffer. */
 622         found_name = (char *)(FoundPtr + 1);
 623         found_name += (strlen( found_name ) + 1);
 624
 625         (void)pstrcpy( s, found_name );
 626         if( saved_ext ) {
 627                 /* Replace the saved_ext as it was truncated. */
 628                 (void)pstrcat( s, saved_ext );
 629                 SAFE_FREE(saved_ext);
 630         }
 631
 632         return( True );
 633 }
 634
 635 /*****************************************************************************
 636  * do the actual mangling to 8.3 format
 637  * the buffer must be able to hold 13 characters (including the null)
 638  *****************************************************************************
 639  */
 640 static void to_8_3(char *s)
 641 {
 642         int csum;
 643         char *p;
 644         char extension[4];
 645         char base[9];
 646         int baselen = 0;
 647         int extlen = 0;
 648
 649         extension[0] = 0;
 650         base[0] = 0;
 651
 652         p = strrchr(s,'.');
 653         if( p && (strlen(p+1) < (size_t)4) ) {
 654                 BOOL all_normal = ( strisnormal(p+1) ); /* XXXXXXXXX */
 655
 656                 if( all_normal && p[1] != 0 ) {
 657                         *p = 0;
 658                         csum = str_checksum( s );
 659                         *p = '.';
 660                 } else
 661                         csum = str_checksum(s);
 662         } else
 663                 csum = str_checksum(s);
 664
 665         strupper_m( s );
 666
 667         if( p ) {
 668                 if( p == s )
 669                         safe_strcpy( extension, "___", 3 );
 670                 else {
 671                         *p++ = 0;
 672                         while( *p && extlen < 3 ) {
 673                                 if ( *p != '.') {
 674                                         extension[extlen++] = p[0];
 675                                 }
 676                                 p++;
 677                         }
 678                         extension[extlen] = 0;
 679                 }
 680         }
 681
 682         p = s;
 683
 684         while( *p && baselen < 5 ) {
 685                 if (*p != '.') {
 686                         base[baselen++] = p[0];
 687                 }
 688                 p++;
 689         }
 690         base[baselen] = 0;
 691
 692         csum = csum % (MANGLE_BASE*MANGLE_BASE);
 693
 694         (void)slprintf(s, 12, "%s%c%c%c",
 695                 base, magic_char, mangle( csum/MANGLE_BASE ), mangle( csum ) );
 696
 697         if( *extension ) {
 698                 (void)pstrcat( s, "." );
 699                 (void)pstrcat( s, extension );
 700         }
 701 }
 702
 703 /*****************************************************************************
 704  * Convert a filename to DOS format.  Return True if successful.
 705  *
 706  *  Input:  OutName - Source *and* destination buffer.
 707  *
 708  *                    NOTE that OutName must point to a memory space that
 709  *                    is at least 13 bytes in size!
 710  *
 711  *          need83  - If False, name mangling will be skipped unless the
 712  *                    name contains illegal characters.  Mapping will still
 713  *                    be done, if appropriate.  This is probably used to
 714  *                    signal that a client does not require name mangling,
 715  *                    thus skipping the name mangling even on shares which
 716  *                    have name-mangling turned on.
 717  *          cache83 - If False, the mangled name cache will not be updated.
 718  *                    This is usually used to prevent that we overwrite
 719  *                    a conflicting cache entry prematurely, i.e. before
 720  *                    we know whether the client is really interested in the
 721  *                    current name.  (See PR#13758).  UKD.
 722  *
 723  *  Output: Returns False only if the name wanted mangling but the share does
 724  *          not have name mangling turned on.
 725  *
 726  * ****************************************************************************
 727  */
 728
 729 static void name_map(char *OutName, BOOL need83, BOOL cache83)
 730 {
 731         smb_ucs2_t *OutName_ucs2;
 732         DEBUG(5,("name_map( %s, need83 = %s, cache83 = %s)\n", OutName,
 733                  need83 ? "True" : "False", cache83 ? "True" : "False"));
 734
 735         if (push_ucs2_allocate(&OutName_ucs2, OutName) == (size_t)-1) {
 736                 DEBUG(0, ("push_ucs2_allocate failed!\n"));
 737                 return;
 738         }
 739
 740         if( !need83 && !NT_STATUS_IS_OK(is_valid_name(OutName_ucs2, False)))
 741                 need83 = True;
 742
 743         /* check if it's already in 8.3 format */
 744         if (need83 && !NT_STATUS_IS_OK(is_8_3_w(OutName_ucs2, False))) {
 745                 char *tmp = NULL;
 746
 747                 /* mangle it into 8.3 */
 748                 if (cache83)
 749                         tmp = strdup(OutName);
 750
 751                 to_8_3(OutName);
 752
 753                 if(tmp != NULL) {
 754                         cache_mangled_name(OutName, tmp);
 755                         SAFE_FREE(tmp);
 756                 }
 757         }
 758
 759         DEBUG(5,("name_map() ==> [%s]\n", OutName));
 760         SAFE_FREE(OutName_ucs2);
 761 }
 762
 763 /*
 764   the following provides the abstraction layer to make it easier
 765   to drop in an alternative mangling implementation
 766 */
 767 static struct mangle_fns mangle_fns = {
 768         is_mangled,
 769         is_8_3,
 770         mangle_reset,
 771         check_cache,
 772         name_map
 773 };
 774
 775 /* return the methods for this mangling implementation */
 776 struct mangle_fns *mangle_hash_init(void)
 777 {
 778         mangle_reset();
 779
 780         return &mangle_fns;
 781 }