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