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 "file_path_helper.h"
  21 #include "file_path_helper.hxx"
  22 #include "uunxapi.hxx"
  23
  24 #include <osl/diagnose.h>
  25 #include <rtl/ustring.hxx>
  26
  27 const sal_Unicode FPH_CHAR_PATH_SEPARATOR = (sal_Unicode)'/';
  28 const sal_Unicode FPH_CHAR_DOT            = (sal_Unicode)'.';
  29 const sal_Unicode FPH_CHAR_COLON          = (sal_Unicode)':';
  30
  31 inline const rtl::OUString FPH_PATH_SEPARATOR()
  32 { return rtl::OUString(FPH_CHAR_PATH_SEPARATOR); }
  33
  34 inline const rtl::OUString FPH_LOCAL_DIR_ENTRY()
  35 { return rtl::OUString(FPH_CHAR_DOT); }
  36
  37 inline const rtl::OUString FPH_PARENT_DIR_ENTRY()
  38 { return rtl::OUString(".."); }
  39
  40 void SAL_CALL osl_systemPathRemoveSeparator(rtl_uString* pustrPath)
  41 {
  42     OSL_PRECOND(0 != pustrPath, "osl_systemPathRemoveSeparator: Invalid parameter");
  43     if (0 != pustrPath)
  44     {
  45         // maybe there are more than one separator at end
  46         // so we run in a loop
  47         while ((pustrPath->length > 1) && (FPH_CHAR_PATH_SEPARATOR == pustrPath->buffer[pustrPath->length - 1]))
  48         {
  49             pustrPath->length--;
  50             pustrPath->buffer[pustrPath->length] = (sal_Unicode)'\0';
  51         }
  52
  53         OSL_POSTCOND((0 == pustrPath->length) || (1 == pustrPath->length) || \
  54                      (pustrPath->length > 1 && pustrPath->buffer[pustrPath->length - 1] != FPH_CHAR_PATH_SEPARATOR), \
  55                      "osl_systemPathRemoveSeparator: Post condition failed");
  56     }
  57 }
  58
  59 void SAL_CALL osl_systemPathEnsureSeparator(rtl_uString** ppustrPath)
  60 {
  61     OSL_PRECOND((0 != ppustrPath) && (0 != *ppustrPath), "osl_systemPathEnsureSeparator: Invalid parameter");
  62     if ((0 != ppustrPath) && (0 != *ppustrPath))
  63     {
  64         rtl::OUString path(*ppustrPath);
  65         sal_Int32    lp = path.getLength();
  66         sal_Int32    i  = path.lastIndexOf(FPH_CHAR_PATH_SEPARATOR);
  67
  68         if ((lp > 1 && i != (lp - 1)) || ((lp < 2) && i < 0))
  69         {
  70             path += FPH_PATH_SEPARATOR();
  71             rtl_uString_assign(ppustrPath, path.pData);
  72         }
  73
  74         OSL_POSTCOND(path.endsWith(FPH_PATH_SEPARATOR()), \
  75                      "osl_systemPathEnsureSeparator: Post condition failed");
  76     }
  77 }
  78
  79 sal_Bool SAL_CALL osl_systemPathIsRelativePath(const rtl_uString* pustrPath)
  80 {
  81     OSL_PRECOND(0 != pustrPath, "osl_systemPathIsRelativePath: Invalid parameter");
  82     return ((0 == pustrPath) || (0 == pustrPath->length) || (pustrPath->buffer[0] != FPH_CHAR_PATH_SEPARATOR));
  83 }
  84
  85 void SAL_CALL osl_systemPathMakeAbsolutePath(
  86     const rtl_uString* pustrBasePath,
  87     const rtl_uString* pustrRelPath,
  88     rtl_uString**      ppustrAbsolutePath)
  89 {
  90     rtl::OUString base(rtl_uString_getStr(const_cast<rtl_uString*>(pustrBasePath)));
  91     rtl::OUString rel(const_cast<rtl_uString*>(pustrRelPath));
  92
  93     if (!base.isEmpty())
  94         osl_systemPathEnsureSeparator(&base.pData);
  95
  96     base += rel;
  97
  98     rtl_uString_acquire(base.pData);
  99     *ppustrAbsolutePath = base.pData;
 100 }
 101
 102 void SAL_CALL osl_systemPathGetFileNameOrLastDirectoryPart(
 103     const rtl_uString*     pustrPath,
 104     rtl_uString**       ppustrFileNameOrLastDirPart)
 105 {
 106     OSL_PRECOND(pustrPath && ppustrFileNameOrLastDirPart, \
 107                 "osl_systemPathGetFileNameOrLastDirectoryPart: Invalid parameter");
 108
 109     rtl::OUString path(const_cast<rtl_uString*>(pustrPath));
 110
 111     osl_systemPathRemoveSeparator(path.pData);
 112
 113     rtl::OUString last_part;
 114
 115     if (path.getLength() > 1 || (1 == path.getLength() && *path.getStr() != FPH_CHAR_PATH_SEPARATOR))
 116     {
 117         sal_Int32 idx_ps = path.lastIndexOf(FPH_CHAR_PATH_SEPARATOR);
 118         idx_ps++; // always right to increment by one even if idx_ps == -1!
 119         last_part = rtl::OUString(path.getStr() + idx_ps);
 120     }
 121     rtl_uString_assign(ppustrFileNameOrLastDirPart, last_part.pData);
 122 }
 123
 124 sal_Bool SAL_CALL osl_systemPathIsHiddenFileOrDirectoryEntry(
 125     const rtl_uString* pustrPath)
 126 {
 127     OSL_PRECOND(0 != pustrPath, "osl_systemPathIsHiddenFileOrDirectoryEntry: Invalid parameter");
 128     if ((0 == pustrPath) || (0 == pustrPath->length))
 129         return sal_False;
 130
 131     rtl::OUString fdp;
 132     osl_systemPathGetFileNameOrLastDirectoryPart(pustrPath, &fdp.pData);
 133
 134     return ((fdp.pData->length > 0) &&
 135             (fdp.pData->buffer[0] == FPH_CHAR_DOT) &&
 136             !osl_systemPathIsLocalOrParentDirectoryEntry(fdp.pData));
 137 }
 138
 139 sal_Bool SAL_CALL osl_systemPathIsLocalOrParentDirectoryEntry(
 140     const rtl_uString* pustrPath)
 141 {
 142     OSL_PRECOND(pustrPath, "osl_systemPathIsLocalOrParentDirectoryEntry: Invalid parameter");
 143
 144     rtl::OUString dirent;
 145
 146     osl_systemPathGetFileNameOrLastDirectoryPart(pustrPath, &dirent.pData);
 147
 148     return (dirent == FPH_LOCAL_DIR_ENTRY() ||
 149             dirent == FPH_PARENT_DIR_ENTRY());
 150 }
 151
 152 /***********************************************
 153  Simple iterator for a path list separated by
 154  the specified character
 155  **********************************************/
 156
 157 class path_list_iterator
 158 {
 159 public:
 160
 161     /* after construction get_current_item
 162        returns the first path in list, no need
 163        to call reset first
 164      */
 165     path_list_iterator(const rtl::OUString& path_list, sal_Unicode list_separator = FPH_CHAR_COLON) :
 166         m_path_list(path_list),
 167         m_end(m_path_list.getStr() + m_path_list.getLength() + 1),
 168         m_separator(list_separator)
 169     {
 170         reset();
 171     }
 172
 173     void reset()
 174     {
 175         m_path_segment_begin = m_path_segment_end = m_path_list.getStr();
 176         advance();
 177     }
 178
 179     void next()
 180     {
 181         OSL_PRECOND(!done(), "path_list_iterator: Already done!");
 182
 183         m_path_segment_begin = ++m_path_segment_end;
 184         advance();
 185     }
 186
 187     bool done() const
 188     {
 189         return (m_path_segment_end >= m_end);
 190     }
 191
 192     rtl::OUString get_current_item() const
 193     {
 194         return rtl::OUString(
 195             m_path_segment_begin,
 196             (m_path_segment_end - m_path_segment_begin));
 197     }
 198
 199 private:
 200     /* move m_path_end to the next separator or
 201        to the end of the string
 202      */
 203     void advance()
 204     {
 205         while (!done() && *m_path_segment_end && (*m_path_segment_end != m_separator))
 206             ++m_path_segment_end;
 207
 208         OSL_ASSERT(m_path_segment_end <= m_end);
 209     }
 210
 211 private:
 212     rtl::OUString       m_path_list;
 213     const sal_Unicode*  m_end;
 214     const sal_Unicode   m_separator;
 215     const sal_Unicode*  m_path_segment_begin;
 216     const sal_Unicode*  m_path_segment_end;
 217
 218 // prevent copy and assignment
 219 private:
 220     /******************************************
 221      copy constructor
 222      remember: do not simply copy m_path_begin
 223      and m_path_end because they point to
 224      the memory of other.m_path_list!
 225      *****************************************/
 226     path_list_iterator(const path_list_iterator& other);
 227
 228     /******************************************
 229      assignment operator
 230       remember: do not simply copy m_path_begin
 231      and m_path_end because they point to
 232      the memory of other.m_path_list!
 233      *****************************************/
 234     path_list_iterator& operator=(const path_list_iterator& other);
 235 };
 236
 237 sal_Bool SAL_CALL osl_searchPath(
 238     const rtl_uString* pustrFilePath,
 239     const rtl_uString* pustrSearchPathList,
 240     rtl_uString**      ppustrPathFound)
 241 {
 242     OSL_PRECOND(pustrFilePath && pustrSearchPathList && ppustrPathFound, "osl_searchPath: Invalid parameter");
 243
 244     bool               bfound = false;
 245     rtl::OUString      fp(const_cast<rtl_uString*>(pustrFilePath));
 246     rtl::OUString      pl = rtl::OUString(const_cast<rtl_uString*>(pustrSearchPathList));
 247     path_list_iterator pli(pl);
 248
 249     while (!pli.done())
 250     {
 251         rtl::OUString p = pli.get_current_item();
 252         osl::systemPathEnsureSeparator(p);
 253         p += fp;
 254
 255         if (osl::access(p, F_OK) > -1)
 256         {
 257             bfound = true;
 258             rtl_uString_assign(ppustrPathFound, p.pData);
 259             break;
 260         }
 261         pli.next();
 262     }
 263     return bfound;
 264 }
 265
 266 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */