source3/smbd/mangle.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Name mangling
   5    Copyright (C) Andrew Tridgell 1992-1995
   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 2 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, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 extern int DEBUGLEVEL;
  25 extern int case_default;
  26 extern BOOL case_mangle;
  27
  28 /****************************************************************************
  29 provide a checksum on a string
  30 ****************************************************************************/
  31 int str_checksum(char *s)
  32 {
  33   int res = 0;
  34   int c;
  35   int i=0;
  36   while (*s)
  37     {
  38       c = *s;
  39       res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
  40       s++; i++;
  41     }
  42   return(res);
  43 }
  44
  45 /****************************************************************************
  46 return True if a name is a special msdos reserved name
  47 ****************************************************************************/
  48 static BOOL is_reserved_msdos(char *fname)
  49 {
  50   char upperFname[13];
  51   char *p;
  52
  53   StrnCpy (upperFname, fname, 12);
  54
  55   /* lpt1.txt and con.txt etc are also illegal */
  56   p=strchr(upperFname,'.');
  57   if (p)
  58    *p='\0';
  59   strupper (upperFname);
  60   if ((strcmp(upperFname,"CLOCK$") == 0) ||
  61     (strcmp(upperFname,"CON") == 0) ||
  62     (strcmp(upperFname,"AUX") == 0) ||
  63     (strcmp(upperFname,"COM1") == 0) ||
  64     (strcmp(upperFname,"COM2") == 0) ||
  65     (strcmp(upperFname,"COM3") == 0) ||
  66     (strcmp(upperFname,"COM4") == 0) ||
  67     (strcmp(upperFname,"LPT1") == 0) ||
  68     (strcmp(upperFname,"LPT2") == 0) ||
  69     (strcmp(upperFname,"LPT3") == 0) ||
  70     (strcmp(upperFname,"NUL") == 0) ||
  71     (strcmp(upperFname,"PRN") == 0))
  72       return (True) ;
  73
  74   return (False);
  75 }
  76
  77
  78
  79 /****************************************************************************
  80 return True if a name is in 8.3 dos format
  81 ****************************************************************************/
  82 BOOL is_8_3(char *fname)
  83 {
  84   int len;
  85   char *dot_pos;
  86   char *slash_pos = strrchr(fname,'/');
  87   int l;
  88
  89   if (slash_pos) fname = slash_pos+1;
  90   len = strlen(fname);
  91
  92   DEBUG(5,("checking %s for 8.3\n",fname));
  93
  94   if (case_mangle)
  95     switch (case_default)
  96       {
  97       case CASE_LOWER:
  98         if (strhasupper(fname)) return(False);
  99         break;
 100       case CASE_UPPER:
 101         if (strhaslower(fname)) return(False);
 102         break;
 103       }
 104
 105   /* can't be longer than 12 chars */
 106   if (len == 0 || len > 12)
 107     return(False);
 108
 109   /* can't be an MS-DOS Special file such as lpt1 or even lpt1.txt */
 110   if (is_reserved_msdos(fname))
 111     return(False);
 112
 113   /* can't contain invalid dos chars */
 114   /* Windows use the ANSI charset.
 115      But filenames are translated in the PC charset.
 116      This Translation may be more or less relaxed depending
 117      the Windows application. */
 118
 119   /* %%% A nice improvment to name mangling would be to translate
 120      filename to ANSI charset on the smb server host */
 121
 122   dot_pos = strchr(fname,'.');
 123
 124   {
 125     char *p = fname;
 126 #ifdef KANJI
 127     dot_pos = 0;
 128     while (*p)
 129       {
 130           if (is_shift_jis (*p)) {
 131               p += 2;
 132           } else if (is_kana (*p)) {
 133               p ++;
 134           } else {
 135               if (*p == '.' && !dot_pos)
 136                   dot_pos = (char *) p;
 137               if (!isdoschar(*p))
 138                   return(False);
 139               p++;
 140           }
 141       }
 142 #else
 143     while (*p)
 144       {
 145         if (!isdoschar(*p))
 146           return(False);
 147         p++;
 148       }
 149 #endif /* KANJI */
 150   }
 151
 152   /* no dot and less than 9 means OK */
 153   if (!dot_pos)
 154     return(len <= 8);
 155
 156   l = PTR_DIFF(dot_pos,fname);
 157
 158   /* base must be at least 1 char except special cases . and .. */
 159   if (l == 0)
 160     return(strcmp(fname,".") == 0 || strcmp(fname,"..") == 0);
 161
 162   /* base can't be greater than 8 */
 163   if (l > 8)
 164     return(False);
 165
 166   if (lp_strip_dot() &&
 167       len - l == 1 &&
 168       !strchr(dot_pos+1,'.'))
 169     {
 170       *dot_pos = 0;
 171       return(True);
 172     }
 173
 174   /* extension must be between 1 and 3 */
 175   if ( (len - l < 2 ) || (len - l > 4) )
 176     return(False);
 177
 178   /* extension can't have a dot */
 179   if (strchr(dot_pos+1,'.'))
 180     return(False);
 181
 182   /* must be in 8.3 format */
 183   return(True);
 184 }
 185
 186
 187
 188 /*
 189 keep a stack of name mangling results - just
 190 so file moves and copies have a chance of working
 191 */
 192 fstring *mangled_stack = NULL;
 193 int mangled_stack_size = 0;
 194 int mangled_stack_len = 0;
 195
 196 /****************************************************************************
 197 create the mangled stack
 198 ****************************************************************************/
 199 void create_mangled_stack(int size)
 200 {
 201   if (mangled_stack)
 202     {
 203       free(mangled_stack);
 204       mangled_stack_size = 0;
 205       mangled_stack_len = 0;
 206     }
 207   if (size > 0)
 208     mangled_stack = (fstring *)malloc(sizeof(fstring)*size);
 209   if (mangled_stack) mangled_stack_size = size;
 210 }
 211
 212 /****************************************************************************
 213 push a mangled name onto the stack
 214 ****************************************************************************/
 215 static void push_mangled_name(char *s)
 216 {
 217   int i;
 218   char *p;
 219
 220   if (!mangled_stack)
 221     return;
 222
 223   for (i=0;i<mangled_stack_len;i++)
 224     if (strcmp(s,mangled_stack[i]) == 0)
 225       {
 226         array_promote(mangled_stack[0],sizeof(fstring),i);
 227         return;
 228       }
 229
 230   memmove(mangled_stack[1],mangled_stack[0],
 231           sizeof(fstring)*MIN(mangled_stack_len,mangled_stack_size-1));
 232   strcpy(mangled_stack[0],s);
 233   p = strrchr(mangled_stack[0],'.');
 234   if (p && (!strhasupper(p+1)) && (strlen(p+1) < 4))
 235     *p = 0;
 236   mangled_stack_len = MIN(mangled_stack_size,mangled_stack_len+1);
 237 }
 238
 239 /****************************************************************************
 240 check for a name on the mangled name stack
 241 ****************************************************************************/
 242 BOOL check_mangled_stack(char *s)
 243 {
 244   int i;
 245   pstring tmpname;
 246   char extension[5];
 247   char *p = strrchr(s,'.');
 248   BOOL check_extension = False;
 249
 250   extension[0] = 0;
 251
 252   if (!mangled_stack) return(False);
 253
 254   if (p)
 255     {
 256       check_extension = True;
 257       StrnCpy(extension,p,4);
 258       strlower(extension); /* XXXXXXX */
 259     }
 260
 261   for (i=0;i<mangled_stack_len;i++)
 262     {
 263       strcpy(tmpname,mangled_stack[i]);
 264       mangle_name_83(tmpname);
 265       if (strequal(tmpname,s))
 266         {
 267           strcpy(s,mangled_stack[i]);
 268           break;
 269         }
 270       if (check_extension && !strchr(mangled_stack[i],'.'))
 271         {
 272           strcpy(tmpname,mangled_stack[i]);
 273           strcat(tmpname,extension);
 274           mangle_name_83(tmpname);
 275           if (strequal(tmpname,s))
 276             {
 277               strcpy(s,mangled_stack[i]);
 278               strcat(s,extension);
 279               break;
 280             }
 281         }
 282     }
 283
 284   if (i < mangled_stack_len)
 285     {
 286       DEBUG(3,("Found %s on mangled stack as %s\n",s,mangled_stack[i]));
 287       array_promote(mangled_stack[0],sizeof(fstring),i);
 288       return(True);
 289     }
 290
 291   return(False);
 292 }
 293
 294 static char *map_filename(char *s, /* This is null terminated */
 295                           char *pattern, /* This isn't. */
 296                           int len) /* This is the length of pattern. */
 297 {
 298   static pstring matching_bit;  /* The bit of the string which matches */
 299                                 /* a * in pattern if indeed there is a * */
 300   char *sp;                     /* Pointer into s. */
 301   char *pp;                     /* Pointer into p. */
 302   char *match_start;            /* Where the matching bit starts. */
 303   pstring pat;
 304
 305   StrnCpy(pat, pattern, len);   /* Get pattern into a proper string! */
 306   strcpy(matching_bit,"");      /* Match but no star gets this. */
 307   pp = pat;                     /* Initialise the pointers. */
 308   sp = s;
 309   if ((len == 1) && (*pattern == '*')) {
 310     return NULL;                /* Impossible, too ambiguous for */
 311                                 /* words! */
 312   }
 313
 314   while ((*sp)                  /* Not the end of the string. */
 315          && (*pp)               /* Not the end of the pattern. */
 316          && (*sp == *pp)        /* The two match. */
 317          && (*pp != '*')) {     /* No wildcard. */
 318     sp++;                       /* Keep looking. */
 319     pp++;
 320   }
 321   if (!*sp && !*pp)             /* End of pattern. */
 322     return matching_bit;        /* Simple match.  Return empty string. */
 323   if (*pp == '*') {
 324     pp++;                       /* Always interrested in the chacter */
 325                                 /* after the '*' */
 326     if (!*pp) {                 /* It is at the end of the pattern. */
 327       StrnCpy(matching_bit, s, sp-s);
 328       return matching_bit;
 329     } else {
 330       /* The next character in pattern must match a character further */
 331       /* along s than sp so look for that character. */
 332       match_start = sp;
 333       while ((*sp)              /* Not the end of s. */
 334              && (*sp != *pp))   /* Not the same  */
 335         sp++;                   /* Keep looking. */
 336       if (!*sp) {               /* Got to the end without a match. */
 337         return NULL;
 338       } else {                  /* Still hope for a match. */
 339         /* Now sp should point to a matching character. */
 340         StrnCpy(matching_bit, match_start, sp-match_start);
 341         /* Back to needing a stright match again. */
 342         while ((*sp)            /* Not the end of the string. */
 343                && (*pp)         /* Not the end of the pattern. */
 344                && (*sp == *pp)) { /* The two match. */
 345           sp++;                 /* Keep looking. */
 346           pp++;
 347         }
 348         if (!*sp && !*pp)       /* Both at end so it matched */
 349           return matching_bit;
 350         else
 351           return NULL;
 352       }
 353     }
 354   }
 355   return NULL;                  /* No match. */
 356 }
 357
 358
 359 /* this is the magic char used for mangling */
 360 char magic_char = '~';
 361
 362
 363 /****************************************************************************
 364 determine whther is name could be a mangled name
 365 ****************************************************************************/
 366 BOOL is_mangled(char *s)
 367 {
 368   char *m = strchr(s,magic_char);
 369   if (!m) return(False);
 370
 371   /* we use two base 36 chars efore the extension */
 372   if (m[1] == '.' || m[1] == 0 ||
 373       m[2] == '.' || m[2] == 0 ||
 374       (m[3] != '.' && m[3] != 0))
 375     return(is_mangled(m+1));
 376
 377   /* it could be */
 378   return(True);
 379 }
 380
 381
 382
 383 /****************************************************************************
 384 return a base 36 character. v must be from 0 to 35.
 385 ****************************************************************************/
 386 static char base36(int v)
 387 {
 388   v = v % 36;
 389   if (v < 10)
 390     return('0'+v);
 391   else /* needed to work around a DEC C compiler bug */
 392     return('A' + (v-10));
 393 }
 394
 395
 396 static void do_fwd_mangled_map(char *s, char *MangledMap)
 397 {
 398   /* MangledMap is a series of name pairs in () separated by spaces.
 399    * If s matches the first of the pair then the name given is the
 400    * second of the pair.  A * means any number of any character and if
 401    * present in the second of the pair as well as the first the
 402    * matching part of the first string takes the place of the * in the
 403    * second.
 404    *
 405    * I wanted this so that we could have RCS files which can be used
 406    * by UNIX and DOS programs.  My mapping string is (RCS rcs) which
 407    * converts the UNIX RCS file subdirectory to lowercase thus
 408    * preventing mangling.
 409    */
 410   char *start=MangledMap;       /* Use this to search for mappings. */
 411   char *end;                    /* Used to find the end of strings. */
 412   char *match_string;
 413   pstring new_string;           /* Make up the result here. */
 414   char *np;                     /* Points into new_string. */
 415
 416   DEBUG(5,("Mangled Mapping '%s' map '%s'\n", s, MangledMap));
 417   while (*start) {
 418     while ((*start) && (*start != '('))
 419       start++;
 420     start++;                    /* Skip the ( */
 421     if (!*start)
 422       continue;                 /* Always check for the end. */
 423     end = start;                /* Search for the ' ' or a ')' */
 424     DEBUG(5,("Start of first in pair '%s'\n", start));
 425     while ((*end) && !((*end == ' ') || (*end == ')')))
 426       end++;
 427     if (!*end) {
 428       start = end;
 429       continue;                 /* Always check for the end. */
 430     }
 431     DEBUG(5,("End of first in pair '%s'\n", end));
 432     if ((match_string = map_filename(s, start, end-start))) {
 433       DEBUG(5,("Found a match\n"));
 434       /* Found a match. */
 435       start = end+1;            /* Point to start of what it is to become. */
 436       DEBUG(5,("Start of second in pair '%s'\n", start));
 437       end = start;
 438       np = new_string;
 439       while ((*end)             /* Not the end of string. */
 440              && (*end != ')')   /* Not the end of the pattern. */
 441              && (*end != '*'))  /* Not a wildcard. */
 442         *np++ = *end++;
 443       if (!*end) {
 444         start = end;
 445         continue;               /* Always check for the end. */
 446       }
 447       if (*end == '*') {
 448         strcpy(np, match_string);
 449         np += strlen(match_string);
 450         end++;                  /* Skip the '*' */
 451         while ((*end)             /* Not the end of string. */
 452                && (*end != ')')   /* Not the end of the pattern. */
 453                && (*end != '*'))  /* Not a wildcard. */
 454           *np++ = *end++;
 455       }
 456       if (!*end) {
 457         start = end;
 458         continue;               /* Always check for the end. */
 459       }
 460       *np++ = '\0';             /* NULL terminate it. */
 461       DEBUG(5,("End of second in pair '%s'\n", end));
 462       strcpy(s, new_string);    /* Substitute with the new name. */
 463       DEBUG(5,("s is now '%s'\n", s));
 464     }
 465     start = end;              /* Skip a bit which cannot be wanted */
 466     /* anymore. */
 467     start++;
 468   }
 469 }
 470
 471 /****************************************************************************
 472 do the actual mangling to 8.3 format
 473 ****************************************************************************/
 474 void mangle_name_83(char *s)
 475 {
 476   int csum = str_checksum(s);
 477   char *p;
 478   char extension[4];
 479   char base[9];
 480   int baselen = 0;
 481   int extlen = 0;
 482
 483   extension[0]=0;
 484   base[0]=0;
 485
 486   p = strrchr(s,'.');
 487   if (p && (strlen(p+1)<4) )
 488     {
 489       BOOL all_normal = (strisnormal(p+1)); /* XXXXXXXXX */
 490       if (all_normal && p[1] != 0)
 491         {
 492           *p = 0;
 493           csum = str_checksum(s);
 494           *p = '.';
 495         }
 496     }
 497
 498
 499   strupper(s);
 500
 501   DEBUG(5,("Mangling name %s to ",s));
 502
 503   if (p)
 504     {
 505       if (p == s)
 506         strcpy(extension,"___");
 507       else
 508         {
 509           *p++ = 0;
 510           while (*p && extlen < 3)
 511             {
 512               if (isdoschar(*p) && *p != '.')
 513                 extension[extlen++] = *p;
 514               p++;
 515             }
 516           extension[extlen] = 0;
 517         }
 518     }
 519
 520   p = s;
 521
 522   while (*p && baselen < 5)
 523     {
 524       if (isdoschar(*p) && *p != '.')
 525         base[baselen++] = *p;
 526       p++;
 527     }
 528   base[baselen] = 0;
 529
 530   csum = csum % (36*36);
 531
 532     sprintf(s,"%s%c%c%c",base,magic_char,base36(csum/36),base36(csum%36));
 533
 534   if (*extension)
 535     {
 536       strcat(s,".");
 537       strcat(s,extension);
 538     }
 539   DEBUG(5,("%s\n",s));
 540 }
 541
 542
 543
 544 /*******************************************************************
 545   work out if a name is illegal, even for long names
 546   ******************************************************************/
 547 static BOOL illegal_name(char *name)
 548 {
 549   static unsigned char illegal[256];
 550   static BOOL initialised=False;
 551   unsigned char *s;
 552
 553   if (!initialised) {
 554     char *ill = "*\\/?<>|\":{}";
 555     initialised = True;
 556
 557     bzero((char *)illegal,256);
 558     for (s = (unsigned char *)ill; *s; s++)
 559       illegal[*s] = True;
 560   }
 561
 562 #ifdef KANJI
 563   for (s = (unsigned char *)name; *s;) {
 564     if (is_shift_jis (*s)) {
 565       s += 2;
 566     } else if (illegal[*s]) {
 567       return(True);
 568     } else {
 569       s++;
 570     }
 571   }
 572 #else
 573   for (s = (unsigned char *)name;*s;s++)
 574     if (illegal[*s]) return(True);
 575 #endif
 576
 577
 578   return(False);
 579 }
 580
 581
 582 /****************************************************************************
 583 convert a filename to DOS format. return True if successful.
 584 ****************************************************************************/
 585 BOOL name_map_mangle(char *OutName,BOOL need83,int snum)
 586 {
 587 #ifdef MANGLE_LONG_FILENAMES
 588   if (!need83 && illegal_name(OutName)) need83 = True;
 589 #endif
 590
 591   /* apply any name mappings */
 592   {
 593     char *map = lp_mangled_map(snum);
 594     if (map && *map)
 595       do_fwd_mangled_map(OutName,map);
 596   }
 597
 598   /* check if it's already in 8.3 format */
 599   if (need83 && !is_8_3(OutName)) {
 600     if (!lp_manglednames(snum)) return(False);
 601
 602     /* mangle it into 8.3 */
 603     push_mangled_name(OutName);
 604     mangle_name_83(OutName);
 605   }
 606
 607   return(True);
 608 }
 609