← Back to branch summary

~ubuntu-branches/ubuntu/feisty/gnupg2/feisty

« back to all changes in this revision

Viewing changes to g10/status.c

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2006-07-11 11:38:13 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20060711113813-zaw7unlbuh7gyxtl
Tags: 1.9.21-0ubuntu1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
g10/status.c
1
 
/* status.c
2
 
 * Copyright (C) 1998, 1999, 2000, 2001, 2002,
3
 
 *               2003 Free Software Foundation, Inc.
 
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
4
 *
5
5
 * This file is part of GnuPG.
6
6
 *
16
16
 *
17
17
 * You should have received a copy of the GNU General Public License
18
18
 * along with this program; if not, write to the Free Software
19
 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
 
20
 * USA.
20
21
 */
21
22
 
22
23
#include <config.h>
44
45
 
45
46
 
46
47
static void
47
 
progress_cb (void *ctx, const char *what, int printchar, int current, int total)
 
48
progress_cb ( void *ctx, int c )
48
49
{
49
 
  char buf[150];
50
 
  
51
 
  if (printchar == '\n')
52
 
    printchar = 'X';
53
 
  
54
 
  sprintf (buf, "%.20s %c %d %d", what, printchar, current, total);
55
 
  write_status_text (STATUS_PROGRESS, buf);
 
50
    char buf[50];
 
51
 
 
52
    if ( c == '\n' )
 
53
        sprintf ( buf, "%.20s X 100 100", (char*)ctx );
 
54
    else
 
55
        sprintf ( buf, "%.20s %c 0 0", (char*)ctx, c );
 
56
    write_status_text ( STATUS_PROGRESS, buf );
56
57
}
57
58
 
58
59
static const char *
59
60
get_status_string ( int no ) 
60
61
{
61
 
    const char *s;
62
 
 
63
 
    switch( no ) {
64
 
      case STATUS_ENTER  : s = "ENTER"; break;
65
 
      case STATUS_LEAVE  : s = "LEAVE"; break;
66
 
      case STATUS_ABORT  : s = "ABORT"; break;
67
 
      case STATUS_GOODSIG: s = "GOODSIG"; break;
68
 
      case STATUS_KEYEXPIRED: s = "KEYEXPIRED"; break;
69
 
      case STATUS_KEYREVOKED: s = "KEYREVOKED"; break;
70
 
      case STATUS_BADSIG : s = "BADSIG"; break;
71
 
      case STATUS_ERRSIG : s = "ERRSIG"; break;
72
 
      case STATUS_BADARMOR : s = "BADARMOR"; break;
73
 
      case STATUS_RSA_OR_IDEA : s= "RSA_OR_IDEA"; break;
74
 
      case STATUS_TRUST_UNDEFINED: s = "TRUST_UNDEFINED"; break;
75
 
      case STATUS_TRUST_NEVER    : s = "TRUST_NEVER"; break;
76
 
      case STATUS_TRUST_MARGINAL : s = "TRUST_MARGINAL"; break;
77
 
      case STATUS_TRUST_FULLY    : s = "TRUST_FULLY"; break;
78
 
      case STATUS_TRUST_ULTIMATE : s = "TRUST_ULTIMATE"; break;
79
 
      case STATUS_GET_BOOL       : s = "GET_BOOL"; break;
80
 
      case STATUS_GET_LINE       : s = "GET_LINE"; break;
81
 
      case STATUS_GET_HIDDEN     : s = "GET_HIDDEN"; break;
82
 
      case STATUS_GOT_IT         : s = "GOT_IT"; break;
83
 
      case STATUS_SHM_INFO       : s = "SHM_INFO"; break;
84
 
      case STATUS_SHM_GET        : s = "SHM_GET"; break;
85
 
      case STATUS_SHM_GET_BOOL   : s = "SHM_GET_BOOL"; break;
86
 
      case STATUS_SHM_GET_HIDDEN : s = "SHM_GET_HIDDEN"; break;
87
 
      case STATUS_NEED_PASSPHRASE: s = "NEED_PASSPHRASE"; break;
88
 
      case STATUS_VALIDSIG       : s = "VALIDSIG"; break;
89
 
      case STATUS_SIG_ID         : s = "SIG_ID"; break;
90
 
      case STATUS_ENC_TO         : s = "ENC_TO"; break;
91
 
      case STATUS_NODATA         : s = "NODATA"; break;
92
 
      case STATUS_BAD_PASSPHRASE : s = "BAD_PASSPHRASE"; break;
93
 
      case STATUS_NO_PUBKEY      : s = "NO_PUBKEY"; break;
94
 
      case STATUS_NO_SECKEY      : s = "NO_SECKEY"; break;
95
 
      case STATUS_NEED_PASSPHRASE_SYM: s = "NEED_PASSPHRASE_SYM"; break;
96
 
      case STATUS_DECRYPTION_FAILED: s = "DECRYPTION_FAILED"; break;
97
 
      case STATUS_DECRYPTION_OKAY: s = "DECRYPTION_OKAY"; break;
98
 
      case STATUS_MISSING_PASSPHRASE: s = "MISSING_PASSPHRASE"; break;
99
 
      case STATUS_GOOD_PASSPHRASE : s = "GOOD_PASSPHRASE"; break;
100
 
      case STATUS_GOODMDC        : s = "GOODMDC"; break;
101
 
      case STATUS_BADMDC         : s = "BADMDC"; break;
102
 
      case STATUS_ERRMDC         : s = "ERRMDC"; break;
103
 
      case STATUS_IMPORTED       : s = "IMPORTED"; break;
104
 
      case STATUS_IMPORT_OK      : s = "IMPORT_OK"; break;
105
 
      case STATUS_IMPORT_CHECK   : s = "IMPORT_CHECK"; break;
106
 
      case STATUS_IMPORT_RES     : s = "IMPORT_RES"; break;
107
 
      case STATUS_FILE_START     : s = "FILE_START"; break;
108
 
      case STATUS_FILE_DONE      : s = "FILE_DONE"; break;
109
 
      case STATUS_FILE_ERROR     : s = "FILE_ERROR"; break;
110
 
      case STATUS_BEGIN_DECRYPTION:s = "BEGIN_DECRYPTION"; break;
111
 
      case STATUS_END_DECRYPTION : s = "END_DECRYPTION"; break;
112
 
      case STATUS_BEGIN_ENCRYPTION:s = "BEGIN_ENCRYPTION"; break;
113
 
      case STATUS_END_ENCRYPTION : s = "END_ENCRYPTION"; break;
114
 
      case STATUS_DELETE_PROBLEM : s = "DELETE_PROBLEM"; break;
115
 
      case STATUS_PROGRESS       : s = "PROGRESS"; break;
116
 
      case STATUS_SIG_CREATED    : s = "SIG_CREATED"; break;
117
 
      case STATUS_SESSION_KEY    : s = "SESSION_KEY"; break;
118
 
      case STATUS_NOTATION_NAME  : s = "NOTATION_NAME" ; break;
119
 
      case STATUS_NOTATION_DATA  : s = "NOTATION_DATA" ; break;
120
 
      case STATUS_POLICY_URL     : s = "POLICY_URL" ; break;
121
 
      case STATUS_BEGIN_STREAM   : s = "BEGIN_STREAM"; break;
122
 
      case STATUS_END_STREAM     : s = "END_STREAM"; break;
123
 
      case STATUS_KEY_CREATED    : s = "KEY_CREATED"; break;
124
 
      case STATUS_USERID_HINT    : s = "USERID_HINT"; break;
125
 
      case STATUS_UNEXPECTED     : s = "UNEXPECTED"; break;
126
 
      case STATUS_INV_RECP       : s = "INV_RECP"; break;
127
 
      case STATUS_NO_RECP        : s = "NO_RECP"; break;
128
 
      case STATUS_ALREADY_SIGNED : s = "ALREADY_SIGNED"; break;
129
 
      case STATUS_SIGEXPIRED     : s = "SIGEXPIRED deprecated-use-keyexpired-instead"; break;
130
 
      case STATUS_EXPSIG         : s = "EXPSIG"; break;
131
 
      case STATUS_EXPKEYSIG      : s = "EXPKEYSIG"; break;
132
 
      case STATUS_REVKEYSIG      : s = "REVKEYSIG"; break;
133
 
      case STATUS_ATTRIBUTE      : s = "ATTRIBUTE"; break;
134
 
      default: s = "?"; break;
135
 
    }
136
 
    return s;
137
 
}
 
62
  const char *s;
 
63
 
 
64
  switch( no )
 
65
    {
 
66
    case STATUS_ENTER  : s = "ENTER"; break;
 
67
    case STATUS_LEAVE  : s = "LEAVE"; break;
 
68
    case STATUS_ABORT  : s = "ABORT"; break;
 
69
    case STATUS_NEWSIG : s = "NEWSIG"; break;
 
70
    case STATUS_GOODSIG: s = "GOODSIG"; break;
 
71
    case STATUS_KEYEXPIRED: s = "KEYEXPIRED"; break;
 
72
    case STATUS_KEYREVOKED: s = "KEYREVOKED"; break;
 
73
    case STATUS_BADSIG : s = "BADSIG"; break;
 
74
    case STATUS_ERRSIG : s = "ERRSIG"; break;
 
75
    case STATUS_BADARMOR : s = "BADARMOR"; break;
 
76
    case STATUS_RSA_OR_IDEA : s= "RSA_OR_IDEA"; break;
 
77
    case STATUS_TRUST_UNDEFINED: s = "TRUST_UNDEFINED"; break;
 
78
    case STATUS_TRUST_NEVER      : s = "TRUST_NEVER"; break;
 
79
    case STATUS_TRUST_MARGINAL : s = "TRUST_MARGINAL"; break;
 
80
    case STATUS_TRUST_FULLY      : s = "TRUST_FULLY"; break;
 
81
    case STATUS_TRUST_ULTIMATE : s = "TRUST_ULTIMATE"; break;
 
82
    case STATUS_GET_BOOL         : s = "GET_BOOL"; break;
 
83
    case STATUS_GET_LINE         : s = "GET_LINE"; break;
 
84
    case STATUS_GET_HIDDEN       : s = "GET_HIDDEN"; break;
 
85
    case STATUS_GOT_IT   : s = "GOT_IT"; break;
 
86
    case STATUS_SHM_INFO         : s = "SHM_INFO"; break;
 
87
    case STATUS_SHM_GET  : s = "SHM_GET"; break;
 
88
    case STATUS_SHM_GET_BOOL     : s = "SHM_GET_BOOL"; break;
 
89
    case STATUS_SHM_GET_HIDDEN : s = "SHM_GET_HIDDEN"; break;
 
90
    case STATUS_NEED_PASSPHRASE: s = "NEED_PASSPHRASE"; break;
 
91
    case STATUS_VALIDSIG         : s = "VALIDSIG"; break;
 
92
    case STATUS_SIG_ID   : s = "SIG_ID"; break;
 
93
    case STATUS_ENC_TO   : s = "ENC_TO"; break;
 
94
    case STATUS_NODATA   : s = "NODATA"; break;
 
95
    case STATUS_BAD_PASSPHRASE : s = "BAD_PASSPHRASE"; break;
 
96
    case STATUS_NO_PUBKEY        : s = "NO_PUBKEY"; break;
 
97
    case STATUS_NO_SECKEY        : s = "NO_SECKEY"; break;
 
98
    case STATUS_NEED_PASSPHRASE_SYM: s = "NEED_PASSPHRASE_SYM"; break;
 
99
    case STATUS_NEED_PASSPHRASE_PIN: s = "NEED_PASSPHRASE_PIN"; break;
 
100
    case STATUS_DECRYPTION_FAILED: s = "DECRYPTION_FAILED"; break;
 
101
    case STATUS_DECRYPTION_OKAY: s = "DECRYPTION_OKAY"; break;
 
102
    case STATUS_MISSING_PASSPHRASE: s = "MISSING_PASSPHRASE"; break;
 
103
    case STATUS_GOOD_PASSPHRASE : s = "GOOD_PASSPHRASE"; break;
 
104
    case STATUS_GOODMDC  : s = "GOODMDC"; break;
 
105
    case STATUS_BADMDC   : s = "BADMDC"; break;
 
106
    case STATUS_ERRMDC   : s = "ERRMDC"; break;
 
107
    case STATUS_IMPORTED         : s = "IMPORTED"; break;
 
108
    case STATUS_IMPORT_OK        : s = "IMPORT_OK"; break;
 
109
    case STATUS_IMPORT_CHECK   : s = "IMPORT_CHECK"; break;
 
110
    case STATUS_IMPORT_RES       : s = "IMPORT_RES"; break;
 
111
    case STATUS_FILE_START       : s = "FILE_START"; break;
 
112
    case STATUS_FILE_DONE        : s = "FILE_DONE"; break;
 
113
    case STATUS_FILE_ERROR       : s = "FILE_ERROR"; break;
 
114
    case STATUS_BEGIN_DECRYPTION:s = "BEGIN_DECRYPTION"; break;
 
115
    case STATUS_END_DECRYPTION : s = "END_DECRYPTION"; break;
 
116
    case STATUS_BEGIN_ENCRYPTION:s = "BEGIN_ENCRYPTION"; break;
 
117
    case STATUS_END_ENCRYPTION : s = "END_ENCRYPTION"; break;
 
118
    case STATUS_DELETE_PROBLEM : s = "DELETE_PROBLEM"; break;
 
119
    case STATUS_PROGRESS       : s = "PROGRESS"; break;
 
120
    case STATUS_SIG_CREATED    : s = "SIG_CREATED"; break;
 
121
    case STATUS_SESSION_KEY    : s = "SESSION_KEY"; break;
 
122
    case STATUS_NOTATION_NAME  : s = "NOTATION_NAME" ; break;
 
123
    case STATUS_NOTATION_DATA  : s = "NOTATION_DATA" ; break;
 
124
    case STATUS_POLICY_URL     : s = "POLICY_URL" ; break;
 
125
    case STATUS_BEGIN_STREAM   : s = "BEGIN_STREAM"; break;
 
126
    case STATUS_END_STREAM     : s = "END_STREAM"; break;
 
127
    case STATUS_KEY_CREATED    : s = "KEY_CREATED"; break;
 
128
    case STATUS_KEY_NOT_CREATED: s = "KEY_NOT_CREATED"; break;
 
129
    case STATUS_USERID_HINT    : s = "USERID_HINT"; break;
 
130
    case STATUS_UNEXPECTED     : s = "UNEXPECTED"; break;
 
131
    case STATUS_INV_RECP       : s = "INV_RECP"; break;
 
132
    case STATUS_NO_RECP        : s = "NO_RECP"; break;
 
133
    case STATUS_ALREADY_SIGNED : s = "ALREADY_SIGNED"; break;
 
134
    case STATUS_SIGEXPIRED     : s = "SIGEXPIRED deprecated-use-keyexpired-instead"; break;
 
135
    case STATUS_EXPSIG         : s = "EXPSIG"; break;
 
136
    case STATUS_EXPKEYSIG      : s = "EXPKEYSIG"; break;
 
137
    case STATUS_REVKEYSIG      : s = "REVKEYSIG"; break;
 
138
    case STATUS_ATTRIBUTE      : s = "ATTRIBUTE"; break;
 
139
    case STATUS_CARDCTRL       : s = "CARDCTRL"; break;
 
140
    case STATUS_PLAINTEXT      : s = "PLAINTEXT"; break;
 
141
    case STATUS_PLAINTEXT_LENGTH:s = "PLAINTEXT_LENGTH"; break;
 
142
    case STATUS_SIG_SUBPACKET  : s = "SIG_SUBPACKET"; break;
 
143
    case STATUS_SC_OP_SUCCESS  : s = "SC_OP_SUCCESS"; break;
 
144
    case STATUS_SC_OP_FAILURE  : s = "SC_OP_FAILURE"; break;
 
145
    case STATUS_BACKUP_KEY_CREATED:s="BACKUP_KEY_CREATED"; break;
 
146
    case STATUS_PKA_TRUST_BAD  : s = "PKA_TRUST_BAD"; break;
 
147
    case STATUS_PKA_TRUST_GOOD : s = "PKA_TRUST_GOOD"; break;
 
148
    case STATUS_BEGIN_SIGNING  : s = "BEGIN_SIGNING"; break;
 
149
    default: s = "?"; break;
 
150
    }
 
151
  return s;
 
152
}
 
153
 
 
154
 
 
155
/* Return true if the status message NO may currently be issued.  We
 
156
   need this to avoid syncronisation problem while auto retrieving a
 
157
   key.  There it may happen that a status NODATA is issued for a non
 
158
   available key and the user may falsely interpret this has a missing
 
159
   signature. */
 
160
static int
 
161
status_currently_allowed (int no)
 
162
{
 
163
  if (!glo_ctrl.in_auto_key_retrieve)
 
164
    return 1; /* Yes. */
 
165
 
 
166
  /* We allow some statis anyway, so that import statistics are
 
167
     correct and to avoid problems if the retriebval subsystem will
 
168
     prompt the user. */
 
169
  switch (no)
 
170
    {
 
171
    case STATUS_GET_BOOL:        
 
172
    case STATUS_GET_LINE:        
 
173
    case STATUS_GET_HIDDEN:      
 
174
    case STATUS_GOT_IT:  
 
175
    case STATUS_IMPORTED:
 
176
    case STATUS_IMPORT_OK:      
 
177
    case STATUS_IMPORT_CHECK:  
 
178
    case STATUS_IMPORT_RES:
 
179
      return 1; /* Yes. */
 
180
    default:
 
181
      break;
 
182
    }
 
183
  return 0; /* No. */
 
184
}
 
185
 
138
186
 
139
187
void
140
188
set_status_fd ( int fd )
161
209
                  fd, strerror(errno));
162
210
    }
163
211
    last_fd = fd;
164
 
    gcry_set_progress_handler (progress_cb, NULL);
 
212
#warning Use libgrypt calls for progress indicators
 
213
/*     register_primegen_progress ( progress_cb, "primegen" ); */
 
214
/*     register_pk_dsa_progress ( progress_cb, "pk_dsa" ); */
 
215
/*     register_pk_elg_progress ( progress_cb, "pk_elg" ); */
165
216
}
166
217
 
167
218
int
179
230
void
180
231
write_status_text ( int no, const char *text)
181
232
{
182
 
    if( !statusfp )
183
 
        return;  /* not enabled */
 
233
    if( !statusfp || !status_currently_allowed (no) )
 
234
        return;  /* Not enabled or allowed. */
184
235
 
185
236
    fputs ( "[GNUPG:] ", statusfp );
186
237
    fputs ( get_status_string (no), statusfp );
196
247
        }
197
248
    }
198
249
    putc ('\n',statusfp);
199
 
    fflush (statusfp);
 
250
    if ( fflush (statusfp) && opt.exit_on_status_write_error )
 
251
      g10_exit (0);
200
252
}
201
253
 
202
254
 
215
267
    int lower_limit = ' ';
216
268
    size_t n, count, dowrap;
217
269
 
218
 
    if( !statusfp )
219
 
        return;  /* not enabled */
 
270
    if( !statusfp || !status_currently_allowed (no) )
 
271
        return;  /* Not enabled or allowed. */
220
272
    
221
273
    if (wrap == -1) {
222
274
        lower_limit--;
260
312
    } while ( len );
261
313
 
262
314
    putc ('\n',statusfp);
263
 
    fflush (statusfp);
 
315
    if ( fflush (statusfp) && opt.exit_on_status_write_error )
 
316
      g10_exit (0);
264
317
}
265
318
 
266
319
void
308
361
    int i, len;
309
362
    char *string;
310
363
 
 
364
    if(statusfp!=stdout)
 
365
      fflush(stdout);
 
366
 
311
367
    write_status_text( bool? STATUS_GET_BOOL :
312
368
                       hidden? STATUS_GET_HIDDEN : STATUS_GET_LINE, keyword );
313
369
 
348
404
{
349
405
    if( opt.command_fd != -1 )
350
406
        return 1;
 
407
#ifdef USE_SHM_COPROCESSING
 
408
    if( opt.shm_coprocess )
 
409
        return 1;
 
410
#endif
351
411
    return 0;
352
412
}
353
413
 
358
418
 
359
419
    if( opt.command_fd != -1 )
360
420
        return do_get_from_fd ( keyword, 0, 0 );
 
421
#ifdef USE_SHM_COPROCESSING
 
422
    if( opt.shm_coprocess )
 
423
        return do_shm_get( keyword, 0, 0 );
 
424
#endif
361
425
    for(;;) {
362
426
        p = tty_get( prompt );
363
427
        return p;
371
435
 
372
436
    if( opt.command_fd != -1 )
373
437
        return do_get_from_fd ( keyword, 0, 0 );
 
438
#ifdef USE_SHM_COPROCESSING
 
439
    if( opt.shm_coprocess )
 
440
        return do_shm_get( keyword, 0, 0 );
 
441
#endif
374
442
    for(;;) {
375
443
        p = tty_get( prompt );
376
444
        if( *p=='?' && !p[1] && !(keyword && !*keyword)) {
377
 
            xfree (p);
 
445
            xfree(p);
378
446
            display_online_help( keyword );
379
447
        }
380
448
        else
390
458
    p = cpr_get( keyword, prompt );
391
459
    if( p ) {
392
460
        char *utf8 = native_to_utf8( p );
393
 
        xfree ( p );
 
461
        xfree( p );
394
462
        p = utf8;
395
463
    }
396
464
    return p;
403
471
 
404
472
    if( opt.command_fd != -1 )
405
473
        return do_get_from_fd ( keyword, 1, 0 );
 
474
#ifdef USE_SHM_COPROCESSING
 
475
    if( opt.shm_coprocess )
 
476
        return do_shm_get( keyword, 1, 0 );
 
477
#endif
406
478
    for(;;) {
407
479
        p = tty_get_hidden( prompt );
408
480
        if( *p == '?' && !p[1] ) {
409
 
            xfree (p);
 
481
            xfree(p);
410
482
            display_online_help( keyword );
411
483
        }
412
484
        else
419
491
{
420
492
    if( opt.command_fd != -1 )
421
493
        return;
 
494
#ifdef USE_SHM_COPROCESSING
 
495
    if( opt.shm_coprocess )
 
496
        return;
 
497
#endif
422
498
    tty_kill_prompt();
423
499
    return;
424
500
}
431
507
 
432
508
    if( opt.command_fd != -1 )
433
509
        return !!do_get_from_fd ( keyword, 0, 1 );
 
510
#ifdef USE_SHM_COPROCESSING
 
511
    if( opt.shm_coprocess )
 
512
        return !!do_shm_get( keyword, 0, 1 );
 
513
#endif
434
514
    for(;;) {
435
515
        p = tty_get( prompt );
436
516
        trim_spaces(p); /* it is okay to do this here */
437
517
        if( *p == '?' && !p[1] ) {
438
 
            xfree (p);
 
518
            xfree(p);
439
519
            display_online_help( keyword );
440
520
        }
441
521
        else {
442
522
            tty_kill_prompt();
443
523
            yes = answer_is_yes(p);
444
 
            xfree (p);
 
524
            xfree(p);
445
525
            return yes;
446
526
        }
447
527
    }
455
535
 
456
536
    if( opt.command_fd != -1 )
457
537
        return !!do_get_from_fd ( keyword, 0, 1 );
 
538
#ifdef USE_SHM_COPROCESSING
 
539
    if( opt.shm_coprocess )
 
540
        return !!do_shm_get( keyword, 0, 1 );
 
541
#endif
458
542
    for(;;) {
459
543
        p = tty_get( prompt );
460
544
        trim_spaces(p); /* it is okay to do this here */
461
545
        if( *p == '?' && !p[1] ) {
462
 
            xfree (p);
 
546
            xfree(p);
463
547
            display_online_help( keyword );
464
548
        }
465
549
        else {
466
550
            tty_kill_prompt();
467
551
            yes = answer_is_yes_no_quit(p);
468
 
            xfree (p);
 
552
            xfree(p);
469
553
            return yes;
470
554
        }
471
555
    }
472
556
}
 
557
 
 
558
 
 
559
int
 
560
cpr_get_answer_okay_cancel (const char *keyword,
 
561
                            const char *prompt,
 
562
                            int def_answer)
 
563
{
 
564
  int yes;
 
565
  char *answer = NULL;
 
566
  char *p;
 
567
 
 
568
  if( opt.command_fd != -1 )
 
569
    answer = do_get_from_fd ( keyword, 0, 0 );
 
570
#ifdef USE_SHM_COPROCESSING
 
571
  else if( opt.shm_coprocess )
 
572
    answer = do_shm_get( keyword, 0, 0 );
 
573
#endif
 
574
 
 
575
  if (answer)
 
576
    {
 
577
      yes = answer_is_okay_cancel (answer, def_answer);
 
578
      xfree (answer);
 
579
      return yes;
 
580
    }
 
581
 
 
582
  for(;;)
 
583
    {
 
584
      p = tty_get( prompt );
 
585
      trim_spaces(p); /* it is okay to do this here */
 
586
      if (*p == '?' && !p[1])
 
587
        {
 
588
          xfree(p);
 
589
          display_online_help (keyword);
 
590
        }
 
591
      else
 
592
        {
 
593
          tty_kill_prompt();
 
594
          yes = answer_is_okay_cancel (p, def_answer);
 
595
          xfree(p);
 
596
          return yes;
 
597
        }
 
598
    }
 
599
}