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