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