glib/gstdio.c

   1 /* gstdio.c - wrappers for C library functions
   2  *
   3  * Copyright 2004 Tor Lillqvist
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public License
  16  * along with this library; if not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "config.h"
  20 #include "glibconfig.h"
  21
  22 #define G_STDIO_NO_WRAP_ON_UNIX
  23
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27
  28 #ifdef G_OS_UNIX
  29 #include <unistd.h>
  30 #endif
  31
  32 #ifdef G_OS_WIN32
  33 #include <windows.h>
  34 #include <errno.h>
  35 #include <wchar.h>
  36 #include <direct.h>
  37 #include <io.h>
  38 #include <sys/utime.h>
  39 #else
  40 #include <utime.h>
  41 #include <errno.h>
  42 #endif
  43
  44 #include "gstdio.h"
  45
  46
  47 #if !defined (G_OS_UNIX) && !defined (G_OS_WIN32)
  48 #error Please port this to your operating system
  49 #endif
  50
  51 #if defined (_MSC_VER) && !defined(_WIN64)
  52 #undef _wstat
  53 #define _wstat _wstat32
  54 #endif
  55
  56 /**
  57  * g_access:
  58  * @filename: (type filename): a pathname in the GLib file name encoding
  59  *     (UTF-8 on Windows)
  60  * @mode: as in access()
  61  *
  62  * A wrapper for the POSIX access() function. This function is used to
  63  * test a pathname for one or several of read, write or execute
  64  * permissions, or just existence.
  65  *
  66  * On Windows, the file protection mechanism is not at all POSIX-like,
  67  * and the underlying function in the C library only checks the
  68  * FAT-style READONLY attribute, and does not look at the ACL of a
  69  * file at all. This function is this in practise almost useless on
  70  * Windows. Software that needs to handle file permissions on Windows
  71  * more exactly should use the Win32 API.
  72  *
  73  * See your C library manual for more details about access().
  74  *
  75  * Returns: zero if the pathname refers to an existing file system
  76  *     object that has all the tested permissions, or -1 otherwise
  77  *     or on error.
  78  *
  79  * Since: 2.8
  80  */
  81 int
  82 g_access (const gchar *filename,
  83           int          mode)
  84 {
  85 #ifdef G_OS_WIN32
  86   wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
  87   int retval;
  88   int save_errno;
  89
  90   if (wfilename == NULL)
  91     {
  92       errno = EINVAL;
  93       return -1;
  94     }
  95
  96 #ifndef X_OK
  97 #define X_OK 1
  98 #endif
  99
 100   retval = _waccess (wfilename, mode & ~X_OK);
 101   save_errno = errno;
 102
 103   g_free (wfilename);
 104
 105   errno = save_errno;
 106   return retval;
 107 #else
 108   return access (filename, mode);
 109 #endif
 110 }
 111
 112 /**
 113  * g_chmod:
 114  * @filename: (type filename): a pathname in the GLib file name encoding
 115  *     (UTF-8 on Windows)
 116  * @mode: as in chmod()
 117  *
 118  * A wrapper for the POSIX chmod() function. The chmod() function is
 119  * used to set the permissions of a file system object.
 120  *
 121  * On Windows the file protection mechanism is not at all POSIX-like,
 122  * and the underlying chmod() function in the C library just sets or
 123  * clears the FAT-style READONLY attribute. It does not touch any
 124  * ACL. Software that needs to manage file permissions on Windows
 125  * exactly should use the Win32 API.
 126  *
 127  * See your C library manual for more details about chmod().
 128  *
 129  * Returns: 0 if the operation succeeded, -1 on error
 130  *
 131  * Since: 2.8
 132  */
 133 int
 134 g_chmod (const gchar *filename,
 135          int          mode)
 136 {
 137 #ifdef G_OS_WIN32
 138   wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
 139   int retval;
 140   int save_errno;
 141
 142   if (wfilename == NULL)
 143     {
 144       errno = EINVAL;
 145       return -1;
 146     }
 147
 148   retval = _wchmod (wfilename, mode);
 149   save_errno = errno;
 150
 151   g_free (wfilename);
 152
 153   errno = save_errno;
 154   return retval;
 155 #else
 156   return chmod (filename, mode);
 157 #endif
 158 }
 159 /**
 160  * g_open:
 161  * @filename: (type filename): a pathname in the GLib file name encoding
 162  *     (UTF-8 on Windows)
 163  * @flags: as in open()
 164  * @mode: as in open()
 165  *
 166  * A wrapper for the POSIX open() function. The open() function is
 167  * used to convert a pathname into a file descriptor.
 168  *
 169  * On POSIX systems file descriptors are implemented by the operating
 170  * system. On Windows, it's the C library that implements open() and
 171  * file descriptors. The actual Win32 API for opening files is quite
 172  * different, see MSDN documentation for CreateFile(). The Win32 API
 173  * uses file handles, which are more randomish integers, not small
 174  * integers like file descriptors.
 175  *
 176  * Because file descriptors are specific to the C library on Windows,
 177  * the file descriptor returned by this function makes sense only to
 178  * functions in the same C library. Thus if the GLib-using code uses a
 179  * different C library than GLib does, the file descriptor returned by
 180  * this function cannot be passed to C library functions like write()
 181  * or read().
 182  *
 183  * See your C library manual for more details about open().
 184  *
 185  * Returns: a new file descriptor, or -1 if an error occurred.
 186  *     The return value can be used exactly like the return value
 187  *     from open().
 188  *
 189  * Since: 2.6
 190  */
 191 int
 192 g_open (const gchar *filename,
 193         int          flags,
 194         int          mode)
 195 {
 196 #ifdef G_OS_WIN32
 197   wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
 198   int retval;
 199   int save_errno;
 200
 201   if (wfilename == NULL)
 202     {
 203       errno = EINVAL;
 204       return -1;
 205     }
 206
 207   retval = _wopen (wfilename, flags, mode);
 208   save_errno = errno;
 209
 210   g_free (wfilename);
 211
 212   errno = save_errno;
 213   return retval;
 214 #else
 215   int fd;
 216   do
 217     fd = open (filename, flags, mode);
 218   while (G_UNLIKELY (fd == -1 && errno == EINTR));
 219   return fd;
 220 #endif
 221 }
 222
 223 /**
 224  * g_creat:
 225  * @filename: (type filename): a pathname in the GLib file name encoding
 226  *     (UTF-8 on Windows)
 227  * @mode: as in creat()
 228  *
 229  * A wrapper for the POSIX creat() function. The creat() function is
 230  * used to convert a pathname into a file descriptor, creating a file
 231  * if necessary.
 232
 233  * On POSIX systems file descriptors are implemented by the operating
 234  * system. On Windows, it's the C library that implements creat() and
 235  * file descriptors. The actual Windows API for opening files is
 236  * different, see MSDN documentation for CreateFile(). The Win32 API
 237  * uses file handles, which are more randomish integers, not small
 238  * integers like file descriptors.
 239  *
 240  * Because file descriptors are specific to the C library on Windows,
 241  * the file descriptor returned by this function makes sense only to
 242  * functions in the same C library. Thus if the GLib-using code uses a
 243  * different C library than GLib does, the file descriptor returned by
 244  * this function cannot be passed to C library functions like write()
 245  * or read().
 246  *
 247  * See your C library manual for more details about creat().
 248  *
 249  * Returns: a new file descriptor, or -1 if an error occurred.
 250  *     The return value can be used exactly like the return value
 251  *     from creat().
 252  *
 253  * Since: 2.8
 254  */
 255 int
 256 g_creat (const gchar *filename,
 257          int          mode)
 258 {
 259 #ifdef G_OS_WIN32
 260   wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
 261   int retval;
 262   int save_errno;
 263
 264   if (wfilename == NULL)
 265     {
 266       errno = EINVAL;
 267       return -1;
 268     }
 269
 270   retval = _wcreat (wfilename, mode);
 271   save_errno = errno;
 272
 273   g_free (wfilename);
 274
 275   errno = save_errno;
 276   return retval;
 277 #else
 278   return creat (filename, mode);
 279 #endif
 280 }
 281
 282 /**
 283  * g_rename:
 284  * @oldfilename: (type filename): a pathname in the GLib file name encoding
 285  *     (UTF-8 on Windows)
 286  * @newfilename: (type filename): a pathname in the GLib file name encoding
 287  *
 288  * A wrapper for the POSIX rename() function. The rename() function
 289  * renames a file, moving it between directories if required.
 290  *
 291  * See your C library manual for more details about how rename() works
 292  * on your system. It is not possible in general on Windows to rename
 293  * a file that is open to some process.
 294  *
 295  * Returns: 0 if the renaming succeeded, -1 if an error occurred
 296  *
 297  * Since: 2.6
 298  */
 299 int
 300 g_rename (const gchar *oldfilename,
 301           const gchar *newfilename)
 302 {
 303 #ifdef G_OS_WIN32
 304   wchar_t *woldfilename = g_utf8_to_utf16 (oldfilename, -1, NULL, NULL, NULL);
 305   wchar_t *wnewfilename;
 306   int retval;
 307   int save_errno = 0;
 308
 309   if (woldfilename == NULL)
 310     {
 311       errno = EINVAL;
 312       return -1;
 313     }
 314
 315   wnewfilename = g_utf8_to_utf16 (newfilename, -1, NULL, NULL, NULL);
 316
 317   if (wnewfilename == NULL)
 318     {
 319       g_free (woldfilename);
 320       errno = EINVAL;
 321       return -1;
 322     }
 323
 324   if (MoveFileExW (woldfilename, wnewfilename, MOVEFILE_REPLACE_EXISTING))
 325     retval = 0;
 326   else
 327     {
 328       retval = -1;
 329       switch (GetLastError ())
 330         {
 331 #define CASE(a,b) case ERROR_##a: save_errno = b; break
 332           CASE (FILE_NOT_FOUND, ENOENT);
 333           CASE (PATH_NOT_FOUND, ENOENT);
 334           CASE (ACCESS_DENIED, EACCES);
 335           CASE (NOT_SAME_DEVICE, EXDEV);
 336           CASE (LOCK_VIOLATION, EACCES);
 337           CASE (SHARING_VIOLATION, EACCES);
 338           CASE (FILE_EXISTS, EEXIST);
 339           CASE (ALREADY_EXISTS, EEXIST);
 340 #undef CASE
 341         default: save_errno = EIO;
 342         }
 343     }
 344
 345   g_free (woldfilename);
 346   g_free (wnewfilename);
 347
 348   errno = save_errno;
 349   return retval;
 350 #else
 351   return rename (oldfilename, newfilename);
 352 #endif
 353 }
 354
 355 /**
 356  * g_mkdir:
 357  * @filename: (type filename): a pathname in the GLib file name encoding
 358  *     (UTF-8 on Windows)
 359  * @mode: permissions to use for the newly created directory
 360  *
 361  * A wrapper for the POSIX mkdir() function. The mkdir() function
 362  * attempts to create a directory with the given name and permissions.
 363  * The mode argument is ignored on Windows.
 364  *
 365  * See your C library manual for more details about mkdir().
 366  *
 367  * Returns: 0 if the directory was successfully created, -1 if an error
 368  *    occurred
 369  *
 370  * Since: 2.6
 371  */
 372 int
 373 g_mkdir (const gchar *filename,
 374          int          mode)
 375 {
 376 #ifdef G_OS_WIN32
 377   wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
 378   int retval;
 379   int save_errno;
 380
 381   if (wfilename == NULL)
 382     {
 383       errno = EINVAL;
 384       return -1;
 385     }
 386
 387   retval = _wmkdir (wfilename);
 388   save_errno = errno;
 389
 390   g_free (wfilename);
 391
 392   errno = save_errno;
 393   return retval;
 394 #else
 395   return mkdir (filename, mode);
 396 #endif
 397 }
 398
 399 /**
 400  * g_chdir:
 401  * @path: (type filename): a pathname in the GLib file name encoding
 402  *     (UTF-8 on Windows)
 403  *
 404  * A wrapper for the POSIX chdir() function. The function changes the
 405  * current directory of the process to @path.
 406  *
 407  * See your C library manual for more details about chdir().
 408  *
 409  * Returns: 0 on success, -1 if an error occurred.
 410  *
 411  * Since: 2.8
 412  */
 413 int
 414 g_chdir (const gchar *path)
 415 {
 416 #ifdef G_OS_WIN32
 417   wchar_t *wpath = g_utf8_to_utf16 (path, -1, NULL, NULL, NULL);
 418   int retval;
 419   int save_errno;
 420
 421   if (wpath == NULL)
 422     {
 423       errno = EINVAL;
 424       return -1;
 425     }
 426
 427   retval = _wchdir (wpath);
 428   save_errno = errno;
 429
 430   g_free (wpath);
 431
 432   errno = save_errno;
 433   return retval;
 434 #else
 435   return chdir (path);
 436 #endif
 437 }
 438
 439 /**
 440  * GStatBuf:
 441  *
 442  * A type corresponding to the appropriate struct type for the stat()
 443  * system call, depending on the platform and/or compiler being used.
 444  *
 445  * See g_stat() for more information.
 446  */
 447 /**
 448  * g_stat:
 449  * @filename: (type filename): a pathname in the GLib file name encoding
 450  *     (UTF-8 on Windows)
 451  * @buf: a pointer to a stat struct, which will be filled with the file
 452  *     information
 453  *
 454  * A wrapper for the POSIX stat() function. The stat() function
 455  * returns information about a file. On Windows the stat() function in
 456  * the C library checks only the FAT-style READONLY attribute and does
 457  * not look at the ACL at all. Thus on Windows the protection bits in
 458  * the @st_mode field are a fabrication of little use.
 459  *
 460  * On Windows the Microsoft C libraries have several variants of the
 461  * stat struct and stat() function with names like _stat(), _stat32(),
 462  * _stat32i64() and _stat64i32(). The one used here is for 32-bit code
 463  * the one with 32-bit size and time fields, specifically called _stat32().
 464  *
 465  * In Microsoft's compiler, by default struct stat means one with
 466  * 64-bit time fields while in MinGW struct stat is the legacy one
 467  * with 32-bit fields. To hopefully clear up this messs, the gstdio.h
 468  * header defines a type #GStatBuf which is the appropriate struct type
 469  * depending on the platform and/or compiler being used. On POSIX it
 470  * is just struct stat, but note that even on POSIX platforms, stat()
 471  * might be a macro.
 472  *
 473  * See your C library manual for more details about stat().
 474  *
 475  * Returns: 0 if the information was successfully retrieved,
 476  *     -1 if an error occurred
 477  *
 478  * Since: 2.6
 479  */
 480 int
 481 g_stat (const gchar *filename,
 482         GStatBuf    *buf)
 483 {
 484 #ifdef G_OS_WIN32
 485   wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
 486   int retval;
 487   int save_errno;
 488   int len;
 489
 490   if (wfilename == NULL)
 491     {
 492       errno = EINVAL;
 493       return -1;
 494     }
 495
 496   len = wcslen (wfilename);
 497   while (len > 0 && G_IS_DIR_SEPARATOR (wfilename[len-1]))
 498     len--;
 499   if (len > 0 &&
 500       (!g_path_is_absolute (filename) || len > g_path_skip_root (filename) - filename))
 501     wfilename[len] = '\0';
 502
 503   retval = _wstat (wfilename, buf);
 504   save_errno = errno;
 505
 506   g_free (wfilename);
 507
 508   errno = save_errno;
 509   return retval;
 510 #else
 511   return stat (filename, buf);
 512 #endif
 513 }
 514
 515 /**
 516  * g_lstat:
 517  * @filename: (type filename): a pathname in the GLib file name encoding
 518  *     (UTF-8 on Windows)
 519  * @buf: a pointer to a stat struct, which will be filled with the file
 520  *     information
 521  *
 522  * A wrapper for the POSIX lstat() function. The lstat() function is
 523  * like stat() except that in the case of symbolic links, it returns
 524  * information about the symbolic link itself and not the file that it
 525  * refers to. If the system does not support symbolic links g_lstat()
 526  * is identical to g_stat().
 527  *
 528  * See your C library manual for more details about lstat().
 529  *
 530  * Returns: 0 if the information was successfully retrieved,
 531  *     -1 if an error occurred
 532  *
 533  * Since: 2.6
 534  */
 535 int
 536 g_lstat (const gchar *filename,
 537          GStatBuf    *buf)
 538 {
 539 #ifdef HAVE_LSTAT
 540   /* This can't be Win32, so don't do the widechar dance. */
 541   return lstat (filename, buf);
 542 #else
 543   return g_stat (filename, buf);
 544 #endif
 545 }
 546
 547 /**
 548  * g_unlink:
 549  * @filename: (type filename): a pathname in the GLib file name encoding
 550  *     (UTF-8 on Windows)
 551  *
 552  * A wrapper for the POSIX unlink() function. The unlink() function
 553  * deletes a name from the filesystem. If this was the last link to the
 554  * file and no processes have it opened, the diskspace occupied by the
 555  * file is freed.
 556  *
 557  * See your C library manual for more details about unlink(). Note
 558  * that on Windows, it is in general not possible to delete files that
 559  * are open to some process, or mapped into memory.
 560  *
 561  * Returns: 0 if the name was successfully deleted, -1 if an error
 562  *    occurred
 563  *
 564  * Since: 2.6
 565  */
 566 int
 567 g_unlink (const gchar *filename)
 568 {
 569 #ifdef G_OS_WIN32
 570   wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
 571   int retval;
 572   int save_errno;
 573
 574   if (wfilename == NULL)
 575     {
 576       errno = EINVAL;
 577       return -1;
 578     }
 579
 580   retval = _wunlink (wfilename);
 581   save_errno = errno;
 582
 583   g_free (wfilename);
 584
 585   errno = save_errno;
 586   return retval;
 587 #else
 588   return unlink (filename);
 589 #endif
 590 }
 591
 592 /**
 593  * g_remove:
 594  * @filename: (type filename): a pathname in the GLib file name encoding
 595  *     (UTF-8 on Windows)
 596  *
 597  * A wrapper for the POSIX remove() function. The remove() function
 598  * deletes a name from the filesystem.
 599  *
 600  * See your C library manual for more details about how remove() works
 601  * on your system. On Unix, remove() removes also directories, as it
 602  * calls unlink() for files and rmdir() for directories. On Windows,
 603  * although remove() in the C library only works for files, this
 604  * function tries first remove() and then if that fails rmdir(), and
 605  * thus works for both files and directories. Note however, that on
 606  * Windows, it is in general not possible to remove a file that is
 607  * open to some process, or mapped into memory.
 608  *
 609  * If this function fails on Windows you can't infer too much from the
 610  * errno value. rmdir() is tried regardless of what caused remove() to
 611  * fail. Any errno value set by remove() will be overwritten by that
 612  * set by rmdir().
 613  *
 614  * Returns: 0 if the file was successfully removed, -1 if an error
 615  *    occurred
 616  *
 617  * Since: 2.6
 618  */
 619 int
 620 g_remove (const gchar *filename)
 621 {
 622 #ifdef G_OS_WIN32
 623   wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
 624   int retval;
 625   int save_errno;
 626
 627   if (wfilename == NULL)
 628     {
 629       errno = EINVAL;
 630       return -1;
 631     }
 632
 633   retval = _wremove (wfilename);
 634   if (retval == -1)
 635     retval = _wrmdir (wfilename);
 636   save_errno = errno;
 637
 638   g_free (wfilename);
 639
 640   errno = save_errno;
 641   return retval;
 642 #else
 643   return remove (filename);
 644 #endif
 645 }
 646
 647 /**
 648  * g_rmdir:
 649  * @filename: (type filename): a pathname in the GLib file name encoding
 650  *     (UTF-8 on Windows)
 651  *
 652  * A wrapper for the POSIX rmdir() function. The rmdir() function
 653  * deletes a directory from the filesystem.
 654  *
 655  * See your C library manual for more details about how rmdir() works
 656  * on your system.
 657  *
 658  * Returns: 0 if the directory was successfully removed, -1 if an error
 659  *    occurred
 660  *
 661  * Since: 2.6
 662  */
 663 int
 664 g_rmdir (const gchar *filename)
 665 {
 666 #ifdef G_OS_WIN32
 667   wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
 668   int retval;
 669   int save_errno;
 670
 671   if (wfilename == NULL)
 672     {
 673       errno = EINVAL;
 674       return -1;
 675     }
 676
 677   retval = _wrmdir (wfilename);
 678   save_errno = errno;
 679
 680   g_free (wfilename);
 681
 682   errno = save_errno;
 683   return retval;
 684 #else
 685   return rmdir (filename);
 686 #endif
 687 }
 688
 689 /**
 690  * g_fopen:
 691  * @filename: (type filename): a pathname in the GLib file name encoding
 692  *     (UTF-8 on Windows)
 693  * @mode: a string describing the mode in which the file should be opened
 694  *
 695  * A wrapper for the stdio fopen() function. The fopen() function
 696  * opens a file and associates a new stream with it.
 697  *
 698  * Because file descriptors are specific to the C library on Windows,
 699  * and a file descriptor is part of the FILE struct, the FILE* returned
 700  * by this function makes sense only to functions in the same C library.
 701  * Thus if the GLib-using code uses a different C library than GLib does,
 702  * the FILE* returned by this function cannot be passed to C library
 703  * functions like fprintf() or fread().
 704  *
 705  * See your C library manual for more details about fopen().
 706  *
 707  * Returns: A FILE* if the file was successfully opened, or %NULL if
 708  *     an error occurred
 709  *
 710  * Since: 2.6
 711  */
 712 FILE *
 713 g_fopen (const gchar *filename,
 714          const gchar *mode)
 715 {
 716 #ifdef G_OS_WIN32
 717   wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
 718   wchar_t *wmode;
 719   FILE *retval;
 720   int save_errno;
 721
 722   if (wfilename == NULL)
 723     {
 724       errno = EINVAL;
 725       return NULL;
 726     }
 727
 728   wmode = g_utf8_to_utf16 (mode, -1, NULL, NULL, NULL);
 729
 730   if (wmode == NULL)
 731     {
 732       g_free (wfilename);
 733       errno = EINVAL;
 734       return NULL;
 735     }
 736
 737   retval = _wfopen (wfilename, wmode);
 738   save_errno = errno;
 739
 740   g_free (wfilename);
 741   g_free (wmode);
 742
 743   errno = save_errno;
 744   return retval;
 745 #else
 746   return fopen (filename, mode);
 747 #endif
 748 }
 749
 750 /**
 751  * g_freopen:
 752  * @filename: (type filename): a pathname in the GLib file name encoding
 753  *     (UTF-8 on Windows)
 754  * @mode: a string describing the mode in which the file should be  opened
 755  * @stream: (nullable): an existing stream which will be reused, or %NULL
 756  *
 757  * A wrapper for the POSIX freopen() function. The freopen() function
 758  * opens a file and associates it with an existing stream.
 759  *
 760  * See your C library manual for more details about freopen().
 761  *
 762  * Returns: A FILE* if the file was successfully opened, or %NULL if
 763  *     an error occurred.
 764  *
 765  * Since: 2.6
 766  */
 767 FILE *
 768 g_freopen (const gchar *filename,
 769            const gchar *mode,
 770            FILE        *stream)
 771 {
 772 #ifdef G_OS_WIN32
 773   wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
 774   wchar_t *wmode;
 775   FILE *retval;
 776   int save_errno;
 777
 778   if (wfilename == NULL)
 779     {
 780       errno = EINVAL;
 781       return NULL;
 782     }
 783
 784   wmode = g_utf8_to_utf16 (mode, -1, NULL, NULL, NULL);
 785
 786   if (wmode == NULL)
 787     {
 788       g_free (wfilename);
 789       errno = EINVAL;
 790       return NULL;
 791     }
 792
 793   retval = _wfreopen (wfilename, wmode, stream);
 794   save_errno = errno;
 795
 796   g_free (wfilename);
 797   g_free (wmode);
 798
 799   errno = save_errno;
 800   return retval;
 801 #else
 802   return freopen (filename, mode, stream);
 803 #endif
 804 }
 805
 806 /**
 807  * g_utime:
 808  * @filename: (type filename): a pathname in the GLib file name encoding
 809  *     (UTF-8 on Windows)
 810  * @utb: a pointer to a struct utimbuf.
 811  *
 812  * A wrapper for the POSIX utime() function. The utime() function
 813  * sets the access and modification timestamps of a file.
 814  *
 815  * See your C library manual for more details about how utime() works
 816  * on your system.
 817  *
 818  * Returns: 0 if the operation was successful, -1 if an error occurred
 819  *
 820  * Since: 2.18
 821  */
 822 int
 823 g_utime (const gchar    *filename,
 824          struct utimbuf *utb)
 825 {
 826 #ifdef G_OS_WIN32
 827   wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
 828   int retval;
 829   int save_errno;
 830
 831   if (wfilename == NULL)
 832     {
 833       errno = EINVAL;
 834       return -1;
 835     }
 836
 837   retval = _wutime (wfilename, (struct _utimbuf*) utb);
 838   save_errno = errno;
 839
 840   g_free (wfilename);
 841
 842   errno = save_errno;
 843   return retval;
 844 #else
 845   return utime (filename, utb);
 846 #endif
 847 }
 848
 849 /**
 850  * g_close:
 851  * @fd: A file descriptor
 852  * @error: a #GError
 853  *
 854  * This wraps the close() call; in case of error, %errno will be
 855  * preserved, but the error will also be stored as a #GError in @error.
 856  *
 857  * Besides using #GError, there is another major reason to prefer this
 858  * function over the call provided by the system; on Unix, it will
 859  * attempt to correctly handle %EINTR, which has platform-specific
 860  * semantics.
 861  *
 862  * Returns: %TRUE on success, %FALSE if there was an error.
 863  *
 864  * Since: 2.36
 865  */
 866 gboolean
 867 g_close (gint       fd,
 868          GError   **error)
 869 {
 870   int res;
 871   res = close (fd);
 872   /* Just ignore EINTR for now; a retry loop is the wrong thing to do
 873    * on Linux at least.  Anyone who wants to add a conditional check
 874    * for e.g. HP-UX is welcome to do so later...
 875    *
 876    * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
 877    * https://bugzilla.gnome.org/show_bug.cgi?id=682819
 878    * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
 879    * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
 880    */
 881   if (G_UNLIKELY (res == -1 && errno == EINTR))
 882     return TRUE;
 883   else if (res == -1)
 884     {
 885       int errsv = errno;
 886       g_set_error_literal (error, G_FILE_ERROR,
 887                            g_file_error_from_errno (errsv),
 888                            g_strerror (errsv));
 889       errno = errsv;
 890       return FALSE;
 891     }
 892   return TRUE;
 893 }
 894