/* GLIB - Library of useful routines for C programming
* Copyright (C) 1995-1998 Peter Mattis, Spencer Kimball and Josh MacDonald
*
+ * 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
#include <sys/stat.h>
#ifdef G_OS_UNIX
#include <pwd.h>
+#include <sys/utsname.h>
#include <unistd.h>
#endif
#include <sys/types.h>
#include "garray.h"
#include "glibintl.h"
#include "gstdio.h"
+#include "gquark.h"
#ifdef G_PLATFORM_WIN32
#include "gconvert.h"
#ifdef G_OS_WIN32
# include <direct.h>
# include <shlobj.h>
- /* older SDK (e.g. msvc 5.0) does not have these*/
-# ifndef CSIDL_MYMUSIC
-# define CSIDL_MYMUSIC 13
-# endif
-# ifndef CSIDL_MYVIDEO
-# define CSIDL_MYVIDEO 14
-# endif
-# ifndef CSIDL_INTERNET_CACHE
-# define CSIDL_INTERNET_CACHE 32
-# endif
-# ifndef CSIDL_COMMON_APPDATA
-# define CSIDL_COMMON_APPDATA 35
-# endif
-# ifndef CSIDL_MYPICTURES
-# define CSIDL_MYPICTURES 0x27
-# endif
-# ifndef CSIDL_COMMON_DOCUMENTS
-# define CSIDL_COMMON_DOCUMENTS 46
-# endif
-# ifndef CSIDL_PROFILE
-# define CSIDL_PROFILE 40
-# endif
# include <process.h>
#endif
-#ifdef HAVE_CARBON
-#include <CoreServices/CoreServices.h>
-#endif
-
#ifdef HAVE_CODESET
#include <langinfo.h>
#endif
-#ifdef G_PLATFORM_WIN32
-
-gchar *
-_glib_get_dll_directory (void)
-{
- gchar *retval;
- gchar *p;
- wchar_t wc_fn[MAX_PATH];
-
-#ifdef DLL_EXPORT
- if (glib_dll == NULL)
- return NULL;
-#endif
-
- /* This code is different from that in
- * g_win32_get_package_installation_directory_of_module() in that
- * here we return the actual folder where the GLib DLL is. We don't
- * do the check for it being in a "bin" or "lib" subfolder and then
- * returning the parent of that.
- *
- * In a statically built GLib, glib_dll will be NULL and we will
- * thus look up the application's .exe file's location.
- */
- if (!GetModuleFileNameW (glib_dll, wc_fn, MAX_PATH))
- return NULL;
-
- retval = g_utf16_to_utf8 (wc_fn, -1, NULL, NULL, NULL);
-
- p = strrchr (retval, G_DIR_SEPARATOR);
- if (p == NULL)
- {
- /* Wtf? */
- return NULL;
- }
- *p = '\0';
-
- return retval;
-}
-
-#endif
-
/**
* g_memmove:
* @dest: the destination address to copy the bytes to.
*
* Deprecated:2.32: It is best to avoid g_atexit().
*/
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS
void
g_atexit (GVoidFunc func)
{
g_strerror (errsv));
}
}
+G_GNUC_END_IGNORE_DEPRECATIONS
/* Based on execvp() from GNU Libc.
* Some of this code is cut-and-pasted into gspawn.c
* the program is found, the return value contains the full name
* including the type suffix.
*
- * Returns: (type filename): a newly-allocated string with the absolute path,
- * or %NULL
+ * Returns: (type filename) (transfer full) (nullable): a newly-allocated
+ * string with the absolute path, or %NULL
**/
#ifdef G_OS_WIN32
static gchar *
g_find_program_in_path (const gchar *program)
#endif
{
- const gchar *path, *p;
+ return g_find_program_for_path (program, NULL, NULL);
+}
+
+/**
+ * g_find_program_for_path:
+ * @program: (type filename): a program name in the GLib file name encoding
+ * @path: (type filename) (nullable): the current dir where to search program
+ * @working_dir: (type filename) (nullable): the working dir where to search
+ * program
+ *
+ * Locates the first executable named @program in @path, in the
+ * same way that execvp() would locate it. Returns an allocated string
+ * with the absolute path name (taking in account the @working_dir), or
+ * %NULL if the program is not found in @path. If @program is already an
+ * absolute path, returns a copy of @program if @program exists and is
+ * executable, and %NULL otherwise.
+ *
+ * On Windows, if @path is %NULL, it looks for the file in the same way as
+ * CreateProcess() would. This means first in the directory where the
+ * executing program was loaded from, then in the current directory, then in
+ * the Windows 32-bit system directory, then in the Windows directory, and
+ * finally in the directories in the `PATH` environment variable. If
+ * the program is found, the return value contains the full name
+ * including the type suffix.
+ *
+ * Returns: (type filename) (transfer full) (nullable): a newly-allocated
+ * string with the absolute path, or %NULL
+ * Since: 2.76
+ **/
+char *
+g_find_program_for_path (const char *program,
+ const char *path,
+ const char *working_dir)
+{
+ const char *original_path = path;
+ const char *original_program = program;
+ char *program_path = NULL;
+ const gchar *p;
gchar *name, *freeme;
#ifdef G_OS_WIN32
const gchar *path_copy;
g_return_val_if_fail (program != NULL, NULL);
+ /* Use the working dir as program path if provided */
+ if (working_dir && !g_path_is_absolute (program))
+ {
+ program_path = g_build_filename (working_dir, program, NULL);
+ program = program_path;
+ }
+
/* If it is an absolute path, or a relative path including subdirectories,
* don't look in PATH.
*/
if (g_path_is_absolute (program)
- || strchr (program, G_DIR_SEPARATOR) != NULL
+ || strchr (original_program, G_DIR_SEPARATOR) != NULL
#ifdef G_OS_WIN32
- || strchr (program, '/') != NULL
+ || strchr (original_program, '/') != NULL
#endif
)
{
if (g_file_test (program, G_FILE_TEST_IS_EXECUTABLE) &&
!g_file_test (program, G_FILE_TEST_IS_DIR))
- return g_strdup (program);
+ {
+ gchar *out = NULL;
+
+ if (g_path_is_absolute (program))
+ {
+ out = g_strdup (program);
+ }
+ else
+ {
+ char *cwd = g_get_current_dir ();
+ out = g_build_filename (cwd, program, NULL);
+ g_free (cwd);
+ }
+
+ g_free (program_path);
+
+ return g_steal_pointer (&out);
+ }
else
- return NULL;
+ {
+ g_clear_pointer (&program_path, g_free);
+
+ if (g_path_is_absolute (original_program))
+ return NULL;
+ }
}
-
- path = g_getenv ("PATH");
+
+ program = original_program;
+
+ if G_LIKELY (original_path == NULL)
+ path = g_getenv ("PATH");
+ else
+ path = original_path;
+
#if defined(G_OS_UNIX)
if (path == NULL)
{
path = "/bin:/usr/bin:.";
}
#else
- n = GetModuleFileNameW (NULL, wfilename, MAXPATHLEN);
- if (n > 0 && n < MAXPATHLEN)
- filename = g_utf16_to_utf8 (wfilename, -1, NULL, NULL, NULL);
-
- n = GetSystemDirectoryW (wsysdir, MAXPATHLEN);
- if (n > 0 && n < MAXPATHLEN)
- sysdir = g_utf16_to_utf8 (wsysdir, -1, NULL, NULL, NULL);
-
- n = GetWindowsDirectoryW (wwindir, MAXPATHLEN);
- if (n > 0 && n < MAXPATHLEN)
- windir = g_utf16_to_utf8 (wwindir, -1, NULL, NULL, NULL);
-
- if (filename)
+ if G_LIKELY (original_path == NULL)
{
- appdir = g_path_get_dirname (filename);
- g_free (filename);
- }
-
- path = g_strdup (path);
+ n = GetModuleFileNameW (NULL, wfilename, MAXPATHLEN);
+ if (n > 0 && n < MAXPATHLEN)
+ filename = g_utf16_to_utf8 (wfilename, -1, NULL, NULL, NULL);
- if (windir)
- {
- const gchar *tem = path;
- path = g_strconcat (windir, ";", path, NULL);
- g_free ((gchar *) tem);
- g_free (windir);
- }
-
- if (sysdir)
- {
- const gchar *tem = path;
- path = g_strconcat (sysdir, ";", path, NULL);
- g_free ((gchar *) tem);
- g_free (sysdir);
+ n = GetSystemDirectoryW (wsysdir, MAXPATHLEN);
+ if (n > 0 && n < MAXPATHLEN)
+ sysdir = g_utf16_to_utf8 (wsysdir, -1, NULL, NULL, NULL);
+
+ n = GetWindowsDirectoryW (wwindir, MAXPATHLEN);
+ if (n > 0 && n < MAXPATHLEN)
+ windir = g_utf16_to_utf8 (wwindir, -1, NULL, NULL, NULL);
+
+ if (filename)
+ {
+ appdir = g_path_get_dirname (filename);
+ g_free (filename);
+ }
+
+ path = g_strdup (path);
+
+ if (windir)
+ {
+ const gchar *tem = path;
+ path = g_strconcat (windir, ";", path, NULL);
+ g_free ((gchar *) tem);
+ g_free (windir);
+ }
+
+ if (sysdir)
+ {
+ const gchar *tem = path;
+ path = g_strconcat (sysdir, ";", path, NULL);
+ g_free ((gchar *) tem);
+ g_free (sysdir);
+ }
+
+ {
+ const gchar *tem = path;
+ path = g_strconcat (".;", path, NULL);
+ g_free ((gchar *) tem);
+ }
+
+ if (appdir)
+ {
+ const gchar *tem = path;
+ path = g_strconcat (appdir, ";", path, NULL);
+ g_free ((gchar *) tem);
+ g_free (appdir);
+ }
+
+ path_copy = path;
}
-
- {
- const gchar *tem = path;
- path = g_strconcat (".;", path, NULL);
- g_free ((gchar *) tem);
- }
-
- if (appdir)
+ else
{
- const gchar *tem = path;
- path = g_strconcat (appdir, ";", path, NULL);
- g_free ((gchar *) tem);
- g_free (appdir);
+ path_copy = g_strdup (path);
}
- path_copy = path;
#endif
len = strlen (program) + 1;
do
{
char *startp;
+ char *startp_path = NULL;
path = p;
p = my_strchrnul (path, G_SEARCHPATH_SEPARATOR);
else
startp = memcpy (name - (p - path), path, p - path);
+ /* Use the working dir as program path if provided */
+ if (working_dir && !g_path_is_absolute (startp))
+ {
+ startp_path = g_build_filename (working_dir, startp, NULL);
+ startp = startp_path;
+ }
+
if (g_file_test (startp, G_FILE_TEST_IS_EXECUTABLE) &&
!g_file_test (startp, G_FILE_TEST_IS_DIR))
{
gchar *ret;
- ret = g_strdup (startp);
+ if (g_path_is_absolute (startp)) {
+ ret = g_strdup (startp);
+ } else {
+ gchar *cwd = NULL;
+ cwd = g_get_current_dir ();
+ ret = g_build_filename (cwd, startp, NULL);
+ g_free (cwd);
+ }
+
+ g_free (program_path);
+ g_free (startp_path);
g_free (freeme);
#ifdef G_OS_WIN32
g_free ((gchar *) path_copy);
#endif
return ret;
}
+
+ g_free (startp_path);
}
while (*p++ != '\0');
-
+
+ g_free (program_path);
g_free (freeme);
#ifdef G_OS_WIN32
g_free ((gchar *) path_copy);
static gchar **g_system_data_dirs = NULL;
static gchar *g_user_cache_dir = NULL;
static gchar *g_user_config_dir = NULL;
+static gchar *g_user_state_dir = NULL;
static gchar *g_user_runtime_dir = NULL;
static gchar **g_system_config_dirs = NULL;
static gchar **g_user_special_dirs = NULL;
+static gchar *g_tmp_dir = NULL;
/* fifteen minutes of fame for everybody */
#define G_USER_DIRS_EXPIRE 15 * 60
#ifdef G_OS_WIN32
static gchar *
-get_special_folder (int csidl)
+get_special_folder (REFKNOWNFOLDERID known_folder_guid_ptr)
{
- wchar_t path[MAX_PATH+1];
+ wchar_t *wcp = NULL;
+ gchar *result = NULL;
HRESULT hr;
- LPITEMIDLIST pidl = NULL;
- BOOL b;
- gchar *retval = NULL;
- hr = SHGetSpecialFolderLocation (NULL, csidl, &pidl);
- if (hr == S_OK)
- {
- b = SHGetPathFromIDListW (pidl, path);
- if (b)
- retval = g_utf16_to_utf8 (path, -1, NULL, NULL, NULL);
- CoTaskMemFree (pidl);
- }
- return retval;
+ hr = SHGetKnownFolderPath (known_folder_guid_ptr, 0, NULL, &wcp);
+
+ if (SUCCEEDED (hr))
+ result = g_utf16_to_utf8 (wcp, -1, NULL, NULL, NULL);
+
+ CoTaskMemFree (wcp);
+
+ return result;
}
static char *
e.user_name = g_strdup (pw->pw_name);
#ifndef __BIONIC__
- if (pw->pw_gecos && *pw->pw_gecos != '\0')
+ if (pw->pw_gecos && *pw->pw_gecos != '\0' && pw->pw_name)
{
gchar **gecos_fields;
gchar **name_parts;
+ gchar *uppercase_pw_name;
/* split the gecos field and substitute '&' */
gecos_fields = g_strsplit (pw->pw_gecos, ",", 0);
name_parts = g_strsplit (gecos_fields[0], "&", 0);
- pw->pw_name[0] = g_ascii_toupper (pw->pw_name[0]);
- e.real_name = g_strjoinv (pw->pw_name, name_parts);
+ uppercase_pw_name = g_strdup (pw->pw_name);
+ uppercase_pw_name[0] = g_ascii_toupper (uppercase_pw_name[0]);
+ e.real_name = g_strjoinv (uppercase_pw_name, name_parts);
g_strfreev (gecos_fields);
g_strfreev (name_parts);
+ g_free (uppercase_pw_name);
}
#endif
* encoding, or something else, and there is no guarantee that it is even
* consistent on a machine. On Windows, it is always UTF-8.
*
- * Returns: (type filename): the user name of the current user.
+ * Returns: (type filename) (transfer none): the user name of the current user.
*/
const gchar *
g_get_user_name (void)
* real user name cannot be determined, the string "Unknown" is
* returned.
*
- * Returns: (type filename): the user's real name.
+ * Returns: (type filename) (transfer none): the user's real name.
*/
const gchar *
g_get_real_name (void)
}
if (home_dir == NULL)
- home_dir = get_special_folder (CSIDL_PROFILE);
+ home_dir = get_special_folder (&FOLDERID_Profile);
if (home_dir == NULL)
home_dir = get_windows_directory_root ();
* should either directly check the `HOME` environment variable yourself
* or unset it before calling any functions in GLib.
*
- * Returns: (type filename): the current user's home directory
+ * Returns: (type filename) (transfer none): the current user's home directory
*/
const gchar *
g_get_home_dir (void)
return home_dir;
}
+void
+_g_unset_cached_tmp_dir (void)
+{
+ G_LOCK (g_utils_global);
+ /* We have to leak the old value, as user code could be retaining pointers
+ * to it. */
+ g_ignore_leak (g_tmp_dir);
+ g_tmp_dir = NULL;
+ G_UNLOCK (g_utils_global);
+}
+
/**
* g_get_tmp_dir:
*
* it is always UTF-8. The return value is never %NULL or the empty
* string.
*
- * Returns: (type filename): the directory to use for temporary files.
+ * Returns: (type filename) (transfer none): the directory to use for temporary files.
*/
const gchar *
g_get_tmp_dir (void)
{
- static gchar *tmp_dir;
+ G_LOCK (g_utils_global);
- if (g_once_init_enter (&tmp_dir))
+ if (g_tmp_dir == NULL)
{
gchar *tmp;
+ tmp = g_strdup (g_getenv ("G_TEST_TMPDIR"));
+
+ if (tmp == NULL || *tmp == '\0')
+ {
+ g_free (tmp);
+ tmp = g_strdup (g_getenv (
#ifdef G_OS_WIN32
- tmp = g_strdup (g_getenv ("TEMP"));
+ "TEMP"
+#else /* G_OS_WIN32 */
+ "TMPDIR"
+#endif /* G_OS_WIN32 */
+ ));
+ }
+#ifdef G_OS_WIN32
if (tmp == NULL || *tmp == '\0')
{
g_free (tmp);
tmp = get_windows_directory_root ();
}
#else /* G_OS_WIN32 */
- tmp = g_strdup (g_getenv ("TMPDIR"));
#ifdef P_tmpdir
if (tmp == NULL || *tmp == '\0')
}
#endif /* !G_OS_WIN32 */
- g_once_init_leave (&tmp_dir, tmp);
+ g_tmp_dir = g_steal_pointer (&tmp);
}
- return tmp_dir;
+ G_UNLOCK (g_utils_global);
+
+ return g_tmp_dir;
}
/**
*
* The encoding of the returned string is UTF-8.
*
- * Returns: the host name of the machine.
+ * Returns: (transfer none): the host name of the machine.
*
* Since: 2.8
*/
if (g_once_init_enter (&hostname))
{
gboolean failed;
- gchar *utmp;
+ gchar *utmp = NULL;
#ifndef G_OS_WIN32
- gchar *tmp = g_malloc (sizeof (gchar) * 100);
- failed = (gethostname (tmp, sizeof (gchar) * 100) == -1);
+ gsize size;
+ /* The number 256 * 256 is taken from the value of _POSIX_HOST_NAME_MAX,
+ * which is 255. Since we use _POSIX_HOST_NAME_MAX + 1 (= 256) in the
+ * fallback case, we pick 256 * 256 as the size of the larger buffer here.
+ * It should be large enough. It doesn't looks reasonable to name a host
+ * with a string that is longer than 64 KiB.
+ */
+ const gsize size_large = (gsize) 256 * 256;
+ gchar *tmp;
+
+#ifdef _SC_HOST_NAME_MAX
+ {
+ glong max;
+
+ max = sysconf (_SC_HOST_NAME_MAX);
+ if (max > 0 && (gsize) max <= G_MAXSIZE - 1)
+ size = (gsize) max + 1;
+ else
+#ifdef HOST_NAME_MAX
+ size = HOST_NAME_MAX + 1;
+#else
+ size = _POSIX_HOST_NAME_MAX + 1;
+#endif /* HOST_NAME_MAX */
+ }
+#else
+ /* Fallback to some reasonable value */
+ size = 256;
+#endif /* _SC_HOST_NAME_MAX */
+ tmp = g_malloc (size);
+ failed = (gethostname (tmp, size) == -1);
+ if (failed && size < size_large)
+ {
+ /* Try again with a larger buffer if 'size' may be too small. */
+ g_free (tmp);
+ tmp = g_malloc (size_large);
+ failed = (gethostname (tmp, size_large) == -1);
+ }
+
if (failed)
g_clear_pointer (&tmp, g_free);
utmp = tmp;
}
G_LOCK_DEFINE_STATIC (g_prgname);
-static gchar *g_prgname = NULL;
+static const gchar *g_prgname = NULL; /* always a quark */
/**
* g_get_prgname:
* in contrast to g_get_application_name().
*
* If you are using #GApplication the program name is set in
- * g_application_run(). In case of GDK or GTK+ it is set in
+ * g_application_run(). In case of GDK or GTK it is set in
* gdk_init(), which is called by gtk_init() and the
* #GtkApplication::startup handler. The program name is found by
* taking the last component of @argv[0].
*
- * Returns: the name of the program. The returned string belongs
- * to GLib and must not be modified or freed.
+ * Returns: (nullable) (transfer none): the name of the program,
+ * or %NULL if it has not been set yet. The returned string belongs
+ * to GLib and must not be modified or freed.
*/
const gchar*
g_get_prgname (void)
{
- gchar* retval;
+ const gchar* retval;
G_LOCK (g_prgname);
-#ifdef G_OS_WIN32
- if (g_prgname == NULL)
- {
- static gboolean beenhere = FALSE;
-
- if (!beenhere)
- {
- gchar *utf8_buf = NULL;
- wchar_t buf[MAX_PATH+1];
-
- beenhere = TRUE;
- if (GetModuleFileNameW (GetModuleHandle (NULL),
- buf, G_N_ELEMENTS (buf)) > 0)
- utf8_buf = g_utf16_to_utf8 (buf, -1, NULL, NULL, NULL);
-
- if (utf8_buf)
- {
- g_prgname = g_path_get_basename (utf8_buf);
- g_free (utf8_buf);
- }
- }
- }
-#endif
retval = g_prgname;
G_UNLOCK (g_prgname);
* in contrast to g_set_application_name().
*
* If you are using #GApplication the program name is set in
- * g_application_run(). In case of GDK or GTK+ it is set in
+ * g_application_run(). In case of GDK or GTK it is set in
* gdk_init(), which is called by gtk_init() and the
* #GtkApplication::startup handler. The program name is found by
* taking the last component of @argv[0].
*
- * Note that for thread-safety reasons this function can only be called once.
+ * Since GLib 2.72, this function can be called multiple times
+ * and is fully thread safe. Prior to GLib 2.72, this function
+ * could only be called once per process.
*/
void
g_set_prgname (const gchar *prgname)
{
+ GQuark qprgname = g_quark_from_string (prgname);
G_LOCK (g_prgname);
- g_free (g_prgname);
- g_prgname = g_strdup (prgname);
+ g_prgname = g_quark_to_string (qprgname);
G_UNLOCK (g_prgname);
}
* g_get_prgname() (which may be %NULL if g_set_prgname() has also not
* been called).
*
- * Returns: human-readable application name. may return %NULL
+ * Returns: (transfer none) (nullable): human-readable application
+ * name. May return %NULL
*
* Since: 2.2
**/
g_warning ("g_set_application_name() called multiple times");
}
+#ifdef G_OS_WIN32
+/* For the past versions we can just
+ * hardcode all the names.
+ */
+static const struct winver
+{
+ gint major;
+ gint minor;
+ gint sp;
+ const char *version;
+ const char *spversion;
+} versions[] =
+{
+ {6, 2, 0, "8", ""},
+ {6, 1, 1, "7", " SP1"},
+ {6, 1, 0, "7", ""},
+ {6, 0, 2, "Vista", " SP2"},
+ {6, 0, 1, "Vista", " SP1"},
+ {6, 0, 0, "Vista", ""},
+ {5, 1, 3, "XP", " SP3"},
+ {5, 1, 2, "XP", " SP2"},
+ {5, 1, 1, "XP", " SP1"},
+ {5, 1, 0, "XP", ""},
+ {0, 0, 0, NULL, NULL},
+};
+
+static gchar *
+get_registry_str (HKEY root_key, const wchar_t *path, const wchar_t *value_name)
+{
+ HKEY key_handle;
+ DWORD req_value_data_size;
+ DWORD req_value_data_size2;
+ LONG status;
+ DWORD value_type_w;
+ DWORD value_type_w2;
+ char *req_value_data;
+ gchar *result;
+
+ status = RegOpenKeyExW (root_key, path, 0, KEY_READ, &key_handle);
+ if (status != ERROR_SUCCESS)
+ return NULL;
+
+ req_value_data_size = 0;
+ status = RegQueryValueExW (key_handle,
+ value_name,
+ NULL,
+ &value_type_w,
+ NULL,
+ &req_value_data_size);
+
+ if (status != ERROR_MORE_DATA && status != ERROR_SUCCESS)
+ {
+ RegCloseKey (key_handle);
+
+ return NULL;
+ }
+
+ req_value_data = g_malloc (req_value_data_size);
+ req_value_data_size2 = req_value_data_size;
+
+ status = RegQueryValueExW (key_handle,
+ value_name,
+ NULL,
+ &value_type_w2,
+ (gpointer) req_value_data,
+ &req_value_data_size2);
+
+ result = NULL;
+
+ if (status == ERROR_SUCCESS && value_type_w2 == REG_SZ)
+ result = g_utf16_to_utf8 ((gunichar2 *) req_value_data,
+ req_value_data_size / sizeof (gunichar2),
+ NULL,
+ NULL,
+ NULL);
+
+ g_free (req_value_data);
+ RegCloseKey (key_handle);
+
+ return result;
+}
+
+/* Windows 8.1 can be either plain or with Update 1,
+ * depending on its build number (9200 or 9600).
+ */
+static gchar *
+get_windows_8_1_update (void)
+{
+ gchar *current_build;
+ gchar *result = NULL;
+
+ current_build = get_registry_str (HKEY_LOCAL_MACHINE,
+ L"SOFTWARE"
+ L"\\Microsoft"
+ L"\\Windows NT"
+ L"\\CurrentVersion",
+ L"CurrentBuild");
+
+ if (current_build != NULL)
+ {
+ wchar_t *end;
+ long build = wcstol ((const wchar_t *) current_build, &end, 10);
+
+ if (build <= INT_MAX &&
+ build >= INT_MIN &&
+ errno == 0 &&
+ *end == L'\0')
+ {
+ if (build >= 9600)
+ result = g_strdup ("Update 1");
+ }
+ }
+
+ g_clear_pointer (¤t_build, g_free);
+
+ return result;
+}
+
+static gchar *
+get_windows_version (gboolean with_windows)
+{
+ GString *version = g_string_new (NULL);
+ gboolean is_win_server = FALSE;
+
+ if (g_win32_check_windows_version (10, 0, 0, G_WIN32_OS_ANY))
+ {
+ gchar *win10_release;
+ gboolean is_win11 = FALSE;
+ OSVERSIONINFOEXW osinfo;
+
+ /* Are we on Windows 2016/2019/2022 Server? */
+ is_win_server = g_win32_check_windows_version (10, 0, 0, G_WIN32_OS_SERVER);
+
+ /*
+ * This always succeeds if we get here, since the
+ * g_win32_check_windows_version() already did this!
+ * We want the OSVERSIONINFOEXW here for more even
+ * fine-grained versioning items
+ */
+ _g_win32_call_rtl_version (&osinfo);
+
+ if (!is_win_server)
+ {
+ /*
+ * Windows 11 is actually Windows 10.0.22000+,
+ * so look at the build number
+ */
+ is_win11 = (osinfo.dwBuildNumber >= 22000);
+ }
+ else
+ {
+ /*
+ * Windows 2022 Server is actually Windows 10.0.20348+,
+ * Windows 2019 Server is actually Windows 10.0.17763+,
+ * Windows 2016 Server is actually Windows 10.0.14393+,
+ * so look at the build number
+ */
+ g_string_append (version, "Server");
+ if (osinfo.dwBuildNumber >= 20348)
+ g_string_append (version, " 2022");
+ else if (osinfo.dwBuildNumber >= 17763)
+ g_string_append (version, " 2019");
+ else
+ g_string_append (version, " 2016");
+ }
+
+ if (is_win11)
+ g_string_append (version, "11");
+ else if (!is_win_server)
+ g_string_append (version, "10");
+
+ /* Windows 10/Server 2016+ is identified by its ReleaseId or
+ * DisplayVersion (since 20H2), such as
+ * 1511, 1607, 1703, 1709, 1803, 1809 or 1903 etc.
+ * The first version of Windows 10 has no release number.
+ */
+ win10_release = get_registry_str (HKEY_LOCAL_MACHINE,
+ L"SOFTWARE"
+ L"\\Microsoft"
+ L"\\Windows NT"
+ L"\\CurrentVersion",
+ L"ReleaseId");
+
+ if (win10_release != NULL)
+ {
+ if (g_strcmp0 (win10_release, "2009") != 0)
+ g_string_append_printf (version, " %s", win10_release);
+ else
+ {
+ g_free (win10_release);
+
+ win10_release = get_registry_str (HKEY_LOCAL_MACHINE,
+ L"SOFTWARE"
+ L"\\Microsoft"
+ L"\\Windows NT"
+ L"\\CurrentVersion",
+ L"DisplayVersion");
+
+ if (win10_release != NULL)
+ g_string_append_printf (version, " %s", win10_release);
+ else
+ g_string_append_printf (version, " 2009");
+ }
+ }
+
+ g_free (win10_release);
+ }
+ else if (g_win32_check_windows_version (6, 3, 0, G_WIN32_OS_ANY))
+ {
+ gchar *win81_update;
+
+ if (g_win32_check_windows_version (6, 3, 0, G_WIN32_OS_WORKSTATION))
+ g_string_append (version, "8.1");
+ else
+ g_string_append (version, "Server 2012 R2");
+
+ win81_update = get_windows_8_1_update ();
+
+ if (win81_update != NULL)
+ g_string_append_printf (version, " %s", win81_update);
+
+ g_free (win81_update);
+ }
+ else
+ {
+ gint i;
+
+ for (i = 0; versions[i].major > 0; i++)
+ {
+ if (!g_win32_check_windows_version (versions[i].major, versions[i].minor, versions[i].sp, G_WIN32_OS_ANY))
+ continue;
+
+ g_string_append (version, versions[i].version);
+
+ if (g_win32_check_windows_version (versions[i].major, versions[i].minor, versions[i].sp, G_WIN32_OS_SERVER))
+ {
+ /*
+ * This condition should now always hold, since Windows
+ * 7+/Server 2008 R2+ is now required
+ */
+ if (versions[i].major == 6)
+ {
+ g_string_append (version, "Server");
+ if (versions[i].minor == 2)
+ g_string_append (version, " 2012");
+ else if (versions[i].minor == 1)
+ g_string_append (version, " 2008 R2");
+ else
+ g_string_append (version, " 2008");
+ }
+ }
+
+ g_string_append (version, versions[i].spversion);
+ }
+ }
+
+ if (version->len == 0)
+ {
+ g_string_free (version, TRUE);
+
+ return NULL;
+ }
+
+ if (with_windows)
+ g_string_prepend (version, "Windows ");
+
+ return g_string_free (version, FALSE);
+}
+#endif
+
+#if defined (G_OS_UNIX) && !defined (__APPLE__)
+static gchar *
+get_os_info_from_os_release (const gchar *key_name,
+ const gchar *buffer)
+{
+ GStrv lines;
+ gchar *prefix;
+ size_t i;
+ gchar *result = NULL;
+
+ lines = g_strsplit (buffer, "\n", -1);
+ prefix = g_strdup_printf ("%s=", key_name);
+ for (i = 0; lines[i] != NULL; i++)
+ {
+ const gchar *line = lines[i];
+ const gchar *value;
+
+ if (g_str_has_prefix (line, prefix))
+ {
+ value = line + strlen (prefix);
+ result = g_shell_unquote (value, NULL);
+ if (result == NULL)
+ result = g_strdup (value);
+ break;
+ }
+ }
+ g_strfreev (lines);
+ g_free (prefix);
+
+#ifdef __linux__
+ /* Default values in spec */
+ if (result == NULL)
+ {
+ if (g_str_equal (key_name, G_OS_INFO_KEY_NAME))
+ return g_strdup ("Linux");
+ if (g_str_equal (key_name, G_OS_INFO_KEY_ID))
+ return g_strdup ("linux");
+ if (g_str_equal (key_name, G_OS_INFO_KEY_PRETTY_NAME))
+ return g_strdup ("Linux");
+ }
+#endif
+
+ return g_steal_pointer (&result);
+}
+
+static gchar *
+get_os_info_from_uname (const gchar *key_name)
+{
+ struct utsname info;
+
+ if (uname (&info) == -1)
+ return NULL;
+
+ if (strcmp (key_name, G_OS_INFO_KEY_NAME) == 0)
+ return g_strdup (info.sysname);
+ else if (strcmp (key_name, G_OS_INFO_KEY_VERSION) == 0)
+ return g_strdup (info.release);
+ else if (strcmp (key_name, G_OS_INFO_KEY_PRETTY_NAME) == 0)
+ return g_strdup_printf ("%s %s", info.sysname, info.release);
+ else if (strcmp (key_name, G_OS_INFO_KEY_ID) == 0)
+ {
+ gchar *result = g_ascii_strdown (info.sysname, -1);
+
+ g_strcanon (result, "abcdefghijklmnopqrstuvwxyz0123456789_-.", '_');
+ return g_steal_pointer (&result);
+ }
+ else if (strcmp (key_name, G_OS_INFO_KEY_VERSION_ID) == 0)
+ {
+ /* We attempt to convert the version string to the format returned by
+ * config.guess, which is the script used to generate target triplets
+ * in GNU autotools. There are a lot of rules in the script. We only
+ * implement a few rules which are easy to understand here.
+ *
+ * config.guess can be found at https://savannah.gnu.org/projects/config.
+ */
+ gchar *result;
+
+ if (strcmp (info.sysname, "NetBSD") == 0)
+ {
+ /* sed -e 's,[-_].*,,' */
+ gssize len = G_MAXSSIZE;
+ const gchar *c;
+
+ if ((c = strchr (info.release, '-')) != NULL)
+ len = MIN (len, c - info.release);
+ if ((c = strchr (info.release, '_')) != NULL)
+ len = MIN (len, c - info.release);
+ if (len == G_MAXSSIZE)
+ len = -1;
+
+ result = g_ascii_strdown (info.release, len);
+ }
+ else if (strcmp (info.sysname, "GNU") == 0)
+ {
+ /* sed -e 's,/.*$,,' */
+ gssize len = -1;
+ const gchar *c = strchr (info.release, '/');
+
+ if (c != NULL)
+ len = c - info.release;
+
+ result = g_ascii_strdown (info.release, len);
+ }
+ else if (g_str_has_prefix (info.sysname, "GNU/") ||
+ strcmp (info.sysname, "FreeBSD") == 0 ||
+ strcmp (info.sysname, "DragonFly") == 0)
+ {
+ /* sed -e 's,[-(].*,,' */
+ gssize len = G_MAXSSIZE;
+ const gchar *c;
+
+ if ((c = strchr (info.release, '-')) != NULL)
+ len = MIN (len, c - info.release);
+ if ((c = strchr (info.release, '(')) != NULL)
+ len = MIN (len, c - info.release);
+ if (len == G_MAXSSIZE)
+ len = -1;
+
+ result = g_ascii_strdown (info.release, len);
+ }
+ else
+ result = g_ascii_strdown (info.release, -1);
+
+ g_strcanon (result, "abcdefghijklmnopqrstuvwxyz0123456789_-.", '_');
+ return g_steal_pointer (&result);
+ }
+ else
+ return NULL;
+}
+#endif /* defined (G_OS_UNIX) && !defined (__APPLE__) */
+
+/**
+ * g_get_os_info:
+ * @key_name: a key for the OS info being requested, for example %G_OS_INFO_KEY_NAME.
+ *
+ * Get information about the operating system.
+ *
+ * On Linux this comes from the `/etc/os-release` file. On other systems, it may
+ * come from a variety of sources. You can either use the standard key names
+ * like %G_OS_INFO_KEY_NAME or pass any UTF-8 string key name. For example,
+ * `/etc/os-release` provides a number of other less commonly used values that may
+ * be useful. No key is guaranteed to be provided, so the caller should always
+ * check if the result is %NULL.
+ *
+ * Returns: (nullable): The associated value for the requested key or %NULL if
+ * this information is not provided.
+ *
+ * Since: 2.64
+ **/
+gchar *
+g_get_os_info (const gchar *key_name)
+{
+#if defined (__APPLE__)
+ if (g_strcmp0 (key_name, G_OS_INFO_KEY_NAME) == 0)
+ return g_strdup ("macOS");
+ else
+ return NULL;
+#elif defined (G_OS_UNIX)
+ const gchar * const os_release_files[] = { "/etc/os-release", "/usr/lib/os-release" };
+ gsize i;
+ gchar *buffer = NULL;
+ gchar *result = NULL;
+
+ g_return_val_if_fail (key_name != NULL, NULL);
+
+ for (i = 0; i < G_N_ELEMENTS (os_release_files); i++)
+ {
+ GError *error = NULL;
+ gboolean file_missing;
+
+ if (g_file_get_contents (os_release_files[i], &buffer, NULL, &error))
+ break;
+
+ file_missing = g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT);
+ g_clear_error (&error);
+
+ if (!file_missing)
+ return NULL;
+ }
+
+ if (buffer != NULL)
+ result = get_os_info_from_os_release (key_name, buffer);
+ else
+ result = get_os_info_from_uname (key_name);
+
+ g_free (buffer);
+ return g_steal_pointer (&result);
+#elif defined (G_OS_WIN32)
+ if (g_strcmp0 (key_name, G_OS_INFO_KEY_NAME) == 0)
+ return g_strdup ("Windows");
+ else if (g_strcmp0 (key_name, G_OS_INFO_KEY_ID) == 0)
+ return g_strdup ("windows");
+ else if (g_strcmp0 (key_name, G_OS_INFO_KEY_PRETTY_NAME) == 0)
+ /* Windows XP SP2 or Windows 10 1903 or Windows 7 Server SP1 */
+ return get_windows_version (TRUE);
+ else if (g_strcmp0 (key_name, G_OS_INFO_KEY_VERSION) == 0)
+ /* XP SP2 or 10 1903 or 7 Server SP1 */
+ return get_windows_version (FALSE);
+ else if (g_strcmp0 (key_name, G_OS_INFO_KEY_VERSION_ID) == 0)
+ {
+ /* xp_sp2 or 10_1903 or 7_server_sp1 */
+ gchar *result;
+ gchar *version = get_windows_version (FALSE);
+
+ if (version == NULL)
+ return NULL;
+
+ result = g_ascii_strdown (version, -1);
+ g_free (version);
+
+ return g_strcanon (result, "abcdefghijklmnopqrstuvwxyz0123456789_-.", '_');
+ }
+ else if (g_strcmp0 (key_name, G_OS_INFO_KEY_HOME_URL) == 0)
+ return g_strdup ("https://microsoft.com/windows/");
+ else if (g_strcmp0 (key_name, G_OS_INFO_KEY_DOCUMENTATION_URL) == 0)
+ return g_strdup ("https://docs.microsoft.com/");
+ else if (g_strcmp0 (key_name, G_OS_INFO_KEY_SUPPORT_URL) == 0)
+ return g_strdup ("https://support.microsoft.com/");
+ else if (g_strcmp0 (key_name, G_OS_INFO_KEY_BUG_REPORT_URL) == 0)
+ return g_strdup ("https://support.microsoft.com/contactus/");
+ else if (g_strcmp0 (key_name, G_OS_INFO_KEY_PRIVACY_POLICY_URL) == 0)
+ return g_strdup ("https://privacy.microsoft.com/");
+ else
+ return NULL;
+#endif
+}
+
/* Set @global_str to a copy of @new_value if it’s currently unset or has a
* different value. If its current value matches @new_value, do nothing. If
* replaced, we have to leak the old value as client code could still have
/* We have to leak the old value, as user code could be retaining pointers
* to it. */
+ g_ignore_leak (*global_str);
*global_str = g_strdup (new_value);
}
}
/* We have to leak the old value, as user code could be retaining pointers
* to it. */
+ g_ignore_strv_leak (*global_strv);
*global_strv = g_strdupv ((gchar **) new_value);
}
}
set_strv_if_different (&g_system_data_dirs, dir_type, dir_value);
else if (g_str_equal (dir_type, "XDG_DATA_HOME"))
set_str_if_different (&g_user_data_dir, dir_type, dir_value);
+ else if (g_str_equal (dir_type, "XDG_STATE_HOME"))
+ set_str_if_different (&g_user_state_dir, dir_type, dir_value);
else if (g_str_equal (dir_type, "XDG_RUNTIME_DIR"))
set_str_if_different (&g_user_runtime_dir, dir_type, dir_value);
else
data_dir = g_strdup (data_dir_env);
#ifdef G_OS_WIN32
else
- data_dir = get_special_folder (CSIDL_LOCAL_APPDATA);
+ data_dir = get_special_folder (&FOLDERID_LocalAppData);
#endif
if (!data_dir || !data_dir[0])
{
* On Windows it follows XDG Base Directory Specification if `XDG_DATA_HOME`
* is defined. If `XDG_DATA_HOME` is undefined, the folder to use for local (as
* opposed to roaming) application data is used instead. See the
- * [documentation for `CSIDL_LOCAL_APPDATA`](https://msdn.microsoft.com/en-us/library/windows/desktop/bb762494%28v=vs.85%29.aspx#csidl_local_appdata).
+ * [documentation for `FOLDERID_LocalAppData`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
* Note that in this case on Windows it will be the same
* as what g_get_user_config_dir() returns.
*
- * Returns: (type filename): a string owned by GLib that must not be modified
- * or freed.
+ * The return value is cached and modifying it at runtime is not supported, as
+ * it’s not thread-safe to modify environment variables at runtime.
+ *
+ * Returns: (type filename) (transfer none): a string owned by GLib that must
+ * not be modified or freed.
+ *
* Since: 2.6
**/
const gchar *
config_dir = g_strdup (config_dir_env);
#ifdef G_OS_WIN32
else
- config_dir = get_special_folder (CSIDL_LOCAL_APPDATA);
+ config_dir = get_special_folder (&FOLDERID_LocalAppData);
#endif
if (!config_dir || !config_dir[0])
{
* On Windows it follows XDG Base Directory Specification if `XDG_CONFIG_HOME` is defined.
* If `XDG_CONFIG_HOME` is undefined, the folder to use for local (as opposed
* to roaming) application data is used instead. See the
- * [documentation for `CSIDL_LOCAL_APPDATA`](https://msdn.microsoft.com/en-us/library/windows/desktop/bb762494%28v=vs.85%29.aspx#csidl_local_appdata).
+ * [documentation for `FOLDERID_LocalAppData`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
* Note that in this case on Windows it will be the same
* as what g_get_user_data_dir() returns.
*
- * Returns: (type filename): a string owned by GLib that must not be modified
- * or freed.
+ * The return value is cached and modifying it at runtime is not supported, as
+ * it’s not thread-safe to modify environment variables at runtime.
+ *
+ * Returns: (type filename) (transfer none): a string owned by GLib that
+ * must not be modified or freed.
* Since: 2.6
**/
const gchar *
cache_dir = g_strdup (cache_dir_env);
#ifdef G_OS_WIN32
else
- cache_dir = get_special_folder (CSIDL_INTERNET_CACHE);
+ cache_dir = get_special_folder (&FOLDERID_InternetCache);
#endif
if (!cache_dir || !cache_dir[0])
{
* If `XDG_CACHE_HOME` is undefined, the directory that serves as a common
* repository for temporary Internet files is used instead. A typical path is
* `C:\Documents and Settings\username\Local Settings\Temporary Internet Files`.
- * See the [documentation for `CSIDL_INTERNET_CACHE`](https://msdn.microsoft.com/en-us/library/windows/desktop/bb762494%28v=vs.85%29.aspx#csidl_internet_cache).
+ * See the [documentation for `FOLDERID_InternetCache`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
+ *
+ * The return value is cached and modifying it at runtime is not supported, as
+ * it’s not thread-safe to modify environment variables at runtime.
*
- * Returns: (type filename): a string owned by GLib that must not be modified
- * or freed.
+ * Returns: (type filename) (transfer none): a string owned by GLib that
+ * must not be modified or freed.
* Since: 2.6
**/
const gchar *
}
static gchar *
+g_build_user_state_dir (void)
+{
+ gchar *state_dir = NULL;
+ const gchar *state_dir_env = g_getenv ("XDG_STATE_HOME");
+
+ if (state_dir_env && state_dir_env[0])
+ state_dir = g_strdup (state_dir_env);
+#ifdef G_OS_WIN32
+ else
+ state_dir = get_special_folder (&FOLDERID_LocalAppData);
+#endif
+ if (!state_dir || !state_dir[0])
+ {
+ gchar *home_dir = g_build_home_dir ();
+ state_dir = g_build_filename (home_dir, ".local/state", NULL);
+ g_free (home_dir);
+ }
+
+ return g_steal_pointer (&state_dir);
+}
+
+/**
+ * g_get_user_state_dir:
+ *
+ * Returns a base directory in which to store state files specific to
+ * particular user.
+ *
+ * On UNIX platforms this is determined using the mechanisms described
+ * in the
+ * [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
+ * In this case the directory retrieved will be `XDG_STATE_HOME`.
+ *
+ * On Windows it follows XDG Base Directory Specification if `XDG_STATE_HOME` is defined.
+ * If `XDG_STATE_HOME` is undefined, the folder to use for local (as opposed
+ * to roaming) application data is used instead. See the
+ * [documentation for `FOLDERID_LocalAppData`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
+ * Note that in this case on Windows it will be the same
+ * as what g_get_user_data_dir() returns.
+ *
+ * The return value is cached and modifying it at runtime is not supported, as
+ * it’s not thread-safe to modify environment variables at runtime.
+ *
+ * Returns: (type filename) (transfer none): a string owned by GLib that
+ * must not be modified or freed.
+ *
+ * Since: 2.72
+ **/
+const gchar *
+g_get_user_state_dir (void)
+{
+ const gchar *user_state_dir;
+
+ G_LOCK (g_utils_global);
+
+ if (g_user_state_dir == NULL)
+ g_user_state_dir = g_build_user_state_dir ();
+ user_state_dir = g_user_state_dir;
+
+ G_UNLOCK (g_utils_global);
+
+ return user_state_dir;
+}
+
+static gchar *
g_build_user_runtime_dir (void)
{
gchar *runtime_dir = NULL;
const gchar *runtime_dir_env = g_getenv ("XDG_RUNTIME_DIR");
if (runtime_dir_env && runtime_dir_env[0])
- runtime_dir = g_strdup (runtime_dir_env);
+ {
+ runtime_dir = g_strdup (runtime_dir_env);
+
+ /* If the XDG_RUNTIME_DIR environment variable is set, we are being told by
+ * the OS that this directory exists and is appropriately configured
+ * already.
+ */
+ }
else
{
runtime_dir = g_build_user_cache_dir ();
- /* The user should be able to rely on the directory existing
+ /* Fallback case: the directory may not yet exist.
+ *
+ * The user should be able to rely on the directory existing
* when the function returns. Probably it already does, but
* let's make sure. Just do mkdir() directly since it will be
* no more expensive than a stat() in the case that the
* In the case that this variable is not set, we return the value of
* g_get_user_cache_dir(), after verifying that it exists.
*
+ * The return value is cached and modifying it at runtime is not supported, as
+ * it’s not thread-safe to modify environment variables at runtime.
+ *
* Returns: (type filename): a string owned by GLib that must not be
* modified or freed.
*
return user_runtime_dir;
}
-#ifdef HAVE_CARBON
-
-static gchar *
-find_folder (OSType type)
-{
- gchar *filename = NULL;
- FSRef found;
-
- if (FSFindFolder (kUserDomain, type, kDontCreateFolder, &found) == noErr)
- {
- CFURLRef url = CFURLCreateFromFSRef (kCFAllocatorSystemDefault, &found);
-
- if (url)
- {
- CFStringRef path = CFURLCopyFileSystemPath (url, kCFURLPOSIXPathStyle);
-
- if (path)
- {
- filename = g_strdup (CFStringGetCStringPtr (path, kCFStringEncodingUTF8));
-
- if (! filename)
- {
- filename = g_new0 (gchar, CFStringGetLength (path) * 3 + 1);
-
- CFStringGetCString (path, filename,
- CFStringGetLength (path) * 3 + 1,
- kCFStringEncodingUTF8);
- }
-
- CFRelease (path);
- }
+#ifdef HAVE_COCOA
- CFRelease (url);
- }
- }
-
- return filename;
-}
+/* Implemented in gutils-macos.m */
+void load_user_special_dirs_macos (gchar **table);
static void
load_user_special_dirs (void)
{
- g_user_special_dirs[G_USER_DIRECTORY_DESKTOP] = find_folder (kDesktopFolderType);
- g_user_special_dirs[G_USER_DIRECTORY_DOCUMENTS] = find_folder (kDocumentsFolderType);
- g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = find_folder (kDesktopFolderType); /* XXX correct ? */
- g_user_special_dirs[G_USER_DIRECTORY_MUSIC] = find_folder (kMusicDocumentsFolderType);
- g_user_special_dirs[G_USER_DIRECTORY_PICTURES] = find_folder (kPictureDocumentsFolderType);
- g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = NULL;
- g_user_special_dirs[G_USER_DIRECTORY_TEMPLATES] = NULL;
- g_user_special_dirs[G_USER_DIRECTORY_VIDEOS] = find_folder (kMovieDocumentsFolderType);
+ load_user_special_dirs_macos (g_user_special_dirs);
}
#elif defined(G_OS_WIN32)
static void
load_user_special_dirs (void)
{
- typedef HRESULT (WINAPI *t_SHGetKnownFolderPath) (const GUID *rfid,
- DWORD dwFlags,
- HANDLE hToken,
- PWSTR *ppszPath);
- t_SHGetKnownFolderPath p_SHGetKnownFolderPath;
+ g_user_special_dirs[G_USER_DIRECTORY_DESKTOP] = get_special_folder (&FOLDERID_Desktop);
+ g_user_special_dirs[G_USER_DIRECTORY_DOCUMENTS] = get_special_folder (&FOLDERID_Documents);
- static const GUID FOLDERID_Downloads =
- { 0x374de290, 0x123f, 0x4565, { 0x91, 0x64, 0x39, 0xc4, 0x92, 0x5e, 0x46, 0x7b } };
- static const GUID FOLDERID_Public =
- { 0xDFDF76A2, 0xC82A, 0x4D63, { 0x90, 0x6A, 0x56, 0x44, 0xAC, 0x45, 0x73, 0x85 } };
+ g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = get_special_folder (&FOLDERID_Downloads);
+ if (g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] == NULL)
+ g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = get_special_folder (&FOLDERID_Desktop);
- wchar_t *wcp;
+ g_user_special_dirs[G_USER_DIRECTORY_MUSIC] = get_special_folder (&FOLDERID_Music);
+ g_user_special_dirs[G_USER_DIRECTORY_PICTURES] = get_special_folder (&FOLDERID_Pictures);
- p_SHGetKnownFolderPath = (t_SHGetKnownFolderPath) GetProcAddress (GetModuleHandle ("shell32.dll"),
- "SHGetKnownFolderPath");
+ g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = get_special_folder (&FOLDERID_Public);
+ if (g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] == NULL)
+ g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = get_special_folder (&FOLDERID_PublicDocuments);
- g_user_special_dirs[G_USER_DIRECTORY_DESKTOP] = get_special_folder (CSIDL_DESKTOPDIRECTORY);
- g_user_special_dirs[G_USER_DIRECTORY_DOCUMENTS] = get_special_folder (CSIDL_PERSONAL);
-
- if (p_SHGetKnownFolderPath == NULL)
- {
- g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = get_special_folder (CSIDL_DESKTOPDIRECTORY);
- }
- else
- {
- wcp = NULL;
- (*p_SHGetKnownFolderPath) (&FOLDERID_Downloads, 0, NULL, &wcp);
- if (wcp)
- {
- g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = g_utf16_to_utf8 (wcp, -1, NULL, NULL, NULL);
- if (g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] == NULL)
- g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = get_special_folder (CSIDL_DESKTOPDIRECTORY);
- CoTaskMemFree (wcp);
- }
- else
- g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = get_special_folder (CSIDL_DESKTOPDIRECTORY);
- }
-
- g_user_special_dirs[G_USER_DIRECTORY_MUSIC] = get_special_folder (CSIDL_MYMUSIC);
- g_user_special_dirs[G_USER_DIRECTORY_PICTURES] = get_special_folder (CSIDL_MYPICTURES);
-
- if (p_SHGetKnownFolderPath == NULL)
- {
- /* XXX */
- g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = get_special_folder (CSIDL_COMMON_DOCUMENTS);
- }
- else
- {
- wcp = NULL;
- (*p_SHGetKnownFolderPath) (&FOLDERID_Public, 0, NULL, &wcp);
- if (wcp)
- {
- g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = g_utf16_to_utf8 (wcp, -1, NULL, NULL, NULL);
- if (g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] == NULL)
- g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = get_special_folder (CSIDL_COMMON_DOCUMENTS);
- CoTaskMemFree (wcp);
- }
- else
- g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = get_special_folder (CSIDL_COMMON_DOCUMENTS);
- }
-
- g_user_special_dirs[G_USER_DIRECTORY_TEMPLATES] = get_special_folder (CSIDL_TEMPLATES);
- g_user_special_dirs[G_USER_DIRECTORY_VIDEOS] = get_special_folder (CSIDL_MYVIDEO);
+ g_user_special_dirs[G_USER_DIRECTORY_TEMPLATES] = get_special_folder (&FOLDERID_Templates);
+ g_user_special_dirs[G_USER_DIRECTORY_VIDEOS] = get_special_folder (&FOLDERID_Videos);
}
#else /* default is unix */
* of the special directory without requiring the session to restart; GLib
* will not reflect any change once the special directories are loaded.
*
- * Returns: (type filename): the path to the specified special directory, or
- * %NULL if the logical id was not found. The returned string is owned by
- * GLib and should not be modified or freed.
+ * Returns: (type filename) (nullable): the path to the specified special
+ * directory, or %NULL if the logical id was not found. The returned string is
+ * owned by GLib and should not be modified or freed.
*
* Since: 2.14
*/
{
/* Holds the g_utils_global lock */
- static gboolean beenhere = FALSE;
- typedef BOOL (WINAPI *t_GetModuleHandleExA) (DWORD, LPCTSTR, HMODULE *);
- static t_GetModuleHandleExA p_GetModuleHandleExA = NULL;
HMODULE hmodule = NULL;
if (!address)
return NULL;
- if (!beenhere)
- {
- p_GetModuleHandleExA =
- (t_GetModuleHandleExA) GetProcAddress (GetModuleHandle ("kernel32.dll"),
- "GetModuleHandleExA");
- beenhere = TRUE;
- }
-
- if (p_GetModuleHandleExA == NULL ||
- !(*p_GetModuleHandleExA) (GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT |
- GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
- address, &hmodule))
+ if (!GetModuleHandleExW (GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT |
+ GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
+ address, &hmodule))
{
MEMORY_BASIC_INFORMATION mbi;
VirtualQuery (address, &mbi, sizeof (mbi));
data_dirs = g_array_new (TRUE, TRUE, sizeof (char *));
/* Documents and Settings\All Users\Application Data */
- p = get_special_folder (CSIDL_COMMON_APPDATA);
+ p = get_special_folder (&FOLDERID_ProgramData);
if (p)
g_array_append_val (data_dirs, p);
-
+
/* Documents and Settings\All Users\Documents */
- p = get_special_folder (CSIDL_COMMON_DOCUMENTS);
+ p = get_special_folder (&FOLDERID_PublicDocuments);
if (p)
g_array_append_val (data_dirs, p);
-
+
/* Using the above subfolders of Documents and Settings perhaps
* makes sense from a Windows perspective.
*
- * But looking at the actual use cases of this function in GTK+
+ * But looking at the actual use cases of this function in GTK
* and GNOME software, what we really want is the "share"
* subdirectory of the installation directory for the package
* our caller is a part of.
* the first elements in the list are the Application Data
* and Documents folders for All Users. (These can be determined only
* on Windows 2000 or later and are not present in the list on other
- * Windows versions.) See documentation for CSIDL_COMMON_APPDATA and
- * CSIDL_COMMON_DOCUMENTS.
+ * Windows versions.) See documentation for FOLDERID_ProgramData and
+ * FOLDERID_PublicDocuments.
*
* Then follows the "share" subfolder in the installation folder for
* the package containing the DLL that calls this function, if it can
* Note that on Windows the returned list can vary depending on where
* this function is called.
*
+ * The return value is cached and modifying it at runtime is not supported, as
+ * it’s not thread-safe to modify environment variables at runtime.
+ *
* Returns: (array zero-terminated=1) (element-type filename) (transfer none):
* a %NULL-terminated array of strings owned by GLib that must not be
* modified or freed.
}
else
{
- gchar *special_conf_dirs = get_special_folder (CSIDL_COMMON_APPDATA);
+ gchar *special_conf_dirs = get_special_folder (&FOLDERID_ProgramData);
if (special_conf_dirs)
conf_dir_vector = g_strsplit (special_conf_dirs, G_SEARCHPATH_SEPARATOR_S, 0);
* This folder is used for application data
* that is not user specific. For example, an application can store
* a spell-check dictionary, a database of clip art, or a log file in the
- * CSIDL_COMMON_APPDATA folder. This information will not roam and is available
+ * FOLDERID_ProgramData folder. This information will not roam and is available
* to anyone using the computer.
*
+ * The return value is cached and modifying it at runtime is not supported, as
+ * it’s not thread-safe to modify environment variables at runtime.
+ *
* Returns: (array zero-terminated=1) (element-type filename) (transfer none):
* a %NULL-terminated array of strings owned by GLib that must not be
* modified or freed.
* Formats a size (for example the size of a file) into a human readable
* string. Sizes are rounded to the nearest size prefix (kB, MB, GB)
* and are displayed rounded to the nearest tenth. E.g. the file size
- * 3292528 bytes will be converted into the string "3.2 MB".
+ * 3292528 bytes will be converted into the string "3.2 MB". The returned string
+ * is UTF-8, and may use a non-breaking space to separate the number and units,
+ * to ensure they aren’t separated when line wrapped.
*
* The prefix units base is 1000 (i.e. 1 kB is 1000 bytes).
*
* See g_format_size_full() for more options about how the size might be
* formatted.
*
- * Returns: a newly-allocated formatted string containing a human readable
- * file size
+ * Returns: (transfer full): a newly-allocated formatted string containing
+ * a human readable file size
*
* Since: 2.30
*/
* Network and storage sizes should be reported in the normal SI units.
* @G_FORMAT_SIZE_BITS: set the size as a quantity in bits, rather than
* bytes, and return units in bits. For example, ‘Mb’ rather than ‘MB’.
+ * @G_FORMAT_SIZE_ONLY_VALUE: return only value, without unit; this should
+ * not be used together with @G_FORMAT_SIZE_LONG_FORMAT
+ * nor @G_FORMAT_SIZE_ONLY_UNIT. Since: 2.74
+ * @G_FORMAT_SIZE_ONLY_UNIT: return only unit, without value; this should
+ * not be used together with @G_FORMAT_SIZE_LONG_FORMAT
+ * nor @G_FORMAT_SIZE_ONLY_VALUE. Since: 2.74
*
* Flags to modify the format of the string returned by g_format_size_full().
*/
* This function is similar to g_format_size() but allows for flags
* that modify the output. See #GFormatSizeFlags.
*
- * Returns: a newly-allocated formatted string containing a human
- * readable file size
+ * Returns: (transfer full): a newly-allocated formatted string
+ * containing a human readable file size
*
* Since: 2.30
*/
struct Format
{
guint64 factor;
- char string[9];
+ char string[10];
};
typedef enum
const struct Format formats[4][6] = {
{
- { KILOBYTE_FACTOR, N_("%.1f kB") },
- { MEGABYTE_FACTOR, N_("%.1f MB") },
- { GIGABYTE_FACTOR, N_("%.1f GB") },
- { TERABYTE_FACTOR, N_("%.1f TB") },
- { PETABYTE_FACTOR, N_("%.1f PB") },
- { EXABYTE_FACTOR, N_("%.1f EB") }
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 kB" */
+ { KILOBYTE_FACTOR, N_("kB") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 MB" */
+ { MEGABYTE_FACTOR, N_("MB") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 GB" */
+ { GIGABYTE_FACTOR, N_("GB") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 TB" */
+ { TERABYTE_FACTOR, N_("TB") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 PB" */
+ { PETABYTE_FACTOR, N_("PB") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 EB" */
+ { EXABYTE_FACTOR, N_("EB") }
},
{
- { KIBIBYTE_FACTOR, N_("%.1f KiB") },
- { MEBIBYTE_FACTOR, N_("%.1f MiB") },
- { GIBIBYTE_FACTOR, N_("%.1f GiB") },
- { TEBIBYTE_FACTOR, N_("%.1f TiB") },
- { PEBIBYTE_FACTOR, N_("%.1f PiB") },
- { EXBIBYTE_FACTOR, N_("%.1f EiB") }
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 KiB" */
+ { KIBIBYTE_FACTOR, N_("KiB") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 MiB" */
+ { MEBIBYTE_FACTOR, N_("MiB") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 GiB" */
+ { GIBIBYTE_FACTOR, N_("GiB") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 TiB" */
+ { TEBIBYTE_FACTOR, N_("TiB") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 PiB" */
+ { PEBIBYTE_FACTOR, N_("PiB") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 EiB" */
+ { EXBIBYTE_FACTOR, N_("EiB") }
},
{
- { KILOBYTE_FACTOR, N_("%.1f kb") },
- { MEGABYTE_FACTOR, N_("%.1f Mb") },
- { GIGABYTE_FACTOR, N_("%.1f Gb") },
- { TERABYTE_FACTOR, N_("%.1f Tb") },
- { PETABYTE_FACTOR, N_("%.1f Pb") },
- { EXABYTE_FACTOR, N_("%.1f Eb") }
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 kb" */
+ { KILOBYTE_FACTOR, N_("kb") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 Mb" */
+ { MEGABYTE_FACTOR, N_("Mb") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 Gb" */
+ { GIGABYTE_FACTOR, N_("Gb") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 Tb" */
+ { TERABYTE_FACTOR, N_("Tb") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 Pb" */
+ { PETABYTE_FACTOR, N_("Pb") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 Eb" */
+ { EXABYTE_FACTOR, N_("Eb") }
},
{
- { KIBIBYTE_FACTOR, N_("%.1f Kib") },
- { MEBIBYTE_FACTOR, N_("%.1f Mib") },
- { GIBIBYTE_FACTOR, N_("%.1f Gib") },
- { TEBIBYTE_FACTOR, N_("%.1f Tib") },
- { PEBIBYTE_FACTOR, N_("%.1f Pib") },
- { EXBIBYTE_FACTOR, N_("%.1f Eib") }
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 Kib" */
+ { KIBIBYTE_FACTOR, N_("Kib") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 Mib" */
+ { MEBIBYTE_FACTOR, N_("Mib") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 Gib" */
+ { GIBIBYTE_FACTOR, N_("Gib") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 Tib" */
+ { TEBIBYTE_FACTOR, N_("Tib") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 Pib" */
+ { PEBIBYTE_FACTOR, N_("Pib") },
+ /* Translators: A unit symbol for size formatting, showing for example: "13.0 Eib" */
+ { EXBIBYTE_FACTOR, N_("Eib") }
}
};
GString *string;
FormatIndex index;
+ g_return_val_if_fail ((flags & (G_FORMAT_SIZE_LONG_FORMAT | G_FORMAT_SIZE_ONLY_VALUE)) != (G_FORMAT_SIZE_LONG_FORMAT | G_FORMAT_SIZE_ONLY_VALUE), NULL);
+ g_return_val_if_fail ((flags & (G_FORMAT_SIZE_LONG_FORMAT | G_FORMAT_SIZE_ONLY_UNIT)) != (G_FORMAT_SIZE_LONG_FORMAT | G_FORMAT_SIZE_ONLY_UNIT), NULL);
+ g_return_val_if_fail ((flags & (G_FORMAT_SIZE_ONLY_VALUE | G_FORMAT_SIZE_ONLY_UNIT)) != (G_FORMAT_SIZE_ONLY_VALUE | G_FORMAT_SIZE_ONLY_UNIT), NULL);
+
string = g_string_new (NULL);
- switch (flags & ~G_FORMAT_SIZE_LONG_FORMAT)
+ switch (flags & ~(G_FORMAT_SIZE_LONG_FORMAT | G_FORMAT_SIZE_ONLY_VALUE | G_FORMAT_SIZE_ONLY_UNIT))
{
case G_FORMAT_SIZE_DEFAULT:
index = FORMAT_BYTES;
if (size < formats[index][0].factor)
{
- const char * format;
+ const char * units;
if (index == FORMAT_BYTES || index == FORMAT_BYTES_IEC)
{
- format = g_dngettext (GETTEXT_PACKAGE, "%u byte", "%u bytes", (guint) size);
+ units = g_dngettext (GETTEXT_PACKAGE, "byte", "bytes", (guint) size);
}
else
{
- format = g_dngettext (GETTEXT_PACKAGE, "%u bit", "%u bits", (guint) size);
+ units = g_dngettext (GETTEXT_PACKAGE, "bit", "bits", (guint) size);
}
- g_string_printf (string, format, (guint) size);
+ if ((flags & G_FORMAT_SIZE_ONLY_UNIT) != 0)
+ g_string_append (string, units);
+ else if ((flags & G_FORMAT_SIZE_ONLY_VALUE) != 0)
+ /* Translators: The "%u" is replaced with the size value, like "13"; it could
+ * be part of "13 bytes", but only the number is requested this time. */
+ g_string_printf (string, C_("format-size", "%u"), (guint) size);
+ else
+ {
+ /* Translators: The first "%u" is replaced with the value, the "%s" with a unit of the value.
+ * The order can be changed with "%$2s %$1u". An example: "13 bytes" */
+ g_string_printf (string, C_("format-size", "%u %s"), (guint) size, units);
+ }
flags &= ~G_FORMAT_SIZE_LONG_FORMAT;
}
else
{
const gsize n = G_N_ELEMENTS (formats[index]);
+ const gchar * units;
+ gdouble value;
gsize i;
/*
}
}
- g_string_printf (string, _(f->string), (gdouble) size / (gdouble) f->factor);
+ units = _(f->string);
+ value = (gdouble) size / (gdouble) f->factor;
+
+ if ((flags & G_FORMAT_SIZE_ONLY_UNIT) != 0)
+ g_string_append (string, units);
+ else if ((flags & G_FORMAT_SIZE_ONLY_VALUE) != 0)
+ /* Translators: The "%.1f" is replaced with the size value, like "13.0"; it could
+ * be part of "13.0 MB", but only the number is requested this time. */
+ g_string_printf (string, C_("format-size", "%.1f"), value);
+ else
+ {
+ /* Translators: The first "%.1f" is replaced with the value, the "%s" with a unit of the value.
+ * The order can be changed with "%$2s %$1.1f". Keep the no-break space between the value and
+ * the unit symbol. An example: "13.0 MB" */
+ g_string_printf (string, C_("format-size", "%.1f %s"), value, units);
+ }
}
if (flags & G_FORMAT_SIZE_LONG_FORMAT)
/* Translators: the %s in "%s bits" will always be replaced by a number. */
translated_format = g_dngettext (GETTEXT_PACKAGE, "%s bit", "%s bits", plural_form);
}
- /* XXX: Windows doesn't support the "'" format modifier, so we
- * must not use it there. Instead, just display the number
- * without separation. Bug #655336 is open until a solution is
- * found.
- */
-#ifndef G_OS_WIN32
formatted_number = g_strdup_printf ("%'"G_GUINT64_FORMAT, size);
-#else
- formatted_number = g_strdup_printf ("%"G_GUINT64_FORMAT, size);
-#endif
g_string_append (string, " (");
g_string_append_printf (string, translated_format, formatted_number);
*
* This string should be freed with g_free() when not needed any longer.
*
- * Returns: a newly-allocated formatted string containing a human
- * readable file size
+ * Returns: (transfer full): a newly-allocated formatted string
+ * containing a human readable file size
*
* Since: 2.16
*
void
g_abort (void)
{
- /* One call to break the debugger */
- DebugBreak ();
- /* One call in case CRT does get saner about abort() behaviour */
+ /* One call to break the debugger
+ * We check if a debugger is actually attached to
+ * avoid a windows error reporting popup window
+ * when run in a test harness / on CI
+ */
+ if (IsDebuggerPresent ())
+ DebugBreak ();
+ /* One call in case CRT changes its abort() behaviour */
abort ();
/* And one call to bind them all and terminate the program for sure */
ExitProcess (127);
projects / platform / upstream / glib.git / blobdiff