src/libpwmd.c

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