libpwmd.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006-2008 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 <libpwmd.h>
  39
  40 #ifdef HAVE_CONFIG_H
  41 #include <config.h>
  42 #endif
  43
  44 #ifdef WITH_LIBPTH
  45 #include <pth.h>
  46 #endif
  47
  48 #ifdef HAVE_ASSUAN_H
  49 #include <assuan.h>
  50 #endif
  51
  52 #ifdef HAVE_SETLOCALE
  53 #include <locale.h>
  54 #endif
  55
  56 #include "gettext.h"
  57 #define N_(msgid)       dgettext("libpwmd", msgid)
  58
  59 #ifndef MEM_DEBUG
  60 #include "mem.h"
  61 #else
  62 #define xfree           free
  63 #define xrealloc        realloc
  64 #define xmalloc         malloc
  65 #define xstrdup         strdup
  66 #define xcalloc         calloc
  67 #endif
  68
  69 #include "types.h"
  70
  71 #ifdef USE_PINENTRY
  72 static pwm_t *gpwm;
  73 static int gelapsed, gtimeout;
  74 static gpg_error_t pinentry_command(pwm_t *pwm, char **result, const char *cmd);
  75 static gpg_error_t global_error;
  76 #endif
  77
  78 const char *pwmd_strerror(gpg_error_t e)
  79 {
  80     gpg_err_code_t code = gpg_err_code(e);
  81
  82     if (code >= GPG_ERR_USER_1 && code < gpg_err_code(EPWMD_MAX)) {
  83         switch (code) {
  84             case GPG_ERR_USER_1:
  85             default:
  86                 return N_("Unknown error");
  87             case GPG_ERR_USER_2:
  88                 return N_("No cache slots available");
  89             case GPG_ERR_USER_3:
  90                 return N_("Recursion loop");
  91             case GPG_ERR_USER_4:
  92                 return N_("No file is open");
  93             case GPG_ERR_USER_5:
  94                 return N_("General LibXML error");
  95             case GPG_ERR_USER_6:
  96                 return N_("File modified");
  97         }
  98     }
  99
 100     return gpg_strerror(e);
 101 }
 102
 103 gpg_error_t pwmd_init()
 104 {
 105 #ifdef ENABLE_NLS
 106     bindtextdomain("libpwmd", LOCALEDIR);
 107 #endif
 108     gpg_err_init();
 109     assuan_set_malloc_hooks(xmalloc, xrealloc, xfree);
 110     assuan_set_assuan_err_source(GPG_ERR_SOURCE_DEFAULT);
 111     return 0;
 112 }
 113
 114 pwm_t *pwmd_connect(const char *path, gpg_error_t *error)
 115 {
 116     pwm_t *pwm = NULL;
 117     char *socketpath = NULL;
 118     time_t now;
 119     struct passwd *pw;
 120     assuan_context_t ctx;
 121     int rc, n;
 122     int active[2];
 123
 124     if (!path) {
 125         pw = getpwuid(getuid());
 126         socketpath = (char *)xmalloc(strlen(pw->pw_dir) + strlen("/.pwmd/socket") + 1);
 127         sprintf(socketpath, "%s/.pwmd/socket", pw->pw_dir);
 128     }
 129     else
 130         socketpath = xstrdup(path);
 131
 132     rc = assuan_socket_connect_ext(&ctx, socketpath, -1, 0);
 133     xfree(socketpath);
 134
 135     if (rc) {
 136         *error = rc;
 137         return NULL;
 138     }
 139
 140     n = assuan_get_active_fds(ctx, 0, active, sizeof(active));
 141
 142     if ((pwm = (pwm_t *)xcalloc(1, sizeof(pwm_t))) == NULL) {
 143         *error = gpg_error_from_errno(errno);
 144         assuan_disconnect(ctx);
 145         return NULL;
 146     }
 147
 148     pwm->fd = n <= 0 ? -1 : dup(active[0]);
 149
 150     if (pwm->fd != -1)
 151         fcntl(pwm->fd, F_SETFL, O_NONBLOCK);
 152
 153     pwm->ctx = ctx;
 154 #ifdef USE_PINENTRY
 155     pwm->pid = -1;
 156     pwm->pinentry_tries = 3;
 157 #endif
 158     time(&now);
 159     srandom(now);
 160     *error = 0;
 161     return pwm;
 162 }
 163
 164 gpg_error_t pwmd_pending_line(pwm_t *pwm, char **line, size_t *len)
 165 {
 166     if (!pwm)
 167         return GPG_ERR_INV_ARG;
 168
 169     if (assuan_pending_line(pwm->ctx))
 170         return assuan_read_line(pwm->ctx, line, len);
 171
 172     return GPG_ERR_NO_DATA;
 173 }
 174
 175 void pwmd_close(pwm_t *pwm)
 176 {
 177     if (!pwm)
 178         return;
 179
 180     if (pwm->ctx)
 181         assuan_disconnect(pwm->ctx);
 182
 183     if (pwm->password)
 184         xfree(pwm->password);
 185
 186     if (pwm->title)
 187         xfree(pwm->title);
 188
 189     if (pwm->desc)
 190         xfree(pwm->desc);
 191
 192     if (pwm->prompt)
 193         xfree(pwm->prompt);
 194
 195     if (pwm->pinentry_tty)
 196         xfree(pwm->pinentry_tty);
 197
 198     if (pwm->pinentry_display)
 199         xfree(pwm->pinentry_display);
 200
 201     if (pwm->pinentry_term)
 202         xfree(pwm->pinentry_term);
 203
 204     if (pwm->filename)
 205         xfree(pwm->filename);
 206
 207     xfree(pwm);
 208 }
 209
 210 static int mem_realloc_cb(void *data, const void *buffer, size_t len)
 211 {
 212     membuf_t *mem = (membuf_t *)data;
 213     void *p;
 214
 215     if (!buffer)
 216         return 0;
 217
 218     if ((p = xrealloc(mem->buf, mem->len + len)) == NULL)
 219         return 1;
 220
 221     mem->buf = p;
 222     memcpy((char *)mem->buf + mem->len, buffer, len);
 223     mem->len += len;
 224     return 0;
 225 }
 226
 227 void pwmd_free_result(void *data)
 228 {
 229     xfree(data);
 230 }
 231
 232 static int _inquire_cb(void *data, const char *keyword)
 233 {
 234     pwm_t *pwm = (pwm_t *)data;
 235     gpg_error_t rc = 0;
 236     int flags = fcntl(pwm->fd, F_GETFL);
 237
 238     /* Shouldn't get this far without a callback. */
 239     if (!pwm->inquire_func)
 240         return GPG_ERR_INV_ARG;
 241
 242     /*
 243      * Since the socket file descriptor is probably set to non-blocking, set to
 244      * blocking to prevent GPG_ERR_EAGAIN errors. This should be fixes when
 245      * asynchronous INQUIRE is supported by either libassuan or a later
 246      * libpwmd.
 247      */
 248     fcntl(pwm->fd, F_SETFL, 0);
 249
 250     for (;;) {
 251         char *result = NULL;
 252         size_t len;
 253         gpg_error_t arc;
 254
 255         rc = pwm->inquire_func(pwm->inquire_data, keyword, rc, &result, &len);
 256         rc = gpg_err_code(rc);
 257
 258         if (rc == GPG_ERR_EOF || !rc) {
 259             if (len <= 0 || !result || !*result) {
 260                 rc = 0;
 261                 break;
 262             }
 263
 264             arc = assuan_send_data(pwm->ctx, result, len);
 265
 266             if (rc == GPG_ERR_EOF) {
 267                 rc = arc;
 268                 break;
 269             }
 270
 271             rc = arc;
 272         }
 273         else if (rc)
 274             break;
 275     }
 276
 277     fcntl(pwm->fd, F_SETFL, flags);
 278     return rc;
 279 }
 280
 281 gpg_error_t pwmd_finalize(pwm_t *pwm)
 282 {
 283     if (!pwm || pwm->fd < 0)
 284         return GPG_ERR_INV_ARG;
 285
 286     pwm->state = ASYNC_INIT;
 287     pwm->ntries = 0;
 288     pwm->is_open_cmd = 0;
 289     return 0;
 290 }
 291
 292 static gpg_error_t do_nb_command(pwm_t *pwm, const char *cmd, const char *arg)
 293 {
 294     char *buf;
 295     gpg_error_t rc;
 296     size_t len = strlen(cmd) + 2;
 297
 298     len += arg ? strlen(arg) : 0;
 299
 300     if (pwm->state != ASYNC_INIT)
 301         return GPG_ERR_UNEXPECTED;
 302
 303     buf = (char *)xmalloc(len);
 304
 305     if (!buf) {
 306         rc = gpg_error_from_errno(ENOMEM);
 307         goto fail;
 308     }
 309
 310     snprintf(buf, len, "%s %s", cmd, arg ? arg : "");
 311     rc = assuan_write_line(pwm->ctx, buf);
 312     xfree(buf);
 313
 314     if (!rc)
 315         pwm->state = ASYNC_PROCESS;
 316
 317 fail:
 318     return rc;
 319 }
 320
 321 gpg_error_t pwmd_open_async(pwm_t *pwm, const char *filename)
 322 {
 323     if (!pwm || !filename)
 324         return GPG_ERR_INV_ARG;
 325
 326     /* For pinentry retries. */
 327     if (!pwm->is_open_cmd) {
 328         if (pwm->filename)
 329             xfree(pwm->filename);
 330
 331         pwm->filename = xstrdup(filename);
 332     }
 333
 334     pwm->is_open_cmd = 1;
 335     return do_nb_command(pwm, "OPEN", filename);
 336 }
 337
 338 gpg_error_t pwmd_save_async(pwm_t *pwm)
 339 {
 340     if (!pwm)
 341         return GPG_ERR_INV_ARG;
 342
 343     return do_nb_command(pwm, "SAVE", NULL);
 344 }
 345
 346 static gpg_error_t parse_assuan_line(pwm_t *pwm)
 347 {
 348     gpg_error_t rc;
 349     char *line;
 350     size_t len;
 351
 352     rc = assuan_read_line(pwm->ctx, &line, &len);
 353
 354     if (!rc) {
 355         if (line[0] == 'O' && line[1] == 'K' &&
 356                 (line[2] == 0 || line[2] == ' ')) {
 357             pwm->state = ASYNC_DONE;
 358         }
 359         else if (line[0] == '#') {
 360         }
 361         else if (line[0] == 'S' && (line[1] == 0 || line[1] == ' ')) {
 362             if (pwm->status_func) {
 363                 pwm->status_func(pwm->status_data,
 364                         line[1] == 0 ? line+1 : line+2);
 365             }
 366         }
 367         else if (line[0] == 'E' && line[1] == 'R' && line[2] == 'R' &&
 368                 (line[3] == 0 || line[3] == ' ')) {
 369             line += 4;
 370             rc = atoi(line);
 371             pwm->state = ASYNC_DONE;
 372         }
 373     }
 374
 375     return rc;
 376 }
 377
 378 pwmd_async_t pwmd_process(pwm_t *pwm, gpg_error_t *rc)
 379 {
 380     fd_set rfds;
 381     int n;
 382     struct timeval tv = {0, 0};
 383
 384     *rc = 0;
 385
 386     if (!pwm || pwm->fd < 0) {
 387         *rc = GPG_ERR_INV_ARG;
 388         return ASYNC_DONE;
 389     }
 390     else if (pwm->state == ASYNC_DONE)
 391         return pwm->state;
 392     else if (pwm->state == ASYNC_INIT) {
 393         *rc = GPG_ERR_UNEXPECTED;
 394         return ASYNC_DONE;
 395     }
 396
 397     FD_ZERO(&rfds);
 398     FD_SET(pwm->fd, &rfds);
 399 #ifdef WITH_LIBPTH
 400     n = pth_select(pwm->fd+1, &rfds, NULL, NULL, &tv);
 401 #else
 402     n = select(pwm->fd+1, &rfds, NULL, NULL, &tv);
 403 #endif
 404
 405     if (n > 0) {
 406         if (FD_ISSET(pwm->fd, &rfds))
 407             *rc = parse_assuan_line(pwm);
 408     }
 409
 410     while (!*rc && assuan_pending_line(pwm->ctx))
 411         *rc = parse_assuan_line(pwm);
 412
 413     if (pwm->is_open_cmd && gpg_err_code(*rc) == EPWMD_BADKEY &&
 414             ++pwm->ntries < pwm->pinentry_tries) {
 415         pwm->state = ASYNC_INIT;
 416         *rc = pwmd_open_async(pwm, pwm->filename);
 417     }
 418
 419     return pwm->state;
 420 }
 421
 422 static gpg_error_t assuan_command(pwm_t *pwm, assuan_context_t ctx,
 423         char **result, const char *cmd)
 424 {
 425     membuf_t data;
 426     gpg_error_t rc;
 427
 428     data.len = 0;
 429     data.buf = NULL;
 430
 431     rc = assuan_transact(ctx, cmd, mem_realloc_cb, &data, _inquire_cb, pwm,
 432             pwm->status_func, pwm->status_data);
 433
 434     if (rc) {
 435         if (data.buf) {
 436             xfree(data.buf);
 437             data.buf = NULL;
 438         }
 439     }
 440     else {
 441         if (data.buf) {
 442             mem_realloc_cb(&data, "", 1);
 443             *result = (char *)data.buf;
 444         }
 445     }
 446
 447     return gpg_err_code(rc);
 448 }
 449
 450 gpg_error_t pwmd_inquire(pwm_t *pwm, const char *cmd, pwmd_inquire_fn fn,
 451         void *data)
 452 {
 453     if (!pwm || !cmd || !fn)
 454         return GPG_ERR_INV_ARG;
 455
 456     pwm->inquire_func = fn;
 457     pwm->inquire_data = data;
 458     return assuan_command(pwm, pwm->ctx, NULL, cmd);
 459 }
 460
 461 gpg_error_t pwmd_terminate_pinentry(pwm_t *pwm)
 462 {
 463 #ifndef USE_PINENTRY
 464     return GPG_ERR_NOT_IMPLEMENTED;
 465 #else
 466     if (!pwm || pwm->pid == -1)
 467         return GPG_ERR_INV_ARG;
 468
 469     if (kill(pwm->pid, 0) == 0) {
 470         if (kill(pwm->pid, SIGTERM) == -1) {
 471             if (kill(pwm->pid, SIGKILL) == -1)
 472                 return gpg_error_from_errno(errno);
 473         }
 474
 475         pwm->pin_error = GPG_ERR_TIMEOUT;
 476     }
 477     else
 478         return gpg_error_from_errno(errno);
 479
 480     return 0;
 481 #endif
 482 }
 483
 484 #ifdef USE_PINENTRY
 485 static gpg_error_t set_pinentry_strings(pwm_t *pwm, int which)
 486 {
 487     char *buf;
 488     char tmp[ASSUAN_LINELENGTH];
 489     gpg_error_t error;
 490
 491     if (!pwm->title)
 492         pwm->title = xstrdup(N_("LibPWMD"));
 493
 494     if (!pwm->prompt)
 495         pwm->prompt = xstrdup(N_("Password:"));
 496
 497     if (!pwm->desc && !which)
 498         pwm->desc = xstrdup(N_("Enter a password."));
 499
 500     if (which == 1) {
 501         snprintf(tmp, sizeof(tmp), "SETERROR %s", N_("Invalid password, please try again."));
 502         buf = xstrdup(tmp);
 503     }
 504     else if (which == 2) {
 505         snprintf(tmp, sizeof(tmp), "SETERROR %s", N_("Please type the password again for confirmation."));
 506         buf = xstrdup(tmp);
 507     }
 508     else {
 509         buf = (char *)xmalloc(strlen("SETERROR ") + strlen(pwm->desc) + 1);
 510         sprintf(buf, "SETERROR %s", pwm->desc);
 511     }
 512
 513     error = pinentry_command(pwm, NULL, buf);
 514     xfree(buf);
 515
 516     if (error)
 517         return error;
 518
 519     buf = (char *)xmalloc(strlen("SETPROMPT ") + strlen(pwm->prompt) + 1);
 520     sprintf(buf, "SETPROMPT %s", pwm->prompt);
 521     error = pinentry_command(pwm, NULL, buf);
 522     xfree(buf);
 523
 524     if (error)
 525         return error;
 526
 527     buf = (char *)xmalloc(strlen("SETDESC ") + strlen(pwm->title) + 1);
 528     sprintf(buf, "SETDESC %s", pwm->title);
 529     error = pinentry_command(pwm, NULL, buf);
 530     xfree(buf);
 531     return error;
 532 }
 533
 534 static void update_pinentry_settings(pwm_t *pwm)
 535 {
 536     FILE *fp;
 537     char buf[LINE_MAX];
 538     struct passwd *pw = getpwuid(getuid());
 539     char *p;
 540
 541     snprintf(buf, sizeof(buf), "%s/.pwmd/pinentry.conf", pw->pw_dir);
 542
 543     if ((fp = fopen(buf, "r")) == NULL)
 544         return;
 545
 546     while ((p = fgets(buf, sizeof(buf), fp)) != NULL) {
 547         char name[32], val[256];
 548
 549         if (sscanf(p, " %31[a-zA-Z] = %255s", name, val) != 2)
 550             continue;
 551
 552         if (strcasecmp(name, "TTYNAME") == 0) {
 553             xfree(pwm->pinentry_tty);
 554             pwm->pinentry_tty = xstrdup(val);
 555         }
 556         else if (strcasecmp(name, "TTYTYPE") == 0) {
 557             xfree(pwm->pinentry_term);
 558             pwm->pinentry_term = xstrdup(val);
 559         }
 560         else if (strcasecmp(name, "DISPLAY") == 0) {
 561             xfree(pwm->pinentry_display);
 562             pwm->pinentry_display = xstrdup(val);
 563         }
 564         else if (strcasecmp(name, "PATH") == 0) {
 565             xfree(pwm->pinentry_path);
 566             pwm->pinentry_path = xstrdup(val);
 567         }
 568     }
 569
 570     fclose(fp);
 571 }
 572
 573 static gpg_error_t launch_pinentry(pwm_t *pwm)
 574 {
 575     int rc;
 576     assuan_context_t ctx;
 577     int child_list[] = {-1};
 578     char *display = getenv("DISPLAY");
 579     const char *argv[6];
 580     int have_display = 0;
 581     char *tty = NULL;
 582
 583     update_pinentry_settings(pwm);
 584
 585     if (pwm->pinentry_display || display)
 586         have_display = 1;
 587     else {
 588         tty = pwm->pinentry_tty ? pwm->pinentry_tty : ttyname(STDOUT_FILENO);
 589
 590         if (!tty)
 591             return gpg_error_from_errno(errno);
 592     }
 593
 594     if (!have_display && !tty)
 595         return GPG_ERR_ENOTTY;
 596
 597     argv[0] = "pinentry";
 598     argv[1] = have_display ? "--display" : "--ttyname";
 599     argv[2] = have_display ? pwm->pinentry_display ? pwm->pinentry_display : display : tty;
 600     argv[3] = NULL;
 601
 602     if (!have_display) {
 603         argv[3] = "--ttytype";
 604         argv[4] = pwm->pinentry_term ? pwm->pinentry_term : getenv("TERM");
 605         argv[5] = NULL;
 606     }
 607
 608     rc = assuan_pipe_connect(&ctx, pwm->pinentry_path ? pwm->pinentry_path : PINENTRY_PATH, argv, child_list);
 609
 610     if (rc)
 611         return rc;
 612
 613     pwm->pid = assuan_get_pid(ctx);
 614     pwm->pctx = ctx;
 615     return set_pinentry_strings(pwm, 0);
 616 }
 617
 618 static gpg_error_t pinentry_command(pwm_t *pwm, char **result, const char *cmd)
 619 {
 620     gpg_error_t n;
 621
 622     if (!pwm->pctx) {
 623         n = launch_pinentry(pwm);
 624
 625         if (n)
 626             return n;
 627     }
 628
 629     return assuan_command(pwm, pwm->pctx, result, cmd);
 630 }
 631
 632 static void pinentry_disconnect(pwm_t *pwm)
 633 {
 634     if (pwm->pctx)
 635         assuan_disconnect(pwm->pctx);
 636
 637     pwm->pctx = NULL;
 638     pwm->pid = -1;
 639 }
 640
 641 /*
 642  * Only called from a child process.
 643  */
 644 static void catchsig(int sig)
 645 {
 646     switch (sig) {
 647         case SIGALRM:
 648             if (gelapsed++ >= gtimeout) {
 649                 global_error = pwmd_terminate_pinentry(gpwm);
 650
 651                 if (!global_error)
 652                     global_error = GPG_ERR_TIMEOUT;
 653
 654                 break;
 655             }
 656
 657             alarm(1);
 658             break;
 659         default:
 660             break;
 661     }
 662 }
 663
 664 /*
 665  * Borrowed from libassuan.
 666  */
 667 static char *percent_escape(const char *atext)
 668 {
 669     const unsigned char *s;
 670     int len = strlen(atext) * 3 + 1;
 671     char *buf = (char *)xmalloc(len), *p = buf;
 672
 673     if (!buf)
 674         return NULL;
 675
 676     for (s=(const unsigned char *)atext; *s; s++) {
 677         if (*s < ' ') {
 678             sprintf (p, "%%%02X", *s);
 679             p += 3;
 680         }
 681         else
 682             *p++ = *s;
 683     }
 684
 685     *p = 0;
 686     return buf;
 687 }
 688 #endif
 689
 690 static gpg_error_t send_command(pwm_t *pwm, char **result, const char *cmd)
 691 {
 692     if (!cmd)
 693         return GPG_ERR_INV_ARG;
 694
 695     return assuan_command(pwm, pwm->ctx, result, cmd);
 696 }
 697
 698 /*
 699  * Avoid sending the BYE command here. libassuan will close the file
 700  * descriptor and release the assuan context. Use pwmd_close() instead.
 701  */
 702 gpg_error_t pwmd_command(pwm_t *pwm, char **result, const char *cmd, ...)
 703 {
 704     va_list ap;
 705     char *buf;
 706     size_t len;
 707     gpg_error_t error;
 708
 709     if (!pwm || !cmd)
 710         return GPG_ERR_INV_ARG;
 711
 712     *result = NULL;
 713     va_start(ap, cmd);
 714     /*
 715      * C99 allows the dst pointer to be null which will calculate the length
 716      * of the result and return it.
 717      */
 718     len = vsnprintf(NULL, 0, cmd, ap);
 719     buf = (char *)xmalloc(len + 1);
 720     len = vsnprintf(buf, len + 1, cmd, ap);
 721     va_end(ap);
 722     error = send_command(pwm, result, buf);
 723     xfree(buf);
 724     return error;
 725 }
 726
 727 #ifdef USE_PINENTRY
 728 static gpg_error_t do_getpin(pwm_t *pwm, char **result)
 729 {
 730     if (gtimeout) {
 731         signal(SIGALRM, catchsig);
 732         alarm(1);
 733     }
 734
 735     *result = NULL;
 736     return pinentry_command(pwm, result, "GETPIN");
 737 }
 738
 739 static gpg_error_t getpin(pwm_t *pwm, char **result, int *try_n, int which)
 740 {
 741     int pin_try = *try_n;
 742     gpg_error_t error;
 743
 744 getpin_again:
 745     *try_n = pin_try;
 746
 747     if (pin_try == -1) {
 748         error = set_pinentry_strings(pwm, which);
 749
 750         if (error) {
 751             pinentry_disconnect(pwm);
 752             return error;
 753         }
 754     }
 755     else {
 756         if (pwm->pinentry_tries-1 != pin_try) {
 757             error = set_pinentry_strings(pwm, 1);
 758
 759             if (error) {
 760                 pinentry_disconnect(pwm);
 761                 return error;
 762             }
 763         }
 764     }
 765
 766     error = do_getpin(pwm, result);
 767
 768     /*
 769      * Since there was input cancel any timeout setting.
 770      */
 771     alarm(0);
 772
 773     if (error) {
 774         if (error == GPG_ERR_CANCELED)
 775             return GPG_ERR_CANCELED;
 776
 777         if (pin_try != -1 && pin_try--)
 778             goto getpin_again;
 779
 780         if (pwm->pctx)
 781             pinentry_disconnect(pwm);
 782
 783         *try_n = pin_try;
 784         return error;
 785     }
 786
 787     return 0;
 788 }
 789 #endif
 790
 791 gpg_error_t pwmd_open_nb_finalize(pwm_t *pwm, pwmd_nb_status_t *pw)
 792 {
 793     gpg_error_t error;
 794
 795 #ifndef USE_PINENTRY
 796     return GPG_ERR_NOT_IMPLEMENTED;
 797 #endif
 798
 799     if (!pwm || !pw || !pw->filename[0])
 800         return GPG_ERR_INV_ARG;
 801
 802     close(pw->fd);
 803
 804     if (pw->error) {
 805         error = pw->error;
 806         goto fail;
 807     }
 808
 809     if (pwm->filename)
 810         xfree(pwm->filename);
 811
 812     pwm->filename = xstrdup(pw->filename);
 813     memset(pw, 0, sizeof(pwmd_nb_status_t));
 814     return 0;
 815
 816 fail:
 817     memset(pw, 0, sizeof(pwmd_nb_status_t));
 818     return error;
 819 }
 820
 821 static gpg_error_t do_open_command(pwm_t *pwm, const char *filename, char *password)
 822 {
 823     char buf[ASSUAN_LINELENGTH];
 824     gpg_error_t error;
 825     char *result = NULL;
 826
 827     snprintf(buf, sizeof(buf), "OPEN %s %s", filename, password ? password : "");
 828     error = send_command(pwm, &result, buf);
 829     memset(buf, 0, sizeof(buf));
 830
 831     if (error && result)
 832         xfree(result);
 833
 834     return error;
 835 }
 836
 837 static int do_pwmd_open(pwm_t *pwm, gpg_error_t *error, const char *filename,
 838         int nb, int timeout)
 839 {
 840     char *result = NULL;
 841     char *password = NULL;
 842     char path[PATH_MAX];
 843 #ifdef USE_PINENTRY
 844     int pin_try;
 845 #endif
 846
 847     if (!pwm || !filename || !*filename) {
 848         *error = GPG_ERR_INV_ARG;
 849         return nb ? -1 : 1;
 850     }
 851
 852 #ifdef USE_PINENTRY
 853     pin_try = pwm->pinentry_tries - 1;
 854 #endif
 855
 856     /*
 857      * Avoid calling pinentry if the password is cached on the server or if
 858      * this is a new file.
 859      */
 860     *error = pwmd_command(pwm, &result, "GETCONFIG data_directory");
 861
 862     if (*error)
 863         return nb ? -1 : 1;
 864
 865     snprintf(path, sizeof(path), "%s/%s", result, filename);
 866     pwmd_free_result(result);
 867
 868     if (access(path, R_OK) == -1) {
 869         if (errno == ENOENT)
 870             goto gotpassword;
 871     }
 872
 873     *error = pwmd_command(pwm, &result, "ISCACHED %s", filename);
 874
 875     if (*error == EPWMD_CACHE_NOT_FOUND) {
 876         if (pwm->passfunc) {
 877             password = pwm->passfunc(pwm, pwm->passdata);
 878             goto gotpassword;
 879         }
 880
 881 #ifdef USE_PINENTRY
 882         /*
 883          * Get the password from pinentry.
 884          */
 885         if (pwm->use_pinentry) {
 886             /*
 887              * Nonblocking is wanted. fork() then return a file descriptor
 888              * that the client can use to read() from.
 889              */
 890             if (nb) {
 891                 int p[2];
 892                 pid_t pid;
 893                 pwmd_nb_status_t pw;
 894
 895                 if (pipe(p) == -1) {
 896                     *error = gpg_error_from_syserror();
 897                     return -1;
 898                 }
 899
 900 #ifdef WITH_LIBPTH
 901                 pid = pth_fork();
 902 #else
 903                 pid = fork();
 904 #endif
 905
 906                 switch (pid) {
 907                     case 0:
 908                         close(p[0]);
 909                         strncpy(pw.filename, filename, sizeof(pw.filename));
 910                         pw.filename[sizeof(pw.filename)-1] = 0;
 911                         pw.fd = p[0];
 912
 913                         if (timeout > 0) {
 914                             gpwm = pwm;
 915                             gtimeout = timeout;
 916                             gelapsed = 0;
 917                         }
 918
 919 getpin_nb_again:
 920                         *error = getpin(pwm, &password, &pin_try, 0);
 921
 922                         if (*error) {
 923 getpin_nb_fail:
 924                             if (pwm->pctx)
 925                                 pinentry_disconnect(pwm);
 926
 927                             if (gtimeout && gelapsed >= gtimeout)
 928                                 *error = GPG_ERR_TIMEOUT;
 929
 930                             pw.error = *error;
 931 #ifdef WITH_LIBPTH
 932                             pth_write(p[1], &pw, sizeof(pw));
 933 #else
 934                             write(p[1], &pw, sizeof(pw));
 935 #endif
 936                             close(p[1]);
 937                             _exit(1);
 938                         }
 939
 940                         /*
 941                          * Don't count the time it takes to open the file
 942                          * which may have many iterations.
 943                          */
 944                         signal(SIGALRM, SIG_DFL);
 945                         *error = do_open_command(pwm, filename, password);
 946
 947                         if (timeout)
 948                             signal(SIGALRM, catchsig);
 949
 950                         if (pwm->pctx && *error == EPWMD_BADKEY) {
 951                             if (pin_try-- > 0)
 952                                 goto getpin_nb_again;
 953
 954                             goto getpin_nb_fail;
 955                         }
 956
 957                         pinentry_disconnect(pwm);
 958                         pw.error = 0;
 959 #ifdef WITH_LIBPTH
 960                         pth_write(p[1], &pw, sizeof(pw));
 961 #else
 962                         write(p[1], &pw, sizeof(pw));
 963 #endif
 964                         close(p[1]);
 965                         _exit(0);
 966                         break;
 967                     case -1:
 968                         *error = gpg_error_from_syserror();
 969                         close(p[0]);
 970                         close(p[1]);
 971                         return -1;
 972                     default:
 973                         break;
 974                 }
 975
 976                 close(p[1]);
 977                 return p[0];
 978             }
 979         }
 980         else {
 981 #endif
 982             /*
 983              * Not using pinentry and the file was not found
 984              * in the cache.
 985              */
 986             password = pwm->password;
 987 #ifdef USE_PINENTRY
 988         }
 989 #endif
 990     }
 991     else if (*error)
 992         return nb ? -1 : 1;
 993
 994 gotpassword:
 995     *error = do_open_command(pwm, filename, password);
 996
 997     /*
 998      * Keep the user defined password set with pwmd_setopt(). The password may
 999      * be needed later (pwmd_save()) depending on the pwmd file cache settings.
1000      */
1001     if (password && password != pwm->password)
1002         xfree(password);
1003
1004 #ifdef USE_PINENTRY
1005     if (*error == EPWMD_BADKEY) {
1006         if (pin_try-- > 0 && !nb) {
1007             *error = pwmd_command(pwm, &result, "OPTION TITLE=%s",
1008                     N_("Invalid password, please try again."));
1009
1010             if (*error)
1011                 return 1;
1012
1013             goto gotpassword;
1014         }
1015
1016         if (nb)
1017             pinentry_disconnect(pwm);
1018
1019         return nb ? -1 : 1;
1020     }
1021 #endif
1022
1023     if (!*error) {
1024         if (pwm->filename)
1025             xfree(pwm->filename);
1026
1027         pwm->filename = xstrdup(filename);
1028     }
1029
1030     /*
1031      * The file is cached or the file is a new file.
1032      */
1033     if (nb)
1034         return *error ? -1 : -2;
1035
1036     return *error ? 1 : 0;
1037 }
1038
1039 gpg_error_t pwmd_open(pwm_t *pwm, const char *filename)
1040 {
1041     gpg_error_t error;
1042
1043     do_pwmd_open(pwm, &error, filename, 0, 0);
1044     return error;
1045 }
1046
1047 int pwmd_open_nb(pwm_t *pwm, gpg_error_t *error, const char *filename,
1048         int timeout)
1049 {
1050 #ifndef USE_PINENTRY
1051     *error = GPG_ERR_NOT_IMPLEMENTED;
1052     return -1;
1053 #else
1054     return do_pwmd_open(pwm, error, filename, 1, timeout);
1055 #endif
1056 }
1057
1058 #ifdef USE_PINENTRY
1059 static gpg_error_t do_save_getpin(pwm_t *pwm, char **password)
1060 {
1061     int confirm = 0;
1062     gpg_error_t error;
1063     char *result = NULL;
1064     int pin_try = -1;
1065
1066 again:
1067     error = getpin(pwm, &result, &pin_try, confirm ? 2 : 0);
1068
1069     if (error) {
1070         if (pwm->pctx)
1071             pinentry_disconnect(pwm);
1072
1073         if (*password)
1074             xfree(*password);
1075
1076         return error;
1077     }
1078
1079     if (!confirm++) {
1080         *password = result;
1081         goto again;
1082     }
1083
1084     if (strcmp(*password, result)) {
1085         xfree(*password);
1086         xfree(result);
1087         pinentry_disconnect(pwm);
1088         error = EPWMD_BADKEY;
1089         return error;
1090     }
1091
1092     xfree(result);
1093     pinentry_disconnect(pwm);
1094     return 0;
1095 }
1096 #endif
1097
1098 static gpg_error_t do_save_command(pwm_t *pwm, char *password)
1099 {
1100     char buf[ASSUAN_LINELENGTH];
1101     gpg_error_t error;
1102     char *result = NULL;
1103
1104     snprintf(buf, sizeof(buf), "SAVE %s", password ? password : "");
1105     error = send_command(pwm, &result, buf);
1106     memset(&buf, 0, sizeof(buf));
1107
1108     if (error && result)
1109         xfree(result);
1110
1111     return error;
1112 }
1113
1114 gpg_error_t pwmd_save_nb_finalize(pwm_t *pwm, pwmd_nb_status_t *pw)
1115 {
1116     gpg_error_t rc;
1117
1118 #ifndef USE_PINENTRY
1119     return GPG_ERR_NOT_IMPLEMENTED;
1120 #endif
1121
1122     if (!pwm || !pw || !pw->filename[0])
1123         return GPG_ERR_INV_ARG;
1124
1125     close(pw->fd);
1126     rc = pw->error;
1127     memset(pw, 0, sizeof(pwmd_nb_status_t));
1128     return rc;
1129 }
1130
1131 static int do_pwmd_save(pwm_t *pwm, gpg_error_t *error, int nb)
1132 {
1133     char *result = NULL;
1134     char *password = NULL;
1135
1136     if (!pwm) {
1137         *error = GPG_ERR_INV_ARG;
1138         return nb ? -1 : 1;
1139     }
1140
1141     if (pwm->use_pinentry || pwm->passfunc) {
1142         *error = pwmd_command(pwm, &result, "ISCACHED %s", pwm->filename);
1143
1144         if (*error == EPWMD_CACHE_NOT_FOUND) {
1145 #ifdef USE_PINENTRY
1146             if (pwm->use_pinentry) {
1147                 if (nb) {
1148                     int p[2];
1149                     pid_t pid;
1150                     pwmd_nb_status_t pw;
1151
1152                     if (pipe(p) == -1) {
1153                         *error = gpg_error_from_syserror();
1154                         return -1;
1155                     }
1156
1157 #ifdef WITH_LIBPTH
1158                     pid = pth_fork();
1159 #else
1160                     pid = fork();
1161 #endif
1162
1163                     switch (pid) {
1164                         case 0:
1165                             close(p[0]);
1166                             strncpy(pw.filename, pwm->filename, sizeof(pw.filename));
1167                             pw.filename[sizeof(pw.filename)-1] = 0;
1168                             pw.fd = p[0];
1169
1170                             do {
1171                                 password = NULL;
1172                                 *error = do_save_getpin(pwm, &password);
1173                             } while (*error == EPWMD_BADKEY);
1174
1175                             if (*error) {
1176                                 if (pwm->pctx)
1177                                     pinentry_disconnect(pwm);
1178
1179                                 pw.error = *error;
1180 #ifdef WITH_LIBPTH
1181                                 pth_write(p[1], &pw, sizeof(pw));
1182 #else
1183                                 write(p[1], &pw, sizeof(pw));
1184 #endif
1185                                 close(p[1]);
1186                                 _exit(1);
1187                             }
1188
1189                             *error = do_save_command(pwm, password);
1190                             pinentry_disconnect(pwm);
1191                             pw.error = *error;
1192 #ifdef WITH_LIBPTH
1193                             pth_write(p[1], &pw, sizeof(pw));
1194 #else
1195                             write(p[1], &pw, sizeof(pw));
1196 #endif
1197                             close(p[1]);
1198                             _exit(0);
1199                             break;
1200                         case -1:
1201                             *error = gpg_error_from_syserror();
1202                             close(p[0]);
1203                             close(p[1]);
1204                             return -1;
1205                         default:
1206                             break;
1207                     }
1208
1209                     close(p[1]);
1210                     return p[0];
1211                 }
1212
1213                 *error = do_save_getpin(pwm, &password);
1214
1215                 if (*error)
1216                     return 1;
1217             }
1218             else {
1219 #endif
1220                 if (pwm->passfunc)
1221                     password = (*pwm->passfunc)(pwm, pwm->passdata);
1222 #ifdef USE_PINENTRY
1223             }
1224 #endif
1225         }
1226         else {
1227             if (*error)
1228                 return nb ? -1 : 1;
1229         }
1230     }
1231     else
1232         password = pwm->password;
1233
1234     *error = do_save_command(pwm, password);
1235
1236     if (password && password != pwm->password)
1237         xfree(password);
1238
1239     if (nb)
1240         return *error ? -1 : -2;
1241
1242     return *error ? 1 : 0;
1243 }
1244
1245 int pwmd_save_nb(pwm_t *pwm, gpg_error_t *error)
1246 {
1247 #ifndef USE_PINENTRY
1248     *error = GPG_ERR_NOT_IMPLEMENTED;
1249     return -1;
1250 #else
1251     return do_pwmd_save(pwm, error, 1);
1252 #endif
1253 }
1254
1255 gpg_error_t pwmd_save(pwm_t *pwm)
1256 {
1257     gpg_error_t error;
1258
1259     do_pwmd_save(pwm, &error, 0);
1260     return error;
1261 }
1262
1263 gpg_error_t pwmd_setopt(pwm_t *pwm, pwmd_option_t opt, ...)
1264 {
1265     va_list ap;
1266 #ifdef USE_PINENTRY
1267     int n = va_arg(ap, int);
1268     char *result;
1269 #endif
1270     char *arg1;
1271     gpg_error_t error = 0;
1272
1273     if (!pwm)
1274         return GPG_ERR_INV_ARG;
1275
1276     va_start(ap, opt);
1277
1278     switch (opt) {
1279         case PWMD_OPTION_STATUS_FUNC:
1280             pwm->status_func = va_arg(ap, pwmd_status_fn);
1281             break;
1282         case PWMD_OPTION_STATUS_DATA:
1283             pwm->status_data = va_arg(ap, void *);
1284             break;
1285         case PWMD_OPTION_PASSWORD_FUNC:
1286             pwm->passfunc = va_arg(ap, pwmd_password_fn);
1287             break;
1288         case PWMD_OPTION_PASSWORD_DATA:
1289             pwm->passdata = va_arg(ap, void *);
1290             break;
1291         case PWMD_OPTION_PASSWORD:
1292             arg1 = va_arg(ap, char *);
1293
1294             if (pwm->password)
1295                 xfree(pwm->password);
1296
1297             pwm->password = xstrdup(arg1);
1298             break;
1299 #ifdef USE_PINENTRY
1300         case PWMD_OPTION_PINENTRY:
1301             n = va_arg(ap, int);
1302
1303             if (n != 0 && n != 1) {
1304                 va_end(ap);
1305                 error = GPG_ERR_INV_VALUE;
1306             }
1307             else {
1308                 pwm->use_pinentry = n;
1309                 error = pwmd_command(pwm, &result, "OPTION PINENTRY=%i",
1310                         !pwm->use_pinentry);
1311             }
1312             break;
1313         case PWMD_OPTION_PINENTRY_TRIES:
1314             n = va_arg(ap, int);
1315
1316             if (n <= 0) {
1317                 va_end(ap);
1318                 error = GPG_ERR_INV_VALUE;
1319             }
1320             else
1321                 pwm->pinentry_tries = n;
1322             break;
1323         case PWMD_OPTION_PINENTRY_PATH:
1324             if (pwm->pinentry_path)
1325                 xfree(pwm->pinentry_path);
1326
1327             pwm->pinentry_path = xstrdup(va_arg(ap, char *));
1328             break;
1329         case PWMD_OPTION_PINENTRY_TTY:
1330             if (pwm->pinentry_tty)
1331                 xfree(pwm->pinentry_tty);
1332
1333             pwm->pinentry_tty = xstrdup(va_arg(ap, char *));
1334             break;
1335         case PWMD_OPTION_PINENTRY_DISPLAY:
1336             if (pwm->pinentry_display)
1337                 xfree(pwm->pinentry_display);
1338
1339             pwm->pinentry_display = xstrdup(va_arg(ap, char *));
1340             break;
1341         case PWMD_OPTION_PINENTRY_TERM:
1342             if (pwm->pinentry_term)
1343                 xfree(pwm->pinentry_term);
1344
1345             pwm->pinentry_term = xstrdup(va_arg(ap, char *));
1346             break;
1347         case PWMD_OPTION_PINENTRY_TITLE:
1348             if (pwm->title)
1349                 xfree(pwm->title);
1350             pwm->title = percent_escape(va_arg(ap, char *));
1351             break;
1352         case PWMD_OPTION_PINENTRY_PROMPT:
1353             if (pwm->prompt)
1354                 xfree(pwm->prompt);
1355             pwm->prompt = percent_escape(va_arg(ap, char *));
1356             break;
1357         case PWMD_OPTION_PINENTRY_DESC:
1358             if (pwm->desc)
1359                 xfree(pwm->desc);
1360             pwm->desc = percent_escape(va_arg(ap, char *));
1361             break;
1362 #else
1363         case PWMD_OPTION_PINENTRY:
1364         case PWMD_OPTION_PINENTRY_TRIES:
1365         case PWMD_OPTION_PINENTRY_PATH:
1366         case PWMD_OPTION_PINENTRY_TTY:
1367         case PWMD_OPTION_PINENTRY_DISPLAY:
1368         case PWMD_OPTION_PINENTRY_TERM:
1369         case PWMD_OPTION_PINENTRY_TITLE:
1370         case PWMD_OPTION_PINENTRY_PROMPT:
1371         case PWMD_OPTION_PINENTRY_DESC:
1372             error = GPG_ERR_NOT_IMPLEMENTED;
1373             break;
1374 #endif
1375         default:
1376             error = GPG_ERR_NOT_IMPLEMENTED;
1377             break;
1378     }
1379
1380     va_end(ap);
1381     return error;
1382 }
1383
1384 gpg_error_t pwmd_assuan_ctx(pwm_t *pwm, assuan_context_t *ctx, int *fd)
1385 {
1386     if (!pwm)
1387         return GPG_ERR_INV_ARG;
1388
1389     *ctx = pwm->ctx;
1390     *fd = pwm->fd;
1391     return 0;
1392 }