src/fcstat.c

   1 /*
   2  * Copyright © 2000 Keith Packard
   3  * Copyright © 2005 Patrick Lam
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software and its
   6  * documentation for any purpose is hereby granted without fee, provided that
   7  * the above copyright notice appear in all copies and that both that
   8  * copyright notice and this permission notice appear in supporting
   9  * documentation, and that the name of the author(s) not be used in
  10  * advertising or publicity pertaining to distribution of the software without
  11  * specific, written prior permission.  The authors make no
  12  * representations about the suitability of this software for any purpose.  It
  13  * is provided "as is" without express or implied warranty.
  14  *
  15  * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  16  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  17  * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  18  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  19  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  20  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  21  * PERFORMANCE OF THIS SOFTWARE.
  22  */
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26 #include "fcint.h"
  27 #include "fcarch.h"
  28 #include <dirent.h>
  29 #include <limits.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <fcntl.h>
  33 #ifdef HAVE_SYS_VFS_H
  34 #include <sys/vfs.h>
  35 #endif
  36 #ifdef HAVE_SYS_STATFS_H
  37 #include <sys/statfs.h>
  38 #endif
  39 #ifdef HAVE_SYS_PARAM_H
  40 #include <sys/param.h>
  41 #endif
  42 #ifdef HAVE_SYS_MOUNT_H
  43 #include <sys/mount.h>
  44 #endif
  45
  46 #ifdef _WIN32
  47 #ifdef __GNUC__
  48 typedef long long INT64;
  49 #define EPOCH_OFFSET 11644473600ll
  50 #else
  51 #define EPOCH_OFFSET 11644473600i64
  52 typedef __int64 INT64;
  53 #endif
  54
  55 /* Workaround for problems in the stat() in the Microsoft C library:
  56  *
  57  * 1) stat() uses FindFirstFile() to get the file
  58  * attributes. Unfortunately this API doesn't return correct values
  59  * for modification time of a directory until some time after a file
  60  * or subdirectory has been added to the directory. (This causes
  61  * run-test.sh to fail, for instance.) GetFileAttributesEx() is
  62  * better, it returns the updated timestamp right away.
  63  *
  64  * 2) stat() does some strange things related to backward
  65  * compatibility with the local time timestamps on FAT volumes and
  66  * daylight saving time. This causes problems after the switches
  67  * to/from daylight saving time. See
  68  * http://bugzilla.gnome.org/show_bug.cgi?id=154968 , especially
  69  * comment #30, and http://www.codeproject.com/datetime/dstbugs.asp .
  70  * We don't need any of that, FAT and Win9x are as good as dead. So
  71  * just use the UTC timestamps from NTFS, converted to the Unix epoch.
  72  */
  73
  74 int
  75 FcStat (const FcChar8 *file, struct stat *statb)
  76 {
  77     WIN32_FILE_ATTRIBUTE_DATA wfad;
  78     char full_path_name[MAX_PATH];
  79     char *basename;
  80     DWORD rc;
  81
  82     if (!GetFileAttributesEx ((LPCSTR) file, GetFileExInfoStandard, &wfad))
  83         return -1;
  84
  85     statb->st_dev = 0;
  86
  87     /* Calculate a pseudo inode number as a hash of the full path name.
  88      * Call GetLongPathName() to get the spelling of the path name as it
  89      * is on disk.
  90      */
  91     rc = GetFullPathName ((LPCSTR) file, sizeof (full_path_name), full_path_name, &basename);
  92     if (rc == 0 || rc > sizeof (full_path_name))
  93         return -1;
  94
  95     rc = GetLongPathName (full_path_name, full_path_name, sizeof (full_path_name));
  96     statb->st_ino = FcStringHash ((const FcChar8 *) full_path_name);
  97
  98     statb->st_mode = _S_IREAD | _S_IWRITE;
  99     statb->st_mode |= (statb->st_mode >> 3) | (statb->st_mode >> 6);
 100
 101     if (wfad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 102         statb->st_mode |= _S_IFDIR;
 103     else
 104         statb->st_mode |= _S_IFREG;
 105
 106     statb->st_nlink = 1;
 107     statb->st_uid = statb->st_gid = 0;
 108     statb->st_rdev = 0;
 109
 110     if (wfad.nFileSizeHigh > 0)
 111         return -1;
 112     statb->st_size = wfad.nFileSizeLow;
 113
 114     statb->st_atime = (*(INT64 *)&wfad.ftLastAccessTime)/10000000 - EPOCH_OFFSET;
 115     statb->st_mtime = (*(INT64 *)&wfad.ftLastWriteTime)/10000000 - EPOCH_OFFSET;
 116     statb->st_ctime = statb->st_mtime;
 117
 118     return 0;
 119 }
 120
 121 #else
 122
 123 int
 124 FcStat (const FcChar8 *file, struct stat *statb)
 125 {
 126   return stat ((char *) file, statb);
 127 }
 128
 129 /* Adler-32 checksum implementation */
 130 struct Adler32 {
 131     int a;
 132     int b;
 133 };
 134
 135 static void
 136 Adler32Init (struct Adler32 *ctx)
 137 {
 138     ctx->a = 1;
 139     ctx->b = 0;
 140 }
 141
 142 static void
 143 Adler32Update (struct Adler32 *ctx, const char *data, int data_len)
 144 {
 145     while (data_len--)
 146     {
 147         ctx->a = (ctx->a + *data++) % 65521;
 148         ctx->b = (ctx->b + ctx->a) % 65521;
 149     }
 150 }
 151
 152 static int
 153 Adler32Finish (struct Adler32 *ctx)
 154 {
 155     return ctx->a + (ctx->b << 16);
 156 }
 157
 158 #ifdef HAVE_STRUCT_DIRENT_D_TYPE
 159 /* dirent.d_type can be relied upon on FAT filesystem */
 160 static FcBool
 161 FcDirChecksumScandirFilter(const struct dirent *entry)
 162 {
 163     return entry->d_type != DT_DIR;
 164 }
 165 #endif
 166
 167 static int
 168 FcDirChecksumScandirSorter(const struct dirent **lhs, const struct dirent **rhs)
 169 {
 170     return strcmp((*lhs)->d_name, (*rhs)->d_name);
 171 }
 172
 173 static int
 174 FcDirChecksum (const FcChar8 *dir, time_t *checksum)
 175 {
 176     struct Adler32 ctx;
 177     struct dirent **files;
 178     int n;
 179 #ifndef HAVE_STRUCT_DIRENT_D_TYPE
 180     int ret = 0;
 181     size_t len = strlen ((const char *)dir);
 182 #endif
 183
 184     Adler32Init (&ctx);
 185
 186     n = scandir ((const char *)dir, &files,
 187 #ifdef HAVE_STRUCT_DIRENT_D_TYPE
 188                  &FcDirChecksumScandirFilter,
 189 #else
 190                  NULL,
 191 #endif
 192                  &FcDirChecksumScandirSorter);
 193     if (n == -1)
 194         return -1;
 195
 196     while (n--)
 197     {
 198         size_t dlen = strlen (files[n]->d_name);
 199         int dtype;
 200
 201 #ifdef HAVE_STRUCT_DIRENT_D_TYPE
 202         dtype = files[n]->d_type;
 203 #else
 204         struct stat statb;
 205         char f[PATH_MAX + 1];
 206
 207         memcpy (f, dir, len);
 208         f[len] = FC_DIR_SEPARATOR;
 209         memcpy (&f[len + 1], files[n]->d_name, dlen);
 210         f[len + 1 + dlen] = 0;
 211         if (lstat (f, &statb) < 0)
 212         {
 213             ret = -1;
 214             goto bail;
 215         }
 216         if (S_ISDIR (statb.st_mode))
 217             goto bail;
 218
 219         dtype = statb.st_mode;
 220 #endif
 221         Adler32Update (&ctx, files[n]->d_name, dlen + 1);
 222         Adler32Update (&ctx, (char *)&dtype, sizeof (int));
 223
 224 #ifndef HAVE_STRUCT_DIRENT_D_TYPE
 225       bail:
 226 #endif
 227         free (files[n]);
 228     }
 229     free (files);
 230 #ifndef HAVE_STRUCT_DIRENT_D_TYPE
 231     if (ret == -1)
 232         return -1;
 233 #endif
 234
 235     *checksum = Adler32Finish (&ctx);
 236
 237     return 0;
 238 }
 239 #endif /* _WIN32 */
 240
 241 int
 242 FcStatChecksum (const FcChar8 *file, struct stat *statb)
 243 {
 244     if (FcStat (file, statb) == -1)
 245         return -1;
 246
 247 #ifndef _WIN32
 248     /* We have a workaround of the broken stat() in FcStat() for Win32.
 249      * No need to do something further more.
 250      */
 251     if (FcIsFsMtimeBroken (file))
 252     {
 253         if (FcDirChecksum (file, &statb->st_mtime) == -1)
 254             return -1;
 255     }
 256 #endif
 257
 258     return 0;
 259 }
 260
 261 static int
 262 FcFStatFs (int fd, FcStatFS *statb)
 263 {
 264     const char *p = NULL;
 265     int ret = -1;
 266     FcBool flag = FcFalse;
 267
 268 #if defined(HAVE_FSTATVFS) && (defined(HAVE_STRUCT_STATVFS_F_BASETYPE) || defined(HAVE_STRUCT_STATVFS_F_FSTYPENAME))
 269     struct statvfs buf;
 270
 271     memset (statb, 0, sizeof (FcStatFS));
 272
 273     if ((ret = fstatvfs (fd, &buf)) == 0)
 274     {
 275 #  if defined(HAVE_STRUCT_STATVFS_F_BASETYPE)
 276         p = buf.f_basetype;
 277 #  elif defined(HAVE_STRUCT_STATVFS_F_FSTYPENAME)
 278         p = buf.f_fstypename;
 279 #  endif
 280     }
 281 #elif defined(HAVE_FSTATFS) && (defined(HAVE_STRUCT_STATFS_F_FLAGS) || defined(HAVE_STRUCT_STATFS_F_FSTYPENAME) || defined(__linux__))
 282     struct statfs buf;
 283
 284     memset (statb, 0, sizeof (FcStatFS));
 285
 286     if ((ret = fstatfs (fd, &buf)) == 0)
 287     {
 288 #  if defined(HAVE_STRUCT_STATFS_F_FLAGS) && defined(MNT_LOCAL)
 289         statb->is_remote_fs = !(buf.f_flags & MNT_LOCAL);
 290         flag = FcTrue;
 291 #  endif
 292 #  if defined(HAVE_STRUCT_STATFS_F_FSTYPENAME)
 293         p = buf.f_fstypename;
 294 #  elif defined(__linux__)
 295         switch (buf.f_type)
 296         {
 297         case 0x6969: /* nfs */
 298             statb->is_remote_fs = FcTrue;
 299             break;
 300         case 0x4d44: /* fat */
 301             statb->is_mtime_broken = FcTrue;
 302             break;
 303         default:
 304             break;
 305         }
 306
 307         return ret;
 308 #  else
 309 #    error "BUG: No way to figure out with fstatfs()"
 310 #  endif
 311     }
 312 #endif
 313     if (p)
 314     {
 315         if (!flag && strcmp (p, "nfs") == 0)
 316             statb->is_remote_fs = FcTrue;
 317         if (strcmp (p, "msdosfs") == 0 ||
 318             strcmp (p, "pcfs") == 0)
 319             statb->is_mtime_broken = FcTrue;
 320     }
 321
 322     return ret;
 323 }
 324
 325 FcBool
 326 FcIsFsMmapSafe (int fd)
 327 {
 328     FcStatFS statb;
 329
 330     if (FcFStatFs (fd, &statb) < 0)
 331         return FcTrue;
 332
 333     return !statb.is_remote_fs;
 334 }
 335
 336 FcBool
 337 FcIsFsMtimeBroken (const FcChar8 *dir)
 338 {
 339     int fd = FcOpen ((const char *) dir, O_RDONLY);
 340
 341     if (fd != -1)
 342     {
 343         FcStatFS statb;
 344         int ret = FcFStatFs (fd, &statb);
 345
 346         close (fd);
 347         if (ret < 0)
 348             return FcFalse;
 349
 350         return statb.is_mtime_broken;
 351     }
 352
 353     return FcFalse;
 354 }