glib/gutils.c

   1 /* GLIB - Library of useful routines for C programming
   2  * Copyright (C) 1995-1998  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GLib Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GLib at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 /*
  28  * MT safe for the unix part, FIXME: make the win32 part MT safe as well.
  29  */
  30
  31 #include "config.h"
  32
  33 #ifdef HAVE_UNISTD_H
  34 #include <unistd.h>
  35 #endif
  36 #include <stdarg.h>
  37 #include <stdlib.h>
  38 #include <stdio.h>
  39 #include <locale.h>
  40 #include <string.h>
  41 #include <ctype.h>              /* For tolower() */
  42 #include <errno.h>
  43 #include <sys/types.h>
  44 #include <sys/stat.h>
  45 #ifdef HAVE_PWD_H
  46 #include <pwd.h>
  47 #endif
  48 #include <sys/types.h>
  49 #ifdef HAVE_SYS_PARAM_H
  50 #include <sys/param.h>
  51 #endif
  52 #ifdef HAVE_CRT_EXTERNS_H
  53 #include <crt_externs.h> /* for _NSGetEnviron */
  54 #endif
  55
  56 /* implement gutils's inline functions
  57  */
  58 #define G_IMPLEMENT_INLINES 1
  59 #define __G_UTILS_C__
  60 #include "gutils.h"
  61
  62 #include "glib-init.h"
  63 #include "glib-private.h"
  64 #include "genviron.h"
  65 #include "gfileutils.h"
  66 #include "ggettext.h"
  67 #include "ghash.h"
  68 #include "gthread.h"
  69 #include "gtestutils.h"
  70 #include "gunicode.h"
  71 #include "gstrfuncs.h"
  72 #include "garray.h"
  73 #include "glibintl.h"
  74
  75 #ifdef G_PLATFORM_WIN32
  76 #include "gconvert.h"
  77 #include "gwin32.h"
  78 #endif
  79
  80
  81 /**
  82  * SECTION:misc_utils
  83  * @title: Miscellaneous Utility Functions
  84  * @short_description: a selection of portable utility functions
  85  *
  86  * These are portable utility functions.
  87  */
  88
  89 #ifdef G_PLATFORM_WIN32
  90 #  include <windows.h>
  91 #  ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
  92 #    define GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT 2
  93 #    define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS 4
  94 #  endif
  95 #  include <lmcons.h>           /* For UNLEN */
  96 #endif /* G_PLATFORM_WIN32 */
  97
  98 #ifdef G_OS_WIN32
  99 #  include <direct.h>
 100 #  include <shlobj.h>
 101    /* older SDK (e.g. msvc 5.0) does not have these*/
 102 #  ifndef CSIDL_MYMUSIC
 103 #    define CSIDL_MYMUSIC 13
 104 #  endif
 105 #  ifndef CSIDL_MYVIDEO
 106 #    define CSIDL_MYVIDEO 14
 107 #  endif
 108 #  ifndef CSIDL_INTERNET_CACHE
 109 #    define CSIDL_INTERNET_CACHE 32
 110 #  endif
 111 #  ifndef CSIDL_COMMON_APPDATA
 112 #    define CSIDL_COMMON_APPDATA 35
 113 #  endif
 114 #  ifndef CSIDL_MYPICTURES
 115 #    define CSIDL_MYPICTURES 0x27
 116 #  endif
 117 #  ifndef CSIDL_COMMON_DOCUMENTS
 118 #    define CSIDL_COMMON_DOCUMENTS 46
 119 #  endif
 120 #  ifndef CSIDL_PROFILE
 121 #    define CSIDL_PROFILE 40
 122 #  endif
 123 #  include <process.h>
 124 #endif
 125
 126 #ifdef HAVE_CARBON
 127 #include <CoreServices/CoreServices.h>
 128 #endif
 129
 130 #ifdef HAVE_CODESET
 131 #include <langinfo.h>
 132 #endif
 133
 134 #ifdef G_PLATFORM_WIN32
 135
 136 gchar *
 137 _glib_get_dll_directory (void)
 138 {
 139   gchar *retval;
 140   gchar *p;
 141   wchar_t wc_fn[MAX_PATH];
 142
 143 #ifdef DLL_EXPORT
 144   if (glib_dll == NULL)
 145     return NULL;
 146 #endif
 147
 148   /* This code is different from that in
 149    * g_win32_get_package_installation_directory_of_module() in that
 150    * here we return the actual folder where the GLib DLL is. We don't
 151    * do the check for it being in a "bin" or "lib" subfolder and then
 152    * returning the parent of that.
 153    *
 154    * In a statically built GLib, glib_dll will be NULL and we will
 155    * thus look up the application's .exe file's location.
 156    */
 157   if (!GetModuleFileNameW (glib_dll, wc_fn, MAX_PATH))
 158     return NULL;
 159
 160   retval = g_utf16_to_utf8 (wc_fn, -1, NULL, NULL, NULL);
 161
 162   p = strrchr (retval, G_DIR_SEPARATOR);
 163   if (p == NULL)
 164     {
 165       /* Wtf? */
 166       return NULL;
 167     }
 168   *p = '\0';
 169
 170   return retval;
 171 }
 172
 173 #endif
 174
 175 #if !defined (HAVE_MEMMOVE) && !defined (HAVE_WORKING_BCOPY)
 176 /**
 177  * g_memmove:
 178  * @dest: the destination address to copy the bytes to.
 179  * @src: the source address to copy the bytes from.
 180  * @len: the number of bytes to copy.
 181  *
 182  * Copies a block of memory @len bytes long, from @src to @dest.
 183  * The source and destination areas may overlap.
 184  *
 185  * In order to use this function, you must include
 186  * <filename>string.h</filename> yourself, because this macro will
 187  * typically simply resolve to memmove() and GLib does not include
 188  * <filename>string.h</filename> for you.
 189  */
 190 void
 191 g_memmove (gpointer      dest,
 192            gconstpointer src,
 193            gulong        len)
 194 {
 195   gchar* destptr = dest;
 196   const gchar* srcptr = src;
 197   if (src + len < dest || dest + len < src)
 198     {
 199       bcopy (src, dest, len);
 200       return;
 201     }
 202   else if (dest <= src)
 203     {
 204       while (len--)
 205         *(destptr++) = *(srcptr++);
 206     }
 207   else
 208     {
 209       destptr += len;
 210       srcptr += len;
 211       while (len--)
 212         *(--destptr) = *(--srcptr);
 213     }
 214 }
 215 #endif /* !HAVE_MEMMOVE && !HAVE_WORKING_BCOPY */
 216
 217 #ifdef G_OS_WIN32
 218 #undef g_atexit
 219 #endif
 220
 221 /**
 222  * g_atexit:
 223  * @func: (scope async): the function to call on normal program termination.
 224  *
 225  * Specifies a function to be called at normal program termination.
 226  *
 227  * Since GLib 2.8.2, on Windows g_atexit() actually is a preprocessor
 228  * macro that maps to a call to the atexit() function in the C
 229  * library. This means that in case the code that calls g_atexit(),
 230  * i.e. atexit(), is in a DLL, the function will be called when the
 231  * DLL is detached from the program. This typically makes more sense
 232  * than that the function is called when the GLib DLL is detached,
 233  * which happened earlier when g_atexit() was a function in the GLib
 234  * DLL.
 235  *
 236  * The behaviour of atexit() in the context of dynamically loaded
 237  * modules is not formally specified and varies wildly.
 238  *
 239  * On POSIX systems, calling g_atexit() (or atexit()) in a dynamically
 240  * loaded module which is unloaded before the program terminates might
 241  * well cause a crash at program exit.
 242  *
 243  * Some POSIX systems implement atexit() like Windows, and have each
 244  * dynamically loaded module maintain an own atexit chain that is
 245  * called when the module is unloaded.
 246  *
 247  * On other POSIX systems, before a dynamically loaded module is
 248  * unloaded, the registered atexit functions (if any) residing in that
 249  * module are called, regardless where the code that registered them
 250  * resided. This is presumably the most robust approach.
 251  *
 252  * As can be seen from the above, for portability it's best to avoid
 253  * calling g_atexit() (or atexit()) except in the main executable of a
 254  * program.
 255  *
 256  * Deprecated:2.32: It is best to avoid g_atexit().
 257  */
 258 void
 259 g_atexit (GVoidFunc func)
 260 {
 261   gint result;
 262   const gchar *error = NULL;
 263
 264   /* keep this in sync with glib.h */
 265
 266 #ifdef  G_NATIVE_ATEXIT
 267   result = ATEXIT (func);
 268   if (result)
 269     error = g_strerror (errno);
 270 #elif defined (HAVE_ATEXIT)
 271 #  ifdef NeXT /* @#%@! NeXTStep */
 272   result = !atexit ((void (*)(void)) func);
 273   if (result)
 274     error = g_strerror (errno);
 275 #  else
 276   result = atexit ((void (*)(void)) func);
 277   if (result)
 278     error = g_strerror (errno);
 279 #  endif /* NeXT */
 280 #elif defined (HAVE_ON_EXIT)
 281   result = on_exit ((void (*)(int, void *)) func, NULL);
 282   if (result)
 283     error = g_strerror (errno);
 284 #else
 285   result = 0;
 286   error = "no implementation";
 287 #endif /* G_NATIVE_ATEXIT */
 288
 289   if (error)
 290     g_error ("Could not register atexit() function: %s", error);
 291 }
 292
 293 /* Based on execvp() from GNU Libc.
 294  * Some of this code is cut-and-pasted into gspawn.c
 295  */
 296
 297 static gchar*
 298 my_strchrnul (const gchar *str,
 299               gchar        c)
 300 {
 301   gchar *p = (gchar*)str;
 302   while (*p && (*p != c))
 303     ++p;
 304
 305   return p;
 306 }
 307
 308 #ifdef G_OS_WIN32
 309
 310 static gchar *inner_find_program_in_path (const gchar *program);
 311
 312 gchar*
 313 g_find_program_in_path (const gchar *program)
 314 {
 315   const gchar *last_dot = strrchr (program, '.');
 316
 317   if (last_dot == NULL ||
 318       strchr (last_dot, '\\') != NULL ||
 319       strchr (last_dot, '/') != NULL)
 320     {
 321       const gint program_length = strlen (program);
 322       gchar *pathext = g_build_path (";",
 323                                      ".exe;.cmd;.bat;.com",
 324                                      g_getenv ("PATHEXT"),
 325                                      NULL);
 326       gchar *p;
 327       gchar *decorated_program;
 328       gchar *retval;
 329
 330       p = pathext;
 331       do
 332         {
 333           gchar *q = my_strchrnul (p, ';');
 334
 335           decorated_program = g_malloc (program_length + (q-p) + 1);
 336           memcpy (decorated_program, program, program_length);
 337           memcpy (decorated_program+program_length, p, q-p);
 338           decorated_program [program_length + (q-p)] = '\0';
 339
 340           retval = inner_find_program_in_path (decorated_program);
 341           g_free (decorated_program);
 342
 343           if (retval != NULL)
 344             {
 345               g_free (pathext);
 346               return retval;
 347             }
 348           p = q;
 349         } while (*p++ != '\0');
 350       g_free (pathext);
 351       return NULL;
 352     }
 353   else
 354     return inner_find_program_in_path (program);
 355 }
 356
 357 #endif
 358
 359 /**
 360  * g_find_program_in_path:
 361  * @program: a program name in the GLib file name encoding
 362  *
 363  * Locates the first executable named @program in the user's path, in the
 364  * same way that execvp() would locate it. Returns an allocated string
 365  * with the absolute path name, or %NULL if the program is not found in
 366  * the path. If @program is already an absolute path, returns a copy of
 367  * @program if @program exists and is executable, and %NULL otherwise.
 368  *
 369  * On Windows, if @program does not have a file type suffix, tries
 370  * with the suffixes .exe, .cmd, .bat and .com, and the suffixes in
 371  * the <envar>PATHEXT</envar> environment variable.
 372  *
 373  * On Windows, it looks for the file in the same way as CreateProcess()
 374  * would. This means first in the directory where the executing
 375  * program was loaded from, then in the current directory, then in the
 376  * Windows 32-bit system directory, then in the Windows directory, and
 377  * finally in the directories in the <envar>PATH</envar> environment
 378  * variable. If the program is found, the return value contains the
 379  * full name including the type suffix.
 380  *
 381  * Return value: a newly-allocated string with the absolute path, or %NULL
 382  **/
 383 #ifdef G_OS_WIN32
 384 static gchar *
 385 inner_find_program_in_path (const gchar *program)
 386 #else
 387 gchar*
 388 g_find_program_in_path (const gchar *program)
 389 #endif
 390 {
 391   const gchar *path, *p;
 392   gchar *name, *freeme;
 393 #ifdef G_OS_WIN32
 394   const gchar *path_copy;
 395   gchar *filename = NULL, *appdir = NULL;
 396   gchar *sysdir = NULL, *windir = NULL;
 397   int n;
 398   wchar_t wfilename[MAXPATHLEN], wsysdir[MAXPATHLEN],
 399     wwindir[MAXPATHLEN];
 400 #endif
 401   gsize len;
 402   gsize pathlen;
 403
 404   g_return_val_if_fail (program != NULL, NULL);
 405
 406   /* If it is an absolute path, or a relative path including subdirectories,
 407    * don't look in PATH.
 408    */
 409   if (g_path_is_absolute (program)
 410       || strchr (program, G_DIR_SEPARATOR) != NULL
 411 #ifdef G_OS_WIN32
 412       || strchr (program, '/') != NULL
 413 #endif
 414       )
 415     {
 416       if (g_file_test (program, G_FILE_TEST_IS_EXECUTABLE) &&
 417           !g_file_test (program, G_FILE_TEST_IS_DIR))
 418         return g_strdup (program);
 419       else
 420         return NULL;
 421     }
 422
 423   path = g_getenv ("PATH");
 424 #if defined(G_OS_UNIX) || defined(G_OS_BEOS)
 425   if (path == NULL)
 426     {
 427       /* There is no `PATH' in the environment.  The default
 428        * search path in GNU libc is the current directory followed by
 429        * the path `confstr' returns for `_CS_PATH'.
 430        */
 431
 432       /* In GLib we put . last, for security, and don't use the
 433        * unportable confstr(); UNIX98 does not actually specify
 434        * what to search if PATH is unset. POSIX may, dunno.
 435        */
 436
 437       path = "/bin:/usr/bin:.";
 438     }
 439 #else
 440   n = GetModuleFileNameW (NULL, wfilename, MAXPATHLEN);
 441   if (n > 0 && n < MAXPATHLEN)
 442     filename = g_utf16_to_utf8 (wfilename, -1, NULL, NULL, NULL);
 443
 444   n = GetSystemDirectoryW (wsysdir, MAXPATHLEN);
 445   if (n > 0 && n < MAXPATHLEN)
 446     sysdir = g_utf16_to_utf8 (wsysdir, -1, NULL, NULL, NULL);
 447
 448   n = GetWindowsDirectoryW (wwindir, MAXPATHLEN);
 449   if (n > 0 && n < MAXPATHLEN)
 450     windir = g_utf16_to_utf8 (wwindir, -1, NULL, NULL, NULL);
 451
 452   if (filename)
 453     {
 454       appdir = g_path_get_dirname (filename);
 455       g_free (filename);
 456     }
 457
 458   path = g_strdup (path);
 459
 460   if (windir)
 461     {
 462       const gchar *tem = path;
 463       path = g_strconcat (windir, ";", path, NULL);
 464       g_free ((gchar *) tem);
 465       g_free (windir);
 466     }
 467
 468   if (sysdir)
 469     {
 470       const gchar *tem = path;
 471       path = g_strconcat (sysdir, ";", path, NULL);
 472       g_free ((gchar *) tem);
 473       g_free (sysdir);
 474     }
 475
 476   {
 477     const gchar *tem = path;
 478     path = g_strconcat (".;", path, NULL);
 479     g_free ((gchar *) tem);
 480   }
 481
 482   if (appdir)
 483     {
 484       const gchar *tem = path;
 485       path = g_strconcat (appdir, ";", path, NULL);
 486       g_free ((gchar *) tem);
 487       g_free (appdir);
 488     }
 489
 490   path_copy = path;
 491 #endif
 492
 493   len = strlen (program) + 1;
 494   pathlen = strlen (path);
 495   freeme = name = g_malloc (pathlen + len + 1);
 496
 497   /* Copy the file name at the top, including '\0'  */
 498   memcpy (name + pathlen + 1, program, len);
 499   name = name + pathlen;
 500   /* And add the slash before the filename  */
 501   *name = G_DIR_SEPARATOR;
 502
 503   p = path;
 504   do
 505     {
 506       char *startp;
 507
 508       path = p;
 509       p = my_strchrnul (path, G_SEARCHPATH_SEPARATOR);
 510
 511       if (p == path)
 512         /* Two adjacent colons, or a colon at the beginning or the end
 513          * of `PATH' means to search the current directory.
 514          */
 515         startp = name + 1;
 516       else
 517         startp = memcpy (name - (p - path), path, p - path);
 518
 519       if (g_file_test (startp, G_FILE_TEST_IS_EXECUTABLE) &&
 520           !g_file_test (startp, G_FILE_TEST_IS_DIR))
 521         {
 522           gchar *ret;
 523           ret = g_strdup (startp);
 524           g_free (freeme);
 525 #ifdef G_OS_WIN32
 526           g_free ((gchar *) path_copy);
 527 #endif
 528           return ret;
 529         }
 530     }
 531   while (*p++ != '\0');
 532
 533   g_free (freeme);
 534 #ifdef G_OS_WIN32
 535   g_free ((gchar *) path_copy);
 536 #endif
 537
 538   return NULL;
 539 }
 540
 541 /**
 542  * g_bit_nth_lsf:
 543  * @mask: a #gulong containing flags
 544  * @nth_bit: the index of the bit to start the search from
 545  *
 546  * Find the position of the first bit set in @mask, searching
 547  * from (but not including) @nth_bit upwards. Bits are numbered
 548  * from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63,
 549  * usually). To start searching from the 0th bit, set @nth_bit to -1.
 550  *
 551  * Returns: the index of the first bit set which is higher than @nth_bit
 552  */
 553
 554 /**
 555  * g_bit_nth_msf:
 556  * @mask: a #gulong containing flags
 557  * @nth_bit: the index of the bit to start the search from
 558  *
 559  * Find the position of the first bit set in @mask, searching
 560  * from (but not including) @nth_bit downwards. Bits are numbered
 561  * from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63,
 562  * usually). To start searching from the last bit, set @nth_bit to
 563  * -1 or GLIB_SIZEOF_LONG * 8.
 564  *
 565  * Returns: the index of the first bit set which is lower than @nth_bit
 566  */
 567
 568 /**
 569  * g_bit_storage:
 570  * @number: a #guint
 571  *
 572  * Gets the number of bits used to hold @number,
 573  * e.g. if @number is 4, 3 bits are needed.
 574  *
 575  * Returns: the number of bits used to hold @number
 576  */
 577
 578 G_LOCK_DEFINE_STATIC (g_utils_global);
 579
 580 static  gchar   *g_user_name = NULL;
 581 static  gchar   *g_real_name = NULL;
 582 static  gchar   *g_home_dir = NULL;
 583
 584 static  gchar   *g_user_data_dir = NULL;
 585 static  gchar  **g_system_data_dirs = NULL;
 586 static  gchar   *g_user_cache_dir = NULL;
 587 static  gchar   *g_user_config_dir = NULL;
 588 static  gchar  **g_system_config_dirs = NULL;
 589
 590 static  gchar  **g_user_special_dirs = NULL;
 591
 592 /* fifteen minutes of fame for everybody */
 593 #define G_USER_DIRS_EXPIRE      15 * 60
 594
 595 #ifdef G_OS_WIN32
 596
 597 static gchar *
 598 get_special_folder (int csidl)
 599 {
 600   wchar_t path[MAX_PATH+1];
 601   HRESULT hr;
 602   LPITEMIDLIST pidl = NULL;
 603   BOOL b;
 604   gchar *retval = NULL;
 605
 606   hr = SHGetSpecialFolderLocation (NULL, csidl, &pidl);
 607   if (hr == S_OK)
 608     {
 609       b = SHGetPathFromIDListW (pidl, path);
 610       if (b)
 611         retval = g_utf16_to_utf8 (path, -1, NULL, NULL, NULL);
 612       CoTaskMemFree (pidl);
 613     }
 614   return retval;
 615 }
 616
 617 static char *
 618 get_windows_directory_root (void)
 619 {
 620   wchar_t wwindowsdir[MAX_PATH];
 621
 622   if (GetWindowsDirectoryW (wwindowsdir, G_N_ELEMENTS (wwindowsdir)))
 623     {
 624       /* Usually X:\Windows, but in terminal server environments
 625        * might be an UNC path, AFAIK.
 626        */
 627       char *windowsdir = g_utf16_to_utf8 (wwindowsdir, -1, NULL, NULL, NULL);
 628       char *p;
 629
 630       if (windowsdir == NULL)
 631         return g_strdup ("C:\\");
 632
 633       p = (char *) g_path_skip_root (windowsdir);
 634       if (G_IS_DIR_SEPARATOR (p[-1]) && p[-2] != ':')
 635         p--;
 636       *p = '\0';
 637       return windowsdir;
 638     }
 639   else
 640     return g_strdup ("C:\\");
 641 }
 642
 643 #endif
 644
 645 /* HOLDS: g_utils_global_lock */
 646 static void
 647 g_get_any_init_do (void)
 648 {
 649   /* We first check HOME and use it if it is set */
 650   g_home_dir = g_strdup (g_getenv ("HOME"));
 651
 652 #ifdef G_OS_WIN32
 653   /* Only believe HOME if it is an absolute path and exists.
 654    *
 655    * We only do this check on Windows for a couple of reasons.
 656    * Historically, we only did it there because we used to ignore $HOME
 657    * on UNIX.  There are concerns about enabling it now on UNIX because
 658    * of things like autofs.  In short, if the user has a bogus value in
 659    * $HOME then they get what they pay for...
 660    */
 661   if (g_home_dir)
 662     {
 663       if (!(g_path_is_absolute (g_home_dir) &&
 664             g_file_test (g_home_dir, G_FILE_TEST_IS_DIR)))
 665         {
 666           g_free (g_home_dir);
 667           g_home_dir = NULL;
 668         }
 669     }
 670
 671   /* In case HOME is Unix-style (it happens), convert it to
 672    * Windows style.
 673    */
 674   if (g_home_dir)
 675     {
 676       gchar *p;
 677       while ((p = strchr (g_home_dir, '/')) != NULL)
 678         *p = '\\';
 679     }
 680
 681   if (!g_home_dir)
 682     {
 683       /* USERPROFILE is probably the closest equivalent to $HOME? */
 684       if (g_getenv ("USERPROFILE") != NULL)
 685         g_home_dir = g_strdup (g_getenv ("USERPROFILE"));
 686     }
 687
 688   if (!g_home_dir)
 689     g_home_dir = get_special_folder (CSIDL_PROFILE);
 690
 691   if (!g_home_dir)
 692     g_home_dir = get_windows_directory_root ();
 693 #endif /* G_OS_WIN32 */
 694
 695 #ifdef HAVE_PWD_H
 696   {
 697     struct passwd *pw = NULL;
 698     gpointer buffer = NULL;
 699     gint error;
 700     gchar *logname;
 701
 702 #  if defined (HAVE_POSIX_GETPWUID_R) || defined (HAVE_NONPOSIX_GETPWUID_R)
 703     struct passwd pwd;
 704 #    ifdef _SC_GETPW_R_SIZE_MAX
 705     /* This reurns the maximum length */
 706     glong bufsize = sysconf (_SC_GETPW_R_SIZE_MAX);
 707
 708     if (bufsize < 0)
 709       bufsize = 64;
 710 #    else /* _SC_GETPW_R_SIZE_MAX */
 711     glong bufsize = 64;
 712 #    endif /* _SC_GETPW_R_SIZE_MAX */
 713
 714     logname = (gchar *) g_getenv ("LOGNAME");
 715
 716     do
 717       {
 718         g_free (buffer);
 719         /* we allocate 6 extra bytes to work around a bug in
 720          * Mac OS < 10.3. See #156446
 721          */
 722         buffer = g_malloc (bufsize + 6);
 723         errno = 0;
 724
 725 #    ifdef HAVE_POSIX_GETPWUID_R
 726         if (logname) {
 727           error = getpwnam_r (logname, &pwd, buffer, bufsize, &pw);
 728           if (!pw || (pw->pw_uid != getuid ())) {
 729             /* LOGNAME is lying, fall back to looking up the uid */
 730             error = getpwuid_r (getuid (), &pwd, buffer, bufsize, &pw);
 731           }
 732         } else {
 733           error = getpwuid_r (getuid (), &pwd, buffer, bufsize, &pw);
 734         }
 735         error = error < 0 ? errno : error;
 736 #    else /* HAVE_NONPOSIX_GETPWUID_R */
 737    /* HPUX 11 falls into the HAVE_POSIX_GETPWUID_R case */
 738 #      if defined(_AIX) || defined(__hpux)
 739         error = getpwuid_r (getuid (), &pwd, buffer, bufsize);
 740         pw = error == 0 ? &pwd : NULL;
 741 #      else /* !_AIX */
 742         if (logname) {
 743           pw = getpwnam_r (logname, &pwd, buffer, bufsize);
 744           if (!pw || (pw->pw_uid != getuid ())) {
 745             /* LOGNAME is lying, fall back to looking up the uid */
 746             pw = getpwuid_r (getuid (), &pwd, buffer, bufsize);
 747           }
 748         } else {
 749           pw = getpwuid_r (getuid (), &pwd, buffer, bufsize);
 750         }
 751         error = pw ? 0 : errno;
 752 #      endif /* !_AIX */
 753 #    endif /* HAVE_NONPOSIX_GETPWUID_R */
 754
 755         if (!pw)
 756           {
 757             /* we bail out prematurely if the user id can't be found
 758              * (should be pretty rare case actually), or if the buffer
 759              * should be sufficiently big and lookups are still not
 760              * successful.
 761              */
 762             if (error == 0 || error == ENOENT)
 763               {
 764                 g_warning ("getpwuid_r(): failed due to unknown user id (%lu)",
 765                            (gulong) getuid ());
 766                 break;
 767               }
 768             if (bufsize > 32 * 1024)
 769               {
 770                 g_warning ("getpwuid_r(): failed due to: %s.",
 771                            g_strerror (error));
 772                 break;
 773               }
 774
 775             bufsize *= 2;
 776           }
 777       }
 778     while (!pw);
 779 #  endif /* HAVE_POSIX_GETPWUID_R || HAVE_NONPOSIX_GETPWUID_R */
 780
 781     if (!pw)
 782       {
 783         setpwent ();
 784         pw = getpwuid (getuid ());
 785         endpwent ();
 786       }
 787     if (pw)
 788       {
 789         g_user_name = g_strdup (pw->pw_name);
 790
 791         if (pw->pw_gecos && *pw->pw_gecos != '\0')
 792           {
 793             gchar **gecos_fields;
 794             gchar **name_parts;
 795
 796             /* split the gecos field and substitute '&' */
 797             gecos_fields = g_strsplit (pw->pw_gecos, ",", 0);
 798             name_parts = g_strsplit (gecos_fields[0], "&", 0);
 799             pw->pw_name[0] = g_ascii_toupper (pw->pw_name[0]);
 800             g_real_name = g_strjoinv (pw->pw_name, name_parts);
 801             g_strfreev (gecos_fields);
 802             g_strfreev (name_parts);
 803           }
 804
 805         if (!g_home_dir)
 806           g_home_dir = g_strdup (pw->pw_dir);
 807       }
 808     g_free (buffer);
 809   }
 810
 811 #else /* !HAVE_PWD_H */
 812
 813 #ifdef G_OS_WIN32
 814   {
 815     guint len = UNLEN+1;
 816     wchar_t buffer[UNLEN+1];
 817
 818     if (GetUserNameW (buffer, (LPDWORD) &len))
 819       {
 820         g_user_name = g_utf16_to_utf8 (buffer, -1, NULL, NULL, NULL);
 821         g_real_name = g_strdup (g_user_name);
 822       }
 823   }
 824 #endif /* G_OS_WIN32 */
 825
 826 #endif /* !HAVE_PWD_H */
 827
 828 #ifdef __EMX__
 829   /* change '\\' in %HOME% to '/' */
 830   g_strdelimit (g_home_dir, "\\",'/');
 831 #endif
 832   if (!g_user_name)
 833     g_user_name = g_strdup ("somebody");
 834   if (!g_real_name)
 835     g_real_name = g_strdup ("Unknown");
 836 }
 837
 838 static inline void
 839 g_get_any_init (void)
 840 {
 841   if (!g_user_name)
 842     g_get_any_init_do ();
 843 }
 844
 845 static inline void
 846 g_get_any_init_locked (void)
 847 {
 848   G_LOCK (g_utils_global);
 849   g_get_any_init ();
 850   G_UNLOCK (g_utils_global);
 851 }
 852
 853
 854 /**
 855  * g_get_user_name:
 856  *
 857  * Gets the user name of the current user. The encoding of the returned
 858  * string is system-defined. On UNIX, it might be the preferred file name
 859  * encoding, or something else, and there is no guarantee that it is even
 860  * consistent on a machine. On Windows, it is always UTF-8.
 861  *
 862  * Returns: the user name of the current user.
 863  */
 864 const gchar *
 865 g_get_user_name (void)
 866 {
 867   g_get_any_init_locked ();
 868   return g_user_name;
 869 }
 870
 871 /**
 872  * g_get_real_name:
 873  *
 874  * Gets the real name of the user. This usually comes from the user's entry
 875  * in the <filename>passwd</filename> file. The encoding of the returned
 876  * string is system-defined. (On Windows, it is, however, always UTF-8.)
 877  * If the real user name cannot be determined, the string "Unknown" is
 878  * returned.
 879  *
 880  * Returns: the user's real name.
 881  */
 882 const gchar *
 883 g_get_real_name (void)
 884 {
 885   g_get_any_init_locked ();
 886   return g_real_name;
 887 }
 888
 889 /**
 890  * g_get_home_dir:
 891  *
 892  * Gets the current user's home directory.
 893  *
 894  * As with most UNIX tools, this function will return the value of the
 895  * <envar>HOME</envar> environment variable if it is set to an existing
 896  * absolute path name, falling back to the <filename>passwd</filename>
 897  * file in the case that it is unset.
 898  *
 899  * If the path given in <envar>HOME</envar> is non-absolute, does not
 900  * exist, or is not a directory, the result is undefined.
 901  *
 902  * <note><para>
 903  *   Before version 2.36 this function would ignore the
 904  *   <envar>HOME</envar> environment variable, taking the value from the
 905  *   <filename>passwd</filename> database instead.  This was changed to
 906  *   increase the compatibility of GLib with other programs (and the XDG
 907  *   basedir specification) and to increase testability of programs
 908  *   based on GLib (by making it easier to run them from test
 909  *   frameworks).
 910  * </para><para>
 911  *   If your program has a strong requirement for either the new or the
 912  *   old behaviour (and if you don't wish to increase your GLib
 913  *   dependency to ensure that the new behaviour is in effect) then you
 914  *   should either directly check the <envar>HOME</envar> environment
 915  *   variable yourself or unset it before calling any functions in GLib.
 916  * </para></note>
 917  *
 918  * Returns: the current user's home directory
 919  */
 920 const gchar *
 921 g_get_home_dir (void)
 922 {
 923   g_get_any_init_locked ();
 924   return g_home_dir;
 925 }
 926
 927 /**
 928  * g_get_tmp_dir:
 929  *
 930  * Gets the directory to use for temporary files. This is found from
 931  * inspecting the environment variables <envar>TMPDIR</envar>,
 932  * <envar>TMP</envar>, and <envar>TEMP</envar> in that order. If none
 933  * of those are defined "/tmp" is returned on UNIX and "C:\" on Windows.
 934  * The encoding of the returned string is system-defined. On Windows,
 935  * it is always UTF-8. The return value is never %NULL or the empty string.
 936  *
 937  * Returns: the directory to use for temporary files.
 938  */
 939 const gchar *
 940 g_get_tmp_dir (void)
 941 {
 942   static gchar *tmp_dir;
 943
 944   if (g_once_init_enter (&tmp_dir))
 945     {
 946       gchar *tmp;
 947
 948       tmp = g_strdup (g_getenv ("TMPDIR"));
 949
 950       if (tmp == NULL || *tmp == '\0')
 951         {
 952           g_free (tmp);
 953           tmp = g_strdup (g_getenv ("TMP"));
 954         }
 955
 956       if (tmp == NULL || *tmp == '\0')
 957         {
 958           g_free (tmp);
 959           tmp = g_strdup (g_getenv ("TEMP"));
 960         }
 961
 962 #ifdef G_OS_WIN32
 963       if (tmp == NULL || *tmp == '\0')
 964         {
 965           g_free (tmp);
 966           tmp = get_windows_directory_root ();
 967         }
 968 #else
 969
 970 #ifdef P_tmpdir
 971       if (tmp == NULL || *tmp == '\0')
 972         {
 973           gsize k;
 974           g_free (tmp);
 975           tmp = g_strdup (P_tmpdir);
 976           k = strlen (tmp);
 977           if (k > 1 && G_IS_DIR_SEPARATOR (tmp[k - 1]))
 978             tmp[k - 1] = '\0';
 979         }
 980 #endif
 981
 982       if (tmp == NULL || *tmp == '\0')
 983         {
 984           g_free (tmp);
 985           tmp = g_strdup ("/tmp");
 986         }
 987 #endif /* !G_OS_WIN32 */
 988
 989       g_once_init_leave (&tmp_dir, tmp);
 990     }
 991
 992   return tmp_dir;
 993 }
 994
 995 /**
 996  * g_get_host_name:
 997  *
 998  * Return a name for the machine.
 999  *
1000  * The returned name is not necessarily a fully-qualified domain name,
1001  * or even present in DNS or some other name service at all. It need
1002  * not even be unique on your local network or site, but usually it
1003  * is. Callers should not rely on the return value having any specific
1004  * properties like uniqueness for security purposes. Even if the name
1005  * of the machine is changed while an application is running, the
1006  * return value from this function does not change. The returned
1007  * string is owned by GLib and should not be modified or freed. If no
1008  * name can be determined, a default fixed string "localhost" is
1009  * returned.
1010  *
1011  * Returns: the host name of the machine.
1012  *
1013  * Since: 2.8
1014  */
1015 const gchar *
1016 g_get_host_name (void)
1017 {
1018   static gchar *hostname;
1019
1020   if (g_once_init_enter (&hostname))
1021     {
1022       gboolean failed;
1023       gchar tmp[100];
1024
1025 #ifndef G_OS_WIN32
1026       failed = (gethostname (tmp, sizeof (tmp)) == -1);
1027 #else
1028       DWORD size = sizeof (tmp);
1029       failed = (!GetComputerName (tmp, &size));
1030 #endif
1031
1032       g_once_init_leave (&hostname, g_strdup (failed ? "localhost" : tmp));
1033     }
1034
1035   return hostname;
1036 }
1037
1038 G_LOCK_DEFINE_STATIC (g_prgname);
1039 static gchar *g_prgname = NULL;
1040
1041 /**
1042  * g_get_prgname:
1043  *
1044  * Gets the name of the program. This name should <emphasis>not</emphasis>
1045  * be localized, contrast with g_get_application_name().
1046  * (If you are using GDK or GTK+ the program name is set in gdk_init(),
1047  * which is called by gtk_init(). The program name is found by taking
1048  * the last component of <literal>argv[0]</literal>.)
1049  *
1050  * Returns: the name of the program. The returned string belongs
1051  * to GLib and must not be modified or freed.
1052  */
1053 const gchar*
1054 g_get_prgname (void)
1055 {
1056   gchar* retval;
1057
1058   G_LOCK (g_prgname);
1059 #ifdef G_OS_WIN32
1060   if (g_prgname == NULL)
1061     {
1062       static gboolean beenhere = FALSE;
1063
1064       if (!beenhere)
1065         {
1066           gchar *utf8_buf = NULL;
1067           wchar_t buf[MAX_PATH+1];
1068
1069           beenhere = TRUE;
1070           if (GetModuleFileNameW (GetModuleHandle (NULL),
1071                                   buf, G_N_ELEMENTS (buf)) > 0)
1072             utf8_buf = g_utf16_to_utf8 (buf, -1, NULL, NULL, NULL);
1073
1074           if (utf8_buf)
1075             {
1076               g_prgname = g_path_get_basename (utf8_buf);
1077               g_free (utf8_buf);
1078             }
1079         }
1080     }
1081 #endif
1082   retval = g_prgname;
1083   G_UNLOCK (g_prgname);
1084
1085   return retval;
1086 }
1087
1088 /**
1089  * g_set_prgname:
1090  * @prgname: the name of the program.
1091  *
1092  * Sets the name of the program. This name should <emphasis>not</emphasis>
1093  * be localized, contrast with g_set_application_name(). Note that for
1094  * thread-safety reasons this function can only be called once.
1095  */
1096 void
1097 g_set_prgname (const gchar *prgname)
1098 {
1099   G_LOCK (g_prgname);
1100   g_free (g_prgname);
1101   g_prgname = g_strdup (prgname);
1102   G_UNLOCK (g_prgname);
1103 }
1104
1105 G_LOCK_DEFINE_STATIC (g_application_name);
1106 static gchar *g_application_name = NULL;
1107
1108 /**
1109  * g_get_application_name:
1110  *
1111  * Gets a human-readable name for the application, as set by
1112  * g_set_application_name(). This name should be localized if
1113  * possible, and is intended for display to the user.  Contrast with
1114  * g_get_prgname(), which gets a non-localized name. If
1115  * g_set_application_name() has not been called, returns the result of
1116  * g_get_prgname() (which may be %NULL if g_set_prgname() has also not
1117  * been called).
1118  *
1119  * Return value: human-readable application name. may return %NULL
1120  *
1121  * Since: 2.2
1122  **/
1123 const gchar *
1124 g_get_application_name (void)
1125 {
1126   gchar* retval;
1127
1128   G_LOCK (g_application_name);
1129   retval = g_application_name;
1130   G_UNLOCK (g_application_name);
1131
1132   if (retval == NULL)
1133     return g_get_prgname ();
1134
1135   return retval;
1136 }
1137
1138 /**
1139  * g_set_application_name:
1140  * @application_name: localized name of the application
1141  *
1142  * Sets a human-readable name for the application. This name should be
1143  * localized if possible, and is intended for display to the user.
1144  * Contrast with g_set_prgname(), which sets a non-localized name.
1145  * g_set_prgname() will be called automatically by gtk_init(),
1146  * but g_set_application_name() will not.
1147  *
1148  * Note that for thread safety reasons, this function can only
1149  * be called once.
1150  *
1151  * The application name will be used in contexts such as error messages,
1152  * or when displaying an application's name in the task list.
1153  *
1154  * Since: 2.2
1155  **/
1156 void
1157 g_set_application_name (const gchar *application_name)
1158 {
1159   gboolean already_set = FALSE;
1160
1161   G_LOCK (g_application_name);
1162   if (g_application_name)
1163     already_set = TRUE;
1164   else
1165     g_application_name = g_strdup (application_name);
1166   G_UNLOCK (g_application_name);
1167
1168   if (already_set)
1169     g_warning ("g_set_application_name() called multiple times");
1170 }
1171
1172 /**
1173  * g_get_user_data_dir:
1174  *
1175  * Returns a base directory in which to access application data such
1176  * as icons that is customized for a particular user.
1177  *
1178  * On UNIX platforms this is determined using the mechanisms described in
1179  * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
1180  * XDG Base Directory Specification</ulink>.
1181  * In this case the directory retrieved will be XDG_DATA_HOME.
1182  *
1183  * On Windows this is the folder to use for local (as opposed to
1184  * roaming) application data. See documentation for
1185  * CSIDL_LOCAL_APPDATA. Note that on Windows it thus is the same as
1186  * what g_get_user_config_dir() returns.
1187  *
1188  * Return value: a string owned by GLib that must not be modified
1189  *               or freed.
1190  * Since: 2.6
1191  **/
1192 const gchar *
1193 g_get_user_data_dir (void)
1194 {
1195   gchar *data_dir;
1196
1197   G_LOCK (g_utils_global);
1198
1199   if (!g_user_data_dir)
1200     {
1201 #ifdef G_OS_WIN32
1202       data_dir = get_special_folder (CSIDL_LOCAL_APPDATA);
1203 #else
1204       data_dir = (gchar *) g_getenv ("XDG_DATA_HOME");
1205
1206       if (data_dir && data_dir[0])
1207         data_dir = g_strdup (data_dir);
1208 #endif
1209       if (!data_dir || !data_dir[0])
1210         {
1211           g_get_any_init ();
1212
1213           if (g_home_dir)
1214             data_dir = g_build_filename (g_home_dir, ".local",
1215                                          "share", NULL);
1216           else
1217             data_dir = g_build_filename (g_get_tmp_dir (), g_user_name, ".local", "share", NULL);
1218         }
1219
1220       g_user_data_dir = data_dir;
1221     }
1222   else
1223     data_dir = g_user_data_dir;
1224
1225   G_UNLOCK (g_utils_global);
1226
1227   return data_dir;
1228 }
1229
1230 static void
1231 g_init_user_config_dir (void)
1232 {
1233   gchar *config_dir;
1234
1235   if (!g_user_config_dir)
1236     {
1237 #ifdef G_OS_WIN32
1238       config_dir = get_special_folder (CSIDL_LOCAL_APPDATA);
1239 #else
1240       config_dir = (gchar *) g_getenv ("XDG_CONFIG_HOME");
1241
1242       if (config_dir && config_dir[0])
1243         config_dir = g_strdup (config_dir);
1244 #endif
1245       if (!config_dir || !config_dir[0])
1246         {
1247           g_get_any_init ();
1248
1249           if (g_home_dir)
1250             config_dir = g_build_filename (g_home_dir, ".config", NULL);
1251           else
1252             config_dir = g_build_filename (g_get_tmp_dir (), g_user_name, ".config", NULL);
1253         }
1254
1255       g_user_config_dir = config_dir;
1256     }
1257 }
1258
1259 /**
1260  * g_get_user_config_dir:
1261  *
1262  * Returns a base directory in which to store user-specific application
1263  * configuration information such as user preferences and settings.
1264  *
1265  * On UNIX platforms this is determined using the mechanisms described in
1266  * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
1267  * XDG Base Directory Specification</ulink>.
1268  * In this case the directory retrieved will be XDG_CONFIG_HOME.
1269  *
1270  * On Windows this is the folder to use for local (as opposed to
1271  * roaming) application data. See documentation for
1272  * CSIDL_LOCAL_APPDATA. Note that on Windows it thus is the same as
1273  * what g_get_user_data_dir() returns.
1274  *
1275  * Return value: a string owned by GLib that must not be modified
1276  *               or freed.
1277  * Since: 2.6
1278  **/
1279 const gchar *
1280 g_get_user_config_dir (void)
1281 {
1282   G_LOCK (g_utils_global);
1283
1284   g_init_user_config_dir ();
1285
1286   G_UNLOCK (g_utils_global);
1287
1288   return g_user_config_dir;
1289 }
1290
1291 /**
1292  * g_get_user_cache_dir:
1293  *
1294  * Returns a base directory in which to store non-essential, cached
1295  * data specific to particular user.
1296  *
1297  * On UNIX platforms this is determined using the mechanisms described in
1298  * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
1299  * XDG Base Directory Specification</ulink>.
1300  * In this case the directory retrieved will be XDG_CACHE_HOME.
1301  *
1302  * On Windows is the directory that serves as a common repository for
1303  * temporary Internet files. A typical path is
1304  * C:\Documents and Settings\username\Local Settings\Temporary Internet Files.
1305  * See documentation for CSIDL_INTERNET_CACHE.
1306  *
1307  * Return value: a string owned by GLib that must not be modified
1308  *               or freed.
1309  * Since: 2.6
1310  **/
1311 const gchar *
1312 g_get_user_cache_dir (void)
1313 {
1314   gchar *cache_dir;
1315
1316   G_LOCK (g_utils_global);
1317
1318   if (!g_user_cache_dir)
1319     {
1320 #ifdef G_OS_WIN32
1321       cache_dir = get_special_folder (CSIDL_INTERNET_CACHE); /* XXX correct? */
1322 #else
1323       cache_dir = (gchar *) g_getenv ("XDG_CACHE_HOME");
1324
1325       if (cache_dir && cache_dir[0])
1326           cache_dir = g_strdup (cache_dir);
1327 #endif
1328       if (!cache_dir || !cache_dir[0])
1329         {
1330           g_get_any_init ();
1331
1332           if (g_home_dir)
1333             cache_dir = g_build_filename (g_home_dir, ".cache", NULL);
1334           else
1335             cache_dir = g_build_filename (g_get_tmp_dir (), g_user_name, ".cache", NULL);
1336         }
1337       g_user_cache_dir = cache_dir;
1338     }
1339   else
1340     cache_dir = g_user_cache_dir;
1341
1342   G_UNLOCK (g_utils_global);
1343
1344   return cache_dir;
1345 }
1346
1347 /**
1348  * g_get_user_runtime_dir:
1349  *
1350  * Returns a directory that is unique to the current user on the local
1351  * system.
1352  *
1353  * On UNIX platforms this is determined using the mechanisms described in
1354  * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
1355  * XDG Base Directory Specification</ulink>.  This is the directory
1356  * specified in the <envar>XDG_RUNTIME_DIR</envar> environment variable.
1357  * In the case that this variable is not set, GLib will issue a warning
1358  * message to stderr and return the value of g_get_user_cache_dir().
1359  *
1360  * On Windows this is the folder to use for local (as opposed to
1361  * roaming) application data. See documentation for
1362  * CSIDL_LOCAL_APPDATA.  Note that on Windows it thus is the same as
1363  * what g_get_user_config_dir() returns.
1364  *
1365  * Returns: a string owned by GLib that must not be modified or freed.
1366  *
1367  * Since: 2.28
1368  **/
1369 const gchar *
1370 g_get_user_runtime_dir (void)
1371 {
1372 #ifndef G_OS_WIN32
1373   static const gchar *runtime_dir;
1374   static gsize initialised;
1375
1376   if (g_once_init_enter (&initialised))
1377     {
1378       runtime_dir = g_strdup (getenv ("XDG_RUNTIME_DIR"));
1379
1380       g_once_init_leave (&initialised, 1);
1381     }
1382
1383   if (runtime_dir)
1384     return runtime_dir;
1385
1386   /* Both fallback for UNIX and the default
1387    * in Windows: use the user cache directory.
1388    */
1389 #endif
1390
1391   return g_get_user_cache_dir ();
1392 }
1393
1394 #ifdef HAVE_CARBON
1395
1396 static gchar *
1397 find_folder (OSType type)
1398 {
1399   gchar *filename = NULL;
1400   FSRef  found;
1401
1402   if (FSFindFolder (kUserDomain, type, kDontCreateFolder, &found) == noErr)
1403     {
1404       CFURLRef url = CFURLCreateFromFSRef (kCFAllocatorSystemDefault, &found);
1405
1406       if (url)
1407         {
1408           CFStringRef path = CFURLCopyFileSystemPath (url, kCFURLPOSIXPathStyle);
1409
1410           if (path)
1411             {
1412               filename = g_strdup (CFStringGetCStringPtr (path, kCFStringEncodingUTF8));
1413
1414               if (! filename)
1415                 {
1416                   filename = g_new0 (gchar, CFStringGetLength (path) * 3 + 1);
1417
1418                   CFStringGetCString (path, filename,
1419                                       CFStringGetLength (path) * 3 + 1,
1420                                       kCFStringEncodingUTF8);
1421                 }
1422
1423               CFRelease (path);
1424             }
1425
1426           CFRelease (url);
1427         }
1428     }
1429
1430   return filename;
1431 }
1432
1433 static void
1434 load_user_special_dirs (void)
1435 {
1436   g_user_special_dirs[G_USER_DIRECTORY_DESKTOP] = find_folder (kDesktopFolderType);
1437   g_user_special_dirs[G_USER_DIRECTORY_DOCUMENTS] = find_folder (kDocumentsFolderType);
1438   g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = find_folder (kDesktopFolderType); /* XXX correct ? */
1439   g_user_special_dirs[G_USER_DIRECTORY_MUSIC] = find_folder (kMusicDocumentsFolderType);
1440   g_user_special_dirs[G_USER_DIRECTORY_PICTURES] = find_folder (kPictureDocumentsFolderType);
1441   g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = NULL;
1442   g_user_special_dirs[G_USER_DIRECTORY_TEMPLATES] = NULL;
1443   g_user_special_dirs[G_USER_DIRECTORY_VIDEOS] = find_folder (kMovieDocumentsFolderType);
1444 }
1445
1446 #endif /* HAVE_CARBON */
1447
1448 #if defined(G_OS_WIN32)
1449 static void
1450 load_user_special_dirs (void)
1451 {
1452   typedef HRESULT (WINAPI *t_SHGetKnownFolderPath) (const GUID *rfid,
1453                                                     DWORD dwFlags,
1454                                                     HANDLE hToken,
1455                                                     PWSTR *ppszPath);
1456   t_SHGetKnownFolderPath p_SHGetKnownFolderPath;
1457
1458   static const GUID FOLDERID_Downloads =
1459     { 0x374de290, 0x123f, 0x4565, { 0x91, 0x64, 0x39, 0xc4, 0x92, 0x5e, 0x46, 0x7b } };
1460   static const GUID FOLDERID_Public =
1461     { 0xDFDF76A2, 0xC82A, 0x4D63, { 0x90, 0x6A, 0x56, 0x44, 0xAC, 0x45, 0x73, 0x85 } };
1462
1463   wchar_t *wcp;
1464
1465   p_SHGetKnownFolderPath = (t_SHGetKnownFolderPath) GetProcAddress (GetModuleHandle ("shell32.dll"),
1466                                                                     "SHGetKnownFolderPath");
1467
1468   g_user_special_dirs[G_USER_DIRECTORY_DESKTOP] = get_special_folder (CSIDL_DESKTOPDIRECTORY);
1469   g_user_special_dirs[G_USER_DIRECTORY_DOCUMENTS] = get_special_folder (CSIDL_PERSONAL);
1470
1471   if (p_SHGetKnownFolderPath == NULL)
1472     {
1473       g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = get_special_folder (CSIDL_DESKTOPDIRECTORY);
1474     }
1475   else
1476     {
1477       wcp = NULL;
1478       (*p_SHGetKnownFolderPath) (&FOLDERID_Downloads, 0, NULL, &wcp);
1479       if (wcp)
1480         {
1481           g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = g_utf16_to_utf8 (wcp, -1, NULL, NULL, NULL);
1482           if (g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] == NULL)
1483               g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = get_special_folder (CSIDL_DESKTOPDIRECTORY);
1484           CoTaskMemFree (wcp);
1485         }
1486       else
1487           g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = get_special_folder (CSIDL_DESKTOPDIRECTORY);
1488     }
1489
1490   g_user_special_dirs[G_USER_DIRECTORY_MUSIC] = get_special_folder (CSIDL_MYMUSIC);
1491   g_user_special_dirs[G_USER_DIRECTORY_PICTURES] = get_special_folder (CSIDL_MYPICTURES);
1492
1493   if (p_SHGetKnownFolderPath == NULL)
1494     {
1495       /* XXX */
1496       g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = get_special_folder (CSIDL_COMMON_DOCUMENTS);
1497     }
1498   else
1499     {
1500       wcp = NULL;
1501       (*p_SHGetKnownFolderPath) (&FOLDERID_Public, 0, NULL, &wcp);
1502       if (wcp)
1503         {
1504           g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = g_utf16_to_utf8 (wcp, -1, NULL, NULL, NULL);
1505           if (g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] == NULL)
1506               g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = get_special_folder (CSIDL_COMMON_DOCUMENTS);
1507           CoTaskMemFree (wcp);
1508         }
1509       else
1510           g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = get_special_folder (CSIDL_COMMON_DOCUMENTS);
1511     }
1512
1513   g_user_special_dirs[G_USER_DIRECTORY_TEMPLATES] = get_special_folder (CSIDL_TEMPLATES);
1514   g_user_special_dirs[G_USER_DIRECTORY_VIDEOS] = get_special_folder (CSIDL_MYVIDEO);
1515 }
1516 #endif /* G_OS_WIN32 */
1517
1518 static void g_init_user_config_dir (void);
1519
1520 #if defined(G_OS_UNIX) && !defined(HAVE_CARBON)
1521
1522 /* adapted from xdg-user-dir-lookup.c
1523  *
1524  * Copyright (C) 2007 Red Hat Inc.
1525  *
1526  * Permission is hereby granted, free of charge, to any person
1527  * obtaining a copy of this software and associated documentation files
1528  * (the "Software"), to deal in the Software without restriction,
1529  * including without limitation the rights to use, copy, modify, merge,
1530  * publish, distribute, sublicense, and/or sell copies of the Software,
1531  * and to permit persons to whom the Software is furnished to do so,
1532  * subject to the following conditions:
1533  *
1534  * The above copyright notice and this permission notice shall be
1535  * included in all copies or substantial portions of the Software.
1536  *
1537  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
1538  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
1539  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
1540  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
1541  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
1542  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
1543  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
1544  * SOFTWARE.
1545  */
1546 static void
1547 load_user_special_dirs (void)
1548 {
1549   gchar *config_file;
1550   gchar *data;
1551   gchar **lines;
1552   gint n_lines, i;
1553
1554   g_init_user_config_dir ();
1555   config_file = g_build_filename (g_user_config_dir,
1556                                   "user-dirs.dirs",
1557                                   NULL);
1558
1559   if (!g_file_get_contents (config_file, &data, NULL, NULL))
1560     {
1561       g_free (config_file);
1562       return;
1563     }
1564
1565   lines = g_strsplit (data, "\n", -1);
1566   n_lines = g_strv_length (lines);
1567   g_free (data);
1568
1569   for (i = 0; i < n_lines; i++)
1570     {
1571       gchar *buffer = lines[i];
1572       gchar *d, *p;
1573       gint len;
1574       gboolean is_relative = FALSE;
1575       GUserDirectory directory;
1576
1577       /* Remove newline at end */
1578       len = strlen (buffer);
1579       if (len > 0 && buffer[len - 1] == '\n')
1580         buffer[len - 1] = 0;
1581
1582       p = buffer;
1583       while (*p == ' ' || *p == '\t')
1584         p++;
1585
1586       if (strncmp (p, "XDG_DESKTOP_DIR", strlen ("XDG_DESKTOP_DIR")) == 0)
1587         {
1588           directory = G_USER_DIRECTORY_DESKTOP;
1589           p += strlen ("XDG_DESKTOP_DIR");
1590         }
1591       else if (strncmp (p, "XDG_DOCUMENTS_DIR", strlen ("XDG_DOCUMENTS_DIR")) == 0)
1592         {
1593           directory = G_USER_DIRECTORY_DOCUMENTS;
1594           p += strlen ("XDG_DOCUMENTS_DIR");
1595         }
1596       else if (strncmp (p, "XDG_DOWNLOAD_DIR", strlen ("XDG_DOWNLOAD_DIR")) == 0)
1597         {
1598           directory = G_USER_DIRECTORY_DOWNLOAD;
1599           p += strlen ("XDG_DOWNLOAD_DIR");
1600         }
1601       else if (strncmp (p, "XDG_MUSIC_DIR", strlen ("XDG_MUSIC_DIR")) == 0)
1602         {
1603           directory = G_USER_DIRECTORY_MUSIC;
1604           p += strlen ("XDG_MUSIC_DIR");
1605         }
1606       else if (strncmp (p, "XDG_PICTURES_DIR", strlen ("XDG_PICTURES_DIR")) == 0)
1607         {
1608           directory = G_USER_DIRECTORY_PICTURES;
1609           p += strlen ("XDG_PICTURES_DIR");
1610         }
1611       else if (strncmp (p, "XDG_PUBLICSHARE_DIR", strlen ("XDG_PUBLICSHARE_DIR")) == 0)
1612         {
1613           directory = G_USER_DIRECTORY_PUBLIC_SHARE;
1614           p += strlen ("XDG_PUBLICSHARE_DIR");
1615         }
1616       else if (strncmp (p, "XDG_TEMPLATES_DIR", strlen ("XDG_TEMPLATES_DIR")) == 0)
1617         {
1618           directory = G_USER_DIRECTORY_TEMPLATES;
1619           p += strlen ("XDG_TEMPLATES_DIR");
1620         }
1621       else if (strncmp (p, "XDG_VIDEOS_DIR", strlen ("XDG_VIDEOS_DIR")) == 0)
1622         {
1623           directory = G_USER_DIRECTORY_VIDEOS;
1624           p += strlen ("XDG_VIDEOS_DIR");
1625         }
1626       else
1627         continue;
1628
1629       while (*p == ' ' || *p == '\t')
1630         p++;
1631
1632       if (*p != '=')
1633         continue;
1634       p++;
1635
1636       while (*p == ' ' || *p == '\t')
1637         p++;
1638
1639       if (*p != '"')
1640         continue;
1641       p++;
1642
1643       if (strncmp (p, "$HOME", 5) == 0)
1644         {
1645           p += 5;
1646           is_relative = TRUE;
1647         }
1648       else if (*p != '/')
1649         continue;
1650
1651       d = strrchr (p, '"');
1652       if (!d)
1653         continue;
1654       *d = 0;
1655
1656       d = p;
1657
1658       /* remove trailing slashes */
1659       len = strlen (d);
1660       if (d[len - 1] == '/')
1661         d[len - 1] = 0;
1662
1663       if (is_relative)
1664         {
1665           g_get_any_init ();
1666           g_user_special_dirs[directory] = g_build_filename (g_home_dir, d, NULL);
1667         }
1668       else
1669         g_user_special_dirs[directory] = g_strdup (d);
1670     }
1671
1672   g_strfreev (lines);
1673   g_free (config_file);
1674 }
1675
1676 #endif /* G_OS_UNIX && !HAVE_CARBON */
1677
1678
1679 /**
1680  * g_reload_user_special_dirs_cache:
1681  *
1682  * Resets the cache used for g_get_user_special_dir(), so
1683  * that the latest on-disk version is used. Call this only
1684  * if you just changed the data on disk yourself.
1685  *
1686  * Due to threadsafety issues this may cause leaking of strings
1687  * that were previously returned from g_get_user_special_dir()
1688  * that can't be freed. We ensure to only leak the data for
1689  * the directories that actually changed value though.
1690  *
1691  * Since: 2.22
1692  */
1693 void
1694 g_reload_user_special_dirs_cache (void)
1695 {
1696   int i;
1697
1698   G_LOCK (g_utils_global);
1699
1700   if (g_user_special_dirs != NULL)
1701     {
1702       /* save a copy of the pointer, to check if some memory can be preserved */
1703       char **old_g_user_special_dirs = g_user_special_dirs;
1704       char *old_val;
1705
1706       /* recreate and reload our cache */
1707       g_user_special_dirs = g_new0 (gchar *, G_USER_N_DIRECTORIES);
1708       load_user_special_dirs ();
1709
1710       /* only leak changed directories */
1711       for (i = 0; i < G_USER_N_DIRECTORIES; i++)
1712         {
1713           old_val = old_g_user_special_dirs[i];
1714           if (g_user_special_dirs[i] == NULL)
1715             {
1716               g_user_special_dirs[i] = old_val;
1717             }
1718           else if (g_strcmp0 (old_val, g_user_special_dirs[i]) == 0)
1719             {
1720               /* don't leak */
1721               g_free (g_user_special_dirs[i]);
1722               g_user_special_dirs[i] = old_val;
1723             }
1724           else
1725             g_free (old_val);
1726         }
1727
1728       /* free the old array */
1729       g_free (old_g_user_special_dirs);
1730     }
1731
1732   G_UNLOCK (g_utils_global);
1733 }
1734
1735 /**
1736  * g_get_user_special_dir:
1737  * @directory: the logical id of special directory
1738  *
1739  * Returns the full path of a special directory using its logical id.
1740  *
1741  * On Unix this is done using the XDG special user directories.
1742  * For compatibility with existing practise, %G_USER_DIRECTORY_DESKTOP
1743  * falls back to <filename>$HOME/Desktop</filename> when XDG special
1744  * user directories have not been set up.
1745  *
1746  * Depending on the platform, the user might be able to change the path
1747  * of the special directory without requiring the session to restart; GLib
1748  * will not reflect any change once the special directories are loaded.
1749  *
1750  * Return value: the path to the specified special directory, or %NULL
1751  *   if the logical id was not found. The returned string is owned by
1752  *   GLib and should not be modified or freed.
1753  *
1754  * Since: 2.14
1755  */
1756 const gchar *
1757 g_get_user_special_dir (GUserDirectory directory)
1758 {
1759   g_return_val_if_fail (directory >= G_USER_DIRECTORY_DESKTOP &&
1760                         directory < G_USER_N_DIRECTORIES, NULL);
1761
1762   G_LOCK (g_utils_global);
1763
1764   if (G_UNLIKELY (g_user_special_dirs == NULL))
1765     {
1766       g_user_special_dirs = g_new0 (gchar *, G_USER_N_DIRECTORIES);
1767
1768       load_user_special_dirs ();
1769
1770       /* Special-case desktop for historical compatibility */
1771       if (g_user_special_dirs[G_USER_DIRECTORY_DESKTOP] == NULL)
1772         {
1773           g_get_any_init ();
1774
1775           g_user_special_dirs[G_USER_DIRECTORY_DESKTOP] =
1776             g_build_filename (g_home_dir, "Desktop", NULL);
1777         }
1778     }
1779
1780   G_UNLOCK (g_utils_global);
1781
1782   return g_user_special_dirs[directory];
1783 }
1784
1785 #ifdef G_OS_WIN32
1786
1787 #undef g_get_system_data_dirs
1788
1789 static HMODULE
1790 get_module_for_address (gconstpointer address)
1791 {
1792   /* Holds the g_utils_global lock */
1793
1794   static gboolean beenhere = FALSE;
1795   typedef BOOL (WINAPI *t_GetModuleHandleExA) (DWORD, LPCTSTR, HMODULE *);
1796   static t_GetModuleHandleExA p_GetModuleHandleExA = NULL;
1797   HMODULE hmodule = NULL;
1798
1799   if (!address)
1800     return NULL;
1801
1802   if (!beenhere)
1803     {
1804       p_GetModuleHandleExA =
1805         (t_GetModuleHandleExA) GetProcAddress (GetModuleHandle ("kernel32.dll"),
1806                                                "GetModuleHandleExA");
1807       beenhere = TRUE;
1808     }
1809
1810   if (p_GetModuleHandleExA == NULL ||
1811       !(*p_GetModuleHandleExA) (GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT |
1812                                 GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
1813                                 address, &hmodule))
1814     {
1815       MEMORY_BASIC_INFORMATION mbi;
1816       VirtualQuery (address, &mbi, sizeof (mbi));
1817       hmodule = (HMODULE) mbi.AllocationBase;
1818     }
1819
1820   return hmodule;
1821 }
1822
1823 static gchar *
1824 get_module_share_dir (gconstpointer address)
1825 {
1826   HMODULE hmodule;
1827   gchar *filename;
1828   gchar *retval;
1829
1830   hmodule = get_module_for_address (address);
1831   if (hmodule == NULL)
1832     return NULL;
1833
1834   filename = g_win32_get_package_installation_directory_of_module (hmodule);
1835   retval = g_build_filename (filename, "share", NULL);
1836   g_free (filename);
1837
1838   return retval;
1839 }
1840
1841 const gchar * const *
1842 g_win32_get_system_data_dirs_for_module (void (*address_of_function)(void))
1843 {
1844   GArray *data_dirs;
1845   HMODULE hmodule;
1846   static GHashTable *per_module_data_dirs = NULL;
1847   gchar **retval;
1848   gchar *p;
1849   gchar *exe_root;
1850
1851   if (address_of_function)
1852     {
1853       G_LOCK (g_utils_global);
1854       hmodule = get_module_for_address (address_of_function);
1855       if (hmodule != NULL)
1856         {
1857           if (per_module_data_dirs == NULL)
1858             per_module_data_dirs = g_hash_table_new (NULL, NULL);
1859           else
1860             {
1861               retval = g_hash_table_lookup (per_module_data_dirs, hmodule);
1862
1863               if (retval != NULL)
1864                 {
1865                   G_UNLOCK (g_utils_global);
1866                   return (const gchar * const *) retval;
1867                 }
1868             }
1869         }
1870     }
1871
1872   data_dirs = g_array_new (TRUE, TRUE, sizeof (char *));
1873
1874   /* Documents and Settings\All Users\Application Data */
1875   p = get_special_folder (CSIDL_COMMON_APPDATA);
1876   if (p)
1877     g_array_append_val (data_dirs, p);
1878
1879   /* Documents and Settings\All Users\Documents */
1880   p = get_special_folder (CSIDL_COMMON_DOCUMENTS);
1881   if (p)
1882     g_array_append_val (data_dirs, p);
1883
1884   /* Using the above subfolders of Documents and Settings perhaps
1885    * makes sense from a Windows perspective.
1886    *
1887    * But looking at the actual use cases of this function in GTK+
1888    * and GNOME software, what we really want is the "share"
1889    * subdirectory of the installation directory for the package
1890    * our caller is a part of.
1891    *
1892    * The address_of_function parameter, if non-NULL, points to a
1893    * function in the calling module. Use that to determine that
1894    * module's installation folder, and use its "share" subfolder.
1895    *
1896    * Additionally, also use the "share" subfolder of the installation
1897    * locations of GLib and the .exe file being run.
1898    *
1899    * To guard against none of the above being what is really wanted,
1900    * callers of this function should have Win32-specific code to look
1901    * up their installation folder themselves, and handle a subfolder
1902    * "share" of it in the same way as the folders returned from this
1903    * function.
1904    */
1905
1906   p = get_module_share_dir (address_of_function);
1907   if (p)
1908     g_array_append_val (data_dirs, p);
1909
1910   if (glib_dll != NULL)
1911     {
1912       gchar *glib_root = g_win32_get_package_installation_directory_of_module (glib_dll);
1913       p = g_build_filename (glib_root, "share", NULL);
1914       if (p)
1915         g_array_append_val (data_dirs, p);
1916       g_free (glib_root);
1917     }
1918
1919   exe_root = g_win32_get_package_installation_directory_of_module (NULL);
1920   p = g_build_filename (exe_root, "share", NULL);
1921   if (p)
1922     g_array_append_val (data_dirs, p);
1923   g_free (exe_root);
1924
1925   retval = (gchar **) g_array_free (data_dirs, FALSE);
1926
1927   if (address_of_function)
1928     {
1929       if (hmodule != NULL)
1930         g_hash_table_insert (per_module_data_dirs, hmodule, retval);
1931       G_UNLOCK (g_utils_global);
1932     }
1933
1934   return (const gchar * const *) retval;
1935 }
1936
1937 #endif
1938
1939 /**
1940  * g_get_system_data_dirs:
1941  *
1942  * Returns an ordered list of base directories in which to access
1943  * system-wide application data.
1944  *
1945  * On UNIX platforms this is determined using the mechanisms described in
1946  * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
1947  * XDG Base Directory Specification</ulink>
1948  * In this case the list of directories retrieved will be XDG_DATA_DIRS.
1949  *
1950  * On Windows the first elements in the list are the Application Data
1951  * and Documents folders for All Users. (These can be determined only
1952  * on Windows 2000 or later and are not present in the list on other
1953  * Windows versions.) See documentation for CSIDL_COMMON_APPDATA and
1954  * CSIDL_COMMON_DOCUMENTS.
1955  *
1956  * Then follows the "share" subfolder in the installation folder for
1957  * the package containing the DLL that calls this function, if it can
1958  * be determined.
1959  *
1960  * Finally the list contains the "share" subfolder in the installation
1961  * folder for GLib, and in the installation folder for the package the
1962  * application's .exe file belongs to.
1963  *
1964  * The installation folders above are determined by looking up the
1965  * folder where the module (DLL or EXE) in question is located. If the
1966  * folder's name is "bin", its parent is used, otherwise the folder
1967  * itself.
1968  *
1969  * Note that on Windows the returned list can vary depending on where
1970  * this function is called.
1971  *
1972  * Return value: (array zero-terminated=1) (transfer none): a %NULL-terminated array of strings owned by GLib that must
1973  *               not be modified or freed.
1974  * Since: 2.6
1975  **/
1976 const gchar * const *
1977 g_get_system_data_dirs (void)
1978 {
1979   gchar **data_dir_vector;
1980
1981   G_LOCK (g_utils_global);
1982
1983   if (!g_system_data_dirs)
1984     {
1985 #ifdef G_OS_WIN32
1986       data_dir_vector = (gchar **) g_win32_get_system_data_dirs_for_module (NULL);
1987 #else
1988       gchar *data_dirs = (gchar *) g_getenv ("XDG_DATA_DIRS");
1989
1990       if (!data_dirs || !data_dirs[0])
1991           data_dirs = "/usr/local/share/:/usr/share/";
1992
1993       data_dir_vector = g_strsplit (data_dirs, G_SEARCHPATH_SEPARATOR_S, 0);
1994 #endif
1995
1996       g_system_data_dirs = data_dir_vector;
1997     }
1998   else
1999     data_dir_vector = g_system_data_dirs;
2000
2001   G_UNLOCK (g_utils_global);
2002
2003   return (const gchar * const *) data_dir_vector;
2004 }
2005
2006 /**
2007  * g_get_system_config_dirs:
2008  *
2009  * Returns an ordered list of base directories in which to access
2010  * system-wide configuration information.
2011  *
2012  * On UNIX platforms this is determined using the mechanisms described in
2013  * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
2014  * XDG Base Directory Specification</ulink>.
2015  * In this case the list of directories retrieved will be XDG_CONFIG_DIRS.
2016  *
2017  * On Windows is the directory that contains application data for all users.
2018  * A typical path is C:\Documents and Settings\All Users\Application Data.
2019  * This folder is used for application data that is not user specific.
2020  * For example, an application can store a spell-check dictionary, a database
2021  * of clip art, or a log file in the CSIDL_COMMON_APPDATA folder.
2022  * This information will not roam and is available to anyone using the computer.
2023  *
2024  * Return value: (array zero-terminated=1) (transfer none): a %NULL-terminated array of strings owned by GLib that must
2025  *               not be modified or freed.
2026  * Since: 2.6
2027  **/
2028 const gchar * const *
2029 g_get_system_config_dirs (void)
2030 {
2031   gchar *conf_dirs, **conf_dir_vector;
2032
2033   G_LOCK (g_utils_global);
2034
2035   if (!g_system_config_dirs)
2036     {
2037 #ifdef G_OS_WIN32
2038       conf_dirs = get_special_folder (CSIDL_COMMON_APPDATA);
2039       if (conf_dirs)
2040         {
2041           conf_dir_vector = g_strsplit (conf_dirs, G_SEARCHPATH_SEPARATOR_S, 0);
2042           g_free (conf_dirs);
2043         }
2044       else
2045         {
2046           /* Return empty list */
2047           conf_dir_vector = g_strsplit ("", G_SEARCHPATH_SEPARATOR_S, 0);
2048         }
2049 #else
2050       conf_dirs = (gchar *) g_getenv ("XDG_CONFIG_DIRS");
2051
2052       if (!conf_dirs || !conf_dirs[0])
2053           conf_dirs = "/etc/xdg";
2054
2055       conf_dir_vector = g_strsplit (conf_dirs, G_SEARCHPATH_SEPARATOR_S, 0);
2056 #endif
2057
2058       g_system_config_dirs = conf_dir_vector;
2059     }
2060   else
2061     conf_dir_vector = g_system_config_dirs;
2062   G_UNLOCK (g_utils_global);
2063
2064   return (const gchar * const *) conf_dir_vector;
2065 }
2066
2067 /**
2068  * g_nullify_pointer:
2069  * @nullify_location: the memory address of the pointer.
2070  *
2071  * Set the pointer at the specified location to %NULL.
2072  **/
2073 void
2074 g_nullify_pointer (gpointer *nullify_location)
2075 {
2076   g_return_if_fail (nullify_location != NULL);
2077
2078   *nullify_location = NULL;
2079 }
2080
2081 #define KILOBYTE_FACTOR (G_GOFFSET_CONSTANT (1000))
2082 #define MEGABYTE_FACTOR (KILOBYTE_FACTOR * KILOBYTE_FACTOR)
2083 #define GIGABYTE_FACTOR (MEGABYTE_FACTOR * KILOBYTE_FACTOR)
2084 #define TERABYTE_FACTOR (GIGABYTE_FACTOR * KILOBYTE_FACTOR)
2085 #define PETABYTE_FACTOR (TERABYTE_FACTOR * KILOBYTE_FACTOR)
2086 #define EXABYTE_FACTOR  (PETABYTE_FACTOR * KILOBYTE_FACTOR)
2087
2088 #define KIBIBYTE_FACTOR (G_GOFFSET_CONSTANT (1024))
2089 #define MEBIBYTE_FACTOR (KIBIBYTE_FACTOR * KIBIBYTE_FACTOR)
2090 #define GIBIBYTE_FACTOR (MEBIBYTE_FACTOR * KIBIBYTE_FACTOR)
2091 #define TEBIBYTE_FACTOR (GIBIBYTE_FACTOR * KIBIBYTE_FACTOR)
2092 #define PEBIBYTE_FACTOR (TEBIBYTE_FACTOR * KIBIBYTE_FACTOR)
2093 #define EXBIBYTE_FACTOR (PEBIBYTE_FACTOR * KIBIBYTE_FACTOR)
2094
2095 /**
2096  * g_format_size:
2097  * @size: a size in bytes
2098  *
2099  * Formats a size (for example the size of a file) into a human readable
2100  * string.  Sizes are rounded to the nearest size prefix (kB, MB, GB)
2101  * and are displayed rounded to the nearest tenth. E.g. the file size
2102  * 3292528 bytes will be converted into the string "3.2 MB".
2103  *
2104  * The prefix units base is 1000 (i.e. 1 kB is 1000 bytes).
2105  *
2106  * This string should be freed with g_free() when not needed any longer.
2107  *
2108  * See g_format_size_full() for more options about how the size might be
2109  * formatted.
2110  *
2111  * Returns: a newly-allocated formatted string containing a human readable
2112  *     file size
2113  *
2114  * Since: 2.30
2115  */
2116 gchar *
2117 g_format_size (guint64 size)
2118 {
2119   return g_format_size_full (size, G_FORMAT_SIZE_DEFAULT);
2120 }
2121
2122 /**
2123  * GFormatSizeFlags:
2124  * @G_FORMAT_SIZE_DEFAULT: behave the same as g_format_size()
2125  * @G_FORMAT_SIZE_LONG_FORMAT: include the exact number of bytes as part
2126  *     of the returned string.  For example, "45.6 kB (45,612 bytes)".
2127  * @G_FORMAT_SIZE_IEC_UNITS: use IEC (base 1024) units with "KiB"-style
2128  *     suffixes. IEC units should only be used for reporting things with
2129  *     a strong "power of 2" basis, like RAM sizes or RAID stripe sizes.
2130  *     Network and storage sizes should be reported in the normal SI units.
2131  *
2132  * Flags to modify the format of the string returned by g_format_size_full().
2133  */
2134
2135 /**
2136  * g_format_size_full:
2137  * @size: a size in bytes
2138  * @flags: #GFormatSizeFlags to modify the output
2139  *
2140  * Formats a size.
2141  *
2142  * This function is similar to g_format_size() but allows for flags
2143  * that modify the output. See #GFormatSizeFlags.
2144  *
2145  * Returns: a newly-allocated formatted string containing a human
2146  *     readable file size
2147  *
2148  * Since: 2.30
2149  */
2150 gchar *
2151 g_format_size_full (guint64          size,
2152                     GFormatSizeFlags flags)
2153 {
2154   GString *string;
2155
2156   string = g_string_new (NULL);
2157
2158   if (flags & G_FORMAT_SIZE_IEC_UNITS)
2159     {
2160       if (size < KIBIBYTE_FACTOR)
2161         {
2162           g_string_printf (string,
2163                            g_dngettext(GETTEXT_PACKAGE, "%u byte", "%u bytes", (guint) size),
2164                            (guint) size);
2165           flags &= ~G_FORMAT_SIZE_LONG_FORMAT;
2166         }
2167
2168       else if (size < MEBIBYTE_FACTOR)
2169         g_string_printf (string, _("%.1f KiB"), (gdouble) size / (gdouble) KIBIBYTE_FACTOR);
2170       else if (size < GIBIBYTE_FACTOR)
2171         g_string_printf (string, _("%.1f MiB"), (gdouble) size / (gdouble) MEBIBYTE_FACTOR);
2172
2173       else if (size < TEBIBYTE_FACTOR)
2174         g_string_printf (string, _("%.1f GiB"), (gdouble) size / (gdouble) GIBIBYTE_FACTOR);
2175
2176       else if (size < PEBIBYTE_FACTOR)
2177         g_string_printf (string, _("%.1f TiB"), (gdouble) size / (gdouble) TEBIBYTE_FACTOR);
2178
2179       else if (size < EXBIBYTE_FACTOR)
2180         g_string_printf (string, _("%.1f PiB"), (gdouble) size / (gdouble) PEBIBYTE_FACTOR);
2181
2182       else
2183         g_string_printf (string, _("%.1f EiB"), (gdouble) size / (gdouble) EXBIBYTE_FACTOR);
2184     }
2185   else
2186     {
2187       if (size < KILOBYTE_FACTOR)
2188         {
2189           g_string_printf (string,
2190                            g_dngettext(GETTEXT_PACKAGE, "%u byte", "%u bytes", (guint) size),
2191                            (guint) size);
2192           flags &= ~G_FORMAT_SIZE_LONG_FORMAT;
2193         }
2194
2195       else if (size < MEGABYTE_FACTOR)
2196         g_string_printf (string, _("%.1f kB"), (gdouble) size / (gdouble) KILOBYTE_FACTOR);
2197
2198       else if (size < GIGABYTE_FACTOR)
2199         g_string_printf (string, _("%.1f MB"), (gdouble) size / (gdouble) MEGABYTE_FACTOR);
2200
2201       else if (size < TERABYTE_FACTOR)
2202         g_string_printf (string, _("%.1f GB"), (gdouble) size / (gdouble) GIGABYTE_FACTOR);
2203       else if (size < PETABYTE_FACTOR)
2204         g_string_printf (string, _("%.1f TB"), (gdouble) size / (gdouble) TERABYTE_FACTOR);
2205
2206       else if (size < EXABYTE_FACTOR)
2207         g_string_printf (string, _("%.1f PB"), (gdouble) size / (gdouble) PETABYTE_FACTOR);
2208
2209       else
2210         g_string_printf (string, _("%.1f EB"), (gdouble) size / (gdouble) EXABYTE_FACTOR);
2211     }
2212
2213   if (flags & G_FORMAT_SIZE_LONG_FORMAT)
2214     {
2215       /* First problem: we need to use the number of bytes to decide on
2216        * the plural form that is used for display, but the number of
2217        * bytes potentially exceeds the size of a guint (which is what
2218        * ngettext() takes).
2219        *
2220        * From a pragmatic standpoint, it seems that all known languages
2221        * base plural forms on one or both of the following:
2222        *
2223        *   - the lowest digits of the number
2224        *
2225        *   - if the number if greater than some small value
2226        *
2227        * Here's how we fake it:  Draw an arbitrary line at one thousand.
2228        * If the number is below that, then fine.  If it is above it,
2229        * then we take the modulus of the number by one thousand (in
2230        * order to keep the lowest digits) and add one thousand to that
2231        * (in order to ensure that 1001 is not treated the same as 1).
2232        */
2233       guint plural_form = size < 1000 ? size : size % 1000 + 1000;
2234
2235       /* Second problem: we need to translate the string "%u byte" and
2236        * "%u bytes" for pluralisation, but the correct number format to
2237        * use for a gsize is different depending on which architecture
2238        * we're on.
2239        *
2240        * Solution: format the number separately and use "%s bytes" on
2241        * all platforms.
2242        */
2243       const gchar *translated_format;
2244       gchar *formatted_number;
2245
2246       /* Translators: the %s in "%s bytes" will always be replaced by a number. */
2247       translated_format = g_dngettext(GETTEXT_PACKAGE, "%s byte", "%s bytes", plural_form);
2248       /* XXX: Windows doesn't support the "'" format modifier, so we
2249        * must not use it there.  Instead, just display the number
2250        * without separation.  Bug #655336 is open until a solution is
2251        * found.
2252        */
2253 #ifndef G_OS_WIN32
2254       formatted_number = g_strdup_printf ("%'"G_GUINT64_FORMAT, size);
2255 #else
2256       formatted_number = g_strdup_printf ("%"G_GUINT64_FORMAT, size);
2257 #endif
2258
2259       g_string_append (string, " (");
2260       g_string_append_printf (string, translated_format, formatted_number);
2261       g_free (formatted_number);
2262       g_string_append (string, ")");
2263     }
2264
2265   return g_string_free (string, FALSE);
2266 }
2267
2268 /**
2269  * g_format_size_for_display:
2270  * @size: a size in bytes
2271  *
2272  * Formats a size (for example the size of a file) into a human
2273  * readable string. Sizes are rounded to the nearest size prefix
2274  * (KB, MB, GB) and are displayed rounded to the nearest tenth.
2275  * E.g. the file size 3292528 bytes will be converted into the
2276  * string "3.1 MB".
2277  *
2278  * The prefix units base is 1024 (i.e. 1 KB is 1024 bytes).
2279  *
2280  * This string should be freed with g_free() when not needed any longer.
2281  *
2282  * Returns: a newly-allocated formatted string containing a human
2283  *     readable file size
2284  *
2285  * Since: 2.16
2286  *
2287  * Deprecated:2.30: This function is broken due to its use of SI
2288  *     suffixes to denote IEC units. Use g_format_size() instead.
2289  */
2290 gchar *
2291 g_format_size_for_display (goffset size)
2292 {
2293   if (size < (goffset) KIBIBYTE_FACTOR)
2294     return g_strdup_printf (g_dngettext(GETTEXT_PACKAGE, "%u byte", "%u bytes",(guint) size), (guint) size);
2295   else
2296     {
2297       gdouble displayed_size;
2298
2299       if (size < (goffset) MEBIBYTE_FACTOR)
2300         {
2301           displayed_size = (gdouble) size / (gdouble) KIBIBYTE_FACTOR;
2302           /* Translators: this is from the deprecated function g_format_size_for_display() which uses 'KB' to
2303            * mean 1024 bytes.  I am aware that 'KB' is not correct, but it has been preserved for reasons of
2304            * compatibility.  Users will not see this string unless a program is using this deprecated function.
2305            * Please translate as literally as possible.
2306            */
2307           return g_strdup_printf (_("%.1f KB"), displayed_size);
2308         }
2309       else if (size < (goffset) GIBIBYTE_FACTOR)
2310         {
2311           displayed_size = (gdouble) size / (gdouble) MEBIBYTE_FACTOR;
2312           return g_strdup_printf (_("%.1f MB"), displayed_size);
2313         }
2314       else if (size < (goffset) TEBIBYTE_FACTOR)
2315         {
2316           displayed_size = (gdouble) size / (gdouble) GIBIBYTE_FACTOR;
2317           return g_strdup_printf (_("%.1f GB"), displayed_size);
2318         }
2319       else if (size < (goffset) PEBIBYTE_FACTOR)
2320         {
2321           displayed_size = (gdouble) size / (gdouble) TEBIBYTE_FACTOR;
2322           return g_strdup_printf (_("%.1f TB"), displayed_size);
2323         }
2324       else if (size < (goffset) EXBIBYTE_FACTOR)
2325         {
2326           displayed_size = (gdouble) size / (gdouble) PEBIBYTE_FACTOR;
2327           return g_strdup_printf (_("%.1f PB"), displayed_size);
2328         }
2329       else
2330         {
2331           displayed_size = (gdouble) size / (gdouble) EXBIBYTE_FACTOR;
2332           return g_strdup_printf (_("%.1f EB"), displayed_size);
2333         }
2334     }
2335 }
2336
2337 #if defined (G_OS_WIN32) && !defined (_WIN64)
2338
2339 /* Binary compatibility versions. Not for newly compiled code. */
2340
2341 _GLIB_EXTERN const gchar *g_get_user_name_utf8        (void);
2342 _GLIB_EXTERN const gchar *g_get_real_name_utf8        (void);
2343 _GLIB_EXTERN const gchar *g_get_home_dir_utf8         (void);
2344 _GLIB_EXTERN const gchar *g_get_tmp_dir_utf8          (void);
2345 _GLIB_EXTERN gchar       *g_find_program_in_path_utf8 (const gchar *program);
2346
2347 gchar *
2348 g_find_program_in_path_utf8 (const gchar *program)
2349 {
2350   return g_find_program_in_path (program);
2351 }
2352
2353 const gchar *g_get_user_name_utf8 (void) { return g_get_user_name (); }
2354 const gchar *g_get_real_name_utf8 (void) { return g_get_real_name (); }
2355 const gchar *g_get_home_dir_utf8 (void) { return g_get_home_dir (); }
2356 const gchar *g_get_tmp_dir_utf8 (void) { return g_get_tmp_dir (); }
2357
2358 #endif
2359
2360 /* Private API:
2361  *
2362  * Returns %TRUE if the current process was executed as setuid (or an
2363  * equivalent __libc_enable_secure is available).  See:
2364  * http://osdir.com/ml/linux.lfs.hardened/2007-04/msg00032.html
2365  */
2366 gboolean
2367 g_check_setuid (void)
2368 {
2369   /* TODO: get __libc_enable_secure exported from glibc.
2370    * See http://www.openwall.com/lists/owl-dev/2012/08/14/1
2371    */
2372 #if 0 && defined(HAVE_LIBC_ENABLE_SECURE)
2373   {
2374     /* See glibc/include/unistd.h */
2375     extern int __libc_enable_secure;
2376     return __libc_enable_secure;
2377   }
2378 #elif defined(HAVE_ISSETUGID)
2379   /* BSD: http://www.freebsd.org/cgi/man.cgi?query=issetugid&sektion=2 */
2380   return issetugid ();
2381 #elif defined(G_OS_UNIX)
2382   uid_t ruid, euid, suid; /* Real, effective and saved user ID's */
2383   gid_t rgid, egid, sgid; /* Real, effective and saved group ID's */
2384
2385   static gsize check_setuid_initialised;
2386   static gboolean is_setuid;
2387
2388   if (g_once_init_enter (&check_setuid_initialised))
2389     {
2390 #ifdef HAVE_GETRESUID
2391       /* These aren't in the header files, so we prototype them here.
2392        */
2393       int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid);
2394       int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid);
2395
2396       if (getresuid (&ruid, &euid, &suid) != 0 ||
2397           getresgid (&rgid, &egid, &sgid) != 0)
2398 #endif /* HAVE_GETRESUID */
2399         {
2400           suid = ruid = getuid ();
2401           sgid = rgid = getgid ();
2402           euid = geteuid ();
2403           egid = getegid ();
2404         }
2405
2406       is_setuid = (ruid != euid || ruid != suid ||
2407                    rgid != egid || rgid != sgid);
2408
2409       g_once_init_leave (&check_setuid_initialised, 1);
2410     }
2411   return is_setuid;
2412 #else
2413   return FALSE;
2414 #endif
2415 }