github/amiga-clib2
1
0
Fork 0
mirror of https://github.com/adtools/clib2.git synced 2025-12-08 14:59:05 +00:00
Code Issues Releases Wiki Activity
Files
28ceb29a20e620f7000dd509e5701a0b0909869f
amiga-clib2/library/unistd_translateu2a.c
Olaf Barthel a1ffc20864 - Documented __strip_double_slash() and plugged in a memmove() 
in place of the copying loop.

- Modified __translate_unix_to_amiga_path_name() and
  __translate_amiga_to_unix_path_name() to not to call strlen()
  on the results of __strip_double_slash().


git-svn-id: file:///Users/olsen/Code/migration-svn-zu-git/logical-line-staging/clib2/trunk@14951 87f5fb63-7c3d-0410-a384-fd976d0f7a62
2005-05-15 12:32:59 +00:00

554 lines
12 KiB
C
Raw Blame History

/*
* $Id: unistd_translateu2a.c,v 1.9 2005-05-15 12:32:59 obarthel Exp $
*
* :ts=4
*
* Portable ISO 'C' (1994) runtime library for the Amiga computer
* Copyright (c) 2002-2005 by Olaf Barthel <olsen@sourcery.han.de>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Neither the name of Olaf Barthel nor the names of contributors
* may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*#define DEBUG*/
#ifndef _UNISTD_HEADERS_H
#include "unistd_headers.h"
#endif /* _UNISTD_HEADERS_H */
/****************************************************************************/
/*
* The following patterns must translate properly:
*
* foo/
* ///
* foo//bar
* foo//bar//baz
* ./foo
* ././foo
* foo/./baz
* foo/./bar/./baz
* foo/.
* /.
* /tmp
* /tmp/foo
* /dev/null
* /dev/null/foo
* /dev/nullX
* /foo
* /foo/
* /foo/bar
* /foo/bar/baz
* foo/../bar
* foo/bar/../../baz
* foo/bar/..
* ../foo
* ../../foo
* .
* ..
*/
/****************************************************************************/
int
__translate_unix_to_amiga_path_name(char const ** name_ptr,struct name_translation_info * nti)
{
int result = ERROR;
char * name;
/*PUSHDEBUGLEVEL(2);*/
assert( name_ptr != NULL && (*name_ptr) != NULL && nti != NULL );
name = (char *)(*name_ptr);
nti->is_root = FALSE;
/* If this is not an absolute Amiga path name, which we will accept "as is",
perform the translation and substitution. */
if(strchr(name,':') == NULL)
{
char volume_name[sizeof(nti->substitute)];
size_t volume_name_len;
char * replace = nti->substitute;
size_t len,i,j;
/* Check if the name would become too long to handle. */
len = strlen(name);
if(len >= sizeof(nti->substitute))
{
D(("path name '%s' is too long (%ld characters total; maximum is %ld)!",name,len,sizeof(nti->substitute)-1));
__set_errno(ENAMETOOLONG);
goto out;
}
D(("initial name = '%s'",name));
/* Prepend an absolute path to the name, if such a path was previously set
as the current directory. */
if(__translate_relative_path_name((const char **)&name,nti->substitute,sizeof(nti->substitute)) < 0)
{
SHOWMSG("relative path name could not be worked into the pattern");
goto out;
}
/*<2A>If the name was replaced, update the string length cached. */
if(name != (*name_ptr))
{
D(("name after relative path replacement = '%s'",name));
len = strlen(name);
}
/* If there are neighboring slashes, strip all but one
('foo//bar' -> 'foo/bar'). The "//" pattern in a Unix
file name is apparently harmless, but on AmigaDOS it
has a very definite meaning. */
if(len > 2)
{
BOOL have_double_slash = FALSE;
for(i = 0 ; i < len - 1 ; i++)
{
if(name[i] == '/' && name[i + 1] == '/')
{
have_double_slash = TRUE;
break;
}
}
if(have_double_slash)
{
BOOL have_slash;
char c;
have_slash = FALSE;
for(i = j = 0 ; i < len ; i++)
{
c = name[i];
if(c == '/')
{
if(NOT have_slash)
replace[j++] = c;
have_slash = TRUE;
}
else
{
replace[j++] = c;
have_slash = FALSE;
}
}
name = replace;
len = j;
name[len] = '\0';
D(("name = '%s' (line %ld)",name,__LINE__));
}
}
/* If there are any, strip the trailing slashes ('foo/' -> 'foo'). A
leading '/' must be preserved, though ('///' -> '/'). */
if(len > 1)
{
size_t num_trailing_slashes = 0;
while((num_trailing_slashes < len - 1) && (name[len - (num_trailing_slashes + 1)] == '/'))
num_trailing_slashes++;
if(num_trailing_slashes > 0)
{
len -= num_trailing_slashes;
if(name != replace)
{
memmove(replace,name,len);
name = replace;
}
name[len] = '\0';
D(("name = '%s' (line %ld)",name,__LINE__));
}
}
/* Ditch all leading './' ('./foo' -> 'foo'). */
while(len > 2 && name[0] == '.' && name[1] == '/')
{
name += 2;
len -= 2;
D(("name = '%s' (line %ld)",name,__LINE__));
}
/* Ditch all embedded '/./' ('foo/./bar' -> 'foo/bar'). */
if(len > 2)
{
BOOL have_slash_dot_slash = FALSE;
for(i = j = 0 ; i < len - 2 ; i++)
{
if(name[i] == '/' && name[i + 1] == '.' && name[i + 2] == '/')
{
have_slash_dot_slash = TRUE;
break;
}
}
if(have_slash_dot_slash)
{
for(i = j = 0 ; i < len ; i++)
{
replace[j++] = name[i];
if(name[i] == '/' && name[i + 1] == '.' && name[i + 2] == '/')
i += 2;
}
len = j;
name = replace;
name[len] = '\0';
D(("name = '%s' (line %ld)",name,__LINE__));
}
}
/* Special case: the path name may end with "/." signifying that the
directory itself is requested ('foo/.' -> 'foo'). */
if(len >= 2 && strncmp(&name[len - 2],"/.",2) == SAME)
{
/* If it's just '/.' then it's really '/'. */
if(len == 2)
{
strcpy(replace,"/");
name = replace;
len = 1;
}
else
{
if(name != replace)
{
memmove(replace,name,len - 2);
name = replace;
}
len -= 2;
}
name[len] = '\0';
D(("name = '%s' (line %ld)",name,__LINE__));
}
/* Check for absolute path. */
if(name[0] == '/')
{
if(len == 1)
{
SHOWMSG("this is the root directory");
nti->is_root = TRUE;
}
/* Ok, so this is an absolute path. We begin by checking
for a few special cases, the first being a reference
to "/tmp". */
if((strncmp(name,"/tmp",4) == SAME) && (name[4] == '/' || len == 4))
{
if(name[4] == '/')
{
/* Convert "/tmp/foo" to "T:foo". */
memmove(&replace[2],&name[5],len - 5);
memmove(replace,"T:",2);
len -= 3;
}
else
{
/* Convert "/tmp" to "T:". */
strcpy(replace,"T:");
len = 2;
}
name = replace;
name[len] = '\0';
D(("name = '%s' (line %ld)",name,__LINE__));
}
else if ((strncmp(name,"/dev/null",9)) == SAME && (len == 9 || name[9] == '/'))
{
strcpy(replace,"NIL:");
name = replace;
len = 4;
name[len] = '\0';
D(("name = '%s' (line %ld)",name,__LINE__));
}
else
{
size_t path_name_start = 0;
volume_name_len = 0;
/* Find out how long the first component
of the absolute path is. */
for(i = 1 ; i <= len ; i++)
{
if(i == len || name[i] == '/')
{
volume_name_len = i - 1;
/* Is there anything following the path name? */
if(i < len)
path_name_start = i + 1;
break;
}
}
/* Copy the first component and attach a colon. "/foo" becomes "foo:". */
memmove(replace,&name[1],volume_name_len);
replace[volume_name_len++] = ':';
/* Now add the finishing touches. "/foo/bar" finally
becomes "foo:bar" and "/foo" becomes "foo:". */
if(path_name_start > 0)
{
memmove(&replace[volume_name_len],&name[path_name_start],len - path_name_start);
len--;
}
name = replace;
name[len] = '\0';
D(("name = '%s' (line %ld)",name,__LINE__));
}
}
/* Extract and remove the volume name from the path. We
are going to need it later. */
volume_name_len = 0;
for(i = 0 ; i < len ; i++)
{
if(name[i] == ':')
{
/* Look for extra colon characters embedded in the name
(as in "foo/bar:baz") which really don't belong here. */
for(j = 0 ; j < i ; j++)
{
if(name[j] == '/')
{
D(("name '%s' still contains colon characters",name));
__set_errno(EINVAL); /* invalid name */
goto out;
}
}
volume_name_len = i + 1;
memmove(volume_name,name,volume_name_len);
name += volume_name_len;
len -= volume_name_len;
D(("name = '%s' (line %ld)",name,__LINE__));
break;
}
}
/* Look for extra colon characters embedded in the name
(as in "foo:bar:baz") which really don't belong here. */
for(i = 0 ; i < len ; i++)
{
if(name[i] == ':')
{
D(("name '%s' still contains colon characters",name));
__set_errno(EINVAL); /* invalid name */
goto out;
}
}
/* Now parse the path name and replace all embedded '..' with
the AmigaDOS counterparts ('foo/../bar' -> 'foo//bar'). */
if(len > 3)
{
BOOL have_slash_dot_dot_slash = FALSE;
for(i = j = 0 ; i < len - 3 ; i++)
{
if(name[i] == '/' && name[i + 1] == '.' && name[i + 2] == '.' && name[i + 3] == '/')
{
have_slash_dot_dot_slash = TRUE;
break;
}
}
if(have_slash_dot_dot_slash)
{
for(i = j = 0 ; i < len ; i++)
{
replace[j++] = name[i];
if(name[i] == '/' && name[i + 1] == '.' && name[i + 2] == '.' && name[i + 3] == '/')
i += 2;
}
len = j;
name = replace;
name[len] = '\0';
D(("name = '%s' (line %ld)",name,__LINE__));
}
}
/* Translate a trailing '/..' to '//' */
if(len >= 3 && strncmp(&name[len - 3],"/..",3) == SAME)
{
if(name != replace)
{
memmove(replace,name,len - 2);
name = replace;
}
len -= 2;
name[len++] = '/';
name[len] = '\0';
D(("name = '%s' (line %ld)",name,__LINE__));
}
/* Translate a leading '../' ('../foo' -> '/foo') */
if(len >= 3 && strncmp(name,"../",3) == SAME)
{
memmove(replace,&name[2],len - 2);
name = replace;
len -= 2;
name[len] = '\0';
D(("name = '%s' (line %ld)",name,__LINE__));
}
/* Translate the '..' ('..' -> '/') */
if(len == 2 && strncmp(name,"..",2) == SAME)
{
strcpy(replace,"/");
name = replace;
len = 1;
D(("name = '%s' (line %ld)",name,__LINE__));
}
/* Translate the '.' ('.' -> '') */
if(len == 1 && name[0] == '.')
{
strcpy(replace,"");
name = replace;
len = 0;
D(("name = '%s' (line %ld)",name,__LINE__));
}
/* Now put it all together again. */
if(volume_name_len > 0)
{
memmove(&replace[volume_name_len],name,len);
memmove(replace,volume_name,volume_name_len);
len += volume_name_len;
name = replace;
name[len] = '\0';
D(("name = '%s' (line %ld)",name,__LINE__));
}
/* Reduce any "//" embedded in the name, if necessary. */
if(len > 1)
{
BOOL have_double_slash = FALSE;
for(i = 0 ; i < len - 1 ; i++)
{
if(name[i] == '/' && name[i + 1] == '/')
{
have_double_slash = TRUE;
break;
}
}
if(have_double_slash)
{
if(name != replace)
{
memmove(replace,name,len);
name = replace;
}
len = __strip_double_slash(name,len);
D(("name = '%s' (line %ld)",name,__LINE__));
}
}
/* The following is somewhat controversial. It assumes that what comes out
as a path name that ends with ":/" should translate into the root
directory. This would not be the case for the names of assignments,
though, for which the "/" suffix would actually do something useful. */
if(len >= 2 && strncmp(&name[len - 2],":/",2) == SAME)
nti->is_root = TRUE;
}
nti->original_name = (char *)(*name_ptr);
(*name_ptr) = name;
D(("translated '%s' to '%s'",nti->original_name,name));
result = OK;
out:
/*POPDEBUGLEVEL();*/
return(result);
}
Reference in New Issue View Git Blame Copy Permalink