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