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