src/libpwmd.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006-2009 Ben Kibbey <bjk@luxsci.net>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02110-1301  USA
  18 */
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <err.h>
  23 #include <errno.h>
  24 #include <ctype.h>
  25 #include <string.h>
  26 #include <sys/socket.h>
  27 #include <sys/un.h>
  28 #include <signal.h>
  29 #include <stdarg.h>
  30 #include <string.h>
  31 #include <sys/wait.h>
  32 #include <fcntl.h>
  33 #include <pwd.h>
  34 #include <time.h>
  35 #include <sys/types.h>
  36 #include <limits.h>
  37 #include <sys/select.h>
  38 #include <netdb.h>
  39 #include <netinet/in.h>
  40 #include <sys/socket.h>
  41 #include <libpwmd.h>
  42
  43 #ifdef HAVE_CONFIG_H
  44 #include <config.h>
  45 #endif
  46
  47 #ifdef WITH_LIBPTH
  48 #include <pth.h>
  49 #endif
  50
  51 #ifdef WITH_TCP
  52 #define DNS_USE_GETTIMEOFDAY_FOR_ID 1
  53 #include <ares.h>
  54 #include <arpa/nameser.h>
  55 #endif
  56
  57 #ifdef HAVE_ASSUAN_H
  58 #include <assuan.h>
  59 #endif
  60
  61 #ifdef HAVE_SETLOCALE
  62 #include <locale.h>
  63 #endif
  64
  65 #include "gettext.h"
  66 #define N_(msgid)       dgettext("libpwmd", msgid)
  67
  68 #include "mem.h"
  69 #include "types.h"
  70
  71 #ifdef WITH_PINENTRY
  72 static pwm_t *gpwm;
  73 static int gelapsed, gtimeout;
  74 static gpg_error_t pinentry_command(pwm_t *pwm, char **result, const char *cmd);
  75 #endif
  76
  77 static char *_getpwuid(struct passwd *pwd)
  78 {
  79     size_t size = sysconf(_SC_GETPW_R_SIZE_MAX);
  80     struct passwd *result;
  81     char *buf;
  82     int n;
  83
  84     if (size == -1)
  85         size = 16384;
  86
  87     buf = pwmd_malloc(size);
  88
  89     if (!buf)
  90         return NULL;
  91
  92     n = getpwuid_r(getuid(), pwd, buf, size, &result);
  93
  94     if (n) {
  95         pwmd_free(buf);
  96         errno = n;
  97         return NULL;
  98     }
  99
 100     if (!result) {
 101         pwmd_free(buf);
 102         return NULL;
 103     }
 104
 105     errno = n;
 106     return buf;
 107 }
 108
 109 const char *_pwmd_strerror(gpg_error_t e)
 110 {
 111     gpg_err_code_t code = gpg_err_code(e);
 112
 113     if (code >= GPG_ERR_USER_1 && code < gpg_err_code(EPWMD_MAX)) {
 114         switch (code) {
 115             default:
 116                 return NULL;
 117             case GPG_ERR_USER_1:
 118                 return N_("Unknown error");
 119             case GPG_ERR_USER_2:
 120                 return N_("No cache slots available");
 121             case GPG_ERR_USER_3:
 122                 return N_("Recursion loop");
 123             case GPG_ERR_USER_4:
 124                 return N_("No file is open");
 125             case GPG_ERR_USER_5:
 126                 return N_("General LibXML error");
 127             case GPG_ERR_USER_6:
 128                 return N_("File modified");
 129             case GPG_ERR_USER_7:
 130                 return N_("Access denied");
 131         }
 132     }
 133
 134     return NULL;
 135 }
 136
 137 const char *pwmd_strerror(gpg_error_t e)
 138 {
 139     const char *p = _pwmd_strerror(e);
 140
 141     return p ? p : gpg_strerror(e);
 142 }
 143
 144 int pwmd_strerror_r(gpg_error_t e, char *buf, size_t size)
 145 {
 146     const char *p = _pwmd_strerror(e);
 147
 148     if (p) {
 149         snprintf(buf, size, "%s", p);
 150
 151         if (strlen(p) > size)
 152             return ERANGE;
 153
 154         return 0;
 155     }
 156
 157     return gpg_strerror_r(e, buf, size);
 158 }
 159
 160 gpg_error_t pwmd_init()
 161 {
 162     static int initialized;
 163
 164     if (initialized)
 165         return 0;
 166
 167 #ifndef MEM_DEBUG
 168     xmem_init();
 169 #endif
 170 #ifdef ENABLE_NLS
 171     bindtextdomain("libpwmd", LOCALEDIR);
 172 #endif
 173     gpg_err_init();
 174     assuan_set_malloc_hooks(pwmd_malloc, pwmd_realloc, pwmd_free);
 175     assuan_set_assuan_err_source(GPG_ERR_SOURCE_DEFAULT);
 176     initialized = 1;
 177     return 0;
 178 }
 179
 180 static gpg_error_t _socket_connect_finalize(pwm_t *pwm)
 181 {
 182     int active[2];
 183     int n = assuan_get_active_fds(pwm->ctx, 0, active, N_ARRAY(active));
 184
 185     pwm->fd = active[0];
 186 #ifdef WITH_PINENTRY
 187     pwm->pid = -1;
 188     pwm->pinentry_tries = 3;
 189 #endif
 190     assuan_set_pointer(pwm->ctx, pwm);
 191
 192     if (pwm->name)
 193         return pwmd_command(pwm, NULL, "OPTION CLIENT NAME=%s", pwm->name);
 194
 195     return 0;
 196 }
 197
 198 #ifdef WITH_TCP
 199 static int read_hook(assuan_context_t ctx, assuan_fd_t fd, void *data,
 200         size_t len, ssize_t *ret)
 201 {
 202     pwm_t *pwm = assuan_get_pointer(ctx);
 203
 204     if (!pwm || !pwm->tcp_conn)
 205 #ifdef WITH_LIBPTH
 206         *ret = pth_read((int)fd, data, len);
 207 #else
 208         *ret = read((int)fd, data, len);
 209 #endif
 210     else {
 211         do {
 212             *ret = libssh2_channel_read(pwm->tcp_conn->channel, data, len);
 213         } while (*ret == LIBSSH2_ERROR_EAGAIN);
 214     }
 215
 216     return *ret <= 0 ? 0 : 1;
 217 }
 218
 219 static int write_hook(assuan_context_t ctx, assuan_fd_t fd, const void *data,
 220         size_t len, ssize_t *ret)
 221 {
 222     pwm_t *pwm = assuan_get_pointer(ctx);
 223
 224     if (!pwm || !pwm->tcp_conn)
 225 #ifdef WITH_LIBPTH
 226         *ret = pth_write((int)fd, data, len);
 227 #else
 228         *ret = write((int)fd, data, len);
 229 #endif
 230     else {
 231         do {
 232             *ret = libssh2_channel_write(pwm->tcp_conn->channel, data, len);
 233         } while (*ret == LIBSSH2_ERROR_EAGAIN);
 234     }
 235
 236     return *ret <= 0 ? 0 : 1;
 237 }
 238
 239 static void _ssh_deinit(pwmd_tcp_conn_t *conn);
 240 static void free_tcp_conn(pwmd_tcp_conn_t *conn)
 241 {
 242     if (!conn)
 243         return;
 244
 245     if (conn->username) {
 246         pwmd_free(conn->username);
 247         conn->username = NULL;
 248     }
 249
 250     if (conn->known_hosts) {
 251         pwmd_free(conn->known_hosts);
 252         conn->known_hosts = NULL;
 253     }
 254
 255     if (conn->identity) {
 256         pwmd_free(conn->identity);
 257         conn->identity = NULL;
 258     }
 259
 260     if (conn->identity_pub) {
 261         pwmd_free(conn->identity_pub);
 262         conn->identity_pub = NULL;
 263     }
 264
 265     if (conn->host) {
 266         pwmd_free(conn->host);
 267         conn->host = NULL;
 268     }
 269
 270     if (conn->hostkey) {
 271         pwmd_free(conn->hostkey);
 272         conn->hostkey = NULL;
 273     }
 274
 275     if (conn->chan) {
 276         ares_destroy(conn->chan);
 277         conn->chan = NULL;
 278     }
 279
 280     if (conn->he) {
 281         ares_free_hostent(conn->he);
 282         conn->he = NULL;
 283     }
 284
 285     if (conn->fd >= 0) {
 286         close(conn->fd);
 287         conn->fd = -1;
 288     }
 289
 290     if (conn->session)
 291         _ssh_deinit(conn);
 292     else
 293         pwmd_free(conn);
 294 }
 295
 296 static void _ssh_deinit(pwmd_tcp_conn_t *conn)
 297 {
 298     if (!conn)
 299         return;
 300
 301     if (conn->channel)
 302         libssh2_channel_free(conn->channel);
 303
 304     if (conn->session) {
 305         libssh2_session_disconnect(conn->session, "Bye!");
 306         libssh2_session_free(conn->session);
 307     }
 308
 309     conn->session = NULL;
 310     conn->channel = NULL;
 311     free_tcp_conn(conn);
 312 }
 313
 314 static void _ssh_assuan_deinit(assuan_context_t ctx)
 315 {
 316     pwm_t *pwm = assuan_get_pointer(ctx);
 317
 318     pwm->tcp_conn->fd = -1;
 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_ssh_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_ssh_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 static gpg_error_t do_nb_command(pwm_t *pwm, const char *cmd, ...)
 951 {
 952     char *buf;
 953     gpg_error_t rc;
 954     va_list ap;
 955
 956     if (pwm->state == ASYNC_DONE)
 957         pwm->state = ASYNC_INIT;
 958
 959     if (pwm->state != ASYNC_INIT)
 960         return GPG_ERR_INV_STATE;
 961
 962     buf = pwmd_malloc(ASSUAN_LINELENGTH);
 963
 964     if (!buf)
 965         return gpg_error_from_errno(ENOMEM);
 966
 967     va_start(ap, cmd);
 968     vsnprintf(buf, ASSUAN_LINELENGTH, cmd, ap);
 969     va_end(ap);
 970     rc = assuan_write_line(pwm->ctx, buf);
 971     pwmd_free(buf);
 972
 973     if (!rc)
 974         pwm->state = ASYNC_PROCESS;
 975
 976 fail:
 977     return rc;
 978 }
 979
 980 gpg_error_t pwmd_open_async(pwm_t *pwm, const char *filename)
 981 {
 982     if (!pwm || !filename)
 983         return GPG_ERR_INV_ARG;
 984
 985     /* For pinentry retries. */
 986     if (!pwm->is_open_cmd) {
 987         if (pwm->filename)
 988             pwmd_free(pwm->filename);
 989
 990         pwm->filename = pwmd_strdup(filename);
 991     }
 992
 993     pwm->is_open_cmd = 1;
 994     pwm->cmd = ASYNC_CMD_OPEN;
 995     return do_nb_command(pwm, "OPEN %s %s", filename,
 996             pwm->password ? pwm->password : "");
 997 }
 998
 999 gpg_error_t pwmd_save_async(pwm_t *pwm)
1000 {
1001     if (!pwm)
1002         return GPG_ERR_INV_ARG;
1003
1004     pwm->cmd = ASYNC_CMD_SAVE;
1005     return do_nb_command(pwm, "SAVE %s", pwm->password ? pwm->password : "");
1006 }
1007
1008 static gpg_error_t parse_assuan_line(pwm_t *pwm)
1009 {
1010     gpg_error_t rc;
1011     char *line;
1012     size_t len;
1013
1014     rc = assuan_read_line(pwm->ctx, &line, &len);
1015
1016     if (!rc) {
1017         if (line[0] == 'O' && line[1] == 'K' &&
1018                 (line[2] == 0 || line[2] == ' ')) {
1019             pwm->state = ASYNC_DONE;
1020         }
1021         else if (line[0] == '#') {
1022         }
1023         else if (line[0] == 'S' && (line[1] == 0 || line[1] == ' ')) {
1024             if (pwm->status_func) {
1025                 pwm->status_func(pwm->status_data,
1026                         line[1] == 0 ? line+1 : line+2);
1027             }
1028         }
1029         else if (line[0] == 'E' && line[1] == 'R' && line[2] == 'R' &&
1030                 (line[3] == 0 || line[3] == ' ')) {
1031             line += 4;
1032             rc = atoi(line);
1033             pwm->state = ASYNC_DONE;
1034         }
1035     }
1036
1037     return rc;
1038 }
1039
1040 gpg_error_t pwmd_pending_line(pwm_t *pwm)
1041 {
1042     if (!pwm)
1043         return GPG_ERR_INV_ARG;
1044
1045     if (!pwm->ctx)
1046         return GPG_ERR_INV_STATE;
1047
1048     return assuan_pending_line(pwm->ctx) ? 0 : GPG_ERR_NO_DATA;
1049 }
1050
1051 static pwmd_async_t reset_async(pwm_t *pwm, int done)
1052 {
1053     pwm->state = ASYNC_INIT;
1054     pwm->cmd = ASYNC_CMD_NONE;
1055     pwm->ntries = 0;
1056 #ifdef WITH_PINENTRY
1057     pwm->is_open_cmd = 0;
1058
1059     if (pwm->nb_fd != -1) {
1060         close(pwm->nb_fd);
1061         pwm->nb_fd = -1;
1062     }
1063 #endif
1064 #ifdef WITH_TCP
1065     if (done && pwm->tcp_conn && pwm->tcp_conn->fd != -1) {
1066         close(pwm->tcp_conn->fd);
1067         pwm->tcp_conn->fd = -1;
1068     }
1069 #endif
1070
1071     return ASYNC_DONE;
1072 };
1073
1074 pwmd_async_t pwmd_process(pwm_t *pwm, gpg_error_t *rc, char **result)
1075 {
1076     fd_set fds;
1077     int n;
1078     struct timeval tv = {0, 0};
1079
1080     *rc = 0;
1081
1082     if (!pwm) {
1083         *rc = GPG_ERR_INV_ARG;
1084         return ASYNC_DONE;
1085     }
1086
1087     /* When not in a command, this will let libassuan process status messages
1088      * by calling PWMD_OPTION_STATUS_FUNC. The client can poll the file
1089      * descriptor returned by pwmd_get_fd() to determine when this should be
1090      * called or call pwmd_pending_line() to determine whether a buffered line
1091      * needs to be processed. */
1092     if (pwm->cmd == ASYNC_CMD_NONE) {
1093         *rc = assuan_command(pwm, pwm->ctx, NULL, "NOP");
1094         return pwm->state;
1095     }
1096
1097     /* Fixes pwmd_open/save_async2() when there is a cached or new file. */
1098     if (pwm->state == ASYNC_DONE) {
1099         reset_async(pwm, 0);
1100         return ASYNC_DONE;
1101     }
1102
1103     if (pwm->state != ASYNC_PROCESS) {
1104         *rc = GPG_ERR_INV_STATE;
1105         return ASYNC_DONE;
1106     }
1107
1108 #ifdef WITH_TCP
1109     if (pwm->cmd == ASYNC_CMD_DNS) {
1110         fd_set rfds, wfds;
1111
1112         if (pwm->tcp_conn->rc) {
1113             *rc = pwm->tcp_conn->rc;
1114             reset_async(pwm, 1);
1115             return ASYNC_DONE;
1116         }
1117
1118         FD_ZERO(&rfds);
1119         FD_ZERO(&wfds);
1120         n = ares_fds(pwm->tcp_conn->chan, &rfds, &wfds);
1121
1122         /* Shouldn't happen. */
1123         if (!n)
1124             return pwm->state;
1125
1126 #ifdef WITH_LIBPTH
1127         n = pth_select(n, &rfds, &wfds, NULL, &tv);
1128 #else
1129         n = select(n, &rfds, &wfds, NULL, &tv);
1130 #endif
1131
1132         if (n > 0)
1133             ares_process(pwm->tcp_conn->chan, &rfds, &wfds);
1134
1135         return pwm->state;
1136     }
1137     else if (pwm->cmd == ASYNC_CMD_CONNECT) {
1138         if (pwm->tcp_conn->rc == GPG_ERR_EINPROGRESS) {
1139             int ret;
1140             socklen_t len = sizeof(int);
1141
1142             FD_ZERO(&fds);
1143             FD_SET(pwm->tcp_conn->fd, &fds);
1144 #ifdef WITH_LIBPTH
1145             n = pth_select(pwm->tcp_conn->fd+1, NULL, &fds, NULL, &tv);
1146 #else
1147             n = select(pwm->tcp_conn->fd+1, NULL, &fds, NULL, &tv);
1148 #endif
1149
1150             if (!n || !FD_ISSET(pwm->tcp_conn->fd, &fds))
1151                 return pwm->state;
1152             else if (n == -1) {
1153                 *rc = gpg_error_from_syserror();
1154                 reset_async(pwm, 1);
1155                 return ASYNC_DONE;
1156             }
1157
1158             ret = getsockopt(pwm->tcp_conn->fd, SOL_SOCKET, SO_ERROR, &n, &len);
1159
1160             if (ret || n) {
1161                 *rc = ret ? gpg_error_from_syserror() : gpg_error_from_errno(n);
1162                 reset_async(pwm, 1);
1163                 return ASYNC_DONE;
1164             }
1165         }
1166         else if (pwm->tcp_conn->rc) {
1167             *rc = pwm->tcp_conn->rc;
1168             reset_async(pwm, 1);
1169             return ASYNC_DONE;
1170         }
1171
1172         fcntl(pwm->tcp_conn->fd, F_SETFL, 0);
1173         *rc = setup_tcp_session(pwm);
1174
1175         if (!*rc) {
1176             switch (pwm->tcp_conn->cmd) {
1177                 case ASYNC_CMD_HOSTKEY:
1178                     if (!*rc)
1179                         *result = pwm->result;
1180                     break;
1181                 default:
1182                     break;
1183             }
1184         }
1185
1186         return reset_async(pwm, *rc ? 1 : 0);
1187     }
1188 #endif
1189
1190 #ifdef WITH_PINENTRY
1191     if (pwm->cmd == ASYNC_CMD_OPEN2 || pwm->cmd == ASYNC_CMD_SAVE2) {
1192         if (pwm->nb_fd == -1) {
1193             *rc = GPG_ERR_INV_STATE;
1194             return reset_async(pwm, 0);
1195         }
1196
1197         FD_ZERO(&fds);
1198         FD_SET(pwm->nb_fd, &fds);
1199 #ifdef WITH_LIBPTH
1200         n = pth_select(pwm->nb_fd+1, &fds, NULL, NULL, &tv);
1201 #else
1202         n = select(pwm->nb_fd+1, &fds, NULL, NULL, &tv);
1203 #endif
1204         if (n == -1) {
1205             *rc = gpg_error_from_syserror();
1206             return reset_async(pwm, 0);
1207         }
1208
1209         if (n > 0) {
1210             pwmd_nb_status_t nb;
1211             size_t len = read(pwm->nb_fd, &nb, sizeof(nb));
1212
1213             *rc = nb.error;
1214             fprintf(stderr, "%s(%i): %s\n", __FILE__, __LINE__, __FUNCTION__);
1215             return reset_async(pwm, 0);
1216         }
1217
1218         return pwm->state;
1219     }
1220 #endif
1221
1222     if (pwm->fd < 0) {
1223         *rc = GPG_ERR_INV_STATE;
1224         return reset_async(pwm, 0);
1225     }
1226
1227     /* This is for the non-blocking OPEN and SAVE commands. */
1228     FD_ZERO(&fds);
1229     FD_SET(pwm->fd, &fds);
1230 #ifdef WITH_LIBPTH
1231     n = pth_select(pwm->fd+1, &fds, NULL, NULL, &tv);
1232 #else
1233     n = select(pwm->fd+1, &fds, NULL, NULL, &tv);
1234 #endif
1235
1236     if (n == -1) {
1237         *rc = gpg_error_from_syserror();
1238         return reset_async(pwm, 0);
1239     }
1240
1241     if (n > 0) {
1242         if (FD_ISSET(pwm->fd, &fds)) {
1243             *rc = parse_assuan_line(pwm);
1244
1245             if (*rc)
1246                 return reset_async(pwm, 0);
1247         }
1248     }
1249
1250     while (!*rc && assuan_pending_line(pwm->ctx))
1251         *rc = parse_assuan_line(pwm);
1252
1253     if (*rc)
1254         return reset_async(pwm, 0);
1255
1256     /* For pinentry retries. */
1257     if (pwm->is_open_cmd && gpg_err_code(*rc) == EPWMD_BADKEY &&
1258             ++pwm->ntries < pwm->pinentry_tries) {
1259         pwm->state = ASYNC_INIT;
1260         *rc = pwmd_open_async(pwm, pwm->filename);
1261     }
1262
1263     if (*rc)
1264         return reset_async(pwm, 0);
1265
1266     if (pwm->state == ASYNC_DONE) {
1267         reset_async(pwm, 0);
1268         return ASYNC_DONE;
1269     }
1270
1271     return pwm->state;
1272 }
1273
1274 static gpg_error_t assuan_command(pwm_t *pwm, assuan_context_t ctx,
1275         char **result, const char *cmd)
1276 {
1277     membuf_t data;
1278     gpg_error_t rc;
1279
1280     data.len = 0;
1281     data.buf = NULL;
1282
1283     rc = assuan_transact(ctx, cmd, mem_realloc_cb, &data, _inquire_cb, pwm,
1284             pwm->status_func, pwm->status_data);
1285
1286     if (rc) {
1287         if (data.buf) {
1288             pwmd_free(data.buf);
1289             data.buf = NULL;
1290         }
1291     }
1292     else {
1293         if (data.buf) {
1294             mem_realloc_cb(&data, "", 1);
1295
1296             if (!result) {
1297                 pwmd_free(data.buf);
1298                 rc = GPG_ERR_INV_ARG;
1299             }
1300             else
1301                 *result = (char *)data.buf;
1302         }
1303     }
1304
1305     return gpg_err_code(rc);
1306 }
1307
1308 gpg_error_t pwmd_inquire(pwm_t *pwm, const char *cmd, pwmd_inquire_fn fn,
1309         void *data)
1310 {
1311     if (!pwm || !cmd || !fn)
1312         return GPG_ERR_INV_ARG;
1313
1314     pwm->inquire_func = fn;
1315     pwm->inquire_data = data;
1316     return assuan_command(pwm, pwm->ctx, NULL, cmd);
1317 }
1318
1319 static gpg_error_t terminate_pinentry(pwm_t *pwm)
1320 {
1321 #ifndef WITH_PINENTRY
1322     return GPG_ERR_NOT_IMPLEMENTED;
1323 #else
1324     pid_t pid = pwm->pid;
1325
1326     pwm->pid = -1;
1327
1328     if (!pwm || pid == -1)
1329         return GPG_ERR_INV_ARG;
1330
1331     if (kill(pid, 0) == 0) {
1332         if (kill(pid, SIGTERM) == -1) {
1333             if (kill(pid, SIGKILL) == -1)
1334                 return gpg_error_from_errno(errno);
1335         }
1336     }
1337     else
1338         return gpg_error_from_errno(errno);
1339
1340     return 0;
1341 #endif
1342 }
1343
1344 #ifdef WITH_PINENTRY
1345 static gpg_error_t set_pinentry_strings(pwm_t *pwm, int which)
1346 {
1347     char *buf;
1348     char tmp[ASSUAN_LINELENGTH];
1349     gpg_error_t error;
1350
1351     if (!pwm->title)
1352         pwm->title = pwmd_strdup(N_("LibPWMD"));
1353
1354     if (!pwm->prompt)
1355         pwm->prompt = pwmd_strdup(N_("Passphrase:"));
1356
1357     if (!pwm->desc && !which)
1358         pwm->desc = pwmd_strdup(N_("Enter a passphrase."));
1359
1360     if (which == 1) {
1361         snprintf(tmp, sizeof(tmp), "SETERROR %s", N_("Invalid passphrase, please try again."));
1362         buf = pwmd_strdup(tmp);
1363     }
1364     else if (which == 2) {
1365         snprintf(tmp, sizeof(tmp), "SETERROR %s", N_("Please type the passphrase again for confirmation."));
1366         buf = pwmd_strdup(tmp);
1367     }
1368     else {
1369         buf = (char *)pwmd_malloc(strlen("SETERROR ") + strlen(pwm->desc) + 1);
1370         sprintf(buf, "SETERROR %s", pwm->desc);
1371     }
1372
1373     error = pinentry_command(pwm, NULL, buf);
1374     pwmd_free(buf);
1375
1376     if (error)
1377         return error;
1378
1379     buf = (char *)pwmd_malloc(strlen("SETPROMPT ") + strlen(pwm->prompt) + 1);
1380     sprintf(buf, "SETPROMPT %s", pwm->prompt);
1381     error = pinentry_command(pwm, NULL, buf);
1382     pwmd_free(buf);
1383
1384     if (error)
1385         return error;
1386
1387     buf = (char *)pwmd_malloc(strlen("SETDESC ") + strlen(pwm->title) + 1);
1388     sprintf(buf, "SETDESC %s", pwm->title);
1389     error = pinentry_command(pwm, NULL, buf);
1390     pwmd_free(buf);
1391     return error;
1392 }
1393
1394 static void update_pinentry_settings(pwm_t *pwm)
1395 {
1396     FILE *fp;
1397     char buf[LINE_MAX];
1398     char *p;
1399     struct passwd pw;
1400     char *pwbuf = _getpwuid(&pw);
1401
1402     if (!pwbuf)
1403         return;
1404
1405     snprintf(buf, sizeof(buf), "%s/.pwmd/pinentry.conf", pw.pw_dir);
1406     pwmd_free(pwbuf);
1407
1408     if ((fp = fopen(buf, "r")) == NULL)
1409         return;
1410
1411     while ((p = fgets(buf, sizeof(buf), fp)) != NULL) {
1412         char name[32], val[256];
1413
1414         if (sscanf(p, " %31[a-zA-Z] = %255s", name, val) != 2)
1415             continue;
1416
1417         if (strcasecmp(name, "TTYNAME") == 0) {
1418             pwmd_free(pwm->pinentry_tty);
1419             pwm->pinentry_tty = pwmd_strdup(val);
1420         }
1421         else if (strcasecmp(name, "TTYTYPE") == 0) {
1422             pwmd_free(pwm->pinentry_term);
1423             pwm->pinentry_term = pwmd_strdup(val);
1424         }
1425         else if (strcasecmp(name, "DISPLAY") == 0) {
1426             pwmd_free(pwm->pinentry_display);
1427             pwm->pinentry_display = pwmd_strdup(val);
1428         }
1429         else if (strcasecmp(name, "PATH") == 0) {
1430             pwmd_free(pwm->pinentry_path);
1431             pwm->pinentry_path = pwmd_strdup(val);
1432         }
1433     }
1434
1435     fclose(fp);
1436 }
1437
1438 static gpg_error_t launch_pinentry(pwm_t *pwm)
1439 {
1440     int rc;
1441     assuan_context_t ctx;
1442     int child_list[] = {-1};
1443     char *display = getenv("DISPLAY");
1444     const char *argv[10];
1445     const char **p = argv;
1446     int have_display = 0;
1447     char *tty = NULL;
1448     char *ttybuf = NULL;
1449
1450     update_pinentry_settings(pwm);
1451
1452     if (pwm->pinentry_display || display)
1453         have_display = 1;
1454     else {
1455         if (!pwm->pinentry_tty) {
1456             ttybuf = pwmd_malloc(255);
1457
1458             if (!ttybuf)
1459                 return gpg_error_from_errno(ENOMEM);
1460
1461             rc = ttyname_r(STDOUT_FILENO, ttybuf, 255);
1462
1463             if (rc) {
1464                 pwmd_free(ttybuf);
1465                 return gpg_error_from_errno(rc);
1466             }
1467
1468             tty = ttybuf;
1469         }
1470         else
1471             tty = pwm->pinentry_tty;
1472     }
1473
1474     if (!have_display && !tty)
1475         return GPG_ERR_ENOTTY;
1476
1477     *p++ = "pinentry";
1478     *p++ = have_display ? "--display" : "--ttyname";
1479     *p++ = have_display ? pwm->pinentry_display ? pwm->pinentry_display : display : tty;
1480
1481     if (pwm->lcctype) {
1482         *p++ = "--lc-ctype";
1483         *p++ = pwm->lcctype;
1484     }
1485
1486     if (pwm->lcmessages) {
1487         *p++ = "--lc-messages";
1488         *p++ = pwm->lcmessages;
1489     }
1490
1491     *p = NULL;
1492
1493     if (!have_display) {
1494         *p++ = "--ttytype";
1495         *p++ = pwm->pinentry_term ? pwm->pinentry_term : getenv("TERM");
1496         *p = NULL;
1497     }
1498
1499     rc = assuan_pipe_connect(&ctx, pwm->pinentry_path ? pwm->pinentry_path : PINENTRY_PATH, argv, child_list);
1500
1501     if (ttybuf)
1502         pwmd_free(ttybuf);
1503
1504     if (rc)
1505         return rc;
1506
1507     pwm->pid = assuan_get_pid(ctx);
1508     pwm->pctx = ctx;
1509     return set_pinentry_strings(pwm, 0);
1510 }
1511
1512 static gpg_error_t pinentry_command(pwm_t *pwm, char **result, const char *cmd)
1513 {
1514     gpg_error_t n;
1515
1516     if (!pwm->pctx) {
1517         n = launch_pinentry(pwm);
1518
1519         if (n)
1520             return n;
1521     }
1522
1523     return assuan_command(pwm, pwm->pctx, result, cmd);
1524 }
1525
1526 static void pinentry_disconnect(pwm_t *pwm)
1527 {
1528     if (pwm->pctx)
1529         assuan_disconnect(pwm->pctx);
1530
1531     pwm->pctx = NULL;
1532     pwm->pid = -1;
1533 }
1534
1535 /*
1536  * Only called from a child process.
1537  */
1538 static void catchsig(int sig)
1539 {
1540     switch (sig) {
1541         case SIGALRM:
1542             if (gelapsed++ >= gtimeout)
1543                 terminate_pinentry(gpwm);
1544             else
1545                 alarm(1);
1546             break;
1547         default:
1548             break;
1549     }
1550 }
1551 #endif
1552
1553 /*
1554  * Borrowed from libassuan.
1555  */
1556 static char *percent_escape(const char *atext)
1557 {
1558     const unsigned char *s;
1559     int len = strlen(atext) * 3 + 1;
1560     char *buf = (char *)pwmd_malloc(len), *p = buf;
1561
1562     if (!buf)
1563         return NULL;
1564
1565     for (s=(const unsigned char *)atext; *s; s++) {
1566         if (*s < ' ') {
1567             sprintf (p, "%%%02X", *s);
1568             p += 3;
1569         }
1570         else
1571             *p++ = *s;
1572     }
1573
1574     *p = 0;
1575     return buf;
1576 }
1577
1578 static gpg_error_t send_command(pwm_t *pwm, char **result, const char *cmd)
1579 {
1580     if (!cmd)
1581         return GPG_ERR_INV_ARG;
1582
1583     return assuan_command(pwm, pwm->ctx, result, cmd);
1584 }
1585
1586 gpg_error_t pwmd_command_ap(pwm_t *pwm, char **result, const char *cmd,
1587         va_list ap)
1588 {
1589     char *buf;
1590     size_t len;
1591     gpg_error_t error;
1592
1593     if (!pwm || !cmd)
1594         return GPG_ERR_INV_ARG;
1595
1596     /*
1597      * C99 allows the dst pointer to be null which will calculate the length
1598      * of the would-be result and return it.
1599      */
1600     len = vsnprintf(NULL, 0, cmd, ap)+1;
1601     buf = (char *)pwmd_malloc(len);
1602     len = vsnprintf(buf, len, cmd, ap);
1603     error = send_command(pwm, result, buf);
1604     pwmd_free(buf);
1605     return error;
1606 }
1607
1608 /*
1609  * Avoid sending the BYE command here. libassuan will close the file
1610  * descriptor and release the assuan context. Use pwmd_close() instead.
1611  */
1612 gpg_error_t pwmd_command(pwm_t *pwm, char **result, const char *cmd, ...)
1613 {
1614     va_list ap;
1615     gpg_error_t error;
1616
1617     if (!pwm || !cmd)
1618         return GPG_ERR_INV_ARG;
1619
1620     if (result)
1621         *result = NULL;
1622
1623     va_start(ap, cmd);
1624     error = pwmd_command_ap(pwm, result, cmd, ap);
1625     va_end(ap);
1626     return error;
1627 }
1628
1629 #ifdef WITH_PINENTRY
1630 static gpg_error_t do_getpin(pwm_t *pwm, char **result)
1631 {
1632     if (gtimeout) {
1633         signal(SIGALRM, catchsig);
1634         alarm(1);
1635     }
1636
1637     *result = NULL;
1638     return pinentry_command(pwm, result, "GETPIN");
1639 }
1640
1641 static gpg_error_t getpin(pwm_t *pwm, char **result, int *try_n, int which)
1642 {
1643     int pin_try = *try_n;
1644     gpg_error_t error;
1645
1646 getpin_again:
1647     *try_n = pin_try;
1648
1649     if (pin_try == -1) {
1650         error = set_pinentry_strings(pwm, which);
1651
1652         if (error) {
1653             pinentry_disconnect(pwm);
1654             return error;
1655         }
1656     }
1657     else {
1658         if (pwm->pinentry_tries-1 != pin_try) {
1659             error = set_pinentry_strings(pwm, 1);
1660
1661             if (error) {
1662                 pinentry_disconnect(pwm);
1663                 return error;
1664             }
1665         }
1666     }
1667
1668     error = do_getpin(pwm, result);
1669
1670     /*
1671      * Since there was input cancel any timeout setting.
1672      */
1673     alarm(0);
1674
1675     if (error) {
1676         if (error == GPG_ERR_CANCELED)
1677             return GPG_ERR_CANCELED;
1678
1679         if (pin_try != -1 && pin_try--)
1680             goto getpin_again;
1681
1682         if (pwm->pctx)
1683             pinentry_disconnect(pwm);
1684
1685         *try_n = pin_try;
1686         return error;
1687     }
1688
1689     return 0;
1690 }
1691 #endif
1692
1693 static gpg_error_t do_open_command(pwm_t *pwm, const char *filename, char *password)
1694 {
1695     char buf[ASSUAN_LINELENGTH];
1696     gpg_error_t error;
1697     char *result = NULL;
1698
1699     snprintf(buf, sizeof(buf), "OPEN %s %s", filename, password ? password : "");
1700     error = send_command(pwm, &result, buf);
1701     memset(buf, 0, sizeof(buf));
1702
1703     if (error && result)
1704         pwmd_free(result);
1705
1706     return error;
1707 }
1708
1709 static gpg_error_t do_pwmd_open(pwm_t *pwm, const char *filename, int nb)
1710 {
1711     char *result = NULL;
1712     char *password = NULL;
1713     char path[PATH_MAX];
1714 #ifdef WITH_PINENTRY
1715     int pin_try;
1716 #endif
1717     gpg_error_t rc;
1718
1719     if (!pwm || !filename || !*filename)
1720         return GPG_ERR_INV_ARG;
1721
1722 #ifdef WITH_PINENTRY
1723     pin_try = pwm->pinentry_tries - 1;
1724 #endif
1725
1726     /*
1727      * Avoid calling pinentry if the password is cached on the server or if
1728      * this is a new file.
1729      */
1730     rc = pwmd_command(pwm, &result, "GETCONFIG data_directory");
1731
1732     if (rc)
1733         return rc;
1734
1735     snprintf(path, sizeof(path), "%s/%s", result, filename);
1736     pwmd_free(result);
1737
1738     if (access(path, R_OK) == -1) {
1739         if (errno == ENOENT)
1740             goto gotpassword;
1741     }
1742
1743     rc = pwmd_command(pwm, &result, "ISCACHED %s", filename);
1744
1745     if (rc == EPWMD_CACHE_NOT_FOUND) {
1746         if (pwm->passfunc) {
1747             password = (char *)pwm->passfunc(pwm->passdata);
1748             goto gotpassword;
1749         }
1750
1751 #ifdef WITH_PINENTRY
1752         /*
1753          * Get the password from pinentry.
1754          */
1755         if (pwm->use_pinentry) {
1756             /*
1757              * Nonblocking is wanted. fork() then return a file descriptor
1758              * that the client can use to read() from.
1759              */
1760             if (nb) {
1761                 int p[2];
1762                 pid_t pid;
1763                 pwmd_nb_status_t pw;
1764
1765                 if (pipe(p) == -1)
1766                     return gpg_error_from_syserror();
1767
1768 #ifdef WITH_LIBPTH
1769                 pid = pth_fork();
1770 #else
1771                 pid = fork();
1772 #endif
1773
1774                 switch (pid) {
1775                     case 0:
1776                         close(p[0]);
1777                         pw.fd = p[0];
1778
1779                         if (pwm->pinentry_timeout > 0) {
1780                             gpwm = pwm;
1781                             gtimeout = pwm->pinentry_timeout;
1782                             gelapsed = 0;
1783                         }
1784
1785 getpin_nb_again:
1786                         rc = getpin(pwm, &password, &pin_try, 0);
1787
1788                         if (rc) {
1789 getpin_nb_fail:
1790                             if (pwm->pctx)
1791                                 pinentry_disconnect(pwm);
1792
1793                             if (gtimeout && gelapsed >= gtimeout)
1794                                 rc = GPG_ERR_TIMEOUT;
1795
1796                             pw.error = rc;
1797 #ifdef WITH_LIBPTH
1798                             pth_write(p[1], &pw, sizeof(pw));
1799 #else
1800                             write(p[1], &pw, sizeof(pw));
1801 #endif
1802                             close(p[1]);
1803                             _exit(1);
1804                         }
1805
1806                         /*
1807                          * Don't count the time it takes to open the file
1808                          * which may have many iterations.
1809                          */
1810                         signal(SIGALRM, SIG_DFL);
1811                         rc = do_open_command(pwm, filename, password);
1812
1813                         if (pwm->pinentry_timeout)
1814                             signal(SIGALRM, catchsig);
1815
1816                         if (pwm->pctx && rc == EPWMD_BADKEY) {
1817                             if (pin_try-- > 0)
1818                                 goto getpin_nb_again;
1819
1820                             goto getpin_nb_fail;
1821                         }
1822
1823                         pinentry_disconnect(pwm);
1824                         pw.error = 0;
1825 #ifdef WITH_LIBPTH
1826                         pth_write(p[1], &pw, sizeof(pw));
1827 #else
1828                         write(p[1], &pw, sizeof(pw));
1829 #endif
1830                         close(p[1]);
1831                         _exit(0);
1832                         break;
1833                     case -1:
1834                         rc = gpg_error_from_syserror();
1835                         close(p[0]);
1836                         close(p[1]);
1837                         return rc;
1838                     default:
1839                         break;
1840                 }
1841
1842                 close(p[1]);
1843                 pwm->nb_fd = p[0];
1844                 return 0;
1845             }
1846         }
1847         else {
1848 #endif
1849             /*
1850              * Not using pinentry and the file was not found
1851              * in the cache.
1852              */
1853             password = pwm->password;
1854 #ifdef WITH_PINENTRY
1855         }
1856 #endif
1857     }
1858     else if (rc)
1859         return rc;
1860
1861 gotpassword:
1862     pwm->state = ASYNC_DONE;
1863     rc = do_open_command(pwm, filename, password);
1864
1865     /*
1866      * Keep the user defined password set with pwmd_setopt(). The password may
1867      * be needed later (pwmd_save()) depending on the pwmd file cache settings.
1868      */
1869     if (!pwm->passfunc && password && password != pwm->password)
1870         pwmd_free(password);
1871
1872 #ifdef WITH_PINENTRY
1873     if (rc == EPWMD_BADKEY) {
1874         if (pin_try-- > 0 && !nb) {
1875             rc = pwmd_command(pwm, &result, "OPTION TITLE=%s",
1876                     N_("Invalid passphrase, please try again."));
1877
1878             if (rc)
1879                 return rc;
1880
1881             goto gotpassword;
1882         }
1883
1884         if (nb)
1885             pinentry_disconnect(pwm);
1886
1887         return rc;
1888     }
1889 #endif
1890
1891     if (!rc) {
1892         if (pwm->filename)
1893             pwmd_free(pwm->filename);
1894
1895         pwm->filename = pwmd_strdup(filename);
1896     }
1897
1898     return rc;
1899 }
1900
1901 gpg_error_t pwmd_open(pwm_t *pwm, const char *filename)
1902 {
1903     return do_pwmd_open(pwm, filename, 0);
1904 }
1905
1906 gpg_error_t pwmd_open_async2(pwm_t *pwm, const char *filename)
1907 {
1908 #ifndef WITH_PINENTRY
1909     return GPG_ERR_NOT_IMPLEMENTED;
1910 #else
1911     gpg_error_t rc;
1912
1913     pwm->cmd = ASYNC_CMD_OPEN2;
1914     pwm->state = ASYNC_PROCESS;
1915     rc = do_pwmd_open(pwm, filename, 1);
1916
1917     if (rc)
1918         reset_async(pwm, 1);
1919
1920     return rc;
1921 #endif
1922 }
1923
1924 #ifdef WITH_PINENTRY
1925 static gpg_error_t do_save_getpin(pwm_t *pwm, char **password)
1926 {
1927     int confirm = 0;
1928     gpg_error_t error;
1929     char *result = NULL;
1930     int pin_try = -1;
1931
1932 again:
1933     error = getpin(pwm, &result, &pin_try, confirm ? 2 : 0);
1934
1935     if (error) {
1936         if (pwm->pctx)
1937             pinentry_disconnect(pwm);
1938
1939         if (*password)
1940             pwmd_free(*password);
1941
1942         return error;
1943     }
1944
1945     if (!confirm++) {
1946         *password = result;
1947         goto again;
1948     }
1949
1950     if (strcmp(*password, result)) {
1951         pwmd_free(*password);
1952         pwmd_free(result);
1953         pinentry_disconnect(pwm);
1954         error = EPWMD_BADKEY;
1955         return error;
1956     }
1957
1958     pwmd_free(result);
1959     pinentry_disconnect(pwm);
1960     return 0;
1961 }
1962 #endif
1963
1964 static gpg_error_t do_save_command(pwm_t *pwm, char *password)
1965 {
1966     char buf[ASSUAN_LINELENGTH];
1967     gpg_error_t error;
1968     char *result = NULL;
1969
1970     snprintf(buf, sizeof(buf), "SAVE %s", password ? password : "");
1971     error = send_command(pwm, &result, buf);
1972     memset(&buf, 0, sizeof(buf));
1973
1974     if (error && result)
1975         pwmd_free(result);
1976
1977     return error;
1978 }
1979
1980 static gpg_error_t do_pwmd_save(pwm_t *pwm, int nb)
1981 {
1982     char *result = NULL;
1983     char *password = NULL;
1984     gpg_error_t rc;
1985
1986     if (!pwm)
1987         return GPG_ERR_INV_ARG;
1988
1989     if (pwm->use_pinentry || pwm->passfunc) {
1990         rc = pwmd_command(pwm, &result, "ISCACHED %s", pwm->filename);
1991
1992         if (rc == EPWMD_CACHE_NOT_FOUND) {
1993             if (pwm->passfunc)
1994                 password = (char *)(*pwm->passfunc)(pwm->passdata);
1995 #ifdef WITH_PINENTRY
1996             else if (pwm->use_pinentry) {
1997                 if (nb) {
1998                     int p[2];
1999                     pid_t pid;
2000                     pwmd_nb_status_t pw;
2001
2002                     if (pipe(p) == -1)
2003                         return gpg_error_from_syserror();
2004
2005 #ifdef WITH_LIBPTH
2006                     pid = pth_fork();
2007 #else
2008                     pid = fork();
2009 #endif
2010
2011                     switch (pid) {
2012                         case 0:
2013                             close(p[0]);
2014                             pw.fd = p[0];
2015
2016                             do {
2017                                 password = NULL;
2018                                 rc = do_save_getpin(pwm, &password);
2019                             } while (rc == EPWMD_BADKEY);
2020
2021                             if (rc) {
2022                                 if (pwm->pctx)
2023                                     pinentry_disconnect(pwm);
2024
2025                                 pw.error = rc;
2026 #ifdef WITH_LIBPTH
2027                                 pth_write(p[1], &pw, sizeof(pw));
2028 #else
2029                                 write(p[1], &pw, sizeof(pw));
2030 #endif
2031                                 close(p[1]);
2032                                 _exit(1);
2033                             }
2034
2035                             rc = do_save_command(pwm, password);
2036                             pinentry_disconnect(pwm);
2037                             pw.error = rc;
2038 #ifdef WITH_LIBPTH
2039                             pth_write(p[1], &pw, sizeof(pw));
2040 #else
2041                             write(p[1], &pw, sizeof(pw));
2042 #endif
2043                             close(p[1]);
2044                             _exit(0);
2045                             break;
2046                         case -1:
2047                             rc = gpg_error_from_syserror();
2048                             close(p[0]);
2049                             close(p[1]);
2050                             return rc;
2051                         default:
2052                             break;
2053                     }
2054
2055                     close(p[1]);
2056                     pwm->nb_fd = p[0];
2057                     return 0;
2058                 }
2059
2060                 rc = do_save_getpin(pwm, &password);
2061
2062                 if (rc)
2063                     return rc;
2064             }
2065 #endif
2066         }
2067         else {
2068             if (rc)
2069                 return rc;
2070
2071             pwm->state = ASYNC_DONE;
2072         }
2073     }
2074     else
2075         password = pwm->password;
2076
2077     rc = do_save_command(pwm, password);
2078
2079     if (!pwm->passfunc && password && password != pwm->password)
2080         pwmd_free(password);
2081
2082     return rc;
2083 }
2084
2085 gpg_error_t pwmd_save_async2(pwm_t *pwm)
2086 {
2087 #ifndef WITH_PINENTRY
2088     return GPG_ERR_NOT_IMPLEMENTED;
2089 #else
2090     gpg_error_t rc;
2091
2092     pwm->cmd = ASYNC_CMD_SAVE2;
2093     pwm->state = ASYNC_PROCESS;
2094     rc = do_pwmd_save(pwm, 1);
2095
2096     if (rc)
2097         reset_async(pwm, 0);
2098
2099     return rc;
2100 #endif
2101 }
2102
2103 gpg_error_t pwmd_save(pwm_t *pwm)
2104 {
2105     return do_pwmd_save(pwm, 0);
2106 }
2107
2108 gpg_error_t pwmd_setopt(pwm_t *pwm, pwmd_option_t opt, ...)
2109 {
2110     va_list ap;
2111     int n = va_arg(ap, int);
2112     char *result;
2113     char *arg1;
2114     gpg_error_t error = 0;
2115
2116     if (!pwm)
2117         return GPG_ERR_INV_ARG;
2118
2119     va_start(ap, opt);
2120
2121     switch (opt) {
2122         case PWMD_OPTION_STATUS_FUNC:
2123             pwm->status_func = va_arg(ap, pwmd_status_fn);
2124             break;
2125         case PWMD_OPTION_STATUS_DATA:
2126             pwm->status_data = va_arg(ap, void *);
2127             break;
2128         case PWMD_OPTION_PASSWORD_FUNC:
2129             pwm->passfunc = va_arg(ap, pwmd_password_fn);
2130             break;
2131         case PWMD_OPTION_PASSWORD_DATA:
2132             pwm->passdata = va_arg(ap, void *);
2133             break;
2134         case PWMD_OPTION_PASSWORD:
2135             arg1 = va_arg(ap, char *);
2136
2137             if (pwm->password)
2138                 pwmd_free(pwm->password);
2139
2140             pwm->password = pwmd_strdup(arg1);
2141             break;
2142         case PWMD_OPTION_PINENTRY:
2143             n = va_arg(ap, int);
2144
2145             if (n != 0 && n != 1) {
2146                 va_end(ap);
2147                 error = GPG_ERR_INV_VALUE;
2148             }
2149             else {
2150                 pwm->use_pinentry = n;
2151                 error = pwmd_command(pwm, &result, "OPTION PINENTRY=%i",
2152                         !pwm->use_pinentry);
2153             }
2154             break;
2155 #ifdef WITH_PINENTRY
2156         case PWMD_OPTION_PINENTRY_TRIES:
2157             n = va_arg(ap, int);
2158
2159             if (n <= 0) {
2160                 va_end(ap);
2161                 error = GPG_ERR_INV_VALUE;
2162             }
2163             else
2164                 pwm->pinentry_tries = n;
2165             break;
2166 #endif
2167         case PWMD_OPTION_PINENTRY_TIMEOUT:
2168             n = va_arg(ap, int);
2169
2170             if (n < 0) {
2171                 va_end(ap);
2172                 error = GPG_ERR_INV_VALUE;
2173             }
2174             else
2175                 pwm->pinentry_timeout = n;
2176
2177             if (!pwm->use_pinentry)
2178                 error = pwmd_command(pwm, &result, "OPTION TIMEOUT=%i",
2179                         pwm->pinentry_timeout);
2180             break;
2181         case PWMD_OPTION_PINENTRY_PATH:
2182             if (pwm->pinentry_path)
2183                 pwmd_free(pwm->pinentry_path);
2184
2185             pwm->pinentry_path = pwmd_strdup(va_arg(ap, char *));
2186
2187             if (!pwm->use_pinentry)
2188                 error = pwmd_command(pwm, &result, "OPTION PATH=%s",
2189                         pwm->pinentry_path);
2190             break;
2191         case PWMD_OPTION_PINENTRY_TTY:
2192             if (pwm->pinentry_tty)
2193                 pwmd_free(pwm->pinentry_tty);
2194
2195             pwm->pinentry_tty = pwmd_strdup(va_arg(ap, char *));
2196
2197             if (!pwm->use_pinentry)
2198                 error = pwmd_command(pwm, &result, "OPTION TTY=%s",
2199                         pwm->pinentry_tty);
2200             break;
2201         case PWMD_OPTION_PINENTRY_DISPLAY:
2202             if (pwm->pinentry_display)
2203                 pwmd_free(pwm->pinentry_display);
2204
2205             pwm->pinentry_display = pwmd_strdup(va_arg(ap, char *));
2206
2207             if (!pwm->use_pinentry)
2208                 error = pwmd_command(pwm, &result, "OPTION DISPLAY=%s",
2209                         pwm->pinentry_display);
2210             break;
2211         case PWMD_OPTION_PINENTRY_TERM:
2212             if (pwm->pinentry_term)
2213                 pwmd_free(pwm->pinentry_term);
2214
2215             pwm->pinentry_term = pwmd_strdup(va_arg(ap, char *));
2216
2217             if (!pwm->use_pinentry)
2218                 error = pwmd_command(pwm, &result, "OPTION TTYTYPE=%s",
2219                         pwm->pinentry_term);
2220             break;
2221         case PWMD_OPTION_PINENTRY_TITLE:
2222             if (pwm->title)
2223                 pwmd_free(pwm->title);
2224
2225             pwm->title = percent_escape(va_arg(ap, char *));
2226
2227             if (!pwm->use_pinentry)
2228                 error = pwmd_command(pwm, &result, "OPTION TITLE=%s",
2229                         pwm->title);
2230             break;
2231         case PWMD_OPTION_PINENTRY_PROMPT:
2232             if (pwm->prompt)
2233                 pwmd_free(pwm->prompt);
2234
2235             pwm->prompt = percent_escape(va_arg(ap, char *));
2236
2237             if (!pwm->use_pinentry)
2238                 error = pwmd_command(pwm, &result, "OPTION PROMPT=%s",
2239                         pwm->prompt);
2240             break;
2241         case PWMD_OPTION_PINENTRY_DESC:
2242             if (pwm->desc)
2243                 pwmd_free(pwm->desc);
2244
2245             pwm->desc = percent_escape(va_arg(ap, char *));
2246
2247             if (!pwm->use_pinentry)
2248                 error = pwmd_command(pwm, &result, "OPTION DESC=%s",
2249                         pwm->desc);
2250             break;
2251         case PWMD_OPTION_PINENTRY_LC_CTYPE:
2252             if (pwm->lcctype)
2253                 pwmd_free(pwm->lcctype);
2254
2255             pwm->lcctype = pwmd_strdup(va_arg(ap, char *));
2256
2257             if (!pwm->use_pinentry)
2258                 error = pwmd_command(pwm, &result, "OPTION LC_CTYPE=%s",
2259                         pwm->lcctype);
2260             break;
2261         case PWMD_OPTION_PINENTRY_LC_MESSAGES:
2262             if (pwm->lcmessages)
2263                 pwmd_free(pwm->lcmessages);
2264
2265             pwm->lcmessages = pwmd_strdup(va_arg(ap, char *));
2266
2267             if (!pwm->use_pinentry)
2268                 error = pwmd_command(pwm, &result, "OPTION LC_MESSAGES=%s",
2269                         pwm->lcmessages);
2270             break;
2271         default:
2272             error = GPG_ERR_NOT_IMPLEMENTED;
2273             break;
2274     }
2275
2276     va_end(ap);
2277     return error;
2278 }
2279
2280 gpg_error_t pwmd_get_fd(pwm_t *pwm, int *fd)
2281 {
2282     if (!pwm)
2283         return GPG_ERR_INV_ARG;
2284
2285     if (pwm->fd == -1)
2286         return GPG_ERR_INV_STATE;
2287
2288     *fd = pwm->fd;
2289     return 0;
2290 }
2291
2292 gpg_error_t pwmd_get_fd2(pwm_t *pwm, int *fd)
2293 {
2294 #ifndef WITH_PINENTRY
2295     return GPG_ERR_NOT_IMPLEMENTED;
2296 #else
2297     if (!pwm)
2298         return GPG_ERR_INV_ARG;
2299
2300     if (pwm->nb_fd == -1)
2301         return GPG_ERR_INV_STATE;
2302
2303     *fd = pwm->nb_fd;
2304     return 0;
2305 #endif
2306 }
2307
2308 pwm_t *pwmd_new(const char *name)
2309 {
2310     pwm_t *h = pwmd_calloc(1, sizeof(pwm_t));
2311
2312     if (!h)
2313         return NULL;
2314
2315     if (name) {
2316         h->name = pwmd_strdup(name);
2317
2318         if (!h->name) {
2319             pwmd_free(h);
2320             return NULL;
2321         }
2322     }
2323
2324     h->fd = -1;
2325 #ifdef WITH_PINENTRY
2326     h->nb_fd = -1;
2327 #endif
2328     return h;
2329 }
2330
2331 void pwmd_free(void *ptr)
2332 {
2333     xfree(ptr);
2334 }
2335
2336 void *pwmd_malloc(size_t size)
2337 {
2338     return xmalloc(size);
2339 }
2340
2341 void *pwmd_calloc(size_t nmemb, size_t size)
2342 {
2343     return xcalloc(nmemb, size);
2344 }
2345
2346 void *pwmd_realloc(void *ptr, size_t size)
2347 {
2348     return xrealloc(ptr, size);
2349 }
2350
2351 char *pwmd_strdup(const char *str)
2352 {
2353     return xstrdup(str);
2354 }