src/libpwmd.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006-2009 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  02110-1301  USA
  18 */
  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>
  42
  43 #ifdef HAVE_CONFIG_H
  44 #include <config.h>
  45 #endif
  46
  47 #ifdef WITH_LIBPTH
  48 #include <pth.h>
  49 #endif
  50
  51 #ifdef WITH_TCP
  52 #define DNS_USE_GETTIMEOFDAY_FOR_ID 1
  53 #include <ares.h>
  54 #include <arpa/nameser.h>
  55 #endif
  56
  57 #ifdef HAVE_ASSUAN_H
  58 #include <assuan.h>
  59 #endif
  60
  61 #ifdef HAVE_SETLOCALE
  62 #include <locale.h>
  63 #endif
  64
  65 #include "gettext.h"
  66 #define N_(msgid)       dgettext("libpwmd", msgid)
  67
  68 #include "mem.h"
  69 #include "types.h"
  70
  71 static char *_getpwuid(struct passwd *pwd)
  72 {
  73     size_t size = sysconf(_SC_GETPW_R_SIZE_MAX);
  74     struct passwd *result;
  75     char *buf;
  76     int n;
  77
  78     if (size == -1)
  79         size = 16384;
  80
  81     buf = pwmd_malloc(size);
  82
  83     if (!buf)
  84         return NULL;
  85
  86     n = getpwuid_r(getuid(), pwd, buf, size, &result);
  87
  88     if (n) {
  89         pwmd_free(buf);
  90         errno = n;
  91         return NULL;
  92     }
  93
  94     if (!result) {
  95         pwmd_free(buf);
  96         return NULL;
  97     }
  98
  99     errno = n;
 100     return buf;
 101 }
 102
 103 static const char *_pwmd_strerror(gpg_error_t e)
 104 {
 105     gpg_err_code_t code = gpg_err_code(e);
 106
 107     if (code >= GPG_ERR_USER_1 && code < gpg_err_code(EPWMD_MAX)) {
 108         switch (code) {
 109             default:
 110                 return NULL;
 111             case GPG_ERR_USER_1:
 112                 return N_("Unknown error");
 113             case GPG_ERR_USER_2:
 114                 return N_("No cache slots available");
 115             case GPG_ERR_USER_3:
 116                 return N_("Recursion loop");
 117             case GPG_ERR_USER_4:
 118                 return N_("No file is open");
 119             case GPG_ERR_USER_5:
 120                 return N_("General LibXML error");
 121             case GPG_ERR_USER_6:
 122                 return N_("File modified");
 123         }
 124     }
 125
 126     return NULL;
 127 }
 128
 129 const char *pwmd_strerror(gpg_error_t code)
 130 {
 131     const char *p = _pwmd_strerror(code);
 132
 133     return p ? p : gpg_strerror(code);
 134 }
 135
 136 int pwmd_strerror_r(gpg_error_t code, char *buf, size_t size)
 137 {
 138     const char *p = _pwmd_strerror(code);
 139
 140     if (p) {
 141         snprintf(buf, size, "%s", p);
 142
 143         if (strlen(p) > size)
 144             return ERANGE;
 145
 146         return 0;
 147     }
 148
 149     return gpg_strerror_r(code, buf, size);
 150 }
 151
 152 gpg_error_t pwmd_init()
 153 {
 154     static int initialized;
 155
 156     if (initialized)
 157         return 0;
 158
 159 #ifndef MEM_DEBUG
 160     xmem_init();
 161 #endif
 162 #ifdef ENABLE_NLS
 163     bindtextdomain("libpwmd", LOCALEDIR);
 164 #endif
 165     gpg_err_init();
 166     assuan_set_malloc_hooks(pwmd_malloc, pwmd_realloc, pwmd_free);
 167     assuan_set_assuan_err_source(GPG_ERR_SOURCE_DEFAULT);
 168     initialized = 1;
 169     return 0;
 170 }
 171
 172 static gpg_error_t _socket_connect_finalize(pwm_t *pwm)
 173 {
 174     int active[2];
 175     int n = assuan_get_active_fds(pwm->ctx, 0, active, N_ARRAY(active));
 176     gpg_error_t rc;
 177     char *result;
 178
 179     if (n <= 0)
 180         return GPG_ERR_EBADFD;
 181
 182     pwm->fd = active[0];
 183 #ifdef WITH_PINENTRY
 184     pwm->pid = -1;
 185 #endif
 186     assuan_set_pointer(pwm->ctx, pwm);
 187
 188     if (pwm->name) {
 189         rc = pwmd_command(pwm, NULL, "OPTION CLIENT NAME=%s", pwm->name);
 190
 191         if (rc)
 192             return rc;
 193     }
 194
 195     rc = pwmd_command(pwm, &result, "VERSION");
 196
 197     if (rc && rc != GPG_ERR_ASS_UNKNOWN_CMD)
 198         return rc;
 199
 200     if (rc)
 201         pwm->version = PWMD_V1;
 202     else
 203         pwm->version = PWMD_V2;
 204
 205     pwmd_free(result);
 206     return 0;
 207 }
 208
 209 #ifdef WITH_TCP
 210 static int read_hook(assuan_context_t ctx, assuan_fd_t fd, void *data,
 211         size_t len, ssize_t *ret)
 212 {
 213     pwm_t *pwm = assuan_get_pointer(ctx);
 214
 215     if (!pwm || !pwm->tcp_conn)
 216 #ifdef WITH_LIBPTH
 217         *ret = pth_read((int)fd, data, len);
 218 #else
 219         *ret = read((int)fd, data, len);
 220 #endif
 221     else
 222         *ret = libssh2_channel_read(pwm->tcp_conn->channel, data, len);
 223
 224     return *ret > 0 ? 1 : 0;
 225 }
 226
 227 static int write_hook(assuan_context_t ctx, assuan_fd_t fd, const void *data,
 228         size_t len, ssize_t *ret)
 229 {
 230     pwm_t *pwm = assuan_get_pointer(ctx);
 231
 232     if (!pwm || !pwm->tcp_conn)
 233 #ifdef WITH_LIBPTH
 234         *ret = pth_write((int)fd, data, len);
 235 #else
 236         *ret = write((int)fd, data, len);
 237 #endif
 238     else
 239         *ret = libssh2_channel_write(pwm->tcp_conn->channel, data, len);
 240
 241     return *ret > 0 ? 1 : 0;
 242 }
 243
 244 static void _ssh_deinit(pwmd_tcp_conn_t *conn);
 245 static void free_tcp_conn(pwmd_tcp_conn_t *conn)
 246 {
 247     if (!conn)
 248         return;
 249
 250     if (conn->username) {
 251         pwmd_free(conn->username);
 252         conn->username = NULL;
 253     }
 254
 255     if (conn->known_hosts) {
 256         pwmd_free(conn->known_hosts);
 257         conn->known_hosts = NULL;
 258     }
 259
 260     if (conn->identity) {
 261         pwmd_free(conn->identity);
 262         conn->identity = NULL;
 263     }
 264
 265     if (conn->identity_pub) {
 266         pwmd_free(conn->identity_pub);
 267         conn->identity_pub = NULL;
 268     }
 269
 270     if (conn->host) {
 271         pwmd_free(conn->host);
 272         conn->host = NULL;
 273     }
 274
 275     if (conn->hostkey) {
 276         pwmd_free(conn->hostkey);
 277         conn->hostkey = NULL;
 278     }
 279
 280     if (conn->chan) {
 281         ares_destroy(conn->chan);
 282         conn->chan = NULL;
 283     }
 284
 285     if (conn->he) {
 286         ares_free_hostent(conn->he);
 287         conn->he = NULL;
 288     }
 289
 290     if (conn->fd >= 0) {
 291         close(conn->fd);
 292         conn->fd = -1;
 293     }
 294
 295     if (conn->session)
 296         _ssh_deinit(conn);
 297     else
 298         pwmd_free(conn);
 299 }
 300
 301 static void _ssh_deinit(pwmd_tcp_conn_t *conn)
 302 {
 303     if (!conn)
 304         return;
 305
 306     if (conn->channel)
 307         libssh2_channel_free(conn->channel);
 308
 309     if (conn->session) {
 310         libssh2_session_disconnect(conn->session, "Bye!");
 311         libssh2_session_free(conn->session);
 312     }
 313
 314     conn->session = NULL;
 315     conn->channel = NULL;
 316     free_tcp_conn(conn);
 317 }
 318
 319 static void _ssh_assuan_deinit(assuan_context_t ctx)
 320 {
 321     pwm_t *pwm = assuan_get_pointer(ctx);
 322
 323     pwm->tcp_conn->fd = -1;
 324     _ssh_deinit(pwm->tcp_conn);
 325     pwm->tcp_conn = NULL;
 326 }
 327
 328 /*
 329  * Sets common options from both pwmd_ssh_connect() and
 330  * pwmd_ssh_connect_async().
 331  */
 332 static gpg_error_t init_tcp_conn(pwmd_tcp_conn_t **dst, const char *host,
 333         int port, const char *identity, const char *user, const char *hosts,
 334         int get)
 335 {
 336     pwmd_tcp_conn_t *conn;
 337     gpg_error_t rc = 0;
 338
 339     if (get) {
 340         if (!host)
 341             return GPG_ERR_INV_ARG;
 342     }
 343     else {
 344         if (!host || !identity || !hosts)
 345             return GPG_ERR_INV_ARG;
 346     }
 347
 348     conn = pwmd_calloc(1, sizeof(pwmd_tcp_conn_t));
 349
 350     if (!conn)
 351         return gpg_error_from_errno(ENOMEM);
 352
 353     conn->port = port == -1 ? 22 : port;
 354     conn->host = pwmd_strdup(host);
 355
 356     if (!conn->host) {
 357         rc = gpg_error_from_errno(ENOMEM);
 358         goto fail;
 359     }
 360
 361     if (!get) {
 362         struct passwd pw;
 363         char *pwbuf = _getpwuid(&pw);
 364
 365         if (!pwbuf) {
 366             rc = gpg_error_from_errno(errno);
 367             goto fail;
 368         }
 369
 370         conn->username = pwmd_strdup(user ? user : pw.pw_name);
 371         pwmd_free(pwbuf);
 372
 373         if (!conn->username) {
 374             rc = gpg_error_from_errno(ENOMEM);
 375             goto fail;
 376         }
 377
 378         conn->identity = pwmd_strdup(identity);
 379
 380         if (!conn->identity) {
 381             rc = gpg_error_from_errno(ENOMEM);
 382             goto fail;
 383         }
 384
 385         conn->identity_pub = pwmd_malloc(strlen(conn->identity)+5);
 386
 387         if (!conn->identity_pub) {
 388             rc = gpg_error_from_errno(ENOMEM);
 389             goto fail;
 390         }
 391
 392         sprintf(conn->identity_pub, "%s.pub", conn->identity);
 393         conn->known_hosts = pwmd_strdup(hosts);
 394
 395         if (!conn->known_hosts) {
 396             rc = gpg_error_from_errno(ENOMEM);
 397             goto fail;
 398         }
 399     }
 400
 401     *dst = conn;
 402     return 0;
 403
 404 fail:
 405     free_tcp_conn(conn);
 406     return rc;
 407 }
 408
 409 static gpg_error_t do_connect(pwm_t *pwm, int prot, void *addr)
 410 {
 411     struct sockaddr_in their_addr;
 412
 413     pwm->tcp_conn->fd = socket(prot, SOCK_STREAM, 0);
 414
 415     if (pwm->tcp_conn->fd == -1)
 416         return gpg_error_from_syserror();
 417
 418     if (pwm->tcp_conn->async)
 419         fcntl(pwm->tcp_conn->fd, F_SETFL, O_NONBLOCK);
 420
 421     pwm->cmd = ASYNC_CMD_CONNECT;
 422     their_addr.sin_family = prot;
 423     their_addr.sin_port = htons(pwm->tcp_conn->port);
 424     their_addr.sin_addr = *((struct in_addr *)addr);
 425     memset(their_addr.sin_zero, '\0', sizeof their_addr.sin_zero);
 426
 427 #ifdef WITH_LIBPTH
 428     if (pth_connect(pwm->tcp_conn->fd, (struct sockaddr *)&their_addr,
 429                 sizeof(their_addr)) == -1)
 430 #else
 431     if (connect(pwm->tcp_conn->fd, (struct sockaddr *)&their_addr,
 432                 sizeof(their_addr)) == -1)
 433 #endif
 434         return gpg_error_from_syserror();
 435
 436     return 0;
 437 }
 438
 439 static gpg_error_t ares_error_to_pwmd(int status)
 440 {
 441     if (status != ARES_SUCCESS)
 442         warnx("%s", ares_strerror(status));
 443
 444     switch (status) {
 445         case ARES_ENODATA:
 446         case ARES_EFORMERR:
 447         case ARES_ENOTFOUND:
 448             return GPG_ERR_UNKNOWN_HOST;
 449         case ARES_ESERVFAIL:
 450              return GPG_ERR_EHOSTDOWN;
 451         case ARES_ETIMEOUT:
 452             return GPG_ERR_TIMEOUT;
 453         case ARES_ENOMEM:
 454             return gpg_error_from_errno(ENOMEM);
 455         case ARES_ECONNREFUSED:
 456             return GPG_ERR_ECONNREFUSED;
 457         default:
 458             /* FIXME ??? */
 459             return GPG_ERR_EHOSTUNREACH;
 460     }
 461
 462     return ARES_SUCCESS;
 463 }
 464
 465 static void dns_resolve_cb(void *arg, int status, int timeouts,
 466         unsigned char *abuf, int alen)
 467 {
 468     pwm_t *pwm = arg;
 469     int rc;
 470     struct hostent *he;
 471
 472     if (status == ARES_EDESTRUCTION)
 473         return;
 474
 475     if (status != ARES_SUCCESS) {
 476         pwm->tcp_conn->rc = ares_error_to_pwmd(status);
 477         return;
 478     }
 479
 480     /* Check for an IPv6 address first. */
 481     if (pwm->prot == PWMD_IP_ANY || pwm->prot == PWMD_IPV6)
 482         rc = ares_parse_aaaa_reply(abuf, alen, &he, NULL, NULL);
 483     else
 484         rc = ares_parse_a_reply(abuf, alen, &he, NULL, NULL);
 485
 486     if (rc != ARES_SUCCESS) {
 487         if (pwm->prot != PWMD_IP_ANY || rc != ARES_ENODATA) {
 488             pwm->tcp_conn->rc = ares_error_to_pwmd(status);
 489             return;
 490         }
 491
 492         rc = ares_parse_a_reply(abuf, alen, &he, NULL, NULL);
 493
 494         if (rc != ARES_SUCCESS) {
 495             pwm->tcp_conn->rc = ares_error_to_pwmd(status);
 496             return;
 497         }
 498     }
 499
 500     pwm->tcp_conn->he = he;
 501     pwm->tcp_conn->rc = do_connect(pwm, he->h_addrtype, he->h_addr);
 502 }
 503
 504 static gpg_error_t _do_pwmd_tcp_connect_async(pwm_t *pwm, const char *host,
 505         int port, const char *identity, const char *user,
 506         const char *known_hosts, pwmd_async_cmd_t which)
 507 {
 508     pwmd_tcp_conn_t *conn;
 509     gpg_error_t rc;
 510
 511     if (!pwm)
 512         return GPG_ERR_INV_ARG;
 513
 514     rc = init_tcp_conn(&conn, host, port, identity, user, known_hosts,
 515             which == ASYNC_CMD_HOSTKEY ? 1 : 0);
 516
 517     if (rc)
 518         return rc;
 519
 520     conn->async = 1;
 521     pwm->tcp_conn = conn;
 522     pwm->tcp_conn->cmd = which;
 523
 524     if (pwm->tcp_conn->cmd == ASYNC_CMD_HOSTKEY)
 525         pwm->tcp_conn->get_only = 1;
 526
 527     pwm->cmd = ASYNC_CMD_DNS;
 528     pwm->state = ASYNC_PROCESS;
 529     ares_init(&pwm->tcp_conn->chan);
 530     ares_query(pwm->tcp_conn->chan, pwm->tcp_conn->host, ns_c_any, ns_t_any,
 531             dns_resolve_cb, pwm);
 532     return 0;
 533 }
 534
 535 gpg_error_t pwmd_ssh_connect_async(pwm_t *pwm, const char *host, int port,
 536         const char *identity, const char *user, const char *known_hosts)
 537 {
 538     return _do_pwmd_tcp_connect_async(pwm, host, port, identity, user,
 539             known_hosts, ASYNC_CMD_CONNECT);
 540 }
 541
 542 static void *_ssh_malloc(size_t size, void **data)
 543 {
 544     return pwmd_malloc(size);
 545 }
 546
 547 static void _ssh_free(void *ptr, void **data)
 548 {
 549     pwmd_free(ptr);
 550 }
 551
 552 static void *_ssh_realloc(void *ptr, size_t size, void **data)
 553 {
 554     return pwmd_realloc(ptr, size);
 555 }
 556
 557 static char *to_hex(const char *str, size_t slen)
 558 {
 559     int i;
 560     char *buf = pwmd_malloc(slen*2+1);
 561
 562     if (!buf)
 563         return NULL;
 564
 565     for (i = 0, buf[0] = 0; i < slen; i++) {
 566         char tmp[3];
 567
 568         sprintf(tmp, "%02x", (unsigned char)str[i]);
 569         strcat(buf, tmp);
 570     }
 571
 572     return buf;
 573 }
 574
 575 static int verify_host_key(pwm_t *pwm)
 576 {
 577     FILE *fp = fopen(pwm->tcp_conn->known_hosts, "r");
 578     char *buf, *p;
 579
 580     if (!fp)
 581         return 1;
 582
 583     buf = pwmd_malloc(LINE_MAX);
 584
 585     if (!buf)
 586         goto fail;
 587
 588     while ((p = fgets(buf, LINE_MAX, fp))) {
 589         if (*p == '#' || isspace(*p))
 590             continue;
 591
 592         if (p[strlen(p)-1] == '\n')
 593             p[strlen(p)-1] = 0;
 594
 595         if (!strcmp(buf, pwm->tcp_conn->hostkey))
 596             goto done;
 597     }
 598
 599 fail:
 600     if (buf)
 601         pwmd_free(buf);
 602
 603     fclose(fp);
 604     return 1;
 605
 606 done:
 607     pwmd_free(buf);
 608     fclose(fp);
 609     return 0;
 610 }
 611
 612 static gpg_error_t authenticate_ssh(pwm_t *pwm)
 613 {
 614     const char *fp = libssh2_hostkey_hash(pwm->tcp_conn->session,
 615             LIBSSH2_HOSTKEY_HASH_SHA1);
 616     char *userauth;
 617
 618     pwm->tcp_conn->hostkey = to_hex(fp, 20);
 619
 620     if (!pwm->tcp_conn->hostkey)
 621         return gpg_error_from_errno(ENOMEM);
 622
 623     if (pwm->tcp_conn->get_only)
 624         return 0;
 625
 626     if (!fp || verify_host_key(pwm))
 627         return GPG_ERR_CHECKSUM;
 628
 629     userauth = libssh2_userauth_list(pwm->tcp_conn->session,
 630             pwm->tcp_conn->username, strlen(pwm->tcp_conn->username));
 631
 632     if (!userauth || !strstr(userauth, "publickey"))
 633         return GPG_ERR_BAD_PIN_METHOD;
 634
 635     if (libssh2_userauth_publickey_fromfile(pwm->tcp_conn->session,
 636                 pwm->tcp_conn->username, pwm->tcp_conn->identity_pub,
 637                 pwm->tcp_conn->identity, NULL))
 638         return GPG_ERR_BAD_SECKEY;
 639
 640     return 0;
 641 }
 642
 643 static gpg_error_t setup_tcp_session(pwm_t *pwm)
 644 {
 645     assuan_context_t ctx;
 646     struct assuan_io_hooks io_hooks = {read_hook, write_hook};
 647     gpg_error_t rc;
 648
 649     pwm->tcp_conn->session = libssh2_session_init_ex(_ssh_malloc, _ssh_free,
 650             _ssh_realloc, NULL);
 651
 652     if (!pwm->tcp_conn->session) {
 653         rc = gpg_error_from_errno(ENOMEM);
 654         goto fail;
 655     }
 656
 657     if (libssh2_session_startup(pwm->tcp_conn->session, pwm->tcp_conn->fd)) {
 658         rc = GPG_ERR_ASSUAN_SERVER_FAULT;
 659         goto fail;
 660     }
 661
 662     rc = authenticate_ssh(pwm);
 663
 664     if (rc)
 665         goto fail;
 666
 667     /* pwmd_get_hostkey(). */
 668     if (pwm->tcp_conn->get_only) {
 669         pwm->result = pwmd_strdup(pwm->tcp_conn->hostkey);
 670
 671         if (!pwm->result) {
 672             rc = gpg_error_from_errno(ENOMEM);
 673             goto fail;
 674         }
 675
 676         return 0;
 677     }
 678
 679     pwm->tcp_conn->channel = libssh2_channel_open_session(pwm->tcp_conn->session);
 680
 681     if (!pwm->tcp_conn->channel) {
 682         rc = GPG_ERR_ASSUAN_SERVER_FAULT;
 683         goto fail;
 684     }
 685
 686     if (libssh2_channel_shell(pwm->tcp_conn->channel)) {
 687         rc = GPG_ERR_ASSUAN_SERVER_FAULT;
 688         goto fail;
 689     }
 690
 691     assuan_set_io_hooks(&io_hooks);
 692     rc = assuan_socket_connect_fd(&ctx, pwm->tcp_conn->fd, 0, pwm);
 693
 694     if (rc)
 695         goto fail;
 696
 697     assuan_set_finish_handler(ctx, _ssh_assuan_deinit);
 698     pwm->ctx = ctx;
 699     return _socket_connect_finalize(pwm);
 700
 701 fail:
 702     free_tcp_conn(pwm->tcp_conn);
 703     pwm->tcp_conn = NULL;
 704     return rc;
 705 }
 706
 707 static gpg_error_t _do_pwmd_tcp_connect(pwm_t *pwm, const char *host, int port,
 708         const char *identity, const char *user, const char *known_hosts, int get)
 709 {
 710     pwmd_tcp_conn_t *conn;
 711     gpg_error_t rc;
 712
 713     if (!pwm)
 714         return GPG_ERR_INV_ARG;
 715
 716     rc = init_tcp_conn(&conn, host, port, identity, user, known_hosts, get);
 717
 718     if (rc)
 719         return rc;
 720
 721     pwm->tcp_conn = conn;
 722     pwm->tcp_conn->get_only = get;
 723     pwm->cmd = ASYNC_CMD_DNS;
 724     ares_init(&pwm->tcp_conn->chan);
 725     ares_query(pwm->tcp_conn->chan, pwm->tcp_conn->host, ns_c_any, ns_t_any,
 726             dns_resolve_cb, pwm);
 727
 728     /* dns_resolve_cb() may have already been called. */
 729     if (pwm->tcp_conn->rc) {
 730         rc = pwm->tcp_conn->rc;
 731         goto fail;
 732     }
 733
 734     /*
 735      * Fake a blocking DNS lookup. libcares does a better job than
 736      * getaddrinfo().
 737      */
 738     do {
 739         fd_set rfds, wfds;
 740         int n;
 741         struct timeval tv;
 742
 743         FD_ZERO(&rfds);
 744         FD_ZERO(&wfds);
 745         n = ares_fds(pwm->tcp_conn->chan, &rfds, &wfds);
 746         ares_timeout(pwm->tcp_conn->chan, NULL, &tv);
 747 #ifdef WITH_LIBPTH
 748         n = pth_select(n, &rfds, &wfds, NULL, &tv);
 749 #else
 750         n = select(n, &rfds, &wfds, NULL, &tv);
 751 #endif
 752
 753         if (n == -1) {
 754             rc = gpg_error_from_syserror();
 755             goto fail;
 756         }
 757         else if (n == 0) {
 758             rc = GPG_ERR_TIMEOUT;
 759             goto fail;
 760         }
 761
 762         ares_process(pwm->tcp_conn->chan, &rfds, &wfds);
 763
 764         if (pwm->tcp_conn->rc)
 765             break;
 766     } while (pwm->cmd == ASYNC_CMD_DNS);
 767
 768     if (pwm->tcp_conn->rc) {
 769         rc = pwm->tcp_conn->rc;
 770         goto fail;
 771     }
 772
 773     return setup_tcp_session(pwm);
 774
 775 fail:
 776     return rc;
 777 }
 778
 779 gpg_error_t pwmd_ssh_connect(pwm_t *pwm, const char *host, int port,
 780         const char *identity, const char *user, const char *known_hosts)
 781 {
 782     return _do_pwmd_tcp_connect(pwm, host, port, identity, user, known_hosts, 0);
 783 }
 784
 785 gpg_error_t pwmd_get_hostkey(pwm_t *pwm, const char *host, int port,
 786         char **result)
 787 {
 788     char *hostkey;
 789     gpg_error_t rc;
 790
 791     rc = _do_pwmd_tcp_connect(pwm, host, port, NULL, NULL, NULL, 1);
 792
 793     if (rc)
 794         return rc;
 795
 796     hostkey = pwmd_strdup(pwm->tcp_conn->hostkey);
 797
 798     if (!hostkey)
 799         rc = gpg_error_from_errno(ENOMEM);
 800
 801     *result = hostkey;
 802     return rc;
 803 }
 804
 805 gpg_error_t pwmd_get_hostkey_async(pwm_t *pwm, const char *host, int port)
 806 {
 807     return _do_pwmd_tcp_connect_async(pwm, host, port, NULL, NULL, NULL,
 808             ASYNC_CMD_HOSTKEY);
 809 }
 810 #endif
 811
 812 gpg_error_t pwmd_connect(pwm_t *pwm, const char *path)
 813 {
 814     char *socketpath = NULL;
 815     assuan_context_t ctx;
 816     struct passwd pw;
 817     char *pwbuf;
 818     gpg_error_t rc;
 819
 820     if (!pwm)
 821         return GPG_ERR_INV_ARG;
 822
 823     pwbuf = _getpwuid(&pw);
 824
 825     if (!pwbuf)
 826         return gpg_error_from_errno(errno);
 827
 828     if (!path) {
 829         socketpath = (char *)pwmd_malloc(strlen(pw.pw_dir) + strlen("/.pwmd/socket") + 1);
 830         sprintf(socketpath, "%s/.pwmd/socket", pw.pw_dir);
 831     }
 832     else
 833         socketpath = pwmd_strdup(path);
 834
 835     pwmd_free(pwbuf);
 836     rc = assuan_socket_connect_ext(&ctx, socketpath, -1, 0);
 837     pwmd_free(socketpath);
 838
 839     if (rc)
 840         return rc;
 841
 842     pwm->ctx = ctx;
 843     return _socket_connect_finalize(pwm);
 844 }
 845
 846 void pwmd_close(pwm_t *pwm)
 847 {
 848     if (!pwm)
 849         return;
 850
 851     if (pwm->ctx)
 852         assuan_disconnect(pwm->ctx);
 853
 854     if (pwm->password)
 855         pwmd_free(pwm->password);
 856
 857     if (pwm->title)
 858         pwmd_free(pwm->title);
 859
 860     if (pwm->desc)
 861         pwmd_free(pwm->desc);
 862
 863     if (pwm->prompt)
 864         pwmd_free(pwm->prompt);
 865
 866     if (pwm->pinentry_tty)
 867         pwmd_free(pwm->pinentry_tty);
 868
 869     if (pwm->pinentry_display)
 870         pwmd_free(pwm->pinentry_display);
 871
 872     if (pwm->pinentry_term)
 873         pwmd_free(pwm->pinentry_term);
 874
 875     if (pwm->lcctype)
 876         pwmd_free(pwm->lcctype);
 877
 878     if (pwm->lcmessages)
 879         pwmd_free(pwm->lcmessages);
 880
 881     if (pwm->filename)
 882         pwmd_free(pwm->filename);
 883
 884     if (pwm->name)
 885         pwmd_free(pwm->name);
 886
 887 #ifdef WITH_TCP
 888     if (pwm->tcp_conn)
 889         free_tcp_conn(pwm->tcp_conn);
 890 #endif
 891
 892     pwmd_free(pwm);
 893 }
 894
 895 static int mem_realloc_cb(void *data, const void *buffer, size_t len)
 896 {
 897     membuf_t *mem = (membuf_t *)data;
 898     void *p;
 899
 900     if (!buffer)
 901         return 0;
 902
 903     if ((p = pwmd_realloc(mem->buf, mem->len + len)) == NULL)
 904         return 1;
 905
 906     mem->buf = p;
 907     memcpy((char *)mem->buf + mem->len, buffer, len);
 908     mem->len += len;
 909     return 0;
 910 }
 911
 912 static int _inquire_cb(void *data, const char *keyword)
 913 {
 914     pwm_t *pwm = (pwm_t *)data;
 915     gpg_error_t rc = 0;
 916     int flags = fcntl(pwm->fd, F_GETFL);
 917
 918     /* Shouldn't get this far without a callback. */
 919     if (!pwm->inquire_func)
 920         return GPG_ERR_INV_ARG;
 921
 922     /*
 923      * Since the socket file descriptor is probably set to non-blocking, set to
 924      * blocking to prevent GPG_ERR_EAGAIN errors. This should be fixed when
 925      * asynchronous INQUIRE is supported by either libassuan or a later
 926      * libpwmd.
 927      */
 928     fcntl(pwm->fd, F_SETFL, 0);
 929
 930     for (;;) {
 931         char *result = NULL;
 932         size_t len;
 933         gpg_error_t arc;
 934
 935         rc = pwm->inquire_func(pwm->inquire_data, keyword, rc, &result, &len);
 936         rc = gpg_err_code(rc);
 937
 938         if (rc == GPG_ERR_EOF || !rc) {
 939             if (len <= 0 || !result) {
 940                 rc = 0;
 941                 break;
 942             }
 943
 944             arc = assuan_send_data(pwm->ctx, result, len);
 945
 946             if (rc == GPG_ERR_EOF) {
 947                 rc = arc;
 948                 break;
 949             }
 950
 951             rc = arc;
 952         }
 953         else if (rc)
 954             break;
 955     }
 956
 957     fcntl(pwm->fd, F_SETFL, flags);
 958     return rc;
 959 }
 960
 961 static gpg_error_t do_nb_command(pwm_t *pwm, const char *cmd, ...)
 962 {
 963     char *buf;
 964     gpg_error_t rc;
 965     va_list ap;
 966
 967     if (pwm->state == ASYNC_DONE)
 968         pwm->state = ASYNC_INIT;
 969
 970     if (pwm->state != ASYNC_INIT)
 971         return GPG_ERR_INV_STATE;
 972
 973     buf = pwmd_malloc(ASSUAN_LINELENGTH+1);
 974
 975     if (!buf)
 976         return gpg_error_from_errno(ENOMEM);
 977
 978     va_start(ap, cmd);
 979     vsnprintf(buf, ASSUAN_LINELENGTH, cmd, ap);
 980     va_end(ap);
 981     rc = assuan_write_line(pwm->ctx, buf);
 982     pwmd_free(buf);
 983
 984     if (!rc)
 985         pwm->state = ASYNC_PROCESS;
 986
 987     return rc;
 988 }
 989
 990 gpg_error_t pwmd_open_async(pwm_t *pwm, const char *filename)
 991 {
 992     if (!pwm || !filename)
 993         return GPG_ERR_INV_ARG;
 994
 995     if (!pwm->ctx)
 996         return GPG_ERR_INV_STATE;
 997
 998     if (pwm->cmd != ASYNC_CMD_OPEN) {
 999         gpg_error_t rc;
1000
1001         pwm->pin_try = 0;
1002
1003         if (pwm->filename)
1004             pwmd_free(pwm->filename);
1005
1006         pwm->filename = pwmd_strdup(filename);
1007
1008         rc = send_pinentry_options(pwm);
1009
1010         if (rc)
1011             return rc;
1012     }
1013
1014     pwm->cmd = ASYNC_CMD_OPEN;
1015     return do_nb_command(pwm, "OPEN %s %s", filename,
1016             pwm->password ? pwm->password : "");
1017 }
1018
1019 gpg_error_t pwmd_save_async(pwm_t *pwm)
1020 {
1021     gpg_error_t rc;
1022
1023     if (!pwm)
1024         return GPG_ERR_INV_ARG;
1025
1026     if (!pwm->ctx)
1027         return GPG_ERR_INV_STATE;
1028
1029     rc = send_pinentry_options(pwm);
1030
1031     if (rc)
1032         return rc;
1033
1034     pwm->cmd = ASYNC_CMD_SAVE;
1035     return do_nb_command(pwm, "SAVE %s", pwm->password ? pwm->password : "");
1036 }
1037
1038 static gpg_error_t parse_assuan_line(pwm_t *pwm)
1039 {
1040     gpg_error_t rc;
1041     char *line;
1042     size_t len;
1043
1044     rc = assuan_read_line(pwm->ctx, &line, &len);
1045
1046     if (!rc) {
1047         if (line[0] == 'O' && line[1] == 'K' &&
1048                 (line[2] == 0 || line[2] == ' ')) {
1049             pwm->state = ASYNC_DONE;
1050         }
1051         else if (line[0] == '#') {
1052         }
1053         else if (line[0] == 'S' && (line[1] == 0 || line[1] == ' ')) {
1054             if (pwm->status_func) {
1055                 pwm->status_func(pwm->status_data,
1056                         line[1] == 0 ? line+1 : line+2);
1057             }
1058         }
1059         else if (line[0] == 'E' && line[1] == 'R' && line[2] == 'R' &&
1060                 (line[3] == 0 || line[3] == ' ')) {
1061             line += 4;
1062             rc = atoi(line);
1063             pwm->state = ASYNC_DONE;
1064         }
1065     }
1066
1067     return rc;
1068 }
1069
1070 gpg_error_t pwmd_pending_line(pwm_t *pwm)
1071 {
1072     if (!pwm)
1073         return GPG_ERR_INV_ARG;
1074
1075     if (!pwm->ctx)
1076         return GPG_ERR_INV_STATE;
1077
1078     return assuan_pending_line(pwm->ctx) ? 0 : GPG_ERR_NO_DATA;
1079 }
1080
1081 static pwmd_async_t reset_async(pwm_t *pwm, int done)
1082 {
1083     pwm->state = ASYNC_INIT;
1084     pwm->cmd = ASYNC_CMD_NONE;
1085
1086 #ifdef WITH_PINENTRY
1087     if (pwm->nb_fd != -1) {
1088         close(pwm->nb_fd);
1089         pwm->nb_fd = -1;
1090     }
1091 #endif
1092 #ifdef WITH_TCP
1093     if (done && pwm->tcp_conn && pwm->tcp_conn->fd != -1) {
1094         close(pwm->tcp_conn->fd);
1095         pwm->tcp_conn->fd = -1;
1096     }
1097 #endif
1098
1099     return ASYNC_DONE;
1100 };
1101
1102 pwmd_async_t pwmd_process(pwm_t *pwm, gpg_error_t *rc, char **result)
1103 {
1104     fd_set fds;
1105     int n;
1106     struct timeval tv = {0, 0};
1107
1108     if (result)
1109         *result = NULL;
1110
1111     if (!rc)
1112         return GPG_ERR_INV_ARG;
1113
1114     *rc = 0;
1115
1116     if (!pwm) {
1117         *rc = GPG_ERR_INV_ARG;
1118         return ASYNC_DONE;
1119     }
1120     else if (!pwm->ctx) {
1121         switch (pwm->cmd) {
1122             default:
1123                 *rc = GPG_ERR_INV_STATE;
1124                 return ASYNC_DONE;
1125 #ifdef WITH_TCP
1126             case ASYNC_CMD_DNS:
1127             case ASYNC_CMD_CONNECT:
1128             case ASYNC_CMD_HOSTKEY:
1129                 break;
1130 #endif
1131         }
1132     }
1133
1134     /* When not in a command, this will let libassuan process status messages
1135      * by calling PWMD_OPTION_STATUS_FUNC. The client can poll the file
1136      * descriptor returned by pwmd_get_fd() to determine when this should be
1137      * called or call pwmd_pending_line() to determine whether a buffered line
1138      * needs to be processed. */
1139     if (pwm->cmd == ASYNC_CMD_NONE) {
1140         *rc = assuan_command(pwm, pwm->ctx, NULL, "NOP");
1141         return ASYNC_DONE;
1142     }
1143
1144     /* Fixes pwmd_open/save_async2() when there is a cached or new file. */
1145     if (pwm->state == ASYNC_DONE) {
1146         reset_async(pwm, 0);
1147         return ASYNC_DONE;
1148     }
1149
1150     if (pwm->state != ASYNC_PROCESS) {
1151         *rc = GPG_ERR_INV_STATE;
1152         return ASYNC_DONE;
1153     }
1154
1155 #ifdef WITH_TCP
1156     if (pwm->cmd == ASYNC_CMD_DNS) {
1157         fd_set rfds, wfds;
1158
1159         if (pwm->tcp_conn->rc) {
1160             *rc = pwm->tcp_conn->rc;
1161             reset_async(pwm, 1);
1162             return ASYNC_DONE;
1163         }
1164
1165         FD_ZERO(&rfds);
1166         FD_ZERO(&wfds);
1167         n = ares_fds(pwm->tcp_conn->chan, &rfds, &wfds);
1168
1169         /* Shouldn't happen. */
1170         if (!n)
1171             return pwm->state;
1172
1173 #ifdef WITH_LIBPTH
1174         n = pth_select(n, &rfds, &wfds, NULL, &tv);
1175 #else
1176         n = select(n, &rfds, &wfds, NULL, &tv);
1177 #endif
1178
1179         if (n > 0)
1180             ares_process(pwm->tcp_conn->chan, &rfds, &wfds);
1181
1182         return pwm->state;
1183     }
1184     else if (pwm->cmd == ASYNC_CMD_CONNECT) {
1185         if (pwm->tcp_conn->rc == GPG_ERR_EINPROGRESS) {
1186             int ret;
1187             socklen_t len = sizeof(int);
1188
1189             FD_ZERO(&fds);
1190             FD_SET(pwm->tcp_conn->fd, &fds);
1191 #ifdef WITH_LIBPTH
1192             n = pth_select(pwm->tcp_conn->fd+1, NULL, &fds, NULL, &tv);
1193 #else
1194             n = select(pwm->tcp_conn->fd+1, NULL, &fds, NULL, &tv);
1195 #endif
1196
1197             if (!n || !FD_ISSET(pwm->tcp_conn->fd, &fds))
1198                 return pwm->state;
1199             else if (n == -1) {
1200                 *rc = gpg_error_from_syserror();
1201                 reset_async(pwm, 1);
1202                 return ASYNC_DONE;
1203             }
1204
1205             ret = getsockopt(pwm->tcp_conn->fd, SOL_SOCKET, SO_ERROR, &n, &len);
1206
1207             if (ret || n) {
1208                 *rc = ret ? gpg_error_from_syserror() : gpg_error_from_errno(n);
1209                 reset_async(pwm, 1);
1210                 return ASYNC_DONE;
1211             }
1212         }
1213         else if (pwm->tcp_conn->rc) {
1214             *rc = pwm->tcp_conn->rc;
1215             reset_async(pwm, 1);
1216             return ASYNC_DONE;
1217         }
1218
1219         fcntl(pwm->tcp_conn->fd, F_SETFL, 0);
1220         *rc = setup_tcp_session(pwm);
1221
1222         if (!*rc) {
1223             switch (pwm->tcp_conn->cmd) {
1224                 case ASYNC_CMD_HOSTKEY:
1225                     if (!*rc)
1226                         *result = pwm->result;
1227                     break;
1228                 default:
1229                     break;
1230             }
1231         }
1232
1233         return reset_async(pwm, *rc ? 1 : 0);
1234     }
1235 #endif
1236
1237 #ifdef WITH_PINENTRY
1238     if (pwm->cmd == ASYNC_CMD_OPEN2 || pwm->cmd == ASYNC_CMD_SAVE2) {
1239         int status;
1240
1241         if (pwm->nb_fd == -1) {
1242             *rc = GPG_ERR_INV_STATE;
1243             return reset_async(pwm, 0);
1244         }
1245
1246         FD_ZERO(&fds);
1247         FD_SET(pwm->nb_fd, &fds);
1248         FD_SET(pwm->fd, &fds);
1249 #ifdef WITH_LIBPTH
1250         n = pth_select(pwm->nb_fd+1, &fds, NULL, NULL, &tv);
1251 #else
1252         n = select(pwm->nb_fd+1, &fds, NULL, NULL, &tv);
1253 #endif
1254         if (n == -1) {
1255             *rc = gpg_error_from_syserror();
1256             return reset_async(pwm, 0);
1257         }
1258
1259         if (n > 0 && FD_ISSET(pwm->nb_fd, &fds)) {
1260             pwmd_nb_status_t nb;
1261 #ifdef WITH_LIBPTH
1262             size_t len = pth_read(pwm->nb_fd, &nb, sizeof(nb));
1263 #else
1264             size_t len = read(pwm->nb_fd, &nb, sizeof(nb));
1265 #endif
1266             waitpid(pwm->nb_pid, &status, WNOHANG);
1267
1268             if (len != sizeof(nb)) {
1269                 *rc = gpg_error_from_syserror();
1270                 return reset_async(pwm, pwm->cmd == ASYNC_CMD_OPEN2 ? 1 : 0);
1271             }
1272
1273             *rc = nb.error;
1274
1275             if (*rc == GPG_ERR_INV_PASSPHRASE && pwm->cmd == ASYNC_CMD_SAVE2) {
1276                 reset_async(pwm, 0);
1277                 *rc = pwmd_save_async2(pwm);
1278                 return ASYNC_PROCESS;
1279             }
1280             else if (*rc)
1281                 return reset_async(pwm, pwm->cmd == ASYNC_CMD_OPEN2 ? 1 : 0);
1282
1283             if (pwm->cmd == ASYNC_CMD_SAVE2) {
1284                 *rc = do_save_command(pwm, nb.password);
1285                 memset(&nb, 0, sizeof(pwmd_nb_status_t));
1286                 return reset_async(pwm, 0);
1287             }
1288
1289             if (pwm->cmd == ASYNC_CMD_OPEN2) {
1290                 *rc = do_open_command(pwm, pwm->filename, nb.password);
1291                 memset(&nb, 0, sizeof(pwmd_nb_status_t));
1292
1293                 if (*rc == GPG_ERR_INV_PASSPHRASE) {
1294                     if (++pwm->pin_try < pwm->pinentry_tries) {
1295                         int n = pwm->pin_try;
1296
1297                         reset_async(pwm, 0);
1298                         pwm->pin_try = n;
1299                         pwm->cmd = ASYNC_CMD_OPEN2;
1300                         *rc = pwmd_open_async2(pwm, pwm->filename);
1301
1302                         if (*rc)
1303                             return reset_async(pwm, 1);
1304
1305                         return pwm->state;
1306                     }
1307                 }
1308
1309                 return reset_async(pwm, *rc ? 1 : 0);
1310             }
1311         }
1312
1313         /* Fall through so status messages can be processed during the
1314          * pinentry. */
1315     }
1316 #endif
1317
1318     if (pwm->fd < 0) {
1319         *rc = GPG_ERR_INV_STATE;
1320         return reset_async(pwm, 0);
1321     }
1322
1323     /* This is for the non-blocking OPEN and SAVE commands. */
1324     FD_ZERO(&fds);
1325     FD_SET(pwm->fd, &fds);
1326 #ifdef WITH_LIBPTH
1327     n = pth_select(pwm->fd+1, &fds, NULL, NULL, &tv);
1328 #else
1329     n = select(pwm->fd+1, &fds, NULL, NULL, &tv);
1330 #endif
1331
1332     if (n == -1) {
1333         *rc = gpg_error_from_syserror();
1334         return reset_async(pwm, 0);
1335     }
1336
1337     if (n > 0) {
1338         if (FD_ISSET(pwm->fd, &fds))
1339             *rc = parse_assuan_line(pwm);
1340     }
1341
1342     while (!*rc && assuan_pending_line(pwm->ctx))
1343         *rc = parse_assuan_line(pwm);
1344
1345     /* For pinentry retries. */
1346     if (pwm->cmd == ASYNC_CMD_OPEN &&
1347             gpg_err_code(*rc) == GPG_ERR_INV_PASSPHRASE &&
1348             ++pwm->pin_try < pwm->pinentry_tries) {
1349         pwm->state = ASYNC_INIT;
1350         *rc = pwmd_open_async(pwm, pwm->filename);
1351     }
1352
1353     if (*rc)
1354         return reset_async(pwm, pwm->cmd == ASYNC_CMD_OPEN ? 1 : 0);
1355
1356     if (pwm->state == ASYNC_DONE) {
1357         reset_async(pwm, 0);
1358         return ASYNC_DONE;
1359     }
1360
1361     return pwm->state;
1362 }
1363
1364 static gpg_error_t assuan_command(pwm_t *pwm, assuan_context_t ctx,
1365         char **result, const char *cmd)
1366 {
1367     membuf_t data;
1368     gpg_error_t rc;
1369
1370     data.len = 0;
1371     data.buf = NULL;
1372
1373     rc = assuan_transact(ctx, cmd, mem_realloc_cb, &data, _inquire_cb, pwm,
1374             pwm->status_func, pwm->status_data);
1375
1376     if (rc) {
1377         if (data.buf) {
1378             pwmd_free(data.buf);
1379             data.buf = NULL;
1380         }
1381     }
1382     else {
1383         if (data.buf) {
1384             mem_realloc_cb(&data, "", 1);
1385
1386             if (!result) {
1387                 pwmd_free(data.buf);
1388                 rc = GPG_ERR_INV_ARG;
1389             }
1390             else
1391                 *result = (char *)data.buf;
1392         }
1393     }
1394
1395     return gpg_err_code(rc);
1396 }
1397
1398 gpg_error_t pwmd_inquire(pwm_t *pwm, const char *cmd, pwmd_inquire_cb_t fn,
1399         void *data)
1400 {
1401     if (!pwm || !cmd || !fn)
1402         return GPG_ERR_INV_ARG;
1403
1404     if (!pwm->ctx)
1405         return GPG_ERR_INV_STATE;
1406
1407     pwm->inquire_func = fn;
1408     pwm->inquire_data = data;
1409     return assuan_command(pwm, pwm->ctx, NULL, cmd);
1410 }
1411
1412 #ifdef WITH_PINENTRY
1413 static gpg_error_t terminate_pinentry(pwm_t *pwm)
1414 {
1415     pid_t pid = pwm->pid;
1416
1417     pwm->pid = -1;
1418
1419     if (!pwm || pid == -1)
1420         return GPG_ERR_INV_ARG;
1421
1422     if (kill(pid, 0) == 0) {
1423         if (kill(pid, SIGTERM) == -1) {
1424             if (kill(pid, SIGKILL) == -1)
1425                 return gpg_error_from_errno(errno);
1426         }
1427     }
1428     else
1429         return gpg_error_from_errno(errno);
1430
1431     return 0;
1432 }
1433
1434 static gpg_error_t set_pinentry_strings(pwm_t *pwm, int which)
1435 {
1436     char *tmp, *desc;
1437     gpg_error_t error;
1438
1439     tmp = pwmd_malloc(ASSUAN_LINELENGTH+1);
1440
1441     if (!tmp)
1442         return gpg_error_from_errno(ENOMEM);
1443
1444     if (!pwm->title)
1445         pwm->title = pwmd_strdup(N_("Password Manager Daemon"));
1446
1447     if (!pwm->title)
1448         goto fail_no_mem;
1449
1450     if (!pwm->prompt)
1451         pwm->prompt = pwmd_strdup(N_("Passphrase:"));
1452
1453     if (!pwm->prompt)
1454         goto fail_no_mem;
1455
1456     if (!pwm->desc && (which == PINENTRY_OPEN || which == PINENTRY_SAVE)) {
1457         if (which == PINENTRY_OPEN)
1458             desc = pwmd_strdup_printf(N_("A passphrase is required to open the file \"%s\". Please%%0Aenter the passphrase below."), pwm->filename);
1459         else
1460             desc = pwmd_strdup_printf(N_("A passphrase is required to save to the file \"%s\". Please%%0Aenter the passphrase below."), pwm->filename);
1461
1462         if (!desc)
1463             goto fail_no_mem;
1464     }
1465
1466     if (pwm->desc)
1467         desc = pwm->desc;
1468
1469     switch (which) {
1470         case PINENTRY_OPEN:
1471         case PINENTRY_SAVE:
1472             snprintf(tmp, ASSUAN_LINELENGTH, "SETERROR %s", desc);
1473
1474             if (pwm->desc != desc)
1475                 pwmd_free(desc);
1476             break;
1477         case PINENTRY_OPEN_FAILED:
1478             snprintf(tmp, ASSUAN_LINELENGTH, "SETERROR %s",
1479                     N_("Invalid passphrase, please try again."));
1480             break;
1481         case PINENTRY_SAVE_CONFIRM:
1482             snprintf(tmp, ASSUAN_LINELENGTH, "SETERROR %s",
1483                     N_("Please type the passphrase again for confirmation."));
1484             break;
1485     }
1486
1487     error = pinentry_command(pwm, NULL, tmp);
1488
1489     if (error) {
1490         pwmd_free(tmp);
1491         return error;
1492     }
1493
1494     snprintf(tmp, ASSUAN_LINELENGTH, "SETPROMPT %s", pwm->prompt);
1495     error = pinentry_command(pwm, NULL, tmp);
1496
1497     if (error) {
1498         pwmd_free(tmp);
1499         return error;
1500     }
1501
1502     snprintf(tmp, ASSUAN_LINELENGTH, "SETDESC %s", pwm->title);
1503     error = pinentry_command(pwm, NULL, tmp);
1504     pwmd_free(tmp);
1505     return error;
1506
1507 fail_no_mem:
1508     pwmd_free(tmp);
1509     return gpg_error_from_errno(ENOMEM);
1510 }
1511
1512 static void update_pinentry_settings(pwm_t *pwm)
1513 {
1514     FILE *fp;
1515     char buf[LINE_MAX];
1516     char *p;
1517     struct passwd pw;
1518     char *pwbuf = _getpwuid(&pw);
1519
1520     if (!pwbuf)
1521         return;
1522
1523     snprintf(buf, sizeof(buf), "%s/.pwmd/pinentry.conf", pw.pw_dir);
1524     pwmd_free(pwbuf);
1525
1526     if ((fp = fopen(buf, "r")) == NULL)
1527         return;
1528
1529     while ((p = fgets(buf, sizeof(buf), fp)) != NULL) {
1530         char name[32], val[256];
1531
1532         if (sscanf(p, " %31[a-zA-Z] = %255s", name, val) != 2)
1533             continue;
1534
1535         if (strcasecmp(name, "TTYNAME") == 0) {
1536             pwmd_free(pwm->pinentry_tty);
1537             pwm->pinentry_tty = pwmd_strdup(val);
1538         }
1539         else if (strcasecmp(name, "TTYTYPE") == 0) {
1540             pwmd_free(pwm->pinentry_term);
1541             pwm->pinentry_term = pwmd_strdup(val);
1542         }
1543         else if (strcasecmp(name, "DISPLAY") == 0) {
1544             pwmd_free(pwm->pinentry_display);
1545             pwm->pinentry_display = pwmd_strdup(val);
1546         }
1547         else if (strcasecmp(name, "PATH") == 0) {
1548             pwmd_free(pwm->pinentry_path);
1549             pwm->pinentry_path = pwmd_strdup(val);
1550         }
1551     }
1552
1553     fclose(fp);
1554 }
1555
1556 static gpg_error_t launch_pinentry(pwm_t *pwm)
1557 {
1558     int rc;
1559     assuan_context_t ctx;
1560     int child_list[] = {-1};
1561     char *display = getenv("DISPLAY");
1562     const char *argv[10];
1563     const char **p = argv;
1564     int have_display = 0;
1565     char *tty = NULL;
1566     char *ttybuf = NULL;
1567
1568     update_pinentry_settings(pwm);
1569
1570     if (pwm->pinentry_display || display)
1571         have_display = 1;
1572     else {
1573         if (!pwm->pinentry_tty) {
1574             ttybuf = pwmd_malloc(255);
1575
1576             if (!ttybuf)
1577                 return gpg_error_from_errno(ENOMEM);
1578
1579             rc = ttyname_r(STDOUT_FILENO, ttybuf, 255);
1580
1581             if (rc) {
1582                 pwmd_free(ttybuf);
1583                 return gpg_error_from_errno(rc);
1584             }
1585
1586             tty = ttybuf;
1587         }
1588         else
1589             tty = pwm->pinentry_tty;
1590     }
1591
1592     if (!have_display && !tty)
1593         return GPG_ERR_ENOTTY;
1594
1595     *p++ = "pinentry";
1596     *p++ = have_display ? "--display" : "--ttyname";
1597     *p++ = have_display ? pwm->pinentry_display ? pwm->pinentry_display : display : tty;
1598
1599     if (pwm->lcctype) {
1600         *p++ = "--lc-ctype";
1601         *p++ = pwm->lcctype;
1602     }
1603
1604     if (pwm->lcmessages) {
1605         *p++ = "--lc-messages";
1606         *p++ = pwm->lcmessages;
1607     }
1608
1609     *p = NULL;
1610
1611     if (!have_display) {
1612         *p++ = "--ttytype";
1613         *p++ = pwm->pinentry_term ? pwm->pinentry_term : getenv("TERM");
1614         *p = NULL;
1615     }
1616
1617     rc = assuan_pipe_connect(&ctx, pwm->pinentry_path ? pwm->pinentry_path : PINENTRY_PATH, argv, child_list);
1618
1619     if (ttybuf)
1620         pwmd_free(ttybuf);
1621
1622     if (rc)
1623         return rc;
1624
1625     pwm->pid = assuan_get_pid(ctx);
1626     pwm->pctx = ctx;
1627     return set_pinentry_strings(pwm, 0);
1628 }
1629
1630 static gpg_error_t pinentry_command(pwm_t *pwm, char **result, const char *cmd)
1631 {
1632     gpg_error_t n;
1633
1634     if (!pwm->pctx) {
1635         n = launch_pinentry(pwm);
1636
1637         if (n)
1638             return n;
1639     }
1640
1641     return assuan_command(pwm, pwm->pctx, result, cmd);
1642 }
1643
1644 static void pinentry_disconnect(pwm_t *pwm)
1645 {
1646     if (pwm->pctx)
1647         assuan_disconnect(pwm->pctx);
1648
1649     pwm->pctx = NULL;
1650     pwm->pid = -1;
1651 }
1652
1653 /*
1654  * Only called from a child process.
1655  */
1656 static void catchsig(int sig)
1657 {
1658     switch (sig) {
1659         case SIGALRM:
1660             if (gelapsed++ >= gtimeout) {
1661                 terminate_pinentry(gpwm);
1662                 gerror = GPG_ERR_TIMEOUT;
1663             }
1664             else
1665                 alarm(1);
1666             break;
1667         default:
1668             break;
1669     }
1670 }
1671 #endif
1672
1673 /*
1674  * Borrowed from libassuan.
1675  */
1676 static char *percent_escape(const char *atext)
1677 {
1678     const unsigned char *s;
1679     int len = strlen(atext) * 3 + 1;
1680     char *buf = (char *)pwmd_malloc(len), *p = buf;
1681
1682     if (!buf)
1683         return NULL;
1684
1685     for (s=(const unsigned char *)atext; *s; s++) {
1686         if (*s < ' ') {
1687             sprintf (p, "%%%02X", *s);
1688             p += 3;
1689         }
1690         else
1691             *p++ = *s;
1692     }
1693
1694     *p = 0;
1695     return buf;
1696 }
1697
1698 static gpg_error_t send_command(pwm_t *pwm, char **result, const char *cmd)
1699 {
1700     if (!cmd)
1701         return GPG_ERR_INV_ARG;
1702
1703     return assuan_command(pwm, pwm->ctx, result, cmd);
1704 }
1705
1706 gpg_error_t pwmd_command_ap(pwm_t *pwm, char **result, const char *cmd,
1707         va_list ap)
1708 {
1709     char *buf;
1710     size_t len;
1711     gpg_error_t error;
1712     va_list ap2;
1713
1714     if (!pwm || !cmd)
1715         return GPG_ERR_INV_ARG;
1716
1717     if (!pwm->ctx)
1718         return GPG_ERR_INV_STATE;
1719
1720     /*
1721      * C99 allows the dst pointer to be null which will calculate the length
1722      * of the would-be result and return it.
1723      */
1724     va_copy(ap2, ap);
1725     len = vsnprintf(NULL, 0, cmd, ap)+1;
1726     buf = (char *)pwmd_malloc(len);
1727
1728     if (!buf) {
1729         va_end(ap2);
1730         return gpg_error_from_errno(ENOMEM);
1731     }
1732
1733     len = vsnprintf(buf, len, cmd, ap2);
1734     va_end(ap2);
1735
1736     if (buf[strlen(buf)-1] == '\n')
1737         buf[strlen(buf)-1] = 0;
1738
1739     if (buf[strlen(buf)-1] == '\r')
1740         buf[strlen(buf)-1] = 0;
1741
1742     error = send_command(pwm, result, buf);
1743     pwmd_free(buf);
1744     return error;
1745 }
1746
1747 gpg_error_t pwmd_command(pwm_t *pwm, char **result, const char *cmd, ...)
1748 {
1749     va_list ap;
1750     gpg_error_t error;
1751
1752     if (!pwm || !cmd)
1753         return GPG_ERR_INV_ARG;
1754
1755     if (!pwm->ctx)
1756         return GPG_ERR_INV_STATE;
1757
1758     if (result)
1759         *result = NULL;
1760
1761     va_start(ap, cmd);
1762     error = pwmd_command_ap(pwm, result, cmd, ap);
1763     va_end(ap);
1764     return error;
1765 }
1766
1767 #ifdef WITH_PINENTRY
1768 static gpg_error_t do_getpin(pwm_t *pwm, char **result)
1769 {
1770     if (gtimeout) {
1771         signal(SIGALRM, catchsig);
1772         alarm(1);
1773     }
1774
1775     *result = NULL;
1776     return pinentry_command(pwm, result, "GETPIN");
1777 }
1778
1779 static gpg_error_t getpin(pwm_t *pwm, char **result, int which)
1780 {
1781     gpg_error_t rc;
1782
1783     gerror = 0;
1784     rc = set_pinentry_strings(pwm, which);
1785
1786     if (rc) {
1787         pinentry_disconnect(pwm);
1788         return rc;
1789     }
1790
1791     rc = do_getpin(pwm, result);
1792
1793     /*
1794      * Since there was input cancel any timeout setting.
1795      */
1796     alarm(0);
1797     signal(SIGALRM, SIG_DFL);
1798
1799     if (rc) {
1800         if (pwm->pctx)
1801             pinentry_disconnect(pwm);
1802
1803         /* This lets pwmd_open2() with PWMD_OPTION_PINENTRY_TIMEOUT work. */
1804         if (rc== GPG_ERR_EOF && gerror == GPG_ERR_TIMEOUT)
1805             return gerror;
1806
1807         return rc;
1808     }
1809
1810     return 0;
1811 }
1812 #endif
1813
1814 static gpg_error_t do_open_command(pwm_t *pwm, const char *filename, char *password)
1815 {
1816     char *buf;
1817     gpg_error_t error;
1818     char *result = NULL;
1819
1820     buf = pwmd_malloc(ASSUAN_LINELENGTH+1);
1821
1822     if (!buf)
1823         return gpg_error_from_errno(ENOMEM);
1824
1825     snprintf(buf, ASSUAN_LINELENGTH, "OPEN %s %s", filename,
1826             password ? password : "");
1827     error = send_command(pwm, &result, buf);
1828     pwmd_free(buf);
1829
1830     if (error && result)
1831         pwmd_free(result);
1832
1833     return error;
1834 }
1835
1836 static gpg_error_t send_pinentry_options(pwm_t *pwm)
1837 {
1838     gpg_error_t rc;
1839
1840     if (pwm->pinentry_path) {
1841         rc = pwmd_command(pwm, NULL, "OPTION PATH=%s", pwm->pinentry_path);
1842
1843         if (rc)
1844             return rc;
1845     }
1846
1847     if (pwm->pinentry_tty) {
1848         rc = pwmd_command(pwm, NULL, "OPTION TTYNAME=%s", pwm->pinentry_tty);
1849
1850         if (rc)
1851             return rc;
1852     }
1853
1854     if (pwm->pinentry_term) {
1855         rc = pwmd_command(pwm, NULL, "OPTION TTYTYPE=%s", pwm->pinentry_term);
1856
1857         if (rc)
1858             return rc;
1859     }
1860
1861     if (pwm->pinentry_display) {
1862         rc = pwmd_command(pwm, NULL, "OPTION TITLE=%s", pwm->pinentry_display);
1863
1864         if (rc)
1865             return rc;
1866     }
1867
1868     if (pwm->title) {
1869         rc = pwmd_command(pwm, NULL, "OPTION TITLE=%s", pwm->title);
1870
1871         if (rc)
1872             return rc;
1873     }
1874
1875     if (pwm->desc) {
1876         rc = pwmd_command(pwm, NULL, "OPTION DESC=%s", pwm->desc);
1877
1878         if (rc)
1879             return rc;
1880     }
1881
1882     if (pwm->prompt) {
1883         rc = pwmd_command(pwm, NULL, "OPTION PROMPT=%s", pwm->prompt);
1884
1885         if (rc)
1886             return rc;
1887     }
1888
1889     if (pwm->lcctype) {
1890         rc = pwmd_command(pwm, NULL, "OPTION LC_CTYPE=%s", pwm->lcctype);
1891
1892         if (rc)
1893             return rc;
1894     }
1895
1896     if (pwm->lcmessages) {
1897         rc = pwmd_command(pwm, NULL, "OPTION LC_MESSAGES=%s", pwm->lcmessages);
1898
1899         if (rc)
1900             return rc;
1901     }
1902
1903     if (pwm->pinentry_timeout >= 0) {
1904         rc = pwmd_command(pwm, NULL, "OPTION TIMEOUT=%i", pwm->pinentry_timeout);
1905
1906         if (rc)
1907             return rc;
1908     }
1909
1910     return 0;
1911 }
1912
1913 static gpg_error_t do_pwmd_open(pwm_t *pwm, const char *filename, int nb,
1914         int local_pinentry)
1915 {
1916     char *result = NULL;
1917     char *password = NULL;
1918     char *path;
1919     int pin_try;
1920     gpg_error_t rc;
1921     size_t len;
1922
1923     if (!pwm || !filename || !*filename)
1924         return GPG_ERR_INV_ARG;
1925
1926     if (!pwm->ctx)
1927         return GPG_ERR_INV_STATE;
1928
1929     pin_try = pwm->pinentry_tries - 1;
1930
1931     /*
1932      * Avoid calling pinentry if the password is cached on the server or if
1933      * this is a new file. pwmd version 2 adds a VERSION command which is
1934      * determined in _socket_connect_finalize(). If the server is version 2,
1935      * ISCACHED can determine if a file exists.
1936      */
1937 #ifdef WITH_TCP
1938     if (!pwm->tcp_conn && pwm->version == PWMD_V1) {
1939 #else
1940     if (pwm->version == PWMD_V1) {
1941 #endif
1942         rc = pwmd_command(pwm, &result, "GETCONFIG data_directory");
1943
1944         if (rc)
1945             return rc;
1946
1947         len = strlen(result)+strlen(filename)+2;
1948         path = pwmd_malloc(len);
1949
1950         if (!path) {
1951             pwmd_free(result);
1952             return gpg_error_from_errno(ENOMEM);
1953         }
1954
1955         snprintf(path, len, "%s/%s", result, filename);
1956         pwmd_free(result);
1957
1958         if (access(path, R_OK) == -1) {
1959             if (errno == ENOENT) {
1960                 pwmd_free(path);
1961                 goto gotpassword;
1962             }
1963         }
1964
1965         pwmd_free(path);
1966     }
1967
1968     rc = pwmd_command(pwm, &result, "ISCACHED %s", filename);
1969
1970     if (gpg_err_code(rc) == GPG_ERR_ENOENT)
1971         goto gotpassword;
1972
1973     if (rc && rc != GPG_ERR_NOT_FOUND)
1974         return rc;
1975
1976     if (!nb && rc == GPG_ERR_NOT_FOUND) {
1977         if (pwm->password) {
1978             password = pwm->password;
1979             goto gotpassword;
1980         }
1981
1982         if (pwm->passfunc) {
1983             rc = pwm->passfunc(pwm->passdata, &password);
1984
1985             if (rc)
1986                 return rc;
1987
1988             goto gotpassword;
1989         }
1990     }
1991
1992 #ifdef WITH_PINENTRY
1993     if (rc == GPG_ERR_NOT_FOUND && local_pinentry) {
1994         rc = pwmd_command(pwm, NULL, "OPTION PINENTRY=0");
1995
1996         if (rc)
1997             return rc;
1998
1999         if (!pwm->filename)
2000             pwm->filename = pwmd_strdup(filename);
2001
2002         if (!pwm->filename)
2003             return gpg_error_from_errno(ENOMEM);
2004
2005         /* Get the passphrase using the LOCAL pinentry. */
2006         if (nb) {
2007             int p[2];
2008             pid_t pid;
2009             pwmd_nb_status_t pw;
2010
2011             if (pipe(p) == -1)
2012                 return gpg_error_from_syserror();
2013
2014 #ifdef WITH_LIBPTH
2015             pid = pth_fork();
2016 #else
2017             pid = fork();
2018 #endif
2019
2020             switch (pid) {
2021                 case 0:
2022                     close(p[0]);
2023                     pw.fd = p[0];
2024
2025                     if (pwm->pinentry_timeout != 0) {
2026                         gpwm = pwm;
2027                         gtimeout = abs(pwm->pinentry_timeout);
2028                         gelapsed = 0;
2029                     }
2030
2031                     pw.error = getpin(pwm, &password, PINENTRY_OPEN);
2032
2033                     if (gtimeout && gelapsed >= gtimeout)
2034                         pw.error = GPG_ERR_TIMEOUT;
2035
2036                     if (!pw.error)
2037                         snprintf(pw.password, sizeof(pw.password), "%s",
2038                                 password);
2039
2040                     pinentry_disconnect(pwm);
2041 #ifdef WITH_LIBPTH
2042                     pth_write(p[1], &pw, sizeof(pw));
2043 #else
2044                     write(p[1], &pw, sizeof(pw));
2045 #endif
2046                     memset(&pw, 0, sizeof(pw));
2047                     close(p[1]);
2048                     _exit(0);
2049                     break;
2050                 case -1:
2051                     rc = gpg_error_from_syserror();
2052                     close(p[0]);
2053                     close(p[1]);
2054                     return rc;
2055                 default:
2056                     break;
2057             }
2058
2059             close(p[1]);
2060             pwm->nb_fd = p[0];
2061             pwm->nb_pid = pid;
2062             return 0;
2063         }
2064
2065         if (pwm->pinentry_timeout != 0) {
2066             gpwm = pwm;
2067             gtimeout = abs(pwm->pinentry_timeout);
2068             gelapsed = 0;
2069         }
2070
2071         rc = getpin(pwm, &password, PINENTRY_OPEN);
2072
2073         /* Don't timeout when an invalid passphrase was entered. */
2074         gtimeout = 0;
2075
2076         if (rc)
2077             return rc;
2078     }
2079 #endif
2080
2081 gotpassword:
2082     pwm->state = ASYNC_DONE;
2083
2084     if (!local_pinentry) {
2085         rc = send_pinentry_options(pwm);
2086
2087         if (rc)
2088             return rc;
2089     }
2090
2091     rc = do_open_command(pwm, filename, password);
2092
2093     /*
2094      * Keep the user defined password set with pwmd_setopt(). The password may
2095      * be needed later (pwmd_save()) depending on the pwmd file cache settings.
2096      */
2097     if (!pwm->passfunc && password && password != pwm->password)
2098         pwmd_free(password);
2099
2100     if (rc == GPG_ERR_INV_PASSPHRASE) {
2101         if (pin_try-- > 0 && !nb) {
2102
2103 #ifdef WITH_PINENTRY
2104             if (local_pinentry)
2105                 rc = getpin(pwm, &password, PINENTRY_OPEN_FAILED);
2106             else
2107 #endif
2108                 rc = pwmd_command(pwm, &result, "OPTION TITLE=%s",
2109                         N_("Invalid passphrase, please try again."));
2110
2111             if (rc)
2112                 return rc;
2113
2114             goto gotpassword;
2115         }
2116
2117 #ifdef WITH_PINENTRY
2118         if (nb)
2119             pinentry_disconnect(pwm);
2120 #endif
2121
2122         return rc;
2123     }
2124
2125     if (!rc) {
2126         if (pwm->filename)
2127             pwmd_free(pwm->filename);
2128
2129         pwm->filename = pwmd_strdup(filename);
2130     }
2131
2132     return rc;
2133 }
2134
2135 gpg_error_t pwmd_open2(pwm_t *pwm, const char *filename)
2136 {
2137 #ifndef WITH_PINENTRY
2138     return GPG_ERR_NOT_IMPLEMENTED;
2139 #else
2140     return do_pwmd_open(pwm, filename, 0, 1);
2141 #endif
2142 }
2143
2144 gpg_error_t pwmd_open(pwm_t *pwm, const char *filename)
2145 {
2146     return do_pwmd_open(pwm, filename, 0, 0);
2147 }
2148
2149 gpg_error_t pwmd_open_async2(pwm_t *pwm, const char *filename)
2150 {
2151 #ifndef WITH_PINENTRY
2152     return GPG_ERR_NOT_IMPLEMENTED;
2153 #else
2154     gpg_error_t rc;
2155
2156     if (!pwm || !filename)
2157         return GPG_ERR_INV_ARG;
2158
2159     if (!pwm->ctx)
2160         return GPG_ERR_INV_STATE;
2161
2162     if (pwm->cmd != ASYNC_CMD_OPEN2)
2163         pwm->pin_try = 0;
2164
2165     pwm->cmd = ASYNC_CMD_OPEN2;
2166     pwm->state = ASYNC_PROCESS;
2167     rc = do_pwmd_open(pwm, filename, 1, 1);
2168
2169     if (rc)
2170         reset_async(pwm, 1);
2171
2172     return rc;
2173 #endif
2174 }
2175
2176 #ifdef WITH_PINENTRY
2177 static gpg_error_t do_save_getpin(pwm_t *pwm, char **password)
2178 {
2179     int confirm = 0;
2180     gpg_error_t error;
2181     char *result = NULL;
2182
2183 again:
2184     error = getpin(pwm, &result, confirm ? PINENTRY_SAVE_CONFIRM : PINENTRY_SAVE);
2185
2186     if (error) {
2187         if (pwm->pctx)
2188             pinentry_disconnect(pwm);
2189
2190         if (*password)
2191             pwmd_free(*password);
2192
2193         return error;
2194     }
2195
2196     if (!confirm++) {
2197         *password = result;
2198         goto again;
2199     }
2200
2201     if (strcmp(*password, result)) {
2202         pwmd_free(*password);
2203         pwmd_free(result);
2204         confirm = 0;
2205         *password = NULL;
2206         goto again;
2207     }
2208
2209     pwmd_free(result);
2210     pinentry_disconnect(pwm);
2211     return 0;
2212 }
2213 #endif
2214
2215 static gpg_error_t do_save_command(pwm_t *pwm, char *password)
2216 {
2217     char *buf;
2218     gpg_error_t error;
2219     char *result = NULL;
2220
2221     buf = pwmd_malloc(ASSUAN_LINELENGTH+1);
2222
2223     if (!buf)
2224         return gpg_error_from_errno(ENOMEM);
2225
2226     snprintf(buf, ASSUAN_LINELENGTH, "SAVE %s", password ? password : "");
2227     error = send_command(pwm, &result, buf);
2228     pwmd_free(buf);
2229
2230     if (error && result)
2231         pwmd_free(result);
2232
2233     return error;
2234 }
2235
2236 static gpg_error_t do_pwmd_save(pwm_t *pwm, int nb, int local_pinentry)
2237 {
2238     char *result = NULL;
2239     char *password = NULL;
2240     gpg_error_t rc;
2241
2242     if (!pwm)
2243         return GPG_ERR_INV_ARG;
2244
2245     if (!pwm->ctx)
2246         return GPG_ERR_INV_STATE;
2247
2248     rc = pwmd_command(pwm, &result, "ISCACHED %s", pwm->filename);
2249
2250     if (rc && rc != GPG_ERR_NOT_FOUND)
2251         return rc;
2252
2253     if (!nb && rc == GPG_ERR_NOT_FOUND) {
2254         if (pwm->password) {
2255             password = pwm->password;
2256             goto gotpassword;
2257         }
2258
2259         if (pwm->passfunc) {
2260             rc = pwm->passfunc(pwm->passdata, &password);
2261
2262             if (rc)
2263                 return rc;
2264
2265             goto gotpassword;
2266         }
2267     }
2268
2269     if (rc == GPG_ERR_NOT_FOUND && local_pinentry) {
2270 #ifdef WITH_PINENTRY
2271         /* Get the password using the LOCAL pinentry. */
2272         if (nb) {
2273             int p[2];
2274             pid_t pid;
2275             pwmd_nb_status_t pw;
2276
2277             if (pipe(p) == -1)
2278                 return gpg_error_from_syserror();
2279
2280 #ifdef WITH_LIBPTH
2281             pid = pth_fork();
2282 #else
2283             pid = fork();
2284 #endif
2285
2286             switch (pid) {
2287                 case 0:
2288                     close(p[0]);
2289                     pw.fd = p[0];
2290                     password = NULL;
2291                     pw.error = do_save_getpin(pwm, &password);
2292                     pinentry_disconnect(pwm);
2293                     snprintf(pw.password, sizeof(pw.password), "%s",
2294                             password);
2295 #ifdef WITH_LIBPTH
2296                     pth_write(p[1], &pw, sizeof(pw));
2297 #else
2298                     write(p[1], &pw, sizeof(pw));
2299 #endif
2300                     memset(&pw, 0, sizeof(pw));
2301                     close(p[1]);
2302                     _exit(0);
2303                     break;
2304                 case -1:
2305                     rc = gpg_error_from_syserror();
2306                     close(p[0]);
2307                     close(p[1]);
2308                     return rc;
2309                 default:
2310                     break;
2311             }
2312
2313             close(p[1]);
2314             pwm->nb_fd = p[0];
2315             pwm->nb_pid = pid;
2316             return 0;
2317         }
2318
2319         rc = do_save_getpin(pwm, &password);
2320
2321         if (rc)
2322             return rc;
2323 #endif
2324     }
2325     else
2326         pwm->state = ASYNC_DONE;
2327
2328 gotpassword:
2329     if (!local_pinentry) {
2330         rc = send_pinentry_options(pwm);
2331
2332         if (rc)
2333             return rc;
2334     }
2335
2336     rc = do_save_command(pwm, password);
2337
2338     if (!pwm->passfunc && password && password != pwm->password)
2339         pwmd_free(password);
2340
2341     return rc;
2342 }
2343
2344 gpg_error_t pwmd_save_async2(pwm_t *pwm)
2345 {
2346 #ifndef WITH_PINENTRY
2347     return GPG_ERR_NOT_IMPLEMENTED;
2348 #else
2349     gpg_error_t rc;
2350
2351     if (!pwm)
2352         return GPG_ERR_INV_ARG;
2353
2354     if (!pwm->ctx)
2355         return GPG_ERR_INV_STATE;
2356
2357     pwm->cmd = ASYNC_CMD_SAVE2;
2358     pwm->state = ASYNC_PROCESS;
2359     rc = do_pwmd_save(pwm, 1, 1);
2360
2361     if (rc)
2362         reset_async(pwm, 0);
2363
2364     return rc;
2365 #endif
2366 }
2367
2368 gpg_error_t pwmd_save2(pwm_t *pwm)
2369 {
2370 #ifndef WITH_PINENTRY
2371     return GPG_ERR_NOT_IMPLEMENTED;
2372 #else
2373     return do_pwmd_save(pwm, 0, 1);
2374 #endif
2375 }
2376
2377 gpg_error_t pwmd_save(pwm_t *pwm)
2378 {
2379     return do_pwmd_save(pwm, 0, 0);
2380 }
2381
2382 gpg_error_t pwmd_setopt(pwm_t *pwm, pwmd_option_t opt, ...)
2383 {
2384     va_list ap;
2385     int n = va_arg(ap, int);
2386     char *arg1;
2387     gpg_error_t error = 0;
2388
2389     if (!pwm)
2390         return GPG_ERR_INV_ARG;
2391
2392     va_start(ap, opt);
2393
2394     switch (opt) {
2395         case PWMD_OPTION_STATUS_CB:
2396             pwm->status_func = va_arg(ap, pwmd_status_cb_t);
2397             break;
2398         case PWMD_OPTION_STATUS_DATA:
2399             pwm->status_data = va_arg(ap, void *);
2400             break;
2401         case PWMD_OPTION_PASSPHRASE_CB:
2402             pwm->passfunc = va_arg(ap, pwmd_passphrase_cb_t);
2403             break;
2404         case PWMD_OPTION_PASSPHRASE_DATA:
2405             pwm->passdata = va_arg(ap, void *);
2406             break;
2407         case PWMD_OPTION_PASSPHRASE:
2408             arg1 = va_arg(ap, char *);
2409
2410             if (pwm->password)
2411                 pwmd_free(pwm->password);
2412
2413             pwm->password = pwmd_strdup(arg1);
2414             break;
2415         case PWMD_OPTION_PINENTRY_TRIES:
2416             n = va_arg(ap, int);
2417
2418             if (n <= 0) {
2419                 va_end(ap);
2420                 error = GPG_ERR_INV_VALUE;
2421             }
2422             else
2423                 pwm->pinentry_tries = n;
2424             break;
2425         case PWMD_OPTION_PINENTRY_TIMEOUT:
2426             n = va_arg(ap, int);
2427
2428             if (n < 0) {
2429                 va_end(ap);
2430                 error = GPG_ERR_INV_VALUE;
2431             }
2432             else
2433                 pwm->pinentry_timeout = n;
2434             break;
2435         case PWMD_OPTION_PINENTRY_PATH:
2436             if (pwm->pinentry_path)
2437                 pwmd_free(pwm->pinentry_path);
2438
2439             pwm->pinentry_path = pwmd_strdup(va_arg(ap, char *));
2440             break;
2441         case PWMD_OPTION_PINENTRY_TTY:
2442             if (pwm->pinentry_tty)
2443                 pwmd_free(pwm->pinentry_tty);
2444
2445             pwm->pinentry_tty = pwmd_strdup(va_arg(ap, char *));
2446             break;
2447         case PWMD_OPTION_PINENTRY_DISPLAY:
2448             if (pwm->pinentry_display)
2449                 pwmd_free(pwm->pinentry_display);
2450
2451             pwm->pinentry_display = pwmd_strdup(va_arg(ap, char *));
2452             break;
2453         case PWMD_OPTION_PINENTRY_TERM:
2454             if (pwm->pinentry_term)
2455                 pwmd_free(pwm->pinentry_term);
2456
2457             pwm->pinentry_term = pwmd_strdup(va_arg(ap, char *));
2458             break;
2459         case PWMD_OPTION_PINENTRY_TITLE:
2460             if (pwm->title)
2461                 pwmd_free(pwm->title);
2462
2463             pwm->title = percent_escape(va_arg(ap, char *));
2464             break;
2465         case PWMD_OPTION_PINENTRY_PROMPT:
2466             if (pwm->prompt)
2467                 pwmd_free(pwm->prompt);
2468
2469             pwm->prompt = percent_escape(va_arg(ap, char *));
2470             break;
2471         case PWMD_OPTION_PINENTRY_DESC:
2472             if (pwm->desc)
2473                 pwmd_free(pwm->desc);
2474
2475             pwm->desc = percent_escape(va_arg(ap, char *));
2476             break;
2477         case PWMD_OPTION_PINENTRY_LC_CTYPE:
2478             if (pwm->lcctype)
2479                 pwmd_free(pwm->lcctype);
2480
2481             pwm->lcctype = pwmd_strdup(va_arg(ap, char *));
2482             break;
2483         case PWMD_OPTION_PINENTRY_LC_MESSAGES:
2484             if (pwm->lcmessages)
2485                 pwmd_free(pwm->lcmessages);
2486
2487             pwm->lcmessages = pwmd_strdup(va_arg(ap, char *));
2488             break;
2489 #ifdef WITH_TCP
2490         case PWMD_OPTION_IP_VERSION:
2491             n = va_arg(ap, int);
2492
2493             switch (n) {
2494                 case PWMD_IP_ANY:
2495                 case PWMD_IPV4:
2496                 case PWMD_IPV6:
2497                     pwm->prot = n;
2498                     break;
2499                 default:
2500                     error = GPG_ERR_INV_VALUE;
2501                     break;
2502             }
2503
2504             va_end(ap);
2505             break;
2506 #endif
2507         default:
2508             error = GPG_ERR_NOT_IMPLEMENTED;
2509             break;
2510     }
2511
2512     va_end(ap);
2513     return error;
2514 }
2515
2516 gpg_error_t pwmd_get_fds(pwm_t *pwm, pwmd_fd_t *fds, int *n_fds)
2517 {
2518     int in_total;
2519     int fd = 0;
2520 #ifdef WITH_TCP
2521     int afds[ARES_GETSOCK_MAXNUM];
2522     int got_sock = 0;
2523     int n, i;
2524 #endif
2525
2526     if (!pwm || !fds || !n_fds || *n_fds <= 0)
2527         return GPG_ERR_INV_ARG;
2528
2529     in_total = *n_fds;
2530 #ifdef WITH_TCP
2531     memset(afds, 0, sizeof(int)*ARES_GETSOCK_MAXNUM);
2532 #endif
2533     memset(fds, 0, sizeof(pwmd_fd_t)*in_total);
2534     *n_fds = 0;
2535
2536     switch (pwm->cmd) {
2537         default:
2538         case ASYNC_CMD_NONE:
2539         case ASYNC_CMD_OPEN:
2540         case ASYNC_CMD_SAVE:
2541 #ifdef WITH_PINENTRY
2542 async1:
2543 #endif
2544             if (pwm->fd == -1)
2545                 return GPG_ERR_INV_STATE;
2546
2547             (*n_fds)++;
2548             fds[fd].fd = pwm->fd;
2549             fds[fd++].flags = PWMD_FD_READABLE;
2550             return 0;
2551 #ifdef WITH_PINENTRY
2552         case ASYNC_CMD_OPEN2:
2553         case ASYNC_CMD_SAVE2:
2554             if (pwm->nb_fd == -1)
2555                 return GPG_ERR_INV_STATE;
2556
2557             (*n_fds)++;
2558             fds[fd].fd = pwm->nb_fd;
2559             fds[fd++].flags = PWMD_FD_READABLE;
2560             goto async1;
2561 #endif
2562 #ifdef WITH_TCP
2563         case ASYNC_CMD_DNS:
2564             if (!pwm->tcp_conn || !pwm->tcp_conn->chan)
2565                 return GPG_ERR_INV_STATE;
2566
2567             n = ares_getsock(pwm->tcp_conn->chan, afds, ARES_GETSOCK_MAXNUM);
2568
2569             for (i = 0; i < ARES_GETSOCK_MAXNUM; i++) {
2570                 got_sock = 0;
2571
2572                 if (fd > in_total) {
2573                     *n_fds = fd;
2574                     return GPG_ERR_ERANGE;
2575                 }
2576
2577                 if (ARES_GETSOCK_READABLE(n, i)) {
2578                     got_sock++;
2579                     fds[fd].flags |= PWMD_FD_READABLE;
2580                 }
2581
2582                 if (ARES_GETSOCK_WRITABLE(n, i)) {
2583                     got_sock++;
2584                     fds[fd].flags |= PWMD_FD_WRITABLE;
2585                 }
2586
2587                 if (got_sock)
2588                     fds[fd++].fd = afds[i];
2589             }
2590
2591             *n_fds = fd;
2592             return 0;
2593         case ASYNC_CMD_CONNECT:
2594         case ASYNC_CMD_HOSTKEY:
2595             if (!pwm->tcp_conn || pwm->tcp_conn->fd == -1)
2596                 return GPG_ERR_INV_STATE;
2597
2598             (*n_fds)++;
2599             fds[fd].fd = pwm->tcp_conn->fd;
2600             fds[fd++].flags = PWMD_FD_READABLE;
2601             return 0;
2602 #endif
2603     }
2604
2605     return GPG_ERR_INV_STATE;
2606 }
2607
2608 pwm_t *pwmd_new(const char *name)
2609 {
2610     pwm_t *h = pwmd_calloc(1, sizeof(pwm_t));
2611
2612     if (!h)
2613         return NULL;
2614
2615     if (name) {
2616         h->name = pwmd_strdup(name);
2617
2618         if (!h->name) {
2619             pwmd_free(h);
2620             return NULL;
2621         }
2622     }
2623
2624     h->fd = -1;
2625 #ifdef WITH_PINENTRY
2626     h->nb_fd = -1;
2627 #endif
2628     h->pinentry_timeout = -30;
2629     h->pinentry_tries = 3;
2630 #ifdef WITH_TCP
2631     h->prot = PWMD_IP_ANY;
2632 #endif
2633     return h;
2634 }
2635
2636 void pwmd_free(void *ptr)
2637 {
2638     xfree(ptr);
2639 }
2640
2641 void *pwmd_malloc(size_t size)
2642 {
2643     return xmalloc(size);
2644 }
2645
2646 void *pwmd_calloc(size_t nmemb, size_t size)
2647 {
2648     return xcalloc(nmemb, size);
2649 }
2650
2651 void *pwmd_realloc(void *ptr, size_t size)
2652 {
2653     return xrealloc(ptr, size);
2654 }
2655
2656 char *pwmd_strdup(const char *str)
2657 {
2658     return xstrdup(str);
2659 }
2660
2661 char *pwmd_strdup_printf(const char *fmt, ...)
2662 {
2663     va_list ap;
2664     int len;
2665     char *buf;
2666
2667     if (!fmt)
2668         return NULL;
2669
2670     va_start(ap, fmt);
2671     len = vsnprintf(NULL, 0, fmt, ap);
2672     buf = pwmd_malloc(++len);
2673
2674     if (!buf) {
2675         va_end(ap);
2676         return NULL;
2677     }
2678
2679     vsnprintf(buf, len, fmt, ap);
2680     va_end(ap);
2681     return buf;
2682 }