2 Unix SMB/Netbios implementation.
5 Copyright (C) Andrew Tridgell 1992-1997
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.
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.
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.
24 extern int DEBUGLEVEL
;
25 extern int case_default
;
26 extern BOOL case_mangle
;
28 /****************************************************************************
29 provide a checksum on a string
30 ****************************************************************************/
31 int str_checksum(char *s
)
39 res
^= (c
<< (i
% 15)) ^ (c
>> (15-(i
%15)));
45 /****************************************************************************
46 return True if a name is a special msdos reserved name
47 ****************************************************************************/
48 static BOOL
is_reserved_msdos(char *fname
)
53 StrnCpy (upperFname
, fname
, 12);
55 /* lpt1.txt and con.txt etc are also illegal */
56 p
=strchr(upperFname
,'.');
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))
79 /****************************************************************************
80 return True if a name is in 8.3 dos format
81 ****************************************************************************/
82 BOOL
is_8_3(char *fname
, BOOL check_case
)
86 char *slash_pos
= strrchr(fname
,'/');
89 if (slash_pos
) fname
= slash_pos
+1;
92 DEBUG(5,("checking %s for 8.3\n",fname
));
94 if (check_case
&& case_mangle
)
98 if (strhasupper(fname
)) return(False
);
101 if (strhaslower(fname
)) return(False
);
105 /* can't be longer than 12 chars */
106 if (len
== 0 || len
> 12)
109 /* can't be an MS-DOS Special file such as lpt1 or even lpt1.txt */
110 if (is_reserved_msdos(fname
))
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. */
119 /* %%% A nice improvment to name mangling would be to translate
120 filename to ANSI charset on the smb server host */
122 dot_pos
= strchr(fname
,'.');
130 if (is_shift_jis (*p
)) {
132 } else if (is_kana (*p
)) {
135 if (*p
== '.' && !dot_pos
)
136 dot_pos
= (char *) p
;
152 /* no dot and less than 9 means OK */
156 l
= PTR_DIFF(dot_pos
,fname
);
158 /* base must be at least 1 char except special cases . and .. */
160 return(strcmp(fname
,".") == 0 || strcmp(fname
,"..") == 0);
162 /* base can't be greater than 8 */
166 if (lp_strip_dot() &&
168 !strchr(dot_pos
+1,'.'))
174 /* extension must be between 1 and 3 */
175 if ( (len
- l
< 2 ) || (len
- l
> 4) )
178 /* extension can't have a dot */
179 if (strchr(dot_pos
+1,'.'))
182 /* must be in 8.3 format */
189 keep a stack of name mangling results - just
190 so file moves and copies have a chance of working
192 fstring
*mangled_stack
= NULL
;
193 int mangled_stack_size
= 0;
194 int mangled_stack_len
= 0;
196 /****************************************************************************
197 create the mangled stack
198 ****************************************************************************/
199 void create_mangled_stack(int size
)
204 mangled_stack_size
= 0;
205 mangled_stack_len
= 0;
208 mangled_stack
= (fstring
*)malloc(sizeof(fstring
)*size
);
209 if (mangled_stack
) mangled_stack_size
= size
;
212 /****************************************************************************
213 push a mangled name onto the stack
214 ****************************************************************************/
215 static void push_mangled_name(char *s
)
223 for (i
=0;i
<mangled_stack_len
;i
++)
224 if (strcmp(s
,mangled_stack
[i
]) == 0)
226 array_promote(mangled_stack
[0],sizeof(fstring
),i
);
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))
236 mangled_stack_len
= MIN(mangled_stack_size
,mangled_stack_len
+1);
239 /****************************************************************************
240 check for a name on the mangled name stack
241 ****************************************************************************/
242 BOOL
check_mangled_stack(char *s
)
247 char *p
= strrchr(s
,'.');
248 BOOL check_extension
= False
;
252 if (!mangled_stack
) return(False
);
256 check_extension
= True
;
257 StrnCpy(extension
,p
,4);
258 strlower(extension
); /* XXXXXXX */
261 for (i
=0;i
<mangled_stack_len
;i
++)
263 strcpy(tmpname
,mangled_stack
[i
]);
264 mangle_name_83(tmpname
);
265 if (strequal(tmpname
,s
))
267 strcpy(s
,mangled_stack
[i
]);
270 if (check_extension
&& !strchr(mangled_stack
[i
],'.'))
272 strcpy(tmpname
,mangled_stack
[i
]);
273 strcat(tmpname
,extension
);
274 mangle_name_83(tmpname
);
275 if (strequal(tmpname
,s
))
277 strcpy(s
,mangled_stack
[i
]);
284 if (i
< mangled_stack_len
)
286 DEBUG(3,("Found %s on mangled stack as %s\n",s
,mangled_stack
[i
]));
287 array_promote(mangled_stack
[0],sizeof(fstring
),i
);
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. */
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. */
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. */
309 if ((len
== 1) && (*pattern
== '*')) {
310 return NULL
; /* Impossible, too ambiguous for */
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. */
321 if (!*sp
&& !*pp
) /* End of pattern. */
322 return matching_bit
; /* Simple match. Return empty string. */
324 pp
++; /* Always interrested in the chacter */
326 if (!*pp
) { /* It is at the end of the pattern. */
327 StrnCpy(matching_bit
, s
, sp
-s
);
330 /* The next character in pattern must match a character further */
331 /* along s than sp so look for that character. */
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. */
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. */
348 if (!*sp
&& !*pp
) /* Both at end so it matched */
355 return NULL
; /* No match. */
359 /* this is the magic char used for mangling */
360 char magic_char
= '~';
363 /****************************************************************************
364 determine whther is name could be a mangled name
365 ****************************************************************************/
366 BOOL
is_mangled(char *s
)
368 char *m
= strchr(s
,magic_char
);
369 if (!m
) return(False
);
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));
383 /****************************************************************************
384 return a base 36 character. v must be from 0 to 35.
385 ****************************************************************************/
386 static char base36(unsigned int v
)
388 static char basechars
[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
389 return basechars
[v
% 36];
393 static void do_fwd_mangled_map(char *s
, char *MangledMap
)
395 /* MangledMap is a series of name pairs in () separated by spaces.
396 * If s matches the first of the pair then the name given is the
397 * second of the pair. A * means any number of any character and if
398 * present in the second of the pair as well as the first the
399 * matching part of the first string takes the place of the * in the
402 * I wanted this so that we could have RCS files which can be used
403 * by UNIX and DOS programs. My mapping string is (RCS rcs) which
404 * converts the UNIX RCS file subdirectory to lowercase thus
405 * preventing mangling.
407 char *start
=MangledMap
; /* Use this to search for mappings. */
408 char *end
; /* Used to find the end of strings. */
410 pstring new_string
; /* Make up the result here. */
411 char *np
; /* Points into new_string. */
413 DEBUG(5,("Mangled Mapping '%s' map '%s'\n", s
, MangledMap
));
415 while ((*start
) && (*start
!= '('))
417 start
++; /* Skip the ( */
419 continue; /* Always check for the end. */
420 end
= start
; /* Search for the ' ' or a ')' */
421 DEBUG(5,("Start of first in pair '%s'\n", start
));
422 while ((*end
) && !((*end
== ' ') || (*end
== ')')))
426 continue; /* Always check for the end. */
428 DEBUG(5,("End of first in pair '%s'\n", end
));
429 if ((match_string
= map_filename(s
, start
, end
-start
))) {
430 DEBUG(5,("Found a match\n"));
432 start
= end
+1; /* Point to start of what it is to become. */
433 DEBUG(5,("Start of second in pair '%s'\n", start
));
436 while ((*end
) /* Not the end of string. */
437 && (*end
!= ')') /* Not the end of the pattern. */
438 && (*end
!= '*')) /* Not a wildcard. */
442 continue; /* Always check for the end. */
445 strcpy(np
, match_string
);
446 np
+= strlen(match_string
);
447 end
++; /* Skip the '*' */
448 while ((*end
) /* Not the end of string. */
449 && (*end
!= ')') /* Not the end of the pattern. */
450 && (*end
!= '*')) /* Not a wildcard. */
455 continue; /* Always check for the end. */
457 *np
++ = '\0'; /* NULL terminate it. */
458 DEBUG(5,("End of second in pair '%s'\n", end
));
459 strcpy(s
, new_string
); /* Substitute with the new name. */
460 DEBUG(5,("s is now '%s'\n", s
));
462 start
= end
; /* Skip a bit which cannot be wanted */
468 /****************************************************************************
469 do the actual mangling to 8.3 format
470 ****************************************************************************/
471 void mangle_name_83(char *s
)
473 int csum
= str_checksum(s
);
484 if (p
&& (strlen(p
+1)<4) )
486 BOOL all_normal
= (strisnormal(p
+1)); /* XXXXXXXXX */
487 if (all_normal
&& p
[1] != 0)
490 csum
= str_checksum(s
);
498 DEBUG(5,("Mangling name %s to ",s
));
503 strcpy(extension
,"___");
507 while (*p
&& extlen
< 3)
510 if (is_shift_jis (*p
))
514 extension
[extlen
++] = p
[0];
515 extension
[extlen
++] = p
[1];
519 extension
[extlen
++] = base36 (((unsigned char) *p
) % 36);
523 else if (is_kana (*p
))
525 extension
[extlen
++] = p
[0];
530 if (isdoschar (*p
) && *p
!= '.')
531 extension
[extlen
++] = p
[0];
535 if (isdoschar(*p
) && *p
!= '.')
536 extension
[extlen
++] = *p
;
540 extension
[extlen
] = 0;
546 while (*p
&& baselen
< 5)
549 if (is_shift_jis (*p
))
553 base
[baselen
++] = p
[0];
554 base
[baselen
++] = p
[1];
558 base
[baselen
++] = base36 (((unsigned char) *p
) % 36);
562 else if (is_kana (*p
))
564 base
[baselen
++] = p
[0];
569 if (isdoschar (*p
) && *p
!= '.')
570 base
[baselen
++] = p
[0];
574 if (isdoschar(*p
) && *p
!= '.')
575 base
[baselen
++] = *p
;
581 csum
= csum
% (36*36);
583 sprintf(s
,"%s%c%c%c",base
,magic_char
,base36(csum
/36),base36(csum
%36));
595 /*******************************************************************
596 work out if a name is illegal, even for long names
597 ******************************************************************/
598 static BOOL
illegal_name(char *name
)
600 static unsigned char illegal
[256];
601 static BOOL initialised
=False
;
605 char *ill
= "*\\/?<>|\":{}";
608 bzero((char *)illegal
,256);
609 for (s
= (unsigned char *)ill
; *s
; s
++)
614 for (s
= (unsigned char *)name
; *s
;) {
615 if (is_shift_jis (*s
)) {
617 } else if (illegal
[*s
]) {
624 for (s
= (unsigned char *)name
;*s
;s
++)
625 if (illegal
[*s
]) return(True
);
633 /****************************************************************************
634 convert a filename to DOS format. return True if successful.
635 ****************************************************************************/
636 BOOL
name_map_mangle(char *OutName
,BOOL need83
,int snum
)
638 #ifdef MANGLE_LONG_FILENAMES
639 if (!need83
&& illegal_name(OutName
)) need83
= True
;
642 /* apply any name mappings */
644 char *map
= lp_mangled_map(snum
);
646 do_fwd_mangled_map(OutName
,map
);
649 /* check if it's already in 8.3 format */
650 if (need83
&& !is_8_3(OutName
, True
)) {
651 if (!lp_manglednames(snum
)) return(False
);
653 /* mangle it into 8.3 */
654 push_mangled_name(OutName
);
655 mangle_name_83(OutName
);