sal/osl/unx/file_stat.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: file_stat.cxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sal.hxx"
  33
  34 #include "osl/file.h"
  35
  36 #include "system.h"
  37 #include <sys/types.h>
  38 #include <dirent.h>
  39 #include <errno.h>
  40 #include <limits.h>
  41 #include <unistd.h>
  42
  43 #include "file_impl.hxx"
  44 #include "file_error_transl.h"
  45 #include "file_path_helper.hxx"
  46 #include "file_url.h"
  47 #include "uunxapi.hxx"
  48
  49 namespace /* private */
  50 {
  51
  52     inline void set_file_type(const struct stat& file_stat, oslFileStatus* pStat)
  53     {
  54         /* links to directories state also to be a directory */
  55        if (S_ISLNK(file_stat.st_mode))
  56            pStat->eType = osl_File_Type_Link;
  57        else if (S_ISDIR(file_stat.st_mode))
  58            pStat->eType = osl_File_Type_Directory;
  59        else if (S_ISREG(file_stat.st_mode))
  60            pStat->eType = osl_File_Type_Regular;
  61        else if (S_ISFIFO(file_stat.st_mode))
  62            pStat->eType = osl_File_Type_Fifo;
  63        else if (S_ISSOCK(file_stat.st_mode))
  64            pStat->eType = osl_File_Type_Socket;
  65        else if (S_ISCHR(file_stat.st_mode) || S_ISBLK(file_stat.st_mode))
  66            pStat->eType = osl_File_Type_Special;
  67        else
  68            pStat->eType = osl_File_Type_Unknown;
  69
  70        pStat->uValidFields |= osl_FileStatus_Mask_Type;
  71     }
  72
  73     inline void set_file_access_mask(const struct stat& file_stat, oslFileStatus* pStat)
  74     {
  75         // user permissions
  76         if (S_IRUSR & file_stat.st_mode)
  77             pStat->uAttributes |= osl_File_Attribute_OwnRead;
  78
  79         if (S_IWUSR & file_stat.st_mode)
  80             pStat->uAttributes |= osl_File_Attribute_OwnWrite;
  81
  82         if (S_IXUSR & file_stat.st_mode)
  83             pStat->uAttributes |= osl_File_Attribute_OwnExe;
  84
  85         // group permissions
  86         if (S_IRGRP & file_stat.st_mode)
  87             pStat->uAttributes |= osl_File_Attribute_GrpRead;
  88
  89         if (S_IWGRP & file_stat.st_mode)
  90             pStat->uAttributes |= osl_File_Attribute_GrpWrite;
  91
  92         if (S_IXGRP & file_stat.st_mode)
  93             pStat->uAttributes |= osl_File_Attribute_GrpExe;
  94
  95         // others permissions
  96         if (S_IROTH & file_stat.st_mode)
  97             pStat->uAttributes |= osl_File_Attribute_OthRead;
  98
  99         if (S_IWOTH & file_stat.st_mode)
 100             pStat->uAttributes |= osl_File_Attribute_OthWrite;
 101
 102         if (S_IXOTH & file_stat.st_mode)
 103             pStat->uAttributes |= osl_File_Attribute_OthExe;
 104
 105         pStat->uValidFields |= osl_FileStatus_Mask_Attributes;
 106     }
 107
 108     inline void set_file_access_rights(const struct stat& file_stat, int S_IR, int S_IW, int S_IX, oslFileStatus* pStat)
 109     {
 110         /* we cannot really map osl_File_Attribute_ReadOnly to
 111            the Unix access rights, it's a Windows only flag
 112            that's why the following hack. We set osl_FileStatus_Mask_Attributes
 113            but if there is no read access for a file we clear the flag
 114            again to signal to the caller that there are no file attributes
 115            to read because that's better than to give them incorrect one.
 116         */
 117         pStat->uValidFields |= osl_FileStatus_Mask_Attributes;
 118
 119         if ((0 == (S_IW & file_stat.st_mode)) && (S_IR & file_stat.st_mode))
 120             pStat->uAttributes |= osl_File_Attribute_ReadOnly;
 121
 122         if (S_IX & file_stat.st_mode)
 123             pStat->uAttributes |= osl_File_Attribute_Executable;
 124     }
 125
 126     /* a process may belong to up to NGROUPS_MAX groups, so when
 127        checking group access rights, we have to check all belonging
 128        groups */
 129     inline bool is_in_process_grouplist(const gid_t file_group)
 130     {
 131         // check primary process group
 132
 133         if (getgid() == file_group)
 134             return true;
 135
 136         // check supplementary process groups
 137
 138         gid_t grplist[NGROUPS_MAX];
 139         int   grp_number = getgroups(NGROUPS_MAX, grplist);
 140
 141         for (int i = 0; i < grp_number; i++)
 142         {
 143             if (grplist[i] == file_group)
 144                 return true;
 145         }
 146         return false;
 147     }
 148
 149     /* Currently we are determining the file access right based
 150        on the real user ID not the effective user ID!
 151        We don't use access(...) because access follows links which
 152        may cause performance problems see #97133.
 153     */
 154     inline void set_file_access_rights(const struct stat& file_stat, oslFileStatus* pStat)
 155     {
 156         if (getuid() == file_stat.st_uid)
 157         {
 158             set_file_access_rights(file_stat, S_IRUSR, S_IWUSR, S_IXUSR, pStat);
 159         }
 160         else if (is_in_process_grouplist(file_stat.st_gid))
 161         {
 162             set_file_access_rights(file_stat, S_IRGRP, S_IWGRP, S_IXGRP, pStat);
 163         }
 164         else
 165         {
 166             set_file_access_rights(file_stat, S_IROTH, S_IWOTH, S_IXOTH, pStat);
 167         }
 168     }
 169
 170     inline void set_file_hidden_status(const rtl::OUString& file_path, oslFileStatus* pStat)
 171     {
 172         pStat->uAttributes   = osl::systemPathIsHiddenFileOrDirectoryEntry(file_path) ? osl_File_Attribute_Hidden : 0;
 173         pStat->uValidFields |= osl_FileStatus_Mask_Attributes;
 174     }
 175
 176     /* the set_file_access_rights must be called after set_file_hidden_status(...) and
 177        set_file_access_mask(...) because of the hack in set_file_access_rights(...) */
 178     inline void set_file_attributes(
 179         const rtl::OUString& file_path, const struct stat& file_stat, const sal_uInt32 uFieldMask, oslFileStatus* pStat)
 180     {
 181         set_file_hidden_status(file_path, pStat);
 182         set_file_access_mask(file_stat, pStat);
 183
 184         // we set the file access rights only on demand
 185         // because it's potentially expensive
 186         if (uFieldMask & osl_FileStatus_Mask_Attributes)
 187                set_file_access_rights(file_stat, pStat);
 188     }
 189
 190     inline void set_file_access_time(const struct stat& file_stat, oslFileStatus* pStat)
 191     {
 192         pStat->aAccessTime.Seconds  = file_stat.st_atime;
 193         pStat->aAccessTime.Nanosec  = 0;
 194            pStat->uValidFields        |= osl_FileStatus_Mask_AccessTime;
 195     }
 196
 197     inline void set_file_modify_time(const struct stat& file_stat, oslFileStatus* pStat)
 198     {
 199         pStat->aModifyTime.Seconds  = file_stat.st_mtime;
 200         pStat->aModifyTime.Nanosec  = 0;
 201         pStat->uValidFields        |= osl_FileStatus_Mask_ModifyTime;
 202     }
 203
 204     inline void set_file_size(const struct stat& file_stat, oslFileStatus* pStat)
 205     {
 206         if (S_ISREG(file_stat.st_mode))
 207            {
 208             pStat->uFileSize     = file_stat.st_size;
 209                pStat->uValidFields |= osl_FileStatus_Mask_FileSize;
 210            }
 211     }
 212
 213     /* we only need to call stat or lstat if one of the
 214        following flags is set */
 215     inline bool is_stat_call_necessary(sal_uInt32 field_mask, oslFileType file_type = osl_File_Type_Unknown)
 216     {
 217         return (
 218                 ((field_mask & osl_FileStatus_Mask_Type) && (file_type == osl_File_Type_Unknown)) ||
 219                 (field_mask & osl_FileStatus_Mask_Attributes) ||
 220                 (field_mask & osl_FileStatus_Mask_CreationTime) ||
 221                 (field_mask & osl_FileStatus_Mask_AccessTime) ||
 222                 (field_mask & osl_FileStatus_Mask_ModifyTime) ||
 223                 (field_mask & osl_FileStatus_Mask_FileSize) ||
 224                 (field_mask & osl_FileStatus_Mask_LinkTargetURL) ||
 225                 (field_mask & osl_FileStatus_Mask_Validate));
 226     }
 227
 228     inline oslFileError set_link_target_url(const rtl::OUString& file_path, oslFileStatus* pStat)
 229     {
 230         rtl::OUString link_target;
 231         if (!osl::realpath(file_path, link_target))
 232             return oslTranslateFileError(OSL_FET_ERROR, errno);
 233
 234         oslFileError osl_error = osl_getFileURLFromSystemPath(link_target.pData, &pStat->ustrLinkTargetURL);
 235         if (osl_error != osl_File_E_None)
 236             return osl_error;
 237
 238         pStat->uValidFields |= osl_FileStatus_Mask_LinkTargetURL;
 239         return osl_File_E_None;
 240     }
 241
 242     inline oslFileError setup_osl_getFileStatus(
 243         DirectoryItem_Impl * pImpl, oslFileStatus* pStat, rtl::OUString& file_path)
 244     {
 245         if ((NULL == pImpl) || (NULL == pStat))
 246             return osl_File_E_INVAL;
 247
 248         file_path = rtl::OUString(pImpl->m_ustrFilePath);
 249         OSL_ASSERT(file_path.getLength() > 0);
 250         if (file_path.getLength() <= 0)
 251             return osl_File_E_INVAL;
 252
 253         pStat->uValidFields = 0;
 254         return osl_File_E_None;
 255     }
 256
 257 } // end namespace private
 258
 259
 260 /****************************************************************************
 261  *      osl_getFileStatus
 262  ****************************************************************************/
 263
 264 oslFileError SAL_CALL osl_getFileStatus(oslDirectoryItem Item, oslFileStatus* pStat, sal_uInt32 uFieldMask)
 265 {
 266     DirectoryItem_Impl * pImpl = static_cast< DirectoryItem_Impl* >(Item);
 267
 268     rtl::OUString file_path;
 269     oslFileError  osl_error = setup_osl_getFileStatus(pImpl, pStat, file_path);
 270     if (osl_File_E_None != osl_error)
 271         return osl_error;
 272
 273 #if defined(__GNUC__) && (__GNUC__ < 3)
 274     struct ::stat file_stat;
 275 #else
 276     struct stat file_stat;
 277 #endif
 278
 279     bool bStatNeeded = is_stat_call_necessary(uFieldMask, pImpl->getFileType());
 280     if (bStatNeeded && (0 != osl::lstat(file_path, file_stat)))
 281         return oslTranslateFileError(OSL_FET_ERROR, errno);
 282
 283     if (bStatNeeded)
 284     {
 285         // we set all these attributes because it's cheap
 286         set_file_type(file_stat, pStat);
 287         set_file_access_time(file_stat, pStat);
 288         set_file_modify_time(file_stat, pStat);
 289         set_file_size(file_stat, pStat);
 290         set_file_attributes(file_path, file_stat, uFieldMask, pStat);
 291
 292         // file exists semantic of osl_FileStatus_Mask_Validate
 293         if ((uFieldMask & osl_FileStatus_Mask_LinkTargetURL) && S_ISLNK(file_stat.st_mode))
 294         {
 295             osl_error = set_link_target_url(file_path, pStat);
 296             if (osl_error != osl_File_E_None)
 297                 return osl_error;
 298         }
 299     }
 300 #ifdef _DIRENT_HAVE_D_TYPE
 301     else if (uFieldMask & osl_FileStatus_Mask_Type)
 302     {
 303         pStat->eType = pImpl->getFileType();
 304         pStat->uValidFields |= osl_FileStatus_Mask_Type;
 305     }
 306 #endif /* _DIRENT_HAVE_D_TYPE */
 307
 308     if (uFieldMask & osl_FileStatus_Mask_FileURL)
 309     {
 310         if ((osl_error = osl_getFileURLFromSystemPath(file_path.pData, &pStat->ustrFileURL)) != osl_File_E_None)
 311             return osl_error;
 312
 313         pStat->uValidFields |= osl_FileStatus_Mask_FileURL;
 314     }
 315
 316     if (uFieldMask & osl_FileStatus_Mask_FileName)
 317     {
 318         osl_systemPathGetFileNameOrLastDirectoryPart(file_path.pData, &pStat->ustrFileName);
 319         pStat->uValidFields |= osl_FileStatus_Mask_FileName;
 320        }
 321     return osl_File_E_None;
 322 }
 323
 324 /****************************************************************************/
 325 /*      osl_setFileAttributes */
 326 /****************************************************************************/
 327
 328 static oslFileError osl_psz_setFileAttributes( const sal_Char* pszFilePath, sal_uInt64 uAttributes )
 329 {
 330     oslFileError osl_error = osl_File_E_None;
 331     mode_t               nNewMode  = 0;
 332
 333      OSL_ENSURE(!(osl_File_Attribute_Hidden & uAttributes), "osl_File_Attribute_Hidden doesn't work under Unix");
 334
 335     if (uAttributes & osl_File_Attribute_OwnRead)
 336         nNewMode |= S_IRUSR;
 337
 338     if (uAttributes & osl_File_Attribute_OwnWrite)
 339         nNewMode|=S_IWUSR;
 340
 341     if  (uAttributes & osl_File_Attribute_OwnExe)
 342         nNewMode|=S_IXUSR;
 343
 344     if (uAttributes & osl_File_Attribute_GrpRead)
 345         nNewMode|=S_IRGRP;
 346
 347     if (uAttributes & osl_File_Attribute_GrpWrite)
 348         nNewMode|=S_IWGRP;
 349
 350     if (uAttributes & osl_File_Attribute_GrpExe)
 351         nNewMode|=S_IXGRP;
 352
 353     if (uAttributes & osl_File_Attribute_OthRead)
 354         nNewMode|=S_IROTH;
 355
 356     if (uAttributes & osl_File_Attribute_OthWrite)
 357         nNewMode|=S_IWOTH;
 358
 359     if (uAttributes & osl_File_Attribute_OthExe)
 360         nNewMode|=S_IXOTH;
 361
 362     if (chmod(pszFilePath, nNewMode) < 0)
 363         osl_error = oslTranslateFileError(OSL_FET_ERROR, errno);
 364
 365     return osl_error;
 366 }
 367
 368 oslFileError SAL_CALL osl_setFileAttributes( rtl_uString* ustrFileURL, sal_uInt64 uAttributes )
 369 {
 370     char path[PATH_MAX];
 371     oslFileError eRet;
 372
 373     OSL_ASSERT( ustrFileURL );
 374
 375     /* convert file url to system path */
 376     eRet = FileURLToPath( path, PATH_MAX, ustrFileURL );
 377     if( eRet != osl_File_E_None )
 378         return eRet;
 379
 380 #ifdef MACOSX
 381     if ( macxp_resolveAlias( path, PATH_MAX ) != 0 )
 382       return oslTranslateFileError( OSL_FET_ERROR, errno );
 383 #endif/* MACOSX */
 384
 385     return osl_psz_setFileAttributes( path, uAttributes );
 386 }
 387
 388 /****************************************************************************/
 389 /*      osl_setFileTime */
 390 /****************************************************************************/
 391
 392 static oslFileError osl_psz_setFileTime (
 393     const sal_Char* pszFilePath,
 394     const TimeValue* /*pCreationTime*/,
 395     const TimeValue* pLastAccessTime,
 396     const TimeValue* pLastWriteTime )
 397 {
 398     int nRet=0;
 399     struct utimbuf aTimeBuffer;
 400     struct stat aFileStat;
 401 #ifdef DEBUG_OSL_FILE
 402     struct tm* pTM=0;
 403 #endif
 404
 405     nRet = lstat(pszFilePath,&aFileStat);
 406
 407     if ( nRet < 0 )
 408     {
 409         nRet=errno;
 410         return oslTranslateFileError(OSL_FET_ERROR, nRet);
 411     }
 412
 413 #ifdef DEBUG_OSL_FILE
 414     fprintf(stderr,"File Times are (in localtime):\n");
 415     pTM=localtime(&aFileStat.st_ctime);
 416     fprintf(stderr,"CreationTime is '%s'\n",asctime(pTM));
 417     pTM=localtime(&aFileStat.st_atime);
 418     fprintf(stderr,"AccessTime   is '%s'\n",asctime(pTM));
 419     pTM=localtime(&aFileStat.st_mtime);
 420     fprintf(stderr,"Modification is '%s'\n",asctime(pTM));
 421
 422     fprintf(stderr,"File Times are (in UTC):\n");
 423     fprintf(stderr,"CreationTime is '%s'\n",ctime(&aFileStat.st_ctime));
 424     fprintf(stderr,"AccessTime   is '%s'\n",ctime(&aTimeBuffer.actime));
 425     fprintf(stderr,"Modification is '%s'\n",ctime(&aTimeBuffer.modtime));
 426 #endif
 427
 428     if ( pLastAccessTime != 0 )
 429     {
 430         aTimeBuffer.actime=pLastAccessTime->Seconds;
 431     }
 432     else
 433     {
 434         aTimeBuffer.actime=aFileStat.st_atime;
 435     }
 436
 437     if ( pLastWriteTime != 0 )
 438     {
 439         aTimeBuffer.modtime=pLastWriteTime->Seconds;
 440     }
 441     else
 442     {
 443         aTimeBuffer.modtime=aFileStat.st_mtime;
 444     }
 445
 446     /* mfe: Creation time not used here! */
 447
 448 #ifdef DEBUG_OSL_FILE
 449     fprintf(stderr,"File Times are (in localtime):\n");
 450     pTM=localtime(&aFileStat.st_ctime);
 451     fprintf(stderr,"CreationTime now '%s'\n",asctime(pTM));
 452     pTM=localtime(&aTimeBuffer.actime);
 453     fprintf(stderr,"AccessTime   now '%s'\n",asctime(pTM));
 454     pTM=localtime(&aTimeBuffer.modtime);
 455     fprintf(stderr,"Modification now '%s'\n",asctime(pTM));
 456
 457     fprintf(stderr,"File Times are (in UTC):\n");
 458     fprintf(stderr,"CreationTime now '%s'\n",ctime(&aFileStat.st_ctime));
 459     fprintf(stderr,"AccessTime   now '%s'\n",ctime(&aTimeBuffer.actime));
 460     fprintf(stderr,"Modification now '%s'\n",ctime(&aTimeBuffer.modtime));
 461 #endif
 462
 463     nRet=utime(pszFilePath,&aTimeBuffer);
 464     if ( nRet < 0 )
 465     {
 466         nRet=errno;
 467         return oslTranslateFileError(OSL_FET_ERROR, nRet);
 468     }
 469
 470     return osl_File_E_None;
 471 }
 472
 473 oslFileError SAL_CALL osl_setFileTime (
 474     rtl_uString* ustrFileURL,
 475     const TimeValue* pCreationTime,
 476     const TimeValue* pLastAccessTime,
 477     const TimeValue* pLastWriteTime )
 478 {
 479     char path[PATH_MAX];
 480     oslFileError eRet;
 481
 482     OSL_ASSERT( ustrFileURL );
 483
 484     /* convert file url to system path */
 485     eRet = FileURLToPath( path, PATH_MAX, ustrFileURL );
 486     if( eRet != osl_File_E_None )
 487         return eRet;
 488
 489 #ifdef MACOSX
 490     if ( macxp_resolveAlias( path, PATH_MAX ) != 0 )
 491       return oslTranslateFileError( OSL_FET_ERROR, errno );
 492 #endif/* MACOSX */
 493
 494     return osl_psz_setFileTime( path, pCreationTime, pLastAccessTime, pLastWriteTime );
 495 }