sal/osl/unx/file_path_helper.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <cassert>
  23 #include <utility>
  24
  25 #include "file_path_helper.hxx"
  26 #include "uunxapi.hxx"
  27
  28 #include <osl/diagnose.h>
  29 #include <rtl/ustring.hxx>
  30 #include <sal/log.hxx>
  31
  32 const sal_Unicode FPH_CHAR_PATH_SEPARATOR = '/';
  33 const sal_Unicode FPH_CHAR_DOT            = '.';
  34 const sal_Unicode FPH_CHAR_COLON          = ':';
  35
  36 void osl_systemPathRemoveSeparator(rtl_String* pstrPath)
  37 {
  38     OSL_PRECOND(nullptr != pstrPath, "osl_systemPathRemoveSeparator: Invalid parameter");
  39     if (pstrPath == nullptr)
  40         return;
  41
  42     // maybe there are more than one separator at end
  43     // so we run in a loop
  44     while ((pstrPath->length > 1) && (pstrPath->buffer[pstrPath->length - 1] == FPH_CHAR_PATH_SEPARATOR))
  45     {
  46         pstrPath->length--;
  47         pstrPath->buffer[pstrPath->length] = '\0';
  48     }
  49
  50     SAL_WARN_IF( !((0 == pstrPath->length) || (1 == pstrPath->length) ||
  51                  (pstrPath->length > 1 && pstrPath->buffer[pstrPath->length - 1] != FPH_CHAR_PATH_SEPARATOR)),
  52                  "sal.osl",
  53                  "osl_systemPathRemoveSeparator: Post condition failed");
  54 }
  55
  56 namespace {
  57
  58 template<typename T> void systemPathEnsureSeparator(T* ppstrPath)
  59 {
  60     assert(nullptr != ppstrPath);
  61     sal_Int32    lp = ppstrPath->getLength();
  62     sal_Int32    i  = ppstrPath->lastIndexOf(FPH_CHAR_PATH_SEPARATOR);
  63
  64     if ((lp > 1 && i != (lp - 1)) || ((lp < 2) && i < 0))
  65     {
  66         *ppstrPath += "/";
  67     }
  68
  69     SAL_WARN_IF( !ppstrPath->endsWith("/"),
  70                  "sal.osl",
  71                  "systemPathEnsureSeparator: Post condition failed");
  72 }
  73
  74 }
  75
  76 bool osl_systemPathIsRelativePath(const rtl_uString* pustrPath)
  77 {
  78     OSL_PRECOND(nullptr != pustrPath, "osl_systemPathIsRelativePath: Invalid parameter");
  79     return ((pustrPath == nullptr) || (pustrPath->length == 0) || (pustrPath->buffer[0] != FPH_CHAR_PATH_SEPARATOR));
  80 }
  81
  82 namespace {
  83
  84 template<typename T> T systemPathMakeAbsolutePath_(
  85     const T& BasePath,
  86     const T& RelPath)
  87 {
  88     T base(BasePath);
  89
  90     if (!base.isEmpty())
  91         systemPathEnsureSeparator(&base);
  92
  93     return base + RelPath;
  94 }
  95
  96 }
  97
  98 OString osl::systemPathMakeAbsolutePath(
  99     const OString& BasePath,
 100     const OString& RelPath)
 101 {
 102     return systemPathMakeAbsolutePath_(BasePath, RelPath);
 103 }
 104
 105 OUString osl::systemPathMakeAbsolutePath(
 106     const OUString& BasePath,
 107     const OUString& RelPath)
 108 {
 109     return systemPathMakeAbsolutePath_(BasePath, RelPath);
 110 }
 111
 112 void osl_systemPathGetFileNameOrLastDirectoryPart(
 113     const rtl_String*     pstrPath,
 114     rtl_String**       ppstrFileNameOrLastDirPart)
 115 {
 116     OSL_PRECOND(pstrPath && ppstrFileNameOrLastDirPart,
 117                 "osl_systemPathGetFileNameOrLastDirectoryPart: Invalid parameter");
 118
 119     OString path(const_cast<rtl_String*>(pstrPath));
 120
 121     osl_systemPathRemoveSeparator(path.pData);
 122
 123     OString last_part;
 124
 125     if (path.getLength() > 1 || (path.getLength() == 1 && path[0] != FPH_CHAR_PATH_SEPARATOR))
 126     {
 127         sal_Int32 idx_ps = path.lastIndexOf(FPH_CHAR_PATH_SEPARATOR);
 128         idx_ps++; // always right to increment by one even if idx_ps == -1!
 129         last_part = path.copy(idx_ps);
 130     }
 131     rtl_string_assign(ppstrFileNameOrLastDirPart, last_part.pData);
 132 }
 133
 134 bool osl_systemPathIsHiddenFileOrDirectoryEntry(
 135     const rtl_String* pstrPath)
 136 {
 137     OSL_PRECOND(nullptr != pstrPath, "osl_systemPathIsHiddenFileOrDirectoryEntry: Invalid parameter");
 138     if ((pstrPath == nullptr) || (pstrPath->length == 0))
 139         return false;
 140
 141     OString fdp;
 142     osl_systemPathGetFileNameOrLastDirectoryPart(pstrPath, &fdp.pData);
 143
 144     return ((fdp.pData->length > 0) &&
 145             (fdp.pData->buffer[0] == FPH_CHAR_DOT) &&
 146             !osl_systemPathIsLocalOrParentDirectoryEntry(fdp.pData));
 147 }
 148
 149 bool osl_systemPathIsLocalOrParentDirectoryEntry(
 150     const rtl_String* pstrPath)
 151 {
 152     OSL_PRECOND(pstrPath, "osl_systemPathIsLocalOrParentDirectoryEntry: Invalid parameter");
 153
 154     OString dirent;
 155
 156     osl_systemPathGetFileNameOrLastDirectoryPart(pstrPath, &dirent.pData);
 157
 158     return (dirent == "." ||
 159             dirent == "..");
 160 }
 161
 162 namespace {
 163
 164 /** Simple iterator for a path list separated by the specified character
 165 */
 166 class path_list_iterator
 167 {
 168 public:
 169
 170     /* after construction get_current_item
 171        returns the first path in list, no need
 172        to call reset first
 173      */
 174     path_list_iterator(OUString path_list, sal_Unicode list_separator = FPH_CHAR_COLON) :
 175         m_path_list(std::move(path_list)),
 176         m_end(m_path_list.getStr() + m_path_list.getLength() + 1),
 177         m_separator(list_separator)
 178     {
 179         reset();
 180     }
 181
 182     path_list_iterator(const path_list_iterator&) = delete;
 183     path_list_iterator& operator=(const path_list_iterator&) = delete;
 184
 185     void reset()
 186     {
 187         m_path_segment_begin = m_path_segment_end = m_path_list.getStr();
 188         advance();
 189     }
 190
 191     void next()
 192     {
 193         OSL_PRECOND(!done(), "path_list_iterator: Already done!");
 194
 195         m_path_segment_begin = ++m_path_segment_end;
 196         advance();
 197     }
 198
 199     bool done() const
 200     {
 201         return (m_path_segment_end >= m_end);
 202     }
 203
 204     OUString get_current_item() const
 205     {
 206         return OUString(
 207             m_path_segment_begin,
 208             (m_path_segment_end - m_path_segment_begin));
 209     }
 210
 211 private:
 212     /* move m_path_end to the next separator or
 213        to the end of the string
 214      */
 215     void advance()
 216     {
 217         while (!done() && *m_path_segment_end && (*m_path_segment_end != m_separator))
 218             ++m_path_segment_end;
 219
 220         OSL_ASSERT(m_path_segment_end <= m_end);
 221     }
 222
 223 private:
 224     OUString            m_path_list;
 225     const sal_Unicode*  m_end;
 226     const sal_Unicode   m_separator;
 227     const sal_Unicode*  m_path_segment_begin;
 228     const sal_Unicode*  m_path_segment_end;
 229 };
 230
 231 }
 232
 233 bool osl_searchPath(
 234     const rtl_uString* pustrFilePath,
 235     const rtl_uString* pustrSearchPathList,
 236     rtl_uString**      ppustrPathFound)
 237 {
 238     OSL_PRECOND(pustrFilePath && pustrSearchPathList && ppustrPathFound, "osl_searchPath: Invalid parameter");
 239
 240     bool               bfound = false;
 241     OUString      fp(const_cast<rtl_uString*>(pustrFilePath));
 242     OUString      pl(const_cast<rtl_uString*>(pustrSearchPathList));
 243     path_list_iterator pli(pl);
 244
 245     while (!pli.done())
 246     {
 247         OUString p = pli.get_current_item();
 248         systemPathEnsureSeparator(&p);
 249         p += fp;
 250
 251         if (osl::access(osl::OUStringToOString(p), F_OK) > -1)
 252         {
 253             bfound = true;
 254             rtl_uString_assign(ppustrPathFound, p.pData);
 255             break;
 256         }
 257         pli.next();
 258     }
 259     return bfound;
 260 }
 261
 262 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */