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