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