Fixed a segfault when after a remote client terminates.
[libpwmd.git] / src / libpwmd.c
blobe9570094f5a5e29cd2a1d759de2d7f45a9dd5fa3
1 /* vim:tw=78:ts=8:sw=4:set ft=c: */
2 /*
3 Copyright (C) 2006-2009 Ben Kibbey <bjk@luxsci.net>
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.
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.
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 02110-1301 USA
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <unistd.h>
22 #include <err.h>
23 #include <errno.h>
24 #include <ctype.h>
25 #include <string.h>
26 #include <sys/socket.h>
27 #include <sys/un.h>
28 #include <signal.h>
29 #include <stdarg.h>
30 #include <string.h>
31 #include <sys/wait.h>
32 #include <fcntl.h>
33 #include <pwd.h>
34 #include <time.h>
35 #include <sys/types.h>
36 #include <limits.h>
37 #include <sys/select.h>
38 #include <netdb.h>
39 #include <netinet/in.h>
40 #include <sys/socket.h>
41 #include <libpwmd.h>
43 #ifdef HAVE_CONFIG_H
44 #include <config.h>
45 #endif
47 #ifdef WITH_LIBPTH
48 #include <pth.h>
49 #endif
51 #ifdef WITH_TCP
52 #define DNS_USE_GETTIMEOFDAY_FOR_ID 1
53 #include <ares.h>
54 #include <arpa/nameser.h>
55 #ifdef WITH_LIBPTH
56 #include <gcrypt.h>
57 GCRY_THREAD_OPTION_PTH_IMPL;
58 #endif
59 #endif
61 #ifdef HAVE_ASSUAN_H
62 #include <assuan.h>
63 #endif
65 #ifdef HAVE_SETLOCALE
66 #include <locale.h>
67 #endif
69 #include "gettext.h"
70 #define N_(msgid) dgettext("libpwmd", msgid)
72 #include "mem.h"
73 #include "types.h"
75 #ifdef WITH_PINENTRY
76 static pwm_t *gpwm;
77 static int gelapsed, gtimeout;
78 static gpg_error_t pinentry_command(pwm_t *pwm, char **result, const char *cmd);
79 static gpg_error_t global_error;
80 #endif
82 const char *pwmd_strerror(gpg_error_t e)
84 gpg_err_code_t code = gpg_err_code(e);
86 if (code >= GPG_ERR_USER_1 && code < gpg_err_code(EPWMD_MAX)) {
87 switch (code) {
88 case GPG_ERR_USER_1:
89 default:
90 return N_("Unknown error");
91 case GPG_ERR_USER_2:
92 return N_("No cache slots available");
93 case GPG_ERR_USER_3:
94 return N_("Recursion loop");
95 case GPG_ERR_USER_4:
96 return N_("No file is open");
97 case GPG_ERR_USER_5:
98 return N_("General LibXML error");
99 case GPG_ERR_USER_6:
100 return N_("File modified");
101 case GPG_ERR_USER_7:
102 return N_("Access denied");
106 return gpg_strerror(e);
109 gpg_error_t pwmd_init()
111 static int initialized;
113 if (initialized)
114 return 0;
116 #ifdef WITH_LIBPTH
117 gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
118 #endif
119 #ifndef MEM_DEBUG
120 xmem_init();
121 #endif
122 #ifdef ENABLE_NLS
123 bindtextdomain("libpwmd", LOCALEDIR);
124 #endif
125 gpg_err_init();
126 assuan_set_malloc_hooks(xmalloc, xrealloc, xfree);
127 assuan_set_assuan_err_source(GPG_ERR_SOURCE_DEFAULT);
128 initialized = 1;
129 return 0;
132 static pwm_t *_socket_connect_finalize(pwm_t *pwm, assuan_context_t ctx)
134 int active[2];
135 int n = assuan_get_active_fds(ctx, 0, active, sizeof(active));
137 pwm->fd = n <= 0 ? -1 : dup(active[0]);
138 pwm->ctx = ctx;
139 #ifdef WITH_PINENTRY
140 pwm->pid = -1;
141 pwm->pinentry_tries = 3;
142 #endif
143 assuan_set_pointer(ctx, pwm);
144 return pwm;
147 #ifdef WITH_TCP
148 static int read_hook(assuan_context_t ctx, assuan_fd_t fd, void *data,
149 size_t len, ssize_t *ret)
151 pwm_t *pwm = assuan_get_pointer(ctx);
153 if (!pwm || !pwm->tcp_conn)
154 *ret = read((int)fd, data, len);
155 else {
156 do {
157 *ret = libssh2_channel_read(pwm->tcp_conn->channel, data, len);
158 } while (*ret == LIBSSH2_ERROR_EAGAIN);
161 return *ret <= 0 ? 0 : 1;
164 static int write_hook(assuan_context_t ctx, assuan_fd_t fd, const void *data,
165 size_t len, ssize_t *ret)
167 pwm_t *pwm = assuan_get_pointer(ctx);
169 if (!pwm || !pwm->tcp_conn)
170 *ret = write((int)fd, data, len);
171 else {
172 do {
173 *ret = libssh2_channel_write(pwm->tcp_conn->channel, data, len);
174 } while (*ret == LIBSSH2_ERROR_EAGAIN);
177 return *ret <= 0 ? 0 : 1;
180 static void _ssh_deinit(pwmd_tcp_conn_t *conn);
181 static void free_tcp_conn(pwmd_tcp_conn_t *conn)
183 if (!conn)
184 return;
186 if (conn->username) {
187 xfree(conn->username);
188 conn->username = NULL;
191 if (conn->known_hosts) {
192 xfree(conn->known_hosts);
193 conn->known_hosts = NULL;
196 if (conn->identity) {
197 xfree(conn->identity);
198 conn->identity = NULL;
201 if (conn->identity_pub) {
202 xfree(conn->identity_pub);
203 conn->identity_pub = NULL;
206 if (conn->host) {
207 xfree(conn->host);
208 conn->host = NULL;
211 if (conn->hostkey) {
212 xfree(conn->hostkey);
213 conn->hostkey = NULL;
216 if (conn->chan) {
217 ares_destroy(conn->chan);
218 conn->chan = NULL;
221 if (conn->he) {
222 ares_free_hostent(conn->he);
223 conn->he = NULL;
226 if (conn->fd >= 0) {
227 close(conn->fd);
228 conn->fd = -1;
231 if (conn->session)
232 _ssh_deinit(conn);
233 else
234 xfree(conn);
237 static void _ssh_deinit(pwmd_tcp_conn_t *conn)
239 if (!conn)
240 return;
242 if (conn->channel)
243 libssh2_channel_free(conn->channel);
245 if (conn->session) {
246 libssh2_session_disconnect(conn->session, "Bye!");
247 libssh2_session_free(conn->session);
250 conn->session = NULL;
251 conn->channel = NULL;
252 free_tcp_conn(conn);
255 static void _ssh_assuan_deinit(assuan_context_t ctx)
257 pwm_t *pwm = assuan_get_pointer(ctx);
259 _ssh_deinit(pwm->tcp_conn);
260 pwm->tcp_conn = NULL;
264 * Sets common options from both pwmd_tcp_connect() and
265 * pwmd_tcp_connect_async().
267 static gpg_error_t init_tcp_conn(pwmd_tcp_conn_t **dst, const char *host,
268 int port, const char *identity, const char *user, const char *hosts,
269 int get)
271 pwmd_tcp_conn_t *conn;
272 gpg_error_t rc = 0;
274 if (get) {
275 if (!host)
276 return GPG_ERR_INV_ARG;
278 else {
279 if (!host || !identity || !user || !hosts)
280 return GPG_ERR_INV_ARG;
283 conn = xcalloc(1, sizeof(pwmd_tcp_conn_t));
285 if (!conn)
286 return gpg_error_from_errno(ENOMEM);
288 conn->port = port == -1 ? 22 : port;
289 conn->host = xstrdup(host);
291 if (!conn->host) {
292 rc = gpg_error_from_errno(ENOMEM);
293 goto fail;
296 if (!get) {
297 conn->identity = xstrdup(identity);
299 if (!conn->identity) {
300 rc = gpg_error_from_errno(ENOMEM);
301 goto fail;
304 conn->identity_pub = xmalloc(strlen(conn->identity)+5);
306 if (!conn->identity_pub) {
307 rc = gpg_error_from_errno(ENOMEM);
308 goto fail;
311 sprintf(conn->identity_pub, "%s.pub", conn->identity);
312 conn->username = xstrdup(user);
314 if (!conn->username) {
315 rc = gpg_error_from_errno(ENOMEM);
316 goto fail;
319 conn->known_hosts = xstrdup(hosts);
321 if (!conn->known_hosts) {
322 rc = gpg_error_from_errno(ENOMEM);
323 goto fail;
327 *dst = conn;
328 return 0;
330 fail:
331 free_tcp_conn(conn);
332 return rc;
335 static gpg_error_t do_connect(pwm_t *pwm, int prot, void *addr)
337 struct sockaddr_in their_addr;
339 pwm->tcp_conn->fd = socket(prot, SOCK_STREAM, 0);
341 if (pwm->tcp_conn->fd == -1)
342 return gpg_error_from_syserror();
344 if (pwm->tcp_conn->async)
345 fcntl(pwm->tcp_conn->fd, F_SETFL, O_NONBLOCK);
347 pwm->cmd = ASYNC_CMD_CONNECT;
348 their_addr.sin_family = prot;
349 their_addr.sin_port = htons(pwm->tcp_conn->port);
350 their_addr.sin_addr = *((struct in_addr *)addr);
351 memset(their_addr.sin_zero, '\0', sizeof their_addr.sin_zero);
353 #ifdef WITH_LIBPTH
354 if (pth_connect(pwm->tcp_conn->fd, (struct sockaddr *)&their_addr,
355 sizeof(their_addr)) == -1)
356 #else
357 if (connect(pwm->tcp_conn->fd, (struct sockaddr *)&their_addr,
358 sizeof(their_addr)) == -1)
359 #endif
360 return gpg_error_from_syserror();
362 return 0;
365 static gpg_error_t ares_error_to_pwmd(int status)
367 if (status != ARES_SUCCESS)
368 warnx("%s", ares_strerror(status));
370 switch (status) {
371 case ARES_ENODATA:
372 case ARES_EFORMERR:
373 case ARES_ENOTFOUND:
374 return GPG_ERR_UNKNOWN_HOST;
375 case ARES_ESERVFAIL:
376 return GPG_ERR_EHOSTDOWN;
377 case ARES_ETIMEOUT:
378 return GPG_ERR_TIMEOUT;
379 case ARES_ENOMEM:
380 return gpg_error_from_errno(ENOMEM);
381 case ARES_ECONNREFUSED:
382 return GPG_ERR_ECONNREFUSED;
383 default:
384 /* FIXME ??? */
385 return GPG_ERR_EHOSTUNREACH;
388 return ARES_SUCCESS;
391 static void dns_resolve_cb(void *arg, int status, int timeouts,
392 unsigned char *abuf, int alen)
394 pwm_t *pwm = arg;
395 int rc;
396 struct hostent *he;
398 if (status == ARES_EDESTRUCTION)
399 return;
401 if (status != ARES_SUCCESS) {
402 pwm->tcp_conn->rc = ares_error_to_pwmd(status);
403 return;
406 //FIXME localhost. works with ipv4. maybe local system config error
407 /* Check for an IPv6 address first. */
408 rc = ares_parse_a_reply(abuf, alen, &he, NULL, NULL);
410 if (rc != ARES_SUCCESS) {
411 if (rc != ARES_ENODATA) {
412 pwm->tcp_conn->rc = ares_error_to_pwmd(status);
413 return;
416 rc = ares_parse_aaaa_reply(abuf, alen, &he, NULL, NULL);
418 if (rc != ARES_SUCCESS) {
419 pwm->tcp_conn->rc = ares_error_to_pwmd(status);
420 return;
424 pwm->tcp_conn->he = he;
425 pwm->tcp_conn->rc = do_connect(pwm, he->h_addrtype, he->h_addr);
428 pwm_t *_do_pwmd_tcp_connect_async(const char *host, int port,
429 const char *identity, const char *user, const char *known_hosts,
430 gpg_error_t *rc, pwmd_async_cmd_t which)
432 pwmd_tcp_conn_t *conn;
433 pwm_t *pwm;
435 *rc = init_tcp_conn(&conn, host, port, identity, user, known_hosts,
436 which == ASYNC_CMD_HOSTKEY ? 1 : 0);
438 if (*rc)
439 return NULL;
441 if ((pwm = (pwm_t *)xcalloc(1, sizeof(pwm_t))) == NULL) {
442 *rc = gpg_error_from_syserror();
443 free_tcp_conn(conn);
444 return NULL;
447 conn->async = 1;
448 pwm->tcp_conn = conn;
449 pwm->tcp_conn->cmd = which;
451 if (pwm->tcp_conn->cmd == ASYNC_CMD_HOSTKEY)
452 pwm->tcp_conn->get_only = 1;
454 pwm->cmd = ASYNC_CMD_DNS;
455 pwm->state = ASYNC_PROCESS;
456 ares_init(&pwm->tcp_conn->chan);
457 ares_query(pwm->tcp_conn->chan, pwm->tcp_conn->host, ns_c_any, ns_t_any,
458 dns_resolve_cb, pwm);
459 return pwm;
462 pwm_t *pwmd_tcp_connect_async(const char *host, int port, const char *identity,
463 const char *user, const char *known_hosts, gpg_error_t *rc)
465 return _do_pwmd_tcp_connect_async(host, port, identity, user, known_hosts,
466 rc, ASYNC_CMD_CONNECT);
469 void *_ssh_malloc(size_t size, void **data)
471 return xmalloc(size);
474 void _ssh_free(void *ptr, void **data)
476 xfree(ptr);
479 void *_ssh_realloc(void *ptr, size_t size, void **data)
481 return xrealloc(ptr, size);
484 static char *to_hex(const char *str, size_t slen)
486 int i;
487 char *buf = xmalloc(slen*2+1);
489 if (!buf)
490 return NULL;
492 for (i = 0, buf[0] = 0; i < slen; i++) {
493 char tmp[3];
495 sprintf(tmp, "%02x", (unsigned char)str[i]);
496 strcat(buf, tmp);
499 return buf;
502 static int verify_host_key(pwm_t *pwm)
504 FILE *fp = fopen(pwm->tcp_conn->known_hosts, "r");
505 char *buf, *p;
507 if (!fp)
508 return 1;
510 buf = xmalloc(LINE_MAX);
512 if (!buf)
513 goto fail;
515 while ((p = fgets(buf, LINE_MAX, fp))) {
516 if (*p == '#' || isspace(*p))
517 continue;
519 if (p[strlen(p)-1] == '\n')
520 p[strlen(p)-1] = 0;
522 if (!strcmp(buf, pwm->tcp_conn->hostkey))
523 goto done;
526 fail:
527 if (buf)
528 xfree(buf);
530 fclose(fp);
531 return 1;
533 done:
534 xfree(buf);
535 fclose(fp);
536 return 0;
539 static gpg_error_t authenticate_ssh(pwm_t *pwm)
541 const char *fp = libssh2_hostkey_hash(pwm->tcp_conn->session,
542 LIBSSH2_HOSTKEY_HASH_SHA1);
543 char *userauth;
545 pwm->tcp_conn->hostkey = to_hex(fp, 20);
547 if (!pwm->tcp_conn->hostkey)
548 return gpg_error_from_errno(ENOMEM);
550 if (pwm->tcp_conn->get_only)
551 return 0;
553 if (!fp || verify_host_key(pwm))
554 return GPG_ERR_CHECKSUM;
556 userauth = libssh2_userauth_list(pwm->tcp_conn->session,
557 pwm->tcp_conn->username, strlen(pwm->tcp_conn->username));
559 if (!userauth || !strstr(userauth, "publickey"))
560 return GPG_ERR_BAD_PIN_METHOD;
562 if (libssh2_userauth_publickey_fromfile(pwm->tcp_conn->session,
563 pwm->tcp_conn->username, pwm->tcp_conn->identity_pub,
564 pwm->tcp_conn->identity, NULL))
565 return GPG_ERR_BAD_SECKEY;
567 return 0;
570 static pwm_t *setup_context(pwm_t *pwm, gpg_error_t *rc)
572 assuan_context_t ctx;
573 struct assuan_io_hooks io_hooks = {read_hook, write_hook};
575 pwm->tcp_conn->session = libssh2_session_init_ex(_ssh_malloc, _ssh_free,
576 _ssh_realloc, NULL);
578 if (!pwm->tcp_conn->session) {
579 *rc = gpg_error_from_errno(ENOMEM);
580 goto fail;
583 if (libssh2_session_startup(pwm->tcp_conn->session, pwm->tcp_conn->fd)) {
584 *rc = GPG_ERR_ASSUAN_SERVER_FAULT;
585 goto fail;
588 *rc = authenticate_ssh(pwm);
590 if (*rc)
591 goto fail;
593 /* pwmd_get_hostkey(). */
594 if (pwm->tcp_conn->get_only) {
595 pwm->result = xstrdup(pwm->tcp_conn->hostkey);
597 if (!pwm->result) {
598 *rc = gpg_error_from_errno(ENOMEM);
599 goto fail;
602 return pwm;
605 pwm->tcp_conn->channel = libssh2_channel_open_session(pwm->tcp_conn->session);
607 if (!pwm->tcp_conn->channel) {
608 *rc = GPG_ERR_ASSUAN_SERVER_FAULT;
609 goto fail;
612 if (libssh2_channel_shell(pwm->tcp_conn->channel)) {
613 *rc = GPG_ERR_ASSUAN_SERVER_FAULT;
614 goto fail;
617 assuan_set_io_hooks(&io_hooks);
618 *rc = assuan_socket_connect_fd(&ctx, pwm->tcp_conn->fd, 0, pwm);
620 if (*rc)
621 goto fail;
623 assuan_set_finish_handler(ctx, _ssh_assuan_deinit);
624 return _socket_connect_finalize(pwm, ctx);
626 fail:
627 if (!pwm->tcp_conn->async)
628 pwmd_close(pwm);
630 return NULL;
633 static pwm_t *_do_pwmd_tcp_connect(const char *host, int port,
634 const char *identity, const char *user, const char *known_hosts,
635 gpg_error_t *rc, int get)
637 pwm_t *pwm = NULL;
638 pwmd_tcp_conn_t *conn;
640 *rc = init_tcp_conn(&conn, host, port, identity, user, known_hosts, get);
642 if (*rc)
643 return NULL;
645 if ((pwm = (pwm_t *)xcalloc(1, sizeof(pwm_t))) == NULL) {
646 *rc = gpg_error_from_errno(ENOMEM);
647 goto fail;
650 pwm->tcp_conn = conn;
651 pwm->tcp_conn->get_only = get;
652 pwm->cmd = ASYNC_CMD_DNS;
653 ares_init(&pwm->tcp_conn->chan);
654 ares_query(pwm->tcp_conn->chan, pwm->tcp_conn->host, ns_c_any, ns_t_any,
655 dns_resolve_cb, pwm);
657 /* dns_resolve_cb() may have already been called. */
658 if (pwm->tcp_conn->rc) {
659 *rc = pwm->tcp_conn->rc;
660 goto fail;
664 * Fake a blocking DNS lookup. libcares does a better job than
665 * getaddrinfo().
667 do {
668 fd_set rfds, wfds;
669 int n;
670 struct timeval tv;
672 FD_ZERO(&rfds);
673 FD_ZERO(&wfds);
674 n = ares_fds(pwm->tcp_conn->chan, &rfds, &wfds);
675 ares_timeout(pwm->tcp_conn->chan, NULL, &tv);
676 #ifdef WITH_LIBPTH
677 n = pth_select(n, &rfds, &wfds, NULL, &tv);
678 #else
679 n = select(n, &rfds, &wfds, NULL, &tv);
680 #endif
682 if (n == -1) {
683 *rc = gpg_error_from_syserror();
684 goto fail;
686 else if (n == 0) {
687 *rc = GPG_ERR_TIMEOUT;
688 goto fail;
691 ares_process(pwm->tcp_conn->chan, &rfds, &wfds);
693 if (pwm->tcp_conn->rc)
694 break;
695 } while (pwm->cmd == ASYNC_CMD_DNS);
697 if (pwm->tcp_conn->rc) {
698 *rc = pwm->tcp_conn->rc;
699 goto fail;
702 return setup_context(pwm, rc);
704 fail:
705 pwmd_close(pwm);
706 return NULL;
709 pwm_t *pwmd_tcp_connect(const char *host, int port, const char *identity,
710 const char *user, const char *known_hosts, gpg_error_t *rc)
712 return _do_pwmd_tcp_connect(host, port, identity, user, known_hosts, rc, 0);
715 /* Must free the result with pwmd_free_result(). */
716 char *pwmd_get_hostkey(const char *host, int port, gpg_error_t *rc)
718 char *hostkey;
719 pwm_t *pwm;
721 pwm = _do_pwmd_tcp_connect(host, port, NULL, NULL, NULL, rc, 1);
723 if (!pwm)
724 return NULL;
726 hostkey = xstrdup(pwm->tcp_conn->hostkey);
728 if (!hostkey)
729 *rc = gpg_error_from_errno(ENOMEM);
731 pwmd_close(pwm);
732 return hostkey;
735 pwm_t *pwmd_get_hostkey_async(const char *host, int port, gpg_error_t *rc)
737 return _do_pwmd_tcp_connect_async(host, port, NULL, NULL, NULL, rc,
738 ASYNC_CMD_HOSTKEY);
740 #endif
742 pwm_t *pwmd_connect(const char *path, gpg_error_t *rc)
744 pwm_t *pwm = NULL;
745 char *socketpath = NULL;
746 struct passwd *pw;
747 assuan_context_t ctx;
749 if (!path) {
750 pw = getpwuid(getuid());
751 socketpath = (char *)xmalloc(strlen(pw->pw_dir) + strlen("/.pwmd/socket") + 1);
752 sprintf(socketpath, "%s/.pwmd/socket", pw->pw_dir);
754 else
755 socketpath = xstrdup(path);
757 *rc = assuan_socket_connect_ext(&ctx, socketpath, -1, 0);
758 xfree(socketpath);
760 if (*rc)
761 return NULL;
763 if ((pwm = (pwm_t *)xcalloc(1, sizeof(pwm_t))) == NULL) {
764 *rc = gpg_error_from_syserror();
765 return NULL;
768 return _socket_connect_finalize(pwm, ctx);
771 gpg_error_t pwmd_pending_line(pwm_t *pwm, char **line, size_t *len)
773 if (!pwm)
774 return GPG_ERR_INV_ARG;
776 if (assuan_pending_line(pwm->ctx))
777 return assuan_read_line(pwm->ctx, line, len);
779 return GPG_ERR_NO_DATA;
782 void pwmd_close(pwm_t *pwm)
784 if (!pwm)
785 return;
787 if (pwm->ctx)
788 assuan_disconnect(pwm->ctx);
790 if (pwm->password)
791 xfree(pwm->password);
793 if (pwm->title)
794 xfree(pwm->title);
796 if (pwm->desc)
797 xfree(pwm->desc);
799 if (pwm->prompt)
800 xfree(pwm->prompt);
802 if (pwm->pinentry_tty)
803 xfree(pwm->pinentry_tty);
805 if (pwm->pinentry_display)
806 xfree(pwm->pinentry_display);
808 if (pwm->pinentry_term)
809 xfree(pwm->pinentry_term);
811 if (pwm->lcctype)
812 xfree(pwm->lcctype);
814 if (pwm->lcmessages)
815 xfree(pwm->lcmessages);
817 if (pwm->filename)
818 xfree(pwm->filename);
820 #ifdef WITH_TCP
821 if (pwm->result)
822 xfree(pwm->result);
824 if (pwm->tcp_conn)
825 free_tcp_conn(pwm->tcp_conn);
827 #endif
828 xfree(pwm);
831 static int mem_realloc_cb(void *data, const void *buffer, size_t len)
833 membuf_t *mem = (membuf_t *)data;
834 void *p;
836 if (!buffer)
837 return 0;
839 if ((p = xrealloc(mem->buf, mem->len + len)) == NULL)
840 return 1;
842 mem->buf = p;
843 memcpy((char *)mem->buf + mem->len, buffer, len);
844 mem->len += len;
845 return 0;
848 void pwmd_free_result(void *data)
850 xfree(data);
853 static int _inquire_cb(void *data, const char *keyword)
855 pwm_t *pwm = (pwm_t *)data;
856 gpg_error_t rc = 0;
857 int flags = fcntl(pwm->fd, F_GETFL);
859 /* Shouldn't get this far without a callback. */
860 if (!pwm->inquire_func)
861 return GPG_ERR_INV_ARG;
864 * Since the socket file descriptor is probably set to non-blocking, set to
865 * blocking to prevent GPG_ERR_EAGAIN errors. This should be fixes when
866 * asynchronous INQUIRE is supported by either libassuan or a later
867 * libpwmd.
869 fcntl(pwm->fd, F_SETFL, 0);
871 for (;;) {
872 char *result = NULL;
873 size_t len;
874 gpg_error_t arc;
876 rc = pwm->inquire_func(pwm->inquire_data, keyword, rc, &result, &len);
877 rc = gpg_err_code(rc);
879 if (rc == GPG_ERR_EOF || !rc) {
880 if (len <= 0 || !result || !*result) {
881 rc = 0;
882 break;
885 arc = assuan_send_data(pwm->ctx, result, len);
887 if (rc == GPG_ERR_EOF) {
888 rc = arc;
889 break;
892 rc = arc;
894 else if (rc)
895 break;
898 fcntl(pwm->fd, F_SETFL, flags);
899 return rc;
902 gpg_error_t pwmd_finalize(pwm_t *pwm)
904 if (!pwm || pwm->cmd == ASYNC_CMD_NONE || pwm->state != ASYNC_DONE)
905 return GPG_ERR_INV_ARG;
907 pwm->state = ASYNC_INIT;
908 pwm->cmd = ASYNC_CMD_NONE;
910 #ifdef WITH_TCP
911 if (pwm->cmd == ASYNC_CMD_CONNECT || pwm->cmd == ASYNC_CMD_DNS) {
912 gpg_error_t rc = pwm->tcp_conn->rc;
914 if (pwm->result)
915 xfree(pwm->result);
917 pwm->result = NULL;
919 /* pwm is no longer a valid handle. */
920 if (rc)
921 pwmd_close(pwm);
923 return 0;
925 #endif
927 if (pwm->fd < 0)
928 return GPG_ERR_INV_ARG;
930 pwm->ntries = 0;
931 #ifdef WITH_PINENTRY
932 pwm->is_open_cmd = 0;
933 #endif
934 return 0;
937 static gpg_error_t do_nb_command(pwm_t *pwm, const char *cmd, const char *arg)
939 char *buf;
940 gpg_error_t rc;
941 size_t len = strlen(cmd) + 2;
943 len += arg ? strlen(arg) : 0;
945 if (pwm->state != ASYNC_INIT)
946 return GPG_ERR_INV_STATE;
948 buf = (char *)xmalloc(len);
950 if (!buf) {
951 rc = gpg_error_from_errno(ENOMEM);
952 goto fail;
955 snprintf(buf, len, "%s %s", cmd, arg ? arg : "");
956 rc = assuan_write_line(pwm->ctx, buf);
957 xfree(buf);
959 if (!rc)
960 pwm->state = ASYNC_PROCESS;
962 fail:
963 return rc;
966 gpg_error_t pwmd_open_async(pwm_t *pwm, const char *filename)
968 if (!pwm || !filename)
969 return GPG_ERR_INV_ARG;
971 /* For pinentry retries. */
972 if (!pwm->is_open_cmd) {
973 if (pwm->filename)
974 xfree(pwm->filename);
976 pwm->filename = xstrdup(filename);
979 pwm->is_open_cmd = 1;
980 return do_nb_command(pwm, "OPEN", filename);
983 gpg_error_t pwmd_save_async(pwm_t *pwm)
985 if (!pwm)
986 return GPG_ERR_INV_ARG;
988 return do_nb_command(pwm, "SAVE", NULL);
991 gpg_error_t pwmd_get_result(pwm_t *pwm, const char **result)
993 if (!pwm || !result)
994 return GPG_ERR_INV_ARG;
996 if (pwm->state != ASYNC_DONE)
997 return GPG_ERR_INV_STATE;
999 if (!pwm->result)
1000 return GPG_ERR_NO_DATA;
1002 *result = pwm->result;
1003 return 0;
1006 static gpg_error_t assuan_command(pwm_t *pwm, assuan_context_t ctx,
1007 char **result, const char *cmd);
1008 pwmd_async_t pwmd_process(pwm_t *pwm, gpg_error_t *rc)
1010 fd_set fds;
1011 int n;
1012 struct timeval tv = {0, 0};
1014 *rc = 0;
1016 if (!pwm) {
1017 *rc = GPG_ERR_INV_ARG;
1018 return ASYNC_DONE;
1021 #ifdef WITH_TCP
1022 if (pwm->cmd == ASYNC_CMD_DNS) {
1023 fd_set rfds, wfds;
1025 if (pwm->tcp_conn->rc) {
1026 *rc = pwm->tcp_conn->rc;
1027 close(pwm->tcp_conn->fd);
1028 pwm->state = ASYNC_DONE;
1029 return pwm->state;
1032 FD_ZERO(&rfds);
1033 FD_ZERO(&wfds);
1034 n = ares_fds(pwm->tcp_conn->chan, &rfds, &wfds);
1036 /* Shouldn't happen. */
1037 if (!n)
1038 return pwm->state;
1040 n = select(n, &rfds, &wfds, NULL, &tv);
1042 if (n > 0)
1043 ares_process(pwm->tcp_conn->chan, &rfds, &wfds);
1045 return pwm->state;
1047 else if (pwm->cmd == ASYNC_CMD_CONNECT) {
1048 if (pwm->tcp_conn->rc == GPG_ERR_EINPROGRESS) {
1049 int ret;
1050 socklen_t len = sizeof(int);
1052 FD_ZERO(&fds);
1053 FD_SET(pwm->tcp_conn->fd, &fds);
1054 n = select(pwm->tcp_conn->fd+1, NULL, &fds, NULL, &tv);
1056 if (!n || !FD_ISSET(pwm->tcp_conn->fd, &fds))
1057 return pwm->state;
1058 else if (n == -1) {
1059 *rc = gpg_error_from_syserror();
1060 close(pwm->tcp_conn->fd);
1061 pwm->state = ASYNC_DONE;
1062 return pwm->state;
1065 ret = getsockopt(pwm->tcp_conn->fd, SOL_SOCKET, SO_ERROR, &n, &len);
1066 if (ret || n) {
1067 *rc = ret ? gpg_error_from_syserror() : gpg_error_from_errno(n);
1068 close(pwm->tcp_conn->fd);
1069 pwm->state = ASYNC_DONE;
1070 return pwm->state;
1073 else if (pwm->tcp_conn->rc) {
1074 *rc = pwm->tcp_conn->rc;
1075 close(pwm->tcp_conn->fd);
1076 pwm->state = ASYNC_DONE;
1077 return pwm->state;
1080 fcntl(pwm->tcp_conn->fd, F_SETFL, 0);
1081 setup_context(pwm, rc);
1082 pwm->state = ASYNC_DONE;
1083 return pwm->state;
1085 #endif
1087 if (pwm->fd < 0) {
1088 *rc = GPG_ERR_INV_ARG;
1089 return ASYNC_DONE;
1091 else if (pwm->state == ASYNC_DONE)
1092 return pwm->state;
1093 else if (pwm->state == ASYNC_INIT) {
1094 /* This will allow pending status messages to be parsed. */
1095 *rc = assuan_command(pwm, pwm->ctx, NULL, "NOP");
1096 return pwm->state;
1099 /* For pinentry retries. */
1100 if (pwm->is_open_cmd && gpg_err_code(*rc) == EPWMD_BADKEY &&
1101 ++pwm->ntries < pwm->pinentry_tries) {
1102 pwm->state = ASYNC_INIT;
1103 *rc = pwmd_open_async(pwm, pwm->filename);
1106 return pwm->state;
1109 static gpg_error_t assuan_command(pwm_t *pwm, assuan_context_t ctx,
1110 char **result, const char *cmd)
1112 membuf_t data;
1113 gpg_error_t rc;
1115 data.len = 0;
1116 data.buf = NULL;
1118 rc = assuan_transact(ctx, cmd, mem_realloc_cb, &data, _inquire_cb, pwm,
1119 pwm->status_func, pwm->status_data);
1121 if (rc) {
1122 if (data.buf) {
1123 xfree(data.buf);
1124 data.buf = NULL;
1127 else {
1128 if (data.buf) {
1129 mem_realloc_cb(&data, "", 1);
1130 *result = (char *)data.buf;
1134 return gpg_err_code(rc);
1137 gpg_error_t pwmd_inquire(pwm_t *pwm, const char *cmd, pwmd_inquire_fn fn,
1138 void *data)
1140 if (!pwm || !cmd || !fn)
1141 return GPG_ERR_INV_ARG;
1143 pwm->inquire_func = fn;
1144 pwm->inquire_data = data;
1145 return assuan_command(pwm, pwm->ctx, NULL, cmd);
1148 gpg_error_t pwmd_terminate_pinentry(pwm_t *pwm)
1150 #ifndef WITH_PINENTRY
1151 return GPG_ERR_NOT_IMPLEMENTED;
1152 #else
1153 pid_t pid = pwm->pid;
1155 pwm->pid = -1;
1157 if (!pwm || pid == -1)
1158 return GPG_ERR_INV_ARG;
1160 if (kill(pid, 0) == 0) {
1161 if (kill(pid, SIGTERM) == -1) {
1162 if (kill(pid, SIGKILL) == -1)
1163 return gpg_error_from_errno(errno);
1166 pwm->pin_error = GPG_ERR_TIMEOUT;
1168 else
1169 return gpg_error_from_errno(errno);
1171 return 0;
1172 #endif
1175 #ifdef WITH_PINENTRY
1176 static gpg_error_t set_pinentry_strings(pwm_t *pwm, int which)
1178 char *buf;
1179 char tmp[ASSUAN_LINELENGTH];
1180 gpg_error_t error;
1182 if (!pwm->title)
1183 pwm->title = xstrdup(N_("LibPWMD"));
1185 if (!pwm->prompt)
1186 pwm->prompt = xstrdup(N_("Passphrase:"));
1188 if (!pwm->desc && !which)
1189 pwm->desc = xstrdup(N_("Enter a passphrase."));
1191 if (which == 1) {
1192 snprintf(tmp, sizeof(tmp), "SETERROR %s", N_("Invalid passphrase, please try again."));
1193 buf = xstrdup(tmp);
1195 else if (which == 2) {
1196 snprintf(tmp, sizeof(tmp), "SETERROR %s", N_("Please type the passphrase again for confirmation."));
1197 buf = xstrdup(tmp);
1199 else {
1200 buf = (char *)xmalloc(strlen("SETERROR ") + strlen(pwm->desc) + 1);
1201 sprintf(buf, "SETERROR %s", pwm->desc);
1204 error = pinentry_command(pwm, NULL, buf);
1205 xfree(buf);
1207 if (error)
1208 return error;
1210 buf = (char *)xmalloc(strlen("SETPROMPT ") + strlen(pwm->prompt) + 1);
1211 sprintf(buf, "SETPROMPT %s", pwm->prompt);
1212 error = pinentry_command(pwm, NULL, buf);
1213 xfree(buf);
1215 if (error)
1216 return error;
1218 buf = (char *)xmalloc(strlen("SETDESC ") + strlen(pwm->title) + 1);
1219 sprintf(buf, "SETDESC %s", pwm->title);
1220 error = pinentry_command(pwm, NULL, buf);
1221 xfree(buf);
1222 return error;
1225 static void update_pinentry_settings(pwm_t *pwm)
1227 FILE *fp;
1228 char buf[LINE_MAX];
1229 struct passwd *pw = getpwuid(getuid());
1230 char *p;
1232 snprintf(buf, sizeof(buf), "%s/.pwmd/pinentry.conf", pw->pw_dir);
1234 if ((fp = fopen(buf, "r")) == NULL)
1235 return;
1237 while ((p = fgets(buf, sizeof(buf), fp)) != NULL) {
1238 char name[32], val[256];
1240 if (sscanf(p, " %31[a-zA-Z] = %255s", name, val) != 2)
1241 continue;
1243 if (strcasecmp(name, "TTYNAME") == 0) {
1244 xfree(pwm->pinentry_tty);
1245 pwm->pinentry_tty = xstrdup(val);
1247 else if (strcasecmp(name, "TTYTYPE") == 0) {
1248 xfree(pwm->pinentry_term);
1249 pwm->pinentry_term = xstrdup(val);
1251 else if (strcasecmp(name, "DISPLAY") == 0) {
1252 xfree(pwm->pinentry_display);
1253 pwm->pinentry_display = xstrdup(val);
1255 else if (strcasecmp(name, "PATH") == 0) {
1256 xfree(pwm->pinentry_path);
1257 pwm->pinentry_path = xstrdup(val);
1261 fclose(fp);
1264 static gpg_error_t launch_pinentry(pwm_t *pwm)
1266 int rc;
1267 assuan_context_t ctx;
1268 int child_list[] = {-1};
1269 char *display = getenv("DISPLAY");
1270 const char *argv[10];
1271 const char **p = argv;
1272 int have_display = 0;
1273 char *tty = NULL;
1275 update_pinentry_settings(pwm);
1277 if (pwm->pinentry_display || display)
1278 have_display = 1;
1279 else {
1280 tty = pwm->pinentry_tty ? pwm->pinentry_tty : ttyname(STDOUT_FILENO);
1282 if (!tty)
1283 return gpg_error_from_errno(errno);
1286 if (!have_display && !tty)
1287 return GPG_ERR_ENOTTY;
1289 *p++ = "pinentry";
1290 *p++ = have_display ? "--display" : "--ttyname";
1291 *p++ = have_display ? pwm->pinentry_display ? pwm->pinentry_display : display : tty;
1293 if (pwm->lcctype) {
1294 *p++ = "--lc-ctype";
1295 *p++ = pwm->lcctype;
1298 if (pwm->lcmessages) {
1299 *p++ = "--lc-messages";
1300 *p++ = pwm->lcmessages;
1303 *p = NULL;
1305 if (!have_display) {
1306 *p++ = "--ttytype";
1307 *p++ = pwm->pinentry_term ? pwm->pinentry_term : getenv("TERM");
1308 *p = NULL;
1311 rc = assuan_pipe_connect(&ctx, pwm->pinentry_path ? pwm->pinentry_path : PINENTRY_PATH, argv, child_list);
1313 if (rc)
1314 return rc;
1316 pwm->pid = assuan_get_pid(ctx);
1317 pwm->pctx = ctx;
1318 return set_pinentry_strings(pwm, 0);
1321 static gpg_error_t pinentry_command(pwm_t *pwm, char **result, const char *cmd)
1323 gpg_error_t n;
1325 if (!pwm->pctx) {
1326 n = launch_pinentry(pwm);
1328 if (n)
1329 return n;
1332 return assuan_command(pwm, pwm->pctx, result, cmd);
1335 static void pinentry_disconnect(pwm_t *pwm)
1337 if (pwm->pctx)
1338 assuan_disconnect(pwm->pctx);
1340 pwm->pctx = NULL;
1341 pwm->pid = -1;
1345 * Only called from a child process.
1347 static void catchsig(int sig)
1349 switch (sig) {
1350 case SIGALRM:
1351 if (gelapsed++ >= gtimeout) {
1352 global_error = pwmd_terminate_pinentry(gpwm);
1354 if (!global_error)
1355 global_error = GPG_ERR_TIMEOUT;
1357 break;
1360 alarm(1);
1361 break;
1362 default:
1363 break;
1366 #endif
1369 * Borrowed from libassuan.
1371 static char *percent_escape(const char *atext)
1373 const unsigned char *s;
1374 int len = strlen(atext) * 3 + 1;
1375 char *buf = (char *)xmalloc(len), *p = buf;
1377 if (!buf)
1378 return NULL;
1380 for (s=(const unsigned char *)atext; *s; s++) {
1381 if (*s < ' ') {
1382 sprintf (p, "%%%02X", *s);
1383 p += 3;
1385 else
1386 *p++ = *s;
1389 *p = 0;
1390 return buf;
1393 static gpg_error_t send_command(pwm_t *pwm, char **result, const char *cmd)
1395 if (!cmd)
1396 return GPG_ERR_INV_ARG;
1398 return assuan_command(pwm, pwm->ctx, result, cmd);
1401 gpg_error_t pwmd_command_ap(pwm_t *pwm, char **result, const char *cmd,
1402 va_list ap)
1404 char *buf;
1405 size_t len;
1406 gpg_error_t error;
1408 if (!pwm || !cmd)
1409 return GPG_ERR_INV_ARG;
1412 * C99 allows the dst pointer to be null which will calculate the length
1413 * of the would-be result and return it.
1415 len = vsnprintf(NULL, 0, cmd, ap)+1;
1416 buf = (char *)xmalloc(len);
1417 len = vsnprintf(buf, len, cmd, ap);
1418 error = send_command(pwm, result, buf);
1419 xfree(buf);
1420 return error;
1424 * Avoid sending the BYE command here. libassuan will close the file
1425 * descriptor and release the assuan context. Use pwmd_close() instead.
1427 gpg_error_t pwmd_command(pwm_t *pwm, char **result, const char *cmd, ...)
1429 va_list ap;
1430 gpg_error_t error;
1432 if (!pwm || !cmd)
1433 return GPG_ERR_INV_ARG;
1435 *result = NULL;
1436 va_start(ap, cmd);
1437 error = pwmd_command_ap(pwm, result, cmd, ap);
1438 va_end(ap);
1439 return error;
1442 #ifdef WITH_PINENTRY
1443 static gpg_error_t do_getpin(pwm_t *pwm, char **result)
1445 if (gtimeout) {
1446 signal(SIGALRM, catchsig);
1447 alarm(1);
1450 *result = NULL;
1451 return pinentry_command(pwm, result, "GETPIN");
1454 static gpg_error_t getpin(pwm_t *pwm, char **result, int *try_n, int which)
1456 int pin_try = *try_n;
1457 gpg_error_t error;
1459 getpin_again:
1460 *try_n = pin_try;
1462 if (pin_try == -1) {
1463 error = set_pinentry_strings(pwm, which);
1465 if (error) {
1466 pinentry_disconnect(pwm);
1467 return error;
1470 else {
1471 if (pwm->pinentry_tries-1 != pin_try) {
1472 error = set_pinentry_strings(pwm, 1);
1474 if (error) {
1475 pinentry_disconnect(pwm);
1476 return error;
1481 error = do_getpin(pwm, result);
1484 * Since there was input cancel any timeout setting.
1486 alarm(0);
1488 if (error) {
1489 if (error == GPG_ERR_CANCELED)
1490 return GPG_ERR_CANCELED;
1492 if (pin_try != -1 && pin_try--)
1493 goto getpin_again;
1495 if (pwm->pctx)
1496 pinentry_disconnect(pwm);
1498 *try_n = pin_try;
1499 return error;
1502 return 0;
1504 #endif
1506 gpg_error_t pwmd_open_nb_finalize(pwm_t *pwm, pwmd_nb_status_t *pw)
1508 gpg_error_t error;
1510 #ifndef WITH_PINENTRY
1511 return GPG_ERR_NOT_IMPLEMENTED;
1512 #endif
1514 if (!pwm || !pw || !pw->filename[0])
1515 return GPG_ERR_INV_ARG;
1517 close(pw->fd);
1519 if (pw->error) {
1520 error = pw->error;
1521 goto fail;
1524 if (pwm->filename)
1525 xfree(pwm->filename);
1527 pwm->filename = xstrdup(pw->filename);
1528 memset(pw, 0, sizeof(pwmd_nb_status_t));
1529 return 0;
1531 fail:
1532 memset(pw, 0, sizeof(pwmd_nb_status_t));
1533 return error;
1536 static gpg_error_t do_open_command(pwm_t *pwm, const char *filename, char *password)
1538 char buf[ASSUAN_LINELENGTH];
1539 gpg_error_t error;
1540 char *result = NULL;
1542 snprintf(buf, sizeof(buf), "OPEN %s %s", filename, password ? password : "");
1543 error = send_command(pwm, &result, buf);
1544 memset(buf, 0, sizeof(buf));
1546 if (error && result)
1547 xfree(result);
1549 return error;
1552 static int do_pwmd_open(pwm_t *pwm, gpg_error_t *error, const char *filename,
1553 int nb, int timeout)
1555 char *result = NULL;
1556 char *password = NULL;
1557 char path[PATH_MAX];
1558 #ifdef WITH_PINENTRY
1559 int pin_try;
1560 #endif
1562 if (!pwm || !filename || !*filename) {
1563 *error = GPG_ERR_INV_ARG;
1564 return nb ? -1 : 1;
1567 #ifdef WITH_PINENTRY
1568 pin_try = pwm->pinentry_tries - 1;
1569 #endif
1572 * Avoid calling pinentry if the password is cached on the server or if
1573 * this is a new file.
1575 *error = pwmd_command(pwm, &result, "GETCONFIG data_directory");
1577 if (*error)
1578 return nb ? -1 : 1;
1580 snprintf(path, sizeof(path), "%s/%s", result, filename);
1581 pwmd_free_result(result);
1583 if (access(path, R_OK) == -1) {
1584 if (errno == ENOENT)
1585 goto gotpassword;
1588 *error = pwmd_command(pwm, &result, "ISCACHED %s", filename);
1590 if (*error == EPWMD_CACHE_NOT_FOUND) {
1591 if (pwm->passfunc) {
1592 password = pwm->passfunc(pwm, pwm->passdata);
1593 goto gotpassword;
1596 #ifdef WITH_PINENTRY
1598 * Get the password from pinentry.
1600 if (pwm->use_pinentry) {
1602 * Nonblocking is wanted. fork() then return a file descriptor
1603 * that the client can use to read() from.
1605 if (nb) {
1606 int p[2];
1607 pid_t pid;
1608 pwmd_nb_status_t pw;
1610 if (pipe(p) == -1) {
1611 *error = gpg_error_from_syserror();
1612 return -1;
1615 #ifdef WITH_LIBPTH
1616 pid = pth_fork();
1617 #else
1618 pid = fork();
1619 #endif
1621 switch (pid) {
1622 case 0:
1623 close(p[0]);
1624 strncpy(pw.filename, filename, sizeof(pw.filename));
1625 pw.filename[sizeof(pw.filename)-1] = 0;
1626 pw.fd = p[0];
1628 if (timeout > 0) {
1629 gpwm = pwm;
1630 gtimeout = timeout;
1631 gelapsed = 0;
1634 getpin_nb_again:
1635 *error = getpin(pwm, &password, &pin_try, 0);
1637 if (*error) {
1638 getpin_nb_fail:
1639 if (pwm->pctx)
1640 pinentry_disconnect(pwm);
1642 if (gtimeout && gelapsed >= gtimeout)
1643 *error = GPG_ERR_TIMEOUT;
1645 pw.error = *error;
1646 #ifdef WITH_LIBPTH
1647 pth_write(p[1], &pw, sizeof(pw));
1648 #else
1649 write(p[1], &pw, sizeof(pw));
1650 #endif
1651 close(p[1]);
1652 _exit(1);
1656 * Don't count the time it takes to open the file
1657 * which may have many iterations.
1659 signal(SIGALRM, SIG_DFL);
1660 *error = do_open_command(pwm, filename, password);
1662 if (timeout)
1663 signal(SIGALRM, catchsig);
1665 if (pwm->pctx && *error == EPWMD_BADKEY) {
1666 if (pin_try-- > 0)
1667 goto getpin_nb_again;
1669 goto getpin_nb_fail;
1672 pinentry_disconnect(pwm);
1673 pw.error = 0;
1674 #ifdef WITH_LIBPTH
1675 pth_write(p[1], &pw, sizeof(pw));
1676 #else
1677 write(p[1], &pw, sizeof(pw));
1678 #endif
1679 close(p[1]);
1680 _exit(0);
1681 break;
1682 case -1:
1683 *error = gpg_error_from_syserror();
1684 close(p[0]);
1685 close(p[1]);
1686 return -1;
1687 default:
1688 break;
1691 close(p[1]);
1692 *error = 0;
1693 return p[0];
1696 else {
1697 #endif
1699 * Not using pinentry and the file was not found
1700 * in the cache.
1702 password = pwm->password;
1703 #ifdef WITH_PINENTRY
1705 #endif
1707 else if (*error)
1708 return nb ? -1 : 1;
1710 gotpassword:
1711 *error = do_open_command(pwm, filename, password);
1714 * Keep the user defined password set with pwmd_setopt(). The password may
1715 * be needed later (pwmd_save()) depending on the pwmd file cache settings.
1717 if (!pwm->passfunc && password && password != pwm->password)
1718 xfree(password);
1720 #ifdef WITH_PINENTRY
1721 if (*error == EPWMD_BADKEY) {
1722 if (pin_try-- > 0 && !nb) {
1723 *error = pwmd_command(pwm, &result, "OPTION TITLE=%s",
1724 N_("Invalid passphrase, please try again."));
1726 if (*error)
1727 return 1;
1729 goto gotpassword;
1732 if (nb)
1733 pinentry_disconnect(pwm);
1735 return nb ? -1 : 1;
1737 #endif
1739 if (!*error) {
1740 if (pwm->filename)
1741 xfree(pwm->filename);
1743 pwm->filename = xstrdup(filename);
1747 * The file is cached or the file is a new file.
1749 if (nb)
1750 return *error ? -1 : -2;
1752 return *error ? 1 : 0;
1755 gpg_error_t pwmd_open(pwm_t *pwm, const char *filename)
1757 gpg_error_t error;
1759 do_pwmd_open(pwm, &error, filename, 0, 0);
1760 return error;
1763 int pwmd_open_nb(pwm_t *pwm, gpg_error_t *error, const char *filename,
1764 int timeout)
1766 #ifndef WITH_PINENTRY
1767 *error = GPG_ERR_NOT_IMPLEMENTED;
1768 return -1;
1769 #else
1770 return do_pwmd_open(pwm, error, filename, 1, timeout);
1771 #endif
1774 #ifdef WITH_PINENTRY
1775 static gpg_error_t do_save_getpin(pwm_t *pwm, char **password)
1777 int confirm = 0;
1778 gpg_error_t error;
1779 char *result = NULL;
1780 int pin_try = -1;
1782 again:
1783 error = getpin(pwm, &result, &pin_try, confirm ? 2 : 0);
1785 if (error) {
1786 if (pwm->pctx)
1787 pinentry_disconnect(pwm);
1789 if (*password)
1790 xfree(*password);
1792 return error;
1795 if (!confirm++) {
1796 *password = result;
1797 goto again;
1800 if (strcmp(*password, result)) {
1801 xfree(*password);
1802 xfree(result);
1803 pinentry_disconnect(pwm);
1804 error = EPWMD_BADKEY;
1805 return error;
1808 xfree(result);
1809 pinentry_disconnect(pwm);
1810 return 0;
1812 #endif
1814 static gpg_error_t do_save_command(pwm_t *pwm, char *password)
1816 char buf[ASSUAN_LINELENGTH];
1817 gpg_error_t error;
1818 char *result = NULL;
1820 snprintf(buf, sizeof(buf), "SAVE %s", password ? password : "");
1821 error = send_command(pwm, &result, buf);
1822 memset(&buf, 0, sizeof(buf));
1824 if (error && result)
1825 xfree(result);
1827 return error;
1830 gpg_error_t pwmd_save_nb_finalize(pwm_t *pwm, pwmd_nb_status_t *pw)
1832 gpg_error_t rc;
1834 #ifndef WITH_PINENTRY
1835 return GPG_ERR_NOT_IMPLEMENTED;
1836 #endif
1838 if (!pwm || !pw || !pw->filename[0])
1839 return GPG_ERR_INV_ARG;
1841 close(pw->fd);
1842 rc = pw->error;
1843 memset(pw, 0, sizeof(pwmd_nb_status_t));
1844 return rc;
1847 static int do_pwmd_save(pwm_t *pwm, gpg_error_t *error, int nb)
1849 char *result = NULL;
1850 char *password = NULL;
1852 if (!pwm) {
1853 *error = GPG_ERR_INV_ARG;
1854 return nb ? -1 : 1;
1857 if (pwm->use_pinentry || pwm->passfunc) {
1858 *error = pwmd_command(pwm, &result, "ISCACHED %s", pwm->filename);
1860 if (*error == EPWMD_CACHE_NOT_FOUND) {
1861 if (pwm->passfunc)
1862 password = (*pwm->passfunc)(pwm, pwm->passdata);
1863 #ifdef WITH_PINENTRY
1864 else if (pwm->use_pinentry) {
1865 if (nb) {
1866 int p[2];
1867 pid_t pid;
1868 pwmd_nb_status_t pw;
1870 if (pipe(p) == -1) {
1871 *error = gpg_error_from_syserror();
1872 return -1;
1875 #ifdef WITH_LIBPTH
1876 pid = pth_fork();
1877 #else
1878 pid = fork();
1879 #endif
1881 switch (pid) {
1882 case 0:
1883 close(p[0]);
1884 strncpy(pw.filename, pwm->filename, sizeof(pw.filename));
1885 pw.filename[sizeof(pw.filename)-1] = 0;
1886 pw.fd = p[0];
1888 do {
1889 password = NULL;
1890 *error = do_save_getpin(pwm, &password);
1891 } while (*error == EPWMD_BADKEY);
1893 if (*error) {
1894 if (pwm->pctx)
1895 pinentry_disconnect(pwm);
1897 pw.error = *error;
1898 #ifdef WITH_LIBPTH
1899 pth_write(p[1], &pw, sizeof(pw));
1900 #else
1901 write(p[1], &pw, sizeof(pw));
1902 #endif
1903 close(p[1]);
1904 _exit(1);
1907 *error = do_save_command(pwm, password);
1908 pinentry_disconnect(pwm);
1909 pw.error = *error;
1910 #ifdef WITH_LIBPTH
1911 pth_write(p[1], &pw, sizeof(pw));
1912 #else
1913 write(p[1], &pw, sizeof(pw));
1914 #endif
1915 close(p[1]);
1916 _exit(0);
1917 break;
1918 case -1:
1919 *error = gpg_error_from_syserror();
1920 close(p[0]);
1921 close(p[1]);
1922 return -1;
1923 default:
1924 break;
1927 close(p[1]);
1928 *error = 0;
1929 return p[0];
1932 *error = do_save_getpin(pwm, &password);
1934 if (*error)
1935 return 1;
1937 #endif
1939 else {
1940 if (*error)
1941 return nb ? -1 : 1;
1944 else
1945 password = pwm->password;
1947 *error = do_save_command(pwm, password);
1949 if (!pwm->passfunc && password && password != pwm->password)
1950 xfree(password);
1952 if (nb)
1953 return *error ? -1 : -2;
1955 return *error ? 1 : 0;
1958 int pwmd_save_nb(pwm_t *pwm, gpg_error_t *error)
1960 #ifndef WITH_PINENTRY
1961 *error = GPG_ERR_NOT_IMPLEMENTED;
1962 return -1;
1963 #else
1964 return do_pwmd_save(pwm, error, 1);
1965 #endif
1968 gpg_error_t pwmd_save(pwm_t *pwm)
1970 gpg_error_t error;
1972 do_pwmd_save(pwm, &error, 0);
1973 return error;
1976 gpg_error_t pwmd_setopt(pwm_t *pwm, pwmd_option_t opt, ...)
1978 va_list ap;
1979 int n = va_arg(ap, int);
1980 char *result;
1981 char *arg1;
1982 gpg_error_t error = 0;
1984 if (!pwm)
1985 return GPG_ERR_INV_ARG;
1987 va_start(ap, opt);
1989 switch (opt) {
1990 case PWMD_OPTION_STATUS_FUNC:
1991 pwm->status_func = va_arg(ap, pwmd_status_fn);
1992 break;
1993 case PWMD_OPTION_STATUS_DATA:
1994 pwm->status_data = va_arg(ap, void *);
1995 break;
1996 case PWMD_OPTION_PASSWORD_FUNC:
1997 pwm->passfunc = va_arg(ap, pwmd_password_fn);
1998 break;
1999 case PWMD_OPTION_PASSWORD_DATA:
2000 pwm->passdata = va_arg(ap, void *);
2001 break;
2002 case PWMD_OPTION_PASSWORD:
2003 arg1 = va_arg(ap, char *);
2005 if (pwm->password)
2006 xfree(pwm->password);
2008 pwm->password = xstrdup(arg1);
2009 break;
2010 case PWMD_OPTION_PINENTRY:
2011 n = va_arg(ap, int);
2013 if (n != 0 && n != 1) {
2014 va_end(ap);
2015 error = GPG_ERR_INV_VALUE;
2017 else {
2018 pwm->use_pinentry = n;
2019 error = pwmd_command(pwm, &result, "OPTION PINENTRY=%i",
2020 !pwm->use_pinentry);
2022 break;
2023 #ifdef WITH_PINENTRY
2024 case PWMD_OPTION_PINENTRY_TRIES:
2025 n = va_arg(ap, int);
2027 if (n <= 0) {
2028 va_end(ap);
2029 error = GPG_ERR_INV_VALUE;
2031 else
2032 pwm->pinentry_tries = n;
2033 break;
2034 #endif
2035 case PWMD_OPTION_PINENTRY_TIMEOUT:
2036 n = va_arg(ap, int);
2038 if (n < 0) {
2039 va_end(ap);
2040 error = GPG_ERR_INV_VALUE;
2042 else
2043 pwm->pinentry_timeout = n;
2045 if (!pwm->use_pinentry)
2046 error = pwmd_command(pwm, &result, "OPTION TIMEOUT=%i",
2047 pwm->pinentry_timeout);
2048 break;
2049 case PWMD_OPTION_PINENTRY_PATH:
2050 if (pwm->pinentry_path)
2051 xfree(pwm->pinentry_path);
2053 pwm->pinentry_path = xstrdup(va_arg(ap, char *));
2055 if (!pwm->use_pinentry)
2056 error = pwmd_command(pwm, &result, "OPTION PATH=%s",
2057 pwm->pinentry_path);
2058 break;
2059 case PWMD_OPTION_PINENTRY_TTY:
2060 if (pwm->pinentry_tty)
2061 xfree(pwm->pinentry_tty);
2063 pwm->pinentry_tty = xstrdup(va_arg(ap, char *));
2065 if (!pwm->use_pinentry)
2066 error = pwmd_command(pwm, &result, "OPTION TTY=%s",
2067 pwm->pinentry_tty);
2068 break;
2069 case PWMD_OPTION_PINENTRY_DISPLAY:
2070 if (pwm->pinentry_display)
2071 xfree(pwm->pinentry_display);
2073 pwm->pinentry_display = xstrdup(va_arg(ap, char *));
2075 if (!pwm->use_pinentry)
2076 error = pwmd_command(pwm, &result, "OPTION DISPLAY=%s",
2077 pwm->pinentry_display);
2078 break;
2079 case PWMD_OPTION_PINENTRY_TERM:
2080 if (pwm->pinentry_term)
2081 xfree(pwm->pinentry_term);
2083 pwm->pinentry_term = xstrdup(va_arg(ap, char *));
2085 if (!pwm->use_pinentry)
2086 error = pwmd_command(pwm, &result, "OPTION TTYTYPE=%s",
2087 pwm->pinentry_term);
2088 break;
2089 case PWMD_OPTION_PINENTRY_TITLE:
2090 if (pwm->title)
2091 xfree(pwm->title);
2093 pwm->title = percent_escape(va_arg(ap, char *));
2095 if (!pwm->use_pinentry)
2096 error = pwmd_command(pwm, &result, "OPTION TITLE=%s",
2097 pwm->title);
2098 break;
2099 case PWMD_OPTION_PINENTRY_PROMPT:
2100 if (pwm->prompt)
2101 xfree(pwm->prompt);
2103 pwm->prompt = percent_escape(va_arg(ap, char *));
2105 if (!pwm->use_pinentry)
2106 error = pwmd_command(pwm, &result, "OPTION PROMPT=%s",
2107 pwm->prompt);
2108 break;
2109 case PWMD_OPTION_PINENTRY_DESC:
2110 if (pwm->desc)
2111 xfree(pwm->desc);
2113 pwm->desc = percent_escape(va_arg(ap, char *));
2115 if (!pwm->use_pinentry)
2116 error = pwmd_command(pwm, &result, "OPTION DESC=%s",
2117 pwm->desc);
2118 break;
2119 case PWMD_OPTION_PINENTRY_LC_CTYPE:
2120 if (pwm->lcctype)
2121 xfree(pwm->lcctype);
2123 pwm->lcctype = xstrdup(va_arg(ap, char *));
2125 if (!pwm->use_pinentry)
2126 error = pwmd_command(pwm, &result, "OPTION LC_CTYPE=%s",
2127 pwm->lcctype);
2128 break;
2129 case PWMD_OPTION_PINENTRY_LC_MESSAGES:
2130 if (pwm->lcmessages)
2131 xfree(pwm->lcmessages);
2133 pwm->lcmessages = xstrdup(va_arg(ap, char *));
2135 if (!pwm->use_pinentry)
2136 error = pwmd_command(pwm, &result, "OPTION LC_MESSAGES=%s",
2137 pwm->lcmessages);
2138 break;
2139 default:
2140 error = GPG_ERR_NOT_IMPLEMENTED;
2141 break;
2144 va_end(ap);
2145 return error;
2149 * Prevent requiring assuan.h when setting ctx. The ctx is really an
2150 * assuan_context_t *.
2152 gpg_error_t pwmd_assuan_ctx(pwm_t *pwm, void *ctx, int *fd)
2154 if (!pwm)
2155 return GPG_ERR_INV_ARG;
2157 ctx = pwm->ctx;
2158 *fd = pwm->fd;
2159 return 0;