See ChangeLog: Mon Jan 24 22:24:38 CET 2000 Werner Koch
[gnupg.git] / g10 / openfile.c
1 /* openfile.c
2  *      Copyright (C) 1998 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26 #include <errno.h>
27 #include <unistd.h>
28 #include "util.h"
29 #include <gcrypt.h>
30 #include "ttyio.h"
31 #include "options.h"
32 #include "main.h"
33 #include "status.h"
34 #include "i18n.h"
35
36 #ifdef USE_ONLY_8DOT3
37   #define SKELEXT ".skl"
38 #else
39   #define SKELEXT ".skel"
40 #endif
41
42
43 #ifdef HAVE_DRIVE_LETTERS
44   #define CMP_FILENAME(a,b) stricmp( (a), (b) )
45 #else
46   #define CMP_FILENAME(a,b) strcmp( (a), (b) )
47 #endif
48
49
50 /* FIXME:  Implement opt.interactive. */
51
52 /****************
53  * Check whether FNAME exists and ask if it's okay to overwrite an
54  * existing one.
55  * Returns: True: it's okay to overwrite or the file does not exist
56  *          False: Do not overwrite
57  */
58 int
59 overwrite_filep( const char *fname )
60 {
61     if( !fname || (*fname == '-' && !fname[1]) )
62         return 1; /* writing to stdout is always okay */
63
64     if( access( fname, F_OK ) )
65         return 1; /* does not exist */
66
67     /* fixme: add some backup stuff in case of overwrite */
68     if( opt.answer_yes )
69         return 1;
70     if( opt.answer_no || opt.batch )
71         return 0;  /* do not overwrite */
72
73     tty_printf(_("File `%s' exists. "), fname);
74     if( cpr_get_answer_is_yes("openfile.overwrite.okay",
75                                _("Overwrite (y/N)? ")) )
76         return 1;
77     return 0;
78 }
79
80
81
82 /****************
83  * Strip know extensions from iname and return a newly allocated
84  * filename.  Return NULL if we can't do that.
85  */
86 char *
87 make_outfile_name( const char *iname )
88 {
89     size_t n;
90
91     if( (!iname || (*iname=='-' && !iname[1]) ))
92         return gcry_xstrdup("-");
93
94     n = strlen(iname);
95     if( n > 4 && (    !CMP_FILENAME(iname+n-4,".gpg")
96                    || !CMP_FILENAME(iname+n-4,".pgp")
97                    || !CMP_FILENAME(iname+n-4,".sig")
98                    || !CMP_FILENAME(iname+n-4,".asc") ) ) {
99         char *buf = gcry_xstrdup( iname );
100         buf[n-4] = 0;
101         return buf;
102     }
103
104     log_info(_("%s: unknown suffix\n"), iname );
105     return NULL;
106 }
107
108
109 /****************
110  * Ask for a outputfilename and use the given one as default.
111  * Return NULL if no file has been given or it is not possible to
112  * ask the user.
113  */
114 char *
115 ask_outfile_name( const char *name, size_t namelen )
116 {
117     size_t n;
118     const char *s;
119     char *prompt;
120     char *fname;
121     char *defname;
122
123     if( opt.batch )
124         return NULL;
125
126     s = _("Enter new filename");
127
128     n = strlen(s) + namelen + 10;
129     defname = name && namelen? make_printable_string( name, namelen, 0): NULL;
130     prompt = gcry_xmalloc(n);
131     if( defname )
132         sprintf(prompt, "%s [%s]: ", s, defname );
133     else
134         sprintf(prompt, "%s: ", s );
135     fname = cpr_get("openfile.askoutname", prompt );
136     cpr_kill_prompt();
137     gcry_free(prompt);
138     if( !*fname ) {
139         gcry_free( fname ); fname = NULL;
140         fname = defname; defname = NULL;
141     }
142     gcry_free(defname);
143     return fname;
144 }
145
146
147
148 /****************
149  * Make an output filename for the inputfile INAME.
150  * Returns an IOBUF and an errorcode
151  * Mode 0 = use ".gpg"
152  *      1 = use ".asc"
153  *      2 = use ".sig"
154  */
155 int
156 open_outfile( const char *iname, int mode, IOBUF *a )
157 {
158     int rc = 0;
159
160     *a = NULL;
161     if( (!iname || (*iname=='-' && !iname[1])) && !opt.outfile ) {
162         if( !(*a = iobuf_create(NULL)) ) {
163             log_error(_("%s: can't open: %s\n"), "[stdout]", strerror(errno) );
164             rc = G10ERR_CREATE_FILE;
165         }
166         else if( opt.verbose )
167             log_info(_("writing to stdout\n"));
168     }
169     else {
170         char *buf=NULL;
171         const char *name;
172
173         if( opt.dry_run )
174             name = "/dev/null";
175         else if( opt.outfile )
176             name = opt.outfile;
177         else {
178           #ifdef USE_ONLY_8DOT3
179             /* It is quite common for DOS system to have only one dot in a
180              * a filename So if we have something like this, we simple
181              * replace the suffix execpt in cases where the suffix is
182              * larger than 3 characters and not the same as.
183              * We should really map the filenames to 8.3 but this tends to
184              * be more complicated and is probaly a duty of the filesystem
185              */
186             char *dot;
187             const char *newsfx = mode==1 ? ".asc" :
188                                  mode==2 ? ".sig" : ".gpg";
189
190             buf = gcry_xmalloc(strlen(iname)+4+1);
191             strcpy(buf,iname);
192             dot = strchr(buf, '.' );
193             if( dot && dot > buf && dot[1] && strlen(dot) <= 4
194                                            && CMP_FILENAME(newsfx, dot) ) {
195                 strcpy(dot, newsfx );
196             }
197             else if( dot && !dot[1] ) /* don't duplicate a dot */
198                 strcat( dot, newsfx+1 );
199             else
200                 strcat( buf, newsfx );
201           #else
202             buf = gcry_xmalloc(strlen(iname)+4+1);
203             strcpy(stpcpy(buf,iname), mode==1 ? ".asc" :
204                                       mode==2 ? ".sig" : ".gpg");
205           #endif
206             name = buf;
207         }
208
209         if( overwrite_filep( name ) ) {
210             if( !(*a = iobuf_create( name )) ) {
211                 log_error(_("%s: can't create: %s\n"), name, strerror(errno) );
212                 rc = G10ERR_CREATE_FILE;
213             }
214             else if( opt.verbose )
215                 log_info(_("writing to `%s'\n"), name );
216         }
217         else
218             rc = G10ERR_FILE_EXISTS;
219         gcry_free(buf);
220     }
221     return rc;
222 }
223
224
225
226 /****************
227  * Try to open a file without the extension ".sig" or ".asc"
228  * Return NULL if such a file is not available.
229  */
230 IOBUF
231 open_sigfile( const char *iname )
232 {
233     IOBUF a = NULL;
234     size_t len;
235
236     if( iname && !(*iname == '-' && !iname[1]) ) {
237         len = strlen(iname);
238         if( len > 4 && ( !strcmp(iname + len - 4, ".sig")
239                         || !strcmp(iname + len - 4, ".asc")) ) {
240             char *buf;
241             buf = gcry_xstrdup(iname);
242             buf[len-4] = 0 ;
243             a = iobuf_open( buf );
244             if( opt.verbose )
245                 log_info(_("assuming signed data in `%s'\n"), buf );
246             gcry_free(buf);
247         }
248     }
249     return a;
250 }
251
252
253 /****************
254  * Copy the option file skeleton to the given directory.
255  */
256 void
257 copy_options_file( const char *destdir )
258 {
259     const char *datadir = GNUPG_DATADIR;
260     char *fname;
261     FILE *src, *dst;
262     int linefeeds=0;
263     int c;
264
265     if( opt.dry_run )
266         return;
267
268     fname = gcry_xmalloc( strlen(datadir) + strlen(destdir) + 15 );
269     strcpy(stpcpy(fname, datadir), "/options" SKELEXT );
270     src = fopen( fname, "r" );
271     if( !src ) {
272         log_error(_("%s: can't open: %s\n"), fname, strerror(errno) );
273         gcry_free(fname);
274         return;
275     }
276     strcpy(stpcpy(fname, destdir), "/options" );
277     dst = fopen( fname, "w" );
278     if( !dst ) {
279         log_error(_("%s: can't create: %s\n"), fname, strerror(errno) );
280         fclose( src );
281         gcry_free(fname);
282         return;
283     }
284
285     while( (c=getc(src)) != EOF ) {
286         if( linefeeds < 3 ) {
287             if( c == '\n' )
288                 linefeeds++;
289         }
290         else
291             putc( c, dst );
292     }
293     fclose( dst );
294     fclose( src );
295     log_info(_("%s: new options file created\n"), fname );
296     gcry_free(fname);
297 }
298