| /* gfileutils.c - File utility functions |
| * |
| * Copyright 2000 Red Hat, Inc. |
| * |
| * SPDX-License-Identifier: LGPL-2.1-or-later |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public License |
| * along with this library; if not, see <http://www.gnu.org/licenses/>. |
| */ |
| |
| #include "config.h" |
| #include "glibconfig.h" |
| |
| #include <sys/stat.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stdarg.h> |
| #include <string.h> |
| #include <errno.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #include <stdlib.h> |
| |
| #ifdef G_OS_UNIX |
| #include <unistd.h> |
| #endif |
| #ifdef G_OS_WIN32 |
| #include <windows.h> |
| #include <io.h> |
| #endif /* G_OS_WIN32 */ |
| |
| #ifndef S_ISLNK |
| #define S_ISLNK(x) 0 |
| #endif |
| |
| #ifndef O_BINARY |
| #define O_BINARY 0 |
| #endif |
| |
| #ifndef O_CLOEXEC |
| #define O_CLOEXEC 0 |
| #endif |
| |
| #include "gfileutils.h" |
| |
| #include "gstdio.h" |
| #include "gstdioprivate.h" |
| #include "glibintl.h" |
| |
| |
| /** |
| * GFileError: |
| * @G_FILE_ERROR_EXIST: Operation not permitted; only the owner of |
| * the file (or other resource) or processes with special privileges |
| * can perform the operation. |
| * @G_FILE_ERROR_ISDIR: File is a directory; you cannot open a directory |
| * for writing, or create or remove hard links to it. |
| * @G_FILE_ERROR_ACCES: Permission denied; the file permissions do not |
| * allow the attempted operation. |
| * @G_FILE_ERROR_NAMETOOLONG: Filename too long. |
| * @G_FILE_ERROR_NOENT: No such file or directory. This is a "file |
| * doesn't exist" error for ordinary files that are referenced in |
| * contexts where they are expected to already exist. |
| * @G_FILE_ERROR_NOTDIR: A file that isn't a directory was specified when |
| * a directory is required. |
| * @G_FILE_ERROR_NXIO: No such device or address. The system tried to |
| * use the device represented by a file you specified, and it |
| * couldn't find the device. This can mean that the device file was |
| * installed incorrectly, or that the physical device is missing or |
| * not correctly attached to the computer. |
| * @G_FILE_ERROR_NODEV: The underlying file system of the specified file |
| * does not support memory mapping. |
| * @G_FILE_ERROR_ROFS: The directory containing the new link can't be |
| * modified because it's on a read-only file system. |
| * @G_FILE_ERROR_TXTBSY: Text file busy. |
| * @G_FILE_ERROR_FAULT: You passed in a pointer to bad memory. |
| * (GLib won't reliably return this, don't pass in pointers to bad |
| * memory.) |
| * @G_FILE_ERROR_LOOP: Too many levels of symbolic links were encountered |
| * in looking up a file name. This often indicates a cycle of symbolic |
| * links. |
| * @G_FILE_ERROR_NOSPC: No space left on device; write operation on a |
| * file failed because the disk is full. |
| * @G_FILE_ERROR_NOMEM: No memory available. The system cannot allocate |
| * more virtual memory because its capacity is full. |
| * @G_FILE_ERROR_MFILE: The current process has too many files open and |
| * can't open any more. Duplicate descriptors do count toward this |
| * limit. |
| * @G_FILE_ERROR_NFILE: There are too many distinct file openings in the |
| * entire system. |
| * @G_FILE_ERROR_BADF: Bad file descriptor; for example, I/O on a |
| * descriptor that has been closed or reading from a descriptor open |
| * only for writing (or vice versa). |
| * @G_FILE_ERROR_INVAL: Invalid argument. This is used to indicate |
| * various kinds of problems with passing the wrong argument to a |
| * library function. |
| * @G_FILE_ERROR_PIPE: Broken pipe; there is no process reading from the |
| * other end of a pipe. Every library function that returns this |
| * error code also generates a 'SIGPIPE' signal; this signal |
| * terminates the program if not handled or blocked. Thus, your |
| * program will never actually see this code unless it has handled |
| * or blocked 'SIGPIPE'. |
| * @G_FILE_ERROR_AGAIN: Resource temporarily unavailable; the call might |
| * work if you try again later. |
| * @G_FILE_ERROR_INTR: Interrupted function call; an asynchronous signal |
| * occurred and prevented completion of the call. When this |
| * happens, you should try the call again. |
| * @G_FILE_ERROR_IO: Input/output error; usually used for physical read |
| * or write errors. i.e. the disk or other physical device hardware |
| * is returning errors. |
| * @G_FILE_ERROR_PERM: Operation not permitted; only the owner of the |
| * file (or other resource) or processes with special privileges can |
| * perform the operation. |
| * @G_FILE_ERROR_NOSYS: Function not implemented; this indicates that |
| * the system is missing some functionality. |
| * @G_FILE_ERROR_FAILED: Does not correspond to a UNIX error code; this |
| * is the standard "failed for unspecified reason" error code present |
| * in all #GError error code enumerations. Returned if no specific |
| * code applies. |
| * |
| * Values corresponding to @errno codes returned from file operations |
| * on UNIX. Unlike @errno codes, GFileError values are available on |
| * all systems, even Windows. The exact meaning of each code depends |
| * on what sort of file operation you were performing; the UNIX |
| * documentation gives more details. The following error code descriptions |
| * come from the GNU C Library manual, and are under the copyright |
| * of that manual. |
| * |
| * It's not very portable to make detailed assumptions about exactly |
| * which errors will be returned from a given operation. Some errors |
| * don't occur on some systems, etc., sometimes there are subtle |
| * differences in when a system will report a given error, etc. |
| */ |
| |
| /** |
| * G_FILE_ERROR: |
| * |
| * Error domain for file operations. Errors in this domain will |
| * be from the #GFileError enumeration. See #GError for information |
| * on error domains. |
| */ |
| |
| /** |
| * GFileTest: |
| * @G_FILE_TEST_IS_REGULAR: %TRUE if the file is a regular file |
| * (not a directory). Note that this test will also return %TRUE |
| * if the tested file is a symlink to a regular file. |
| * @G_FILE_TEST_IS_SYMLINK: %TRUE if the file is a symlink. |
| * @G_FILE_TEST_IS_DIR: %TRUE if the file is a directory. |
| * @G_FILE_TEST_IS_EXECUTABLE: %TRUE if the file is executable. |
| * @G_FILE_TEST_EXISTS: %TRUE if the file exists. It may or may not |
| * be a regular file. |
| * |
| * A test to perform on a file using g_file_test(). |
| */ |
| |
| /** |
| * g_mkdir_with_parents: |
| * @pathname: (type filename): a pathname in the GLib file name encoding |
| * @mode: permissions to use for newly created directories |
| * |
| * Create a directory if it doesn't already exist. Create intermediate |
| * parent directories as needed, too. |
| * |
| * Returns: 0 if the directory already exists, or was successfully |
| * created. Returns -1 if an error occurred, with errno set. |
| * |
| * Since: 2.8 |
| */ |
| int |
| g_mkdir_with_parents (const gchar *pathname, |
| int mode) |
| { |
| gchar *fn, *p; |
| |
| if (pathname == NULL || *pathname == '\0') |
| { |
| errno = EINVAL; |
| return -1; |
| } |
| |
| /* try to create the full path first */ |
| if (g_mkdir (pathname, mode) == 0) |
| return 0; |
| else if (errno == EEXIST) |
| { |
| if (!g_file_test (pathname, G_FILE_TEST_IS_DIR)) |
| { |
| errno = ENOTDIR; |
| return -1; |
| } |
| return 0; |
| } |
| |
| /* walk the full path and try creating each element */ |
| fn = g_strdup (pathname); |
| |
| if (g_path_is_absolute (fn)) |
| p = (gchar *) g_path_skip_root (fn); |
| else |
| p = fn; |
| |
| do |
| { |
| while (*p && !G_IS_DIR_SEPARATOR (*p)) |
| p++; |
| |
| if (!*p) |
| p = NULL; |
| else |
| *p = '\0'; |
| |
| if (!g_file_test (fn, G_FILE_TEST_EXISTS)) |
| { |
| if (g_mkdir (fn, mode) == -1 && errno != EEXIST) |
| { |
| int errno_save = errno; |
| if (errno != ENOENT || !p) |
| { |
| g_free (fn); |
| errno = errno_save; |
| return -1; |
| } |
| } |
| } |
| else if (!g_file_test (fn, G_FILE_TEST_IS_DIR)) |
| { |
| g_free (fn); |
| errno = ENOTDIR; |
| return -1; |
| } |
| if (p) |
| { |
| *p++ = G_DIR_SEPARATOR; |
| while (*p && G_IS_DIR_SEPARATOR (*p)) |
| p++; |
| } |
| } |
| while (p); |
| |
| g_free (fn); |
| |
| return 0; |
| } |
| |
| /** |
| * g_file_test: |
| * @filename: (type filename): a filename to test in the |
| * GLib file name encoding |
| * @test: bitfield of #GFileTest flags |
| * |
| * Returns %TRUE if any of the tests in the bitfield @test are |
| * %TRUE. For example, `(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)` |
| * will return %TRUE if the file exists; the check whether it's a |
| * directory doesn't matter since the existence test is %TRUE. With |
| * the current set of available tests, there's no point passing in |
| * more than one test at a time. |
| * |
| * Apart from %G_FILE_TEST_IS_SYMLINK all tests follow symbolic links, |
| * so for a symbolic link to a regular file g_file_test() will return |
| * %TRUE for both %G_FILE_TEST_IS_SYMLINK and %G_FILE_TEST_IS_REGULAR. |
| * |
| * Note, that for a dangling symbolic link g_file_test() will return |
| * %TRUE for %G_FILE_TEST_IS_SYMLINK and %FALSE for all other flags. |
| * |
| * You should never use g_file_test() to test whether it is safe |
| * to perform an operation, because there is always the possibility |
| * of the condition changing before you actually perform the operation, |
| * see [TOCTOU](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use). |
| * |
| * For example, you might think you could use %G_FILE_TEST_IS_SYMLINK |
| * to know whether it is safe to write to a file without being |
| * tricked into writing into a different location. It doesn't work! |
| * |
| * |[<!-- language="C" --> |
| * // DON'T DO THIS |
| * if (!g_file_test (filename, G_FILE_TEST_IS_SYMLINK)) |
| * { |
| * fd = g_open (filename, O_WRONLY); |
| * // write to fd |
| * } |
| * |
| * // DO THIS INSTEAD |
| * fd = g_open (filename, O_WRONLY | O_NOFOLLOW | O_CLOEXEC); |
| * if (fd == -1) |
| * { |
| * // check error |
| * if (errno == ELOOP) |
| * // file is a symlink and can be ignored |
| * else |
| * // handle errors as before |
| * } |
| * else |
| * { |
| * // write to fd |
| * } |
| * ]| |
| * |
| * Another thing to note is that %G_FILE_TEST_EXISTS and |
| * %G_FILE_TEST_IS_EXECUTABLE are implemented using the access() |
| * system call. This usually doesn't matter, but if your program |
| * is setuid or setgid it means that these tests will give you |
| * the answer for the real user ID and group ID, rather than the |
| * effective user ID and group ID. |
| * |
| * On Windows, there are no symlinks, so testing for |
| * %G_FILE_TEST_IS_SYMLINK will always return %FALSE. Testing for |
| * %G_FILE_TEST_IS_EXECUTABLE will just check that the file exists and |
| * its name indicates that it is executable, checking for well-known |
| * extensions and those listed in the `PATHEXT` environment variable. |
| * |
| * Returns: whether a test was %TRUE |
| **/ |
| gboolean |
| g_file_test (const gchar *filename, |
| GFileTest test) |
| { |
| #ifdef G_OS_WIN32 |
| DWORD attributes; |
| wchar_t *wfilename; |
| #endif |
| |
| g_return_val_if_fail (filename != NULL, FALSE); |
| |
| #ifdef G_OS_WIN32 |
| /* stuff missing in std vc6 api */ |
| # ifndef INVALID_FILE_ATTRIBUTES |
| # define INVALID_FILE_ATTRIBUTES -1 |
| # endif |
| # ifndef FILE_ATTRIBUTE_DEVICE |
| # define FILE_ATTRIBUTE_DEVICE 64 |
| # endif |
| wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL); |
| |
| if (wfilename == NULL) |
| return FALSE; |
| |
| attributes = GetFileAttributesW (wfilename); |
| |
| g_free (wfilename); |
| |
| if (attributes == INVALID_FILE_ATTRIBUTES) |
| return FALSE; |
| |
| if (test & G_FILE_TEST_EXISTS) |
| return TRUE; |
| |
| if (test & G_FILE_TEST_IS_REGULAR) |
| { |
| if ((attributes & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_DEVICE)) == 0) |
| return TRUE; |
| } |
| |
| if (test & G_FILE_TEST_IS_DIR) |
| { |
| if ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) |
| return TRUE; |
| } |
| |
| /* "while" so that we can exit this "loop" with a simple "break" */ |
| while (test & G_FILE_TEST_IS_EXECUTABLE) |
| { |
| const gchar *lastdot = strrchr (filename, '.'); |
| const gchar *pathext = NULL, *p; |
| int extlen; |
| |
| if (lastdot == NULL) |
| break; |
| |
| if (_stricmp (lastdot, ".exe") == 0 || |
| _stricmp (lastdot, ".cmd") == 0 || |
| _stricmp (lastdot, ".bat") == 0 || |
| _stricmp (lastdot, ".com") == 0) |
| return TRUE; |
| |
| /* Check if it is one of the types listed in %PATHEXT% */ |
| |
| pathext = g_getenv ("PATHEXT"); |
| if (pathext == NULL) |
| break; |
| |
| pathext = g_utf8_casefold (pathext, -1); |
| |
| lastdot = g_utf8_casefold (lastdot, -1); |
| extlen = strlen (lastdot); |
| |
| p = pathext; |
| while (TRUE) |
| { |
| const gchar *q = strchr (p, ';'); |
| if (q == NULL) |
| q = p + strlen (p); |
| if (extlen == q - p && |
| memcmp (lastdot, p, extlen) == 0) |
| { |
| g_free ((gchar *) pathext); |
| g_free ((gchar *) lastdot); |
| return TRUE; |
| } |
| if (*q) |
| p = q + 1; |
| else |
| break; |
| } |
| |
| g_free ((gchar *) pathext); |
| g_free ((gchar *) lastdot); |
| break; |
| } |
| |
| return FALSE; |
| #else |
| if ((test & G_FILE_TEST_EXISTS) && (access (filename, F_OK) == 0)) |
| return TRUE; |
| |
| if ((test & G_FILE_TEST_IS_EXECUTABLE) && (access (filename, X_OK) == 0)) |
| { |
| if (getuid () != 0) |
| return TRUE; |
| |
| /* For root, on some POSIX systems, access (filename, X_OK) |
| * will succeed even if no executable bits are set on the |
| * file. We fall through to a stat test to avoid that. |
| */ |
| } |
| else |
| test &= ~G_FILE_TEST_IS_EXECUTABLE; |
| |
| if (test & G_FILE_TEST_IS_SYMLINK) |
| { |
| struct stat s; |
| |
| if ((lstat (filename, &s) == 0) && S_ISLNK (s.st_mode)) |
| return TRUE; |
| } |
| |
| if (test & (G_FILE_TEST_IS_REGULAR | |
| G_FILE_TEST_IS_DIR | |
| G_FILE_TEST_IS_EXECUTABLE)) |
| { |
| struct stat s; |
| |
| if (stat (filename, &s) == 0) |
| { |
| if ((test & G_FILE_TEST_IS_REGULAR) && S_ISREG (s.st_mode)) |
| return TRUE; |
| |
| if ((test & G_FILE_TEST_IS_DIR) && S_ISDIR (s.st_mode)) |
| return TRUE; |
| |
| /* The extra test for root when access (file, X_OK) succeeds. |
| */ |
| if ((test & G_FILE_TEST_IS_EXECUTABLE) && |
| ((s.st_mode & S_IXOTH) || |
| (s.st_mode & S_IXUSR) || |
| (s.st_mode & S_IXGRP))) |
| return TRUE; |
| } |
| } |
| |
| return FALSE; |
| #endif |
| } |
| |
| G_DEFINE_QUARK (g-file-error-quark, g_file_error) |
| |
| /** |
| * g_file_error_from_errno: |
| * @err_no: an "errno" value |
| * |
| * Gets a #GFileError constant based on the passed-in @err_no. |
| * |
| * For example, if you pass in `EEXIST` this function returns |
| * %G_FILE_ERROR_EXIST. Unlike `errno` values, you can portably |
| * assume that all #GFileError values will exist. |
| * |
| * Normally a #GFileError value goes into a #GError returned |
| * from a function that manipulates files. So you would use |
| * g_file_error_from_errno() when constructing a #GError. |
| * |
| * Returns: #GFileError corresponding to the given @err_no |
| **/ |
| GFileError |
| g_file_error_from_errno (gint err_no) |
| { |
| switch (err_no) |
| { |
| #ifdef EEXIST |
| case EEXIST: |
| return G_FILE_ERROR_EXIST; |
| #endif |
| |
| #ifdef EISDIR |
| case EISDIR: |
| return G_FILE_ERROR_ISDIR; |
| #endif |
| |
| #ifdef EACCES |
| case EACCES: |
| return G_FILE_ERROR_ACCES; |
| #endif |
| |
| #ifdef ENAMETOOLONG |
| case ENAMETOOLONG: |
| return G_FILE_ERROR_NAMETOOLONG; |
| #endif |
| |
| #ifdef ENOENT |
| case ENOENT: |
| return G_FILE_ERROR_NOENT; |
| #endif |
| |
| #ifdef ENOTDIR |
| case ENOTDIR: |
| return G_FILE_ERROR_NOTDIR; |
| #endif |
| |
| #ifdef ENXIO |
| case ENXIO: |
| return G_FILE_ERROR_NXIO; |
| #endif |
| |
| #ifdef ENODEV |
| case ENODEV: |
| return G_FILE_ERROR_NODEV; |
| #endif |
| |
| #ifdef EROFS |
| case EROFS: |
| return G_FILE_ERROR_ROFS; |
| #endif |
| |
| #ifdef ETXTBSY |
| case ETXTBSY: |
| return G_FILE_ERROR_TXTBSY; |
| #endif |
| |
| #ifdef EFAULT |
| case EFAULT: |
| return G_FILE_ERROR_FAULT; |
| #endif |
| |
| #ifdef ELOOP |
| case ELOOP: |
| return G_FILE_ERROR_LOOP; |
| #endif |
| |
| #ifdef ENOSPC |
| case ENOSPC: |
| return G_FILE_ERROR_NOSPC; |
| #endif |
| |
| #ifdef ENOMEM |
| case ENOMEM: |
| return G_FILE_ERROR_NOMEM; |
| #endif |
| |
| #ifdef EMFILE |
| case EMFILE: |
| return G_FILE_ERROR_MFILE; |
| #endif |
| |
| #ifdef ENFILE |
| case ENFILE: |
| return G_FILE_ERROR_NFILE; |
| #endif |
| |
| #ifdef EBADF |
| case EBADF: |
| return G_FILE_ERROR_BADF; |
| #endif |
| |
| #ifdef EINVAL |
| case EINVAL: |
| return G_FILE_ERROR_INVAL; |
| #endif |
| |
| #ifdef EPIPE |
| case EPIPE: |
| return G_FILE_ERROR_PIPE; |
| #endif |
| |
| #ifdef EAGAIN |
| case EAGAIN: |
| return G_FILE_ERROR_AGAIN; |
| #endif |
| |
| #ifdef EINTR |
| case EINTR: |
| return G_FILE_ERROR_INTR; |
| #endif |
| |
| #ifdef EIO |
| case EIO: |
| return G_FILE_ERROR_IO; |
| #endif |
| |
| #ifdef EPERM |
| case EPERM: |
| return G_FILE_ERROR_PERM; |
| #endif |
| |
| #ifdef ENOSYS |
| case ENOSYS: |
| return G_FILE_ERROR_NOSYS; |
| #endif |
| |
| default: |
| return G_FILE_ERROR_FAILED; |
| } |
| } |
| |
| static char * |
| format_error_message (const gchar *filename, |
| const gchar *format_string, |
| int saved_errno) G_GNUC_FORMAT(2); |
| |
| #pragma GCC diagnostic push |
| #pragma GCC diagnostic ignored "-Wformat-nonliteral" |
| |
| static char * |
| format_error_message (const gchar *filename, |
| const gchar *format_string, |
| int saved_errno) |
| { |
| gchar *display_name; |
| gchar *msg; |
| |
| display_name = g_filename_display_name (filename); |
| msg = g_strdup_printf (format_string, display_name, g_strerror (saved_errno)); |
| g_free (display_name); |
| |
| return msg; |
| } |
| |
| #pragma GCC diagnostic pop |
| |
| /* format string must have two '%s': |
| * |
| * - the place for the filename |
| * - the place for the strerror |
| */ |
| static void |
| set_file_error (GError **error, |
| const gchar *filename, |
| const gchar *format_string, |
| int saved_errno) |
| { |
| char *msg = format_error_message (filename, format_string, saved_errno); |
| |
| g_set_error_literal (error, G_FILE_ERROR, g_file_error_from_errno (saved_errno), |
| msg); |
| g_free (msg); |
| } |
| |
| static gboolean |
| get_contents_stdio (const gchar *filename, |
| FILE *f, |
| gchar **contents, |
| gsize *length, |
| GError **error) |
| { |
| gchar buf[4096]; |
| gsize bytes; /* always <= sizeof(buf) */ |
| gchar *str = NULL; |
| gsize total_bytes = 0; |
| gsize total_allocated = 0; |
| gchar *tmp; |
| gchar *display_filename; |
| |
| g_assert (f != NULL); |
| |
| while (!feof (f)) |
| { |
| gint save_errno; |
| |
| bytes = fread (buf, 1, sizeof (buf), f); |
| save_errno = errno; |
| |
| if (total_bytes > G_MAXSIZE - bytes) |
| goto file_too_large; |
| |
| /* Possibility of overflow eliminated above. */ |
| while (total_bytes + bytes >= total_allocated) |
| { |
| if (str) |
| { |
| if (total_allocated > G_MAXSIZE / 2) |
| goto file_too_large; |
| total_allocated *= 2; |
| } |
| else |
| { |
| total_allocated = MIN (bytes + 1, sizeof (buf)); |
| } |
| |
| tmp = g_try_realloc (str, total_allocated); |
| |
| if (tmp == NULL) |
| { |
| char *display_size = g_format_size_full (total_allocated, G_FORMAT_SIZE_LONG_FORMAT); |
| display_filename = g_filename_display_name (filename); |
| g_set_error (error, |
| G_FILE_ERROR, |
| G_FILE_ERROR_NOMEM, |
| /* Translators: the first %s contains the file size |
| * (already formatted with units), and the second %s |
| * contains the file name */ |
| _("Could not allocate %s to read file “%s”"), |
| display_size, |
| display_filename); |
| g_free (display_filename); |
| g_free (display_size); |
| |
| goto error; |
| } |
| |
| str = tmp; |
| } |
| |
| if (ferror (f)) |
| { |
| display_filename = g_filename_display_name (filename); |
| g_set_error (error, |
| G_FILE_ERROR, |
| g_file_error_from_errno (save_errno), |
| _("Error reading file “%s”: %s"), |
| display_filename, |
| g_strerror (save_errno)); |
| g_free (display_filename); |
| |
| goto error; |
| } |
| |
| g_assert (str != NULL); |
| memcpy (str + total_bytes, buf, bytes); |
| |
| total_bytes += bytes; |
| } |
| |
| fclose (f); |
| |
| if (total_allocated == 0) |
| { |
| str = g_new (gchar, 1); |
| total_bytes = 0; |
| } |
| |
| str[total_bytes] = '\0'; |
| |
| if (length) |
| *length = total_bytes; |
| |
| *contents = str; |
| |
| return TRUE; |
| |
| file_too_large: |
| display_filename = g_filename_display_name (filename); |
| g_set_error (error, |
| G_FILE_ERROR, |
| G_FILE_ERROR_FAILED, |
| _("File “%s” is too large"), |
| display_filename); |
| g_free (display_filename); |
| |
| error: |
| |
| g_free (str); |
| fclose (f); |
| |
| return FALSE; |
| } |
| |
| #ifndef G_OS_WIN32 |
| |
| static gboolean |
| get_contents_regfile (const gchar *filename, |
| struct stat *stat_buf, |
| gint fd, |
| gchar **contents, |
| gsize *length, |
| GError **error) |
| { |
| gchar *buf; |
| gsize bytes_read; |
| gsize size; |
| gsize alloc_size; |
| gchar *display_filename; |
| |
| if ((G_MAXOFFSET >= G_MAXSIZE) && (stat_buf->st_size > (goffset) (G_MAXSIZE - 1))) |
| { |
| display_filename = g_filename_display_name (filename); |
| g_set_error (error, |
| G_FILE_ERROR, |
| G_FILE_ERROR_FAILED, |
| _("File “%s” is too large"), |
| display_filename); |
| g_free (display_filename); |
| goto error; |
| } |
| |
| size = stat_buf->st_size; |
| |
| alloc_size = size + 1; |
| buf = g_try_malloc (alloc_size); |
| |
| if (buf == NULL) |
| { |
| char *display_size = g_format_size_full (alloc_size, G_FORMAT_SIZE_LONG_FORMAT); |
| display_filename = g_filename_display_name (filename); |
| g_set_error (error, |
| G_FILE_ERROR, |
| G_FILE_ERROR_NOMEM, |
| /* Translators: the first %s contains the file size |
| * (already formatted with units), and the second %s |
| * contains the file name */ |
| _("Could not allocate %s to read file “%s”"), |
| display_size, |
| display_filename); |
| g_free (display_filename); |
| g_free (display_size); |
| goto error; |
| } |
| |
| bytes_read = 0; |
| while (bytes_read < size) |
| { |
| gssize rc; |
| |
| rc = read (fd, buf + bytes_read, size - bytes_read); |
| |
| if (rc < 0) |
| { |
| if (errno != EINTR) |
| { |
| int save_errno = errno; |
| |
| g_free (buf); |
| display_filename = g_filename_display_name (filename); |
| g_set_error (error, |
| G_FILE_ERROR, |
| g_file_error_from_errno (save_errno), |
| _("Failed to read from file “%s”: %s"), |
| display_filename, |
| g_strerror (save_errno)); |
| g_free (display_filename); |
| goto error; |
| } |
| } |
| else if (rc == 0) |
| break; |
| else |
| bytes_read += rc; |
| } |
| |
| buf[bytes_read] = '\0'; |
| |
| if (length) |
| *length = bytes_read; |
| |
| *contents = buf; |
| |
| close (fd); |
| |
| return TRUE; |
| |
| error: |
| |
| close (fd); |
| |
| return FALSE; |
| } |
| |
| static gboolean |
| get_contents_posix (const gchar *filename, |
| gchar **contents, |
| gsize *length, |
| GError **error) |
| { |
| struct stat stat_buf; |
| gint fd; |
| |
| /* O_BINARY useful on Cygwin */ |
| fd = open (filename, O_RDONLY | O_BINARY | O_CLOEXEC); |
| |
| if (fd < 0) |
| { |
| int saved_errno = errno; |
| |
| if (error) |
| set_file_error (error, |
| filename, |
| _("Failed to open file “%s”: %s"), |
| saved_errno); |
| |
| return FALSE; |
| } |
| |
| /* I don't think this will ever fail, aside from ENOMEM, but. */ |
| if (fstat (fd, &stat_buf) < 0) |
| { |
| int saved_errno = errno; |
| if (error) |
| set_file_error (error, |
| filename, |
| _("Failed to get attributes of file “%s”: fstat() failed: %s"), |
| saved_errno); |
| close (fd); |
| |
| return FALSE; |
| } |
| |
| if (stat_buf.st_size > 0 && S_ISREG (stat_buf.st_mode)) |
| { |
| gboolean retval = get_contents_regfile (filename, |
| &stat_buf, |
| fd, |
| contents, |
| length, |
| error); |
| |
| return retval; |
| } |
| else |
| { |
| FILE *f; |
| gboolean retval; |
| |
| f = fdopen (fd, "r"); |
| |
| if (f == NULL) |
| { |
| int saved_errno = errno; |
| if (error) |
| set_file_error (error, |
| filename, |
| _("Failed to open file “%s”: fdopen() failed: %s"), |
| saved_errno); |
| |
| return FALSE; |
| } |
| |
| retval = get_contents_stdio (filename, f, contents, length, error); |
| |
| return retval; |
| } |
| } |
| |
| #else /* G_OS_WIN32 */ |
| |
| static gboolean |
| get_contents_win32 (const gchar *filename, |
| gchar **contents, |
| gsize *length, |
| GError **error) |
| { |
| FILE *f; |
| gboolean retval; |
| |
| f = g_fopen (filename, "rb"); |
| |
| if (f == NULL) |
| { |
| int saved_errno = errno; |
| if (error) |
| set_file_error (error, |
| filename, |
| _("Failed to open file “%s”: %s"), |
| saved_errno); |
| |
| return FALSE; |
| } |
| |
| retval = get_contents_stdio (filename, f, contents, length, error); |
| |
| return retval; |
| } |
| |
| #endif |
| |
| /** |
| * g_file_get_contents: |
| * @filename: (type filename): name of a file to read contents from, in the GLib file name encoding |
| * @contents: (out) (array length=length) (element-type guint8): location to store an allocated string, use g_free() to free |
| * the returned string |
| * @length: (nullable): location to store length in bytes of the contents, or %NULL |
| * @error: return location for a #GError, or %NULL |
| * |
| * Reads an entire file into allocated memory, with good error |
| * checking. |
| * |
| * If the call was successful, it returns %TRUE and sets @contents to the file |
| * contents and @length to the length of the file contents in bytes. The string |
| * stored in @contents will be nul-terminated, so for text files you can pass |
| * %NULL for the @length argument. If the call was not successful, it returns |
| * %FALSE and sets @error. The error domain is %G_FILE_ERROR. Possible error |
| * codes are those in the #GFileError enumeration. In the error case, |
| * @contents is set to %NULL and @length is set to zero. |
| * |
| * Returns: %TRUE on success, %FALSE if an error occurred |
| **/ |
| gboolean |
| g_file_get_contents (const gchar *filename, |
| gchar **contents, |
| gsize *length, |
| GError **error) |
| { |
| g_return_val_if_fail (filename != NULL, FALSE); |
| g_return_val_if_fail (contents != NULL, FALSE); |
| |
| *contents = NULL; |
| if (length) |
| *length = 0; |
| |
| #ifdef G_OS_WIN32 |
| return get_contents_win32 (filename, contents, length, error); |
| #else |
| return get_contents_posix (filename, contents, length, error); |
| #endif |
| } |
| |
| static gboolean |
| rename_file (const char *old_name, |
| const char *new_name, |
| gboolean do_fsync, |
| GError **err) |
| { |
| errno = 0; |
| if (g_rename (old_name, new_name) == -1) |
| { |
| int save_errno = errno; |
| gchar *display_old_name = g_filename_display_name (old_name); |
| gchar *display_new_name = g_filename_display_name (new_name); |
| |
| g_set_error (err, |
| G_FILE_ERROR, |
| g_file_error_from_errno (save_errno), |
| _("Failed to rename file “%s” to “%s”: g_rename() failed: %s"), |
| display_old_name, |
| display_new_name, |
| g_strerror (save_errno)); |
| |
| g_free (display_old_name); |
| g_free (display_new_name); |
| |
| return FALSE; |
| } |
| |
| /* In order to guarantee that the *new* contents of the file are seen in |
| * future, fsync() the directory containing the file. Otherwise if the file |
| * system was unmounted cleanly now, it would be undefined whether the old |
| * or new contents of the file were visible after recovery. |
| * |
| * This assumes the @old_name and @new_name are in the same directory. */ |
| #ifdef HAVE_FSYNC |
| if (do_fsync) |
| { |
| gchar *dir = g_path_get_dirname (new_name); |
| int dir_fd = g_open (dir, O_RDONLY | O_CLOEXEC, 0); |
| |
| if (dir_fd >= 0) |
| { |
| g_fsync (dir_fd); |
| g_close (dir_fd, NULL); |
| } |
| |
| g_free (dir); |
| } |
| #endif /* HAVE_FSYNC */ |
| |
| return TRUE; |
| } |
| |
| static gboolean |
| fd_should_be_fsynced (int fd, |
| const gchar *test_file, |
| GFileSetContentsFlags flags) |
| { |
| #ifdef HAVE_FSYNC |
| struct stat statbuf; |
| |
| /* If the final destination exists and is > 0 bytes, we want to sync the |
| * newly written file to ensure the data is on disk when we rename over |
| * the destination. Otherwise if we get a system crash we can lose both |
| * the new and the old file on some filesystems. (I.E. those that don't |
| * guarantee the data is written to the disk before the metadata.) |
| * |
| * There is no difference (in file system terms) if the old file doesn’t |
| * already exist, apart from the fact that if the system crashes and the new |
| * data hasn’t been fsync()ed, there is only one bit of old data to lose (that |
| * the file didn’t exist in the first place). In some situations, such as |
| * trashing files, the old file never exists, so it seems reasonable to avoid |
| * the fsync(). This is not a widely applicable optimisation though. |
| */ |
| if ((flags & (G_FILE_SET_CONTENTS_CONSISTENT | G_FILE_SET_CONTENTS_DURABLE)) && |
| (flags & G_FILE_SET_CONTENTS_ONLY_EXISTING)) |
| { |
| errno = 0; |
| if (g_lstat (test_file, &statbuf) == 0) |
| return (statbuf.st_size > 0); |
| else if (errno == ENOENT) |
| return FALSE; |
| else |
| return TRUE; /* lstat() failed; be cautious */ |
| } |
| else |
| { |
| return (flags & (G_FILE_SET_CONTENTS_CONSISTENT | G_FILE_SET_CONTENTS_DURABLE)); |
| } |
| #else /* if !HAVE_FSYNC */ |
| return FALSE; |
| #endif /* !HAVE_FSYNC */ |
| } |
| |
| static gboolean |
| truncate_file (int fd, |
| off_t length, |
| const char *dest_file, |
| GError **error) |
| { |
| while ( |
| #ifdef G_OS_WIN32 |
| g_win32_ftruncate (fd, length) < 0 |
| #else |
| ftruncate (fd, length) < 0 |
| #endif |
| ) |
| { |
| int saved_errno = errno; |
| |
| if (saved_errno == EINTR) |
| continue; |
| |
| if (error != NULL) |
| set_file_error (error, |
| dest_file, |
| _("Failed to write file “%s”: ftruncate() failed: %s"), |
| saved_errno); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| /* closes @fd once it’s finished (on success or error) */ |
| static gboolean |
| write_to_file (const gchar *contents, |
| gsize length, |
| int fd, |
| const gchar *dest_file, |
| gboolean do_fsync, |
| GError **err) |
| { |
| #ifdef HAVE_FALLOCATE |
| if (length > 0) |
| { |
| /* We do this on a 'best effort' basis... It may not be supported |
| * on the underlying filesystem. |
| */ |
| (void) fallocate (fd, 0, 0, length); |
| } |
| #endif |
| while (length > 0) |
| { |
| gssize s; |
| |
| #ifdef G_OS_WIN32 |
| /* 'write' on windows uses int types, so limit count to G_MAXINT */ |
| s = write (fd, contents, MIN (length, (gsize) G_MAXINT)); |
| #else |
| /* Limit count to G_MAXSSIZE to fit into the return value. */ |
| s = write (fd, contents, MIN (length, (gsize) G_MAXSSIZE)); |
| #endif |
| if (s < 0) |
| { |
| int saved_errno = errno; |
| if (saved_errno == EINTR) |
| continue; |
| |
| if (err) |
| set_file_error (err, |
| dest_file, _("Failed to write file “%s”: write() failed: %s"), |
| saved_errno); |
| close (fd); |
| |
| return FALSE; |
| } |
| |
| g_assert ((gsize) s <= length); |
| |
| contents += s; |
| length -= s; |
| } |
| |
| |
| #ifdef HAVE_FSYNC |
| errno = 0; |
| if (do_fsync && g_fsync (fd) != 0) |
| { |
| int saved_errno = errno; |
| if (err) |
| set_file_error (err, |
| dest_file, _("Failed to write file “%s”: fsync() failed: %s"), |
| saved_errno); |
| close (fd); |
| |
| return FALSE; |
| } |
| #endif |
| |
| errno = 0; |
| if (!g_close (fd, err)) |
| return FALSE; |
| |
| return TRUE; |
| } |
| |
| /** |
| * g_file_set_contents: |
| * @filename: (type filename): name of a file to write @contents to, in the GLib file name |
| * encoding |
| * @contents: (array length=length) (element-type guint8): string to write to the file |
| * @length: length of @contents, or -1 if @contents is a nul-terminated string |
| * @error: return location for a #GError, or %NULL |
| * |
| * Writes all of @contents to a file named @filename. This is a convenience |
| * wrapper around calling g_file_set_contents_full() with `flags` set to |
| * `G_FILE_SET_CONTENTS_CONSISTENT | G_FILE_SET_CONTENTS_ONLY_EXISTING` and |
| * `mode` set to `0666`. |
| * |
| * Returns: %TRUE on success, %FALSE if an error occurred |
| * |
| * Since: 2.8 |
| */ |
| gboolean |
| g_file_set_contents (const gchar *filename, |
| const gchar *contents, |
| gssize length, |
| GError **error) |
| { |
| return g_file_set_contents_full (filename, contents, length, |
| G_FILE_SET_CONTENTS_CONSISTENT | |
| G_FILE_SET_CONTENTS_ONLY_EXISTING, |
| 0666, error); |
| } |
| |
| /** |
| * g_file_set_contents_full: |
| * @filename: (type filename): name of a file to write @contents to, in the GLib file name |
| * encoding |
| * @contents: (array length=length) (element-type guint8): string to write to the file |
| * @length: length of @contents, or -1 if @contents is a nul-terminated string |
| * @flags: flags controlling the safety vs speed of the operation |
| * @mode: file mode, as passed to `open()`; typically this will be `0666` |
| * @error: return location for a #GError, or %NULL |
| * |
| * Writes all of @contents to a file named @filename, with good error checking. |
| * If a file called @filename already exists it will be overwritten. |
| * |
| * @flags control the properties of the write operation: whether it’s atomic, |
| * and what the tradeoff is between returning quickly or being resilient to |
| * system crashes. |
| * |
| * As this function performs file I/O, it is recommended to not call it anywhere |
| * where blocking would cause problems, such as in the main loop of a graphical |
| * application. In particular, if @flags has any value other than |
| * %G_FILE_SET_CONTENTS_NONE then this function may call `fsync()`. |
| * |
| * If %G_FILE_SET_CONTENTS_CONSISTENT is set in @flags, the operation is atomic |
| * in the sense that it is first written to a temporary file which is then |
| * renamed to the final name. |
| * |
| * Notes: |
| * |
| * - On UNIX, if @filename already exists hard links to @filename will break. |
| * Also since the file is recreated, existing permissions, access control |
| * lists, metadata etc. may be lost. If @filename is a symbolic link, |
| * the link itself will be replaced, not the linked file. |
| * |
| * - On UNIX, if @filename already exists and is non-empty, and if the system |
| * supports it (via a journalling filesystem or equivalent), and if |
| * %G_FILE_SET_CONTENTS_CONSISTENT is set in @flags, the `fsync()` call (or |
| * equivalent) will be used to ensure atomic replacement: @filename |
| * will contain either its old contents or @contents, even in the face of |
| * system power loss, the disk being unsafely removed, etc. |
| * |
| * - On UNIX, if @filename does not already exist or is empty, there is a |
| * possibility that system power loss etc. after calling this function will |
| * leave @filename empty or full of NUL bytes, depending on the underlying |
| * filesystem, unless %G_FILE_SET_CONTENTS_DURABLE and |
| * %G_FILE_SET_CONTENTS_CONSISTENT are set in @flags. |
| * |
| * - On Windows renaming a file will not remove an existing file with the |
| * new name, so on Windows there is a race condition between the existing |
| * file being removed and the temporary file being renamed. |
| * |
| * - On Windows there is no way to remove a file that is open to some |
| * process, or mapped into memory. Thus, this function will fail if |
| * @filename already exists and is open. |
| * |
| * If the call was successful, it returns %TRUE. If the call was not successful, |
| * it returns %FALSE and sets @error. The error domain is %G_FILE_ERROR. |
| * Possible error codes are those in the #GFileError enumeration. |
| * |
| * Note that the name for the temporary file is constructed by appending up |
| * to 7 characters to @filename. |
| * |
| * If the file didn’t exist before and is created, it will be given the |
| * permissions from @mode. Otherwise, the permissions of the existing file may |
| * be changed to @mode depending on @flags, or they may remain unchanged. |
| * |
| * Returns: %TRUE on success, %FALSE if an error occurred |
| * |
| * Since: 2.66 |
| */ |
| gboolean |
| g_file_set_contents_full (const gchar *filename, |
| const gchar *contents, |
| gssize length, |
| GFileSetContentsFlags flags, |
| int mode, |
| GError **error) |
| { |
| g_return_val_if_fail (filename != NULL, FALSE); |
| g_return_val_if_fail (error == NULL || *error == NULL, FALSE); |
| g_return_val_if_fail (contents != NULL || length == 0, FALSE); |
| g_return_val_if_fail (length >= -1, FALSE); |
| |
| /* @flags are handled as follows: |
| * - %G_FILE_SET_CONTENTS_NONE: write directly to @filename, no fsync()s |
| * - %G_FILE_SET_CONTENTS_CONSISTENT: write to temp file, fsync() it, rename() |
| * - %G_FILE_SET_CONTENTS_CONSISTENT | ONLY_EXISTING: as above, but skip the |
| * fsync() if @filename doesn’t exist or is empty |
| * - %G_FILE_SET_CONTENTS_DURABLE: write directly to @filename, fsync() it |
| * - %G_FILE_SET_CONTENTS_DURABLE | ONLY_EXISTING: as above, but skip the |
| * fsync() if @filename doesn’t exist or is empty |
| * - %G_FILE_SET_CONTENTS_CONSISTENT | DURABLE: write to temp file, fsync() |
| * it, rename(), fsync() containing directory |
| * - %G_FILE_SET_CONTENTS_CONSISTENT | DURABLE | ONLY_EXISTING: as above, but |
| * skip both fsync()s if @filename doesn’t exist or is empty |
| */ |
| |
| if (length < 0) |
| length = strlen (contents); |
| |
| if (flags & G_FILE_SET_CONTENTS_CONSISTENT) |
| { |
| gchar *tmp_filename = NULL; |
| GError *rename_error = NULL; |
| gboolean retval; |
| int fd; |
| gboolean do_fsync; |
| |
| tmp_filename = g_strdup_printf ("%s.XXXXXX", filename); |
| |
| errno = 0; |
| fd = g_mkstemp_full (tmp_filename, O_RDWR | O_BINARY | O_CLOEXEC, mode); |
| |
| if (fd == -1) |
| { |
| int saved_errno = errno; |
| if (error) |
| set_file_error (error, |
| tmp_filename, _("Failed to create file “%s”: %s"), |
| saved_errno); |
| retval = FALSE; |
| goto consistent_out; |
| } |
| |
| do_fsync = fd_should_be_fsynced (fd, filename, flags); |
| if (!write_to_file (contents, length, g_steal_fd (&fd), tmp_filename, do_fsync, error)) |
| { |
| g_unlink (tmp_filename); |
| retval = FALSE; |
| goto consistent_out; |
| } |
| |
| if (!rename_file (tmp_filename, filename, do_fsync, &rename_error)) |
| { |
| #ifndef G_OS_WIN32 |
| |
| g_unlink (tmp_filename); |
| g_propagate_error (error, rename_error); |
| retval = FALSE; |
| goto consistent_out; |
| |
| #else /* G_OS_WIN32 */ |
| |
| /* Renaming failed, but on Windows this may just mean |
| * the file already exists. So if the target file |
| * exists, try deleting it and do the rename again. |
| */ |
| if (!g_file_test (filename, G_FILE_TEST_EXISTS)) |
| { |
| g_unlink (tmp_filename); |
| g_propagate_error (error, rename_error); |
| retval = FALSE; |
| goto consistent_out; |
| } |
| |
| g_error_free (rename_error); |
| |
| if (g_unlink (filename) == -1) |
| { |
| int saved_errno = errno; |
| if (error) |
| set_file_error (error, |
| filename, |
| _("Existing file “%s” could not be removed: g_unlink() failed: %s"), |
| saved_errno); |
| g_unlink (tmp_filename); |
| retval = FALSE; |
| goto consistent_out; |
| } |
| |
| if (!rename_file (tmp_filename, filename, flags, error)) |
| { |
| g_unlink (tmp_filename); |
| retval = FALSE; |
| goto consistent_out; |
| } |
| |
| #endif /* G_OS_WIN32 */ |
| } |
| |
| retval = TRUE; |
| |
| consistent_out: |
| g_free (tmp_filename); |
| return retval; |
| } |
| else |
| { |
| int direct_fd; |
| int open_flags; |
| gboolean do_fsync; |
| |
| open_flags = O_RDWR | O_BINARY | O_CREAT | O_CLOEXEC; |
| #ifdef O_NOFOLLOW |
| /* Windows doesn’t have symlinks, so O_NOFOLLOW is unnecessary there. */ |
| open_flags |= O_NOFOLLOW; |
| #endif |
| |
| errno = 0; |
| direct_fd = g_open (filename, open_flags, mode); |
| |
| if (direct_fd < 0) |
| { |
| int saved_errno = errno; |
| |
| #ifdef O_NOFOLLOW |
| /* ELOOP indicates that @filename is a symlink, since we used |
| * O_NOFOLLOW (alternately it could indicate that @filename contains |
| * looping or too many symlinks). In either case, try again on the |
| * %G_FILE_SET_CONTENTS_CONSISTENT code path. |
| * |
| * FreeBSD uses EMLINK instead of ELOOP |
| * (https://www.freebsd.org/cgi/man.cgi?query=open&sektion=2#STANDARDS), |
| * and NetBSD uses EFTYPE |
| * (https://netbsd.gw.com/cgi-bin/man-cgi?open+2+NetBSD-current). */ |
| #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) |
| if (saved_errno == EMLINK) |
| #elif defined(__NetBSD__) |
| if (saved_errno == EFTYPE) |
| #else |
| if (saved_errno == ELOOP) |
| #endif |
| return g_file_set_contents_full (filename, contents, length, |
| flags | G_FILE_SET_CONTENTS_CONSISTENT, |
| mode, error); |
| #endif /* O_NOFOLLOW */ |
| |
| if (error) |
| set_file_error (error, |
| filename, _("Failed to open file “%s”: %s"), |
| saved_errno); |
| return FALSE; |
| } |
| |
| do_fsync = fd_should_be_fsynced (direct_fd, filename, flags); |
| if (!truncate_file (direct_fd, 0, filename, error)) |
| return FALSE; |
| if (!write_to_file (contents, length, g_steal_fd (&direct_fd), filename, |
| do_fsync, error)) |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| /* |
| * get_tmp_file based on the mkstemp implementation from the GNU C library. |
| * Copyright (C) 1991,92,93,94,95,96,97,98,99 Free Software Foundation, Inc. |
| */ |
| typedef gint (*GTmpFileCallback) (const gchar *, gint, gint); |
| |
| static gint |
| get_tmp_file (gchar *tmpl, |
| GTmpFileCallback f, |
| int flags, |
| int mode) |
| { |
| char *XXXXXX; |
| int count, fd; |
| static const char letters[] = |
| "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; |
| static const int NLETTERS = sizeof (letters) - 1; |
| gint64 value; |
| gint64 now_us; |
| static int counter = 0; |
| |
| g_return_val_if_fail (tmpl != NULL, -1); |
| |
| /* find the last occurrence of "XXXXXX" */ |
| XXXXXX = g_strrstr (tmpl, "XXXXXX"); |
| |
| if (!XXXXXX || strncmp (XXXXXX, "XXXXXX", 6)) |
| { |
| errno = EINVAL; |
| return -1; |
| } |
| |
| /* Get some more or less random data. */ |
| now_us = g_get_real_time (); |
| value = ((now_us % G_USEC_PER_SEC) ^ (now_us / G_USEC_PER_SEC)) + counter++; |
| |
| for (count = 0; count < 100; value += 7777, ++count) |
| { |
| gint64 v = value; |
| |
| /* Fill in the random bits. */ |
| XXXXXX[0] = letters[v % NLETTERS]; |
| v /= NLETTERS; |
| XXXXXX[1] = letters[v % NLETTERS]; |
| v /= NLETTERS; |
| XXXXXX[2] = letters[v % NLETTERS]; |
| v /= NLETTERS; |
| XXXXXX[3] = letters[v % NLETTERS]; |
| v /= NLETTERS; |
| XXXXXX[4] = letters[v % NLETTERS]; |
| v /= NLETTERS; |
| XXXXXX[5] = letters[v % NLETTERS]; |
| |
| fd = f (tmpl, flags, mode); |
| |
| if (fd >= 0) |
| return fd; |
| else if (errno != EEXIST) |
| /* Any other error will apply also to other names we might |
| * try, and there are 2^32 or so of them, so give up now. |
| */ |
| return -1; |
| } |
| |
| /* We got out of the loop because we ran out of combinations to try. */ |
| errno = EEXIST; |
| return -1; |
| } |
| |
| /* Some GTmpFileCallback implementations. |
| * |
| * Note: we cannot use open() or g_open() directly because even though |
| * they appear compatible, they may be vararg functions and calling |
| * varargs functions through a non-varargs type is undefined. |
| */ |
| static gint |
| wrap_g_mkdir (const gchar *filename, |
| int flags G_GNUC_UNUSED, |
| int mode) |
| { |
| /* tmpl is in UTF-8 on Windows, thus use g_mkdir() */ |
| return g_mkdir (filename, mode); |
| } |
| |
| static gint |
| wrap_g_open (const gchar *filename, |
| int flags, |
| int mode) |
| { |
| return g_open (filename, flags, mode); |
| } |
| |
| /** |
| * g_mkdtemp_full: (skip) |
| * @tmpl: (type filename): template directory name |
| * @mode: permissions to create the temporary directory with |
| * |
| * Creates a temporary directory. See the mkdtemp() documentation |
| * on most UNIX-like systems. |
| * |
| * The parameter is a string that should follow the rules for |
| * mkdtemp() templates, i.e. contain the string "XXXXXX". |
| * g_mkdtemp_full() is slightly more flexible than mkdtemp() in that the |
| * sequence does not have to occur at the very end of the template |
| * and you can pass a @mode. The X string will be modified to form |
| * the name of a directory that didn't exist. The string should be |
| * in the GLib file name encoding. Most importantly, on Windows it |
| * should be in UTF-8. |
| * |
| * If you are going to be creating a temporary directory inside the |
| * directory returned by g_get_tmp_dir(), you might want to use |
| * g_dir_make_tmp() instead. |
| * |
| * Returns: (nullable) (type filename): A pointer to @tmpl, which has been |
| * modified to hold the directory name. In case of errors, %NULL is |
| * returned, and %errno will be set. |
| * |
| * Since: 2.30 |
| */ |
| gchar * |
| g_mkdtemp_full (gchar *tmpl, |
| gint mode) |
| { |
| if (get_tmp_file (tmpl, wrap_g_mkdir, 0, mode) == -1) |
| return NULL; |
| else |
| return tmpl; |
| } |
| |
| /** |
| * g_mkdtemp: (skip) |
| * @tmpl: (type filename): template directory name |
| * |
| * Creates a temporary directory. See the mkdtemp() documentation |
| * on most UNIX-like systems. |
| * |
| * The parameter is a string that should follow the rules for |
| * mkdtemp() templates, i.e. contain the string "XXXXXX". |
| * g_mkdtemp() is slightly more flexible than mkdtemp() in that the |
| * sequence does not have to occur at the very end of the template. |
| * The X string will be modified to form the name of a directory that |
| * didn't exist. |
| * The string should be in the GLib file name encoding. Most importantly, |
| * on Windows it should be in UTF-8. |
| * |
| * If you are going to be creating a temporary directory inside the |
| * directory returned by g_get_tmp_dir(), you might want to use |
| * g_dir_make_tmp() instead. |
| * |
| * Returns: (nullable) (type filename): A pointer to @tmpl, which has been |
| * modified to hold the directory name. In case of errors, %NULL is |
| * returned and %errno will be set. |
| * |
| * Since: 2.30 |
| */ |
| gchar * |
| g_mkdtemp (gchar *tmpl) |
| { |
| return g_mkdtemp_full (tmpl, 0700); |
| } |
| |
| /** |
| * g_mkstemp_full: (skip) |
| * @tmpl: (type filename): template filename |
| * @flags: flags to pass to an open() call in addition to O_EXCL |
| * and O_CREAT, which are passed automatically |
| * @mode: permissions to create the temporary file with |
| * |
| * Opens a temporary file. See the mkstemp() documentation |
| * on most UNIX-like systems. |
| * |
| * The parameter is a string that should follow the rules for |
| * mkstemp() templates, i.e. contain the string "XXXXXX". |
| * g_mkstemp_full() is slightly more flexible than mkstemp() |
| * in that the sequence does not have to occur at the very end of the |
| * template and you can pass a @mode and additional @flags. The X |
| * string will be modified to form the name of a file that didn't exist. |
| * The string should be in the GLib file name encoding. Most importantly, |
| * on Windows it should be in UTF-8. |
| * |
| * Returns: A file handle (as from open()) to the file |
| * opened for reading and writing. The file handle should be |
| * closed with close(). In case of errors, -1 is returned |
| * and %errno will be set. |
| * |
| * Since: 2.22 |
| */ |
| gint |
| g_mkstemp_full (gchar *tmpl, |
| gint flags, |
| gint mode) |
| { |
| /* tmpl is in UTF-8 on Windows, thus use g_open() */ |
| return get_tmp_file (tmpl, wrap_g_open, |
| flags | O_CREAT | O_EXCL, mode); |
| } |
| |
| /** |
| * g_mkstemp: (skip) |
| * @tmpl: (type filename): template filename |
| * |
| * Opens a temporary file. See the mkstemp() documentation |
| * on most UNIX-like systems. |
| * |
| * The parameter is a string that should follow the rules for |
| * mkstemp() templates, i.e. contain the string "XXXXXX". |
| * g_mkstemp() is slightly more flexible than mkstemp() in that the |
| * sequence does not have to occur at the very end of the template. |
| * The X string will be modified to form the name of a file that |
| * didn't exist. The string should be in the GLib file name encoding. |
| * Most importantly, on Windows it should be in UTF-8. |
| * |
| * Returns: A file handle (as from open()) to the file |
| * opened for reading and writing. The file is opened in binary |
| * mode on platforms where there is a difference. The file handle |
| * should be closed with close(). In case of errors, -1 is |
| * returned and %errno will be set. |
| */ |
| gint |
| g_mkstemp (gchar *tmpl) |
| { |
| return g_mkstemp_full (tmpl, O_RDWR | O_BINARY | O_CLOEXEC, 0600); |
| } |
| |
| static gint |
| g_get_tmp_name (const gchar *tmpl, |
| gchar **name_used, |
| GTmpFileCallback f, |
| gint flags, |
| gint mode, |
| GError **error) |
| { |
| int retval; |
| const char *tmpdir; |
| const char *sep; |
| char *fulltemplate; |
| const char *slash; |
| |
| if (tmpl == NULL) |
| tmpl = ".XXXXXX"; |
| |
| if ((slash = strchr (tmpl, G_DIR_SEPARATOR)) != NULL |
| #ifdef G_OS_WIN32 |
| || (strchr (tmpl, '/') != NULL && (slash = "/")) |
| #endif |
| ) |
| { |
| gchar *display_tmpl = g_filename_display_name (tmpl); |
| char c[2]; |
| c[0] = *slash; |
| c[1] = '\0'; |
| |
| g_set_error (error, |
| G_FILE_ERROR, |
| G_FILE_ERROR_FAILED, |
| _("Template “%s” invalid, should not contain a “%s”"), |
| display_tmpl, c); |
| g_free (display_tmpl); |
| |
| return -1; |
| } |
| |
| if (strstr (tmpl, "XXXXXX") == NULL) |
| { |
| gchar *display_tmpl = g_filename_display_name (tmpl); |
| g_set_error (error, |
| G_FILE_ERROR, |
| G_FILE_ERROR_FAILED, |
| _("Template “%s” doesn’t contain XXXXXX"), |
| display_tmpl); |
| g_free (display_tmpl); |
| return -1; |
| } |
| |
| tmpdir = g_get_tmp_dir (); |
| |
| if (G_IS_DIR_SEPARATOR (tmpdir [strlen (tmpdir) - 1])) |
| sep = ""; |
| else |
| sep = G_DIR_SEPARATOR_S; |
| |
| fulltemplate = g_strconcat (tmpdir, sep, tmpl, NULL); |
| |
| retval = get_tmp_file (fulltemplate, f, flags, mode); |
| if (retval == -1) |
| { |
| int saved_errno = errno; |
| if (error) |
| set_file_error (error, |
| fulltemplate, |
| _("Failed to create file “%s”: %s"), |
| saved_errno); |
| g_free (fulltemplate); |
| return -1; |
| } |
| |
| *name_used = fulltemplate; |
| |
| return retval; |
| } |
| |
| /** |
| * g_file_open_tmp: |
| * @tmpl: (type filename) (nullable): Template for file name, as in |
| * g_mkstemp(), basename only, or %NULL for a default template |
| * @name_used: (out) (type filename): location to store actual name used, |
| * or %NULL |
| * @error: return location for a #GError |
| * |
| * Opens a file for writing in the preferred directory for temporary |
| * files (as returned by g_get_tmp_dir()). |
| * |
| * @tmpl should be a string in the GLib file name encoding containing |
| * a sequence of six 'X' characters, as the parameter to g_mkstemp(). |
| * However, unlike these functions, the template should only be a |
| * basename, no directory components are allowed. If template is |
| * %NULL, a default template is used. |
| * |
| * Note that in contrast to g_mkstemp() (and mkstemp()) @tmpl is not |
| * modified, and might thus be a read-only literal string. |
| * |
| * Upon success, and if @name_used is non-%NULL, the actual name used |
| * is returned in @name_used. This string should be freed with g_free() |
| * when not needed any longer. The returned name is in the GLib file |
| * name encoding. |
| * |
| * Returns: A file handle (as from open()) to the file opened for |
| * reading and writing. The file is opened in binary mode on platforms |
| * where there is a difference. The file handle should be closed with |
| * close(). In case of errors, -1 is returned and @error will be set. |
| */ |
| gint |
| g_file_open_tmp (const gchar *tmpl, |
| gchar **name_used, |
| GError **error) |
| { |
| gchar *fulltemplate; |
| gint result; |
| |
| g_return_val_if_fail (error == NULL || *error == NULL, -1); |
| |
| result = g_get_tmp_name (tmpl, &fulltemplate, |
| wrap_g_open, |
| O_CREAT | O_EXCL | O_RDWR | O_BINARY | O_CLOEXEC, |
| 0600, |
| error); |
| if (result != -1) |
| { |
| if (name_used) |
| *name_used = fulltemplate; |
| else |
| g_free (fulltemplate); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * g_dir_make_tmp: |
| * @tmpl: (type filename) (nullable): Template for directory name, |
| * as in g_mkdtemp(), basename only, or %NULL for a default template |
| * @error: return location for a #GError |
| * |
| * Creates a subdirectory in the preferred directory for temporary |
| * files (as returned by g_get_tmp_dir()). |
| * |
| * @tmpl should be a string in the GLib file name encoding containing |
| * a sequence of six 'X' characters, as the parameter to g_mkstemp(). |
| * However, unlike these functions, the template should only be a |
| * basename, no directory components are allowed. If template is |
| * %NULL, a default template is used. |
| * |
| * Note that in contrast to g_mkdtemp() (and mkdtemp()) @tmpl is not |
| * modified, and might thus be a read-only literal string. |
| * |
| * Returns: (type filename) (transfer full): The actual name used. This string |
| * should be freed with g_free() when not needed any longer and is |
| * is in the GLib file name encoding. In case of errors, %NULL is |
| * returned and @error will be set. |
| * |
| * Since: 2.30 |
| */ |
| gchar * |
| g_dir_make_tmp (const gchar *tmpl, |
| GError **error) |
| { |
| gchar *fulltemplate; |
| |
| g_return_val_if_fail (error == NULL || *error == NULL, NULL); |
| |
| if (g_get_tmp_name (tmpl, &fulltemplate, wrap_g_mkdir, 0, 0700, error) == -1) |
| return NULL; |
| else |
| return fulltemplate; |
| } |
| |
| static gchar * |
| g_build_path_va (const gchar *separator, |
| const gchar *first_element, |
| va_list *args, |
| gchar **str_array) |
| { |
| GString *result; |
| gint separator_len = strlen (separator); |
| gboolean is_first = TRUE; |
| gboolean have_leading = FALSE; |
| const gchar *single_element = NULL; |
| const gchar *next_element; |
| const gchar *last_trailing = NULL; |
| gint i = 0; |
| |
| result = g_string_new (NULL); |
| |
| if (str_array) |
| next_element = str_array[i++]; |
| else |
| next_element = first_element; |
| |
| while (TRUE) |
| { |
| const gchar *element; |
| const gchar *start; |
| const gchar *end; |
| |
| if (next_element) |
| { |
| element = next_element; |
| if (str_array) |
| next_element = str_array[i++]; |
| else |
| next_element = va_arg (*args, gchar *); |
| } |
| else |
| break; |
| |
| /* Ignore empty elements */ |
| if (!*element) |
| continue; |
| |
| start = element; |
| |
| if (separator_len) |
| { |
| while (strncmp (start, separator, separator_len) == 0) |
| start += separator_len; |
| } |
| |
| end = start + strlen (start); |
| |
| if (separator_len) |
| { |
| while (end >= start + separator_len && |
| strncmp (end - separator_len, separator, separator_len) == 0) |
| end -= separator_len; |
| |
| last_trailing = end; |
| while (last_trailing >= element + separator_len && |
| strncmp (last_trailing - separator_len, separator, separator_len) == 0) |
| last_trailing -= separator_len; |
| |
| if (!have_leading) |
| { |
| /* If the leading and trailing separator strings are in the |
| * same element and overlap, the result is exactly that element |
| */ |
| if (last_trailing <= start) |
| single_element = element; |
| |
| g_string_append_len (result, element, start - element); |
| have_leading = TRUE; |
| } |
| else |
| single_element = NULL; |
| } |
| |
| if (end == start) |
| continue; |
| |
| if (!is_first) |
| g_string_append (result, separator); |
| |
| g_string_append_len (result, start, end - start); |
| is_first = FALSE; |
| } |
| |
| if (single_element) |
| { |
| g_string_free (result, TRUE); |
| return g_strdup (single_element); |
| } |
| else |
| { |
| if (last_trailing) |
| g_string_append (result, last_trailing); |
| |
| return g_string_free (result, FALSE); |
| } |
| } |
| |
| /** |
| * g_build_pathv: |
| * @separator: a string used to separator the elements of the path. |
| * @args: (array zero-terminated=1) (element-type filename): %NULL-terminated |
| * array of strings containing the path elements. |
| * |
| * Behaves exactly like g_build_path(), but takes the path elements |
| * as a string array, instead of variadic arguments. |
| * |
| * This function is mainly meant for language bindings. |
| * |
| * Returns: (type filename) (transfer full): a newly-allocated string that |
| * must be freed with g_free(). |
| * |
| * Since: 2.8 |
| */ |
| gchar * |
| g_build_pathv (const gchar *separator, |
| gchar **args) |
| { |
| if (!args) |
| return NULL; |
| |
| return g_build_path_va (separator, NULL, NULL, args); |
| } |
| |
| |
| /** |
| * g_build_path: |
| * @separator: (type filename): a string used to separator the elements of the path. |
| * @first_element: (type filename): the first element in the path |
| * @...: remaining elements in path, terminated by %NULL |
| * |
| * Creates a path from a series of elements using @separator as the |
| * separator between elements. |
| * |
| * At the boundary between two elements, any trailing occurrences of |
| * separator in the first element, or leading occurrences of separator |
| * in the second element are removed and exactly one copy of the |
| * separator is inserted. |
| * |
| * Empty elements are ignored. |
| * |
| * The number of leading copies of the separator on the result is |
| * the same as the number of leading copies of the separator on |
| * the first non-empty element. |
| * |
| * The number of trailing copies of the separator on the result is |
| * the same as the number of trailing copies of the separator on |
| * the last non-empty element. (Determination of the number of |
| * trailing copies is done without stripping leading copies, so |
| * if the separator is `ABA`, then `ABABA` has 1 trailing copy.) |
| * |
| * However, if there is only a single non-empty element, and there |
| * are no characters in that element not part of the leading or |
| * trailing separators, then the result is exactly the original value |
| * of that element. |
| * |
| * Other than for determination of the number of leading and trailing |
| * copies of the separator, elements consisting only of copies |
| * of the separator are ignored. |
| * |
| * Returns: (type filename) (transfer full): the newly allocated path |
| **/ |
| gchar * |
| g_build_path (const gchar *separator, |
| const gchar *first_element, |
| ...) |
| { |
| gchar *str; |
| va_list args; |
| |
| g_return_val_if_fail (separator != NULL, NULL); |
| |
| va_start (args, first_element); |
| str = g_build_path_va (separator, first_element, &args, NULL); |
| va_end (args); |
| |
| return str; |
| } |
| |
| #ifdef G_OS_WIN32 |
| |
| static gchar * |
| g_build_pathname_va (const gchar *first_element, |
| va_list *args, |
| gchar **str_array) |
| { |
| /* Code copied from g_build_pathv(), and modified to use two |
| * alternative single-character separators. |
| */ |
| GString *result; |
| gboolean is_first = TRUE; |
| gboolean have_leading = FALSE; |
| const gchar *single_element = NULL; |
| const gchar *next_element; |
| const gchar *last_trailing = NULL; |
| gchar current_separator = '\\'; |
| gint i = 0; |
| |
| result = g_string_new (NULL); |
| |
| if (str_array) |
| next_element = str_array[i++]; |
| else |
| next_element = first_element; |
| |
| while (TRUE) |
| { |
| const gchar *element; |
| const gchar *start; |
| const gchar *end; |
| |
| if (next_element) |
| { |
| element = next_element; |
| if (str_array) |
| next_element = str_array[i++]; |
| else |
| next_element = va_arg (*args, gchar *); |
| } |
| else |
| break; |
| |
| /* Ignore empty elements */ |
| if (!*element) |
| continue; |
| |
| start = element; |
| |
| if (TRUE) |
| { |
| while (start && |
| (*start == '\\' || *start == '/')) |
| { |
| current_separator = *start; |
| start++; |
| } |
| } |
| |
| end = start + strlen (start); |
| |
| if (TRUE) |
| { |
| while (end >= start + 1 && |
| (end[-1] == '\\' || end[-1] == '/')) |
| { |
| current_separator = end[-1]; |
| end--; |
| } |
| |
| last_trailing = end; |
| while (last_trailing >= element + 1 && |
| (last_trailing[-1] == '\\' || last_trailing[-1] == '/')) |
| last_trailing--; |
| |
| if (!have_leading) |
| { |
| /* If the leading and trailing separator strings are in the |
| * same element and overlap, the result is exactly that element |
| */ |
| if (last_trailing <= start) |
| single_element = element; |
| |
| g_string_append_len (result, element, start - element); |
| have_leading = TRUE; |
| } |
| else |
| single_element = NULL; |
| } |
| |
| if (end == start) |
| continue; |
| |
| if (!is_first) |
| g_string_append_len (result, ¤t_separator, 1); |
| |
| g_string_append_len (result, start, end - start); |
| is_first = FALSE; |
| } |
| |
| if (single_element) |
| { |
| g_string_free (result, TRUE); |
| return g_strdup (single_element); |
| } |
| else |
| { |
| if (last_trailing) |
| g_string_append (result, last_trailing); |
| |
| return g_string_free (result, FALSE); |
| } |
| } |
| |
| #endif |
| |
| static gchar * |
| g_build_filename_va (const gchar *first_argument, |
| va_list *args, |
| gchar **str_array) |
| { |
| gchar *str; |
| |
| #ifndef G_OS_WIN32 |
| str = g_build_path_va (G_DIR_SEPARATOR_S, first_argument, args, str_array); |
| #else |
| str = g_build_pathname_va (first_argument, args, str_array); |
| #endif |
| |
| return str; |
| } |
| |
| /** |
| * g_build_filename_valist: |
| * @first_element: (type filename): the first element in the path |
| * @args: va_list of remaining elements in path |
| * |
| * Creates a filename from a list of elements using the correct |
| * separator for the current platform. |
| * |
| * Behaves exactly like g_build_filename(), but takes the path elements |
| * as a va_list. |
| * |
| * This function is mainly meant for implementing other variadic arguments |
| * functions. |
| * |
| * Returns: (type filename) (transfer full): the newly allocated path |
| * |
| * Since: 2.56 |
| */ |
| gchar * |
| g_build_filename_valist (const gchar *first_element, |
| va_list *args) |
| { |
| g_return_val_if_fail (first_element != NULL, NULL); |
| |
| return g_build_filename_va (first_element, args, NULL); |
| } |
| |
| /** |
| * g_build_filenamev: |
| * @args: (array zero-terminated=1) (element-type filename): %NULL-terminated |
| * array of strings containing the path elements. |
| * |
| * Creates a filename from a vector of elements using the correct |
| * separator for the current platform. |
| * |
| * This function behaves exactly like g_build_filename(), but takes the path |
| * elements as a string array, instead of varargs. This function is mainly |
| * meant for language bindings. |
| * |
| * If you are building a path programmatically you may want to use |
| * #GPathBuf instead. |
| * |
| * Returns: (type filename) (transfer full): the newly allocated path |
| * |
| * Since: 2.8 |
| */ |
| gchar * |
| g_build_filenamev (gchar **args) |
| { |
| return g_build_filename_va (NULL, NULL, args); |
| } |
| |
| /** |
| * g_build_filename: |
| * @first_element: (type filename): the first element in the path |
| * @...: remaining elements in path, terminated by %NULL |
| * |
| * Creates a filename from a series of elements using the correct |
| * separator for the current platform. |
| * |
| * On Unix, this function behaves identically to `g_build_path |
| * (G_DIR_SEPARATOR_S, first_element, ....)`. |
| * |
| * On Windows, it takes into account that either the backslash |
| * (`\` or slash (`/`) can be used as separator in filenames, but |
| * otherwise behaves as on UNIX. When file pathname separators need |
| * to be inserted, the one that last previously occurred in the |
| * parameters (reading from left to right) is used. |
| * |
| * No attempt is made to force the resulting filename to be an absolute |
| * path. If the first element is a relative path, the result will |
| * be a relative path. |
| * |
| * If you are building a path programmatically you may want to use |
| * #GPathBuf instead. |
| * |
| * Returns: (type filename) (transfer full): the newly allocated path |
| */ |
| gchar * |
| g_build_filename (const gchar *first_element, |
| ...) |
| { |
| gchar *str; |
| va_list args; |
| |
| va_start (args, first_element); |
| str = g_build_filename_va (first_element, &args, NULL); |
| va_end (args); |
| |
| return str; |
| } |
| |
| /** |
| * g_file_read_link: |
| * @filename: (type filename): the symbolic link |
| * @error: return location for a #GError |
| * |
| * Reads the contents of the symbolic link @filename like the POSIX |
| * `readlink()` function. |
| * |
| * The returned string is in the encoding used for filenames. Use |
| * g_filename_to_utf8() to convert it to UTF-8. |
| * |
| * The returned string may also be a relative path. Use g_build_filename() |
| * to convert it to an absolute path: |
| * |
| * |[<!-- language="C" --> |
| * g_autoptr(GError) local_error = NULL; |
| * g_autofree gchar *link_target = g_file_read_link ("/etc/localtime", &local_error); |
| * |
| * if (local_error != NULL) |
| * g_error ("Error reading link: %s", local_error->message); |
| * |
| * if (!g_path_is_absolute (link_target)) |
| * { |
| * g_autofree gchar *absolute_link_target = g_build_filename ("/etc", link_target, NULL); |
| * g_free (link_target); |
| * link_target = g_steal_pointer (&absolute_link_target); |
| * } |
| * ]| |
| * |
| * Returns: (type filename) (transfer full): A newly-allocated string with |
| * the contents of the symbolic link, or %NULL if an error occurred. |
| * |
| * Since: 2.4 |
| */ |
| gchar * |
| g_file_read_link (const gchar *filename, |
| GError **error) |
| { |
| #if defined (HAVE_READLINK) |
| gchar *buffer; |
| size_t size; |
| gssize read_size; |
| |
| g_return_val_if_fail (filename != NULL, NULL); |
| g_return_val_if_fail (error == NULL || *error == NULL, NULL); |
| |
| size = 256; |
| buffer = g_malloc (size); |
| |
| while (TRUE) |
| { |
| read_size = readlink (filename, buffer, size); |
| if (read_size < 0) |
| { |
| int saved_errno = errno; |
| if (error) |
| set_file_error (error, |
| filename, |
| _("Failed to read the symbolic link “%s”: %s"), |
| saved_errno); |
| g_free (buffer); |
| return NULL; |
| } |
| |
| if ((size_t) read_size < size) |
| { |
| buffer[read_size] = 0; |
| return buffer; |
| } |
| |
| size *= 2; |
| buffer = g_realloc (buffer, size); |
| } |
| #elif defined (G_OS_WIN32) |
| gchar *buffer; |
| gssize read_size; |
| |
| g_return_val_if_fail (filename != NULL, NULL); |
| g_return_val_if_fail (error == NULL || *error == NULL, NULL); |
| |
| read_size = g_win32_readlink_utf8 (filename, NULL, 0, &buffer, TRUE); |
| if (read_size < 0) |
| { |
| int saved_errno = errno; |
| if (error) |
| set_file_error (error, |
| filename, |
| _("Failed to read the symbolic link “%s”: %s"), |
| saved_errno); |
| return NULL; |
| } |
| else if (read_size == 0) |
| return strdup (""); |
| else |
| return buffer; |
| #else |
| g_return_val_if_fail (filename != NULL, NULL); |
| g_return_val_if_fail (error == NULL || *error == NULL, NULL); |
| |
| g_set_error_literal (error, |
| G_FILE_ERROR, |
| G_FILE_ERROR_INVAL, |
| _("Symbolic links not supported")); |
| |
| return NULL; |
| #endif |
| } |
| |
| /** |
| * g_path_is_absolute: |
| * @file_name: (type filename): a file name |
| * |
| * Returns %TRUE if the given @file_name is an absolute file name. |
| * Note that this is a somewhat vague concept on Windows. |
| * |
| * On POSIX systems, an absolute file name is well-defined. It always |
| * starts from the single root directory. For example "/usr/local". |
| * |
| * On Windows, the concepts of current drive and drive-specific |
| * current directory introduce vagueness. This function interprets as |
| * an absolute file name one that either begins with a directory |
| * separator such as "\Users\tml" or begins with the root on a drive, |
| * for example "C:\Windows". The first case also includes UNC paths |
| * such as "\\\\myserver\docs\foo". In all cases, either slashes or |
| * backslashes are accepted. |
| * |
| * Note that a file name relative to the current drive root does not |
| * truly specify a file uniquely over time and across processes, as |
| * the current drive is a per-process value and can be changed. |
| * |
| * File names relative the current directory on some specific drive, |
| * such as "D:foo/bar", are not interpreted as absolute by this |
| * function, but they obviously are not relative to the normal current |
| * directory as returned by getcwd() or g_get_current_dir() |
| * either. Such paths should be avoided, or need to be handled using |
| * Windows-specific code. |
| * |
| * Returns: %TRUE if @file_name is absolute |
| */ |
| gboolean |
| g_path_is_absolute (const gchar *file_name) |
| { |
| g_return_val_if_fail (file_name != NULL, FALSE); |
| |
| if (G_IS_DIR_SEPARATOR (file_name[0])) |
| return TRUE; |
| |
| #ifdef G_OS_WIN32 |
| /* Recognize drive letter on native Windows */ |
| if (g_ascii_isalpha (file_name[0]) && |
| file_name[1] == ':' && G_IS_DIR_SEPARATOR (file_name[2])) |
| return TRUE; |
| #endif |
| |
| return FALSE; |
| } |
| |
| /** |
| * g_path_skip_root: |
| * @file_name: (type filename): a file name |
| * |
| * Returns a pointer into @file_name after the root component, |
| * i.e. after the "/" in UNIX or "C:\" under Windows. If @file_name |
| * is not an absolute path it returns %NULL. |
| * |
| * Returns: (type filename) (nullable): a pointer into @file_name after the |
| * root component |
| */ |
| const gchar * |
| g_path_skip_root (const gchar *file_name) |
| { |
| g_return_val_if_fail (file_name != NULL, NULL); |
| |
| #ifdef G_PLATFORM_WIN32 |
| /* Skip \\server\share or //server/share */ |
| if (G_IS_DIR_SEPARATOR (file_name[0]) && |
| G_IS_DIR_SEPARATOR (file_name[1]) && |
| file_name[2] && |
| !G_IS_DIR_SEPARATOR (file_name[2])) |
| { |
| gchar *p; |
| p = strchr (file_name + 2, G_DIR_SEPARATOR); |
| |
| #ifdef G_OS_WIN32 |
| { |
| gchar *q; |
| |
| q = strchr (file_name + 2, '/'); |
| if (p == NULL || (q != NULL && q < p)) |
| p = q; |
| } |
| #endif |
| |
| if (p && p > file_name + 2 && p[1]) |
| { |
| file_name = p + 1; |
| |
| while (file_name[0] && !G_IS_DIR_SEPARATOR (file_name[0])) |
| file_name++; |
| |
| /* Possibly skip a backslash after the share name */ |
| if (G_IS_DIR_SEPARATOR (file_name[0])) |
| file_name++; |
| |
| return (gchar *)file_name; |
| } |
| } |
| #endif |
| |
| /* Skip initial slashes */ |
| if (G_IS_DIR_SEPARATOR (file_name[0])) |
| { |
| while (G_IS_DIR_SEPARATOR (file_name[0])) |
| file_name++; |
| return (gchar *)file_name; |
| } |
| |
| #ifdef G_OS_WIN32 |
| /* Skip X:\ */ |
| if (g_ascii_isalpha (file_name[0]) && |
| file_name[1] == ':' && |
| G_IS_DIR_SEPARATOR (file_name[2])) |
| return (gchar *)file_name + 3; |
| #endif |
| |
| return NULL; |
| } |
| |
| /** |
| * g_basename: |
| * @file_name: (type filename): the name of the file |
| * |
| * Gets the name of the file without any leading directory |
| * components. It returns a pointer into the given file name |
| * string. |
| * |
| * Returns: (type filename): the name of the file without any leading |
| * directory components |
| * |
| * Deprecated:2.2: Use g_path_get_basename() instead, but notice |
| * that g_path_get_basename() allocates new memory for the |
| * returned string, unlike this function which returns a pointer |
| * into the argument. |
| */ |
| const gchar * |
| g_basename (const gchar *file_name) |
| { |
| gchar *base; |
| |
| g_return_val_if_fail (file_name != NULL, NULL); |
| |
| base = strrchr (file_name, G_DIR_SEPARATOR); |
| |
| #ifdef G_OS_WIN32 |
| { |
| gchar *q; |
| q = strrchr (file_name, '/'); |
| if (base == NULL || (q != NULL && q > base)) |
| base = q; |
| } |
| #endif |
| |
| if (base) |
| return base + 1; |
| |
| #ifdef G_OS_WIN32 |
| if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':') |
| return (gchar*) file_name + 2; |
| #endif |
| |
| return (gchar*) file_name; |
| } |
| |
| /** |
| * g_path_get_basename: |
| * @file_name: (type filename): the name of the file |
| * |
| * Gets the last component of the filename. |
| * |
| * If @file_name ends with a directory separator it gets the component |
| * before the last slash. If @file_name consists only of directory |
| * separators (and on Windows, possibly a drive letter), a single |
| * separator is returned. If @file_name is empty, it gets ".". |
| * |
| * Returns: (type filename) (transfer full): a newly allocated string |
| * containing the last component of the filename |
| */ |
| gchar * |
| g_path_get_basename (const gchar *file_name) |
| { |
| gssize base; |
| gssize last_nonslash; |
| gsize len; |
| gchar *retval; |
| |
| g_return_val_if_fail (file_name != NULL, NULL); |
| |
| if (file_name[0] == '\0') |
| return g_strdup ("."); |
| |
| last_nonslash = strlen (file_name) - 1; |
| |
| while (last_nonslash >= 0 && G_IS_DIR_SEPARATOR (file_name [last_nonslash])) |
| last_nonslash--; |
| |
| if (last_nonslash == -1) |
| /* string only containing slashes */ |
| return g_strdup (G_DIR_SEPARATOR_S); |
| |
| #ifdef G_OS_WIN32 |
| if (last_nonslash == 1 && |
| g_ascii_isalpha (file_name[0]) && |
| file_name[1] == ':') |
| /* string only containing slashes and a drive */ |
| return g_strdup (G_DIR_SEPARATOR_S); |
| #endif |
| base = last_nonslash; |
| |
| while (base >=0 && !G_IS_DIR_SEPARATOR (file_name [base])) |
| base--; |
| |
| #ifdef G_OS_WIN32 |
| if (base == -1 && |
| g_ascii_isalpha (file_name[0]) && |
| file_name[1] == ':') |
| base = 1; |
| #endif /* G_OS_WIN32 */ |
| |
| len = last_nonslash - base; |
| retval = g_malloc (len + 1); |
| memcpy (retval, file_name + (base + 1), len); |
| retval [len] = '\0'; |
| |
| return retval; |
| } |
| |
| /** |
| * g_dirname: |
| * @file_name: (type filename): the name of the file |
| * |
| * Gets the directory components of a file name. |
| * |
| * If the file name has no directory components "." is returned. |
| * The returned string should be freed when no longer needed. |
| * |
| * Returns: (type filename) (transfer full): the directory components of the file |
| * |
| * Deprecated: use g_path_get_dirname() instead |
| */ |
| |
| /** |
| * g_path_get_dirname: |
| * @file_name: (type filename): the name of the file |
| * |
| * Gets the directory components of a file name. For example, the directory |
| * component of `/usr/bin/test` is `/usr/bin`. The directory component of `/` |
| * is `/`. |
| * |
| * If the file name has no directory components "." is returned. |
| * The returned string should be freed when no longer needed. |
| * |
| * Returns: (type filename) (transfer full): the directory components of the file |
| */ |
| gchar * |
| g_path_get_dirname (const gchar *file_name) |
| { |
| gchar *base; |
| gsize len; |
| |
| g_return_val_if_fail (file_name != NULL, NULL); |
| |
| base = strrchr (file_name, G_DIR_SEPARATOR); |
| |
| #ifdef G_OS_WIN32 |
| { |
| gchar *q; |
| q = strrchr (file_name, '/'); |
| if (base == NULL || (q != NULL && q > base)) |
| base = q; |
| } |
| #endif |
| |
| if (!base) |
| { |
| #ifdef G_OS_WIN32 |
| if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':') |
| { |
| gchar drive_colon_dot[4]; |
| |
| drive_colon_dot[0] = file_name[0]; |
| drive_colon_dot[1] = ':'; |
| drive_colon_dot[2] = '.'; |
| drive_colon_dot[3] = '\0'; |
| |
| return g_strdup (drive_colon_dot); |
| } |
| #endif |
| return g_strdup ("."); |
| } |
| |
| while (base > file_name && G_IS_DIR_SEPARATOR (*base)) |
| base--; |
| |
| #ifdef G_OS_WIN32 |
| /* base points to the char before the last slash. |
| * |
| * In case file_name is the root of a drive (X:\) or a child of the |
| * root of a drive (X:\foo), include the slash. |
| * |
| * In case file_name is the root share of an UNC path |
| * (\\server\share), add a slash, returning \\server\share\ . |
| * |
| * In case file_name is a direct child of a share in an UNC path |
| * (\\server\share\foo), include the slash after the share name, |
| * returning \\server\share\ . |
| */ |
| if (base == file_name + 1 && |
| g_ascii_isalpha (file_name[0]) && |
| file_name[1] == ':') |
| base++; |
| else if (G_IS_DIR_SEPARATOR (file_name[0]) && |
| G_IS_DIR_SEPARATOR (file_name[1]) && |
| file_name[2] && |
| !G_IS_DIR_SEPARATOR (file_name[2]) && |
| base >= file_name + 2) |
| { |
| const gchar *p = file_name + 2; |
| while (*p && !G_IS_DIR_SEPARATOR (*p)) |
| p++; |
| if (p == base + 1) |
| { |
| len = (guint) strlen (file_name) + 1; |
| base = g_new (gchar, len + 1); |
| strcpy (base, file_name); |
| base[len-1] = G_DIR_SEPARATOR; |
| base[len] = 0; |
| return base; |
| } |
| if (G_IS_DIR_SEPARATOR (*p)) |
| { |
| p++; |
| while (*p && !G_IS_DIR_SEPARATOR (*p)) |
| p++; |
| if (p == base + 1) |
| base++; |
| } |
| } |
| #endif |
| |
| len = (guint) 1 + base - file_name; |
| base = g_new (gchar, len + 1); |
| memmove (base, file_name, len); |
| base[len] = 0; |
| |
| return base; |
| } |
| |
| /** |
| * g_canonicalize_filename: |
| * @filename: (type filename): the name of the file |
| * @relative_to: (type filename) (nullable): the relative directory, or %NULL |
| * to use the current working directory |
| * |
| * Gets the canonical file name from @filename. All triple slashes are turned into |
| * single slashes, and all `..` and `.`s resolved against @relative_to. |
| * |
| * Symlinks are not followed, and the returned path is guaranteed to be absolute. |
| * |
| * If @filename is an absolute path, @relative_to is ignored. Otherwise, |
| * @relative_to will be prepended to @filename to make it absolute. @relative_to |
| * must be an absolute path, or %NULL. If @relative_to is %NULL, it'll fallback |
| * to g_get_current_dir(). |
| * |
| * This function never fails, and will canonicalize file paths even if they don't |
| * exist. |
| * |
| * No file system I/O is done. |
| * |
| * Returns: (type filename) (transfer full): a newly allocated string with the |
| * canonical file path |
| * |
| * Since: 2.58 |
| */ |
| gchar * |
| g_canonicalize_filename (const gchar *filename, |
| const gchar *relative_to) |
| { |
| gchar *canon, *input, *output, *after_root, *output_start; |
| |
| g_return_val_if_fail (relative_to == NULL || g_path_is_absolute (relative_to), NULL); |
| |
| if (!g_path_is_absolute (filename)) |
| { |
| gchar *cwd_allocated = NULL; |
| const gchar *cwd; |
| |
| if (relative_to != NULL) |
| cwd = relative_to; |
| else |
| cwd = cwd_allocated = g_get_current_dir (); |
| |
| canon = g_build_filename (cwd, filename, NULL); |
| g_free (cwd_allocated); |
| } |
| else |
| { |
| canon = g_strdup (filename); |
| } |
| |
| after_root = (char *)g_path_skip_root (canon); |
| |
| if (after_root == NULL) |
| { |
| /* This shouldn't really happen, as g_get_current_dir() should |
| return an absolute pathname, but bug 573843 shows this is |
| not always happening */ |
| g_free (canon); |
| return g_build_filename (G_DIR_SEPARATOR_S, filename, NULL); |
| } |
| |
| /* Find the first dir separator and use the canonical dir separator. */ |
| for (output = after_root - 1; |
| (output >= canon) && G_IS_DIR_SEPARATOR (*output); |
| output--) |
| *output = G_DIR_SEPARATOR; |
| |
| /* 1 to re-increment after the final decrement above (so that output >= canon), |
| * and 1 to skip the first `/`. There might not be a first `/` if |
| * the @canon is a Windows `//server/share` style path with no |
| * trailing directories. @after_root will be '\0' in that case. */ |
| output++; |
| if (*output == G_DIR_SEPARATOR) |
| output++; |
| |
| /* POSIX allows double slashes at the start to mean something special |
| * (as does windows too). So, "//" != "/", but more than two slashes |
| * is treated as "/". |
| */ |
| if (after_root - output == 1) |
| output++; |
| |
| input = after_root; |
| output_start = output; |
| while (*input) |
| { |
| /* input points to the next non-separator to be processed. */ |
| /* output points to the next location to write to. */ |
| g_assert (input > canon && G_IS_DIR_SEPARATOR (input[-1])); |
| g_assert (output > canon && G_IS_DIR_SEPARATOR (output[-1])); |
| g_assert (input >= output); |
| |
| /* Ignore repeated dir separators. */ |
| while (G_IS_DIR_SEPARATOR (input[0])) |
| input++; |
| |
| /* Ignore single dot directory components. */ |
| if (input[0] == '.' && (input[1] == 0 || G_IS_DIR_SEPARATOR (input[1]))) |
| { |
| if (input[1] == 0) |
| break; |
| input += 2; |
| } |
| /* Remove double-dot directory components along with the preceding |
| * path component. */ |
| else if (input[0] == '.' && input[1] == '.' && |
| (input[2] == 0 || G_IS_DIR_SEPARATOR (input[2]))) |
| { |
| if (output > output_start) |
| { |
| do |
| { |
| output--; |
| } |
| while (!G_IS_DIR_SEPARATOR (output[-1]) && output > output_start); |
| } |
| if (input[2] == 0) |
| break; |
| input += 3; |
| } |
| /* Copy the input to the output until the next separator, |
| * while converting it to canonical separator */ |
| else |
| { |
| while (*input && !G_IS_DIR_SEPARATOR (*input)) |
| *output++ = *input++; |
| if (input[0] == 0) |
| break; |
| input++; |
| *output++ = G_DIR_SEPARATOR; |
| } |
| } |
| |
| /* Remove a potentially trailing dir separator */ |
| if (output > output_start && G_IS_DIR_SEPARATOR (output[-1])) |
| output--; |
| |
| *output = '\0'; |
| |
| return canon; |
| } |
| |
| #if defined(MAXPATHLEN) |
| #define G_PATH_LENGTH MAXPATHLEN |
| #elif defined(PATH_MAX) |
| #define G_PATH_LENGTH PATH_MAX |
| #elif defined(_PC_PATH_MAX) |
| #define G_PATH_LENGTH sysconf(_PC_PATH_MAX) |
| #else |
| #define G_PATH_LENGTH 2048 |
| #endif |
| |
| /** |
| * g_get_current_dir: |
| * |
| * Gets the current directory. |
| * |
| * The returned string should be freed when no longer needed. |
| * The encoding of the returned string is system defined. |
| * On Windows, it is always UTF-8. |
| * |
| * Since GLib 2.40, this function will return the value of the "PWD" |
| * environment variable if it is set and it happens to be the same as |
| * the current directory. This can make a difference in the case that |
| * the current directory is the target of a symbolic link. |
| * |
| * Returns: (type filename) (transfer full): the current directory |
| */ |
| gchar * |
| g_get_current_dir (void) |
| { |
| #ifdef G_OS_WIN32 |
| |
| gchar *dir = NULL; |
| wchar_t dummy[2], *wdir; |
| DWORD len; |
| |
| len = GetCurrentDirectoryW (2, dummy); |
| wdir = g_new (wchar_t, len); |
| |
| if (GetCurrentDirectoryW (len, wdir) == len - 1) |
| dir = g_utf16_to_utf8 (wdir, -1, NULL, NULL, NULL); |
| |
| g_free (wdir); |
| |
| if (dir == NULL) |
| dir = g_strdup ("\\"); |
| |
| return dir; |
| |
| #else |
| const gchar *pwd; |
| gchar *buffer = NULL; |
| gchar *dir = NULL; |
| static gsize buffer_size = 0; |
| struct stat pwdbuf, dotbuf; |
| |
| pwd = g_getenv ("PWD"); |
| if (pwd != NULL && |
| g_stat (".", &dotbuf) == 0 && g_stat (pwd, &pwdbuf) == 0 && |
| dotbuf.st_dev == pwdbuf.st_dev && dotbuf.st_ino == pwdbuf.st_ino) |
| return g_strdup (pwd); |
| |
| if (buffer_size == 0) |
| buffer_size = (G_PATH_LENGTH == -1) ? 2048 : G_PATH_LENGTH; |
| |
| while (buffer_size < G_MAXSIZE / 2) |
| { |
| g_free (buffer); |
| buffer = g_new (gchar, buffer_size); |
| *buffer = 0; |
| dir = getcwd (buffer, buffer_size); |
| |
| if (dir || errno != ERANGE) |
| break; |
| |
| buffer_size *= 2; |
| } |
| |
| /* Check that getcwd() nul-terminated the string. It should do, but the specs |
| * don’t actually explicitly state that: |
| * https://pubs.opengroup.org/onlinepubs/9699919799/functions/getcwd.html */ |
| g_assert (dir == NULL || strnlen (dir, buffer_size) < buffer_size); |
| |
| if (!dir || !*buffer) |
| { |
| /* Fallback return value */ |
| g_assert (buffer_size >= 2); |
| buffer[0] = G_DIR_SEPARATOR; |
| buffer[1] = 0; |
| } |
| |
| dir = g_strdup (buffer); |
| g_free (buffer); |
| |
| return dir; |
| |
| #endif /* !G_OS_WIN32 */ |
| } |
| |
| #ifdef G_OS_WIN32 |
| |
| /* Binary compatibility versions. Not for newly compiled code. */ |
| |
| _GLIB_EXTERN gboolean g_file_test_utf8 (const gchar *filename, |
| GFileTest test); |
| _GLIB_EXTERN gboolean g_file_get_contents_utf8 (const gchar *filename, |
| gchar **contents, |
| gsize *length, |
| GError **error); |
| _GLIB_EXTERN gint g_mkstemp_utf8 (gchar *tmpl); |
| _GLIB_EXTERN gint g_file_open_tmp_utf8 (const gchar *tmpl, |
| gchar **name_used, |
| GError **error); |
| _GLIB_EXTERN gchar *g_get_current_dir_utf8 (void); |
| |
| |
| gboolean |
| g_file_test_utf8 (const gchar *filename, |
| GFileTest test) |
| { |
| return g_file_test (filename, test); |
| } |
| |
| gboolean |
| g_file_get_contents_utf8 (const gchar *filename, |
| gchar **contents, |
| gsize *length, |
| GError **error) |
| { |
| return g_file_get_contents (filename, contents, length, error); |
| } |
| |
| gint |
| g_mkstemp_utf8 (gchar *tmpl) |
| { |
| return g_mkstemp (tmpl); |
| } |
| |
| gint |
| g_file_open_tmp_utf8 (const gchar *tmpl, |
| gchar **name_used, |
| GError **error) |
| { |
| return g_file_open_tmp (tmpl, name_used, error); |
| } |
| |
| gchar * |
| g_get_current_dir_utf8 (void) |
| { |
| return g_get_current_dir (); |
| } |
| |
| #endif |