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 "glib.h"
  61 #include "gprintfint.h"
  62 #include "gthreadprivate.h"
  63 #include "glibintl.h"
  64 #include "galias.h"
  65
  66 #ifdef  MAXPATHLEN
  67 #define G_PATH_LENGTH   MAXPATHLEN
  68 #elif   defined (PATH_MAX)
  69 #define G_PATH_LENGTH   PATH_MAX
  70 #elif   defined (_PC_PATH_MAX)
  71 #define G_PATH_LENGTH   sysconf(_PC_PATH_MAX)
  72 #else
  73 #define G_PATH_LENGTH   2048
  74 #endif
  75
  76 #ifdef G_PLATFORM_WIN32
  77 #  define STRICT                /* Strict typing, please */
  78 #  include <windows.h>
  79 #  undef STRICT
  80 #  ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
  81 #    define GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT 2
  82 #    define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS 4
  83 #  endif
  84 #  include <lmcons.h>           /* For UNLEN */
  85 #endif /* G_PLATFORM_WIN32 */
  86
  87 #ifdef G_OS_WIN32
  88 #  include <direct.h>
  89 #  include <shlobj.h>
  90    /* older SDK (e.g. msvc 5.0) does not have these*/
  91 #  ifndef CSIDL_MYMUSIC
  92 #    define CSIDL_MYMUSIC 13
  93 #  endif
  94 #  ifndef CSIDL_MYVIDEO
  95 #    define CSIDL_MYVIDEO 14
  96 #  endif
  97 #  ifndef CSIDL_INTERNET_CACHE
  98 #    define CSIDL_INTERNET_CACHE 32
  99 #  endif
 100 #  ifndef CSIDL_COMMON_APPDATA
 101 #    define CSIDL_COMMON_APPDATA 35
 102 #  endif
 103 #  ifndef CSIDL_MYPICTURES
 104 #    define CSIDL_MYPICTURES 0x27
 105 #  endif
 106 #  ifndef CSIDL_COMMON_DOCUMENTS
 107 #    define CSIDL_COMMON_DOCUMENTS 46
 108 #  endif
 109 #  ifndef CSIDL_PROFILE
 110 #    define CSIDL_PROFILE 40
 111 #  endif
 112 #  include <process.h>
 113 #endif
 114
 115 #ifdef HAVE_CARBON
 116 #include <CoreServices/CoreServices.h>
 117 #endif
 118
 119 #ifdef HAVE_CODESET
 120 #include <langinfo.h>
 121 #endif
 122
 123 const guint glib_major_version = GLIB_MAJOR_VERSION;
 124 const guint glib_minor_version = GLIB_MINOR_VERSION;
 125 const guint glib_micro_version = GLIB_MICRO_VERSION;
 126 const guint glib_interface_age = GLIB_INTERFACE_AGE;
 127 const guint glib_binary_age = GLIB_BINARY_AGE;
 128
 129 #ifdef G_PLATFORM_WIN32
 130
 131 static HMODULE glib_dll = NULL;
 132
 133 #ifdef DLL_EXPORT
 134
 135 BOOL WINAPI
 136 DllMain (HINSTANCE hinstDLL,
 137          DWORD     fdwReason,
 138          LPVOID    lpvReserved)
 139 {
 140   if (fdwReason == DLL_PROCESS_ATTACH)
 141       glib_dll = hinstDLL;
 142
 143   return TRUE;
 144 }
 145
 146 #endif
 147
 148 gchar *
 149 _glib_get_dll_directory (void)
 150 {
 151   gchar *retval;
 152   gchar *p;
 153   wchar_t wc_fn[MAX_PATH];
 154
 155 #ifdef DLL_EXPORT
 156   if (glib_dll == NULL)
 157     return NULL;
 158 #endif
 159
 160   /* This code is different from that in
 161    * g_win32_get_package_installation_directory_of_module() in that
 162    * here we return the actual folder where the GLib DLL is. We don't
 163    * do the check for it being in a "bin" or "lib" subfolder and then
 164    * returning the parent of that.
 165    *
 166    * In a statically built GLib, glib_dll will be NULL and we will
 167    * thus look up the application's .exe file's location.
 168    */
 169   if (!GetModuleFileNameW (glib_dll, wc_fn, MAX_PATH))
 170     return NULL;
 171
 172   retval = g_utf16_to_utf8 (wc_fn, -1, NULL, NULL, NULL);
 173
 174   p = strrchr (retval, G_DIR_SEPARATOR);
 175   if (p == NULL)
 176     {
 177       /* Wtf? */
 178       return NULL;
 179     }
 180   *p = '\0';
 181
 182   return retval;
 183 }
 184
 185 #endif
 186
 187 /**
 188  * glib_check_version:
 189  * @required_major: the required major version.
 190  * @required_minor: the required minor version.
 191  * @required_micro: the required micro version.
 192  *
 193  * Checks that the GLib library in use is compatible with the
 194  * given version. Generally you would pass in the constants
 195  * #GLIB_MAJOR_VERSION, #GLIB_MINOR_VERSION, #GLIB_MICRO_VERSION
 196  * as the three arguments to this function; that produces
 197  * a check that the library in use is compatible with
 198  * the version of GLib the application or module was compiled
 199  * against.
 200  *
 201  * Compatibility is defined by two things: first the version
 202  * of the running library is newer than the version
 203  * @required_major.required_minor.@required_micro. Second
 204  * the running library must be binary compatible with the
 205  * version @required_major.required_minor.@required_micro
 206  * (same major version.)
 207  *
 208  * Return value: %NULL if the GLib library is compatible with the
 209  *   given version, or a string describing the version mismatch.
 210  *   The returned string is owned by GLib and must not be modified
 211  *   or freed.
 212  *
 213  * Since: 2.6
 214  **/
 215 const gchar *
 216 glib_check_version (guint required_major,
 217                     guint required_minor,
 218                     guint required_micro)
 219 {
 220   gint glib_effective_micro = 100 * GLIB_MINOR_VERSION + GLIB_MICRO_VERSION;
 221   gint required_effective_micro = 100 * required_minor + required_micro;
 222
 223   if (required_major > GLIB_MAJOR_VERSION)
 224     return "GLib version too old (major mismatch)";
 225   if (required_major < GLIB_MAJOR_VERSION)
 226     return "GLib version too new (major mismatch)";
 227   if (required_effective_micro < glib_effective_micro - GLIB_BINARY_AGE)
 228     return "GLib version too new (micro mismatch)";
 229   if (required_effective_micro > glib_effective_micro)
 230     return "GLib version too old (micro mismatch)";
 231   return NULL;
 232 }
 233
 234 #if !defined (HAVE_MEMMOVE) && !defined (HAVE_WORKING_BCOPY)
 235 /**
 236  * g_memmove:
 237  * @dest: the destination address to copy the bytes to.
 238  * @src: the source address to copy the bytes from.
 239  * @len: the number of bytes to copy.
 240  *
 241  * Copies a block of memory @len bytes long, from @src to @dest.
 242  * The source and destination areas may overlap.
 243  *
 244  * In order to use this function, you must include
 245  * <filename>string.h</filename> yourself, because this macro will
 246  * typically simply resolve to memmove() and GLib does not include
 247  * <filename>string.h</filename> for you.
 248  */
 249 void
 250 g_memmove (gpointer      dest,
 251            gconstpointer src,
 252            gulong        len)
 253 {
 254   gchar* destptr = dest;
 255   const gchar* srcptr = src;
 256   if (src + len < dest || dest + len < src)
 257     {
 258       bcopy (src, dest, len);
 259       return;
 260     }
 261   else if (dest <= src)
 262     {
 263       while (len--)
 264         *(destptr++) = *(srcptr++);
 265     }
 266   else
 267     {
 268       destptr += len;
 269       srcptr += len;
 270       while (len--)
 271         *(--destptr) = *(--srcptr);
 272     }
 273 }
 274 #endif /* !HAVE_MEMMOVE && !HAVE_WORKING_BCOPY */
 275
 276 #ifdef G_OS_WIN32
 277 #undef g_atexit
 278 #endif
 279
 280 /**
 281  * g_atexit:
 282  * @func: the function to call on normal program termination.
 283  *
 284  * Specifies a function to be called at normal program termination.
 285  *
 286  * Since GLib 2.8.2, on Windows g_atexit() actually is a preprocessor
 287  * macro that maps to a call to the atexit() function in the C
 288  * library. This means that in case the code that calls g_atexit(),
 289  * i.e. atexit(), is in a DLL, the function will be called when the
 290  * DLL is detached from the program. This typically makes more sense
 291  * than that the function is called when the GLib DLL is detached,
 292  * which happened earlier when g_atexit() was a function in the GLib
 293  * DLL.
 294  *
 295  * The behaviour of atexit() in the context of dynamically loaded
 296  * modules is not formally specified and varies wildly.
 297  *
 298  * On POSIX systems, calling g_atexit() (or atexit()) in a dynamically
 299  * loaded module which is unloaded before the program terminates might
 300  * well cause a crash at program exit.
 301  *
 302  * Some POSIX systems implement atexit() like Windows, and have each
 303  * dynamically loaded module maintain an own atexit chain that is
 304  * called when the module is unloaded.
 305  *
 306  * On other POSIX systems, before a dynamically loaded module is
 307  * unloaded, the registered atexit functions (if any) residing in that
 308  * module are called, regardless where the code that registered them
 309  * resided. This is presumably the most robust approach.
 310  *
 311  * As can be seen from the above, for portability it's best to avoid
 312  * calling g_atexit() (or atexit()) except in the main executable of a
 313  * program.
 314  */
 315 void
 316 g_atexit (GVoidFunc func)
 317 {
 318   gint result;
 319   const gchar *error = NULL;
 320
 321   /* keep this in sync with glib.h */
 322
 323 #ifdef  G_NATIVE_ATEXIT
 324   result = ATEXIT (func);
 325   if (result)
 326     error = g_strerror (errno);
 327 #elif defined (HAVE_ATEXIT)
 328 #  ifdef NeXT /* @#%@! NeXTStep */
 329   result = !atexit ((void (*)(void)) func);
 330   if (result)
 331     error = g_strerror (errno);
 332 #  else
 333   result = atexit ((void (*)(void)) func);
 334   if (result)
 335     error = g_strerror (errno);
 336 #  endif /* NeXT */
 337 #elif defined (HAVE_ON_EXIT)
 338   result = on_exit ((void (*)(int, void *)) func, NULL);
 339   if (result)
 340     error = g_strerror (errno);
 341 #else
 342   result = 0;
 343   error = "no implementation";
 344 #endif /* G_NATIVE_ATEXIT */
 345
 346   if (error)
 347     g_error ("Could not register atexit() function: %s", error);
 348 }
 349
 350 /* Based on execvp() from GNU Libc.
 351  * Some of this code is cut-and-pasted into gspawn.c
 352  */
 353
 354 static gchar*
 355 my_strchrnul (const gchar *str,
 356               gchar        c)
 357 {
 358   gchar *p = (gchar*)str;
 359   while (*p && (*p != c))
 360     ++p;
 361
 362   return p;
 363 }
 364
 365 #ifdef G_OS_WIN32
 366
 367 static gchar *inner_find_program_in_path (const gchar *program);
 368
 369 gchar*
 370 g_find_program_in_path (const gchar *program)
 371 {
 372   const gchar *last_dot = strrchr (program, '.');
 373
 374   if (last_dot == NULL ||
 375       strchr (last_dot, '\\') != NULL ||
 376       strchr (last_dot, '/') != NULL)
 377     {
 378       const gint program_length = strlen (program);
 379       gchar *pathext = g_build_path (";",
 380                                      ".exe;.cmd;.bat;.com",
 381                                      g_getenv ("PATHEXT"),
 382                                      NULL);
 383       gchar *p;
 384       gchar *decorated_program;
 385       gchar *retval;
 386
 387       p = pathext;
 388       do
 389         {
 390           gchar *q = my_strchrnul (p, ';');
 391
 392           decorated_program = g_malloc (program_length + (q-p) + 1);
 393           memcpy (decorated_program, program, program_length);
 394           memcpy (decorated_program+program_length, p, q-p);
 395           decorated_program [program_length + (q-p)] = '\0';
 396
 397           retval = inner_find_program_in_path (decorated_program);
 398           g_free (decorated_program);
 399
 400           if (retval != NULL)
 401             {
 402               g_free (pathext);
 403               return retval;
 404             }
 405           p = q;
 406         } while (*p++ != '\0');
 407       g_free (pathext);
 408       return NULL;
 409     }
 410   else
 411     return inner_find_program_in_path (program);
 412 }
 413
 414 #endif
 415
 416 /**
 417  * g_find_program_in_path:
 418  * @program: a program name in the GLib file name encoding
 419  *
 420  * Locates the first executable named @program in the user's path, in the
 421  * same way that execvp() would locate it. Returns an allocated string
 422  * with the absolute path name, or %NULL if the program is not found in
 423  * the path. If @program is already an absolute path, returns a copy of
 424  * @program if @program exists and is executable, and %NULL otherwise.
 425  *
 426  * On Windows, if @program does not have a file type suffix, tries
 427  * with the suffixes .exe, .cmd, .bat and .com, and the suffixes in
 428  * the <envar>PATHEXT</envar> environment variable.
 429  *
 430  * On Windows, it looks for the file in the same way as CreateProcess()
 431  * would. This means first in the directory where the executing
 432  * program was loaded from, then in the current directory, then in the
 433  * Windows 32-bit system directory, then in the Windows directory, and
 434  * finally in the directories in the <envar>PATH</envar> environment
 435  * variable. If the program is found, the return value contains the
 436  * full name including the type suffix.
 437  *
 438  * Return value: absolute path, or %NULL
 439  **/
 440 #ifdef G_OS_WIN32
 441 static gchar *
 442 inner_find_program_in_path (const gchar *program)
 443 #else
 444 gchar*
 445 g_find_program_in_path (const gchar *program)
 446 #endif
 447 {
 448   const gchar *path, *p;
 449   gchar *name, *freeme;
 450 #ifdef G_OS_WIN32
 451   const gchar *path_copy;
 452   gchar *filename = NULL, *appdir = NULL;
 453   gchar *sysdir = NULL, *windir = NULL;
 454   int n;
 455   wchar_t wfilename[MAXPATHLEN], wsysdir[MAXPATHLEN],
 456     wwindir[MAXPATHLEN];
 457 #endif
 458   gsize len;
 459   gsize pathlen;
 460
 461   g_return_val_if_fail (program != NULL, NULL);
 462
 463   /* If it is an absolute path, or a relative path including subdirectories,
 464    * don't look in PATH.
 465    */
 466   if (g_path_is_absolute (program)
 467       || strchr (program, G_DIR_SEPARATOR) != NULL
 468 #ifdef G_OS_WIN32
 469       || strchr (program, '/') != NULL
 470 #endif
 471       )
 472     {
 473       if (g_file_test (program, G_FILE_TEST_IS_EXECUTABLE) &&
 474           !g_file_test (program, G_FILE_TEST_IS_DIR))
 475         return g_strdup (program);
 476       else
 477         return NULL;
 478     }
 479
 480   path = g_getenv ("PATH");
 481 #if defined(G_OS_UNIX) || defined(G_OS_BEOS)
 482   if (path == NULL)
 483     {
 484       /* There is no `PATH' in the environment.  The default
 485        * search path in GNU libc is the current directory followed by
 486        * the path `confstr' returns for `_CS_PATH'.
 487        */
 488
 489       /* In GLib we put . last, for security, and don't use the
 490        * unportable confstr(); UNIX98 does not actually specify
 491        * what to search if PATH is unset. POSIX may, dunno.
 492        */
 493
 494       path = "/bin:/usr/bin:.";
 495     }
 496 #else
 497   n = GetModuleFileNameW (NULL, wfilename, MAXPATHLEN);
 498   if (n > 0 && n < MAXPATHLEN)
 499     filename = g_utf16_to_utf8 (wfilename, -1, NULL, NULL, NULL);
 500
 501   n = GetSystemDirectoryW (wsysdir, MAXPATHLEN);
 502   if (n > 0 && n < MAXPATHLEN)
 503     sysdir = g_utf16_to_utf8 (wsysdir, -1, NULL, NULL, NULL);
 504
 505   n = GetWindowsDirectoryW (wwindir, MAXPATHLEN);
 506   if (n > 0 && n < MAXPATHLEN)
 507     windir = g_utf16_to_utf8 (wwindir, -1, NULL, NULL, NULL);
 508
 509   if (filename)
 510     {
 511       appdir = g_path_get_dirname (filename);
 512       g_free (filename);
 513     }
 514
 515   path = g_strdup (path);
 516
 517   if (windir)
 518     {
 519       const gchar *tem = path;
 520       path = g_strconcat (windir, ";", path, NULL);
 521       g_free ((gchar *) tem);
 522       g_free (windir);
 523     }
 524
 525   if (sysdir)
 526     {
 527       const gchar *tem = path;
 528       path = g_strconcat (sysdir, ";", path, NULL);
 529       g_free ((gchar *) tem);
 530       g_free (sysdir);
 531     }
 532
 533   {
 534     const gchar *tem = path;
 535     path = g_strconcat (".;", path, NULL);
 536     g_free ((gchar *) tem);
 537   }
 538
 539   if (appdir)
 540     {
 541       const gchar *tem = path;
 542       path = g_strconcat (appdir, ";", path, NULL);
 543       g_free ((gchar *) tem);
 544       g_free (appdir);
 545     }
 546
 547   path_copy = path;
 548 #endif
 549
 550   len = strlen (program) + 1;
 551   pathlen = strlen (path);
 552   freeme = name = g_malloc (pathlen + len + 1);
 553
 554   /* Copy the file name at the top, including '\0'  */
 555   memcpy (name + pathlen + 1, program, len);
 556   name = name + pathlen;
 557   /* And add the slash before the filename  */
 558   *name = G_DIR_SEPARATOR;
 559
 560   p = path;
 561   do
 562     {
 563       char *startp;
 564
 565       path = p;
 566       p = my_strchrnul (path, G_SEARCHPATH_SEPARATOR);
 567
 568       if (p == path)
 569         /* Two adjacent colons, or a colon at the beginning or the end
 570          * of `PATH' means to search the current directory.
 571          */
 572         startp = name + 1;
 573       else
 574         startp = memcpy (name - (p - path), path, p - path);
 575
 576       if (g_file_test (startp, G_FILE_TEST_IS_EXECUTABLE) &&
 577           !g_file_test (startp, G_FILE_TEST_IS_DIR))
 578         {
 579           gchar *ret;
 580           ret = g_strdup (startp);
 581           g_free (freeme);
 582 #ifdef G_OS_WIN32
 583           g_free ((gchar *) path_copy);
 584 #endif
 585           return ret;
 586         }
 587     }
 588   while (*p++ != '\0');
 589
 590   g_free (freeme);
 591 #ifdef G_OS_WIN32
 592   g_free ((gchar *) path_copy);
 593 #endif
 594
 595   return NULL;
 596 }
 597
 598 static gboolean
 599 debug_key_matches (const gchar *key,
 600                    const gchar *token,
 601                    guint        length)
 602 {
 603   for (; length; length--, key++, token++)
 604     {
 605       char k = (*key   == '_') ? '-' : tolower (*key  );
 606       char t = (*token == '_') ? '-' : tolower (*token);
 607
 608       if (k != t)
 609         return FALSE;
 610     }
 611
 612   return *key == '\0';
 613 }
 614
 615 /**
 616  * g_parse_debug_string:
 617  * @string: a list of debug options separated by colons, spaces, or
 618  * commas, or %NULL.
 619  * @keys: pointer to an array of #GDebugKey which associate
 620  *     strings with bit flags.
 621  * @nkeys: the number of #GDebugKey<!-- -->s in the array.
 622  *
 623  * Parses a string containing debugging options
 624  * into a %guint containing bit flags. This is used
 625  * within GDK and GTK+ to parse the debug options passed on the
 626  * command line or through environment variables.
 627  *
 628  * If @string is equal to "all", all flags are set.  If @string
 629  * is equal to "help", all the available keys in @keys are printed
 630  * out to standard error.
 631  *
 632  * Returns: the combined set of bit flags.
 633  */
 634 guint
 635 g_parse_debug_string  (const gchar     *string,
 636                        const GDebugKey *keys,
 637                        guint            nkeys)
 638 {
 639   guint i;
 640   guint result = 0;
 641
 642   if (string == NULL)
 643     return 0;
 644
 645   /* this function is used by gmem.c/gslice.c initialization code,
 646    * so introducing malloc dependencies here would require adaptions
 647    * of those code portions.
 648    */
 649
 650   if (!g_ascii_strcasecmp (string, "all"))
 651     {
 652       for (i=0; i<nkeys; i++)
 653         result |= keys[i].value;
 654     }
 655   else if (!g_ascii_strcasecmp (string, "help"))
 656     {
 657       /* using stdio directly for the reason stated above */
 658       fprintf (stderr, "Supported debug values: ");
 659       for (i=0; i<nkeys; i++)
 660         fprintf (stderr, " %s", keys[i].key);
 661       fprintf (stderr, "\n");
 662     }
 663   else
 664     {
 665       const gchar *p = string;
 666       const gchar *q;
 667
 668       while (*p)
 669         {
 670           q = strpbrk (p, ":;, \t");
 671           if (!q)
 672             q = p + strlen(p);
 673
 674           for (i = 0; i < nkeys; i++)
 675             if (debug_key_matches (keys[i].key, p, q - p))
 676               result |= keys[i].value;
 677
 678           p = q;
 679           if (*p)
 680             p++;
 681         }
 682     }
 683
 684   return result;
 685 }
 686
 687 /**
 688  * g_basename:
 689  * @file_name: the name of the file.
 690  *
 691  * Gets the name of the file without any leading directory components.
 692  * It returns a pointer into the given file name string.
 693  *
 694  * Return value: the name of the file without any leading directory components.
 695  *
 696  * Deprecated:2.2: Use g_path_get_basename() instead, but notice that
 697  * g_path_get_basename() allocates new memory for the returned string, unlike
 698  * this function which returns a pointer into the argument.
 699  **/
 700 G_CONST_RETURN gchar*
 701 g_basename (const gchar    *file_name)
 702 {
 703   register gchar *base;
 704
 705   g_return_val_if_fail (file_name != NULL, NULL);
 706
 707   base = strrchr (file_name, G_DIR_SEPARATOR);
 708
 709 #ifdef G_OS_WIN32
 710   {
 711     gchar *q = strrchr (file_name, '/');
 712     if (base == NULL || (q != NULL && q > base))
 713         base = q;
 714   }
 715 #endif
 716
 717   if (base)
 718     return base + 1;
 719
 720 #ifdef G_OS_WIN32
 721   if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
 722     return (gchar*) file_name + 2;
 723 #endif /* G_OS_WIN32 */
 724
 725   return (gchar*) file_name;
 726 }
 727
 728 /**
 729  * g_path_get_basename:
 730  * @file_name: the name of the file.
 731  *
 732  * Gets the last component of the filename. If @file_name ends with a
 733  * directory separator it gets the component before the last slash. If
 734  * @file_name consists only of directory separators (and on Windows,
 735  * possibly a drive letter), a single separator is returned. If
 736  * @file_name is empty, it gets ".".
 737  *
 738  * Return value: a newly allocated string containing the last component of
 739  *   the filename.
 740  */
 741 gchar*
 742 g_path_get_basename (const gchar   *file_name)
 743 {
 744   register gssize base;
 745   register gssize last_nonslash;
 746   gsize len;
 747   gchar *retval;
 748
 749   g_return_val_if_fail (file_name != NULL, NULL);
 750
 751   if (file_name[0] == '\0')
 752     /* empty string */
 753     return g_strdup (".");
 754
 755   last_nonslash = strlen (file_name) - 1;
 756
 757   while (last_nonslash >= 0 && G_IS_DIR_SEPARATOR (file_name [last_nonslash]))
 758     last_nonslash--;
 759
 760   if (last_nonslash == -1)
 761     /* string only containing slashes */
 762     return g_strdup (G_DIR_SEPARATOR_S);
 763
 764 #ifdef G_OS_WIN32
 765   if (last_nonslash == 1 && g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
 766     /* string only containing slashes and a drive */
 767     return g_strdup (G_DIR_SEPARATOR_S);
 768 #endif /* G_OS_WIN32 */
 769
 770   base = last_nonslash;
 771
 772   while (base >=0 && !G_IS_DIR_SEPARATOR (file_name [base]))
 773     base--;
 774
 775 #ifdef G_OS_WIN32
 776   if (base == -1 && g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
 777     base = 1;
 778 #endif /* G_OS_WIN32 */
 779
 780   len = last_nonslash - base;
 781   retval = g_malloc (len + 1);
 782   memcpy (retval, file_name + base + 1, len);
 783   retval [len] = '\0';
 784   return retval;
 785 }
 786
 787 /**
 788  * g_path_is_absolute:
 789  * @file_name: a file name.
 790  *
 791  * Returns %TRUE if the given @file_name is an absolute file name,
 792  * i.e. it contains a full path from the root directory such as "/usr/local"
 793  * on UNIX or "C:\windows" on Windows systems.
 794  *
 795  * Returns: %TRUE if @file_name is an absolute path.
 796  */
 797 gboolean
 798 g_path_is_absolute (const gchar *file_name)
 799 {
 800   g_return_val_if_fail (file_name != NULL, FALSE);
 801
 802   if (G_IS_DIR_SEPARATOR (file_name[0]))
 803     return TRUE;
 804
 805 #ifdef G_OS_WIN32
 806   /* Recognize drive letter on native Windows */
 807   if (g_ascii_isalpha (file_name[0]) &&
 808       file_name[1] == ':' && G_IS_DIR_SEPARATOR (file_name[2]))
 809     return TRUE;
 810 #endif /* G_OS_WIN32 */
 811
 812   return FALSE;
 813 }
 814
 815 /**
 816  * g_path_skip_root:
 817  * @file_name: a file name.
 818  *
 819  * Returns a pointer into @file_name after the root component, i.e. after
 820  * the "/" in UNIX or "C:\" under Windows. If @file_name is not an absolute
 821  * path it returns %NULL.
 822  *
 823  * Returns: a pointer into @file_name after the root component.
 824  */
 825 G_CONST_RETURN gchar*
 826 g_path_skip_root (const gchar *file_name)
 827 {
 828   g_return_val_if_fail (file_name != NULL, NULL);
 829
 830 #ifdef G_PLATFORM_WIN32
 831   /* Skip \\server\share or //server/share */
 832   if (G_IS_DIR_SEPARATOR (file_name[0]) &&
 833       G_IS_DIR_SEPARATOR (file_name[1]) &&
 834       file_name[2] &&
 835       !G_IS_DIR_SEPARATOR (file_name[2]))
 836     {
 837       gchar *p;
 838
 839       p = strchr (file_name + 2, G_DIR_SEPARATOR);
 840 #ifdef G_OS_WIN32
 841       {
 842         gchar *q = strchr (file_name + 2, '/');
 843         if (p == NULL || (q != NULL && q < p))
 844           p = q;
 845       }
 846 #endif
 847       if (p &&
 848           p > file_name + 2 &&
 849           p[1])
 850         {
 851           file_name = p + 1;
 852
 853           while (file_name[0] && !G_IS_DIR_SEPARATOR (file_name[0]))
 854             file_name++;
 855
 856           /* Possibly skip a backslash after the share name */
 857           if (G_IS_DIR_SEPARATOR (file_name[0]))
 858             file_name++;
 859
 860           return (gchar *)file_name;
 861         }
 862     }
 863 #endif
 864
 865   /* Skip initial slashes */
 866   if (G_IS_DIR_SEPARATOR (file_name[0]))
 867     {
 868       while (G_IS_DIR_SEPARATOR (file_name[0]))
 869         file_name++;
 870       return (gchar *)file_name;
 871     }
 872
 873 #ifdef G_OS_WIN32
 874   /* Skip X:\ */
 875   if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':' && G_IS_DIR_SEPARATOR (file_name[2]))
 876     return (gchar *)file_name + 3;
 877 #endif
 878
 879   return NULL;
 880 }
 881
 882 /**
 883  * g_path_get_dirname:
 884  * @file_name: the name of the file.
 885  *
 886  * Gets the directory components of a file name.  If the file name has no
 887  * directory components "." is returned.  The returned string should be
 888  * freed when no longer needed.
 889  *
 890  * Returns: the directory components of the file.
 891  */
 892 gchar*
 893 g_path_get_dirname (const gchar    *file_name)
 894 {
 895   register gchar *base;
 896   register gsize len;
 897
 898   g_return_val_if_fail (file_name != NULL, NULL);
 899
 900   base = strrchr (file_name, G_DIR_SEPARATOR);
 901 #ifdef G_OS_WIN32
 902   {
 903     gchar *q = strrchr (file_name, '/');
 904     if (base == NULL || (q != NULL && q > base))
 905         base = q;
 906   }
 907 #endif
 908   if (!base)
 909     {
 910 #ifdef G_OS_WIN32
 911       if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
 912         {
 913           gchar drive_colon_dot[4];
 914
 915           drive_colon_dot[0] = file_name[0];
 916           drive_colon_dot[1] = ':';
 917           drive_colon_dot[2] = '.';
 918           drive_colon_dot[3] = '\0';
 919
 920           return g_strdup (drive_colon_dot);
 921         }
 922 #endif
 923     return g_strdup (".");
 924     }
 925
 926   while (base > file_name && G_IS_DIR_SEPARATOR (*base))
 927     base--;
 928
 929 #ifdef G_OS_WIN32
 930   /* base points to the char before the last slash.
 931    *
 932    * In case file_name is the root of a drive (X:\) or a child of the
 933    * root of a drive (X:\foo), include the slash.
 934    *
 935    * In case file_name is the root share of an UNC path
 936    * (\\server\share), add a slash, returning \\server\share\ .
 937    *
 938    * In case file_name is a direct child of a share in an UNC path
 939    * (\\server\share\foo), include the slash after the share name,
 940    * returning \\server\share\ .
 941    */
 942   if (base == file_name + 1 && g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
 943     base++;
 944   else if (G_IS_DIR_SEPARATOR (file_name[0]) &&
 945            G_IS_DIR_SEPARATOR (file_name[1]) &&
 946            file_name[2] &&
 947            !G_IS_DIR_SEPARATOR (file_name[2]) &&
 948            base >= file_name + 2)
 949     {
 950       const gchar *p = file_name + 2;
 951       while (*p && !G_IS_DIR_SEPARATOR (*p))
 952         p++;
 953       if (p == base + 1)
 954         {
 955           len = (guint) strlen (file_name) + 1;
 956           base = g_new (gchar, len + 1);
 957           strcpy (base, file_name);
 958           base[len-1] = G_DIR_SEPARATOR;
 959           base[len] = 0;
 960           return base;
 961         }
 962       if (G_IS_DIR_SEPARATOR (*p))
 963         {
 964           p++;
 965           while (*p && !G_IS_DIR_SEPARATOR (*p))
 966             p++;
 967           if (p == base + 1)
 968             base++;
 969         }
 970     }
 971 #endif
 972
 973   len = (guint) 1 + base - file_name;
 974
 975   base = g_new (gchar, len + 1);
 976   g_memmove (base, file_name, len);
 977   base[len] = 0;
 978
 979   return base;
 980 }
 981
 982 /**
 983  * g_get_current_dir:
 984  *
 985  * Gets the current directory.
 986  * The returned string should be freed when no longer needed. The encoding
 987  * of the returned string is system defined. On Windows, it is always UTF-8.
 988  *
 989  * Returns: the current directory.
 990  */
 991 gchar*
 992 g_get_current_dir (void)
 993 {
 994 #ifdef G_OS_WIN32
 995
 996   gchar *dir = NULL;
 997   wchar_t dummy[2], *wdir;
 998   int len;
 999
1000   len = GetCurrentDirectoryW (2, dummy);
1001   wdir = g_new (wchar_t, len);
1002
1003   if (GetCurrentDirectoryW (len, wdir) == len - 1)
1004     dir = g_utf16_to_utf8 (wdir, -1, NULL, NULL, NULL);
1005
1006   g_free (wdir);
1007
1008   if (dir == NULL)
1009     dir = g_strdup ("\\");
1010
1011   return dir;
1012
1013 #else
1014
1015   gchar *buffer = NULL;
1016   gchar *dir = NULL;
1017   static gulong max_len = 0;
1018
1019   if (max_len == 0)
1020     max_len = (G_PATH_LENGTH == -1) ? 2048 : G_PATH_LENGTH;
1021
1022   /* We don't use getcwd(3) on SUNOS, because, it does a popen("pwd")
1023    * and, if that wasn't bad enough, hangs in doing so.
1024    */
1025 #if     (defined (sun) && !defined (__SVR4)) || !defined(HAVE_GETCWD)
1026   buffer = g_new (gchar, max_len + 1);
1027   *buffer = 0;
1028   dir = getwd (buffer);
1029 #else   /* !sun || !HAVE_GETCWD */
1030   while (max_len < G_MAXULONG / 2)
1031     {
1032       g_free (buffer);
1033       buffer = g_new (gchar, max_len + 1);
1034       *buffer = 0;
1035       dir = getcwd (buffer, max_len);
1036
1037       if (dir || errno != ERANGE)
1038         break;
1039
1040       max_len *= 2;
1041     }
1042 #endif  /* !sun || !HAVE_GETCWD */
1043
1044   if (!dir || !*buffer)
1045     {
1046       /* hm, should we g_error() out here?
1047        * this can happen if e.g. "./" has mode \0000
1048        */
1049       buffer[0] = G_DIR_SEPARATOR;
1050       buffer[1] = 0;
1051     }
1052
1053   dir = g_strdup (buffer);
1054   g_free (buffer);
1055
1056   return dir;
1057 #endif /* !Win32 */
1058 }
1059
1060 /**
1061  * g_getenv:
1062  * @variable: the environment variable to get, in the GLib file name encoding.
1063  *
1064  * Returns the value of an environment variable. The name and value
1065  * are in the GLib file name encoding. On UNIX, this means the actual
1066  * bytes which might or might not be in some consistent character set
1067  * and encoding. On Windows, it is in UTF-8. On Windows, in case the
1068  * environment variable's value contains references to other
1069  * environment variables, they are expanded.
1070  *
1071  * Return value: the value of the environment variable, or %NULL if
1072  * the environment variable is not found. The returned string may be
1073  * overwritten by the next call to g_getenv(), g_setenv() or
1074  * g_unsetenv().
1075  **/
1076 G_CONST_RETURN gchar*
1077 g_getenv (const gchar *variable)
1078 {
1079 #ifndef G_OS_WIN32
1080
1081   g_return_val_if_fail (variable != NULL, NULL);
1082
1083   return getenv (variable);
1084
1085 #else /* G_OS_WIN32 */
1086
1087   GQuark quark;
1088   gchar *value;
1089   wchar_t dummy[2], *wname, *wvalue;
1090   int len;
1091
1092   g_return_val_if_fail (variable != NULL, NULL);
1093   g_return_val_if_fail (g_utf8_validate (variable, -1, NULL), NULL);
1094
1095   /* On Windows NT, it is relatively typical that environment
1096    * variables contain references to other environment variables. If
1097    * so, use ExpandEnvironmentStrings(). (In an ideal world, such
1098    * environment variables would be stored in the Registry as
1099    * REG_EXPAND_SZ type values, and would then get automatically
1100    * expanded before a program sees them. But there is broken software
1101    * that stores environment variables as REG_SZ values even if they
1102    * contain references to other environment variables.)
1103    */
1104
1105   wname = g_utf8_to_utf16 (variable, -1, NULL, NULL, NULL);
1106
1107   len = GetEnvironmentVariableW (wname, dummy, 2);
1108
1109   if (len == 0)
1110     {
1111       g_free (wname);
1112       return NULL;
1113     }
1114   else if (len == 1)
1115     len = 2;
1116
1117   wvalue = g_new (wchar_t, len);
1118
1119   if (GetEnvironmentVariableW (wname, wvalue, len) != len - 1)
1120     {
1121       g_free (wname);
1122       g_free (wvalue);
1123       return NULL;
1124     }
1125
1126   if (wcschr (wvalue, L'%') != NULL)
1127     {
1128       wchar_t *tem = wvalue;
1129
1130       len = ExpandEnvironmentStringsW (wvalue, dummy, 2);
1131
1132       if (len > 0)
1133         {
1134           wvalue = g_new (wchar_t, len);
1135
1136           if (ExpandEnvironmentStringsW (tem, wvalue, len) != len)
1137             {
1138               g_free (wvalue);
1139               wvalue = tem;
1140             }
1141           else
1142             g_free (tem);
1143         }
1144     }
1145
1146   value = g_utf16_to_utf8 (wvalue, -1, NULL, NULL, NULL);
1147
1148   g_free (wname);
1149   g_free (wvalue);
1150
1151   quark = g_quark_from_string (value);
1152   g_free (value);
1153
1154   return g_quark_to_string (quark);
1155
1156 #endif /* G_OS_WIN32 */
1157 }
1158
1159 /* _g_getenv_nomalloc
1160  * this function does a getenv() without doing any kind of allocation
1161  * through glib. it's suitable for chars <= 127 only (both, for the
1162  * variable name and the contents) and for contents < 1024 chars in
1163  * length. also, it aliases "" to a NULL return value.
1164  **/
1165 const gchar*
1166 _g_getenv_nomalloc (const gchar *variable,
1167                     gchar        buffer[1024])
1168 {
1169   const gchar *retval = getenv (variable);
1170   if (retval && retval[0])
1171     {
1172       gint l = strlen (retval);
1173       if (l < 1024)
1174         {
1175           strncpy (buffer, retval, l);
1176           buffer[l] = 0;
1177           return buffer;
1178         }
1179     }
1180   return NULL;
1181 }
1182
1183 /**
1184  * g_setenv:
1185  * @variable: the environment variable to set, must not contain '='.
1186  * @value: the value for to set the variable to.
1187  * @overwrite: whether to change the variable if it already exists.
1188  *
1189  * Sets an environment variable. Both the variable's name and value
1190  * should be in the GLib file name encoding. On UNIX, this means that
1191  * they can be any sequence of bytes. On Windows, they should be in
1192  * UTF-8.
1193  *
1194  * Note that on some systems, when variables are overwritten, the memory
1195  * used for the previous variables and its value isn't reclaimed.
1196  *
1197  * Returns: %FALSE if the environment variable couldn't be set.
1198  *
1199  * Since: 2.4
1200  */
1201 gboolean
1202 g_setenv (const gchar *variable,
1203           const gchar *value,
1204           gboolean     overwrite)
1205 {
1206 #ifndef G_OS_WIN32
1207
1208   gint result;
1209 #ifndef HAVE_SETENV
1210   gchar *string;
1211 #endif
1212
1213   g_return_val_if_fail (variable != NULL, FALSE);
1214   g_return_val_if_fail (strchr (variable, '=') == NULL, FALSE);
1215
1216 #ifdef HAVE_SETENV
1217   result = setenv (variable, value, overwrite);
1218 #else
1219   if (!overwrite && getenv (variable) != NULL)
1220     return TRUE;
1221
1222   /* This results in a leak when you overwrite existing
1223    * settings. It would be fairly easy to fix this by keeping
1224    * our own parallel array or hash table.
1225    */
1226   string = g_strconcat (variable, "=", value, NULL);
1227   result = putenv (string);
1228 #endif
1229   return result == 0;
1230
1231 #else /* G_OS_WIN32 */
1232
1233   gboolean retval;
1234   wchar_t *wname, *wvalue, *wassignment;
1235   gchar *tem;
1236
1237   g_return_val_if_fail (variable != NULL, FALSE);
1238   g_return_val_if_fail (strchr (variable, '=') == NULL, FALSE);
1239   g_return_val_if_fail (g_utf8_validate (variable, -1, NULL), FALSE);
1240   g_return_val_if_fail (g_utf8_validate (value, -1, NULL), FALSE);
1241
1242   if (!overwrite && g_getenv (variable) != NULL)
1243     return TRUE;
1244
1245   /* We want to (if possible) set both the environment variable copy
1246    * kept by the C runtime and the one kept by the system.
1247    *
1248    * We can't use only the C runtime's putenv or _wputenv() as that
1249    * won't work for arbitrary Unicode strings in a "non-Unicode" app
1250    * (with main() and not wmain()). In a "main()" app the C runtime
1251    * initializes the C runtime's environment table by converting the
1252    * real (wide char) environment variables to system codepage, thus
1253    * breaking those that aren't representable in the system codepage.
1254    *
1255    * As the C runtime's putenv() will also set the system copy, we do
1256    * the putenv() first, then call SetEnvironmentValueW ourselves.
1257    */
1258
1259   wname = g_utf8_to_utf16 (variable, -1, NULL, NULL, NULL);
1260   wvalue = g_utf8_to_utf16 (value, -1, NULL, NULL, NULL);
1261   tem = g_strconcat (variable, "=", value, NULL);
1262   wassignment = g_utf8_to_utf16 (tem, -1, NULL, NULL, NULL);
1263
1264   g_free (tem);
1265   _wputenv (wassignment);
1266   g_free (wassignment);
1267
1268   retval = (SetEnvironmentVariableW (wname, wvalue) != 0);
1269
1270   g_free (wname);
1271   g_free (wvalue);
1272
1273   return retval;
1274
1275 #endif /* G_OS_WIN32 */
1276 }
1277
1278 #ifdef HAVE__NSGETENVIRON
1279 #define environ (*_NSGetEnviron())
1280 #elif !defined(G_OS_WIN32)
1281
1282 /* According to the Single Unix Specification, environ is not in
1283  * any system header, although unistd.h often declares it.
1284  */
1285 extern char **environ;
1286 #endif
1287
1288 /**
1289  * g_unsetenv:
1290  * @variable: the environment variable to remove, must not contain '='.
1291  *
1292  * Removes an environment variable from the environment.
1293  *
1294  * Note that on some systems, when variables are overwritten, the memory
1295  * used for the previous variables and its value isn't reclaimed.
1296  * Furthermore, this function can't be guaranteed to operate in a
1297  * threadsafe way.
1298  *
1299  * Since: 2.4
1300  **/
1301 void
1302 g_unsetenv (const gchar *variable)
1303 {
1304 #ifndef G_OS_WIN32
1305
1306 #ifdef HAVE_UNSETENV
1307   g_return_if_fail (variable != NULL);
1308   g_return_if_fail (strchr (variable, '=') == NULL);
1309
1310   unsetenv (variable);
1311 #else /* !HAVE_UNSETENV */
1312   int len;
1313   gchar **e, **f;
1314
1315   g_return_if_fail (variable != NULL);
1316   g_return_if_fail (strchr (variable, '=') == NULL);
1317
1318   len = strlen (variable);
1319
1320   /* Mess directly with the environ array.
1321    * This seems to be the only portable way to do this.
1322    *
1323    * Note that we remove *all* environment entries for
1324    * the variable name, not just the first.
1325    */
1326   e = f = environ;
1327   while (*e != NULL)
1328     {
1329       if (strncmp (*e, variable, len) != 0 || (*e)[len] != '=')
1330         {
1331           *f = *e;
1332           f++;
1333         }
1334       e++;
1335     }
1336   *f = NULL;
1337 #endif /* !HAVE_UNSETENV */
1338
1339 #else  /* G_OS_WIN32 */
1340
1341   wchar_t *wname, *wassignment;
1342   gchar *tem;
1343
1344   g_return_if_fail (variable != NULL);
1345   g_return_if_fail (strchr (variable, '=') == NULL);
1346   g_return_if_fail (g_utf8_validate (variable, -1, NULL));
1347
1348   wname = g_utf8_to_utf16 (variable, -1, NULL, NULL, NULL);
1349   tem = g_strconcat (variable, "=", NULL);
1350   wassignment = g_utf8_to_utf16 (tem, -1, NULL, NULL, NULL);
1351
1352   g_free (tem);
1353   _wputenv (wassignment);
1354   g_free (wassignment);
1355
1356   SetEnvironmentVariableW (wname, NULL);
1357
1358   g_free (wname);
1359
1360 #endif /* G_OS_WIN32 */
1361 }
1362
1363 /**
1364  * g_listenv:
1365  *
1366  * Gets the names of all variables set in the environment.
1367  *
1368  * Returns: a %NULL-terminated list of strings which must be freed
1369  * with g_strfreev().
1370  *
1371  * Programs that want to be portable to Windows should typically use
1372  * this function and g_getenv() instead of using the environ array
1373  * from the C library directly. On Windows, the strings in the environ
1374  * array are in system codepage encoding, while in most of the typical
1375  * use cases for environment variables in GLib-using programs you want
1376  * the UTF-8 encoding that this function and g_getenv() provide.
1377  *
1378  * Since: 2.8
1379  */
1380 gchar **
1381 g_listenv (void)
1382 {
1383 #ifndef G_OS_WIN32
1384   gchar **result, *eq;
1385   gint len, i, j;
1386
1387   len = g_strv_length (environ);
1388   result = g_new0 (gchar *, len + 1);
1389
1390   j = 0;
1391   for (i = 0; i < len; i++)
1392     {
1393       eq = strchr (environ[i], '=');
1394       if (eq)
1395         result[j++] = g_strndup (environ[i], eq - environ[i]);
1396     }
1397
1398   result[j] = NULL;
1399
1400   return result;
1401 #else
1402   gchar **result, *eq;
1403   gint len = 0, j;
1404   wchar_t *p, *q;
1405
1406   p = (wchar_t *) GetEnvironmentStringsW ();
1407   if (p != NULL)
1408     {
1409       q = p;
1410       while (*q)
1411         {
1412           q += wcslen (q) + 1;
1413           len++;
1414         }
1415     }
1416   result = g_new0 (gchar *, len + 1);
1417
1418   j = 0;
1419   q = p;
1420   while (*q)
1421     {
1422       result[j] = g_utf16_to_utf8 (q, -1, NULL, NULL, NULL);
1423       if (result[j] != NULL)
1424         {
1425           eq = strchr (result[j], '=');
1426           if (eq && eq > result[j])
1427             {
1428               *eq = '\0';
1429               j++;
1430             }
1431           else
1432             g_free (result[j]);
1433         }
1434       q += wcslen (q) + 1;
1435     }
1436   result[j] = NULL;
1437   FreeEnvironmentStringsW (p);
1438
1439   return result;
1440 #endif
1441 }
1442
1443 G_LOCK_DEFINE_STATIC (g_utils_global);
1444
1445 static  gchar   *g_tmp_dir = NULL;
1446 static  gchar   *g_user_name = NULL;
1447 static  gchar   *g_real_name = NULL;
1448 static  gchar   *g_home_dir = NULL;
1449 static  gchar   *g_host_name = NULL;
1450
1451 #ifdef G_OS_WIN32
1452 /* System codepage versions of the above, kept at file level so that they,
1453  * too, are produced only once.
1454  */
1455 static  gchar   *g_tmp_dir_cp = NULL;
1456 static  gchar   *g_user_name_cp = NULL;
1457 static  gchar   *g_real_name_cp = NULL;
1458 static  gchar   *g_home_dir_cp = NULL;
1459 #endif
1460
1461 static  gchar   *g_user_data_dir = NULL;
1462 static  gchar  **g_system_data_dirs = NULL;
1463 static  gchar   *g_user_cache_dir = NULL;
1464 static  gchar   *g_user_config_dir = NULL;
1465 static  gchar  **g_system_config_dirs = NULL;
1466
1467 static  gchar  **g_user_special_dirs = NULL;
1468
1469 /* fifteen minutes of fame for everybody */
1470 #define G_USER_DIRS_EXPIRE      15 * 60
1471
1472 #ifdef G_OS_WIN32
1473
1474 static gchar *
1475 get_special_folder (int csidl)
1476 {
1477   wchar_t path[MAX_PATH+1];
1478   HRESULT hr;
1479   LPITEMIDLIST pidl = NULL;
1480   BOOL b;
1481   gchar *retval = NULL;
1482
1483   hr = SHGetSpecialFolderLocation (NULL, csidl, &pidl);
1484   if (hr == S_OK)
1485     {
1486       b = SHGetPathFromIDListW (pidl, path);
1487       if (b)
1488         retval = g_utf16_to_utf8 (path, -1, NULL, NULL, NULL);
1489       CoTaskMemFree (pidl);
1490     }
1491   return retval;
1492 }
1493
1494 static char *
1495 get_windows_directory_root (void)
1496 {
1497   wchar_t wwindowsdir[MAX_PATH];
1498
1499   if (GetWindowsDirectoryW (wwindowsdir, G_N_ELEMENTS (wwindowsdir)))
1500     {
1501       /* Usually X:\Windows, but in terminal server environments
1502        * might be an UNC path, AFAIK.
1503        */
1504       char *windowsdir = g_utf16_to_utf8 (wwindowsdir, -1, NULL, NULL, NULL);
1505       char *p;
1506
1507       if (windowsdir == NULL)
1508         return g_strdup ("C:\\");
1509
1510       p = (char *) g_path_skip_root (windowsdir);
1511       if (G_IS_DIR_SEPARATOR (p[-1]) && p[-2] != ':')
1512         p--;
1513       *p = '\0';
1514       return windowsdir;
1515     }
1516   else
1517     return g_strdup ("C:\\");
1518 }
1519
1520 #endif
1521
1522 /* HOLDS: g_utils_global_lock */
1523 static void
1524 g_get_any_init_do (void)
1525 {
1526   gchar hostname[100];
1527
1528   g_tmp_dir = g_strdup (g_getenv ("TMPDIR"));
1529   if (!g_tmp_dir)
1530     g_tmp_dir = g_strdup (g_getenv ("TMP"));
1531   if (!g_tmp_dir)
1532     g_tmp_dir = g_strdup (g_getenv ("TEMP"));
1533
1534 #ifdef G_OS_WIN32
1535   if (!g_tmp_dir)
1536     g_tmp_dir = get_windows_directory_root ();
1537 #else
1538 #ifdef P_tmpdir
1539   if (!g_tmp_dir)
1540     {
1541       gsize k;
1542       g_tmp_dir = g_strdup (P_tmpdir);
1543       k = strlen (g_tmp_dir);
1544       if (k > 1 && G_IS_DIR_SEPARATOR (g_tmp_dir[k - 1]))
1545         g_tmp_dir[k - 1] = '\0';
1546     }
1547 #endif
1548
1549   if (!g_tmp_dir)
1550     {
1551       g_tmp_dir = g_strdup ("/tmp");
1552     }
1553 #endif  /* !G_OS_WIN32 */
1554
1555 #ifdef G_OS_WIN32
1556   /* We check $HOME first for Win32, though it is a last resort for Unix
1557    * where we prefer the results of getpwuid().
1558    */
1559   g_home_dir = g_strdup (g_getenv ("HOME"));
1560
1561   /* Only believe HOME if it is an absolute path and exists */
1562   if (g_home_dir)
1563     {
1564       if (!(g_path_is_absolute (g_home_dir) &&
1565             g_file_test (g_home_dir, G_FILE_TEST_IS_DIR)))
1566         {
1567           g_free (g_home_dir);
1568           g_home_dir = NULL;
1569         }
1570     }
1571
1572   /* In case HOME is Unix-style (it happens), convert it to
1573    * Windows style.
1574    */
1575   if (g_home_dir)
1576     {
1577       gchar *p;
1578       while ((p = strchr (g_home_dir, '/')) != NULL)
1579         *p = '\\';
1580     }
1581
1582   if (!g_home_dir)
1583     {
1584       /* USERPROFILE is probably the closest equivalent to $HOME? */
1585       if (g_getenv ("USERPROFILE") != NULL)
1586         g_home_dir = g_strdup (g_getenv ("USERPROFILE"));
1587     }
1588
1589   if (!g_home_dir)
1590     g_home_dir = get_special_folder (CSIDL_PROFILE);
1591
1592   if (!g_home_dir)
1593     g_home_dir = get_windows_directory_root ();
1594 #endif /* G_OS_WIN32 */
1595
1596 #ifdef HAVE_PWD_H
1597   {
1598     struct passwd *pw = NULL;
1599     gpointer buffer = NULL;
1600     gint error;
1601     gchar *logname;
1602
1603 #  if defined (HAVE_POSIX_GETPWUID_R) || defined (HAVE_NONPOSIX_GETPWUID_R)
1604     struct passwd pwd;
1605 #    ifdef _SC_GETPW_R_SIZE_MAX
1606     /* This reurns the maximum length */
1607     glong bufsize = sysconf (_SC_GETPW_R_SIZE_MAX);
1608
1609     if (bufsize < 0)
1610       bufsize = 64;
1611 #    else /* _SC_GETPW_R_SIZE_MAX */
1612     glong bufsize = 64;
1613 #    endif /* _SC_GETPW_R_SIZE_MAX */
1614
1615     logname = (gchar *) g_getenv ("LOGNAME");
1616
1617     do
1618       {
1619         g_free (buffer);
1620         /* we allocate 6 extra bytes to work around a bug in
1621          * Mac OS < 10.3. See #156446
1622          */
1623         buffer = g_malloc (bufsize + 6);
1624         errno = 0;
1625
1626 #    ifdef HAVE_POSIX_GETPWUID_R
1627         if (logname) {
1628           error = getpwnam_r (logname, &pwd, buffer, bufsize, &pw);
1629           if (!pw || (pw->pw_uid != getuid ())) {
1630             /* LOGNAME is lying, fall back to looking up the uid */
1631             error = getpwuid_r (getuid (), &pwd, buffer, bufsize, &pw);
1632           }
1633         } else {
1634           error = getpwuid_r (getuid (), &pwd, buffer, bufsize, &pw);
1635         }
1636         error = error < 0 ? errno : error;
1637 #    else /* HAVE_NONPOSIX_GETPWUID_R */
1638    /* HPUX 11 falls into the HAVE_POSIX_GETPWUID_R case */
1639 #      if defined(_AIX) || defined(__hpux)
1640         error = getpwuid_r (getuid (), &pwd, buffer, bufsize);
1641         pw = error == 0 ? &pwd : NULL;
1642 #      else /* !_AIX */
1643         if (logname) {
1644           pw = getpwnam_r (logname, &pwd, buffer, bufsize);
1645           if (!pw || (pw->pw_uid != getuid ())) {
1646             /* LOGNAME is lying, fall back to looking up the uid */
1647             pw = getpwuid_r (getuid (), &pwd, buffer, bufsize);
1648           }
1649         } else {
1650           pw = getpwuid_r (getuid (), &pwd, buffer, bufsize);
1651         }
1652         error = pw ? 0 : errno;
1653 #      endif /* !_AIX */
1654 #    endif /* HAVE_NONPOSIX_GETPWUID_R */
1655
1656         if (!pw)
1657           {
1658             /* we bail out prematurely if the user id can't be found
1659              * (should be pretty rare case actually), or if the buffer
1660              * should be sufficiently big and lookups are still not
1661              * successfull.
1662              */
1663             if (error == 0 || error == ENOENT)
1664               {
1665                 g_warning ("getpwuid_r(): failed due to unknown user id (%lu)",
1666                            (gulong) getuid ());
1667                 break;
1668               }
1669             if (bufsize > 32 * 1024)
1670               {
1671                 g_warning ("getpwuid_r(): failed due to: %s.",
1672                            g_strerror (error));
1673                 break;
1674               }
1675
1676             bufsize *= 2;
1677           }
1678       }
1679     while (!pw);
1680 #  endif /* HAVE_POSIX_GETPWUID_R || HAVE_NONPOSIX_GETPWUID_R */
1681
1682     if (!pw)
1683       {
1684         setpwent ();
1685         pw = getpwuid (getuid ());
1686         endpwent ();
1687       }
1688     if (pw)
1689       {
1690         g_user_name = g_strdup (pw->pw_name);
1691
1692         if (pw->pw_gecos && *pw->pw_gecos != '\0')
1693           {
1694             gchar **gecos_fields;
1695             gchar **name_parts;
1696
1697             /* split the gecos field and substitute '&' */
1698             gecos_fields = g_strsplit (pw->pw_gecos, ",", 0);
1699             name_parts = g_strsplit (gecos_fields[0], "&", 0);
1700             pw->pw_name[0] = g_ascii_toupper (pw->pw_name[0]);
1701             g_real_name = g_strjoinv (pw->pw_name, name_parts);
1702             g_strfreev (gecos_fields);
1703             g_strfreev (name_parts);
1704           }
1705
1706         if (!g_home_dir)
1707           g_home_dir = g_strdup (pw->pw_dir);
1708       }
1709     g_free (buffer);
1710   }
1711
1712 #else /* !HAVE_PWD_H */
1713
1714 #ifdef G_OS_WIN32
1715   {
1716     guint len = UNLEN+1;
1717     wchar_t buffer[UNLEN+1];
1718
1719     if (GetUserNameW (buffer, (LPDWORD) &len))
1720       {
1721         g_user_name = g_utf16_to_utf8 (buffer, -1, NULL, NULL, NULL);
1722         g_real_name = g_strdup (g_user_name);
1723       }
1724   }
1725 #endif /* G_OS_WIN32 */
1726
1727 #endif /* !HAVE_PWD_H */
1728
1729 #ifndef G_OS_WIN32
1730   if (!g_home_dir)
1731     g_home_dir = g_strdup (g_getenv ("HOME"));
1732 #endif
1733
1734 #ifdef __EMX__
1735   /* change '\\' in %HOME% to '/' */
1736   g_strdelimit (g_home_dir, "\\",'/');
1737 #endif
1738   if (!g_user_name)
1739     g_user_name = g_strdup ("somebody");
1740   if (!g_real_name)
1741     g_real_name = g_strdup ("Unknown");
1742
1743   {
1744 #ifndef G_OS_WIN32
1745     gboolean hostname_fail = (gethostname (hostname, sizeof (hostname)) == -1);
1746 #else
1747     DWORD size = sizeof (hostname);
1748     gboolean hostname_fail = (!GetComputerName (hostname, &size));
1749 #endif
1750     g_host_name = g_strdup (hostname_fail ? "localhost" : hostname);
1751   }
1752
1753 #ifdef G_OS_WIN32
1754   g_tmp_dir_cp = g_locale_from_utf8 (g_tmp_dir, -1, NULL, NULL, NULL);
1755   g_user_name_cp = g_locale_from_utf8 (g_user_name, -1, NULL, NULL, NULL);
1756   g_real_name_cp = g_locale_from_utf8 (g_real_name, -1, NULL, NULL, NULL);
1757
1758   if (!g_tmp_dir_cp)
1759     g_tmp_dir_cp = g_strdup ("\\");
1760   if (!g_user_name_cp)
1761     g_user_name_cp = g_strdup ("somebody");
1762   if (!g_real_name_cp)
1763     g_real_name_cp = g_strdup ("Unknown");
1764
1765   /* home_dir might be NULL, unlike tmp_dir, user_name and
1766    * real_name.
1767    */
1768   if (g_home_dir)
1769     g_home_dir_cp = g_locale_from_utf8 (g_home_dir, -1, NULL, NULL, NULL);
1770   else
1771     g_home_dir_cp = NULL;
1772 #endif /* G_OS_WIN32 */
1773 }
1774
1775 static inline void
1776 g_get_any_init (void)
1777 {
1778   if (!g_tmp_dir)
1779     g_get_any_init_do ();
1780 }
1781
1782 static inline void
1783 g_get_any_init_locked (void)
1784 {
1785   G_LOCK (g_utils_global);
1786   g_get_any_init ();
1787   G_UNLOCK (g_utils_global);
1788 }
1789
1790
1791 /**
1792  * g_get_user_name:
1793  *
1794  * Gets the user name of the current user. The encoding of the returned
1795  * string is system-defined. On UNIX, it might be the preferred file name
1796  * encoding, or something else, and there is no guarantee that it is even
1797  * consistent on a machine. On Windows, it is always UTF-8.
1798  *
1799  * Returns: the user name of the current user.
1800  */
1801 G_CONST_RETURN gchar*
1802 g_get_user_name (void)
1803 {
1804   g_get_any_init_locked ();
1805   return g_user_name;
1806 }
1807
1808 /**
1809  * g_get_real_name:
1810  *
1811  * Gets the real name of the user. This usually comes from the user's entry
1812  * in the <filename>passwd</filename> file. The encoding of the returned
1813  * string is system-defined. (On Windows, it is, however, always UTF-8.)
1814  * If the real user name cannot be determined, the string "Unknown" is
1815  * returned.
1816  *
1817  * Returns: the user's real name.
1818  */
1819 G_CONST_RETURN gchar*
1820 g_get_real_name (void)
1821 {
1822   g_get_any_init_locked ();
1823   return g_real_name;
1824 }
1825
1826 /**
1827  * g_get_home_dir:
1828  *
1829  * Gets the current user's home directory as defined in the
1830  * password database.
1831  *
1832  * Note that in contrast to traditional UNIX tools, this function
1833  * prefers <filename>passwd</filename> entries over the <envar>HOME</envar>
1834  * environment variable.
1835  *
1836  * One of the reasons for this decision is that applications in many
1837  * cases need special handling to deal with the case where
1838  * <envar>HOME</envar> is
1839  * <simplelist>
1840  *   <member>Not owned by the user</member>
1841  *   <member>Not writeable</member>
1842  *   <member>Not even readable</member>
1843  * </simplelist>
1844  * Since applications are in general <emphasis>not</emphasis> written
1845  * to deal with these situations it was considered better to make
1846  * g_get_home_dir() not pay attention to <envar>HOME</envar> and to
1847  * return the real home directory for the user. If applications
1848  * want to pay attention to <envar>HOME</envar>, they can do:
1849  * |[
1850  *  const char *homedir = g_getenv ("HOME");
1851  *   if (!homedir)
1852  *      homedir = g_get_home_dir (<!-- -->);
1853  * ]|
1854  *
1855  * Returns: the current user's home directory
1856  */
1857 G_CONST_RETURN gchar*
1858 g_get_home_dir (void)
1859 {
1860   g_get_any_init_locked ();
1861   return g_home_dir;
1862 }
1863
1864 /**
1865  * g_get_tmp_dir:
1866  *
1867  * Gets the directory to use for temporary files. This is found from
1868  * inspecting the environment variables <envar>TMPDIR</envar>,
1869  * <envar>TMP</envar>, and <envar>TEMP</envar> in that order. If none
1870  * of those are defined "/tmp" is returned on UNIX and "C:\" on Windows.
1871  * The encoding of the returned string is system-defined. On Windows,
1872  * it is always UTF-8. The return value is never %NULL.
1873  *
1874  * Returns: the directory to use for temporary files.
1875  */
1876 G_CONST_RETURN gchar*
1877 g_get_tmp_dir (void)
1878 {
1879   g_get_any_init_locked ();
1880   return g_tmp_dir;
1881 }
1882
1883 /**
1884  * g_get_host_name:
1885  *
1886  * Return a name for the machine.
1887  *
1888  * The returned name is not necessarily a fully-qualified domain name,
1889  * or even present in DNS or some other name service at all. It need
1890  * not even be unique on your local network or site, but usually it
1891  * is. Callers should not rely on the return value having any specific
1892  * properties like uniqueness for security purposes. Even if the name
1893  * of the machine is changed while an application is running, the
1894  * return value from this function does not change. The returned
1895  * string is owned by GLib and should not be modified or freed. If no
1896  * name can be determined, a default fixed string "localhost" is
1897  * returned.
1898  *
1899  * Returns: the host name of the machine.
1900  *
1901  * Since: 2.8
1902  */
1903 const gchar *
1904 g_get_host_name (void)
1905 {
1906   g_get_any_init_locked ();
1907   return g_host_name;
1908 }
1909
1910 G_LOCK_DEFINE_STATIC (g_prgname);
1911 static gchar *g_prgname = NULL;
1912
1913 /**
1914  * g_get_prgname:
1915  *
1916  * Gets the name of the program. This name should <emphasis>not</emphasis>
1917  * be localized, contrast with g_get_application_name().
1918  * (If you are using GDK or GTK+ the program name is set in gdk_init(),
1919  * which is called by gtk_init(). The program name is found by taking
1920  * the last component of <literal>argv[0]</literal>.)
1921  *
1922  * Returns: the name of the program. The returned string belongs
1923  * to GLib and must not be modified or freed.
1924  */
1925 gchar*
1926 g_get_prgname (void)
1927 {
1928   gchar* retval;
1929
1930   G_LOCK (g_prgname);
1931 #ifdef G_OS_WIN32
1932   if (g_prgname == NULL)
1933     {
1934       static gboolean beenhere = FALSE;
1935
1936       if (!beenhere)
1937         {
1938           gchar *utf8_buf = NULL;
1939           wchar_t buf[MAX_PATH+1];
1940
1941           beenhere = TRUE;
1942           if (GetModuleFileNameW (GetModuleHandle (NULL),
1943                                   buf, G_N_ELEMENTS (buf)) > 0)
1944             utf8_buf = g_utf16_to_utf8 (buf, -1, NULL, NULL, NULL);
1945
1946           if (utf8_buf)
1947             {
1948               g_prgname = g_path_get_basename (utf8_buf);
1949               g_free (utf8_buf);
1950             }
1951         }
1952     }
1953 #endif
1954   retval = g_prgname;
1955   G_UNLOCK (g_prgname);
1956
1957   return retval;
1958 }
1959
1960 /**
1961  * g_set_prgname:
1962  * @prgname: the name of the program.
1963  *
1964  * Sets the name of the program. This name should <emphasis>not</emphasis>
1965  * be localized, contrast with g_set_application_name(). Note that for
1966  * thread-safety reasons this function can only be called once.
1967  */
1968 void
1969 g_set_prgname (const gchar *prgname)
1970 {
1971   G_LOCK (g_prgname);
1972   g_free (g_prgname);
1973   g_prgname = g_strdup (prgname);
1974   G_UNLOCK (g_prgname);
1975 }
1976
1977 G_LOCK_DEFINE_STATIC (g_application_name);
1978 static gchar *g_application_name = NULL;
1979
1980 /**
1981  * g_get_application_name:
1982  *
1983  * Gets a human-readable name for the application, as set by
1984  * g_set_application_name(). This name should be localized if
1985  * possible, and is intended for display to the user.  Contrast with
1986  * g_get_prgname(), which gets a non-localized name. If
1987  * g_set_application_name() has not been called, returns the result of
1988  * g_get_prgname() (which may be %NULL if g_set_prgname() has also not
1989  * been called).
1990  *
1991  * Return value: human-readable application name. may return %NULL
1992  *
1993  * Since: 2.2
1994  **/
1995 G_CONST_RETURN gchar*
1996 g_get_application_name (void)
1997 {
1998   gchar* retval;
1999
2000   G_LOCK (g_application_name);
2001   retval = g_application_name;
2002   G_UNLOCK (g_application_name);
2003
2004   if (retval == NULL)
2005     return g_get_prgname ();
2006
2007   return retval;
2008 }
2009
2010 /**
2011  * g_set_application_name:
2012  * @application_name: localized name of the application
2013  *
2014  * Sets a human-readable name for the application. This name should be
2015  * localized if possible, and is intended for display to the user.
2016  * Contrast with g_set_prgname(), which sets a non-localized name.
2017  * g_set_prgname() will be called automatically by gtk_init(),
2018  * but g_set_application_name() will not.
2019  *
2020  * Note that for thread safety reasons, this function can only
2021  * be called once.
2022  *
2023  * The application name will be used in contexts such as error messages,
2024  * or when displaying an application's name in the task list.
2025  *
2026  * Since: 2.2
2027  **/
2028 void
2029 g_set_application_name (const gchar *application_name)
2030 {
2031   gboolean already_set = FALSE;
2032
2033   G_LOCK (g_application_name);
2034   if (g_application_name)
2035     already_set = TRUE;
2036   else
2037     g_application_name = g_strdup (application_name);
2038   G_UNLOCK (g_application_name);
2039
2040   if (already_set)
2041     g_warning ("g_set_application_name() called multiple times");
2042 }
2043
2044 /**
2045  * g_get_user_data_dir:
2046  *
2047  * Returns a base directory in which to access application data such
2048  * as icons that is customized for a particular user.
2049  *
2050  * On UNIX platforms this is determined using the mechanisms described in
2051  * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
2052  * XDG Base Directory Specification</ulink>
2053  *
2054  * Return value: a string owned by GLib that must not be modified
2055  *               or freed.
2056  * Since: 2.6
2057  **/
2058 G_CONST_RETURN gchar*
2059 g_get_user_data_dir (void)
2060 {
2061   gchar *data_dir;
2062
2063   G_LOCK (g_utils_global);
2064
2065   if (!g_user_data_dir)
2066     {
2067 #ifdef G_OS_WIN32
2068       data_dir = get_special_folder (CSIDL_PERSONAL);
2069 #else
2070       data_dir = (gchar *) g_getenv ("XDG_DATA_HOME");
2071
2072       if (data_dir && data_dir[0])
2073         data_dir = g_strdup (data_dir);
2074 #endif
2075       if (!data_dir || !data_dir[0])
2076         {
2077           g_get_any_init ();
2078
2079           if (g_home_dir)
2080             data_dir = g_build_filename (g_home_dir, ".local",
2081                                          "share", NULL);
2082           else
2083             data_dir = g_build_filename (g_tmp_dir, g_user_name, ".local",
2084                                          "share", NULL);
2085         }
2086
2087       g_user_data_dir = data_dir;
2088     }
2089   else
2090     data_dir = g_user_data_dir;
2091
2092   G_UNLOCK (g_utils_global);
2093
2094   return data_dir;
2095 }
2096
2097 static void
2098 g_init_user_config_dir (void)
2099 {
2100   gchar *config_dir;
2101
2102   if (!g_user_config_dir)
2103     {
2104 #ifdef G_OS_WIN32
2105       config_dir = get_special_folder (CSIDL_APPDATA);
2106 #else
2107       config_dir = (gchar *) g_getenv ("XDG_CONFIG_HOME");
2108
2109       if (config_dir && config_dir[0])
2110         config_dir = g_strdup (config_dir);
2111 #endif
2112       if (!config_dir || !config_dir[0])
2113         {
2114           g_get_any_init ();
2115
2116           if (g_home_dir)
2117             config_dir = g_build_filename (g_home_dir, ".config", NULL);
2118           else
2119             config_dir = g_build_filename (g_tmp_dir, g_user_name, ".config", NULL);
2120         }
2121
2122       g_user_config_dir = config_dir;
2123     }
2124 }
2125
2126 /**
2127  * g_get_user_config_dir:
2128  *
2129  * Returns a base directory in which to store user-specific application
2130  * configuration information such as user preferences and settings.
2131  *
2132  * On UNIX platforms this is determined using the mechanisms described in
2133  * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
2134  * XDG Base Directory Specification</ulink>
2135  *
2136  * Return value: a string owned by GLib that must not be modified
2137  *               or freed.
2138  * Since: 2.6
2139  **/
2140 G_CONST_RETURN gchar*
2141 g_get_user_config_dir (void)
2142 {
2143   G_LOCK (g_utils_global);
2144
2145   g_init_user_config_dir ();
2146
2147   G_UNLOCK (g_utils_global);
2148
2149   return g_user_config_dir;
2150 }
2151
2152 /**
2153  * g_get_user_cache_dir:
2154  *
2155  * Returns a base directory in which to store non-essential, cached
2156  * data specific to particular user.
2157  *
2158  * On UNIX platforms this is determined using the mechanisms described in
2159  * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
2160  * XDG Base Directory Specification</ulink>
2161  *
2162  * Return value: a string owned by GLib that must not be modified
2163  *               or freed.
2164  * Since: 2.6
2165  **/
2166 G_CONST_RETURN gchar*
2167 g_get_user_cache_dir (void)
2168 {
2169   gchar *cache_dir;
2170
2171   G_LOCK (g_utils_global);
2172
2173   if (!g_user_cache_dir)
2174     {
2175 #ifdef G_OS_WIN32
2176       cache_dir = get_special_folder (CSIDL_INTERNET_CACHE); /* XXX correct? */
2177 #else
2178       cache_dir = (gchar *) g_getenv ("XDG_CACHE_HOME");
2179
2180       if (cache_dir && cache_dir[0])
2181           cache_dir = g_strdup (cache_dir);
2182 #endif
2183       if (!cache_dir || !cache_dir[0])
2184         {
2185           g_get_any_init ();
2186
2187           if (g_home_dir)
2188             cache_dir = g_build_filename (g_home_dir, ".cache", NULL);
2189           else
2190             cache_dir = g_build_filename (g_tmp_dir, g_user_name, ".cache", NULL);
2191         }
2192       g_user_cache_dir = cache_dir;
2193     }
2194   else
2195     cache_dir = g_user_cache_dir;
2196
2197   G_UNLOCK (g_utils_global);
2198
2199   return cache_dir;
2200 }
2201
2202 #ifdef HAVE_CARBON
2203
2204 static gchar *
2205 find_folder (OSType type)
2206 {
2207   gchar *filename = NULL;
2208   FSRef  found;
2209
2210   if (FSFindFolder (kUserDomain, type, kDontCreateFolder, &found) == noErr)
2211     {
2212       CFURLRef url = CFURLCreateFromFSRef (kCFAllocatorSystemDefault, &found);
2213
2214       if (url)
2215         {
2216           CFStringRef path = CFURLCopyFileSystemPath (url, kCFURLPOSIXPathStyle);
2217
2218           if (path)
2219             {
2220               filename = g_strdup (CFStringGetCStringPtr (path, kCFStringEncodingUTF8));
2221
2222               if (! filename)
2223                 {
2224                   filename = g_new0 (gchar, CFStringGetLength (path) * 3 + 1);
2225
2226                   CFStringGetCString (path, filename,
2227                                       CFStringGetLength (path) * 3 + 1,
2228                                       kCFStringEncodingUTF8);
2229                 }
2230
2231               CFRelease (path);
2232             }
2233
2234           CFRelease (url);
2235         }
2236     }
2237
2238   return filename;
2239 }
2240
2241 static void
2242 load_user_special_dirs (void)
2243 {
2244   g_user_special_dirs[G_USER_DIRECTORY_DESKTOP] = find_folder (kDesktopFolderType);
2245   g_user_special_dirs[G_USER_DIRECTORY_DOCUMENTS] = find_folder (kDocumentsFolderType);
2246   g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = find_folder (kDesktopFolderType); /* XXX correct ? */
2247   g_user_special_dirs[G_USER_DIRECTORY_MUSIC] = find_folder (kMusicDocumentsFolderType);
2248   g_user_special_dirs[G_USER_DIRECTORY_PICTURES] = find_folder (kPictureDocumentsFolderType);
2249   g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = NULL;
2250   g_user_special_dirs[G_USER_DIRECTORY_TEMPLATES] = NULL;
2251   g_user_special_dirs[G_USER_DIRECTORY_VIDEOS] = find_folder (kMovieDocumentsFolderType);
2252 }
2253
2254 #endif /* HAVE_CARBON */
2255
2256 #if defined(G_OS_WIN32)
2257 static void
2258 load_user_special_dirs (void)
2259 {
2260   typedef HRESULT (WINAPI *t_SHGetKnownFolderPath) (const GUID *rfid,
2261                                                     DWORD dwFlags,
2262                                                     HANDLE hToken,
2263                                                     PWSTR *ppszPath);
2264   t_SHGetKnownFolderPath p_SHGetKnownFolderPath;
2265   static const GUID FOLDERID_Downloads =
2266     { 0x374de290, 0x123f, 0x4565, { 0x91, 0x64, 0x39, 0xc4, 0x92, 0x5e, 0x46, 0x7b } };
2267   static const GUID FOLDERID_Public =
2268     { 0xDFDF76A2, 0xC82A, 0x4D63, { 0x90, 0x6A, 0x56, 0x44, 0xAC, 0x45, 0x73, 0x85 } };
2269   wchar_t *wcp;
2270
2271   p_SHGetKnownFolderPath = (t_SHGetKnownFolderPath) GetProcAddress (LoadLibrary ("shell32.dll"),
2272                                                                     "SHGetKnownFolderPath");
2273
2274   g_user_special_dirs[G_USER_DIRECTORY_DESKTOP] = get_special_folder (CSIDL_DESKTOPDIRECTORY);
2275   g_user_special_dirs[G_USER_DIRECTORY_DOCUMENTS] = get_special_folder (CSIDL_PERSONAL);
2276
2277   if (p_SHGetKnownFolderPath == NULL)
2278     {
2279       g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = get_special_folder (CSIDL_DESKTOPDIRECTORY);
2280     }
2281   else
2282     {
2283       wcp = NULL;
2284       (*p_SHGetKnownFolderPath) (&FOLDERID_Downloads, 0, NULL, &wcp);
2285       g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = g_utf16_to_utf8 (wcp, -1, NULL, NULL, NULL);
2286       if (g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] == NULL)
2287         g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = get_special_folder (CSIDL_DESKTOPDIRECTORY);
2288       CoTaskMemFree (wcp);
2289     }
2290
2291   g_user_special_dirs[G_USER_DIRECTORY_MUSIC] = get_special_folder (CSIDL_MYMUSIC);
2292   g_user_special_dirs[G_USER_DIRECTORY_PICTURES] = get_special_folder (CSIDL_MYPICTURES);
2293
2294   if (p_SHGetKnownFolderPath == NULL)
2295     {
2296       /* XXX */
2297       g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = get_special_folder (CSIDL_COMMON_DOCUMENTS);
2298     }
2299   else
2300     {
2301       wcp = NULL;
2302       (*p_SHGetKnownFolderPath) (&FOLDERID_Public, 0, NULL, &wcp);
2303       g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = g_utf16_to_utf8 (wcp, -1, NULL, NULL, NULL);
2304       if (g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] == NULL)
2305         g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = get_special_folder (CSIDL_COMMON_DOCUMENTS);
2306       CoTaskMemFree (wcp);
2307     }
2308
2309   g_user_special_dirs[G_USER_DIRECTORY_TEMPLATES] = get_special_folder (CSIDL_TEMPLATES);
2310   g_user_special_dirs[G_USER_DIRECTORY_VIDEOS] = get_special_folder (CSIDL_MYVIDEO);
2311 }
2312 #endif /* G_OS_WIN32 */
2313
2314 static void g_init_user_config_dir (void);
2315
2316 #if defined(G_OS_UNIX) && !defined(HAVE_CARBON)
2317
2318 /* adapted from xdg-user-dir-lookup.c
2319  *
2320  * Copyright (C) 2007 Red Hat Inc.
2321  *
2322  * Permission is hereby granted, free of charge, to any person
2323  * obtaining a copy of this software and associated documentation files
2324  * (the "Software"), to deal in the Software without restriction,
2325  * including without limitation the rights to use, copy, modify, merge,
2326  * publish, distribute, sublicense, and/or sell copies of the Software,
2327  * and to permit persons to whom the Software is furnished to do so,
2328  * subject to the following conditions:
2329  *
2330  * The above copyright notice and this permission notice shall be
2331  * included in all copies or substantial portions of the Software.
2332  *
2333  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
2334  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
2335  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
2336  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
2337  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
2338  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
2339  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
2340  * SOFTWARE.
2341  */
2342 static void
2343 load_user_special_dirs (void)
2344 {
2345   gchar *config_file;
2346   gchar *data;
2347   gchar **lines;
2348   gint n_lines, i;
2349
2350   g_init_user_config_dir ();
2351   config_file = g_build_filename (g_user_config_dir,
2352                                   "user-dirs.dirs",
2353                                   NULL);
2354
2355   if (!g_file_get_contents (config_file, &data, NULL, NULL))
2356     {
2357       g_free (config_file);
2358       return;
2359     }
2360
2361   lines = g_strsplit (data, "\n", -1);
2362   n_lines = g_strv_length (lines);
2363   g_free (data);
2364
2365   for (i = 0; i < n_lines; i++)
2366     {
2367       gchar *buffer = lines[i];
2368       gchar *d, *p;
2369       gint len;
2370       gboolean is_relative = FALSE;
2371       GUserDirectory directory;
2372
2373       /* Remove newline at end */
2374       len = strlen (buffer);
2375       if (len > 0 && buffer[len - 1] == '\n')
2376         buffer[len - 1] = 0;
2377
2378       p = buffer;
2379       while (*p == ' ' || *p == '\t')
2380         p++;
2381
2382       if (strncmp (p, "XDG_DESKTOP_DIR", strlen ("XDG_DESKTOP_DIR")) == 0)
2383         {
2384           directory = G_USER_DIRECTORY_DESKTOP;
2385           p += strlen ("XDG_DESKTOP_DIR");
2386         }
2387       else if (strncmp (p, "XDG_DOCUMENTS_DIR", strlen ("XDG_DOCUMENTS_DIR")) == 0)
2388         {
2389           directory = G_USER_DIRECTORY_DOCUMENTS;
2390           p += strlen ("XDG_DOCUMENTS_DIR");
2391         }
2392       else if (strncmp (p, "XDG_DOWNLOAD_DIR", strlen ("XDG_DOWNLOAD_DIR")) == 0)
2393         {
2394           directory = G_USER_DIRECTORY_DOWNLOAD;
2395           p += strlen ("XDG_DOWNLOAD_DIR");
2396         }
2397       else if (strncmp (p, "XDG_MUSIC_DIR", strlen ("XDG_MUSIC_DIR")) == 0)
2398         {
2399           directory = G_USER_DIRECTORY_MUSIC;
2400           p += strlen ("XDG_MUSIC_DIR");
2401         }
2402       else if (strncmp (p, "XDG_PICTURES_DIR", strlen ("XDG_PICTURES_DIR")) == 0)
2403         {
2404           directory = G_USER_DIRECTORY_PICTURES;
2405           p += strlen ("XDG_PICTURES_DIR");
2406         }
2407       else if (strncmp (p, "XDG_PUBLICSHARE_DIR", strlen ("XDG_PUBLICSHARE_DIR")) == 0)
2408         {
2409           directory = G_USER_DIRECTORY_PUBLIC_SHARE;
2410           p += strlen ("XDG_PUBLICSHARE_DIR");
2411         }
2412       else if (strncmp (p, "XDG_TEMPLATES_DIR", strlen ("XDG_TEMPLATES_DIR")) == 0)
2413         {
2414           directory = G_USER_DIRECTORY_TEMPLATES;
2415           p += strlen ("XDG_TEMPLATES_DIR");
2416         }
2417       else if (strncmp (p, "XDG_VIDEOS_DIR", strlen ("XDG_VIDEOS_DIR")) == 0)
2418         {
2419           directory = G_USER_DIRECTORY_VIDEOS;
2420           p += strlen ("XDG_VIDEOS_DIR");
2421         }
2422       else
2423         continue;
2424
2425       while (*p == ' ' || *p == '\t')
2426         p++;
2427
2428       if (*p != '=')
2429         continue;
2430       p++;
2431
2432       while (*p == ' ' || *p == '\t')
2433         p++;
2434
2435       if (*p != '"')
2436         continue;
2437       p++;
2438
2439       if (strncmp (p, "$HOME", 5) == 0)
2440         {
2441           p += 5;
2442           is_relative = TRUE;
2443         }
2444       else if (*p != '/')
2445         continue;
2446
2447       d = strrchr (p, '"');
2448       if (!d)
2449         continue;
2450       *d = 0;
2451
2452       d = p;
2453
2454       /* remove trailing slashes */
2455       len = strlen (d);
2456       if (d[len - 1] == '/')
2457         d[len - 1] = 0;
2458
2459       if (is_relative)
2460         {
2461           g_get_any_init ();
2462           g_user_special_dirs[directory] = g_build_filename (g_home_dir, d, NULL);
2463         }
2464       else
2465         g_user_special_dirs[directory] = g_strdup (d);
2466     }
2467
2468   g_strfreev (lines);
2469   g_free (config_file);
2470 }
2471
2472 #endif /* G_OS_UNIX && !HAVE_CARBON */
2473
2474
2475 /**
2476  * g_reload_user_special_dirs_cache:
2477  *
2478  * Resets the cache used for g_get_user_special_dir(), so
2479  * that the latest on-disk version is used. Call this only
2480  * if you just changed the data on disk yourself.
2481  *
2482  * Due to threadsafety issues this may cause leaking of strings
2483  * that were previously returned from g_get_user_special_dir()
2484  * that can't be freed. We ensure to only leak the data for
2485  * the directories that actually changed value though.
2486  *
2487  * Since: 2.22
2488  */
2489 void
2490 g_reload_user_special_dirs_cache (void)
2491 {
2492   int i;
2493
2494   G_LOCK (g_utils_global);
2495
2496   if (g_user_special_dirs != NULL)
2497     {
2498       /* save a copy of the pointer, to check if some memory can be preserved */
2499       char **old_g_user_special_dirs = g_user_special_dirs;
2500       char *old_val;
2501
2502       /* recreate and reload our cache */
2503       g_user_special_dirs = g_new0 (gchar *, G_USER_N_DIRECTORIES);
2504       load_user_special_dirs ();
2505
2506       /* only leak changed directories */
2507       for (i = 0; i < G_USER_N_DIRECTORIES; i++)
2508         {
2509           old_val = old_g_user_special_dirs[i];
2510           if (g_strcmp0 (old_val, g_user_special_dirs[i]) == 0)
2511             {
2512               /* don't leak */
2513               g_free (g_user_special_dirs[i]);
2514               g_user_special_dirs[i] = old_val;
2515             }
2516           else
2517             g_free (old_val);
2518         }
2519
2520       /* free the old array */
2521       g_free (old_g_user_special_dirs);
2522     }
2523
2524   G_UNLOCK (g_utils_global);
2525 }
2526
2527 /**
2528  * g_get_user_special_dir:
2529  * @directory: the logical id of special directory
2530  *
2531  * Returns the full path of a special directory using its logical id.
2532  *
2533  * On Unix this is done using the XDG special user directories.
2534  * For compatibility with existing practise, %G_USER_DIRECTORY_DESKTOP
2535  * falls back to <filename>$HOME/Desktop</filename> when XDG special
2536  * user directories have not been set up.
2537  *
2538  * Depending on the platform, the user might be able to change the path
2539  * of the special directory without requiring the session to restart; GLib
2540  * will not reflect any change once the special directories are loaded.
2541  *
2542  * Return value: the path to the specified special directory, or %NULL
2543  *   if the logical id was not found. The returned string is owned by
2544  *   GLib and should not be modified or freed.
2545  *
2546  * Since: 2.14
2547  */
2548 G_CONST_RETURN gchar *
2549 g_get_user_special_dir (GUserDirectory directory)
2550 {
2551   g_return_val_if_fail (directory >= G_USER_DIRECTORY_DESKTOP &&
2552                         directory < G_USER_N_DIRECTORIES, NULL);
2553
2554   G_LOCK (g_utils_global);
2555
2556   if (G_UNLIKELY (g_user_special_dirs == NULL))
2557     {
2558       g_user_special_dirs = g_new0 (gchar *, G_USER_N_DIRECTORIES);
2559
2560       load_user_special_dirs ();
2561
2562       /* Special-case desktop for historical compatibility */
2563       if (g_user_special_dirs[G_USER_DIRECTORY_DESKTOP] == NULL)
2564         {
2565           g_get_any_init ();
2566
2567           g_user_special_dirs[G_USER_DIRECTORY_DESKTOP] =
2568             g_build_filename (g_home_dir, "Desktop", NULL);
2569         }
2570     }
2571
2572   G_UNLOCK (g_utils_global);
2573
2574   return g_user_special_dirs[directory];
2575 }
2576
2577 #ifdef G_OS_WIN32
2578
2579 #undef g_get_system_data_dirs
2580
2581 static HMODULE
2582 get_module_for_address (gconstpointer address)
2583 {
2584   /* Holds the g_utils_global lock */
2585
2586   static gboolean beenhere = FALSE;
2587   typedef BOOL (WINAPI *t_GetModuleHandleExA) (DWORD, LPCTSTR, HMODULE *);
2588   static t_GetModuleHandleExA p_GetModuleHandleExA = NULL;
2589   HMODULE hmodule = NULL;
2590
2591   if (!address)
2592     return NULL;
2593
2594   if (!beenhere)
2595     {
2596       p_GetModuleHandleExA =
2597         (t_GetModuleHandleExA) GetProcAddress (LoadLibrary ("kernel32.dll"),
2598                                                "GetModuleHandleExA");
2599       beenhere = TRUE;
2600     }
2601
2602   if (p_GetModuleHandleExA == NULL ||
2603       !(*p_GetModuleHandleExA) (GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT |
2604                                 GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
2605                                 address, &hmodule))
2606     {
2607       MEMORY_BASIC_INFORMATION mbi;
2608       VirtualQuery (address, &mbi, sizeof (mbi));
2609       hmodule = (HMODULE) mbi.AllocationBase;
2610     }
2611
2612   return hmodule;
2613 }
2614
2615 static gchar *
2616 get_module_share_dir (gconstpointer address)
2617 {
2618   HMODULE hmodule;
2619   gchar *filename;
2620   gchar *retval;
2621
2622   hmodule = get_module_for_address (address);
2623   if (hmodule == NULL)
2624     return NULL;
2625
2626   filename = g_win32_get_package_installation_directory_of_module (hmodule);
2627   retval = g_build_filename (filename, "share", NULL);
2628   g_free (filename);
2629
2630   return retval;
2631 }
2632
2633 G_CONST_RETURN gchar * G_CONST_RETURN *
2634 g_win32_get_system_data_dirs_for_module (void (*address_of_function)())
2635 {
2636   GArray *data_dirs;
2637   HMODULE hmodule;
2638   static GHashTable *per_module_data_dirs = NULL;
2639   gchar **retval;
2640   gchar *p;
2641   gchar *exe_root;
2642
2643   if (address_of_function)
2644     {
2645       G_LOCK (g_utils_global);
2646       hmodule = get_module_for_address (address_of_function);
2647       if (hmodule != NULL)
2648         {
2649           if (per_module_data_dirs == NULL)
2650             per_module_data_dirs = g_hash_table_new (NULL, NULL);
2651           else
2652             {
2653               retval = g_hash_table_lookup (per_module_data_dirs, hmodule);
2654
2655               if (retval != NULL)
2656                 {
2657                   G_UNLOCK (g_utils_global);
2658                   return (G_CONST_RETURN gchar * G_CONST_RETURN *) retval;
2659                 }
2660             }
2661         }
2662     }
2663
2664   data_dirs = g_array_new (TRUE, TRUE, sizeof (char *));
2665
2666   /* Documents and Settings\All Users\Application Data */
2667   p = get_special_folder (CSIDL_COMMON_APPDATA);
2668   if (p)
2669     g_array_append_val (data_dirs, p);
2670
2671   /* Documents and Settings\All Users\Documents */
2672   p = get_special_folder (CSIDL_COMMON_DOCUMENTS);
2673   if (p)
2674     g_array_append_val (data_dirs, p);
2675
2676   /* Using the above subfolders of Documents and Settings perhaps
2677    * makes sense from a Windows perspective.
2678    *
2679    * But looking at the actual use cases of this function in GTK+
2680    * and GNOME software, what we really want is the "share"
2681    * subdirectory of the installation directory for the package
2682    * our caller is a part of.
2683    *
2684    * The address_of_function parameter, if non-NULL, points to a
2685    * function in the calling module. Use that to determine that
2686    * module's installation folder, and use its "share" subfolder.
2687    *
2688    * Additionally, also use the "share" subfolder of the installation
2689    * locations of GLib and the .exe file being run.
2690    *
2691    * To guard against none of the above being what is really wanted,
2692    * callers of this function should have Win32-specific code to look
2693    * up their installation folder themselves, and handle a subfolder
2694    * "share" of it in the same way as the folders returned from this
2695    * function.
2696    */
2697
2698   p = get_module_share_dir (address_of_function);
2699   if (p)
2700     g_array_append_val (data_dirs, p);
2701
2702   if (glib_dll != NULL)
2703     {
2704       gchar *glib_root = g_win32_get_package_installation_directory_of_module (glib_dll);
2705       p = g_build_filename (glib_root, "share", NULL);
2706       if (p)
2707         g_array_append_val (data_dirs, p);
2708       g_free (glib_root);
2709     }
2710
2711   exe_root = g_win32_get_package_installation_directory_of_module (NULL);
2712   p = g_build_filename (exe_root, "share", NULL);
2713   if (p)
2714     g_array_append_val (data_dirs, p);
2715   g_free (exe_root);
2716
2717   retval = (gchar **) g_array_free (data_dirs, FALSE);
2718
2719   if (address_of_function)
2720     {
2721       if (hmodule != NULL)
2722         g_hash_table_insert (per_module_data_dirs, hmodule, retval);
2723       G_UNLOCK (g_utils_global);
2724     }
2725
2726   return (G_CONST_RETURN gchar * G_CONST_RETURN *) retval;
2727 }
2728
2729 #endif
2730
2731 /**
2732  * g_get_system_data_dirs:
2733  *
2734  * Returns an ordered list of base directories in which to access
2735  * system-wide application data.
2736  *
2737  * On UNIX platforms this is determined using the mechanisms described in
2738  * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
2739  * XDG Base Directory Specification</ulink>
2740  *
2741  * On Windows the first elements in the list are the Application Data
2742  * and Documents folders for All Users. (These can be determined only
2743  * on Windows 2000 or later and are not present in the list on other
2744  * Windows versions.) See documentation for CSIDL_COMMON_APPDATA and
2745  * CSIDL_COMMON_DOCUMENTS.
2746  *
2747  * Then follows the "share" subfolder in the installation folder for
2748  * the package containing the DLL that calls this function, if it can
2749  * be determined.
2750  *
2751  * Finally the list contains the "share" subfolder in the installation
2752  * folder for GLib, and in the installation folder for the package the
2753  * application's .exe file belongs to.
2754  *
2755  * The installation folders above are determined by looking up the
2756  * folder where the module (DLL or EXE) in question is located. If the
2757  * folder's name is "bin", its parent is used, otherwise the folder
2758  * itself.
2759  *
2760  * Note that on Windows the returned list can vary depending on where
2761  * this function is called.
2762  *
2763  * Return value: a %NULL-terminated array of strings owned by GLib that must
2764  *               not be modified or freed.
2765  * Since: 2.6
2766  **/
2767 G_CONST_RETURN gchar * G_CONST_RETURN *
2768 g_get_system_data_dirs (void)
2769 {
2770   gchar **data_dir_vector;
2771
2772   G_LOCK (g_utils_global);
2773
2774   if (!g_system_data_dirs)
2775     {
2776 #ifdef G_OS_WIN32
2777       data_dir_vector = (gchar **) g_win32_get_system_data_dirs_for_module (NULL);
2778 #else
2779       gchar *data_dirs = (gchar *) g_getenv ("XDG_DATA_DIRS");
2780
2781       if (!data_dirs || !data_dirs[0])
2782           data_dirs = "/usr/local/share/:/usr/share/";
2783
2784       data_dir_vector = g_strsplit (data_dirs, G_SEARCHPATH_SEPARATOR_S, 0);
2785 #endif
2786
2787       g_system_data_dirs = data_dir_vector;
2788     }
2789   else
2790     data_dir_vector = g_system_data_dirs;
2791
2792   G_UNLOCK (g_utils_global);
2793
2794   return (G_CONST_RETURN gchar * G_CONST_RETURN *) data_dir_vector;
2795 }
2796
2797 /**
2798  * g_get_system_config_dirs:
2799  *
2800  * Returns an ordered list of base directories in which to access
2801  * system-wide configuration information.
2802  *
2803  * On UNIX platforms this is determined using the mechanisms described in
2804  * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
2805  * XDG Base Directory Specification</ulink>
2806  *
2807  * Return value: a %NULL-terminated array of strings owned by GLib that must
2808  *               not be modified or freed.
2809  * Since: 2.6
2810  **/
2811 G_CONST_RETURN gchar * G_CONST_RETURN *
2812 g_get_system_config_dirs (void)
2813 {
2814   gchar *conf_dirs, **conf_dir_vector;
2815
2816   G_LOCK (g_utils_global);
2817
2818   if (!g_system_config_dirs)
2819     {
2820 #ifdef G_OS_WIN32
2821       conf_dirs = get_special_folder (CSIDL_COMMON_APPDATA);
2822       if (conf_dirs)
2823         {
2824           conf_dir_vector = g_strsplit (conf_dirs, G_SEARCHPATH_SEPARATOR_S, 0);
2825           g_free (conf_dirs);
2826         }
2827       else
2828         {
2829           /* Return empty list */
2830           conf_dir_vector = g_strsplit ("", G_SEARCHPATH_SEPARATOR_S, 0);
2831         }
2832 #else
2833       conf_dirs = (gchar *) g_getenv ("XDG_CONFIG_DIRS");
2834
2835       if (!conf_dirs || !conf_dirs[0])
2836           conf_dirs = "/etc/xdg";
2837
2838       conf_dir_vector = g_strsplit (conf_dirs, G_SEARCHPATH_SEPARATOR_S, 0);
2839 #endif
2840
2841       g_system_config_dirs = conf_dir_vector;
2842     }
2843   else
2844     conf_dir_vector = g_system_config_dirs;
2845   G_UNLOCK (g_utils_global);
2846
2847   return (G_CONST_RETURN gchar * G_CONST_RETURN *) conf_dir_vector;
2848 }
2849
2850 #ifndef G_OS_WIN32
2851
2852 static GHashTable *alias_table = NULL;
2853
2854 /* read an alias file for the locales */
2855 static void
2856 read_aliases (gchar *file)
2857 {
2858   FILE *fp;
2859   char buf[256];
2860
2861   if (!alias_table)
2862     alias_table = g_hash_table_new (g_str_hash, g_str_equal);
2863   fp = fopen (file,"r");
2864   if (!fp)
2865     return;
2866   while (fgets (buf, 256, fp))
2867     {
2868       char *p, *q;
2869
2870       g_strstrip (buf);
2871
2872       /* Line is a comment */
2873       if ((buf[0] == '#') || (buf[0] == '\0'))
2874         continue;
2875
2876       /* Reads first column */
2877       for (p = buf, q = NULL; *p; p++) {
2878         if ((*p == '\t') || (*p == ' ') || (*p == ':')) {
2879           *p = '\0';
2880           q = p+1;
2881           while ((*q == '\t') || (*q == ' ')) {
2882             q++;
2883           }
2884           break;
2885         }
2886       }
2887       /* The line only had one column */
2888       if (!q || *q == '\0')
2889         continue;
2890
2891       /* Read second column */
2892       for (p = q; *p; p++) {
2893         if ((*p == '\t') || (*p == ' ')) {
2894           *p = '\0';
2895           break;
2896         }
2897       }
2898
2899       /* Add to alias table if necessary */
2900       if (!g_hash_table_lookup (alias_table, buf)) {
2901         g_hash_table_insert (alias_table, g_strdup (buf), g_strdup (q));
2902       }
2903     }
2904   fclose (fp);
2905 }
2906
2907 #endif
2908
2909 static char *
2910 unalias_lang (char *lang)
2911 {
2912 #ifndef G_OS_WIN32
2913   char *p;
2914   int i;
2915
2916   if (!alias_table)
2917     read_aliases ("/usr/share/locale/locale.alias");
2918
2919   i = 0;
2920   while ((p = g_hash_table_lookup (alias_table, lang)) && (strcmp (p, lang) != 0))
2921     {
2922       lang = p;
2923       if (i++ == 30)
2924         {
2925           static gboolean said_before = FALSE;
2926           if (!said_before)
2927             g_warning ("Too many alias levels for a locale, "
2928                        "may indicate a loop");
2929           said_before = TRUE;
2930           return lang;
2931         }
2932     }
2933 #endif
2934   return lang;
2935 }
2936
2937 /* Mask for components of locale spec. The ordering here is from
2938  * least significant to most significant
2939  */
2940 enum
2941 {
2942   COMPONENT_CODESET =   1 << 0,
2943   COMPONENT_TERRITORY = 1 << 1,
2944   COMPONENT_MODIFIER =  1 << 2
2945 };
2946
2947 /* Break an X/Open style locale specification into components
2948  */
2949 static guint
2950 explode_locale (const gchar *locale,
2951                 gchar      **language,
2952                 gchar      **territory,
2953                 gchar      **codeset,
2954                 gchar      **modifier)
2955 {
2956   const gchar *uscore_pos;
2957   const gchar *at_pos;
2958   const gchar *dot_pos;
2959
2960   guint mask = 0;
2961
2962   uscore_pos = strchr (locale, '_');
2963   dot_pos = strchr (uscore_pos ? uscore_pos : locale, '.');
2964   at_pos = strchr (dot_pos ? dot_pos : (uscore_pos ? uscore_pos : locale), '@');
2965
2966   if (at_pos)
2967     {
2968       mask |= COMPONENT_MODIFIER;
2969       *modifier = g_strdup (at_pos);
2970     }
2971   else
2972     at_pos = locale + strlen (locale);
2973
2974   if (dot_pos)
2975     {
2976       mask |= COMPONENT_CODESET;
2977       *codeset = g_strndup (dot_pos, at_pos - dot_pos);
2978     }
2979   else
2980     dot_pos = at_pos;
2981
2982   if (uscore_pos)
2983     {
2984       mask |= COMPONENT_TERRITORY;
2985       *territory = g_strndup (uscore_pos, dot_pos - uscore_pos);
2986     }
2987   else
2988     uscore_pos = dot_pos;
2989
2990   *language = g_strndup (locale, uscore_pos - locale);
2991
2992   return mask;
2993 }
2994
2995 /*
2996  * Compute all interesting variants for a given locale name -
2997  * by stripping off different components of the value.
2998  *
2999  * For simplicity, we assume that the locale is in
3000  * X/Open format: language[_territory][.codeset][@modifier]
3001  *
3002  * TODO: Extend this to handle the CEN format (see the GNUlibc docs)
3003  *       as well. We could just copy the code from glibc wholesale
3004  *       but it is big, ugly, and complicated, so I'm reluctant
3005  *       to do so when this should handle 99% of the time...
3006  */
3007 GSList *
3008 _g_compute_locale_variants (const gchar *locale)
3009 {
3010   GSList *retval = NULL;
3011
3012   gchar *language = NULL;
3013   gchar *territory = NULL;
3014   gchar *codeset = NULL;
3015   gchar *modifier = NULL;
3016
3017   guint mask;
3018   guint i;
3019
3020   g_return_val_if_fail (locale != NULL, NULL);
3021
3022   mask = explode_locale (locale, &language, &territory, &codeset, &modifier);
3023
3024   /* Iterate through all possible combinations, from least attractive
3025    * to most attractive.
3026    */
3027   for (i = 0; i <= mask; i++)
3028     if ((i & ~mask) == 0)
3029       {
3030         gchar *val = g_strconcat (language,
3031                                   (i & COMPONENT_TERRITORY) ? territory : "",
3032                                   (i & COMPONENT_CODESET) ? codeset : "",
3033                                   (i & COMPONENT_MODIFIER) ? modifier : "",
3034                                   NULL);
3035         retval = g_slist_prepend (retval, val);
3036       }
3037
3038   g_free (language);
3039   if (mask & COMPONENT_CODESET)
3040     g_free (codeset);
3041   if (mask & COMPONENT_TERRITORY)
3042     g_free (territory);
3043   if (mask & COMPONENT_MODIFIER)
3044     g_free (modifier);
3045
3046   return retval;
3047 }
3048
3049 /* The following is (partly) taken from the gettext package.
3050    Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.  */
3051
3052 static const gchar *
3053 guess_category_value (const gchar *category_name)
3054 {
3055   const gchar *retval;
3056
3057   /* The highest priority value is the `LANGUAGE' environment
3058      variable.  This is a GNU extension.  */
3059   retval = g_getenv ("LANGUAGE");
3060   if ((retval != NULL) && (retval[0] != '\0'))
3061     return retval;
3062
3063   /* `LANGUAGE' is not set.  So we have to proceed with the POSIX
3064      methods of looking to `LC_ALL', `LC_xxx', and `LANG'.  On some
3065      systems this can be done by the `setlocale' function itself.  */
3066
3067   /* Setting of LC_ALL overwrites all other.  */
3068   retval = g_getenv ("LC_ALL");
3069   if ((retval != NULL) && (retval[0] != '\0'))
3070     return retval;
3071
3072   /* Next comes the name of the desired category.  */
3073   retval = g_getenv (category_name);
3074   if ((retval != NULL) && (retval[0] != '\0'))
3075     return retval;
3076
3077   /* Last possibility is the LANG environment variable.  */
3078   retval = g_getenv ("LANG");
3079   if ((retval != NULL) && (retval[0] != '\0'))
3080     return retval;
3081
3082 #ifdef G_PLATFORM_WIN32
3083   /* g_win32_getlocale() first checks for LC_ALL, LC_MESSAGES and
3084    * LANG, which we already did above. Oh well. The main point of
3085    * calling g_win32_getlocale() is to get the thread's locale as used
3086    * by Windows and the Microsoft C runtime (in the "English_United
3087    * States" format) translated into the Unixish format.
3088    */
3089   retval = g_win32_getlocale ();
3090   if ((retval != NULL) && (retval[0] != '\0'))
3091     return retval;
3092 #endif
3093
3094   return NULL;
3095 }
3096
3097 typedef struct _GLanguageNamesCache GLanguageNamesCache;
3098
3099 struct _GLanguageNamesCache {
3100   gchar *languages;
3101   gchar **language_names;
3102 };
3103
3104 static void
3105 language_names_cache_free (gpointer data)
3106 {
3107   GLanguageNamesCache *cache = data;
3108   g_free (cache->languages);
3109   g_strfreev (cache->language_names);
3110   g_free (cache);
3111 }
3112
3113 /**
3114  * g_get_language_names:
3115  *
3116  * Computes a list of applicable locale names, which can be used to
3117  * e.g. construct locale-dependent filenames or search paths. The returned
3118  * list is sorted from most desirable to least desirable and always contains
3119  * the default locale "C".
3120  *
3121  * For example, if LANGUAGE=de:en_US, then the returned list is
3122  * "de", "en_US", "en", "C".
3123  *
3124  * This function consults the environment variables <envar>LANGUAGE</envar>,
3125  * <envar>LC_ALL</envar>, <envar>LC_MESSAGES</envar> and <envar>LANG</envar>
3126  * to find the list of locales specified by the user.
3127  *
3128  * Return value: a %NULL-terminated array of strings owned by GLib
3129  *    that must not be modified or freed.
3130  *
3131  * Since: 2.6
3132  **/
3133 G_CONST_RETURN gchar * G_CONST_RETURN *
3134 g_get_language_names (void)
3135 {
3136   static GStaticPrivate cache_private = G_STATIC_PRIVATE_INIT;
3137   GLanguageNamesCache *cache = g_static_private_get (&cache_private);
3138   const gchar *value;
3139
3140   if (!cache)
3141     {
3142       cache = g_new0 (GLanguageNamesCache, 1);
3143       g_static_private_set (&cache_private, cache, language_names_cache_free);
3144     }
3145
3146   value = guess_category_value ("LC_MESSAGES");
3147   if (!value)
3148     value = "C";
3149
3150   if (!(cache->languages && strcmp (cache->languages, value) == 0))
3151     {
3152       gchar **languages;
3153       gchar **alist, **a;
3154       GSList *list, *l;
3155       gint i;
3156
3157       g_free (cache->languages);
3158       g_strfreev (cache->language_names);
3159       cache->languages = g_strdup (value);
3160
3161       alist = g_strsplit (value, ":", 0);
3162       list = NULL;
3163       for (a = alist; *a; a++)
3164         {
3165           gchar *b = unalias_lang (*a);
3166           list = g_slist_concat (list, _g_compute_locale_variants (b));
3167         }
3168       g_strfreev (alist);
3169       list = g_slist_append (list, g_strdup ("C"));
3170
3171       cache->language_names = languages = g_new (gchar *, g_slist_length (list) + 1);
3172       for (l = list, i = 0; l; l = l->next, i++)
3173         languages[i] = l->data;
3174       languages[i] = NULL;
3175
3176       g_slist_free (list);
3177     }
3178
3179   return (G_CONST_RETURN gchar * G_CONST_RETURN *) cache->language_names;
3180 }
3181
3182 /**
3183  * g_direct_hash:
3184  * @v: a #gpointer key
3185  *
3186  * Converts a gpointer to a hash value.
3187  * It can be passed to g_hash_table_new() as the @hash_func parameter,
3188  * when using pointers as keys in a #GHashTable.
3189  *
3190  * Returns: a hash value corresponding to the key.
3191  */
3192 guint
3193 g_direct_hash (gconstpointer v)
3194 {
3195   return GPOINTER_TO_UINT (v);
3196 }
3197
3198 /**
3199  * g_direct_equal:
3200  * @v1: a key.
3201  * @v2: a key to compare with @v1.
3202  *
3203  * Compares two #gpointer arguments and returns %TRUE if they are equal.
3204  * It can be passed to g_hash_table_new() as the @key_equal_func
3205  * parameter, when using pointers as keys in a #GHashTable.
3206  *
3207  * Returns: %TRUE if the two keys match.
3208  */
3209 gboolean
3210 g_direct_equal (gconstpointer v1,
3211                 gconstpointer v2)
3212 {
3213   return v1 == v2;
3214 }
3215
3216 /**
3217  * g_int_equal:
3218  * @v1: a pointer to a #gint key.
3219  * @v2: a pointer to a #gint key to compare with @v1.
3220  *
3221  * Compares the two #gint values being pointed to and returns
3222  * %TRUE if they are equal.
3223  * It can be passed to g_hash_table_new() as the @key_equal_func
3224  * parameter, when using pointers to integers as keys in a #GHashTable.
3225  *
3226  * Returns: %TRUE if the two keys match.
3227  */
3228 gboolean
3229 g_int_equal (gconstpointer v1,
3230              gconstpointer v2)
3231 {
3232   return *((const gint*) v1) == *((const gint*) v2);
3233 }
3234
3235 /**
3236  * g_int_hash:
3237  * @v: a pointer to a #gint key
3238  *
3239  * Converts a pointer to a #gint to a hash value.
3240  * It can be passed to g_hash_table_new() as the @hash_func parameter,
3241  * when using pointers to integers values as keys in a #GHashTable.
3242  *
3243  * Returns: a hash value corresponding to the key.
3244  */
3245 guint
3246 g_int_hash (gconstpointer v)
3247 {
3248   return *(const gint*) v;
3249 }
3250
3251 /**
3252  * g_int64_equal:
3253  * @v1: a pointer to a #gint64 key.
3254  * @v2: a pointer to a #gint64 key to compare with @v1.
3255  *
3256  * Compares the two #gint64 values being pointed to and returns
3257  * %TRUE if they are equal.
3258  * It can be passed to g_hash_table_new() as the @key_equal_func
3259  * parameter, when using pointers to 64-bit integers as keys in a #GHashTable.
3260  *
3261  * Returns: %TRUE if the two keys match.
3262  *
3263  * Since: 2.22
3264  */
3265 gboolean
3266 g_int64_equal (gconstpointer v1,
3267                gconstpointer v2)
3268 {
3269   return *((const gint64*) v1) == *((const gint64*) v2);
3270 }
3271
3272 /**
3273  * g_int64_hash:
3274  * @v: a pointer to a #gint64 key
3275  *
3276  * Converts a pointer to a #gint64 to a hash value.
3277  * It can be passed to g_hash_table_new() as the @hash_func parameter,
3278  * when using pointers to 64-bit integers values as keys in a #GHashTable.
3279  *
3280  * Returns: a hash value corresponding to the key.
3281  *
3282  * Since: 2.22
3283  */
3284 guint
3285 g_int64_hash (gconstpointer v)
3286 {
3287   return (guint) *(const gint64*) v;
3288 }
3289
3290 /**
3291  * g_double_equal:
3292  * @v1: a pointer to a #gdouble key.
3293  * @v2: a pointer to a #gdouble key to compare with @v1.
3294  *
3295  * Compares the two #gdouble values being pointed to and returns
3296  * %TRUE if they are equal.
3297  * It can be passed to g_hash_table_new() as the @key_equal_func
3298  * parameter, when using pointers to doubles as keys in a #GHashTable.
3299  *
3300  * Returns: %TRUE if the two keys match.
3301  *
3302  * Since: 2.22
3303  */
3304 gboolean
3305 g_double_equal (gconstpointer v1,
3306                 gconstpointer v2)
3307 {
3308   return *((const gdouble*) v1) == *((const gdouble*) v2);
3309 }
3310
3311 /**
3312  * g_double_hash:
3313  * @v: a pointer to a #gdouble key
3314  *
3315  * Converts a pointer to a #gdouble to a hash value.
3316  * It can be passed to g_hash_table_new() as the @hash_func parameter,
3317  * when using pointers to doubles as keys in a #GHashTable.
3318  *
3319  * Returns: a hash value corresponding to the key.
3320  *
3321  * Since: 2.22
3322  */
3323 guint
3324 g_double_hash (gconstpointer v)
3325 {
3326   return (guint) *(const gdouble*) v;
3327 }
3328
3329 /**
3330  * g_nullify_pointer:
3331  * @nullify_location: the memory address of the pointer.
3332  *
3333  * Set the pointer at the specified location to %NULL.
3334  **/
3335 void
3336 g_nullify_pointer (gpointer *nullify_location)
3337 {
3338   g_return_if_fail (nullify_location != NULL);
3339
3340   *nullify_location = NULL;
3341 }
3342
3343 /**
3344  * g_get_codeset:
3345  *
3346  * Get the codeset for the current locale.
3347  *
3348  * Return value: a newly allocated string containing the name
3349  * of the codeset. This string must be freed with g_free().
3350  **/
3351 gchar *
3352 g_get_codeset (void)
3353 {
3354   const gchar *charset;
3355
3356   g_get_charset (&charset);
3357
3358   return g_strdup (charset);
3359 }
3360
3361 /* This is called from g_thread_init(). It's used to
3362  * initialize some static data in a threadsafe way.
3363  */
3364 void
3365 _g_utils_thread_init (void)
3366 {
3367   g_get_language_names ();
3368 }
3369
3370 #ifdef G_OS_WIN32
3371
3372 /**
3373  * _glib_get_locale_dir:
3374  *
3375  * Return the path to the share\locale or lib\locale subfolder of the
3376  * GLib installation folder. The path is in the system codepage. We
3377  * have to use system codepage as bindtextdomain() doesn't have a
3378  * UTF-8 interface.
3379  */
3380 static gchar *
3381 _glib_get_locale_dir (void)
3382 {
3383   gchar *install_dir = NULL, *locale_dir;
3384   gchar *retval = NULL;
3385
3386   if (glib_dll != NULL)
3387     install_dir = g_win32_get_package_installation_directory_of_module (glib_dll);
3388
3389   if (install_dir)
3390     {
3391       /*
3392        * Append "/share/locale" or "/lib/locale" depending on whether
3393        * autoconfigury detected GNU gettext or not.
3394        */
3395       const char *p = GLIB_LOCALE_DIR + strlen (GLIB_LOCALE_DIR);
3396       while (*--p != '/')
3397         ;
3398       while (*--p != '/')
3399         ;
3400
3401       locale_dir = g_build_filename (install_dir, p, NULL);
3402
3403       retval = g_win32_locale_filename_from_utf8 (locale_dir);
3404
3405       g_free (install_dir);
3406       g_free (locale_dir);
3407     }
3408
3409   if (retval)
3410     return retval;
3411   else
3412     return g_strdup ("");
3413 }
3414
3415 #undef GLIB_LOCALE_DIR
3416
3417 #endif /* G_OS_WIN32 */
3418
3419 /**
3420  * glib_gettext:
3421  * @str: The string to be translated
3422  *
3423  * Returns the translated string from the glib translations.
3424  * This is an internal function and should only be used by
3425  * the internals of glib (such as libgio).
3426  *
3427  * Returns: the transation of @str to the current locale
3428  */
3429 G_CONST_RETURN gchar *
3430 glib_gettext (const gchar *str)
3431 {
3432   static gboolean _glib_gettext_initialized = FALSE;
3433
3434   if (!_glib_gettext_initialized)
3435     {
3436 #ifdef G_OS_WIN32
3437       gchar *tmp = _glib_get_locale_dir ();
3438       bindtextdomain (GETTEXT_PACKAGE, tmp);
3439       g_free (tmp);
3440 #else
3441       bindtextdomain (GETTEXT_PACKAGE, GLIB_LOCALE_DIR);
3442 #endif
3443 #    ifdef HAVE_BIND_TEXTDOMAIN_CODESET
3444       bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
3445 #    endif
3446       _glib_gettext_initialized = TRUE;
3447     }
3448
3449   return g_dgettext (GETTEXT_PACKAGE, str);
3450 }
3451
3452 #if defined (G_OS_WIN32) && !defined (_WIN64)
3453
3454 /* Binary compatibility versions. Not for newly compiled code. */
3455
3456 #undef g_find_program_in_path
3457
3458 gchar*
3459 g_find_program_in_path (const gchar *program)
3460 {
3461   gchar *utf8_program = g_locale_to_utf8 (program, -1, NULL, NULL, NULL);
3462   gchar *utf8_retval = g_find_program_in_path_utf8 (utf8_program);
3463   gchar *retval;
3464
3465   g_free (utf8_program);
3466   if (utf8_retval == NULL)
3467     return NULL;
3468   retval = g_locale_from_utf8 (utf8_retval, -1, NULL, NULL, NULL);
3469   g_free (utf8_retval);
3470
3471   return retval;
3472 }
3473
3474 #undef g_get_current_dir
3475
3476 gchar*
3477 g_get_current_dir (void)
3478 {
3479   gchar *utf8_dir = g_get_current_dir_utf8 ();
3480   gchar *dir = g_locale_from_utf8 (utf8_dir, -1, NULL, NULL, NULL);
3481   g_free (utf8_dir);
3482   return dir;
3483 }
3484
3485 #undef g_getenv
3486
3487 G_CONST_RETURN gchar*
3488 g_getenv (const gchar *variable)
3489 {
3490   gchar *utf8_variable = g_locale_to_utf8 (variable, -1, NULL, NULL, NULL);
3491   const gchar *utf8_value = g_getenv_utf8 (utf8_variable);
3492   gchar *value;
3493   GQuark quark;
3494
3495   g_free (utf8_variable);
3496   if (!utf8_value)
3497     return NULL;
3498   value = g_locale_from_utf8 (utf8_value, -1, NULL, NULL, NULL);
3499   quark = g_quark_from_string (value);
3500   g_free (value);
3501
3502   return g_quark_to_string (quark);
3503 }
3504
3505 #undef g_setenv
3506
3507 gboolean
3508 g_setenv (const gchar *variable,
3509           const gchar *value,
3510           gboolean     overwrite)
3511 {
3512   gchar *utf8_variable = g_locale_to_utf8 (variable, -1, NULL, NULL, NULL);
3513   gchar *utf8_value = g_locale_to_utf8 (value, -1, NULL, NULL, NULL);
3514   gboolean retval = g_setenv_utf8 (utf8_variable, utf8_value, overwrite);
3515
3516   g_free (utf8_variable);
3517   g_free (utf8_value);
3518
3519   return retval;
3520 }
3521
3522 #undef g_unsetenv
3523
3524 void
3525 g_unsetenv (const gchar *variable)
3526 {
3527   gchar *utf8_variable = g_locale_to_utf8 (variable, -1, NULL, NULL, NULL);
3528
3529   g_unsetenv_utf8 (utf8_variable);
3530
3531   g_free (utf8_variable);
3532 }
3533
3534 #undef g_get_user_name
3535
3536 G_CONST_RETURN gchar*
3537 g_get_user_name (void)
3538 {
3539   g_get_any_init_locked ();
3540   return g_user_name_cp;
3541 }
3542
3543 #undef g_get_real_name
3544
3545 G_CONST_RETURN gchar*
3546 g_get_real_name (void)
3547 {
3548   g_get_any_init_locked ();
3549   return g_real_name_cp;
3550 }
3551
3552 #undef g_get_home_dir
3553
3554 G_CONST_RETURN gchar*
3555 g_get_home_dir (void)
3556 {
3557   g_get_any_init_locked ();
3558   return g_home_dir_cp;
3559 }
3560
3561 #undef g_get_tmp_dir
3562
3563 G_CONST_RETURN gchar*
3564 g_get_tmp_dir (void)
3565 {
3566   g_get_any_init_locked ();
3567   return g_tmp_dir_cp;
3568 }
3569
3570 #endif
3571
3572 #define __G_UTILS_C__
3573 #include "galiasdef.c"