sal/osl/unx/file_stat.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 <osl/file.h>
  21
  22 #include <sys/stat.h>
  23 #include <dirent.h>
  24 #include <errno.h>
  25 #include <limits.h>
  26 #include <unistd.h>
  27 #include <utime.h>
  28
  29 #include <osl/diagnose.h>
  30 #include <osl/thread.h>
  31
  32 #include "system.hxx"
  33 #include "file_impl.hxx"
  34 #include "file_error_transl.hxx"
  35 #include "file_path_helper.hxx"
  36 #include "file_url.hxx"
  37 #include "uunxapi.hxx"
  38
  39 namespace
  40 {
  41     void set_file_type(const struct stat& file_stat, oslFileStatus* pStat)
  42     {
  43         /* links to directories state also to be a directory */
  44        if (S_ISLNK(file_stat.st_mode))
  45            pStat->eType = osl_File_Type_Link;
  46        else if (S_ISDIR(file_stat.st_mode))
  47            pStat->eType = osl_File_Type_Directory;
  48        else if (S_ISREG(file_stat.st_mode))
  49            pStat->eType = osl_File_Type_Regular;
  50        else if (S_ISFIFO(file_stat.st_mode))
  51            pStat->eType = osl_File_Type_Fifo;
  52        else if (S_ISSOCK(file_stat.st_mode))
  53            pStat->eType = osl_File_Type_Socket;
  54        else if (S_ISCHR(file_stat.st_mode) || S_ISBLK(file_stat.st_mode))
  55            pStat->eType = osl_File_Type_Special;
  56        else
  57            pStat->eType = osl_File_Type_Unknown;
  58
  59        pStat->uValidFields |= osl_FileStatus_Mask_Type;
  60     }
  61
  62     void set_file_access_mask(const struct stat& file_stat, oslFileStatus* pStat)
  63     {
  64         // user permissions
  65         if (S_IRUSR & file_stat.st_mode)
  66             pStat->uAttributes |= osl_File_Attribute_OwnRead;
  67
  68         if (S_IWUSR & file_stat.st_mode)
  69             pStat->uAttributes |= osl_File_Attribute_OwnWrite;
  70
  71         if (S_IXUSR & file_stat.st_mode)
  72             pStat->uAttributes |= osl_File_Attribute_OwnExe;
  73
  74         // group permissions
  75         if (S_IRGRP & file_stat.st_mode)
  76             pStat->uAttributes |= osl_File_Attribute_GrpRead;
  77
  78         if (S_IWGRP & file_stat.st_mode)
  79             pStat->uAttributes |= osl_File_Attribute_GrpWrite;
  80
  81         if (S_IXGRP & file_stat.st_mode)
  82             pStat->uAttributes |= osl_File_Attribute_GrpExe;
  83
  84         // others permissions
  85         if (S_IROTH & file_stat.st_mode)
  86             pStat->uAttributes |= osl_File_Attribute_OthRead;
  87
  88         if (S_IWOTH & file_stat.st_mode)
  89             pStat->uAttributes |= osl_File_Attribute_OthWrite;
  90
  91         if (S_IXOTH & file_stat.st_mode)
  92             pStat->uAttributes |= osl_File_Attribute_OthExe;
  93
  94         pStat->uValidFields |= osl_FileStatus_Mask_Attributes;
  95     }
  96
  97     /* This code used not to use access(...) because access follows links which
  98        may cause performance problems see #97133.  (That apparently references a
  99        no-longer accessible Hamburg-internal bug-tracking system.)
 100        However, contrary to what is stated above the use of access calls is
 101        required on network file systems not using unix semantics (AFS, see
 102        fdo#43095).
 103     */
 104     void set_file_access_rights(const OString& file_path, oslFileStatus* pStat)
 105     {
 106         pStat->uValidFields |= osl_FileStatus_Mask_Attributes;
 107
 108         if (osl::access(file_path, W_OK) < 0)
 109             pStat->uAttributes |= osl_File_Attribute_ReadOnly;
 110
 111         if (osl::access(file_path, X_OK) == 0)
 112             pStat->uAttributes |= osl_File_Attribute_Executable;
 113     }
 114
 115     void set_file_hidden_status(const OString& file_path, oslFileStatus* pStat)
 116     {
 117         pStat->uAttributes   = osl::systemPathIsHiddenFileOrDirectoryEntry(file_path) ? osl_File_Attribute_Hidden : 0;
 118         pStat->uValidFields |= osl_FileStatus_Mask_Attributes;
 119     }
 120
 121     /* the set_file_access_rights must be called after set_file_hidden_status(...) and
 122        set_file_access_mask(...) because of the hack in set_file_access_rights(...) */
 123     void set_file_attributes(
 124         const OString& file_path, const struct stat& file_stat, const sal_uInt32 uFieldMask, oslFileStatus* pStat)
 125     {
 126         set_file_hidden_status(file_path, pStat);
 127         set_file_access_mask(file_stat, pStat);
 128
 129         // we set the file access rights only on demand
 130         // because it's potentially expensive
 131         if (uFieldMask & osl_FileStatus_Mask_Attributes)
 132             set_file_access_rights(file_path, pStat);
 133     }
 134
 135     void set_file_access_time(const struct stat& file_stat, oslFileStatus* pStat)
 136     {
 137         pStat->aAccessTime.Seconds  = file_stat.st_atime;
 138         pStat->aAccessTime.Nanosec  = 0;
 139         pStat->uValidFields        |= osl_FileStatus_Mask_AccessTime;
 140     }
 141
 142     void set_file_modify_time(const struct stat& file_stat, oslFileStatus* pStat)
 143     {
 144         pStat->aModifyTime.Seconds  = file_stat.st_mtime;
 145         pStat->aModifyTime.Nanosec  = 0;
 146         pStat->uValidFields        |= osl_FileStatus_Mask_ModifyTime;
 147     }
 148
 149     void set_file_size(const struct stat& file_stat, oslFileStatus* pStat)
 150     {
 151         if (S_ISREG(file_stat.st_mode))
 152         {
 153             pStat->uFileSize     = file_stat.st_size;
 154             pStat->uValidFields |= osl_FileStatus_Mask_FileSize;
 155         }
 156     }
 157
 158     /* we only need to call stat or lstat if one of the
 159        following flags is set */
 160     bool is_stat_call_necessary(sal_uInt32 field_mask, oslFileType file_type)
 161     {
 162         return (
 163                 ((field_mask & osl_FileStatus_Mask_Type) && (file_type == osl_File_Type_Unknown)) ||
 164                 (field_mask & osl_FileStatus_Mask_Attributes) ||
 165                 (field_mask & osl_FileStatus_Mask_CreationTime) ||
 166                 (field_mask & osl_FileStatus_Mask_AccessTime) ||
 167                 (field_mask & osl_FileStatus_Mask_ModifyTime) ||
 168                 (field_mask & osl_FileStatus_Mask_FileSize) ||
 169                 (field_mask & osl_FileStatus_Mask_LinkTargetURL) ||
 170                 (field_mask & osl_FileStatus_Mask_Validate));
 171     }
 172
 173     oslFileError set_link_target_url(const OString& file_path, oslFileStatus* pStat)
 174     {
 175         OString link_target;
 176         if (!osl::realpath(file_path, link_target))
 177             return oslTranslateFileError(errno);
 178
 179         OUString url;
 180         oslFileError osl_error = osl::detail::convertPathnameToUrl(link_target, &url);
 181         if (osl_error != osl_File_E_None)
 182             return osl_error;
 183         rtl_uString_assign(&pStat->ustrLinkTargetURL, url.pData);
 184
 185         pStat->uValidFields |= osl_FileStatus_Mask_LinkTargetURL;
 186         return osl_File_E_None;
 187     }
 188
 189     oslFileError setup_osl_getFileStatus(
 190         DirectoryItem_Impl * pImpl, oslFileStatus* pStat, OString& file_path)
 191     {
 192         if ((pImpl == nullptr) || (pStat == nullptr))
 193             return osl_File_E_INVAL;
 194
 195         file_path = pImpl->m_strFilePath;
 196         OSL_ASSERT(!file_path.isEmpty());
 197         if (file_path.isEmpty())
 198             return osl_File_E_INVAL;
 199
 200         pStat->uValidFields = 0;
 201         return osl_File_E_None;
 202     }
 203
 204 }
 205
 206 oslFileError SAL_CALL osl_getFileStatus(oslDirectoryItem Item, oslFileStatus* pStat, sal_uInt32 uFieldMask)
 207 {
 208     DirectoryItem_Impl * pImpl = static_cast< DirectoryItem_Impl* >(Item);
 209
 210     OString file_path;
 211     oslFileError  osl_error = setup_osl_getFileStatus(pImpl, pStat, file_path);
 212     if (osl_error != osl_File_E_None)
 213         return osl_error;
 214
 215     struct stat file_stat;
 216
 217     bool bStatNeeded = is_stat_call_necessary(uFieldMask, pImpl->getFileType());
 218     if (bStatNeeded && (osl::lstat(file_path, file_stat) != 0))
 219         return oslTranslateFileError(errno);
 220
 221     if (bStatNeeded)
 222     {
 223         // we set all these attributes because it's cheap
 224         set_file_type(file_stat, pStat);
 225         set_file_access_time(file_stat, pStat);
 226         set_file_modify_time(file_stat, pStat);
 227         set_file_size(file_stat, pStat);
 228         set_file_attributes(file_path, file_stat, uFieldMask, pStat);
 229
 230         // file exists semantic of osl_FileStatus_Mask_Validate
 231         if ((uFieldMask & osl_FileStatus_Mask_LinkTargetURL) && S_ISLNK(file_stat.st_mode))
 232         {
 233             osl_error = set_link_target_url(file_path, pStat);
 234             if (osl_error != osl_File_E_None)
 235                 return osl_error;
 236         }
 237     }
 238 #ifdef _DIRENT_HAVE_D_TYPE
 239     else if (uFieldMask & osl_FileStatus_Mask_Type)
 240     {
 241         pStat->eType = pImpl->getFileType();
 242         pStat->uValidFields |= osl_FileStatus_Mask_Type;
 243     }
 244 #endif /* _DIRENT_HAVE_D_TYPE */
 245
 246     if (uFieldMask & osl_FileStatus_Mask_FileURL)
 247     {
 248         OUString url;
 249         if ((osl_error = osl::detail::convertPathnameToUrl(file_path, &url)) != osl_File_E_None)
 250             return osl_error;
 251         rtl_uString_assign(&pStat->ustrFileURL, url.pData);
 252
 253         pStat->uValidFields |= osl_FileStatus_Mask_FileURL;
 254     }
 255
 256     if (uFieldMask & osl_FileStatus_Mask_FileName)
 257     {
 258         OString name;
 259         osl_systemPathGetFileNameOrLastDirectoryPart(file_path.pData, &name.pData);
 260         bool ok = rtl_convertStringToUString(
 261             &pStat->ustrFileName, name.getStr(), name.getLength(), osl_getThreadTextEncoding(),
 262             (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_DEFAULT | RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT
 263              | RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT));
 264         assert(ok); (void)ok;
 265         pStat->uValidFields |= osl_FileStatus_Mask_FileName;
 266     }
 267     return osl_File_E_None;
 268 }
 269
 270 static oslFileError osl_psz_setFileAttributes( const char* pszFilePath, sal_uInt64 uAttributes )
 271 {
 272     oslFileError osl_error = osl_File_E_None;
 273     mode_t       nNewMode  = 0;
 274
 275     OSL_ENSURE(!(osl_File_Attribute_Hidden & uAttributes), "osl_File_Attribute_Hidden doesn't work under Unix");
 276
 277     if (uAttributes & osl_File_Attribute_OwnRead)
 278         nNewMode |= S_IRUSR;
 279
 280     if (uAttributes & osl_File_Attribute_OwnWrite)
 281         nNewMode|=S_IWUSR;
 282
 283     if  (uAttributes & osl_File_Attribute_OwnExe)
 284         nNewMode|=S_IXUSR;
 285
 286     if (uAttributes & osl_File_Attribute_GrpRead)
 287         nNewMode|=S_IRGRP;
 288
 289     if (uAttributes & osl_File_Attribute_GrpWrite)
 290         nNewMode|=S_IWGRP;
 291
 292     if (uAttributes & osl_File_Attribute_GrpExe)
 293         nNewMode|=S_IXGRP;
 294
 295     if (uAttributes & osl_File_Attribute_OthRead)
 296         nNewMode|=S_IROTH;
 297
 298     if (uAttributes & osl_File_Attribute_OthWrite)
 299         nNewMode|=S_IWOTH;
 300
 301     if (uAttributes & osl_File_Attribute_OthExe)
 302         nNewMode|=S_IXOTH;
 303
 304     if (chmod(pszFilePath, nNewMode) < 0)
 305         osl_error = oslTranslateFileError(errno);
 306
 307     return osl_error;
 308 }
 309
 310 oslFileError SAL_CALL osl_setFileAttributes( rtl_uString* ustrFileURL, sal_uInt64 uAttributes )
 311 {
 312     char path[PATH_MAX];
 313     oslFileError eRet;
 314
 315     OSL_ASSERT( ustrFileURL );
 316
 317     /* convert file url to system path */
 318     eRet = FileURLToPath( path, PATH_MAX, ustrFileURL );
 319     if( eRet != osl_File_E_None )
 320         return eRet;
 321
 322 #ifdef MACOSX
 323     if ( macxp_resolveAlias( path, PATH_MAX ) != 0 )
 324       return oslTranslateFileError( errno );
 325 #endif/* MACOSX */
 326
 327     return osl_psz_setFileAttributes( path, uAttributes );
 328 }
 329
 330 static oslFileError osl_psz_setFileTime (
 331     const char* pszFilePath,
 332     const TimeValue* pLastAccessTime,
 333     const TimeValue* pLastWriteTime )
 334 {
 335     int nRet=0;
 336     struct utimbuf aTimeBuffer;
 337     struct stat aFileStat;
 338 #ifdef DEBUG_OSL_FILE
 339     struct tm* pTM=0;
 340 #endif
 341
 342     nRet = lstat_c(pszFilePath,&aFileStat);
 343
 344     if ( nRet < 0 )
 345     {
 346         nRet=errno;
 347         return oslTranslateFileError(nRet);
 348     }
 349
 350 #ifdef DEBUG_OSL_FILE
 351     fprintf(stderr,"File Times are (in localtime):\n");
 352     pTM=localtime(&aFileStat.st_ctime);
 353     fprintf(stderr,"CreationTime is '%s'\n",asctime(pTM));
 354     pTM=localtime(&aFileStat.st_atime);
 355     fprintf(stderr,"AccessTime   is '%s'\n",asctime(pTM));
 356     pTM=localtime(&aFileStat.st_mtime);
 357     fprintf(stderr,"Modification is '%s'\n",asctime(pTM));
 358
 359     fprintf(stderr,"File Times are (in UTC):\n");
 360     fprintf(stderr,"CreationTime is '%s'\n",ctime(&aFileStat.st_ctime));
 361     fprintf(stderr,"AccessTime   is '%s'\n",ctime(&aTimeBuffer.actime));
 362     fprintf(stderr,"Modification is '%s'\n",ctime(&aTimeBuffer.modtime));
 363 #endif
 364
 365     if ( pLastAccessTime != nullptr )
 366     {
 367         aTimeBuffer.actime=pLastAccessTime->Seconds;
 368     }
 369     else
 370     {
 371         aTimeBuffer.actime=aFileStat.st_atime;
 372     }
 373
 374     if ( pLastWriteTime != nullptr )
 375     {
 376         aTimeBuffer.modtime=pLastWriteTime->Seconds;
 377     }
 378     else
 379     {
 380         aTimeBuffer.modtime=aFileStat.st_mtime;
 381     }
 382
 383     /* mfe: Creation time not used here! */
 384
 385 #ifdef DEBUG_OSL_FILE
 386     fprintf(stderr,"File Times are (in localtime):\n");
 387     pTM=localtime(&aFileStat.st_ctime);
 388     fprintf(stderr,"CreationTime now '%s'\n",asctime(pTM));
 389     pTM=localtime(&aTimeBuffer.actime);
 390     fprintf(stderr,"AccessTime   now '%s'\n",asctime(pTM));
 391     pTM=localtime(&aTimeBuffer.modtime);
 392     fprintf(stderr,"Modification now '%s'\n",asctime(pTM));
 393
 394     fprintf(stderr,"File Times are (in UTC):\n");
 395     fprintf(stderr,"CreationTime now '%s'\n",ctime(&aFileStat.st_ctime));
 396     fprintf(stderr,"AccessTime   now '%s'\n",ctime(&aTimeBuffer.actime));
 397     fprintf(stderr,"Modification now '%s'\n",ctime(&aTimeBuffer.modtime));
 398 #endif
 399
 400     nRet = utime_c(pszFilePath,&aTimeBuffer);
 401     if ( nRet < 0 )
 402     {
 403         nRet=errno;
 404         return oslTranslateFileError(nRet);
 405     }
 406
 407     return osl_File_E_None;
 408 }
 409
 410 oslFileError SAL_CALL osl_setFileTime (
 411     rtl_uString* ustrFileURL,
 412     SAL_UNUSED_PARAMETER const TimeValue* /* pCreationTime */,
 413     const TimeValue* pLastAccessTime,
 414     const TimeValue* pLastWriteTime )
 415 {
 416     char path[PATH_MAX];
 417     oslFileError eRet;
 418
 419     OSL_ASSERT( ustrFileURL );
 420
 421     /* convert file url to system path */
 422     eRet = FileURLToPath( path, PATH_MAX, ustrFileURL );
 423     if( eRet != osl_File_E_None )
 424         return eRet;
 425
 426 #ifdef MACOSX
 427     if ( macxp_resolveAlias( path, PATH_MAX ) != 0 )
 428       return oslTranslateFileError( errno );
 429 #endif/* MACOSX */
 430
 431     return osl_psz_setFileTime( path, pLastAccessTime, pLastWriteTime );
 432 }
 433
 434 sal_Bool
 435 SAL_CALL osl_identicalDirectoryItem( oslDirectoryItem a, oslDirectoryItem b)
 436 {
 437     DirectoryItem_Impl *pA = static_cast<DirectoryItem_Impl *>(a);
 438     DirectoryItem_Impl *pB = static_cast<DirectoryItem_Impl *>(b);
 439     if (a == b)
 440         return true;
 441     /* same name => same item, unless renaming / moving madness has occurred */
 442     if (pA->m_strFilePath == pB->m_strFilePath)
 443         return true;
 444
 445     struct stat a_stat, b_stat;
 446
 447     if (osl::lstat(pA->m_strFilePath, a_stat) != 0 ||
 448         osl::lstat(pB->m_strFilePath, b_stat) != 0)
 449         return false;
 450
 451     return (a_stat.st_ino == b_stat.st_ino);
 452 }
 453
 454 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */