libpwmd.c

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