2007-01-26 Robert Jordan <robertj@gmx.net>
[mono.git] / 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 #if defined (G_OS_UNIX)
188
189 static pthread_mutex_t home_lock = PTHREAD_MUTEX_INITIALIZER;
190 static char *home_dir;
191
192 /* Give preference to /etc/passwd than HOME */
193 const gchar *
194 g_get_home_dir (void)
195 {
196         if (home_dir == NULL){
197                 uid_t uid;
198
199                 pthread_mutex_lock (&home_lock);
200                 if (home_dir == NULL){
201                         struct passwd pwbuf, *track;
202                         char buf [4096];
203                         
204                         uid = getuid ();
205
206                         setpwent ();
207                         
208                         while (getpwent_r (&pwbuf, buf, sizeof (buf), &track) == 0){
209                                 if (pwbuf.pw_uid == uid){
210                                         home_dir = g_strdup (pwbuf.pw_dir);
211                                         break;
212                                 }
213                         }
214                         endpwent ();
215                         if (home_dir == NULL)
216                                 home_dir = getenv ("HOME");
217                         pthread_mutex_unlock (&home_lock);
218                 }
219         }
220         return home_dir;
221 }
222
223 #elif defined (G_OS_WIN32)
224 #include <windows.h>
225
226 const gchar *
227 g_get_home_dir (void)
228 {
229         /* FIXME */
230         return getenv ("HOME");
231 }
232
233 #else
234
235 const gchar *
236 g_get_home_dir (void)
237 {
238         g_error ("g_get_home_dir not implemented on this platform");
239         return NULL;
240 }
241
242 #endif
243
244 static char *tmp_dir;
245 static pthread_mutex_t tmp_lock = PTHREAD_MUTEX_INITIALIZER;
246
247 const gchar *
248 g_get_tmp_dir (void)
249 {
250         if (tmp_dir == NULL){
251                 pthread_mutex_lock (&tmp_lock);
252                 if (tmp_dir == NULL){
253                         tmp_dir = getenv ("TMPDIR");
254                         if (tmp_dir == NULL){
255                                 tmp_dir = getenv ("TMP");
256                                 if (tmp_dir == NULL){
257                                         tmp_dir = getenv ("TEMP");
258                                         if (tmp_dir == NULL)
259                                                 tmp_dir = "/tmp";
260                                 }
261                         }
262                 }
263                 pthread_mutex_unlock (&tmp_lock);
264         }
265         return tmp_dir;
266 }
267
268 const char *
269 g_get_user_name (void)
270 {
271         return getenv ("USER");
272 }
273
274 static char *name;
275
276 void
277 g_set_prgname (const gchar *prgname)
278 {
279         name = g_strdup (prgname);
280 }
281
282 gchar *
283 g_get_prgname (void)
284 {
285         return name;
286 }