Runtime/r3/path.cpp

	path.cpp revision fa1bb60e72e0f90a8bf676d5d824f51657d99ff8
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync/* $Id$ */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync/** @file
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync * IPRT - Path Manipulation.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync/*
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * Copyright (C) 2006-2007 Sun Microsystems, Inc.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync *
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * available from http://www.virtualbox.org. This file is free software;
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync * you can redistribute it and/or modify it under the terms of the GNU
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync * General Public License (GPL) as published by the Free Software
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync *
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync * The contents of this file may alternatively be used under the terms
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync * of the Common Development and Distribution License Version 1.0
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync * VirtualBox OSE distribution, in which case the provisions of the
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync * CDDL are applicable instead of those of the GPL.
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync *
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync * You may elect to license modified versions of this file under the
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync * terms and conditions of either the GPL or the CDDL or both.
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync *
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * Clara, CA 95054 USA or visit http://www.sun.com if you need
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * additional information or have any questions.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync/*******************************************************************************
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync*   Header Files                                                               *
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync*******************************************************************************/
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#include <iprt/path.h>
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#include <iprt/dir.h>
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#include <iprt/param.h>
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#include <iprt/string.h>
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#include <iprt/assert.h>
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#include <iprt/string.h>
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#include <iprt/ctype.h>
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#include <iprt/err.h>
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#include <iprt/uni.h>
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#include "internal/fs.h"
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#include "internal/path.h"
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#include "internal/process.h"
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync/**
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * Strips the filename from a path. Truncates the given string in-place by overwriting the
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * last path separator character with a null byte in a platform-neutral way.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync *
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * @param   pszPath     Path from which filename should be extracted, will be truncated.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync *                      If the string contains no path separator, it will be changed to a "." string.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsyncRTDECL(void) RTPathStripFilename(char *pszPath)
0493c79a1867f7760af6bc330c8c42a09da852abvboxsync{
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    char *psz = pszPath;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    char *pszLastSep = NULL;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    for (;; psz++)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    {
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync        switch (*psz)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync        {
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            /* handle separators. */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            case ':':
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                pszLastSep = psz + 1;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                if (RTPATH_IS_SLASH(psz[1]))
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                    pszPath = psz + 1;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                else
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                    pszPath = psz;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                break;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            case '\\':
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#endif
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            case '/':
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                pszLastSep = psz;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                break;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            /* the end */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            case '\0':
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                if (!pszLastSep)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                {
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                    /* no directory component */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                    pszPath[0] = '.';
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                    pszPath[1] = '\0';
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync                }
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                else if (pszLastSep == pszPath)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                {
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                    /* only root. */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                    pszLastSep[1] = '\0';
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                }
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                else
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                    pszLastSep[0] = '\0';
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                return;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync        }
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    }
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    /* will never get here */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync}
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync/**
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * Strips the extension from a path.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync *
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * @param   pszPath     Path which extension should be stripped.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsyncRTDECL(void) RTPathStripExt(char *pszPath)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync{
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    char *pszDot = NULL;
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync    for (;; pszPath++)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    {
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync        switch (*pszPath)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync        {
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            /* handle separators. */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            case ':':
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            case '\\':
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#endif
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            case '/':
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                pszDot = NULL;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                break;
b4fc07ae3f394595370fc5ed6ab1c353a87259dbvboxsync            case '.':
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                pszDot = pszPath;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                break;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            /* the end */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            case '\0':
b4fc07ae3f394595370fc5ed6ab1c353a87259dbvboxsync                if (pszDot)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                    *pszDot = '\0';
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                return;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync        }
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    }
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    /* will never get here */
8bed792bc65abd39393889351f22263ce6c289bfvboxsync}
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync/**
b4fc07ae3f394595370fc5ed6ab1c353a87259dbvboxsync * Parses a path.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync *
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * It figures the length of the directory component, the offset of
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * the file name and the location of the suffix dot.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync *
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * @returns The path length.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync *
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * @param   pszPath     Path to find filename in.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * @param   pcbDir      Where to put the length of the directory component.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync *                      If no directory, this will be 0. Optional.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * @param   poffName    Where to store the filename offset.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync *                      If empty string or if it's ending with a slash this
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync *                      will be set to -1. Optional.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * @param   poffSuff    Where to store the suffix offset (the last dot).
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync *                      If empty string or if it's ending with a slash this
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync *                      will be set to -1. Optional.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * @param   pfFlags     Where to set flags returning more information about
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync *                      the path. For the future. Optional.
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync */
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsyncRTDECL(size_t) RTPathParse(const char *pszPath, size_t *pcchDir, ssize_t *poffName, ssize_t *poffSuff)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync{
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    const char *psz = pszPath;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    ssize_t     offRoot = 0;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    const char *pszName = pszPath;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    const char *pszLastDot = NULL;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    for (;; psz++)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    {
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync        switch (*psz)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync        {
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync            /* handle separators. */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync            case ':':
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync                pszName = psz + 1;
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync                offRoot = pszName - psz;
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync                break;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            case '\\':
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#endif
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync            case '/':
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                pszName = psz + 1;
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync                break;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            case '.':
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                pszLastDot = psz;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                break;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync            /*
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync             * The end. Complete the results.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync             */
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync            case '\0':
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync            {
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                ssize_t offName = *pszName != '\0' ? pszName - pszPath : -1;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                if (poffName)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                    *poffName = offName;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                if (poffSuff)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                {
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                    ssize_t offSuff = -1;
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync                    if (pszLastDot)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                    {
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync                        offSuff = pszLastDot - pszPath;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                        if (offSuff <= offName)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                            offSuff = -1;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                    }
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                    *poffSuff = offSuff;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                }
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                if (pcchDir)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                {
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync                    ssize_t off = offName - 1;
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync                    while (off >= offRoot && RTPATH_IS_SLASH(pszPath[off]))
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                        off--;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                    *pcchDir = RT_MAX(off, offRoot) + 1;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                }
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                return psz - pszPath;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            }
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync        }
a0f8619bc2bbe3614578c21b5b50a88d2841e7aavboxsync    }
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    /* will never get here */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    return 0;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync}
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync/**
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * Finds the filename in a path.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync *
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * @returns Pointer to filename within pszPath.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * @returns NULL if no filename (i.e. empty string or ends with a slash).
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync * @param   pszPath     Path to find filename in.
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsyncRTDECL(char *) RTPathFilename(const char *pszPath)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync{
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    const char *psz = pszPath;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    const char *pszName = pszPath;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    for (;; psz++)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    {
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync        switch (*psz)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync        {
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            /* handle separators. */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            case ':':
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                pszName = psz + 1;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                break;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            case '\\':
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync#endif
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            case '/':
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                pszName = psz + 1;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                break;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            /* the end */
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync            case '\0':
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                if (*pszName)
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                    return (char *)(void *)pszName;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync                return NULL;
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync        }
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync    }
632b4638bd18092c6b8edb4e1028c9be112f5076vboxsync
    /* will never get here */
    return NULL;
}


/**
 * Strips the trailing slashes of a path name.
 *
 * @param   pszPath     Path to strip.
 *
 * @todo    This isn't safe for a root element! Needs fixing.
 */
RTDECL(void) RTPathStripTrailingSlash(char *pszPath)
{
    char *pszEnd = strchr(pszPath, '\0');
    while (pszEnd-- > pszPath)
    {
        switch (*pszEnd)
        {
            case '/':
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
            case '\\':
#endif
                *pszEnd = '\0';
                break;
            default:
                return;
        }
    }
    return;
}


/**
 * Finds the extension part of in a path.
 *
 * @returns Pointer to extension within pszPath.
 * @returns NULL if no extension.
 * @param   pszPath     Path to find extension in.
 */
RTDECL(char *) RTPathExt(const char *pszPath)
{
    const char *psz = pszPath;
    const char *pszExt = NULL;

    for (;; psz++)
    {
        switch (*psz)
        {
            /* handle separators. */
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
            case ':':
                pszExt = NULL;
                break;

            case '\\':
#endif
            case '/':
                pszExt = NULL;
                break;
            case '.':
                pszExt = psz;
                break;

            /* the end */
            case '\0':
                if (pszExt)
                    return (char *)(void *)pszExt;
                return NULL;
        }
    }

    /* will never get here */
    return NULL;
}


/**
 * Checks if a path have an extension.
 *
 * @returns true if extension present.
 * @returns false if no extension.
 * @param   pszPath     Path to check.
 */
RTDECL(bool) RTPathHaveExt(const char *pszPath)
{
    return RTPathExt(pszPath) != NULL;
}


/**
 * Checks if a path includes more than a filename.
 *
 * @returns true if path present.
 * @returns false if no path.
 * @param   pszPath     Path to check.
 */
RTDECL(bool) RTPathHavePath(const char *pszPath)
{
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
    return strpbrk(pszPath, "/\\:") != NULL;
#else
    return strpbrk(pszPath, "/") != NULL;
#endif
}


/**
 * Helper for RTPathCompare() and RTPathStartsWith().
 *
 * @returns similar to strcmp.
 * @param   pszPath1        Path to compare.
 * @param   pszPath2        Path to compare.
 * @param   fLimit          Limit the comparison to the length of \a pszPath2
 * @internal
 */
static int rtPathCompare(const char *pszPath1, const char *pszPath2, bool fLimit)
{
    if (pszPath1 == pszPath2)
        return 0;
    if (!pszPath1)
        return -1;
    if (!pszPath2)
        return 1;

#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
    PRTUNICP puszPath1;
    int rc = RTStrToUni(pszPath1, &puszPath1);
    if (RT_FAILURE(rc))
        return -1;
    PRTUNICP puszPath2;
    rc = RTStrToUni(pszPath2, &puszPath2);
    if (RT_FAILURE(rc))
    {
        RTUniFree(puszPath1);
        return 1;
    }

    int iDiff = 0;
    PRTUNICP puszTmpPath1 = puszPath1;
    PRTUNICP puszTmpPath2 = puszPath2;
    for (;;)
    {
        register RTUNICP uc1 = *puszTmpPath1;
        register RTUNICP uc2 = *puszTmpPath2;
        if (uc1 != uc2)
        {
            if (uc1 == '\\')
                uc1 = '/';
            else
                uc1 = RTUniCpToUpper(uc1);
            if (uc2 == '\\')
                uc2 = '/';
            else
                uc2 = RTUniCpToUpper(uc2);
            if (uc1 != uc2)
            {
                iDiff = uc1 > uc2 ? 1 : -1; /* (overflow/underflow paranoia) */
                if (fLimit && uc2 == '\0')
                    iDiff = 0;
                break;
            }
        }
        if (!uc1)
            break;
        puszTmpPath1++;
        puszTmpPath2++;

    }

    RTUniFree(puszPath2);
    RTUniFree(puszPath1);
    return iDiff;

#else
    if (!fLimit)
        return strcmp(pszPath1, pszPath2);
    return strncmp(pszPath1, pszPath2, strlen(pszPath2));
#endif
}


/**
 * Compares two paths.
 *
 * The comparison takes platform-dependent details into account,
 * such as:
 * <ul>
 * <li>On DOS-like platforms, both |\| and |/| separator chars are considered
 *     to be equal.
 * <li>On platforms with case-insensitive file systems, mismatching characters
 *     are uppercased and compared again.
 * </ul>
 *
 * @remark
 *
 * File system details are currently ignored. This means that you won't get
 * case-insentive compares on unix systems when a path goes into a case-insensitive
 * filesystem like FAT, HPFS, HFS, NTFS, JFS, or similar. For NT, OS/2 and similar
 * you'll won't get case-sensitve compares on a case-sensitive file system.
 *
 * @param   pszPath1    Path to compare (must be an absolute path).
 * @param   pszPath2    Path to compare (must be an absolute path).
 *
 * @returns @< 0 if the first path less than the second path.
 * @returns 0 if the first path identical to the second path.
 * @returns @> 0 if the first path greater than the second path.
 */
RTDECL(int) RTPathCompare(const char *pszPath1, const char *pszPath2)
{
    return rtPathCompare(pszPath1, pszPath2, false /* full path lengths */);
}


/**
 * Checks if a path starts with the given parent path.
 *
 * This means that either the path and the parent path matches completely, or that
 * the path is to some file or directory residing in the tree given by the parent
 * directory.
 *
 * The path comparison takes platform-dependent details into account,
 * see RTPathCompare() for details.
 *
 * @param   pszPath         Path to check, must be an absolute path.
 * @param   pszParentPath   Parent path, must be an absolute path.
 *                          No trailing directory slash!
 *
 * @returns |true| when \a pszPath starts with \a pszParentPath (or when they
 *          are identical), or |false| otherwise.
 *
 * @remark  This API doesn't currently handle root directory compares in a manner
 *          consistant with the other APIs. RTPathStartsWith(pszSomePath, "/") will
 *          not work if pszSomePath isn't "/".
 */
RTDECL(bool) RTPathStartsWith(const char *pszPath, const char *pszParentPath)
{
    if (pszPath == pszParentPath)
        return true;
    if (!pszPath || !pszParentPath)
        return false;

    if (rtPathCompare(pszPath, pszParentPath, true /* limited by path 2 */) != 0)
        return false;

    const size_t cchParentPath = strlen(pszParentPath);
    return RTPATH_IS_SLASH(pszPath[cchParentPath])
        || pszPath[cchParentPath] == '\0';
}


/**
 * Same as RTPathReal only the result is RTStrDup()'ed.
 *
 * @returns Pointer to real path. Use RTStrFree() to free this string.
 * @returns NULL if RTPathReal() or RTStrDup() fails.
 * @param   pszPath
 */
RTDECL(char *) RTPathRealDup(const char *pszPath)
{
    char szPath[RTPATH_MAX];
    int rc = RTPathReal(pszPath, szPath, sizeof(szPath));
    if (RT_SUCCESS(rc))
        return RTStrDup(szPath);
    return NULL;
}


/**
 * Same as RTPathAbs only the result is RTStrDup()'ed.
 *
 * @returns Pointer to real path. Use RTStrFree() to free this string.
 * @returns NULL if RTPathAbs() or RTStrDup() fails.
 * @param   pszPath         The path to resolve.
 */
RTDECL(char *) RTPathAbsDup(const char *pszPath)
{
    char szPath[RTPATH_MAX];
    int rc = RTPathAbs(pszPath, szPath, sizeof(szPath));
    if (RT_SUCCESS(rc))
        return RTStrDup(szPath);
    return NULL;
}


/**
 * Returns the length of the volume name specifier of the given path.
 * If no such specifier zero is returned.
 */
size_t rtPathVolumeSpecLen(const char *pszPath)
{
#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
    if (pszPath && *pszPath)
    {
        /* UTC path. */
        if (    (pszPath[0] == '\\' || pszPath[0] == '/')
            &&  (pszPath[1] == '\\' || pszPath[1] == '/'))
            return strcspn(pszPath + 2, "\\/") + 2;

        /* Drive letter. */
        if (    pszPath[1] == ':'
            &&  toupper(pszPath[0]) >= 'A' && toupper(pszPath[0]) <= 'Z')
            return 2;
    }
    return 0;

#else
    /* This isn't quite right when looking at the above stuff, but it works assuming that '//' does not mean UNC. */
    /// @todo (dmik) well, it's better to consider there's no volume name
    //  at all on *nix systems
    return 0;
//    return pszPath && pszPath[0] == '/';
#endif
}


/**
 * Get the absolute path (no symlinks, no . or .. components), assuming the
 * given base path as the current directory. The resulting path doesn't have
 * to exist.
 *
 * @returns iprt status code.
 * @param   pszBase         The base path to act like a current directory.
 *                          When NULL, the actual cwd is used (i.e. the call
 *                          is equivalent to RTPathAbs(pszPath, ...).
 * @param   pszPath         The path to resolve.
 * @param   pszAbsPath      Where to store the absolute path.
 * @param   cchAbsPath      Size of the buffer.
 */
RTDECL(int) RTPathAbsEx(const char *pszBase, const char *pszPath, char *pszAbsPath, size_t cchAbsPath)
{
    if (pszBase && pszPath && !rtPathVolumeSpecLen(pszPath))
    {
#if defined(RT_OS_WINDOWS)
        /* The format for very long paths is not supported. */
        if (    (pszBase[0] == '/' || pszBase[0] == '\\')
            &&  (pszBase[1] == '/' || pszBase[1] == '\\')
            &&   pszBase[2] == '?'
            &&  (pszBase[3] == '/' || pszBase[3] == '\\'))
            return VERR_INVALID_NAME;
#endif

        /** @todo there are a couple of things which isn't 100% correct, although the
         * current code will have to work for now - I don't have time to fix it right now.
         *
         * 1) On Windows & OS/2 we confuse '/' with an abspath spec and will
         *    not necessarily resolve it on the right drive.
         * 2) A trailing slash in the base might cause UNC names to be created.
         * 3) The lengths total doesn't have to be less than max length
         *    if the pszPath starts with a slash.
         */
        size_t cchBase = strlen(pszBase);
        size_t cchPath = strlen(pszPath);
        if (cchBase + cchPath >= RTPATH_MAX)
            return VERR_FILENAME_TOO_LONG;

        bool fRootSpec = pszPath[0] == '/'
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
            || pszPath[0] == '\\'
#endif
            ;
        size_t cchVolSpec = rtPathVolumeSpecLen(pszBase);
        char szPath[RTPATH_MAX];
        if (fRootSpec)
        {
            /* join the disk name from base and the path */
            memcpy(szPath, pszBase, cchVolSpec);
            strcpy(&szPath[cchVolSpec], pszPath);
        }
        else
        {
            /* join the base path and the path */
            strcpy(szPath, pszBase);
            szPath[cchBase] = RTPATH_DELIMITER;
            strcpy(&szPath[cchBase + 1], pszPath);
        }
        return RTPathAbs(szPath, pszAbsPath, cchAbsPath);
    }

    /* Fallback to the non *Ex version */
    return RTPathAbs(pszPath, pszAbsPath, cchAbsPath);
}


/**
 * Same as RTPathAbsEx only the result is RTStrDup()'ed.
 *
 * @returns Pointer to the absolute path. Use RTStrFree() to free this string.
 * @returns NULL if RTPathAbsEx() or RTStrDup() fails.
 * @param   pszBase         The base path to act like a current directory.
 *                          When NULL, the actual cwd is used (i.e. the call
 *                          is equivalent to RTPathAbs(pszPath, ...).
 * @param   pszPath         The path to resolve.
 */
RTDECL(char *) RTPathAbsExDup(const char *pszBase, const char *pszPath)
{
    char szPath[RTPATH_MAX];
    int rc = RTPathAbsEx(pszBase, pszPath, szPath, sizeof(szPath));
    if (RT_SUCCESS(rc))
        return RTStrDup(szPath);
    return NULL;
}


#ifndef RT_MINI

RTDECL(int) RTPathProgram(char *pszPath, size_t cchPath)
{
    AssertReturn(g_szrtProcExePath[0], VERR_WRONG_ORDER);

    /*
     * Calc the length and check if there is space before copying.
     */
    size_t cch = g_cchrtProcDir;
    if (cch <= cchPath)
    {
        memcpy(pszPath, g_szrtProcExePath, cch);
        pszPath[cch] = '\0';
        return VINF_SUCCESS;
    }

    AssertMsgFailed(("Buffer too small (%zu <= %zu)\n", cchPath, cch));
    return VERR_BUFFER_OVERFLOW;
}


/**
 * Gets the directory for architecture-independent application data, for
 * example NLS files, module sources, ...
 *
 * Linux:    /usr/shared/@<application@>
 * Windows:  @<program files directory@>/@<application@>
 * Old path: same as RTPathProgram()
 *
 */
RTDECL(int) RTPathAppPrivateNoArch(char *pszPath, size_t cchPath)
{
#if !defined(RT_OS_WINDOWS) && defined(RTPATH_APP_PRIVATE)
    char *pszUtf8Path;
    int rc;
    rc = rtPathFromNative(&pszUtf8Path, RTPATH_APP_PRIVATE);
    if (RT_SUCCESS(rc))
    {
        size_t cchPathPrivateNoArch = strlen(pszUtf8Path);
        if (cchPathPrivateNoArch < cchPath)
            memcpy(pszPath, pszUtf8Path, cchPathPrivateNoArch + 1);
        else
            rc = VERR_BUFFER_OVERFLOW;
        RTStrFree(pszUtf8Path);
    }
    return rc;
#else
    return RTPathProgram(pszPath, cchPath);
#endif
}


/**
 * Gets the directory for architecture-dependent application data, for
 * example modules which can be loaded at runtime.
 *
 * Linux:    /usr/lib/@<application@>
 * Windows:  @<program files directory@>/@<application@>
 * Old path: same as RTPathProgram()
 *
 * @returns iprt status code.
 * @param   pszPath     Buffer where to store the path.
 * @param   cchPath     Buffer size in bytes.
 */
RTDECL(int) RTPathAppPrivateArch(char *pszPath, size_t cchPath)
{
#if !defined(RT_OS_WINDOWS) && defined(RTPATH_APP_PRIVATE_ARCH)
    char *pszUtf8Path;
    int rc;
    rc = rtPathFromNative(&pszUtf8Path, RTPATH_APP_PRIVATE_ARCH);
    if (RT_SUCCESS(rc))
    {
        size_t cchPathPrivateArch = strlen(pszUtf8Path);
        if (cchPathPrivateArch < cchPath)
            memcpy(pszPath, pszUtf8Path, cchPathPrivateArch + 1);
        else
            rc = VERR_BUFFER_OVERFLOW;
        RTStrFree(pszUtf8Path);
    }
    return rc;
#else
    return RTPathProgram(pszPath, cchPath);
#endif
}


/**
 * Gets the directory of shared libraries. This is not the same as
 * RTPathAppPrivateArch() as Linux depends all shared libraries in
 * a common global directory where ld.so can found them.
 *
 * Linux:    /usr/lib
 * Windows:  @<program files directory@>/@<application@>
 * Old path: same as RTPathProgram()
 *
 * @returns iprt status code.
 * @param   pszPath     Buffer where to store the path.
 * @param   cchPath     Buffer size in bytes.
 */
RTDECL(int) RTPathSharedLibs(char *pszPath, size_t cchPath)
{
#if !defined(RT_OS_WINDOWS) && defined(RTPATH_SHARED_LIBS)
    char *pszUtf8Path;
    int rc;
    rc = rtPathFromNative(&pszUtf8Path, RTPATH_SHARED_LIBS);
    if (RT_SUCCESS(rc))
    {
        size_t cchPathSharedLibs = strlen(pszUtf8Path);
        if (cchPathSharedLibs < cchPath)
            memcpy(pszPath, pszUtf8Path, cchPathSharedLibs + 1);
        else
            rc = VERR_BUFFER_OVERFLOW;
        RTStrFree(pszUtf8Path);
    }
    return rc;
#else
    return RTPathProgram(pszPath, cchPath);
#endif
}


/**
 * Gets the directory for documentation.
 *
 * Linux:    /usr/share/doc/@<application@>
 * Windows:  @<program files directory@>/@<application@>
 * Old path: same as RTPathProgram()
 *
 * @returns iprt status code.
 * @param   pszPath     Buffer where to store the path.
 * @param   cchPath     Buffer size in bytes.
 */
RTDECL(int) RTPathAppDocs(char *pszPath, size_t cchPath)
{
#if !defined(RT_OS_WINDOWS) && defined(RTPATH_APP_DOCS)
    char *pszUtf8Path;
    int rc;
    rc = rtPathFromNative(&pszUtf8Path, RTPATH_APP_DOCS);
    if (RT_SUCCESS(rc))
    {
        size_t cchPathAppDocs = strlen(pszUtf8Path);
        if (cchPathAppDocs < cchPath)
            memcpy(pszPath, pszUtf8Path, cchPathAppDocs + 1);
        else
            rc = VERR_BUFFER_OVERFLOW;
        RTStrFree(pszUtf8Path);
    }
    return rc;
#else
    return RTPathProgram(pszPath, cchPath);
#endif
}

#endif /* !RT_MINI */