Ask for the keysize when generating a new card key.
[gnupg.git] / g10 / cpr.c
1 /* status.c - Status message and command-fd interface 
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2004, 2005, 2006 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 3 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, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <unistd.h>
27 #include <signal.h>
28
29 #include "gpg.h"
30 #include "util.h"
31 #include "status.h"
32 #include "ttyio.h"
33 #include "options.h"
34 #include "main.h"
35 #include "i18n.h"
36 #include "cipher.h" /* for progress functions */
37
38 #define CONTROL_D ('D' - 'A' + 1)
39
40
41
42 static FILE *statusfp;
43
44
45 static void
46 progress_cb (void *ctx, const char *what, int printchar,
47              int current, int total)
48 {
49   char buf[50];
50
51   (void)ctx;
52
53   if ( printchar == '\n' && !strcmp (what, "primegen") )
54     snprintf (buf, sizeof buf -1, "%.20s X 100 100", what );
55   else
56     snprintf (buf, sizeof buf -1, "%.20s %c %d %d",
57               what, printchar=='\n'?'X':printchar, current, total );
58   write_status_text (STATUS_PROGRESS, buf);
59 }
60
61
62 /* Return true if the status message NO may currently be issued.  We
63    need this to avoid syncronisation problem while auto retrieving a
64    key.  There it may happen that a status NODATA is issued for a non
65    available key and the user may falsely interpret this has a missing
66    signature. */
67 static int
68 status_currently_allowed (int no)
69 {
70   if (!glo_ctrl.in_auto_key_retrieve)
71     return 1; /* Yes. */
72
73   /* We allow some statis anyway, so that import statistics are
74      correct and to avoid problems if the retriebval subsystem will
75      prompt the user. */
76   switch (no)
77     {
78     case STATUS_GET_BOOL:        
79     case STATUS_GET_LINE:        
80     case STATUS_GET_HIDDEN:      
81     case STATUS_GOT_IT:  
82     case STATUS_IMPORTED:
83     case STATUS_IMPORT_OK:      
84     case STATUS_IMPORT_CHECK:  
85     case STATUS_IMPORT_RES:
86       return 1; /* Yes. */
87     default:
88       break;
89     }
90   return 0; /* No. */
91 }
92
93
94 void
95 set_status_fd ( int fd )
96 {
97     static int last_fd = -1;
98
99     if ( fd != -1 && last_fd == fd )
100         return;
101
102     if ( statusfp && statusfp != stdout && statusfp != stderr )
103         fclose (statusfp);
104     statusfp = NULL;
105     if ( fd == -1 ) 
106         return;
107
108     if( fd == 1 )
109         statusfp = stdout;
110     else if( fd == 2 )
111         statusfp = stderr;
112     else
113         statusfp = fdopen( fd, "w" );
114     if( !statusfp ) {
115         log_fatal("can't open fd %d for status output: %s\n",
116                   fd, strerror(errno));
117     }
118     last_fd = fd;
119
120     gcry_set_progress_handler ( progress_cb, NULL );
121 }
122
123 int
124 is_status_enabled()
125 {
126     return !!statusfp;
127 }
128
129 void
130 write_status ( int no )
131 {
132     write_status_text( no, NULL );
133 }
134
135 void
136 write_status_text ( int no, const char *text)
137 {
138     if( !statusfp || !status_currently_allowed (no) )
139         return;  /* Not enabled or allowed. */
140
141     fputs ( "[GNUPG:] ", statusfp );
142     fputs ( get_status_string (no), statusfp );
143     if( text ) {
144         putc ( ' ', statusfp );
145         for (; *text; text++) {
146             if (*text == '\n')
147                 fputs ( "\\n", statusfp );
148             else if (*text == '\r')
149                 fputs ( "\\r", statusfp );
150             else 
151                 putc ( *(const byte *)text,  statusfp );
152         }
153     }
154     putc ('\n',statusfp);
155     if ( fflush (statusfp) && opt.exit_on_status_write_error )
156       g10_exit (0);
157 }
158
159
160 void
161 write_status_error (const char *where, int errcode)
162 {
163   if (!statusfp || !status_currently_allowed (STATUS_ERROR))
164     return;  /* Not enabled or allowed. */
165
166   fprintf (statusfp, "[GNUPG:] %s %s %u\n", 
167            get_status_string (STATUS_ERROR), where, gpg_err_code (errcode));
168   if (fflush (statusfp) && opt.exit_on_status_write_error)
169     g10_exit (0);
170 }
171
172
173 /*
174  * Write a status line with a buffer using %XX escapes.  If WRAP is >
175  * 0 wrap the line after this length.  If STRING is not NULL it will
176  * be prepended to the buffer, no escaping is done for string.
177  * A wrap of -1 forces spaces not to be encoded as %20.
178  */
179 void
180 write_status_text_and_buffer ( int no, const char *string,
181                                const char *buffer, size_t len, int wrap )
182 {
183     const char *s, *text;
184     int esc, first;
185     int lower_limit = ' ';
186     size_t n, count, dowrap;
187
188     if( !statusfp || !status_currently_allowed (no) )
189         return;  /* Not enabled or allowed. */
190     
191     if (wrap == -1) {
192         lower_limit--;
193         wrap = 0;
194     }
195
196     text = get_status_string (no);
197     count = dowrap = first = 1;
198     do {
199         if (dowrap) {
200             fprintf (statusfp, "[GNUPG:] %s ", text );
201             count = dowrap = 0;
202             if (first && string) {
203                 fputs (string, statusfp);
204                 count += strlen (string);
205             }
206             first = 0;
207         }
208         for (esc=0, s=buffer, n=len; n && !esc; s++, n-- ) {
209             if ( *s == '%' || *(const byte*)s <= lower_limit 
210                            || *(const byte*)s == 127 ) 
211                 esc = 1;
212             if ( wrap && ++count > wrap ) {
213                 dowrap=1;
214                 break;
215             }
216         }
217         if (esc) {
218             s--; n++;
219         }
220         if (s != buffer) 
221             fwrite (buffer, s-buffer, 1, statusfp );
222         if ( esc ) {
223             fprintf (statusfp, "%%%02X", *(const byte*)s );
224             s++; n--;
225         }
226         buffer = s;
227         len = n;
228         if ( dowrap && len )
229             putc ( '\n', statusfp );
230     } while ( len );
231
232     putc ('\n',statusfp);
233     if ( fflush (statusfp) && opt.exit_on_status_write_error )
234       g10_exit (0);
235 }
236
237 void
238 write_status_buffer ( int no, const char *buffer, size_t len, int wrap )
239 {
240     write_status_text_and_buffer (no, NULL, buffer, len, wrap);
241 }
242
243
244 /* Print the BEGIN_SIGNING status message.  If MD is not NULL it is
245    used to retrieve the hash algorithms used for the message. */
246 void
247 write_status_begin_signing (gcry_md_hd_t md)
248 {
249   if (md)
250     {
251       char buf[100];
252       size_t buflen;
253       int i;
254       
255       /* We use a hard coded list of possible algorithms.  Using other
256          algorithms than specified by OpenPGP does not make sense
257          anyway.  We do this out of performance reasons: Walking all
258          the 110 allowed Ids is not a good idea given the way the
259          check is implemented in libgcrypt.  Recall that the only use
260          of this status code is to create the micalg algorithm for
261          PGP/MIME. */
262       buflen = 0;
263       for (i=1; i <= 11; i++)
264         if (i < 4 || i > 7)
265           if ( gcry_md_is_enabled (md, i) && buflen < DIM(buf) )
266             {
267               snprintf (buf+buflen, DIM(buf) - buflen - 1, 
268                         "%sH%d", buflen? " ":"",i);
269               buflen += strlen (buf+buflen);
270             }
271       write_status_text ( STATUS_BEGIN_SIGNING, buf );
272     }
273   else
274     write_status ( STATUS_BEGIN_SIGNING );
275 }
276
277
278 static int
279 myread(int fd, void *buf, size_t count)
280 {
281     int rc;
282     do {
283         rc = read( fd, buf, count );
284     } while ( rc == -1 && errno == EINTR );
285     if ( !rc && count ) {
286         static int eof_emmited=0;
287         if ( eof_emmited < 3 ) {
288             *(char*)buf = CONTROL_D;
289             rc = 1;
290             eof_emmited++;
291         }
292         else { /* Ctrl-D not caught - do something reasonable */
293 #ifdef HAVE_DOSISH_SYSTEM
294             raise (SIGINT);  /* nothing to hangup under DOS */
295 #else
296             raise (SIGHUP); /* no more input data */
297 #endif
298         }
299     }    
300     return rc;
301 }
302
303
304
305 /* Request a string from the client over the command-fd.  If GETBOOL
306    is set the function returns a static string (do not free) if the
307    netered value was true or NULL if the entered value was false.  */
308 static char *
309 do_get_from_fd ( const char *keyword, int hidden, int getbool )
310 {
311   int i, len;
312   char *string;
313   
314   if (statusfp != stdout)
315     fflush (stdout);
316   
317   write_status_text (getbool? STATUS_GET_BOOL :
318                      hidden? STATUS_GET_HIDDEN : STATUS_GET_LINE, keyword);
319
320   for (string = NULL, i = len = 200; ; i++ ) 
321     {
322       if (i >= len-1 ) 
323         {
324           char *save = string;
325           len += 100;
326           string = hidden? xmalloc_secure ( len ) : xmalloc ( len );
327           if (save)
328             memcpy (string, save, i );
329           else
330             i = 0;
331         }
332       /* Fixme: why not use our read_line function here? */
333       if ( myread( opt.command_fd, string+i, 1) != 1 || string[i] == '\n'  )
334         break;
335       else if ( string[i] == CONTROL_D ) 
336         {
337           /* Found ETX - Cancel the line and return a sole ETX.  */
338           string[0] = CONTROL_D;
339           i = 1;
340           break;
341         }
342     }
343   string[i] = 0;
344
345   write_status (STATUS_GOT_IT);
346
347   if (getbool)   /* Fixme: is this correct??? */
348     return (string[0] == 'Y' || string[0] == 'y') ? "" : NULL;
349
350   return string;
351 }
352
353
354
355 int
356 cpr_enabled()
357 {
358     if( opt.command_fd != -1 )
359         return 1;
360     return 0;
361 }
362
363 char *
364 cpr_get_no_help( const char *keyword, const char *prompt )
365 {
366     char *p;
367
368     if( opt.command_fd != -1 )
369         return do_get_from_fd ( keyword, 0, 0 );
370     for(;;) {
371         p = tty_get( prompt );
372         return p;
373     }
374 }
375
376 char *
377 cpr_get( const char *keyword, const char *prompt )
378 {
379     char *p;
380
381     if( opt.command_fd != -1 )
382         return do_get_from_fd ( keyword, 0, 0 );
383     for(;;) {
384         p = tty_get( prompt );
385         if( *p=='?' && !p[1] && !(keyword && !*keyword)) {
386             xfree(p);
387             display_online_help( keyword );
388         }
389         else
390             return p;
391     }
392 }
393
394
395 char *
396 cpr_get_utf8( const char *keyword, const char *prompt )
397 {
398     char *p;
399     p = cpr_get( keyword, prompt );
400     if( p ) {
401         char *utf8 = native_to_utf8( p );
402         xfree( p );
403         p = utf8;
404     }
405     return p;
406 }
407
408 char *
409 cpr_get_hidden( const char *keyword, const char *prompt )
410 {
411     char *p;
412
413     if( opt.command_fd != -1 )
414         return do_get_from_fd ( keyword, 1, 0 );
415     for(;;) {
416         p = tty_get_hidden( prompt );
417         if( *p == '?' && !p[1] ) {
418             xfree(p);
419             display_online_help( keyword );
420         }
421         else
422             return p;
423     }
424 }
425
426 void
427 cpr_kill_prompt(void)
428 {
429     if( opt.command_fd != -1 )
430         return;
431     tty_kill_prompt();
432     return;
433 }
434
435 int
436 cpr_get_answer_is_yes( const char *keyword, const char *prompt )
437 {
438     int yes;
439     char *p;
440
441     if( opt.command_fd != -1 )
442         return !!do_get_from_fd ( keyword, 0, 1 );
443     for(;;) {
444         p = tty_get( prompt );
445         trim_spaces(p); /* it is okay to do this here */
446         if( *p == '?' && !p[1] ) {
447             xfree(p);
448             display_online_help( keyword );
449         }
450         else {
451             tty_kill_prompt();
452             yes = answer_is_yes(p);
453             xfree(p);
454             return yes;
455         }
456     }
457 }
458
459 int
460 cpr_get_answer_yes_no_quit( const char *keyword, const char *prompt )
461 {
462     int yes;
463     char *p;
464
465     if( opt.command_fd != -1 )
466         return !!do_get_from_fd ( keyword, 0, 1 );
467     for(;;) {
468         p = tty_get( prompt );
469         trim_spaces(p); /* it is okay to do this here */
470         if( *p == '?' && !p[1] ) {
471             xfree(p);
472             display_online_help( keyword );
473         }
474         else {
475             tty_kill_prompt();
476             yes = answer_is_yes_no_quit(p);
477             xfree(p);
478             return yes;
479         }
480     }
481 }
482
483
484 int
485 cpr_get_answer_okay_cancel (const char *keyword,
486                             const char *prompt,
487                             int def_answer)
488 {
489   int yes;
490   char *answer = NULL;
491   char *p;
492
493   if( opt.command_fd != -1 )
494     answer = do_get_from_fd ( keyword, 0, 0 );
495
496   if (answer)
497     {
498       yes = answer_is_okay_cancel (answer, def_answer);
499       xfree (answer);
500       return yes;
501     }
502
503   for(;;)
504     {
505       p = tty_get( prompt );
506       trim_spaces(p); /* it is okay to do this here */
507       if (*p == '?' && !p[1])
508         {
509           xfree(p);
510           display_online_help (keyword);
511         }
512       else
513         {
514           tty_kill_prompt();
515           yes = answer_is_okay_cancel (p, def_answer);
516           xfree(p);
517           return yes;
518         }
519     }
520 }