src/libpwmd.c

   1 /*
   2     Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015,
   3     2016
   4     Ben Kibbey <bjk@luxsci.net>
   5
   6     This file is part of libpwmd.
   7
   8     Libpwmd is free software: you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License as published by
  10     the Free Software Foundation, either version 2 of the License, or
  11     (at your option) any later version.
  12
  13     Libpwmd is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with Libpwmd.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <unistd.h>
  28 #include <err.h>
  29 #include <errno.h>
  30 #include <ctype.h>
  31 #include <string.h>
  32 #include <sys/types.h>
  33 #include <sys/socket.h>
  34 #include <sys/un.h>
  35 #include <signal.h>
  36 #include <stdarg.h>
  37 #include <string.h>
  38 #include <sys/wait.h>
  39 #include <fcntl.h>
  40 #include <pwd.h>
  41 #include <time.h>
  42 #include <limits.h>
  43 #include <sys/select.h>
  44 #include <termios.h>
  45 #include <libpwmd.h>
  46
  47 #ifdef HAVE_STRINGS_H
  48 #include <strings.h>
  49 #endif
  50
  51 #ifndef LINE_MAX
  52 #define LINE_MAX        2048
  53 #endif
  54
  55 #include "mem.h"
  56 #include "misc.h"
  57 #include "types.h"
  58
  59 #ifdef WITH_PINENTRY
  60 #include "pinentry.h"
  61 #endif
  62
  63 #if defined(WITH_SSH) || defined(WITH_GNUTLS)
  64 #include <sys/types.h>
  65 #include <sys/socket.h>
  66 #include <netdb.h>
  67 #include <netinet/in.h>
  68 #endif
  69
  70 #define FINISH(rc) (gpg_err_source(rc) == GPG_ERR_SOURCE_UNKNOWN) \
  71                                         ? gpg_error(rc) : rc
  72
  73 typedef struct
  74 {
  75   size_t len;
  76   void *buf;
  77 } membuf_t;
  78
  79 ssize_t
  80 hook_read (assuan_context_t ctx, assuan_fd_t fd, void *data, size_t len)
  81 {
  82 #if defined(WITH_SSH) || defined(WITH_GNUTLS)
  83   pwm_t *pwm = assuan_get_pointer (ctx);
  84
  85 #ifdef WITH_SSH
  86   if (pwm && pwm->tcp && pwm->tcp->ssh)
  87     return read_hook_ssh (pwm->tcp->ssh, fd, data, len);
  88 #endif
  89 #ifdef WITH_GNUTLS
  90   if (pwm && pwm->tcp && pwm->tcp->tls)
  91     return read_hook_tls (pwm, fd, data, len);
  92 #endif
  93 #endif
  94
  95   return read ((int) fd, data, len);
  96 }
  97
  98 ssize_t
  99 hook_write (assuan_context_t ctx, assuan_fd_t fd, const void *data,
 100             size_t len)
 101 {
 102   ssize_t wrote;
 103 #if defined(WITH_SSH) || defined(WITH_GNUTLS)
 104   pwm_t *pwm = assuan_get_pointer (ctx);
 105
 106 #ifdef WITH_SSH
 107   if (pwm && pwm->tcp && pwm->tcp->ssh)
 108     return write_hook_ssh (pwm->tcp->ssh, fd, data, len);
 109 #endif
 110 #ifdef WITH_GNUTLS
 111   if (pwm && pwm->tcp && pwm->tcp->tls)
 112     return write_hook_tls (pwm, fd, data, len);
 113 #endif
 114 #endif
 115
 116   /* libassuan cannot handle EAGAIN when doing writes. */
 117   do
 118     {
 119       wrote = write ((int) fd, data, len);
 120       if (wrote == -1 && errno == EAGAIN)
 121         usleep (50000);
 122     }
 123   while (wrote == -1 && errno == EAGAIN);
 124
 125   return wrote;
 126 }
 127
 128 pid_t
 129 hook_waitpid (assuan_context_t ctx, pid_t pid, int action, int *status,
 130               int options)
 131 {
 132   return waitpid (pid, status, options);
 133 }
 134
 135 gpg_error_t
 136 pwmd_init ()
 137 {
 138   static int initialized;
 139
 140 #ifdef WITH_GNUTLS
 141   // May be called more than once.
 142   gnutls_global_init ();
 143 #endif
 144
 145   if (initialized)
 146     return 0;
 147
 148 #ifdef ENABLE_NLS
 149   bindtextdomain ("libpwmd", LOCALEDIR);
 150 #endif
 151 #ifdef WITH_SSH
 152   libssh2_init (0);
 153 #endif
 154   gpgrt_init ();
 155   gpgrt_set_alloc_func (_xrealloc_gpgrt);
 156   initialized = 1;
 157   return 0;
 158 }
 159
 160 void
 161 pwmd_deinit ()
 162 {
 163 #ifdef WITH_GNUTLS
 164   gnutls_global_deinit ();
 165 #endif
 166 }
 167
 168 gpg_error_t
 169 _connect_finalize (pwm_t * pwm)
 170 {
 171   gpg_error_t rc = 0;
 172   char *result = NULL;
 173   int active[2];
 174   int n = assuan_get_active_fds (pwm->ctx, 0, active, N_ARRAY (active));
 175
 176   if (n <= 0)
 177     return GPG_ERR_EBADFD;
 178
 179   pwm->fd = active[0];
 180 #ifdef WITH_PINENTRY
 181   pwm->pinentry_pid = -1;
 182 #endif
 183
 184   rc = pwmd_command (pwm, &result, NULL, NULL, NULL, "GETINFO VERSION");
 185   if (!rc)
 186     {
 187       pwm->version = strtoul (result, NULL, 16);
 188       pwmd_free (result);
 189     }
 190
 191   if (!rc && pwm->name)
 192     rc = pwmd_command (pwm, NULL, NULL, NULL, NULL, "OPTION NAME=%s",
 193                        pwm->name);
 194
 195   return rc;
 196 }
 197
 198 static gpg_error_t
 199 connect_uds (pwm_t * pwm, const char *path)
 200 {
 201   char *socketpath = NULL;
 202   struct passwd pw;
 203   char *pwbuf;
 204   gpg_error_t rc;
 205
 206   if (!pwm)
 207     return GPG_ERR_INV_ARG;
 208
 209   pwbuf = _getpwuid (&pw);
 210   if (!pwbuf)
 211     return gpg_error_from_syserror ();
 212
 213   if (!path || !*path)
 214     socketpath = pwmd_strdup_printf ("%s/.pwmd/socket", pw.pw_dir);
 215   else
 216     socketpath = _expand_homedir ((char *) path, &pw);
 217
 218   pwmd_free (pwbuf);
 219   if (!socketpath)
 220     return GPG_ERR_ENOMEM;
 221
 222   rc = assuan_socket_connect (pwm->ctx, socketpath, ASSUAN_INVALID_FD, 0);
 223   pwmd_free (socketpath);
 224   return rc ? rc : _connect_finalize (pwm);
 225 }
 226
 227 static gpg_error_t
 228 init_handle (pwm_t * pwm)
 229 {
 230   gpg_error_t rc;
 231   static struct assuan_malloc_hooks mhooks = {
 232     pwmd_malloc, pwmd_realloc, pwmd_free
 233   };
 234   static struct assuan_system_hooks shooks = {
 235     ASSUAN_SYSTEM_HOOKS_VERSION,
 236     __assuan_usleep,
 237     __assuan_pipe,
 238     __assuan_close,
 239     hook_read,
 240     hook_write,
 241     //FIXME
 242     NULL,                       //recvmsg
 243     NULL,                       //sendmsg both are used for FD passing
 244     __assuan_spawn,
 245     hook_waitpid,
 246     __assuan_socketpair,
 247     __assuan_socket,
 248     __assuan_connect
 249   };
 250
 251   rc = assuan_new_ext (&pwm->ctx, GPG_ERR_SOURCE_DEFAULT, &mhooks, NULL,
 252                        NULL);
 253   if (rc)
 254     return rc;
 255
 256   assuan_set_pointer (pwm->ctx, pwm);
 257   assuan_ctx_set_system_hooks (pwm->ctx, &shooks);
 258   return 0;
 259 }
 260
 261 #if defined(WITH_SSH) || defined(WITH_GNUTLS)
 262 void
 263 free_tcp (pwm_t *pwm)
 264 {
 265   struct tcp_s *tcp = pwm->tcp;
 266
 267   if (!tcp)
 268     return;
 269
 270 #ifdef WITH_SSH
 271   _free_ssh_conn (tcp->ssh);
 272 #endif
 273 #ifdef WITH_GNUTLS
 274   tls_free (pwm);
 275 #endif
 276
 277   pwmd_free (tcp->host);
 278   if (tcp->addrs)
 279     {
 280       freeaddrinfo (tcp->addrs);
 281       tcp->addrs = NULL;
 282     }
 283
 284   pthread_cond_destroy (&tcp->dns_cond);
 285   pthread_mutex_destroy (&tcp->dns_mutex);
 286   pwmd_free (tcp);
 287   pwm->tcp = NULL;
 288 }
 289 #endif
 290
 291 #if defined(WITH_SSH) || defined(WITH_GNUTLS)
 292 static void *
 293 resolve_host_thread (void *arg)
 294 {
 295   pwm_t *pwm = arg;
 296   struct addrinfo hints = { 0 };
 297   char portstr[6];
 298
 299   switch (pwm->prot)
 300     {
 301     case PWMD_IP_ANY:
 302       hints.ai_family = AF_UNSPEC;
 303       break;
 304     case PWMD_IPV4:
 305       hints.ai_family = AF_INET;
 306       break;
 307     case PWMD_IPV6:
 308       hints.ai_family = AF_INET6;
 309       break;
 310     }
 311
 312   hints.ai_socktype = SOCK_STREAM;
 313   snprintf (portstr, sizeof (portstr), "%i", pwm->tcp->port);
 314   int *n = pwmd_malloc (sizeof (int));
 315   pthread_cleanup_push (pwmd_free, n);
 316   *n = getaddrinfo (pwm->tcp->host, portstr, &hints, &pwm->tcp->addrs);
 317   pthread_cleanup_pop (0);
 318   pthread_cond_broadcast (&pwm->tcp->dns_cond);
 319   pthread_exit (n);
 320   return NULL;
 321 }
 322
 323 gpg_error_t
 324 tcp_connect_common (pwm_t * pwm)
 325 {
 326 #define TS_TIMEOUT 50000000L
 327   int n;
 328   gpg_error_t rc = 0;
 329   pthread_t tid;
 330   time_t now;
 331
 332   time (&now);
 333   n = pthread_create (&tid, NULL, resolve_host_thread, pwm);
 334   if (n)
 335     return gpg_error_from_errno (n);
 336
 337   pthread_mutex_lock (&pwm->tcp->dns_mutex);
 338
 339   for (;;)
 340     {
 341       struct timespec ts;
 342       int *result = NULL;
 343
 344       clock_gettime (CLOCK_REALTIME, &ts);
 345       if (ts.tv_nsec + TS_TIMEOUT >= 1000000000LL) {
 346           ts.tv_sec++;
 347           ts.tv_nsec = 0;
 348       }
 349       else
 350         ts.tv_nsec += TS_TIMEOUT;
 351
 352       if (pwm->cancel)
 353         {
 354 #ifdef HAVE_PTHREAD_CANCEL
 355           pthread_cancel (tid);
 356           pthread_join (tid, NULL);
 357 #else
 358           pthread_join (tid, (void **)&result);
 359           pwmd_free (result);
 360 #endif
 361           return GPG_ERR_CANCELED;
 362         }
 363
 364       n = pthread_cond_timedwait (&pwm->tcp->dns_cond, &pwm->tcp->dns_mutex,
 365                                   &ts);
 366       if (n == ETIMEDOUT)
 367         {
 368           if (pwm->socket_timeout && ts.tv_sec - now >= pwm->socket_timeout)
 369             {
 370 #ifdef HAVE_PTHREAD_CANCEL
 371               pthread_cancel (tid);
 372               pthread_join (tid, NULL);
 373 #else
 374               pthread_join (tid, (void **)&result);
 375               pwmd_free (result);
 376 #endif
 377               return GPG_ERR_ETIMEDOUT;
 378             }
 379
 380           continue;
 381         }
 382       else if (n)
 383         {
 384 #ifdef HAVE_PTHREAD_CANCEL
 385           pthread_cancel (tid);
 386           pthread_join (tid, NULL);
 387 #else
 388           pthread_join (tid, (void **)&result);
 389           pwmd_free (result);
 390 #endif
 391           return gpg_error_from_errno (n);
 392         }
 393
 394       pthread_join (tid, (void **)&result);
 395       n = *result;
 396       pwmd_free (result);
 397       break;
 398     }
 399
 400   if (n)
 401     return GPG_ERR_UNKNOWN_HOST;        //FIXME
 402
 403   for (pwm->tcp->addr = pwm->tcp->addrs; pwm->tcp->addr;
 404        pwm->tcp->addr = pwm->tcp->addrs->ai_next)
 405     {
 406       pwm->fd = socket (pwm->tcp->addr->ai_family, SOCK_STREAM, 0);
 407       if (pwm->fd == -1)
 408         {
 409           rc = gpg_error_from_syserror ();
 410           if (pwm->tcp->addr == pwm->tcp->addrs->ai_next)
 411             break;
 412           continue;
 413         }
 414
 415       if (fcntl (pwm->fd, F_SETFL, O_NONBLOCK) == -1)
 416         {
 417           rc = gpg_error_from_syserror ();
 418           break;
 419         }
 420
 421       if (connect (pwm->fd, pwm->tcp->addr->ai_addr,
 422                    pwm->tcp->addr->ai_family == AF_INET6
 423                    ? sizeof (struct sockaddr_in6)
 424                    : sizeof (struct sockaddr)) == -1)
 425         {
 426           int n;
 427           struct timeval tv;
 428           fd_set wfds;
 429           unsigned elapsed = 0;
 430
 431           rc = gpg_error_from_syserror ();
 432           if (gpg_err_code (rc) != GPG_ERR_EINPROGRESS)
 433             {
 434               close (pwm->fd);
 435               pwm->fd = -1;
 436               if (pwm->tcp->addr == pwm->tcp->addrs->ai_next)
 437                 return rc;
 438               continue;
 439             }
 440
 441 again:
 442           tv.tv_sec = 1;
 443           tv.tv_usec = 0;
 444           FD_ZERO (&wfds);
 445           FD_SET (pwm->fd, &wfds);
 446           n = select (pwm->fd+1, NULL, &wfds, NULL, &tv);
 447           rc = 0;
 448           if (!n || pwm->cancel)
 449             {
 450               if (pwm->cancel)
 451                 rc = gpg_error (GPG_ERR_CANCELED);
 452               else if (++elapsed >= pwm->socket_timeout)
 453                 rc = gpg_error (GPG_ERR_ETIMEDOUT);
 454               else
 455                 goto again;
 456             }
 457           else if (n != -1)
 458             {
 459               socklen_t len = sizeof(int);
 460
 461               getsockopt (pwm->fd, SOL_SOCKET, SO_ERROR, &n, &len);
 462               if (n)
 463                 rc = gpg_error_from_errno (n);
 464             }
 465           else if (n == -1)
 466             rc = gpg_error_from_syserror ();
 467
 468           if (rc)
 469             {
 470               close (pwm->fd);
 471               pwm->fd = -1;
 472               if (pwm->tcp->addr == pwm->tcp->addrs->ai_next
 473                   || gpg_err_code (rc) == GPG_ERR_ETIMEDOUT
 474                   || pwm->cancel)
 475                 return rc;
 476             }
 477           else
 478             break;
 479         }
 480       else
 481         break;
 482     }
 483
 484   if (!rc)
 485     if (fcntl (pwm->fd, F_SETFL, 0) == -1)
 486       rc = gpg_error_from_syserror ();
 487
 488   return rc;
 489 }
 490 #endif
 491
 492 static void
 493 command_start (pwm_t *pwm)
 494 {
 495   pwm->cancel = 0;
 496 }
 497
 498 gpg_error_t
 499 pwmd_connect (pwm_t * pwm, const char *url, ...)
 500 {
 501   const char *p = url;
 502   gpg_error_t rc;
 503
 504   if (!pwm)
 505     return FINISH (GPG_ERR_INV_ARG);
 506   else if (!pwm->ctx)
 507     {
 508       rc = init_handle (pwm);
 509       if (rc)
 510         return rc;
 511     }
 512
 513   command_start (pwm);
 514
 515   if (!(pwm->opts & OPT_SIGPIPE))
 516     signal (SIGPIPE, SIG_IGN);
 517
 518 #ifdef WITH_GNUTLS
 519   pwm->tls_error = 0;
 520 #endif
 521   rc = GPG_ERR_UNSUPPORTED_PROTOCOL;
 522
 523   if (p && (*p == '/' || *p == '~'))
 524     rc = connect_uds (pwm, p);
 525   else if (!p || !strncmp (p, "file://", 7))
 526     {
 527       if (p)
 528         p += 7;
 529 #ifdef DEFAULT_PWMD_SOCKET
 530       else
 531         p = DEFAULT_PWMD_SOCKET;
 532 #endif
 533       rc = connect_uds (pwm, p);
 534     }
 535   else if (!strncmp (p, "ssh://", 6) || !strncmp (p, "ssh6://", 7) ||
 536            !strncmp (p, "ssh4://", 7))
 537     {
 538 #ifndef WITH_SSH
 539       return FINISH (GPG_ERR_NOT_IMPLEMENTED);
 540 #else
 541       char *host = NULL;
 542       int port;
 543       char *username = NULL;
 544
 545       if (!strncmp (p, "ssh6://", 7))
 546         {
 547           pwm->prot = PWMD_IPV6;
 548           p += 7;
 549         }
 550       else if (!strncmp (p, "ssh4://", 7))
 551         {
 552           pwm->prot = PWMD_IPV4;
 553           p += 7;
 554         }
 555       else
 556         {
 557           pwm->prot = PWMD_IP_ANY;
 558           p += 6;
 559         }
 560
 561       rc = _parse_ssh_url (p, &host, &port, &username);
 562       if (!rc)
 563         {
 564           va_list ap;
 565           char *identity = NULL;
 566           char *knownhosts = NULL;
 567
 568           va_start (ap, url);
 569           identity = va_arg (ap, char *);
 570
 571           if (!identity && !pwm->use_agent)
 572             rc = GPG_ERR_INV_ARG;
 573           else
 574             knownhosts = va_arg (ap, char *);
 575
 576           va_end (ap);
 577
 578           if (!rc)
 579             rc = _do_ssh_connect (pwm, host, port, identity, username,
 580                                   knownhosts);
 581           if (!rc)
 582             {
 583               rc = _connect_finalize (pwm);
 584               if (rc)
 585                 free_tcp (pwm);
 586             }
 587         }
 588
 589       pwmd_free (host);
 590       pwmd_free (username);
 591       pwm->local_pinentry = 1;
 592 #endif
 593     }
 594   else if (!strncmp (p, "tls://", 6) || !strncmp (p, "tls6://", 7) ||
 595            !strncmp (p, "tls4://", 7))
 596     {
 597 #ifndef WITH_GNUTLS
 598       return FINISH (GPG_ERR_NOT_IMPLEMENTED);
 599 #else
 600       char *host = NULL;
 601       int port;
 602
 603       if (!strncmp (p, "tls6://", 7))
 604         {
 605           pwm->prot = PWMD_IPV6;
 606           p += 7;
 607         }
 608       else if (!strncmp (p, "tls4://", 7))
 609         {
 610           pwm->prot = PWMD_IPV4;
 611           p += 7;
 612         }
 613       else
 614         {
 615           pwm->prot = PWMD_IP_ANY;
 616           p += 6;
 617         }
 618
 619       rc = _parse_tls_url (p, &host, &port);
 620       if (!rc)
 621         {
 622           va_list ap;
 623           char *clientcert = NULL;
 624           char *clientkey = NULL;
 625           char *cacert = NULL;
 626           char *prio = NULL;
 627           char *server_fp = NULL;
 628
 629           va_start (ap, url);
 630           clientcert = va_arg (ap, char *);
 631
 632           if (!clientcert)
 633             rc = GPG_ERR_INV_ARG;
 634           else
 635             {
 636               clientkey = va_arg (ap, char *);
 637               if (!clientkey)
 638                 rc = GPG_ERR_INV_ARG;
 639               else
 640                 {
 641                   cacert = va_arg (ap, char *);
 642                   if (!cacert)
 643                     rc = GPG_ERR_INV_ARG;
 644                   else
 645                     {
 646                       prio = va_arg (ap, char *);
 647                       server_fp = va_arg (ap, char *);
 648                     }
 649                 }
 650             }
 651
 652           va_end (ap);
 653
 654           if (!rc)
 655             rc = _do_tls_connect (pwm, host, port, clientcert, clientkey,
 656                                   cacert, prio, server_fp, pwm->tls_verify);
 657           if (!rc)
 658             {
 659               rc = _connect_finalize (pwm);
 660               if (rc)
 661                 free_tcp (pwm);
 662             }
 663         }
 664
 665       pwmd_free (host);
 666       pwm->local_pinentry = 1;
 667 #endif
 668     }
 669
 670   if (!rc)
 671     pwm->connected = 1;
 672
 673   return FINISH (rc);
 674 }
 675
 676 static void
 677 disconnect (pwm_t * pwm)
 678 {
 679   if (!pwm)
 680     return;
 681
 682   if (pwm->ctx)
 683     assuan_release (pwm->ctx);
 684
 685 #if defined(WITH_SSH) || defined(WITH_GNUTLS)
 686   free_tcp (pwm);
 687 #endif
 688   pwm->ctx = NULL;
 689   pwm->fd = -1;
 690   pwm->connected = 0;
 691 }
 692
 693 void
 694 pwmd_close (pwm_t * pwm)
 695 {
 696   if (!pwm)
 697     return;
 698
 699   disconnect (pwm);
 700   pwmd_free (pwm->pinentry_error);
 701   pwmd_free (pwm->pinentry_desc);
 702   pwmd_free (pwm->pinentry_prompt);
 703   pwmd_free (pwm->pinentry_tty);
 704   pwmd_free (pwm->pinentry_display);
 705   pwmd_free (pwm->pinentry_term);
 706   pwmd_free (pwm->pinentry_lcctype);
 707   pwmd_free (pwm->pinentry_lcmessages);
 708   pwmd_free (pwm->filename);
 709   pwmd_free (pwm->name);
 710   pwmd_free (pwm->passphrase_info);
 711   pwmd_free (pwm->passphrase_hint);
 712
 713 #ifdef WITH_PINENTRY
 714   if (pwm->pctx)
 715     _pinentry_disconnect (pwm);
 716 #endif
 717
 718   pwmd_free (pwm);
 719 }
 720
 721 static gpg_error_t
 722 inquire_realloc_cb (void *data, const void *buffer, size_t len)
 723 {
 724   membuf_t *mem = (membuf_t *) data;
 725   void *p;
 726
 727   if (!buffer)
 728     return 0;
 729
 730   if ((p = pwmd_realloc (mem->buf, mem->len + len)) == NULL)
 731     return gpg_error (GPG_ERR_ENOMEM);
 732
 733   mem->buf = p;
 734   memcpy ((char *) mem->buf + mem->len, buffer, len);
 735   mem->len += len;
 736   return 0;
 737 }
 738
 739 static gpg_error_t
 740 get_password (pwm_t * pwm, char **result, size_t * len,
 741               pwmd_pinentry_t w, int echo)
 742 {
 743   char buf[ASSUAN_LINELENGTH+1] = { 0 }, *p;
 744   struct termios told, tnew;
 745   char *key = NULL;
 746
 747   if (result)
 748     *result = NULL;
 749
 750   if (len)
 751     *len = 0;
 752
 753   if (!isatty (STDIN_FILENO))
 754     {
 755       fprintf (stderr, N_("Input is not from a terminal! Failing.\n"));
 756       return GPG_ERR_ENOTTY;
 757     }
 758
 759   if (!echo)
 760     {
 761       if (tcgetattr (STDIN_FILENO, &told) == -1)
 762         return gpg_error_from_syserror ();
 763
 764       memcpy (&tnew, &told, sizeof (struct termios));
 765       tnew.c_lflag &= ~(ECHO);
 766       tnew.c_lflag |= ICANON | ECHONL;
 767
 768       if (tcsetattr (STDIN_FILENO, TCSANOW, &tnew) == -1)
 769         {
 770           int n = errno;
 771
 772           tcsetattr (STDIN_FILENO, TCSANOW, &told);
 773           return gpg_error_from_errno (n);
 774         }
 775     }
 776
 777   if (pwm->passphrase_hint)
 778     fprintf(stderr, N_("Key info: %s\n"), pwm->passphrase_hint);
 779
 780   switch (w)
 781     {
 782     case PWMD_PINENTRY_OPEN:
 783       fprintf (stderr, N_("Password for %s: "), pwm->filename);
 784       break;
 785     case PWMD_PINENTRY_OPEN_FAILED:
 786       fprintf (stderr, N_("Invalid password. Password for %s: "),
 787                pwm->filename);
 788       break;
 789     case PWMD_PINENTRY_SAVE:
 790       fprintf (stderr, N_("New password for %s: "), pwm->filename);
 791       break;
 792     case PWMD_PINENTRY_SAVE_CONFIRM:
 793       fprintf (stderr, N_("Confirm password: "));
 794       break;
 795     default:
 796       break;
 797     }
 798
 799   if ((p = fgets (buf, sizeof (buf), stdin)) == NULL)
 800     {
 801       if (!echo)
 802         tcsetattr (STDIN_FILENO, TCSANOW, &told);
 803       return 0;
 804     }
 805
 806   if (!echo)
 807     tcsetattr (STDIN_FILENO, TCSANOW, &told);
 808
 809   if (feof (stdin))
 810     {
 811       clearerr (stdin);
 812       return GPG_ERR_CANCELED;
 813     }
 814
 815   /* Strip the newline character. */
 816   p[strlen (p) - 1] = 0;
 817
 818   if (buf[0])
 819     {
 820       key = pwmd_strdup_printf ("%s", p);
 821       wipememory (buf, 0, sizeof (buf));
 822       if (!key)
 823         return GPG_ERR_ENOMEM;
 824
 825       if (result)
 826         *result = key;
 827
 828       if (len)
 829         *len = strlen (key);
 830     }
 831   else
 832     {
 833       /* To satisfy inquire_cb(). */
 834       if (result)
 835         *result = pwmd_strdup ("");
 836
 837       if (len)
 838         *len = 1;
 839     }
 840
 841   return 0;
 842 }
 843
 844 gpg_error_t
 845 pwmd_password (pwm_t * pwm, const char *keyword, char **data, size_t * size)
 846 {
 847   gpg_error_t rc;
 848   int new_password = 0;
 849   char *password = NULL, *newpass = NULL;
 850   int error = 0;
 851
 852   command_start (pwm);
 853
 854   if (data)
 855     *data = NULL;
 856
 857   if (size)
 858     *size = 0;
 859
 860   if (!strcmp (keyword, "NEW_PASSPHRASE"))
 861     new_password = 1;
 862
 863   if (!new_password && pwm->pinentry_try)
 864     error = 1;
 865
 866 again:
 867   if (pwm->disable_pinentry)
 868     {
 869       rc = get_password (pwm, &password, size,
 870                          new_password ? PWMD_PINENTRY_SAVE :
 871                          error ? PWMD_PINENTRY_OPEN_FAILED :
 872                          PWMD_PINENTRY_OPEN, 0);
 873       if (!rc && new_password)
 874         rc = get_password (pwm, &newpass, size, PWMD_PINENTRY_SAVE_CONFIRM,
 875                            0);
 876     }
 877   else
 878     {
 879       pwmd_pinentry_t which;
 880
 881       if (error)
 882         which = new_password
 883           ? PWMD_PINENTRY_SAVE_FAILED : PWMD_PINENTRY_OPEN_FAILED;
 884       else
 885         which = new_password ? PWMD_PINENTRY_SAVE : PWMD_PINENTRY_OPEN;
 886
 887       rc = pwmd_getpin (pwm, pwm->filename, &password, size, which);
 888       if (!rc && new_password)
 889         rc = pwmd_getpin (pwm, pwm->filename, &newpass, size,
 890                           PWMD_PINENTRY_SAVE_CONFIRM);
 891     }
 892
 893   if (!rc && new_password)
 894     {
 895       if ((!password && newpass) || (!newpass && password)
 896           || (newpass && password && strcmp (newpass, password)))
 897         {
 898           if (pwm->disable_pinentry)
 899             fprintf (stderr, N_("Passphrases do not match.\n"));
 900
 901           pwmd_free (password);
 902           pwmd_free (newpass);
 903           password = newpass = NULL;
 904           error = 1;
 905           goto again;
 906         }
 907     }
 908
 909   (void) pwmd_getpin (pwm, pwm->filename, NULL, NULL, PWMD_PINENTRY_CLOSE);
 910   pwmd_free (newpass);
 911   if (!rc && data)
 912     *data = password;
 913   else
 914     pwmd_free (password);
 915
 916   return rc;
 917 }
 918
 919 static gpg_error_t
 920 inquire_cb (void *data, const char *keyword)
 921 {
 922   pwm_t *pwm = (pwm_t *) data;
 923   gpg_error_t rc = 0;
 924   int free_result = 0;
 925   char *result = NULL;
 926   int is_password = 0;
 927   int new_password = 0;
 928
 929   if (!strcmp (keyword, "PASSPHRASE") || !strcmp (keyword, "SIGN_PASSPHRASE"))
 930     is_password = 1;
 931   else if (!strcmp (keyword, "NEW_PASSPHRASE") || !strcmp (keyword, "GENKEY"))
 932     new_password = 1;
 933
 934   /* Shouldn't get this far without a callback. */
 935   if (!pwm->override_inquire && !pwm->inquire_func
 936       && !is_password && !new_password)
 937     return gpg_error (GPG_ERR_ASS_NO_INQUIRE_CB);
 938
 939   for (;;)
 940     {
 941       size_t len = 0;
 942       gpg_error_t arc;
 943
 944       result = NULL;
 945
 946       if (!pwm->override_inquire && (is_password || new_password))
 947         {
 948           free_result = 1;
 949           rc = pwmd_password (data, keyword, &result, &len);
 950           if (!rc)
 951             rc = GPG_ERR_EOF;
 952         }
 953       else
 954         rc = pwm->inquire_func (pwm->inquire_data, keyword, rc, &result,
 955                                 &len);
 956
 957       /* gpg will truncate a passphrase at the first nil byte which may be bad
 958        * for generated key files. */
 959       if ((!rc || gpg_err_code (rc) == GPG_ERR_EOF)
 960           && (is_password || new_password))
 961         {
 962           if (len && result && *result)
 963             {
 964               for (size_t n = 0; n < len; n++)
 965                 {
 966                   if (result[n] == 0 && n+1 != len)
 967                     rc = GPG_ERR_INV_PASSPHRASE;
 968                 }
 969             }
 970         }
 971
 972     cancel:
 973       if (rc && gpg_err_code (rc) != GPG_ERR_EOF)
 974         {
 975 #ifndef LIBASSUAN_2_1_0
 976           gpg_error_t trc = rc;
 977
 978           /* Cancel this inquire. */
 979           rc = assuan_send_data (pwm->ctx, NULL, 1);
 980           if (!rc)
 981             {
 982               char *line;
 983               size_t len;
 984
 985               /* There is a bug (or feature?) in assuan_send_data() that
 986                * when cancelling an inquire the next read from the server is
 987                * not done until the next command making the next command
 988                * fail with GPG_ERR_ASS_UNEXPECTED_CMD.
 989                */
 990               rc = assuan_read_line (pwm->ctx, &line, &len);
 991
 992               /* Restore the original error. This differs from the error
 993                * returned from the pwmd command (GPG_ERR_CANCELED). This
 994                * error is returned to the calling function.
 995                */
 996               if (!rc)
 997                 rc = trc;
 998             }
 999 #endif
1000           break;
1001         }
1002
1003       if (gpg_err_code (rc) == GPG_ERR_EOF || !rc)
1004         {
1005           if (len <= 0 && !result)
1006             {
1007               rc = 0;
1008               break;
1009             }
1010           else if ((len <= 0 && result) || (len && !result))
1011             {
1012               rc = gpg_error (GPG_ERR_INV_ARG);
1013               break;
1014             }
1015
1016           if (pwm->inquire_maxlen
1017               && pwm->inquire_sent + len > pwm->inquire_maxlen)
1018             {
1019               rc = gpg_error (GPG_ERR_TOO_LARGE);
1020               if (!free_result)
1021                 rc = pwm->inquire_func (pwm->inquire_data, keyword, rc,
1022                                         &result, &len);
1023               goto cancel;
1024             }
1025
1026           arc = assuan_send_data (pwm->ctx, result, len);
1027           if (gpg_err_code (rc) == GPG_ERR_EOF)
1028             {
1029               rc = arc;
1030               break;
1031             }
1032
1033           rc = arc;
1034         }
1035       else if (rc)
1036         break;
1037
1038       if (!rc)
1039         {
1040           pwm->inquire_sent += len;
1041
1042           if (pwm->status_func)
1043             {
1044               char buf[ASSUAN_LINELENGTH];
1045
1046               snprintf (buf, sizeof (buf), "XFER %zu %zu", pwm->inquire_sent,
1047                         pwm->inquire_total);
1048               rc = pwm->status_func (pwm->status_data, buf);
1049               if (rc)
1050                 continue;
1051             }
1052         }
1053     }
1054
1055   if (free_result)
1056     pwmd_free (result);
1057
1058   pwm->inquire_maxlen = pwm->inquire_sent = 0;
1059   return rc;
1060 }
1061
1062 static gpg_error_t
1063 parse_assuan_line (pwm_t * pwm)
1064 {
1065   gpg_error_t rc;
1066   char *line;
1067   size_t len;
1068
1069   rc = assuan_read_line (pwm->ctx, &line, &len);
1070   if (!rc)
1071     {
1072       if (line[0] == 'O' && line[1] == 'K' &&
1073           (line[2] == 0 || line[2] == ' '))
1074         {
1075         }
1076       else if (line[0] == '#')
1077         {
1078         }
1079       else if (line[0] == 'S' && (line[1] == 0 || line[1] == ' '))
1080         {
1081           if (pwm->status_func)
1082             {
1083               rc = pwm->status_func (pwm->status_data,
1084                                      line[1] == 0 ? line + 1 : line + 2);
1085             }
1086         }
1087       else if (line[0] == 'E' && line[1] == 'R' && line[2] == 'R' &&
1088                (line[3] == 0 || line[3] == ' '))
1089         {
1090           line += 4;
1091           rc = strtol (line, NULL, 10);
1092         }
1093     }
1094
1095   return rc;
1096 }
1097
1098 static void
1099 reset_handle (pwm_t *pwm)
1100 {
1101   pwm->fd = -1;
1102   pwm->cancel = 0;
1103   pwm->pinentry_disabled = 0;
1104 #ifdef WITH_PINENTRY
1105   if (pwm->pctx)
1106     _pinentry_disconnect (pwm);
1107 #endif
1108 #if defined(WITH_SSH) || defined(WITH_GNUTLS)
1109 #ifdef WITH_GNUTLS
1110   pwm->tls_error = 0;
1111 #endif
1112
1113   if (pwm->tcp)
1114     pwm->tcp->rc = 0;
1115 #endif
1116 }
1117
1118 gpg_error_t
1119 pwmd_disconnect (pwm_t * pwm)
1120 {
1121   if (!pwm)
1122     return FINISH (GPG_ERR_INV_ARG);
1123
1124   command_start (pwm);
1125
1126   if (pwm->fd == -1)
1127     return FINISH (GPG_ERR_INV_STATE);
1128
1129   disconnect (pwm);
1130   reset_handle (pwm);
1131   return 0;
1132 }
1133
1134 /* Note that this should only be called when not in a command. */
1135 gpg_error_t
1136 pwmd_process (pwm_t * pwm)
1137 {
1138   gpg_error_t rc = 0;
1139   fd_set fds;
1140   struct timeval tv = { 0, 0 };
1141   int n;
1142
1143   if (!pwm || pwm->fd == -1)
1144     return FINISH (GPG_ERR_INV_ARG);
1145   else if (!pwm->ctx)
1146     return FINISH (GPG_ERR_INV_STATE);
1147
1148   FD_ZERO (&fds);
1149   FD_SET (pwm->fd, &fds);
1150   n = select (pwm->fd + 1, &fds, NULL, NULL, &tv);
1151
1152   if (n == -1)
1153     return FINISH (gpg_error_from_syserror ());
1154
1155   if (n > 0)
1156     {
1157       if (FD_ISSET (pwm->fd, &fds))
1158         rc = parse_assuan_line (pwm);
1159     }
1160
1161   while (!rc && assuan_pending_line (pwm->ctx))
1162     rc = parse_assuan_line (pwm);
1163
1164 #if defined (WITH_SSH) || defined (WITH_GNUTLS)
1165   if (gpg_err_code (rc) == GPG_ERR_EOF && pwm->tcp)
1166     {
1167       close (pwm->fd);
1168       pwm->fd = -1;
1169     }
1170 #endif
1171
1172   return FINISH (rc);
1173 }
1174
1175 static gpg_error_t
1176 status_cb (void *data, const char *line)
1177 {
1178   pwm_t *pwm = data;
1179
1180   if (!strncmp (line, "INQUIRE_MAXLEN ", 15))
1181     pwm->inquire_maxlen = strtol (line + 15, NULL, 10);
1182   else if (!strncmp (line, "PASSPHRASE_HINT ", 16))
1183     {
1184       pwmd_free (pwm->passphrase_hint);
1185       pwm->passphrase_hint = pwmd_strdup (line+16);
1186     }
1187   else if (!strncmp (line, "PASSPHRASE_INFO ", 16))
1188     {
1189       pwmd_free (pwm->passphrase_info);
1190       pwm->passphrase_info = pwmd_strdup (line+16);
1191     }
1192
1193   if (pwm->status_func)
1194     return pwm->status_func (pwm->status_data, line);
1195
1196   return 0;
1197 }
1198
1199 gpg_error_t
1200 _assuan_command (pwm_t * pwm, assuan_context_t ctx,
1201                  char **result, size_t * len, const char *cmd)
1202 {
1203   membuf_t data;
1204   gpg_error_t rc;
1205
1206   if (!cmd || !*cmd)
1207     return FINISH (GPG_ERR_INV_ARG);
1208
1209   if (strlen (cmd) >= ASSUAN_LINELENGTH + 1)
1210     return FINISH (GPG_ERR_LINE_TOO_LONG);
1211
1212   data.len = 0;
1213   data.buf = NULL;
1214   rc = assuan_transact (ctx, cmd, inquire_realloc_cb, &data,
1215 #ifdef WITH_QUALITY
1216                         pwm->pctx == ctx ? pwm->_inquire_func : inquire_cb,
1217                         pwm->pctx == ctx ? pwm->_inquire_data : pwm,
1218 #else
1219                         inquire_cb, pwm,
1220 #endif
1221                         status_cb, pwm);
1222
1223   if (rc)
1224     {
1225       if (data.buf)
1226         {
1227           pwmd_free (data.buf);
1228           data.buf = NULL;
1229         }
1230     }
1231   else
1232     {
1233       if (data.buf)
1234         {
1235           inquire_realloc_cb (&data, "", 1);
1236
1237           if (result)
1238             *result = (char *) data.buf;
1239           else
1240             pwmd_free (data.buf);
1241
1242           if (len)
1243             *len = data.len;
1244         }
1245     }
1246
1247   pwm->inquire_maxlen = 0;
1248   return rc;
1249 }
1250
1251 gpg_error_t
1252 pwmd_command_ap (pwm_t * pwm, char **result, size_t * rlen,
1253                  pwmd_inquire_cb_t func, void *user, const char *cmd,
1254                  va_list ap)
1255 {
1256   char *buf;
1257   size_t len;
1258   va_list ap2;
1259
1260   command_start (pwm);
1261
1262   if (result)
1263     *result = NULL;
1264
1265   if (rlen)
1266     *rlen = 0;
1267
1268   if (!pwm || !cmd)
1269     return FINISH (GPG_ERR_INV_ARG);
1270   if (!pwm->ctx)
1271     return FINISH (GPG_ERR_INV_STATE);
1272
1273   /*
1274    * C99 allows the dst pointer to be null which will calculate the length
1275    * of the would-be result and return it.
1276    */
1277   va_copy (ap2, ap);
1278   len = vsnprintf (NULL, 0, cmd, ap) + 1;
1279   buf = (char *) pwmd_malloc (len);
1280   if (!buf)
1281     {
1282       va_end (ap2);
1283       return FINISH (GPG_ERR_ENOMEM);
1284     }
1285
1286   len = vsnprintf (buf, len, cmd, ap2);
1287   va_end (ap2);
1288
1289   if (buf[strlen (buf) - 1] == '\n')
1290     buf[strlen (buf) - 1] = 0;
1291   if (buf[strlen (buf) - 1] == '\r')
1292     buf[strlen (buf) - 1] = 0;
1293
1294   pwm->inquire_func = func;
1295   pwm->inquire_data = user;
1296   pwm->inquire_sent = 0;
1297   gpg_error_t rc = _assuan_command (pwm, pwm->ctx, result, rlen, buf);
1298   pwmd_free (buf);
1299   return rc;
1300 }
1301
1302 gpg_error_t
1303 pwmd_command (pwm_t * pwm, char **result, size_t * len,
1304               pwmd_inquire_cb_t func, void *user, const char *cmd, ...)
1305 {
1306   va_list ap;
1307
1308   if (result)
1309     *result = NULL;
1310
1311   if (len)
1312     *len = 0;
1313
1314   if (!pwm || !cmd)
1315     return FINISH (GPG_ERR_INV_ARG);
1316   if (!pwm->ctx)
1317     return FINISH (GPG_ERR_INV_STATE);
1318
1319   va_start (ap, cmd);
1320   gpg_error_t rc = pwmd_command_ap (pwm, result, len, func, user, cmd, ap);
1321   va_end (ap);
1322   return rc;
1323 }
1324
1325 static gpg_error_t
1326 send_pinentry_timeout (pwm_t *pwm)
1327 {
1328   gpg_error_t rc = 0;
1329
1330   if ((pwm->pinentry_timeout >= 0
1331       && pwm->pinentry_timeout != pwm->current_pinentry_timeout)
1332       || (pwm->pinentry_timeout == -1
1333           && pwm->pinentry_timeout != pwm->current_pinentry_timeout))
1334     {
1335       rc = pwmd_command (pwm, NULL, NULL, NULL, NULL,
1336                          "OPTION pinentry-timeout=%i",
1337                          pwm->pinentry_timeout);
1338       if (!rc)
1339         pwm->current_pinentry_timeout = pwm->pinentry_timeout;
1340     }
1341
1342   return rc;
1343 }
1344
1345 static gpg_error_t
1346 send_pinentry_options (pwm_t * pwm)
1347 {
1348   gpg_error_t rc;
1349
1350   rc = pwmd_command (pwm, NULL, NULL, NULL, NULL,
1351                      "OPTION disable-pinentry=0");
1352   if (!rc && pwm->pinentry_tty)
1353     rc = pwmd_command (pwm, NULL, NULL, NULL, NULL, "OPTION TTYNAME=%s",
1354                        pwm->pinentry_tty);
1355
1356   if (!rc && pwm->pinentry_term)
1357     rc = pwmd_command (pwm, NULL, NULL, NULL, NULL, "OPTION TTYTYPE=%s",
1358                        pwm->pinentry_term);
1359
1360   if (!rc && pwm->pinentry_display)
1361     rc = pwmd_command (pwm, NULL, NULL, NULL, NULL, "OPTION DISPLAY=%s",
1362                        pwm->pinentry_display);
1363
1364   if (!rc && pwm->pinentry_desc)
1365     rc = pwmd_command (pwm, NULL, NULL, NULL, NULL, "OPTION DESC=%s",
1366                        pwm->pinentry_desc);
1367
1368   if (!rc && pwm->pinentry_lcctype)
1369     rc = pwmd_command (pwm, NULL, NULL, NULL, NULL, "OPTION LC_CTYPE=%s",
1370                        pwm->pinentry_lcctype);
1371
1372   if (!rc && pwm->pinentry_lcmessages)
1373     rc = pwmd_command (pwm, NULL, NULL, NULL, NULL, "OPTION LC_MESSAGES=%s",
1374                        pwm->pinentry_lcmessages);
1375
1376   if (!rc)
1377     rc = send_pinentry_timeout (pwm);
1378
1379   return rc;
1380 }
1381
1382 gpg_error_t
1383 pwmd_socket_type (pwm_t * pwm, pwmd_socket_t * result)
1384 {
1385   if (!pwm || !result)
1386     return FINISH (GPG_ERR_INV_ARG);
1387
1388   *result = PWMD_SOCKET_LOCAL;
1389
1390   if (pwm->fd == -1)
1391     return FINISH (GPG_ERR_INV_STATE);
1392
1393 #if defined(WITH_SSH) || defined(WITH_GNUTLS)
1394 #ifdef WITH_SSH
1395   if (pwm->tcp && pwm->tcp->ssh)
1396     *result = PWMD_SOCKET_SSH;
1397 #endif
1398 #ifdef WITH_GNUTLS
1399   if (pwm->tcp && pwm->tcp->tls)
1400     *result = PWMD_SOCKET_TLS;
1401 #endif
1402 #endif
1403   return 0;
1404 }
1405
1406 static gpg_error_t
1407 disable_pinentry (pwm_t *pwm, int *disable)
1408 {
1409   gpg_error_t rc;
1410 #if defined(WITH_SSH) || defined(WITH_GNUTLS)
1411   int no_pinentry = pwm->disable_pinentry || pwm->tcp || pwm->local_pinentry;
1412 #else
1413   int no_pinentry = pwm->disable_pinentry || pwm->local_pinentry;
1414 #endif
1415
1416   if (disable)
1417     *disable = no_pinentry;
1418
1419   if (pwm->pinentry_disabled && no_pinentry)
1420     return 0;
1421   else if (!pwm->pinentry_disabled && !no_pinentry)
1422     return 0;
1423
1424   rc = pwmd_command (pwm, NULL, NULL, NULL, NULL, "OPTION disable-pinentry=%i",
1425                      no_pinentry);
1426   if (!rc)
1427     pwm->pinentry_disabled = no_pinentry;
1428
1429   return rc;
1430 }
1431
1432 gpg_error_t
1433 pwmd_open (pwm_t * pwm, const char *filename, pwmd_inquire_cb_t cb,
1434            void *data)
1435 {
1436   gpg_error_t rc = 0;
1437   int no_pinentry = 0;
1438
1439   if (!pwm || !filename || !*filename)
1440     return FINISH (GPG_ERR_INV_ARG);
1441
1442   if (!pwm->ctx)
1443     return FINISH (GPG_ERR_INV_STATE);
1444
1445   command_start (pwm);
1446   rc = disable_pinentry (pwm, &no_pinentry);
1447   if (!rc && !no_pinentry)
1448     rc = send_pinentry_options (pwm);
1449
1450   if (!rc)
1451     {
1452       pwm->pinentry_try = 0;
1453       pwmd_free (pwm->filename);
1454       pwm->filename = pwmd_strdup (filename);
1455
1456       do
1457         {
1458           rc = pwmd_command (pwm, NULL, NULL, cb, data, "OPEN %s%s",
1459                              (pwm->opts & OPT_LOCK_ON_OPEN) ? "--lock " : "",
1460                              filename);
1461         }
1462       while (gpg_err_code (rc) == GPG_ERR_BAD_PASSPHRASE
1463              && pwm->pinentry_disabled
1464              && ++pwm->pinentry_try < pwm->pinentry_tries);
1465
1466       pwm->pinentry_try = 0;
1467
1468       if (rc)
1469         {
1470           pwmd_free (pwm->filename);
1471           pwm->filename = NULL;
1472         }
1473     }
1474
1475   pwmd_free (pwm->passphrase_hint);
1476   pwmd_free (pwm->passphrase_info);
1477   pwm->passphrase_info = pwm->passphrase_hint = NULL;
1478   return FINISH (rc);
1479 }
1480
1481 static gpg_error_t
1482 do_pwmd_save_passwd (pwm_t * pwm, const char *args, pwmd_inquire_cb_t cb,
1483                      void *data, int save)
1484 {
1485   gpg_error_t rc = 0;
1486   int no_pinentry = 0;
1487
1488   if (!pwm)
1489     return FINISH (GPG_ERR_INV_ARG);
1490   if (!pwm->ctx)
1491     return FINISH (GPG_ERR_INV_STATE);
1492
1493   command_start (pwm);
1494   rc = disable_pinentry (pwm, &no_pinentry);
1495   if (!rc && !no_pinentry)
1496     rc = send_pinentry_options (pwm);
1497
1498   if (!rc)
1499     rc = pwmd_command (pwm, NULL, NULL, cb, data,
1500                        save ? "SAVE %s" : "PASSWD %s", args ? args : "");
1501
1502   pwmd_free (pwm->passphrase_hint);
1503   pwmd_free (pwm->passphrase_info);
1504   pwm->passphrase_info = pwm->passphrase_hint = NULL;
1505   return FINISH (rc);
1506 }
1507
1508 gpg_error_t
1509 pwmd_passwd (pwm_t * pwm, const char *args, pwmd_inquire_cb_t cb, void *data)
1510 {
1511   return do_pwmd_save_passwd (pwm, args, cb, data, 0);
1512 }
1513
1514 gpg_error_t
1515 pwmd_save (pwm_t * pwm, const char *args, pwmd_inquire_cb_t cb, void *data)
1516 {
1517   return do_pwmd_save_passwd (pwm, args, cb, data, 1);
1518 }
1519
1520 static gpg_error_t
1521 pwmd_get_set_opt (pwm_t *pwm, pwmd_option_t opt, int get, va_list ap)
1522 {
1523   int n, *intp;
1524   size_t *sizetp;
1525   char *arg1, **charpp;
1526   gpg_error_t rc = 0;
1527
1528   if (!pwm)
1529     return GPG_ERR_INV_ARG;
1530
1531   command_start (pwm);
1532   switch (opt)
1533     {
1534     case PWMD_OPTION_SERVER_VERSION:
1535       if (!get)
1536         return GPG_ERR_NOT_SUPPORTED;
1537
1538       if (!pwm)
1539         rc = GPG_ERR_INV_ARG;
1540       else if (!pwm->ctx)
1541         rc = GPG_ERR_INV_STATE;
1542       else
1543         {
1544           unsigned *u = va_arg (ap, unsigned *);
1545           *u = pwm->version;
1546         }
1547
1548       break;
1549     case PWMD_OPTION_SIGPIPE:
1550       if (get)
1551         {
1552           intp = va_arg (ap, int *);
1553           *intp = pwm->opts & OPT_SIGPIPE ? 1 : 0;
1554           break;
1555         }
1556
1557       n = va_arg (ap, int);
1558       if (n < 0 || n > 1)
1559         rc = GPG_ERR_INV_VALUE;
1560
1561       if (n)
1562         pwm->opts |= OPT_SIGPIPE;
1563       else
1564         pwm->opts &= ~OPT_SIGPIPE;
1565
1566       break;
1567     case PWMD_OPTION_LOCK_ON_OPEN:
1568       if (get)
1569         {
1570           intp = va_arg (ap, int *);
1571           *intp = pwm->opts & OPT_LOCK_ON_OPEN ? 1 : 0;
1572           break;
1573         }
1574
1575       n = va_arg (ap, int);
1576
1577       if (n < 0 || n > 1)
1578         rc = GPG_ERR_INV_VALUE;
1579
1580       if (n)
1581         pwm->opts |= OPT_LOCK_ON_OPEN;
1582       else
1583         pwm->opts &= ~OPT_LOCK_ON_OPEN;
1584
1585       break;
1586     case PWMD_OPTION_INQUIRE_TOTAL:
1587       if (get)
1588         {
1589           sizetp = va_arg (ap, size_t *);
1590           *sizetp = pwm->inquire_total;
1591           break;
1592         }
1593
1594       pwm->inquire_total = va_arg (ap, size_t);
1595       break;
1596     case PWMD_OPTION_STATUS_CB:
1597       if (get)
1598         {
1599           pwmd_status_cb_t *cb = va_arg (ap, pwmd_status_cb_t *);
1600
1601           *cb = pwm->status_func;
1602           break;
1603         }
1604
1605       pwm->status_func = va_arg (ap, pwmd_status_cb_t);
1606       break;
1607     case PWMD_OPTION_STATUS_DATA:
1608       if (get)
1609         {
1610           void **data = va_arg (ap, void **);
1611
1612           *data = pwm->status_data;
1613           break;
1614         }
1615
1616       pwm->status_data = va_arg (ap, void *);
1617       break;
1618     case PWMD_OPTION_NO_PINENTRY:
1619       if (get)
1620         {
1621           intp = va_arg (ap, int *);
1622           *intp = pwm->disable_pinentry;
1623           break;
1624         }
1625
1626       n = va_arg (ap, int);
1627
1628       if (n < 0 || n > 1)
1629         rc = GPG_ERR_INV_VALUE;
1630       else
1631         pwm->disable_pinentry = n;
1632       break;
1633     case PWMD_OPTION_LOCAL_PINENTRY:
1634       if (get)
1635         {
1636           intp = va_arg (ap, int *);
1637           *intp = pwm->local_pinentry;
1638           break;
1639         }
1640
1641       n = va_arg (ap, int);
1642
1643       if (n < 0 || n > 1)
1644         rc = GPG_ERR_INV_VALUE;
1645       else
1646         pwm->local_pinentry = n;
1647
1648       break;
1649     case PWMD_OPTION_PINENTRY_TIMEOUT:
1650       if (get)
1651         {
1652           intp = va_arg (ap, int *);
1653           *intp = pwm->pinentry_timeout;
1654           break;
1655         }
1656
1657       n = va_arg (ap, int);
1658
1659       if (n < 0)
1660         rc = GPG_ERR_INV_VALUE;
1661       else
1662         pwm->pinentry_timeout = n;
1663       break;
1664     case PWMD_OPTION_PINENTRY_TRIES:
1665       if (get)
1666         {
1667           intp = va_arg (ap, int *);
1668           *intp = pwm->pinentry_tries;
1669           break;
1670         }
1671
1672       n = va_arg (ap, int);
1673       pwm->pinentry_tries = n;
1674       break;
1675     case PWMD_OPTION_PINENTRY_PATH:
1676       if (get)
1677         {
1678           charpp = va_arg (ap, char **);
1679           *charpp = pwm->pinentry_path;
1680           break;
1681         }
1682
1683       arg1 = va_arg (ap, char *);
1684       pwmd_free (pwm->pinentry_path);
1685       pwm->pinentry_path = arg1 ? _expand_homedir (arg1, NULL) : NULL;
1686       break;
1687     case PWMD_OPTION_PINENTRY_TTY:
1688       if (get)
1689         {
1690           charpp = va_arg (ap, char **);
1691           *charpp = pwm->pinentry_tty;
1692           break;
1693         }
1694
1695       arg1 = va_arg (ap, char *);
1696       pwmd_free (pwm->pinentry_tty);
1697       pwm->pinentry_tty = arg1 ? pwmd_strdup (arg1) : NULL;
1698       break;
1699     case PWMD_OPTION_PINENTRY_DISPLAY:
1700       if (get)
1701         {
1702           charpp = va_arg (ap, char **);
1703           *charpp = pwm->pinentry_display;
1704           break;
1705         }
1706
1707       arg1 = va_arg (ap, char *);
1708       pwmd_free (pwm->pinentry_display);
1709       pwm->pinentry_display = arg1 ? pwmd_strdup (arg1) : NULL;
1710       break;
1711     case PWMD_OPTION_PINENTRY_TERM:
1712       if (get)
1713         {
1714           charpp = va_arg (ap, char **);
1715           *charpp = pwm->pinentry_term;
1716           break;
1717         }
1718
1719       arg1 = va_arg (ap, char *);
1720       pwmd_free (pwm->pinentry_term);
1721       pwm->pinentry_term = arg1 ? pwmd_strdup (arg1) : NULL;
1722       break;
1723     case PWMD_OPTION_PINENTRY_ERROR:
1724       if (get)
1725         {
1726           charpp = va_arg (ap, char **);
1727           *charpp = pwm->pinentry_error;
1728           break;
1729         }
1730
1731       arg1 = va_arg (ap, char *);
1732       pwmd_free (pwm->pinentry_error);
1733       pwm->pinentry_error = arg1 ? _percent_escape (arg1) : NULL;
1734       break;
1735     case PWMD_OPTION_PINENTRY_PROMPT:
1736       if (get)
1737         {
1738           charpp = va_arg (ap, char **);
1739           *charpp = pwm->pinentry_prompt;
1740           break;
1741         }
1742
1743       arg1 = va_arg (ap, char *);
1744       pwmd_free (pwm->pinentry_prompt);
1745       pwm->pinentry_prompt = arg1 ? _percent_escape (arg1) : NULL;
1746       break;
1747     case PWMD_OPTION_PINENTRY_DESC:
1748       if (get)
1749         {
1750           charpp = va_arg (ap, char **);
1751           *charpp = pwm->pinentry_desc;
1752           break;
1753         }
1754
1755       arg1 = va_arg (ap, char *);
1756       pwmd_free (pwm->pinentry_desc);
1757       pwm->pinentry_desc = arg1 ? _percent_escape (arg1) : NULL;
1758       break;
1759     case PWMD_OPTION_PINENTRY_LC_CTYPE:
1760       if (get)
1761         {
1762           charpp = va_arg (ap, char **);
1763           *charpp = pwm->pinentry_lcctype;
1764           break;
1765         }
1766
1767       arg1 = va_arg (ap, char *);
1768       pwmd_free (pwm->pinentry_lcctype);
1769       pwm->pinentry_lcctype = arg1 ? pwmd_strdup (arg1) : NULL;
1770       break;
1771     case PWMD_OPTION_PINENTRY_LC_MESSAGES:
1772       if (get)
1773         {
1774           charpp = va_arg (ap, char **);
1775           *charpp = pwm->pinentry_lcmessages;
1776           break;
1777         }
1778
1779       arg1 = va_arg (ap, char *);
1780       pwmd_free (pwm->pinentry_lcmessages);
1781       pwm->pinentry_lcmessages = arg1 ? pwmd_strdup (arg1) : NULL;
1782       break;
1783     case PWMD_OPTION_KNOWNHOST_CB:
1784       if (get)
1785         {
1786           pwmd_knownhost_cb_t *cb = va_arg (ap, pwmd_knownhost_cb_t *);
1787
1788           *cb = pwm->kh_cb;
1789           break;
1790         }
1791
1792       pwm->kh_cb = va_arg (ap, pwmd_knownhost_cb_t);
1793       break;
1794     case PWMD_OPTION_KNOWNHOST_DATA:
1795       if (get)
1796         {
1797           void **data = va_arg (ap, void **);
1798
1799           *data = pwm->kh_data;
1800           break;
1801         }
1802
1803       pwm->kh_data = va_arg (ap, void *);
1804       break;
1805     case PWMD_OPTION_SSH_AGENT:
1806       if (get)
1807         {
1808           intp = va_arg (ap, int *);
1809           *intp = pwm->use_agent;
1810           break;
1811         }
1812
1813       pwm->use_agent = va_arg (ap, int);
1814
1815       if (pwm->use_agent < 0 || pwm->use_agent > 1)
1816         {
1817           pwm->use_agent = 0;
1818           rc = GPG_ERR_INV_VALUE;
1819         }
1820       break;
1821     case PWMD_OPTION_SSH_NEEDS_PASSPHRASE:
1822       if (get)
1823         {
1824           intp = va_arg (ap, int *);
1825           *intp = pwm->needs_passphrase;
1826           break;
1827         }
1828
1829       pwm->needs_passphrase = va_arg (ap, int);
1830
1831       if (pwm->needs_passphrase < 0 || pwm->needs_passphrase > 1)
1832         {
1833           pwm->needs_passphrase = 0;
1834           rc = GPG_ERR_INV_VALUE;
1835         }
1836       break;
1837     case PWMD_OPTION_TLS_VERIFY:
1838       if (get)
1839         {
1840           intp = va_arg (ap, int *);
1841           *intp = pwm->tls_verify;
1842           break;
1843         }
1844
1845       pwm->tls_verify = va_arg (ap, int);
1846
1847       if (pwm->tls_verify < 0 || pwm->tls_verify > 1)
1848         {
1849           pwm->tls_verify = 0;
1850           rc = GPG_ERR_INV_VALUE;
1851         }
1852       break;
1853     case PWMD_OPTION_SOCKET_TIMEOUT:
1854       if (get)
1855         {
1856           intp = va_arg (ap, int *);
1857           *intp = pwm->socket_timeout;
1858           break;
1859         }
1860
1861       pwm->socket_timeout = va_arg (ap, int);
1862       if (pwm->socket_timeout < 0)
1863         {
1864           pwm->socket_timeout = 0;
1865           rc = GPG_ERR_INV_VALUE;
1866         }
1867
1868 #ifdef WITH_SSH
1869       if (pwm->tcp && pwm->tcp->ssh && pwm->tcp->ssh->session)
1870         {
1871           pwm->tcp->ssh->timeout = pwm->socket_timeout;
1872           libssh2_session_set_timeout (pwm->tcp->ssh->session,
1873                                        pwm->socket_timeout * 1000);
1874         }
1875 #endif
1876 #ifdef WITH_GNUTLS
1877       if (pwm->tcp && pwm->tcp->tls && pwm->tcp->tls->session)
1878         pwm->tcp->tls->timeout = pwm->socket_timeout;
1879 #endif
1880       break;
1881     case PWMD_OPTION_OVERRIDE_INQUIRE:
1882       if (get)
1883         {
1884           intp = va_arg (ap, int *);
1885           *intp = pwm->override_inquire;
1886           break;
1887         }
1888
1889       pwm->override_inquire = va_arg (ap, int);
1890
1891       if (pwm->override_inquire < 0 || pwm->override_inquire > 1)
1892         {
1893           pwm->override_inquire = 0;
1894           rc = GPG_ERR_INV_VALUE;
1895         }
1896       break;
1897     default:
1898       rc = GPG_ERR_UNKNOWN_OPTION;
1899       break;
1900     }
1901
1902   return FINISH (rc);
1903 }
1904
1905 gpg_error_t
1906 pwmd_setopt (pwm_t * pwm, pwmd_option_t opt, ...)
1907 {
1908   va_list ap;
1909   gpg_error_t rc = 0;
1910
1911   va_start (ap, opt);
1912   rc = pwmd_get_set_opt (pwm, opt, 0, ap);
1913   va_end (ap);
1914   return FINISH (rc);
1915 }
1916
1917 gpg_error_t
1918 pwmd_getopt (pwm_t *pwm, pwmd_option_t opt, ...)
1919 {
1920   va_list ap;
1921   gpg_error_t rc = 0;
1922
1923   va_start (ap, opt);
1924   rc = pwmd_get_set_opt (pwm, opt, 1, ap);
1925   va_end (ap);
1926   return FINISH (rc);
1927 }
1928
1929 gpg_error_t
1930 pwmd_new (const char *name, pwm_t ** pwm)
1931 {
1932   pwm_t *h = pwmd_calloc (1, sizeof (pwm_t));
1933   gpg_error_t rc;
1934
1935   if (!h)
1936     return FINISH (GPG_ERR_ENOMEM);
1937
1938   if (name)
1939     {
1940       h->name = pwmd_strdup (name);
1941       if (!h->name)
1942         {
1943           pwmd_free (h);
1944           return FINISH (GPG_ERR_ENOMEM);
1945         }
1946     }
1947
1948   reset_handle (h);
1949   h->pinentry_timeout = -1;
1950   h->current_pinentry_timeout = -1;
1951   h->pinentry_tries = 3;
1952 #if defined(WITH_SSH) || defined(WITH_GNUTLS)
1953   h->prot = PWMD_IP_ANY;
1954 #endif
1955
1956   if (isatty (STDOUT_FILENO))
1957     {
1958       char buf[256];
1959       int err = ttyname_r (STDOUT_FILENO, buf, sizeof (buf));
1960
1961       if (!err)
1962         {
1963           h->pinentry_tty = pwmd_strdup (buf);
1964           if (!h->pinentry_tty)
1965             {
1966               rc = GPG_ERR_ENOMEM;
1967               goto fail;
1968             }
1969         }
1970     }
1971
1972   if (getenv ("TERM") && h->pinentry_tty)
1973     {
1974       h->pinentry_term = pwmd_strdup (getenv ("TERM"));
1975       if (!h->pinentry_term)
1976         {
1977           rc = GPG_ERR_ENOMEM;
1978           goto fail;
1979         }
1980     }
1981
1982   if (getenv ("DISPLAY"))
1983     {
1984       h->pinentry_display = pwmd_strdup (getenv ("DISPLAY"));
1985       if (!h->pinentry_display)
1986         {
1987           rc = GPG_ERR_ENOMEM;
1988           goto fail;
1989         }
1990     }
1991
1992   *pwm = h;
1993   return 0;
1994
1995 fail:
1996   pwmd_close (h);
1997   return FINISH (rc);
1998 }
1999
2000 void
2001 pwmd_free (void *ptr)
2002 {
2003   _xfree (ptr);
2004 }
2005
2006 void *
2007 pwmd_malloc (size_t size)
2008 {
2009   return _xmalloc (size);
2010 }
2011
2012 void *
2013 pwmd_calloc (size_t nmemb, size_t size)
2014 {
2015   return _xcalloc (nmemb, size);
2016 }
2017
2018 void *
2019 pwmd_realloc (void *ptr, size_t size)
2020 {
2021   return _xrealloc (ptr, size);
2022 }
2023
2024 char *
2025 pwmd_strdup (const char *str)
2026 {
2027   char *t;
2028   size_t len;
2029   register size_t c;
2030
2031   len = strlen (str);
2032   t = _xmalloc ((len + 1) * sizeof (char));
2033   if (!t)
2034     return NULL;
2035
2036   for (c = 0; c < len; c++)
2037     t[c] = str[c];
2038
2039   t[c] = 0;
2040   return t;
2041 }
2042
2043 char *
2044 pwmd_strdup_printf (const char *fmt, ...)
2045 {
2046   va_list ap, ap2;
2047   int len;
2048   char *buf;
2049
2050   if (!fmt)
2051     return NULL;
2052
2053   va_start (ap, fmt);
2054   va_copy (ap2, ap);
2055   len = vsnprintf (NULL, 0, fmt, ap);
2056   va_end (ap);
2057   buf = pwmd_malloc (++len);
2058   if (buf)
2059     vsnprintf (buf, len, fmt, ap2);
2060
2061   va_end (ap2);
2062   return buf;
2063 }
2064
2065 gpg_error_t
2066 pwmd_getpin (pwm_t * pwm, const char *filename, char **result,
2067              size_t * len, pwmd_pinentry_t which)
2068 {
2069 #ifndef WITH_PINENTRY
2070   return FINISH (GPG_ERR_NOT_IMPLEMENTED);
2071 #else
2072   command_start (pwm);
2073   gpg_error_t rc = _pwmd_getpin (pwm, filename, result, len, which);
2074
2075   return FINISH (rc);
2076 #endif
2077 }
2078
2079 const char *
2080 pwmd_version ()
2081 {
2082   return LIBPWMD_VERSION_STR;
2083 }
2084
2085 unsigned int
2086 pwmd_features ()
2087 {
2088   unsigned int n = 0;
2089
2090 #ifdef WITH_PINENTRY
2091   n |= PWMD_FEATURE_PINENTRY;
2092 #endif
2093 #ifdef WITH_SSH
2094   n |= PWMD_FEATURE_SSH;
2095 #endif
2096 #ifdef WITH_QUALITY
2097   n |= PWMD_FEATURE_CRACK;
2098 #endif
2099 #ifdef WITH_GNUTLS
2100   n |= PWMD_FEATURE_GNUTLS;
2101 #endif
2102   return n;
2103 }
2104
2105 gpg_error_t
2106 pwmd_fd (pwm_t * pwm, int *fd)
2107 {
2108   if (!pwm || !fd)
2109     return FINISH (GPG_ERR_INV_ARG);
2110
2111   if (pwm->fd == -1)
2112     return FINISH (GPG_ERR_INV_STATE);
2113
2114   *fd = pwm->fd;
2115   return 0;
2116 }
2117
2118 void
2119 pwmd_set_pointer (pwm_t *pwm, void *data)
2120 {
2121   pwm->user_data = data;
2122 }
2123
2124 void *
2125 pwmd_get_pointer (pwm_t *pwm)
2126 {
2127   return pwm->user_data;
2128 }
2129
2130 int
2131 pwmd_tls_error (pwm_t *pwm)
2132 {
2133 #ifndef WITH_GNUTLS
2134   return 0;
2135 #else
2136   return pwm ? pwm->tls_error : 0;
2137 #endif
2138 }
2139
2140 int
2141 pwmd_gnutls_error (pwm_t *pwm, const char **str)
2142 {
2143 #ifndef WITH_GNUTLS
2144   return 0;
2145 #else
2146   if (str && pwm && pwm->tls_error)
2147     *str = gnutls_strerror (pwm->tls_error);
2148
2149   return pwm ? pwm->tls_error : 0;
2150 #endif
2151 }
2152
2153 gpg_error_t
2154 pwmd_cancel (pwm_t *pwm)
2155 {
2156   if (!pwm)
2157     return FINISH (GPG_ERR_INV_ARG);
2158
2159 #if defined(WITH_SSH) || defined(WITH_GNUTLS)
2160   if (pwm->fd == -1 && !pwm->tcp)
2161 #else
2162   if (pwm->fd == -1)
2163 #endif
2164     return FINISH (GPG_ERR_INV_STATE);
2165
2166   /* Can only cancel the connection for the time being. */
2167   if (pwm->connected)
2168     return FINISH (GPG_ERR_INV_STATE);
2169
2170   pwm->cancel = 1;
2171   return 0;
2172 }