Updated.
[gnupg.git] / g10 / decrypt.c
1 /* decrypt.c - verify signed data
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *               2004 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20  * USA.
21  */
22
23 #include <config.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <assert.h>
29
30 #include "options.h"
31 #include "packet.h"
32 #include "errors.h"
33 #include "iobuf.h"
34 #include "keydb.h"
35 #include "memory.h"
36 #include "util.h"
37 #include "main.h"
38 #include "status.h"
39 #include "i18n.h"
40
41
42
43 /****************
44  * Assume that the input is an encrypted message and decrypt
45  * (and if signed, verify the signature on) it.
46  * This command differs from the default operation, as it never
47  * writes to the filename which is included in the file and it
48  * rejects files which don't begin with an encrypted message.
49  */
50
51 int
52 decrypt_message( const char *filename )
53 {
54     IOBUF fp;
55     armor_filter_context_t afx;
56     progress_filter_context_t pfx;
57     int rc;
58     int no_out=0;
59
60     /* open the message file */
61     fp = iobuf_open(filename);
62     if (fp && is_secured_file (iobuf_get_fd (fp)))
63       {
64         iobuf_close (fp);
65         fp = NULL;
66         errno = EPERM;
67       }
68     if( !fp ) {
69         log_error(_("can't open `%s'\n"), print_fname_stdin(filename));
70         return G10ERR_OPEN_FILE;
71     }
72
73     handle_progress (&pfx, fp, filename);
74
75     if( !opt.no_armor ) {
76         if( use_armor_filter( fp ) ) {
77             memset( &afx, 0, sizeof afx);
78             iobuf_push_filter( fp, armor_filter, &afx );
79         }
80     }
81
82     if( !opt.outfile ) {
83         no_out = 1;
84         opt.outfile = "-";
85     }
86     rc = proc_encryption_packets( NULL, fp );
87     if( no_out )
88        opt.outfile = NULL;
89     iobuf_close(fp);
90     return rc;
91 }
92
93 void
94 decrypt_messages(int nfiles, char *files[])
95 {
96   IOBUF fp;
97   armor_filter_context_t afx;  
98   progress_filter_context_t pfx;
99   char *p, *output = NULL;
100   int rc=0,use_stdin=0;
101   unsigned int lno=0;
102   
103   if (opt.outfile)
104     {
105       log_error(_("--output doesn't work for this command\n"));
106       return;
107         
108     }
109
110   if(!nfiles)
111     use_stdin=1;
112
113   for(;;)
114     {
115       char line[2048];
116       char *filename=NULL;
117
118       if(use_stdin)
119         {
120           if(fgets(line, DIM(line), stdin))
121             {
122               lno++;
123               if (!*line || line[strlen(line)-1] != '\n')
124                 log_error("input line %u too long or missing LF\n", lno);
125               else
126                 {
127                   line[strlen(line)-1] = '\0';
128                   filename=line;
129                 }
130             }
131         }
132       else
133         {
134           if(nfiles)
135             {
136               filename=*files;
137               nfiles--;
138               files++;
139             }
140         }
141
142       if(filename==NULL)
143         break;
144
145       print_file_status(STATUS_FILE_START, filename, 3);      
146       output = make_outfile_name(filename);
147       if (!output)
148         goto next_file;
149       fp = iobuf_open(filename);
150       if (fp)
151         iobuf_ioctl (fp,3,1,NULL); /* disable fd caching */
152       if (fp && is_secured_file (iobuf_get_fd (fp)))
153         {
154           iobuf_close (fp);
155           fp = NULL;
156           errno = EPERM;
157         }
158       if (!fp)
159         {
160           log_error(_("can't open `%s'\n"), print_fname_stdin(filename));
161           goto next_file;
162         }
163
164       handle_progress (&pfx, fp, filename);
165
166       if (!opt.no_armor)
167         {
168           if (use_armor_filter(fp))
169             {
170               memset(&afx, 0, sizeof afx);
171               iobuf_push_filter(fp, armor_filter, &afx);
172             }
173         }
174       rc = proc_packets(NULL, fp);
175       iobuf_close(fp);
176       if (rc)
177         log_error("%s: decryption failed: %s\n", print_fname_stdin(filename),
178                   g10_errstr(rc));
179       p = get_last_passphrase();
180       set_next_passphrase(p);
181       xfree (p);
182
183     next_file:
184       /* Note that we emit file_done even after an error. */
185       write_status( STATUS_FILE_DONE );
186       xfree(output);
187     }
188
189   set_next_passphrase(NULL);  
190 }