?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added pwmd_inquire(). This removes PWMD_OPTION_INQUIRE_FUNC and
[libpwmd.git] / pwmc.c
bloba9c571b8d9609590e52a22bd1de5d1117f75c410
1 /* vim:tw=78:ts=8:sw=4:set ft=c: */
2 /*
3 Copyright (C) 2007 Ben Kibbey <bjk@luxsci.net>
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <unistd.h>
22 #include <err.h>
23 #include <errno.h>
24 #include <string.h>
25 #include <signal.h>
26 #include <termios.h>
27 #include <libpwmd.h>
28
29 #ifdef HAVE_CONFIG_H
30 #include <config.h>
31 #endif
32
33 #ifdef HAVE_LOCALE_H
34 #include <locale.h>
35 #endif
36
37 #include "gettext.h"
38 #define N_(msgid) gettext(msgid)
39
40 #ifndef MEM_DEBUG
41 #include "mem.h"
42 #else
43 #define xfree free
44 #define xrealloc realloc
45 #define xmalloc malloc
46 #define xstrdup strdup
47 #define xcalloc calloc
48 #endif
49
50 int timeout, elapsed;
51 pwm_t *pwm;
52
53 static void show_error(gpg_error_t error)
54 {
55 fprintf(stderr, "ERR %i %s\n", gpg_err_code(error), pwmd_strerror(error));
56 }
57
58 void catchsig(int sig)
59 {
60 gpg_error_t error;
61
62 switch (sig) {
63 case SIGALRM:
64 if (pwm && timeout > 0 && elapsed++ >= timeout) {
65 error = pwmd_terminate_pinentry(pwm);
66
67 if (error)
68 show_error(error);
69
70 break;
71 }
72
73 alarm(1);
74 break;
75 default:
76 break;
77 }
78 }
79
80 static void usage(const char *pn)
81 {
82 fprintf(stderr, N_(
83 "Reads PWMD protocol commands from standard input.\n\n"
84 "Usage: pwmc [-hvX] [-s <socket>] [[-a [-P -T -N -D] [-t <seconds>]] |\n"
85 " [-p <password>]] [-S] [-d <fd>] [-I <fd>] [filename]\n"
86 " -X disable showing of status messages from the server\n"
87 " -s socket path\n"
88 " -p password\n"
89 " -a use pinentry(1) for password retrieval\n"
90 " -P path to the pinentry binary (%s)\n"
91 " -T pinentry tty\n"
92 " -N pinentry terminal type\n"
93 " -D pinentry display\n"
94 " -t pinentry timeout\n"
95 " -d redirect command output to the specified file descriptor\n"
96 " -I read inquire data from the specified file descriptor\n"
97 " -S send the SAVE command after all others\n"
98 " -v version\n"
99 " -h this help text\n"), PINENTRY_PATH);
100 exit(EXIT_FAILURE);
101 }
102
103 int set_pinentry_option(pwmd_option_t option, void *value)
104 {
105 gpg_error_t error;
106
107 error = pwmd_setopt(pwm, option, value);
108
109 if (error) {
110 show_error(error);
111 pwmd_close(pwm);
112 return 1;
113 }
114
115 return 0;
116 }
117
118 struct inquire_s {
119 FILE *fp;
120 char *data;
121 };
122
123 static gpg_error_t do_inquire(void *data, const char *keyword, gpg_error_t rc,
124 char **result, size_t *result_len)
125 {
126 int c;
127 static char buf[1000]; /* Assuan protocol line length limit. */
128 char *p;
129 size_t len = 0;
130 struct inquire_s *inq = data;
131
132 if (rc) {
133 memset(buf, 0, sizeof(buf));
134 return rc;
135 }
136
137 buf[0] = 0;
138 p = buf;
139
140 if (inq->data) {
141 snprintf(buf, sizeof(buf), "%s", inq->data);
142 xfree(inq->data);
143 inq->data = NULL;
144 len = strlen(buf);
145 p = buf + len;
146 }
147
148 while ((c = fgetc(inq->fp)) != EOF) {
149 if (len == sizeof(buf)) {
150 ungetc(c, inq->fp);
151 break;
152 }
153
154 *p++ = c;
155 len++;
156 }
157
158 if (!buf[0]) {
159 memset(buf, 0, sizeof(buf));
160 return GPG_ERR_EOF;
161 }
162
163 *result = buf;
164 *result_len = len;
165 return 0;
166 }
167
168 static int status_msg_cb(void *data, const char *line)
169 {
170 fprintf(stderr, "%s\n", line);
171 return 0;
172 }
173
174 int main(int argc, char *argv[])
175 {
176 int opt;
177 int use_pinentry = 0;
178 char *password = NULL;
179 char *filename = NULL;
180 char *socketpath = NULL;
181 char command[1000], *p;
182 int ret = EXIT_SUCCESS;
183 gpg_error_t error;
184 char *result = NULL;
185 int save = 0;
186 char *pinentry_path = NULL;
187 char *display = NULL, *tty = NULL, *ttytype = NULL;
188 struct termios term;
189 int outfd = STDOUT_FILENO;
190 FILE *outfp = stdout;
191 int inquirefd = STDIN_FILENO;
192 FILE *inquirefp = stdin;
193 int show_status = 1;
194
195 setlocale(LC_ALL, "");
196 bindtextdomain("libpwmd", LOCALEDIR);
197 timeout = -1;
198
199 while ((opt = getopt(argc, argv, "I:XT:N:D:hvaP:t:p:s:Sd:")) != EOF) {
200 switch (opt) {
201 case 'X':
202 show_status = 0;
203 break;
204 case 'T':
205 tty = optarg;
206 break;
207 case 'N':
208 ttytype = optarg;
209 break;
210 case 'D':
211 display = optarg;
212 break;
213 case 'I':
214 inquirefd = atoi(optarg);
215 inquirefp = fdopen(inquirefd, "r");
216
217 if (!inquirefp) {
218 xfree(password);
219 err(EXIT_FAILURE, "%i", inquirefd);
220 }
221 break;
222 case 'd':
223 outfd = atoi(optarg);
224 outfp = fdopen(outfd, "w");
225
226 if (!outfp) {
227 xfree(password);
228 err(EXIT_FAILURE, "%i", outfd);
229 }
230 break;
231 case 'S':
232 save = 1;
233 break;
234 case 's':
235 socketpath = xstrdup(optarg);
236 break;
237 case 'p':
238 password = xstrdup(optarg);
239 break;
240 case 'a':
241 use_pinentry = 1;
242 break;
243 case 'P':
244 pinentry_path = xstrdup(optarg);
245 break;
246 case 't':
247 timeout = atoi(optarg);
248 break;
249 case 'v':
250 xfree(password);
251 printf("%s (pwmc)\n%s\n", PACKAGE_STRING, PACKAGE_BUGREPORT);
252 exit(EXIT_SUCCESS);
253 case 'h':
254 default:
255 xfree(password);
256 usage(argv[0]);
257 }
258 }
259
260 if (use_pinentry && password) {
261 xfree(password);
262 usage(argv[0]);
263 }
264
265 filename = argv[optind];
266 pwmd_init();
267
268 if ((pwm = pwmd_connect(socketpath, &error)) == NULL) {
269 xfree(password);
270 errx(EXIT_FAILURE, "pwmd_connect(): %s", pwmd_strerror(error));
271 }
272
273 if (password) {
274 if (set_pinentry_option(PWMD_OPTION_PASSWORD, password)) {
275 xfree(password);
276 exit(EXIT_FAILURE);
277 }
278
279 xfree(password);
280 }
281 else if (use_pinentry) {
282 error = pwmd_setopt(pwm, PWMD_OPTION_PINENTRY, 1);
283
284 if (error) {
285 show_error(error);
286 pwmd_close(pwm);
287 exit(EXIT_FAILURE);
288 }
289
290 if (set_pinentry_option(PWMD_OPTION_PINENTRY_PATH, pinentry_path))
291 exit(EXIT_FAILURE);
292
293 if (set_pinentry_option(PWMD_OPTION_PINENTRY_TITLE,
294 N_("Password Manager Daemon")))
295 exit(EXIT_FAILURE);
296
297 snprintf(command, sizeof(command), N_("A password is required for the "
298 "file \"%s\". Please\nenter the password below."), filename);
299
300 if (set_pinentry_option(PWMD_OPTION_PINENTRY_DESC, command))
301 exit(EXIT_FAILURE);
302
303 if (display) {
304 if (set_pinentry_option(PWMD_OPTION_PINENTRY_DISPLAY, display))
305 exit(EXIT_FAILURE);
306 }
307
308 if (tty) {
309 if (set_pinentry_option(PWMD_OPTION_PINENTRY_TTY, tty))
310 exit(EXIT_FAILURE);
311 }
312
313 if (ttytype) {
314 if (set_pinentry_option(PWMD_OPTION_PINENTRY_TERM, ttytype))
315 exit(EXIT_FAILURE);
316 }
317 }
318
319 if (show_status) {
320 if (set_pinentry_option(PWMD_OPTION_STATUS_FUNC, status_msg_cb)) {
321 show_error(error);
322 pwmd_close(pwm);
323 exit(EXIT_FAILURE);
324 }
325 }
326
327 if (filename) {
328 if (use_pinentry && timeout != -1) {
329 tcgetattr(STDOUT_FILENO, &term);
330 signal(SIGALRM, catchsig);
331 alarm(1);
332 }
333
334 error = pwmd_open(pwm, filename);
335
336 if (error) {
337 if (error == GPG_ERR_TIMEOUT) {
338 tcsetattr(STDOUT_FILENO, 0, &term);
339 printf("\r\n");
340 }
341
342 show_error(error);
343 pwmd_close(pwm);
344 exit(EXIT_FAILURE);
345 }
346 }
347
348 signal(SIGALRM, SIG_IGN);
349 elapsed = 0;
350
351 p = fgets(command, sizeof(command), stdin);
352
353 if (!p)
354 goto done;
355
356 /*
357 * This is a known INQUIRE command. We use pwmd_inquire() to send the
358 * data from the do_inquire() callback function.
359 */
360 if (strncasecmp(p, "STORE ", 6) == 0) {
361 struct inquire_s *inq = malloc(sizeof(struct inquire_s));
362
363 if (!inq) {
364 show_error(gpg_error_from_errno(ENOMEM));
365 ret = EXIT_FAILURE;
366 goto done;
367 }
368
369 inq->data = xstrdup(p+6);
370 inq->fp = inquirefp;
371 error = pwmd_inquire(pwm, "STORE", do_inquire, inq);
372 free(inq);
373
374 if (error) {
375 show_error(error);
376 ret = EXIT_FAILURE;
377 }
378
379 goto done;
380 }
381
382 if (p[strlen(p) - 1] == '\n')
383 p[strlen(p) - 1] = 0;
384
385 if (strcasecmp(p, "BYE") == 0)
386 goto done;
387
388 error = pwmd_command(pwm, &result, command);
389 memset(command, 0, sizeof(command));
390
391 if (error) {
392 show_error(error);
393 ret = EXIT_FAILURE;
394 goto fail;
395 }
396
397 if (result) {
398 if (isatty(outfd) && result[strlen(result) - 1] == '\n')
399 result[strlen(result) - 1] = 0;
400
401 fwrite(result, 1, strlen(result), outfp);
402 pwmd_free_result(result);
403
404 if (isatty(outfd))
405 fputc('\n', outfp);
406 }
407
408 done:
409 memset(command, 0, sizeof(command));
410
411 if (!error && save) {
412 save_again:
413 error = pwmd_save(pwm);
414
415 if (error) {
416 if (use_pinentry && (error == EPWMD_BADKEY || error == EPWMD_KEY))
417 goto save_again;
418
419 show_error(error);
420 ret = EXIT_FAILURE;
421 goto fail;
422 }
423 }
424
425 fail:
426 pwmd_close(pwm);
427
428 if (socketpath)
429 xfree(socketpath);
430
431 exit(ret);
432 }
An API for pwmd.