glib/gstdio.c

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