« back to all changes in this revision
Viewing changes to gpgwrap/src/gpgwrap.c
- browse files at revision 5
- compare with another revision
- download diff
- download tarball
- view history from revision 5
- Committer: Bazaar Package Importer
- Author(s): Thijs Kinkhorst
- Date: 2009-02-23 21:37:20 UTC
- mfrom: (4.1.1 sid)
- Revision ID: james.westby@ubuntu.com-20090223213720-98hkq51ynr3oaic7
Tags: 1.1-2
Fix build error when only building the binary package
by fixing the build-arch target (Closes: #516804).
by fixing the build-arch target (Closes: #516804).
- files added:
- debian/README.source
- debian/patches
- gpgdir
- gpgdir/packaging
- gpgdir/test
- gpgdir/test/conf
- gpgdir/test/conf/test-gpg
- gpgdir/test/data-dir
- gpgdir/test/data-dir/.hidden-dir
- gpgdir/test/data-dir/dir2
- gpgdir/test/data-dir/dir2/dir4
- gpgdir/test/data-dir/dir3
- gpgdir/test/data-dir/dir3/dir4
- gpgdir/test/data-dir/files_with_spaces
- gpgdir/test/output
- gpgwrap
- gpgwrap/bin
- gpgwrap/doc
- gpgwrap/src
- keyanalyze
- keyanalyze/pgpring
- keyanalyze/scripts
- keyanalyze/willy
- files removed:
- debian/overrides
- files modified:
- Makefile
added
removed
gpgwrap/src/gpgwrap.c
1
/****************************************************************************
2
****************************************************************************
3
*
4
* gpgwrap.c
5
*
6
****************************************************************************
7
****************************************************************************/
8
9
10
11
12
13
#include <errno.h>
14
#include <fcntl.h>
15
#include <stdio.h>
16
#include <string.h>
17
#include <stdlib.h>
18
#include <signal.h>
19
#include <termios.h>
20
#include <unistd.h>
21
#include <sys/stat.h>
22
#include <sys/types.h>
23
#include <sys/wait.h>
24
25
#include "version.h"
26
27
28
29
#define PROGRAM_NAME "gpgwrap"
30
#define VERSION_STRING PROGRAM_NAME " " VERSION "-" VERSION_DATE
31
#define EXEC_ARGV_SIZE 1024
32
#define PASSPHRASE_BUFFER_SIZE 0x10000
33
#define LIST_BUFFER_SIZE 0x10000
34
#define CMDLINE_MAX_FILES 1024
35
#define GPGWRAP_MODE_DEFAULT 0
36
#define GPGWRAP_MODE_VERSION 1
37
#define GPGWRAP_MODE_FILE 2
38
#define GPGWRAP_MODE_PRINT 3
39
40
41
42
static char program_name[] = PROGRAM_NAME;
43
static char environ_name[] = "GPGWRAP_PASSPHRASE";
44
static int mode = GPGWRAP_MODE_DEFAULT;
45
static int verbose = 0;
46
static int interactive = 0;
47
static int ask_twice = 0;
48
static int check_exit_code = 0;
49
static char *calling_path = NULL;
50
static char *environ_var = NULL;
51
static char *passphrase_file = NULL;
52
static char *option_name = "--passphrase-fd";
53
static char *files[CMDLINE_MAX_FILES];
54
static int nfiles = 0;
55
static char **gpg_cmd = NULL;
56
57
58
59
/****************************************************************************
60
* do_perror
61
****************************************************************************/
62
static void
63
do_perror(
64
void)
65
66
{
67
perror(program_name);
68
exit(1);
69
}
70
71
72
73
/****************************************************************************
74
* do_error
75
****************************************************************************/
76
#define do_error(args...) \
77
do \
78
{ \
79
fprintf(stderr, "%s: ", program_name); \
80
fprintf(stderr, args); \
81
fprintf(stderr, "\n"); \
82
exit(1); \
83
} \
84
while (0)
85
86
87
88
/****************************************************************************
89
* do_warning
90
****************************************************************************/
91
#define do_warning(args...) \
92
do \
93
{ \
94
fprintf(stderr, "%s: ", program_name); \
95
fprintf(stderr, args); \
96
fprintf(stderr, "\n"); \
97
} \
98
while (0)
99
100
101
102
/****************************************************************************
103
* do_error_oom
104
****************************************************************************/
105
static void
106
do_error_oom(
107
void)
108
109
{
110
do_error("could not allocate memory");
111
}
112
113
114
115
/****************************************************************************
116
* do_error_too_long
117
****************************************************************************/
118
static void
119
do_error_too_long(
120
void)
121
122
{
123
do_error("passphrase too long");
124
}
125
126
127
128
/****************************************************************************
129
* do_verbose
130
****************************************************************************/
131
#define do_verbose(level, args...) \
132
do \
133
{ \
134
if (verbose < level) break; \
135
fprintf(stderr, "%s[%d]: ", program_name, getpid()); \
136
fprintf(stderr, args); \
137
fprintf(stderr, "\n"); \
138
} \
139
while (0)
140
141
142
143
/****************************************************************************
144
* do_verbose_start
145
****************************************************************************/
146
#define do_verbose_start(level, args...) \
147
do \
148
{ \
149
if (verbose < level) break; \
150
fprintf(stderr, "%s[%d] ", program_name, getpid()); \
151
fprintf(stderr, args); \
152
} \
153
while (0)
154
155
156
157
/****************************************************************************
158
* do_verbose_append
159
****************************************************************************/
160
#define do_verbose_append(level, args...) \
161
do \
162
{ \
163
if (verbose < level) break; \
164
fprintf(stderr, args); \
165
} \
166
while (0)
167
168
169
170
/****************************************************************************
171
* do_snprintf
172
****************************************************************************/
173
#define do_snprintf(string, max, args...) do_snprintf2(snprintf(string, max, args), max)
174
175
176
177
/****************************************************************************
178
* do_snprintf2
179
****************************************************************************/
180
static int
181
do_snprintf2(
182
int len,
183
int max)
184
185
{
186
if ((len == -1) || (len >= max)) do_error("do_snprintf() size exceeded");
187
return (len);
188
}
189
190
191
192
/****************************************************************************
193
* mangle_passphrase
194
****************************************************************************/
195
static int
196
mangle_passphrase(
197
char *buffer,
198
int size,
199
char *mbuffer,
200
int msize)
201
202
{
203
char c;
204
int i, j, c1;
205
206
/*
207
* look for "unusual" characters and convert them to
208
* backslash escaped octal numbers
209
*/
210
211
for (i = j = 0, msize--; i < size; i++)
212
{
213
c = buffer[i];
214
if (j >= msize) goto error;
215
if ((c < '+') || ((c > ';') && (c < 'A')) ||
216
((c > 'Z') && (c != '_') && (c < 'a')) ||
217
((c > 'z') && (c != '~')))
218
{
219
c1 = (unsigned char) c;
220
if (j >= msize - 4) goto error;
221
mbuffer[j++] = '\\';
222
mbuffer[j++] = '0' + (c1 >> 6);
223
mbuffer[j++] = '0' + ((c1 >> 3) & 7);
224
mbuffer[j++] = '0' + (c1 & 7);
225
}
226
else mbuffer[j++] = c;
227
}
228
mbuffer[j] = '\0';
229
return (j);
230
error:
231
do_error("could not mangle passphrase");
232
}
233
234
235
236
/****************************************************************************
237
* unmangle_passphrase
238
****************************************************************************/
239
static int
240
unmangle_passphrase(
241
char *buffer,
242
int size)
243
244
{
245
char c;
246
int i, j, c1, c2, c3;
247
248
/* replace backslash escaped octal numbers */
249
250
for (i = j = 0; j < size; i++)
251
{
252
c = buffer[j++];
253
if (c == '\\')
254
{
255
if (j > size - 3) goto error;
256
c1 = buffer[j++];
257
c2 = buffer[j++];
258
c3 = buffer[j++];
259
if ((c1 < '0') || (c1 > '3') || (c2 < '0') || (c2 > '7') ||
260
(c3 < '0') || (c3 > '7')) goto error;
261
c1 -= '0';
262
c2 -= '0';
263
c3 -= '0';
264
c = (char) (((c1 << 6) | (c2 << 3) | c3) & 0xff);
265
}
266
buffer[i] = c;
267
}
268
return (i);
269
error:
270
do_error("could not unmangle passphrase");
271
}
272
273
274
275
/****************************************************************************
276
* read_passphrase
277
****************************************************************************/
278
static int
279
read_passphrase(
280
char *buffer,
281
int size)
282
283
{
284
int fd, len, i;
285
286
do_verbose(2, "reading passphrase from file '%s'", passphrase_file);
287
if (strcmp(passphrase_file, "-") == 0) fd = STDIN_FILENO;
288
else fd = open(passphrase_file, O_RDONLY);
289
if (fd == -1) do_perror();
290
for (len = 0; (i = read(fd, buffer, size)) > 0; len += i)
291
{
292
buffer += i;
293
size -= i;
294
if (size == 0) do_error_too_long();
295
}
296
if (i == -1) do_perror();
297
if (close(fd) == -1) do_perror();
298
return (len);
299
}
300
301
302
303
/****************************************************************************
304
* prompt_passphrase
305
****************************************************************************/
306
static int
307
prompt_passphrase(
308
char *buffer,
309
int size)
310
311
{
312
int len, len2;
313
int fd;
314
struct termios t, tt;
315
char tty[] = "/dev/tty";
316
char pp[] = "Passphrase: ";
317
char pp2[] = "\nPassphrase (again): ";
318
char *buffer2;
319
320
/*
321
* don't touch stdin, just open the controlling tty and ask for the
322
* passphrase
323
*/
324
325
do_verbose(2, "opening '%s' to prompt for passphrase", tty);
326
fd = open(tty, O_RDWR);
327
if (fd == -1) do_perror();
328
write(fd, pp, strlen(pp));
329
tcgetattr(fd, &t);
330
tt = t;
331
tt.c_lflag &= ~ECHO;
332
tcsetattr(fd, TCSAFLUSH, &tt);
333
len = read(fd, buffer, size);
334
if (len == -1) do_perror();
335
if ((ask_twice) && (len < size))
336
{
337
buffer2 = (char *) alloca(sizeof (char) * size);
338
if (buffer2 == NULL) do_error_oom();
339
write(fd, pp2, strlen(pp2));
340
len2 = read(fd, buffer2, size);
341
if (len2 == -1) do_perror();
342
write(fd, "\n", 1);
343
tcsetattr(fd, TCSAFLUSH, &t);
344
if ((len != len2) || (memcmp(buffer, buffer2, len) != 0)) do_error("passphrases are not the same");
345
}
346
else
347
{
348
write(fd, "\n", 1);
349
tcsetattr(fd, TCSAFLUSH, &t);
350
351
/*
352
* if the above read() returns with len == size, we don't
353
* know if there are more bytes, so we assume passphrase is
354
* too long
355
*/
356
357
if (len >= size) do_error_too_long();
358
}
359
if (close(fd) == -1) do_perror();
360
361
/* ignore trailing \012 */
362
363
return (len - 1);
364
}
365
366
367
368
/****************************************************************************
369
* environ_or_prompt
370
****************************************************************************/
371
static int
372
environ_or_prompt(
373
char *buffer,
374
int size)
375
376
{
377
int len, len2;
378
char *env;
379
380
env = getenv(environ_name);
381
if ((env != NULL) && (! interactive))
382
{
383
do_verbose(2, "got passphrase from environment variable: %s=%s", environ_name, env);
384
385
/*
386
* first unmangle the content of the environment
387
* variable inplace, then clear the memory
388
*/
389
390
len2 = strlen(env);
391
len = unmangle_passphrase(env, len2);
392
if (len > size) do_error_too_long();
393
memcpy(buffer, env, len);
394
memset(env, 0, len2);
395
}
396
else len = prompt_passphrase(buffer, size);
397
return (len);
398
}
399
400
401
402
/****************************************************************************
403
* do_wait
404
****************************************************************************/
405
static void
406
do_wait(
407
void)
408
409
{
410
int status, value = 1;
411
412
do_verbose(2, "waiting for child");
413
wait(&status);
414
if (! check_exit_code) return;
415
do_verbose(2, "checking child exit code");
416
if (! WIFEXITED(status)) goto out;
417
value = WEXITSTATUS(status);
418
if (value == 0) return;
419
do_verbose(2, "child process terminated abnormal, exiting");
420
out:
421
exit(value);
422
}
423
424
425
426
/****************************************************************************
427
* do_fork
428
****************************************************************************/
429
static int
430
do_fork(
431
char *buffer,
432
int size)
433
434
{
435
int fds[2], i;
436
437
/*
438
* parent will write passphrase to the opened pipe, child will
439
* pass the fd to gpg
440
*/
441
442
if (pipe(fds) == -1) do_perror();
443
do_verbose(2, "forking");
444
switch (fork())
445
{
446
case -1:
447
do_perror();
448
case 0:
449
/* child */
450
451
if (close(fds[1]) == -1) do_perror();
452
return (fds[0]);
453
default:
454
break;
455
}
456
457
/* parent */
458
459
signal(SIGPIPE, SIG_IGN);
460
if (close(fds[0]) == -1) do_perror();
461
while (size > 0)
462
{
463
i = write(fds[1], buffer, size);
464
if ((i == -1) && (errno == EPIPE)) break;
465
if (i == -1) do_perror();
466
buffer += i;
467
size -= i;
468
}
469
if (size > 0) do_warning("only partial passphrase written");
470
if (close(fds[1]) == -1) do_perror();
471
do_wait();
472
return (-1);
473
}
474
475
476
477
/****************************************************************************
478
* get_passphrase_fd
479
****************************************************************************/
480
static int
481
get_passphrase_fd(
482
void)
483
484
{
485
int fd, len;
486
char buffer[PASSPHRASE_BUFFER_SIZE];
487
488
if ((passphrase_file == NULL) || (interactive))
489
{
490
len = environ_or_prompt(buffer, sizeof (buffer));
491
fd = do_fork(buffer, len);
492
}
493
else if (strcmp(passphrase_file, "-") == 0)
494
{
495
len = read_passphrase(buffer, sizeof (buffer));
496
fd = do_fork(buffer, len);
497
}
498
else
499
{
500
do_verbose(2, "opening file '%s' to pass fd", passphrase_file);
501
fd = open(passphrase_file, O_RDONLY);
502
if (fd == -1) do_perror();
503
}
504
return (fd);
505
}
506
507
508
509
/****************************************************************************
510
* get_passphrase
511
****************************************************************************/
512
static int
513
get_passphrase(
514
char *buffer,
515
int size)
516
517
{
518
int len;
519
520
if ((passphrase_file == NULL) || (interactive)) len = environ_or_prompt(buffer, size);
521
else len = read_passphrase(buffer, size);
522
return (len);
523
}
524
525
526
527
/****************************************************************************
528
* do_putenv
529
****************************************************************************/
530
static void
531
do_putenv(
532
char *buffer,
533
int len)
534
535
{
536
int size, len2;
537
char *old_var;
538
539
/*
540
* putenv() only stores the given pointer in **environ, so we have
541
* to use malloc here
542
*/
543
544
size = strlen(environ_name) + (4 * len) + 2;
545
old_var = environ_var;
546
environ_var = (char *) malloc(sizeof (char) * size);
547
if (environ_var == NULL) do_error_oom();
548
len2 = do_snprintf(environ_var, size, "%s=", environ_name);
549
if ((buffer != NULL) && (len > 0)) mangle_passphrase(buffer, len, &environ_var[len2], size - len2);
550
do_verbose(2, "setting environment variable: %s", environ_var);
551
if (putenv(environ_var) == -1) do_perror();
552
if (old_var != NULL) free(old_var);
553
}
554
555
556
557
/****************************************************************************
558
* do_exec
559
****************************************************************************/
560
static void
561
do_exec(
562
char **argv,
563
int clear)
564
565
{
566
if (clear) do_putenv(NULL, 0);
567
if (verbose > 0)
568
{
569
int i;
570
571
do_verbose_start(1, "executing:");
572
for (i = 0; argv[i] != NULL; i++) do_verbose_append(1, " %s", argv[i]);
573
do_verbose_append(1, "\n");
574
}
575
execvp(argv[0], argv);
576
577
/* only reached if execvp fails */
578
579
do_perror();
580
}
581
582
583
584
/****************************************************************************
585
* exec_gpg
586
****************************************************************************/
587
static void
588
exec_gpg(
589
void)
590
591
{
592
int fd;
593
int i, j, k;
594
char fd_num[32];
595
char *argv[EXEC_ARGV_SIZE];
596
char homedir_eq[] = "--homedir=";
597
char options_eq[] = "--options=";
598
599
/*
600
* get fd to read passphrase from, parent will return with fd == -1
601
* after fork
602
*/
603
604
fd = get_passphrase_fd();
605
if (fd == -1) return;
606
607
/* create argv for execvp */
608
609
do_snprintf(fd_num, sizeof (fd_num), "%d", fd);
610
for (i = 0, j = 0, k = 1; gpg_cmd[i] != NULL; i++, k--)
611
{
612
613
/*
614
* check if there is enough space to store option_name
615
* and fd_num
616
*/
617
618
if (i >= (EXEC_ARGV_SIZE - 4)) do_error("too many gpg arguments specified");
619
if (strcmp(gpg_cmd[i], option_name) == 0) do_error("gpg command already has a '%s' option", option_name);
620
if (k == 0)
621
{
622
if ((strncmp(gpg_cmd[i], homedir_eq, sizeof (homedir_eq) - 1) == 0) || (strncmp(gpg_cmd[i], options_eq, sizeof (options_eq) - 1) == 0)) k = 1;
623
else if ((strcmp(gpg_cmd[i], "--homedir") == 0) || (strcmp(gpg_cmd[i], "--options") == 0)) k = 2;
624
else
625
{
626
argv[j++] = option_name;
627
argv[j++] = fd_num;
628
}
629
}
630
argv[j++] = gpg_cmd[i];
631
}
632
if (k >= 0)
633
{
634
argv[j++] = option_name;
635
argv[j++] = fd_num;
636
}
637
argv[j] = NULL;
638
do_exec(argv, 1);
639
}
640
641
642
643
/****************************************************************************
644
* exec_line
645
****************************************************************************/
646
static void
647
exec_line(
648
char *line)
649
650
{
651
char shell_cmd[LIST_BUFFER_SIZE];
652
char verbose_string[128] = "";
653
char *argv[] = { "sh", "-c", NULL, NULL };
654
int fds[2], i;
655
656
/* fork a child and disallow it to read stdin from parent */
657
658
if (pipe(fds) == -1) do_perror();
659
do_verbose(1, "forking");
660
switch (fork())
661
{
662
case -1:
663
do_perror();
664
case 0:
665
break;
666
default:
667
/* parent */
668
669
if (close(fds[0]) == -1) do_perror();
670
if (close(fds[1]) == -1) do_perror();
671
do_wait();
672
return;
673
}
674
675
/* child */
676
677
if (close(fds[1]) == -1) do_perror();
678
if (fds[0] != STDIN_FILENO) dup2(fds[0], STDIN_FILENO);
679
680
/* create argv for execvp */
681
682
for (i = 0; i < verbose; i++)
683
{
684
if (strlen(verbose_string) >= sizeof (verbose_string) - 4) break;
685
strcat(verbose_string, " -v");
686
}
687
do_snprintf(shell_cmd, sizeof (shell_cmd), "exec %s%s -o %s -- %s",
688
calling_path, verbose_string, option_name, line);
689
argv[2] = shell_cmd;
690
do_exec(argv, 0);
691
}
692
693
694
695
/****************************************************************************
696
* exec_list
697
****************************************************************************/
698
static void
699
exec_list(
700
char *path,
701
char *buffer,
702
int len)
703
704
{
705
int fd;
706
char lbuffer[LIST_BUFFER_SIZE];
707
int inuse, start, free, nread, llen;
708
char *line, *next_line;
709
710
/* open file */
711
712
do_verbose(1, "reading gpg commands from file: '%s'", path);
713
if (strcmp(path, "-") == 0) fd = STDIN_FILENO;
714
else fd = open(path, O_RDONLY);
715
if (fd == -1) do_perror();
716
717
/* export passphrase to environment */
718
719
do_putenv(buffer, len);
720
721
/* read gpg commands */
722
723
for (inuse = 0, free = LIST_BUFFER_SIZE; (nread = read(fd, &lbuffer[inuse], free)) > 0; )
724
{
725
inuse += nread;
726
for (line = lbuffer; (next_line = memchr(line, '\n', inuse)) != NULL; )
727
{
728
*next_line = '\0';
729
llen = (int) (next_line - line) + 1;
730
if (llen != strlen(line) + 1) do_error("line contains \\0 character");
731
exec_line(line);
732
inuse -= llen;
733
line = next_line + 1;
734
}
735
start = (int) (line - lbuffer);
736
if ((start == 0) && (inuse == LIST_BUFFER_SIZE)) do_error("line too long");
737
if ((start > 0) && (inuse > 0)) memmove(lbuffer, &lbuffer[start], inuse);
738
free = LIST_BUFFER_SIZE - inuse;
739
}
740
741
/* check for error while read() */
742
743
if (nread == -1) do_perror();
744
if (close(fd) == -1) do_perror();
745
746
/* check if there are bytes left */
747
748
if (inuse > 0) do_error("last line incomplete");
749
}
750
751
752
753
/****************************************************************************
754
* cmdline_fill_space
755
****************************************************************************/
756
static void
757
cmdline_fill_space(
758
char *s)
759
760
{
761
while (*s != '\0') *s++ = ' ';
762
}
763
764
765
766
/****************************************************************************
767
* cmdline_usage
768
****************************************************************************/
769
static void
770
cmdline_usage(
771
void)
772
773
{
774
char space1[] = VERSION_STRING;
775
char space2[] = PROGRAM_NAME;
776
777
cmdline_fill_space(space1);
778
cmdline_fill_space(space2);
779
printf(VERSION_STRING " | written by Karsten Scheibler\n"
780
"%s | http://unusedino.de/gpgwrap/\n"
781
"%s | gpgwrap@unusedino.de\n\n"
782
"Usage: %s -V\n"
783
"or: %s -P [-v] [-i] [-a] [-p <file>]\n"
784
"or: %s -F [-v] [-i] [-a] [-c] [-p <file>] [-o <name>]\n"
785
" %s [--] <file> [<file> ... ]\n"
786
"or: %s [-v] [-i] [-a] [-p <file>] [-o <name>]\n"
787
" %s [--] gpg [gpg options]\n\n"
788
" -V print out version\n"
789
" -P get the passphrase and print it mangled to stdout\n"
790
" -F read gpg commands from file\n"
791
" -v be more verbose\n"
792
" -i be interactive, always prompt for passphrase\n"
793
" -a ask twice if prompting for passphrase\n"
794
" -c check exit code of child processes\n"
795
" -p <file> read passphrase from <file>\n"
796
" -o <name> specify name of \"--passphrase-fd\" option\n"
797
" -h this help\n",
798
space1, space1, program_name, program_name, program_name,
799
space2, program_name, space2);
800
exit(0);
801
}
802
803
804
805
/****************************************************************************
806
* cmdline_check_arg
807
****************************************************************************/
808
static char *
809
cmdline_check_arg(
810
char *msg,
811
char *file)
812
813
{
814
if (file == NULL) do_error("%s expects a file name", msg);
815
return (file);
816
}
817
818
819
820
/****************************************************************************
821
* cmdline_check_stdin
822
****************************************************************************/
823
static char *
824
cmdline_check_stdin(
825
char *msg,
826
char *file)
827
828
{
829
static int stdin_count = 0;
830
831
cmdline_check_arg(msg, file);
832
if (strcmp(file, "-") == 0) stdin_count++;
833
if (stdin_count > 1) do_error("%s used stdin although already used before", msg);
834
return (file);
835
}
836
837
838
839
/****************************************************************************
840
* cmdline_parse
841
****************************************************************************/
842
static void
843
cmdline_parse(
844
int argc,
845
char **argv)
846
847
{
848
char *arg;
849
int args;
850
int ignore = 0;
851
852
calling_path = argv[0];
853
for (args = 0, argv++; (arg = *argv++) != NULL; args++)
854
{
855
if ((arg[0] != '-') || (ignore))
856
{
857
if (mode == GPGWRAP_MODE_FILE) goto get_file;
858
gpg_cmd = argv - 1;
859
break;
860
}
861
else if ((strcmp(arg, "-") == 0) && (mode == GPGWRAP_MODE_FILE))
862
{
863
get_file:
864
if (nfiles >= CMDLINE_MAX_FILES) do_error("too many files specified");
865
files[nfiles++] = cmdline_check_stdin("-F/--file", arg);
866
}
867
else if (strcmp(arg, "--") == 0)
868
{
869
ignore = 1;
870
}
871
else if ((strcmp(arg, "-h") == 0) || (strcmp(arg, "--help") == 0))
872
{
873
cmdline_usage();
874
}
875
else if (((strcmp(arg, "-V") == 0) || (strcmp(arg, "--version") == 0)) && (args == 0))
876
{
877
mode = GPGWRAP_MODE_VERSION;
878
}
879
else if (((strcmp(arg, "-F") == 0) || (strcmp(arg, "--file") == 0)) && (args == 0))
880
{
881
mode = GPGWRAP_MODE_FILE;
882
}
883
else if (((strcmp(arg, "-P") == 0) || (strcmp(arg, "--print") == 0)) && (args == 0))
884
{
885
mode = GPGWRAP_MODE_PRINT;
886
}
887
else if (mode == GPGWRAP_MODE_VERSION)
888
{
889
goto bad_option;
890
}
891
else if ((strcmp(arg, "-v") == 0) || (strcmp(arg, "--verbose") == 0))
892
{
893
verbose++;
894
}
895
else if ((strcmp(arg, "-i") == 0) || (strcmp(arg, "--interactive") == 0))
896
{
897
interactive = 1;
898
}
899
else if ((strcmp(arg, "-a") == 0) || (strcmp(arg, "--ask-twice") == 0))
900
{
901
ask_twice = 1;
902
}
903
else if ((strcmp(arg, "-p") == 0) || (strcmp(arg, "--passphrase-file") == 0))
904
{
905
if (passphrase_file != NULL) do_error("-p/--passphrase-file specified more than once");
906
passphrase_file = cmdline_check_stdin("-p/--passphrase-file", *argv++);
907
}
908
else if (mode == GPGWRAP_MODE_PRINT)
909
{
910
goto bad_option;
911
}
912
else if ((strcmp(arg, "-o") == 0) || (strcmp(arg, "--option-name") == 0))
913
{
914
option_name = cmdline_check_arg("-o/--option-name", *argv++);
915
}
916
else if (mode != GPGWRAP_MODE_FILE)
917
{
918
goto bad_option;
919
}
920
else if ((strcmp(arg, "-c") == 0) || (strcmp(arg, "--check-exit-code") == 0))
921
{
922
check_exit_code = 1;
923
}
924
else
925
{
926
bad_option:
927
do_error("unrecognized option '%s'", arg);
928
}
929
}
930
if ((mode == GPGWRAP_MODE_DEFAULT) && (nfiles == 0) && (gpg_cmd == NULL)) do_error("no gpg command specified");
931
if ((mode == GPGWRAP_MODE_FILE) && (nfiles == 0)) do_error("no files to process");
932
if ((mode == GPGWRAP_MODE_PRINT) && (nfiles > 0)) do_error("no additional arguments allowed");
933
if (mode != GPGWRAP_MODE_FILE) check_exit_code = 1;
934
}
935
936
937
938
/****************************************************************************
939
* main
940
****************************************************************************/
941
int
942
main(
943
int argc,
944
char **argv)
945
946
{
947
948
/*
949
* we need setlinebuf(), because otherwise do_verbose() output of
950
* parent and child processes may get mixed in some cases
951
*/
952
953
setlinebuf(stderr);
954
955
/* parse cmdline */
956
957
cmdline_parse(argc, argv);
958
959
/* do it */
960
961
if (mode == GPGWRAP_MODE_VERSION)
962
{
963
printf(VERSION_STRING "\n");
964
}
965
else if (mode == GPGWRAP_MODE_FILE)
966
{
967
int i, len;
968
char buffer[PASSPHRASE_BUFFER_SIZE];
969
970
len = get_passphrase(buffer, sizeof (buffer));
971
for (i = 0; i < nfiles; i++) exec_list(files[i], buffer, len);
972
}
973
else if (mode == GPGWRAP_MODE_PRINT)
974
{
975
char buffer[PASSPHRASE_BUFFER_SIZE];
976
char mbuffer[PASSPHRASE_BUFFER_SIZE];
977
int len;
978
979
len = get_passphrase(buffer, sizeof (buffer));
980
mangle_passphrase(buffer, len, mbuffer, sizeof (mbuffer));
981
printf("%s\n", mbuffer);
982
}
983
else exec_gpg();
984
985
/* done */
986
987
return (0);
988
}
989
/******************************************************** Karsten Scheibler */
Loggerhead is a web-based interface for Breezy
Version: 2.0.1