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