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