eglib/src/gpath.c

   1 /*
   2  * Portable Utility Functions
   3  *
   4  * Author:
   5  *   Miguel de Icaza (miguel@novell.com)
   6  *
   7  * (C) 2006 Novell, Inc.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining
  10  * a copy of this software and associated documentation files (the
  11  * "Software"), to deal in the Software without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sublicense, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be
  18  * included in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27  */
  28 #include <stdio.h>
  29 #include <glib.h>
  30 #include <unistd.h>
  31 #include <errno.h>
  32 #include <sys/types.h>
  33 #include <pwd.h>
  34 #include <pthread.h>
  35
  36 gchar *
  37 g_build_path (const gchar *separator, const gchar *first_element, ...)
  38 {
  39         GString *result;
  40         const char *s, *p, *next;
  41         int slen;
  42         va_list args;
  43
  44         g_return_val_if_fail (separator != NULL, NULL);
  45         g_return_val_if_fail (first_element != NULL, NULL);
  46
  47         result = g_string_sized_new (48);
  48
  49         slen = strlen (separator);
  50
  51         va_start (args, first_element);
  52         for (s = first_element; s != NULL; s = next){
  53                 next = va_arg (args, char *);
  54                 p = (s + strlen (s));
  55
  56                 if (next && p - slen > s){
  57                         for (; strncmp (p-slen, separator, slen) == 0; ){
  58                                 p -= slen;
  59                         }
  60                 }
  61                 g_string_append_len (result, s, p - s);
  62
  63                 if (next && *next){
  64                         g_string_append (result, separator);
  65
  66                         for (; strncmp (next, separator, slen) == 0; )
  67                                 next += slen;
  68                 }
  69         }
  70         g_string_append_c (result, 0);
  71         va_end (args);
  72
  73         return g_string_free (result, FALSE);
  74 }
  75
  76 gchar *
  77 g_path_get_dirname (const gchar *filename)
  78 {
  79         char *p, *r;
  80         int count;
  81         g_return_val_if_fail (filename != NULL, NULL);
  82
  83         p = strrchr (filename, G_DIR_SEPARATOR);
  84         if (p == NULL)
  85                 return g_strdup (".");
  86         if (p == filename)
  87                 return g_strdup ("/");
  88         count = p - filename;
  89         r = g_malloc (count + 1);
  90         strncpy (r, filename, count);
  91         r [count] = 0;
  92
  93         return r;
  94 }
  95
  96 gchar *
  97 g_path_get_basename (const char *filename)
  98 {
  99         char *r;
 100         g_return_val_if_fail (filename != NULL, NULL);
 101
 102         /* Empty filename -> . */
 103         if (!*filename)
 104                 return g_strdup (".");
 105
 106         /* No separator -> filename */
 107         r = strrchr (filename, G_DIR_SEPARATOR);
 108         if (r == NULL)
 109                 return g_strdup (filename);
 110
 111         /* Trailing slash, remove component */
 112         if (r [1] == 0){
 113                 char *copy = g_strdup (filename);
 114                 copy [r-filename] = 0;
 115                 r = strrchr (copy, G_DIR_SEPARATOR);
 116
 117                 if (r == NULL){
 118                         g_free (copy);
 119                         return g_strdup ("/");
 120                 }
 121                 r = g_strdup (&r[1]);
 122                 g_free (copy);
 123                 return r;
 124         }
 125
 126         return g_strdup (&r[1]);
 127 }
 128
 129 gboolean
 130 g_path_is_absolute (const char *filename)
 131 {
 132         g_return_val_if_fail (filename != NULL, FALSE);
 133         return (*filename == '/');
 134 }
 135
 136 gchar *
 137 g_find_program_in_path (const gchar *program)
 138 {
 139         char *p = g_strdup (getenv ("PATH"));
 140         char *x = p, *l;
 141         gchar *curdir = NULL;
 142         char *save;
 143
 144         g_return_val_if_fail (program != NULL, NULL);
 145
 146         if (x == NULL || *x == '\0') {
 147                 curdir = g_get_current_dir ();
 148                 x = curdir;
 149         }
 150
 151         while ((l = strtok_r (x, G_SEARCHPATH_SEPARATOR_S, &save)) != NULL){
 152                 char *probe_path;
 153
 154                 x = NULL;
 155                 probe_path = g_build_path (G_DIR_SEPARATOR_S, l, program, NULL);
 156                 if (access (probe_path, X_OK) == 0){
 157                         g_free (curdir);
 158                         g_free (p);
 159                         return probe_path;
 160                 }
 161                 g_free (probe_path);
 162         }
 163         g_free (curdir);
 164         g_free (p);
 165         return NULL;
 166 }
 167
 168 gchar *
 169 g_get_current_dir (void)
 170 {
 171         int s = 32;
 172         char *buffer = NULL, *r;
 173         gboolean fail;
 174
 175         do {
 176                 buffer = g_realloc (buffer, s);
 177                 r = getcwd  (buffer, s);
 178                 fail = (r == NULL && errno == ERANGE);
 179                 if (fail) {
 180                         s <<= 1;
 181                 }
 182         } while (fail);
 183
 184         return r;
 185 }
 186
 187 static pthread_mutex_t home_lock = PTHREAD_MUTEX_INITIALIZER;
 188 static char *home_dir;
 189
 190 /* Give preference to /etc/passwd than HOME */
 191 const gchar *
 192 g_get_home_dir (void)
 193 {
 194         if (home_dir == NULL){
 195                 uid_t uid;
 196
 197                 pthread_mutex_lock (&home_lock);
 198                 if (home_dir == NULL){
 199                         struct passwd pwbuf, *track;
 200                         char buf [4096];
 201
 202                         uid = getuid ();
 203
 204                         setpwent ();
 205
 206                         while (getpwent_r (&pwbuf, buf, sizeof (buf), &track) == 0){
 207                                 if (pwbuf.pw_uid == uid){
 208                                         home_dir = g_strdup (pwbuf.pw_dir);
 209                                         break;
 210                                 }
 211                         }
 212                         endpwent ();
 213                         if (home_dir == NULL)
 214                                 home_dir = getenv ("HOME");
 215                         pthread_mutex_unlock (&home_lock);
 216                 }
 217         }
 218         return home_dir;
 219 }
 220
 221 static char *tmp_dir;
 222 static pthread_mutex_t tmp_lock = PTHREAD_MUTEX_INITIALIZER;
 223
 224 const gchar *
 225 g_get_tmp_dir (void)
 226 {
 227         if (tmp_dir == NULL){
 228                 pthread_mutex_lock (&tmp_lock);
 229                 if (tmp_dir == NULL){
 230                         tmp_dir = getenv ("TMPDIR");
 231                         if (tmp_dir == NULL){
 232                                 tmp_dir = getenv ("TMP");
 233                                 if (tmp_dir == NULL){
 234                                         tmp_dir = getenv ("TEMP");
 235                                         if (tmp_dir == NULL)
 236                                                 tmp_dir = "/tmp";
 237                                 }
 238                         }
 239                 }
 240                 pthread_mutex_unlock (&tmp_lock);
 241         }
 242         return tmp_dir;
 243 }
 244
 245 const char *
 246 g_get_user_name (void)
 247 {
 248         return getenv ("USER");
 249 }
 250
 251 static char *name;
 252
 253 void
 254 g_set_prgname (const gchar *prgname)
 255 {
 256         name = g_strdup (prgname);
 257 }
 258
 259 gchar *
 260 g_get_prgname (void)
 261 {
 262         return name;
 263 }