LCOV - code coverage report
Current view: top level - source3/smbd - mangle_hash2.c (source / functions) Hit Total Coverage
Test: coverage report for master 2b515b7d Lines: 210 237 88.6 %
Date: 2024-02-28 12:06:22 Functions: 19 20 95.0 %

          Line data    Source code
       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 algorithm 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             : #define FNV1_PRIME 0x01000193
      93             : /*the following number is a fnv1 of the string: idra@samba.org 2002 */
      94             : #define FNV1_INIT  0xa6b93095
      95             : 
      96             : #define FLAG_CHECK(c, flag) (char_flags[(unsigned char)(c)] & (flag))
      97             : 
      98             : /* these are the characters we use in the 8.3 hash. Must be 36 chars long */
      99             : static const char basechars[36] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     100             : #define base_forward(v) basechars[v]
     101             : 
     102             : /* the list of reserved dos names - all of these are illegal */
     103             : static const char * const reserved_names[] =
     104             : { "AUX", "CON",
     105             :   "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9",
     106             :   "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9",
     107             :   "NUL", "PRN", NULL };
     108             : 
     109             : #define DYNAMIC_MANGLE_TABLES 0
     110             : 
     111             : #if DYNAMIC_MANGLE_TABLES
     112             : 
     113             : /* these tables are used to provide fast tests for characters */
     114             : static unsigned char char_flags[256];
     115             : static unsigned char base_reverse[256];
     116             : 
     117             : /* initialise the flags table
     118             : 
     119             :   we allow only a very restricted set of characters as 'ascii' in this
     120             :   mangling backend. This isn't a significant problem as modern clients
     121             :   use the 'long' filenames anyway, and those don't have these
     122             :   restrictions.
     123             : */
     124             : static void init_tables(void)
     125             : {
     126             :         int i;
     127             : 
     128             :         memset(char_flags, 0, sizeof(char_flags));
     129             : 
     130             :         for (i=1;i<128;i++) {
     131             :                 if (i <= 0x1f) {
     132             :                         /* Control characters. */
     133             :                         char_flags[i] |= FLAG_ILLEGAL;
     134             :                 }
     135             : 
     136             :                 if ((i >= '0' && i <= '9') ||
     137             :                     (i >= 'a' && i <= 'z') ||
     138             :                     (i >= 'A' && i <= 'Z')) {
     139             :                         char_flags[i] |=  (FLAG_ASCII | FLAG_BASECHAR);
     140             :                 }
     141             :                 if (strchr("_-$~", i)) {
     142             :                         char_flags[i] |= FLAG_ASCII;
     143             :                 }
     144             : 
     145             :                 if (strchr("*\\/?<>|\":", i)) {
     146             :                         char_flags[i] |= FLAG_ILLEGAL;
     147             :                 }
     148             : 
     149             :                 if (strchr("*?\"<>", i)) {
     150             :                         char_flags[i] |= FLAG_WILDCARD;
     151             :                 }
     152             :         }
     153             : 
     154             :         memset(base_reverse, 0, sizeof(base_reverse));
     155             :         for (i=0;i<36;i++) {
     156             :                 base_reverse[(unsigned char)base_forward(i)] = i;
     157             :         }
     158             : 
     159             :         /* fill in the reserved names flags. These are used as a very
     160             :            fast filter for finding possible DOS reserved filenames */
     161             :         for (i=0; reserved_names[i]; i++) {
     162             :                 unsigned char c1, c2, c3, c4;
     163             : 
     164             :                 c1 = (unsigned char)reserved_names[i][0];
     165             :                 c2 = (unsigned char)reserved_names[i][1];
     166             :                 c3 = (unsigned char)reserved_names[i][2];
     167             :                 c4 = (unsigned char)reserved_names[i][3];
     168             : 
     169             :                 char_flags[c1] |= FLAG_POSSIBLE1;
     170             :                 char_flags[c2] |= FLAG_POSSIBLE2;
     171             :                 char_flags[c3] |= FLAG_POSSIBLE3;
     172             :                 char_flags[c4] |= FLAG_POSSIBLE4;
     173             :                 char_flags[tolower_m(c1)] |= FLAG_POSSIBLE1;
     174             :                 char_flags[tolower_m(c2)] |= FLAG_POSSIBLE2;
     175             :                 char_flags[tolower_m(c3)] |= FLAG_POSSIBLE3;
     176             :                 char_flags[tolower_m(c4)] |= FLAG_POSSIBLE4;
     177             : 
     178             :                 char_flags[(unsigned char)'.'] |= FLAG_POSSIBLE4;
     179             :         }
     180             : 
     181             : #if 0
     182             :         DEBUG(10, ("char_flags\n"));
     183             :         dump_data(10, char_flags, sizeof(char_flags));
     184             : 
     185             :         DEBUG(10, ("base_reverse\n"));
     186             :         dump_data(10, base_reverse, sizeof(base_reverse));
     187             : #endif
     188             : }
     189             : 
     190             : #else /* DYNAMIC_MANGLE_TABLES */
     191             : 
     192             : /*
     193             :  * These tables were initialized by a single run of the above
     194             :  * init_tables() routine, dumping the tables and a simple emacs macro.
     195             :  *
     196             :  * Technically we could leave out the 0's at the end of the array
     197             :  * initializers, but I'll leave it in: less surprise.
     198             :  */
     199             : 
     200             : static const uint8_t char_flags[256] = {
     201             :         0x80, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
     202             :         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
     203             :         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
     204             :         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
     205             :         0x00, 0x00, 0x0C, 0x00, 0x02, 0x00, 0x00, 0x00,
     206             :         0x00, 0x00, 0x0C, 0x00, 0x00, 0x02, 0x80, 0x04,
     207             :         0x03, 0x83, 0x83, 0x83, 0x83, 0x03, 0x03, 0x03,
     208             :         0x03, 0x03, 0x04, 0x00, 0x0C, 0x00, 0x0C, 0x0C,
     209             :         0x00, 0x13, 0x03, 0x53, 0x03, 0x03, 0x03, 0x03,
     210             :         0x03, 0x03, 0x03, 0x83, 0x53, 0x43, 0x53, 0x23,
     211             :         0x33, 0x03, 0x23, 0x03, 0x43, 0x23, 0x03, 0x03,
     212             :         0x43, 0x03, 0x03, 0x00, 0x04, 0x00, 0x00, 0x02,
     213             :         0x00, 0x13, 0x03, 0x53, 0x03, 0x03, 0x03, 0x03,
     214             :         0x03, 0x03, 0x03, 0x83, 0x53, 0x43, 0x53, 0x23,
     215             :         0x33, 0x03, 0x23, 0x03, 0x43, 0x23, 0x03, 0x03,
     216             :         0x43, 0x03, 0x03, 0x00, 0x04, 0x00, 0x02, 0x00,
     217             :         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     218             :         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     219             :         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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             : };
     234             : 
     235             : static const uint8_t base_reverse[256] = {
     236             :         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     237             :         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     238             :         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     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, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
     243             :         0x08, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     244             :         0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
     245             :         0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
     246             :         0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
     247             :         0x21, 0x22, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00,
     248             :         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     249             :         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     250             :         0x00, 0x00, 0x00, 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             : };
     269             : 
     270             : #endif /* DYNAMIC_MANGLE_TABLES */
     271             : 
     272             : /* 
     273             :    hash a string of the specified length. The string does not need to be
     274             :    null terminated 
     275             : 
     276             :    this hash needs to be fast with a low collision rate (what hash doesn't?)
     277             : */
     278       52659 : static unsigned int mangle_hash(const char *key, unsigned int length)
     279             : {
     280         178 :         unsigned int value;
     281         178 :         unsigned int   i;
     282         178 :         fstring str;
     283             : 
     284             :         /* we have to uppercase here to ensure that the mangled name
     285             :            doesn't depend on the case of the long name. Note that this
     286             :            is the only place where we need to use a multi-byte string
     287             :            function */
     288       52659 :         length = MIN(length,sizeof(fstring)-1);
     289       52659 :         strncpy(str, key, length);
     290       52659 :         str[length] = 0;
     291       52659 :         (void)strupper_m(str);
     292             : 
     293             :         /* the length of a multi-byte string can change after a strupper_m */
     294       52659 :         length = strlen(str);
     295             : 
     296             :         /* Set the initial value from the key size. */
     297     1415923 :         for (value = FNV1_INIT, i=0; i < length; i++) {
     298     1363264 :                 value *= (unsigned int)FNV1_PRIME;
     299     1363264 :                 value ^= (unsigned int)(str[i]);
     300             :         }
     301             : 
     302             :         /* note that we force it to a 31 bit hash, to keep within the limits
     303             :            of the 36^6 mangle space */
     304       52659 :         return value & ~0x80000000;  
     305             : }
     306             : 
     307             : /*
     308             :   insert an entry into the prefix cache. The string might not be null
     309             :   terminated */
     310       51682 : static void cache_insert(const char *prefix, int length, unsigned int hash)
     311             : {
     312       51682 :         char *str = SMB_STRNDUP(prefix, length);
     313             : 
     314       51682 :         if (str == NULL) {
     315           0 :                 return;
     316             :         }
     317             : 
     318       51682 :         memcache_add(smbd_memcache(), MANGLE_HASH2_CACHE,
     319             :                      data_blob_const(&hash, sizeof(hash)),
     320       51682 :                      data_blob_const(str, length+1));
     321       51682 :         SAFE_FREE(str);
     322             : }
     323             : 
     324             : /*
     325             :   lookup an entry in the prefix cache. Return NULL if not found.
     326             : */
     327         225 : static char *cache_lookup(TALLOC_CTX *mem_ctx, unsigned int hash)
     328             : {
     329           0 :         DATA_BLOB value;
     330             : 
     331         225 :         if (!memcache_lookup(smbd_memcache(), MANGLE_HASH2_CACHE,
     332             :                              data_blob_const(&hash, sizeof(hash)), &value)) {
     333          48 :                 return NULL;
     334             :         }
     335             : 
     336         177 :         SMB_ASSERT((value.length > 0)
     337             :                    && (value.data[value.length-1] == '\0'));
     338             : 
     339         177 :         return talloc_strdup(mem_ctx, (char *)value.data);
     340             : }
     341             : 
     342             : 
     343             : /* 
     344             :    determine if a string is possibly in a mangled format, ignoring
     345             :    case 
     346             : 
     347             :    In this algorithm, mangled names use only pure ascii characters (no
     348             :    multi-byte) so we can avoid doing a UCS2 conversion 
     349             :  */
     350      570081 : static bool is_mangled_component(const char *name, size_t len)
     351             : {
     352        1759 :         unsigned int i;
     353             : 
     354      570081 :         M_DEBUG(10,("is_mangled_component %s (len %lu) ?\n", name, (unsigned long)len));
     355             : 
     356             :         /* check the length */
     357      570081 :         if (len > 12 || len < 8)
     358      376302 :                 return False;
     359             : 
     360             :         /* the best distinguishing characteristic is the ~ */
     361      192788 :         if (name[6] != '~')
     362      191564 :                 return False;
     363             : 
     364             :         /* check extension */
     365         456 :         if (len > 8) {
     366          56 :                 if (name[8] != '.')
     367           2 :                         return False;
     368         198 :                 for (i=9; name[i] && i < len; i++) {
     369         144 :                         if (! FLAG_CHECK(name[i], FLAG_ASCII)) {
     370           0 :                                 return False;
     371             :                         }
     372             :                 }
     373             :         }
     374             :         
     375             :         /* check lead characters */
     376         908 :         for (i=0;i<mangle_prefix;i++) {
     377         454 :                 if (! FLAG_CHECK(name[i], FLAG_ASCII)) {
     378           0 :                         return False;
     379             :                 }
     380             :         }
     381             :         
     382             :         /* check rest of hash */
     383         454 :         if (! FLAG_CHECK(name[7], FLAG_BASECHAR)) {
     384           0 :                 return False;
     385             :         }
     386        2724 :         for (i=mangle_prefix;i<6;i++) {
     387        2270 :                 if (! FLAG_CHECK(name[i], FLAG_BASECHAR)) {
     388           0 :                         return False;
     389             :                 }
     390             :         }
     391             : 
     392         454 :         M_DEBUG(10,("is_mangled_component %s (len %lu) -> yes\n", name, (unsigned long)len));
     393             : 
     394         454 :         return True;
     395             : }
     396             : 
     397             : 
     398             : 
     399             : /* 
     400             :    determine if a string is possibly in a mangled format, ignoring
     401             :    case 
     402             : 
     403             :    In this algorithm, mangled names use only pure ascii characters (no
     404             :    multi-byte) so we can avoid doing a UCS2 conversion 
     405             : 
     406             :    NOTE! This interface must be able to handle a path with unix
     407             :    directory separators. It should return true if any component is
     408             :    mangled
     409             :  */
     410      570081 : static bool is_mangled(const char *name, const struct share_params *parm)
     411             : {
     412        1759 :         const char *p;
     413        1759 :         const char *s;
     414             : 
     415      570081 :         M_DEBUG(10,("is_mangled %s ?\n", name));
     416             : 
     417      570081 :         for (s=name; (p=strchr(s, '/')); s=p+1) {
     418           0 :                 if (is_mangled_component(s, PTR_DIFF(p, s))) {
     419           0 :                         return True;
     420             :                 }
     421             :         }
     422             :         
     423             :         /* and the last part ... */
     424      570081 :         return is_mangled_component(s,strlen(s));
     425             : }
     426             : 
     427             : 
     428             : /* 
     429             :    see if a filename is an allowable 8.3 name to return to the client.
     430             :    Note this is not testing if this is a valid Samba mangled name, so
     431             :    the rules are different for is_mangled.
     432             : 
     433             :    we are only going to allow ascii characters in 8.3 names, as this
     434             :    simplifies things greatly (it means that we know the string won't
     435             :    get larger when converted from UNIX to DOS formats)
     436             : */
     437             : 
     438             : static const char force_shortname_chars[] = " +,[];=";
     439             : 
     440      569378 : static bool is_8_3(const char *name, bool check_case, bool allow_wildcards, const struct share_params *p)
     441             : {
     442        1275 :         int len, i;
     443        1275 :         char *dot_p;
     444             : 
     445             :         /* as a special case, the names '.' and '..' are allowable 8.3 names */
     446      569378 :         if (ISDOT(name) || (ISDOTDOT(name))) {
     447       29646 :                 return true;
     448             :         }
     449             : 
     450             :         /* the simplest test is on the overall length of the
     451             :          filename. Note that we deliberately use the ascii string
     452             :          length (not the multi-byte one) as it is faster, and gives us
     453             :          the result we need in this case. Using strlen_m would not
     454             :          only be slower, it would be incorrect */
     455      539640 :         len = strlen(name);
     456      539640 :         if (len > 12)
     457       97502 :                 return False;
     458             : 
     459             :         /* find the '.'. Note that once again we use the non-multibyte
     460             :            function */
     461      441640 :         dot_p = strchr(name, '.');
     462             : 
     463      441640 :         if (!dot_p) {
     464             :                 /* if the name doesn't contain a '.' then its length
     465             :                    must be less than 8 */
     466      348003 :                 if (len > 8) {
     467       17212 :                         return False;
     468             :                 }
     469             :         } else {
     470         524 :                 int prefix_len, suffix_len;
     471             : 
     472             :                 /* if it does contain a dot then the prefix must be <=
     473             :                    8 and the suffix <= 3 in length */
     474       93637 :                 prefix_len = PTR_DIFF(dot_p, name);
     475       93637 :                 suffix_len = len - (prefix_len+1);
     476             : 
     477       93637 :                 if (prefix_len > 8 || suffix_len > 3 || suffix_len == 0) {
     478        4651 :                         return False;
     479             :                 }
     480             : 
     481             :                 /* a 8.3 name cannot contain more than 1 '.' */
     482       88689 :                 if (strchr(dot_p+1, '.')) {
     483           0 :                         return False;
     484             :                 }
     485             :         }
     486             : 
     487             :         /* the length are all OK. Now check to see if the characters themselves are OK */
     488     3233152 :         for (i=0; name[i]; i++) {
     489     2822040 :                 if (FLAG_CHECK(name[i], FLAG_ILLEGAL)) {
     490        7039 :                         return false;
     491             :                 }
     492             :                 /* note that we may allow wildcard petterns! */
     493     2814923 :                 if (!allow_wildcards && FLAG_CHECK(name[i], FLAG_WILDCARD)) {
     494           0 :                         return false;
     495             :                 }
     496     2814923 :                 if (((unsigned char)name[i]) > 0x7e) {
     497         142 :                         return false;
     498             :                 }
     499     2814781 :                 if (strchr(force_shortname_chars, name[i])) {
     500        1078 :                         return false;
     501             :                 }
     502             :         }
     503             : 
     504             :         /* it is a good 8.3 name */
     505      410833 :         return True;
     506             : }
     507             : 
     508             : 
     509             : /*
     510             :   reset the mangling cache on a smb.conf reload. This only really makes sense for
     511             :   mangling backends that have parameters in smb.conf, and as this backend doesn't
     512             :   this is a NULL operation
     513             : */
     514        1561 : static void mangle_reset(void)
     515             : {
     516             :         /* noop */
     517        1561 : }
     518             : 
     519             : 
     520             : /*
     521             :   try to find a 8.3 name in the cache, and if found then
     522             :   replace the string with the original long name.
     523             : */
     524         225 : static bool lookup_name_from_8_3(TALLOC_CTX *ctx,
     525             :                         const char *name,
     526             :                         char **pp_out, /* talloced on the given context. */
     527             :                         const struct share_params *p)
     528             : {
     529           0 :         unsigned int hash, multiplier;
     530           0 :         unsigned int i;
     531           0 :         char *prefix;
     532           0 :         char extension[4];
     533             : 
     534         225 :         *pp_out = NULL;
     535             : 
     536             :         /* make sure that this is a mangled name from this cache */
     537         225 :         if (!is_mangled(name, p)) {
     538           0 :                 M_DEBUG(10,("lookup_name_from_8_3: %s -> not mangled\n", name));
     539           0 :                 return False;
     540             :         }
     541             : 
     542             :         /* we need to extract the hash from the 8.3 name */
     543         225 :         hash = base_reverse[(unsigned char)name[7]];
     544        1350 :         for (multiplier=36, i=5;i>=mangle_prefix;i--) {
     545        1125 :                 unsigned int v = base_reverse[(unsigned char)name[i]];
     546        1125 :                 hash += multiplier * v;
     547        1125 :                 multiplier *= 36;
     548             :         }
     549             : 
     550             :         /* now look in the prefix cache for that hash */
     551         225 :         prefix = cache_lookup(ctx, hash);
     552         225 :         if (!prefix) {
     553          48 :                 M_DEBUG(10,("lookup_name_from_8_3: %s -> %08X -> not found\n",
     554             :                                         name, hash));
     555          48 :                 return False;
     556             :         }
     557             : 
     558             :         /* we found it - construct the full name */
     559         177 :         if (name[8] == '.') {
     560          27 :                 strncpy(extension, name+9, 3);
     561          27 :                 extension[3] = 0;
     562             :         } else {
     563         150 :                 extension[0] = 0;
     564             :         }
     565             : 
     566         177 :         if (extension[0]) {
     567          27 :                 M_DEBUG(10,("lookup_name_from_8_3: %s -> %s.%s\n",
     568             :                                         name, prefix, extension));
     569          27 :                 *pp_out = talloc_asprintf(ctx, "%s.%s", prefix, extension);
     570             :         } else {
     571         150 :                 M_DEBUG(10,("lookup_name_from_8_3: %s -> %s\n", name, prefix));
     572         150 :                 *pp_out = talloc_strdup(ctx, prefix);
     573             :         }
     574             : 
     575         177 :         TALLOC_FREE(prefix);
     576             : 
     577         177 :         if (!*pp_out) {
     578           0 :                 M_DEBUG(0,("talloc_fail\n"));
     579           0 :                 return False;
     580             :         }
     581             : 
     582         177 :         return True;
     583             : }
     584             : 
     585             : /*
     586             :   look for a DOS reserved name
     587             : */
     588      985171 : static bool is_reserved_name(const char *name)
     589             : {
     590      985171 :         if (FLAG_CHECK(name[0], FLAG_POSSIBLE1) &&
     591       20375 :             FLAG_CHECK(name[1], FLAG_POSSIBLE2) &&
     592        7572 :             FLAG_CHECK(name[2], FLAG_POSSIBLE3) &&
     593        3894 :             FLAG_CHECK(name[3], FLAG_POSSIBLE4)) {
     594             :                 /* a likely match, scan the lot */
     595             :                 int i;
     596       18837 :                 for (i=0; reserved_names[i]; i++) {
     597       18018 :                         int len = strlen(reserved_names[i]);
     598             :                         /* note that we match on COM1 as well as COM1.foo */
     599       18018 :                         if (strnequal(name, reserved_names[i], len) &&
     600           0 :                             (name[len] == '.' || name[len] == 0)) {
     601           0 :                                 return True;
     602             :                         }
     603             :                 }
     604             :         }
     605             : 
     606      984678 :         return False;
     607             : }
     608             : 
     609             : /*
     610             :  See if a filename is a legal long filename.
     611             :  A filename ending in a '.' is not legal unless it's "." or "..". JRA.
     612             :  A filename ending in ' ' is not legal either. See bug id #2769.
     613             : */
     614             : 
     615      985171 : static bool is_legal_name(const char *name)
     616             : {
     617      985171 :         const char *dot_pos = NULL;
     618      985171 :         bool alldots = True;
     619      985171 :         size_t numdots = 0;
     620             : 
     621    11849536 :         while (*name) {
     622    10871702 :                 if (((unsigned int)name[0]) > 128 && (name[1] != 0)) {
     623             :                         /* Possible start of mb character. */
     624         488 :                         size_t size = 0;
     625         488 :                         (void)next_codepoint(name, &size);
     626             :                         /*
     627             :                          * Note that we're only looking for multibyte
     628             :                          * encoding here. No encoding with a length > 1
     629             :                          * contains invalid characters.
     630             :                          */
     631         488 :                         if (size > 1) {
     632             :                                 /* Was a mb string. */
     633          48 :                                 name += size;
     634          48 :                                 continue;
     635             :                         }
     636             :                 }
     637             : 
     638    10871654 :                 if (FLAG_CHECK(name[0], FLAG_ILLEGAL)) {
     639        7259 :                         return False;
     640             :                 }
     641    10864317 :                 if (name[0] == '.') {
     642      740532 :                         dot_pos = name;
     643      740532 :                         numdots++;
     644             :                 } else {
     645    10120961 :                         alldots = False;
     646             :                 }
     647    10864317 :                 if ((name[0] == ' ') && (name[1] == '\0')) {
     648             :                         /* Can't end in ' ' */
     649           0 :                         return False;
     650             :                 }
     651    10864317 :                 name++;
     652             :         }
     653             : 
     654      977834 :         if (dot_pos) {
     655      721179 :                 if (alldots && (numdots == 1 || numdots == 2))
     656       38059 :                         return True; /* . or .. is a valid name */
     657             : 
     658             :                 /* A valid long name cannot end in '.' */
     659      682942 :                 if (dot_pos[1] == '\0')
     660           2 :                         return False;
     661             :         }
     662      939358 :         return True;
     663             : }
     664             : 
     665      930218 : static bool must_mangle(const char *name,
     666             :                         const struct share_params *p)
     667             : {
     668      930218 :         if (is_reserved_name(name)) {
     669           0 :                 return True;
     670             :         }
     671      930218 :         return !is_legal_name(name);
     672             : }
     673             : 
     674             : /*
     675             :   the main forward mapping function, which converts a long filename to 
     676             :   a 8.3 name
     677             : 
     678             :   if cache83 is not set then we don't cache the result
     679             : 
     680             : */
     681       54953 : static bool hash2_name_to_8_3(const char *name,
     682             :                         char new_name[13],
     683             :                         bool cache83,
     684             :                         int default_case,
     685             :                         const struct share_params *p)
     686             : {
     687         178 :         char *dot_p;
     688         178 :         char lead_chars[7];
     689         178 :         char extension[4];
     690         178 :         unsigned int extension_length, i;
     691         178 :         unsigned int prefix_len;
     692         178 :         unsigned int hash, v;
     693             : 
     694             :         /* reserved names are handled specially */
     695       54953 :         if (!is_reserved_name(name)) {
     696             :                 /* if the name is already a valid 8.3 name then we don't need to
     697             :                  * change anything */
     698       54953 :                 if (is_legal_name(name) && is_8_3(name, False, False, p)) {
     699        2294 :                         strlcpy(new_name, name, 13);
     700        2294 :                         return True;
     701             :                 }
     702             :         }
     703             : 
     704             :         /* find the '.' if any */
     705       52659 :         dot_p = strrchr(name, '.');
     706             : 
     707       52659 :         if (dot_p) {
     708             :                 /* if the extension contains any illegal characters or
     709             :                    is too long or zero length then we treat it as part
     710             :                    of the prefix */
     711      111775 :                 for (i=0; i<4 && dot_p[i+1]; i++) {
     712       87090 :                         if (! FLAG_CHECK(dot_p[i+1], FLAG_ASCII)) {
     713         450 :                                 dot_p = NULL;
     714         450 :                                 break;
     715             :                         }
     716             :                 }
     717       25135 :                 if (i == 0 || i == 4) {
     718       13697 :                         dot_p = NULL;
     719             :                 }
     720             :         }
     721             : 
     722             :         /* the leading characters in the mangled name is taken from
     723             :            the first characters of the name, if they are ascii otherwise
     724             :            '_' is used
     725             :         */
     726      105318 :         for (i=0;i<mangle_prefix && name[i];i++) {
     727       52659 :                 lead_chars[i] = name[i];
     728       52659 :                 if (! FLAG_CHECK(lead_chars[i], FLAG_ASCII)) {
     729        7616 :                         lead_chars[i] = '_';
     730             :                 }
     731       52659 :                 lead_chars[i] = toupper_m(lead_chars[i]);
     732             :         }
     733       52659 :         for (;i<mangle_prefix;i++) {
     734           0 :                 lead_chars[i] = '_';
     735             :         }
     736             : 
     737             :         /* the prefix is anything up to the first dot */
     738       52659 :         if (dot_p) {
     739       11438 :                 prefix_len = PTR_DIFF(dot_p, name);
     740             :         } else {
     741       41221 :                 prefix_len = strlen(name);
     742             :         }
     743             : 
     744             :         /* the extension of the mangled name is taken from the first 3
     745             :            ascii chars after the dot */
     746       52659 :         extension_length = 0;
     747       52659 :         if (dot_p) {
     748       45098 :                 for (i=1; extension_length < 3 && dot_p[i]; i++) {
     749       33660 :                         char c = dot_p[i];
     750       33660 :                         if (FLAG_CHECK(c, FLAG_ASCII)) {
     751       33660 :                                 extension[extension_length++] =
     752       33660 :                                         toupper_m(c);
     753             :                         }
     754             :                 }
     755             :         }
     756             : 
     757             :         /* find the hash for this prefix */
     758       52659 :         v = hash = mangle_hash(name, prefix_len);
     759             : 
     760             :         /* now form the mangled name. */
     761      105496 :         for (i=0;i<mangle_prefix;i++) {
     762       52659 :                 new_name[i] = lead_chars[i];
     763             :         }
     764       52659 :         new_name[7] = base_forward(v % 36);
     765       52659 :         new_name[6] = '~';
     766      315954 :         for (i=5; i>=mangle_prefix; i--) {
     767      263295 :                 v = v / 36;
     768      263295 :                 new_name[i] = base_forward(v % 36);
     769             :         }
     770             : 
     771             :         /* add the extension */
     772       52659 :         if (extension_length) {
     773       11438 :                 new_name[8] = '.';
     774       11438 :                 memcpy(&new_name[9], extension, extension_length);
     775       11438 :                 new_name[9+extension_length] = 0;
     776             :         } else {
     777       41221 :                 new_name[8] = 0;
     778             :         }
     779             : 
     780       52659 :         if (cache83) {
     781             :                 /* put it in the cache */
     782       51682 :                 cache_insert(name, prefix_len, hash);
     783             :         }
     784             : 
     785       52659 :         M_DEBUG(10,("hash2_name_to_8_3: %s -> %08X -> %s (cache=%d)\n",
     786             :                    name, hash, new_name, cache83));
     787             : 
     788       52481 :         return True;
     789             : }
     790             : 
     791             : /*
     792             :   the following provides the abstraction layer to make it easier
     793             :   to drop in an alternative mangling implementation */
     794             : static const struct mangle_fns mangle_hash2_fns = {
     795             :         mangle_reset,
     796             :         is_mangled,
     797             :         must_mangle,
     798             :         is_8_3,
     799             :         lookup_name_from_8_3,
     800             :         hash2_name_to_8_3
     801             : };
     802             : 
     803             : /* return the methods for this mangling implementation */
     804         163 : const struct mangle_fns *mangle_hash2_init(void)
     805             : {
     806             :         /* the mangle prefix can only be in the mange 1 to 6 */
     807         163 :         mangle_prefix = lp_mangle_prefix();
     808         163 :         if (mangle_prefix > 6) {
     809           0 :                 mangle_prefix = 6;
     810             :         }
     811         163 :         if (mangle_prefix < 1) {
     812           0 :                 mangle_prefix = 1;
     813             :         }
     814             : 
     815             : #if DYNAMIC_MANGLE_TABLES
     816             :         init_tables();
     817             : #endif
     818         163 :         mangle_reset();
     819             : 
     820         163 :         return &mangle_hash2_fns;
     821             : }
     822             : 
     823         478 : static void posix_mangle_reset(void)
     824         478 : {;}
     825             : 
     826         646 : static bool posix_is_mangled(const char *s, const struct share_params *p)
     827             : {
     828         646 :         return False;
     829             : }
     830             : 
     831        3320 : static bool posix_must_mangle(const char *s, const struct share_params *p)
     832             : {
     833        3320 :         return False;
     834             : }
     835             : 
     836        3824 : static bool posix_is_8_3(const char *fname,
     837             :                         bool check_case,
     838             :                         bool allow_wildcards,
     839             :                         const struct share_params *p)
     840             : {
     841        3824 :         return False;
     842             : }
     843             : 
     844           0 : static bool posix_lookup_name_from_8_3(TALLOC_CTX *ctx,
     845             :                                 const char *in,
     846             :                                 char **out, /* talloced on the given context. */
     847             :                                 const struct share_params *p)
     848             : {
     849           0 :         return False;
     850             : }
     851             : 
     852        3186 : static bool posix_name_to_8_3(const char *in,
     853             :                                 char out[13],
     854             :                                 bool cache83,
     855             :                                 int default_case,
     856             :                                 const struct share_params *p)
     857             : {
     858        3186 :         memset(out, '\0', 13);
     859        3186 :         return True;
     860             : }
     861             : 
     862             : /* POSIX paths backend - no mangle. */
     863             : static const struct mangle_fns posix_mangle_fns = {
     864             :         posix_mangle_reset,
     865             :         posix_is_mangled,
     866             :         posix_must_mangle,
     867             :         posix_is_8_3,
     868             :         posix_lookup_name_from_8_3,
     869             :         posix_name_to_8_3
     870             : };
     871             : 
     872         478 : const struct mangle_fns *posix_mangle_init(void)
     873             : {
     874         478 :         return &posix_mangle_fns;
     875             : }

Generated by: LCOV version 1.14