/* Unix SMB/CIFS implementation. Name mapping code Copyright (C) Jeremy Allison 1998 Copyright (C) Andrew Tridgell 2002 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "includes.h" /* ************************************************************************** ** * Used only in do_fwd_mangled_map(), below. * ************************************************************************** ** */ static char *map_filename( char *s, /* This is null terminated */ const char *pattern, /* This isn't. */ int len ) /* This is the length of pattern. */ { static pstring matching_bit; /* The bit of the string which matches */ /* a * in pattern if indeed there is a * */ char *sp; /* Pointer into s. */ char *pp; /* Pointer into p. */ char *match_start; /* Where the matching bit starts. */ pstring pat; StrnCpy( pat, pattern, len ); /* Get pattern into a proper string! */ pstrcpy( matching_bit, "" ); /* Match but no star gets this. */ pp = pat; /* Initialize the pointers. */ sp = s; if( strequal(s, ".") || strequal(s, "..")) { return NULL; /* Do not map '.' and '..' */ } if( (len == 1) && (*pattern == '*') ) { return NULL; /* Impossible, too ambiguous for */ } /* words! */ while( (*sp) /* Not the end of the string. */ && (*pp) /* Not the end of the pattern. */ && (*sp == *pp) /* The two match. */ && (*pp != '*') ) /* No wildcard. */ { sp++; /* Keep looking. */ pp++; } if( !*sp && !*pp ) /* End of pattern. */ return( matching_bit ); /* Simple match. Return empty string. */ if( *pp == '*' ) { pp++; /* Always interrested in the chacter */ /* after the '*' */ if( !*pp ) /* It is at the end of the pattern. */ { StrnCpy( matching_bit, s, sp-s ); return( matching_bit ); } else { /* The next character in pattern must match a character further */ /* along s than sp so look for that character. */ match_start = sp; while( (*sp) /* Not the end of s. */ && (*sp != *pp) ) /* Not the same */ sp++; /* Keep looking. */ if( !*sp ) /* Got to the end without a match. */ { return( NULL ); } /* Still hope for a match. */ else { /* Now sp should point to a matching character. */ StrnCpy(matching_bit, match_start, sp-match_start); /* Back to needing a stright match again. */ while( (*sp) /* Not the end of the string. */ && (*pp) /* Not the end of the pattern. */ && (*sp == *pp) ) /* The two match. */ { sp++; /* Keep looking. */ pp++; } if( !*sp && !*pp ) /* Both at end so it matched */ return( matching_bit ); else return( NULL ); } } } return( NULL ); /* No match. */ } /* map_filename */ /* ************************************************************************** ** * MangledMap is a series of name pairs in () separated by spaces. * If s matches the first of the pair then the name given is the * second of the pair. A * means any number of any character and if * present in the second of the pair as well as the first the * matching part of the first string takes the place of the * in the * second. * * I wanted this so that we could have RCS files which can be used * by UNIX and DOS programs. My mapping string is (RCS rcs) which * converts the UNIX RCS file subdirectory to lowercase thus * preventing mangling. * * See 'mangled map' in smb.conf(5). * * ************************************************************************** ** */ static void mangled_map(char *s, const char *MangledMap) { const char *start=MangledMap; /* Use this to search for mappings. */ const char *end; /* Used to find the end of strings. */ char *match_string; pstring new_string; /* Make up the result here. */ char *np; /* Points into new_string. */ DEBUG( 5, ("Mangled Mapping '%s' map '%s'\n", s, MangledMap) ); while( *start ) { while( (*start) && (*start != '(') ) start++; if( !*start ) continue; /* Always check for the end. */ start++; /* Skip the ( */ end = start; /* Search for the ' ' or a ')' */ DEBUG( 5, ("Start of first in pair '%s'\n", start) ); while( (*end) && !((*end == ' ') || (*end == ')')) ) end++; if( !*end ) { start = end; continue; /* Always check for the end. */ } DEBUG( 5, ("End of first in pair '%s'\n", end) ); if( (match_string = map_filename( s, start, end-start )) ) { int size_left = sizeof(new_string) - 1; DEBUG( 5, ("Found a match\n") ); /* Found a match. */ start = end + 1; /* Point to start of what it is to become. */ DEBUG( 5, ("Start of second in pair '%s'\n", start) ); end = start; np = new_string; while( (*end && size_left > 0) /* Not the end of string. */ && (*end != ')') /* Not the end of the pattern. */ && (*end != '*') ) { /* Not a wildcard. */ *np++ = *end++; size_left--; } if( !*end ) { start = end; continue; /* Always check for the end. */ } if( *end == '*' ) { if (size_left > 0 ) safe_strcpy( np, match_string, size_left ); np += strlen( match_string ); size_left -= strlen( match_string ); end++; /* Skip the '*' */ while ((*end && size_left > 0) /* Not the end of string. */ && (*end != ')') /* Not the end of the pattern. */ && (*end != '*')) { /* Not a wildcard. */ *np++ = *end++; size_left--; } } if (!*end) { start = end; continue; /* Always check for the end. */ } if (size_left > 0) *np++ = '\0'; /* NULL terminate it. */ DEBUG(5,("End of second in pair '%s'\n", end)); new_string[sizeof(new_string)-1] = '\0'; pstrcpy( s, new_string ); /* Substitute with the new name. */ DEBUG( 5, ("s is now '%s'\n", s) ); } start = end; /* Skip a bit which cannot be wanted anymore. */ start++; } } /* front end routine to the mangled map code personally I think that the whole idea of "mangled map" is completely bogus */ void mangle_map_filename(fstring fname, const struct share_params *p) { char *map; map = lp_mangled_map(p); if (!map || !*map) return; mangled_map(fname, map); }