Subversion Repositories DevTools

/***************************************************************************
* Module name   : realpath.c
* Module type   : CMDFILE source file
* Environment(s): n/a
*
* Description:
     realpath resolves all links and references to '.' and
     .' in "file_name" and stores it in "resolved_name".

     It can handle both relative and absolute path names. 
     For absolute path names and relative path whose resolved
     name cannot be expressed relatively (for example,
     ../../reldir), it returns the resolved absolute name.  For
     other relative names, it returns the resolved relative name.

     resolved name must be be big enough (MAXPATHLEN) to
     contain the fully resolved path name.

Returns:
     The realpath function returns the address of the string 
     containing the name of the resolved directory, unless an 
     error occurs, in which case NULL is returned.

*
* Version   Who      Date        Description
            APY      02/03/00    Created
*
* $Source: /cvsroot/device/DEVL/UTILS/CMDFILE/realpath.c,v $            
* $Revision: 1.5 $ $Date: 2004/10/08 03:07:37 $ $State: Exp $ 
* $Author: ayoung $ $Locker:  $
*.........................................................................*/
/*
*     Include Files
*     ---------------
*/
#include <ctype.h>
#include <unistd.h>
#if defined(WIN32)
#include <windows.h>
#endif
#include "cmdfile.h"

const char *        Realpath( const char *name, char *buf );
#if defined(MSDOS)
static void         dos_realpath( const char *in, char *out, char sep );
#endif


int
do_realpath( String_t *str, const char *s )
{
    char name[ PATH_MAX ], buf[ PATH_MAX ];
    int  len;

    if (expected(s++, ',') > 0 &&
            (len = pathargument(s, name, PATH_MAX)) > 0)
    {
        const char *p;

        p = Realpath( name, buf );
        verbose( " realpath(%s) = %s", name, p );
        StringPath( str, p );
        return (1+len);
    }
    return (-1);
}


const char *
Realpath(const char *name, char *buf)
{
#if defined(unix)
    const char *p;

    memset(buf, 0, PATH_MAX);                   /* PURIFY - solaris realpath illuse of 'buf'*/
    if ((p = realpath(name, buf)) == name && name != NULL)
        if (buf == NULL)
        {                                       /* NULL output buffer */
            errno = EFAULT;
            p = NULL;
        }
        else
        {                                       /* 'abs' match, copy to dest */
            (void) strcpy(buf, name);
            p = buf;
        }
    return (p);

#elif defined(WIN32)
    const char *p;

                                                /* restore full path */
    if ((p = _fullpath(buf, name, PATH_MAX)) == NULL && name != NULL)
        if (buf == NULL)
        {                                       /* NULL output buffer */
            errno = EFAULT;
            p = NULL;
        }
        else
        {                                       /* 'abs' match, copy to dest */
            (void) strcpy(buf, name);
            p = buf;
        }
    return (p);

#elif defined(MSDOS)
    char sep;

    sep = strchr(name, '/') ? '/' : '\\';       /* handle UNIX, default MSDOS */
    (void) dos_realpath(name, buf, sep);
    return (buf);

#else
#error Unknown target OS ...
#endif
}


#if defined(MSDOS)
/* realpath ---
 *
 *  Takes as input an arbitrary path.  Fixes up the path by:
 *      1.  Convert relative path to absolute
 *      2.  Removing consecutive slashes
 *      3.  Removing trailing slashes
 *      4.  Making the path absolute if it wasn't already
 *      5.  Removing "." in the path
 *      6.  Removing ".." entries in the path (and the directory above them)
 */
static char         *get_cwd(char *out, int drive, char sep);

static void
dos_realpath( const char *in, char *out, char sep )
{
    register const char *i = in;
    register char *o = out;

/* Convert relative path to absolute */
    {
        int drive;

        if (*(i+1) == ':' &&
                ((*i >= 'a' && *i <= 'z') || (*i >= 'A' && *i <= 'Z'))) {
            if (*i >= 'a' && *i <= 'z')
                drive = *i - 'a';
            else drive = *i - 'A';
            *o++ = *i++;
            *o++ = *i++;
        } else {
            drive = GetDisk();
            *o++ = drive + 'A';
            *o++ = ':';
        }
        if (!is_slash(*i))
            o = get_cwd(o, drive, sep);
    }

/* Step through the input path */
    while (*i != '\0')
    {
    /* Skip input slashes */
        if (is_slash(*i))
        {
            i++;
            continue;
        }

    /* Skip "." and output nothing */
        if (*i == '.' && is_term(*(i + 1)))
        {
            i++; continue;
        }

    /* Skip ".." and remove previous output directory */
        if (*i == '.' && *(i + 1) == '.' && is_term(*(i + 2)))
        {
        /* Don't back up over drive spec or consume ../.. */
            if (o > out+2 && strncmp(o-2, "..", 2) != 0)
            {
            /* Consume .. and parent directory */
                i += 2;
                while (--o > out+2 && !is_slash(*o))
                    ;
                continue;
            }
        }

    /* Copy path component from in to p */
        *o++ = sep;

    /* Copy next filename/directory */
        while (!is_term(*i))
            *o++ = *i++;
    }
    *o = '\0';
}


static int
get_disk(void)
{
#ifdef __WATCOMC__
    unsigned drive;
    _dos_getdrive(&drive);
    return 0;
#else
    union REGS regs;
    regs.h.ah = 0x19;                           /* DOS Get Default Drive call */
    regs.h.al = 0;
    (void) intdos(&regs, &regs);
    return regs.h.al;
#endif
}


static char *
get_cwd(char *out, int drive, char sep)
{
    char cwd[ PATH_MAX ];
    register char *p, *o;

/* Get current work directory */
    {
        union REGS  regs;
        regs.h.ah   = 0x47;
        regs.h.dl   = drive + 1;
    #ifdef __386__
        regs.x.esi  = (unsigned long) cwd;
    #else
        regs.x.si   = (unsigned long) cwd;
    #endif
        (void) intdos(&regs, &regs);
    #ifdef __WATCOMC__
        if (regs.w.cflag != 0) {
            errno = regs.w.ax;
            return out;
        }
    #else
        if (regs.x.cflag != 0) {
            errno = regs.x.ax;
            return out;
        }
    #endif
    }

/* Copy and convert path */
    for (p = cwd, o = out+1; *p; p++)
         *o++ = is_slash(*p) ? sep : *p;
    *o = '\0';

/* Root path, don't insert "/", it'll be added later */
    if (*(out+1) != '\0')
        *out = sep;
    else *out = '\0';
    return (out + strlen(out));
}
#endif  /*MSDOS*/