* fileutil.c (untilde): New. Expand ~/foo and ~username/foo filenames
[gnupg.git] / util / fileutil.c
1 /* fileutil.c -  file utilities
2  * Copyright (C) 1998, 2003, 2005 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19  * USA.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <stdarg.h>
26 #include <string.h>
27 #include <assert.h>
28 #include <unistd.h>
29 #include <sys/types.h>
30 #ifdef HAVE_PWD_H
31 #include <pwd.h>
32 #endif
33 #include "util.h"
34 #include "memory.h"
35 #include "ttyio.h"
36
37
38 /***************
39  * Extract from a given path the filename component.
40  *
41  */
42 char *
43 make_basename(const char *filepath, const char *inputpath)
44 {
45 #ifdef __riscos__
46     return riscos_make_basename(filepath, inputpath);
47 #endif
48
49     char *p;
50
51     if ( !(p=strrchr(filepath, DIRSEP_C)) )
52 #ifdef HAVE_DRIVE_LETTERS
53         if ( !(p=strrchr(filepath, '\\')) )
54             if ( !(p=strrchr(filepath, ':')) )
55 #endif
56               {
57                 return xstrdup(filepath);
58               }
59
60     return xstrdup(p+1);
61 }
62
63
64
65 /***************
66  * Extract from a given filename the path prepended to it.
67  * If their isn't a path prepended to the filename, a dot
68  * is returned ('.').
69  *
70  */
71 char *
72 make_dirname(const char *filepath)
73 {
74     char *dirname;
75     int  dirname_length;
76     char *p;
77
78     if ( !(p=strrchr(filepath, DIRSEP_C)) )
79 #ifdef HAVE_DRIVE_LETTERS
80         if ( !(p=strrchr(filepath, '\\')) )
81             if ( !(p=strrchr(filepath, ':')) )
82 #endif
83               {
84                 return xstrdup(EXTSEP_S);
85               }
86
87     dirname_length = p-filepath;
88     dirname = xmalloc(dirname_length+1);
89     strncpy(dirname, filepath, dirname_length);
90     dirname[dirname_length] = 0;
91
92     return dirname;
93 }
94
95 /* Expand tildes.  Handles both the ~/foo and ~username/foo cases.
96    Returns what the tilde expands to.  *name is advanced to be past
97    the tilde expansion. */
98 static char *
99 untilde(const char **name)
100 {
101   char *home=NULL;
102
103   assert((*name)[0]=='~');
104
105   if((*name)[1]==DIRSEP_C || (*name)[1]=='\0')
106     {
107       /* This is the "~/foo" or "~" case. */
108       char *tmp=getenv("HOME");
109       if(tmp)
110         home=xstrdup(tmp);
111
112 #ifdef HAVE_GETPWUID
113       if(!home)
114         {
115           struct passwd *pwd;
116
117           pwd=getpwuid(getuid());
118           if(pwd)
119             home=xstrdup(pwd->pw_dir);
120         }
121 #endif
122       if(home)
123         (*name)++;
124     }
125 #ifdef HAVE_GETPWNAM
126   else
127     {
128       /* This is the "~username" case. */
129       char *user,*sep;
130       struct passwd *pwd;
131
132       user=xstrdup((*name)+1);
133
134       sep=strchr(user,DIRSEP_C);
135       if(sep)
136         *sep='\0';
137
138       pwd=getpwnam(user);
139       if(pwd)
140         {
141           home=xstrdup(pwd->pw_dir);
142           (*name)+=1+strlen(user);
143         }
144
145       xfree(user);
146     }
147 #endif
148
149   return home;
150 }
151
152 /*
153   Construct a filename from the NULL terminated list of parts.  Tilde
154   expansion is done here.  Note that FIRST_PART must never be NULL and
155   that this function is guaranteed to return an allocated string.  */
156 char *
157 make_filename( const char *first_part, ... )
158 {
159     va_list arg_ptr ;
160     size_t n;
161     const char *s;
162     char *name, *p, *home=NULL;
163
164     va_start( arg_ptr, first_part ) ;
165     n = strlen(first_part)+1;
166     while( (s=va_arg(arg_ptr, const char *)) )
167         n += strlen(s) + 1;
168     va_end(arg_ptr);
169
170 #ifndef __riscos__
171     if(*first_part=='~')
172       {
173         home=untilde(&first_part);
174         if(home)
175           n+=strlen(home);
176       }
177 #endif
178     name = xmalloc(n);
179     p = home ? stpcpy(stpcpy(name,home), first_part)
180              : stpcpy(name, first_part);
181     va_start( arg_ptr, first_part ) ;
182     while( (s=va_arg(arg_ptr, const char *)) )
183         p = stpcpy(stpcpy(p, DIRSEP_S), s);
184     va_end(arg_ptr);
185     xfree(home);
186
187 #ifndef __riscos__
188     return name;
189 #else /* __riscos__ */
190     p = riscos_gstrans(name);
191     xfree(name);
192     return p;
193 #endif /* __riscos__ */
194 }
195
196
197 int
198 compare_filenames( const char *a, const char *b )
199 {
200     /* ? check whether this is an absolute filename and
201      * resolve symlinks?
202      */
203 #ifndef __riscos__
204 #ifdef HAVE_DRIVE_LETTERS
205     return ascii_strcasecmp(a,b);
206 #else
207     return strcmp(a,b);
208 #endif
209 #else /* __riscos__ */
210     int c = 0;
211     char *abuf, *bbuf;
212
213     abuf = riscos_gstrans(a);
214     bbuf = riscos_gstrans(b);
215
216     c = ascii_strcasecmp (abuf, bbuf);
217
218     xfree(abuf);
219     xfree(bbuf);
220
221     return c;
222 #endif /* __riscos__ */
223 }
224
225
226 /****************
227  * A simple function to decide whether the filename is stdout
228  * or a real filename.
229  */
230 const char *
231 print_fname_stdout( const char *s )
232 {
233     if( !s || (*s == '-' && !s[1]) )
234         return "[stdout]";
235     return s;
236 }
237
238
239 const char *
240 print_fname_stdin( const char *s )
241 {
242     if( !s || (*s == '-' && !s[1]) )
243         return "[stdin]";
244     return s;
245 }
246
247 /****************
248  * Check if the file is compressed.
249  **/
250 int
251 is_file_compressed( const char *s, int *ret_rc )
252 {
253     IOBUF a;
254     byte buf[4];
255     int i, rc = 0;
256
257     struct magic_compress_s {
258         size_t len;
259         byte magic[4];
260     } magic[] = {
261         { 3, { 0x42, 0x5a, 0x68, 0x00 } }, /* bzip2 */
262         { 3, { 0x1f, 0x8b, 0x08, 0x00 } }, /* gzip */
263         { 4, { 0x50, 0x4b, 0x03, 0x04 } }, /* (pk)zip */
264     };
265     
266     if ( iobuf_is_pipe_filename (s) || !ret_rc )
267         return 0; /* We can't check stdin or no file was given */
268
269     a = iobuf_open( s );
270     if ( a == NULL ) {
271         *ret_rc = G10ERR_OPEN_FILE;
272         return 0;
273     }
274
275     if ( iobuf_get_filelength( a ) < 4 ) {
276         *ret_rc = 0;
277         goto leave;
278     }
279
280     if ( iobuf_read( a, buf, 4 ) == -1 ) {
281         *ret_rc = G10ERR_READ_FILE;
282         goto leave;
283     }
284
285     for ( i = 0; i < DIM( magic ); i++ ) {
286         if ( !memcmp( buf, magic[i].magic, magic[i].len ) ) {
287             *ret_rc = 0;
288             rc = 1;
289             break;
290         }
291     }
292
293 leave:    
294     iobuf_close( a );
295     return rc;
296 }