pwmc.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2007-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  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 <string.h>
  25 #include <libpwmd.h>
  26 #include <assuan.h>
  27 #ifdef DEBUG
  28 #include <sys/select.h>
  29 #include <fcntl.h>
  30 #endif
  31
  32 #ifdef HAVE_CONFIG_H
  33 #include <config.h>
  34 #endif
  35
  36 #ifdef HAVE_LOCALE_H
  37 #include <locale.h>
  38 #endif
  39
  40 #include "gettext.h"
  41 #define N_(msgid)       gettext(msgid)
  42
  43 #ifndef MEM_DEBUG
  44 #include "mem.h"
  45 #else
  46 #define xfree           free
  47 #define xrealloc        realloc
  48 #define xmalloc         malloc
  49 #define xstrdup         strdup
  50 #define xcalloc         calloc
  51 #endif
  52
  53 pwm_t *pwm;
  54
  55 static void show_error(gpg_error_t error)
  56 {
  57     fprintf(stderr, "ERR %i %s\n", gpg_err_code(error), pwmd_strerror(error));
  58 }
  59
  60 static void usage(const char *pn)
  61 {
  62     fprintf(stderr, N_(
  63             "Reads PWMD protocol commands from standard input.\n\n"
  64 #ifdef DEBUG
  65             "Usage: pwmc [-hvX] [-s <socket>] [-E <n> -P -T -N -D | -p <password>] [-S [-i <iter>]]\n"
  66 #else
  67             "Usage: pwmc [-hvX] [-s <socket>] [-P -T -N -D | -p <password>]\n"
  68 #endif
  69             "          [-S [-i <iter>]] [-c <name>] [-t <n>] [-d <fd>] [-I <fd>] [filename]\n"
  70 #ifdef DEBUG
  71             "   -E  pinentry method (0=pwmd, 1=pwmd async, 2=libpwmd nb)\n"
  72 #endif
  73             "   -t  pinentry timeout\n"
  74             "   -X  disable showing of status messages from the server\n"
  75             "   -c  set the client name\n"
  76             "   -s  socket path (~/.pwmd/socket)\n"
  77             "   -p  password\n"
  78             "   -P  path to the pinentry binary (server default)\n"
  79             "   -T  pinentry tty\n"
  80             "   -N  pinentry terminal type\n"
  81             "   -D  pinentry display\n"
  82             "   -d  redirect command output to the specified file descriptor\n"
  83             "   -I  read inquire data from the specified file descriptor\n"
  84             "   -S  send the SAVE command before exiting\n"
  85             "   -i  encrypt with the specified number of iterations (-1 = 0 iterations)\n"
  86             "   -v  version\n"
  87             "   -h  this help text\n"));
  88     exit(EXIT_FAILURE);
  89 }
  90
  91 struct inquire_s {
  92     FILE *fp;
  93     char *data;
  94 };
  95
  96 static gpg_error_t do_inquire(void *data, const char *keyword, gpg_error_t rc,
  97         char **result, size_t *result_len)
  98 {
  99     int c;
 100     static char buf[ASSUAN_LINELENGTH];
 101     char *p;
 102     size_t len = 0;
 103     struct inquire_s *inq = (struct inquire_s *)data;
 104
 105     if (rc) {
 106         memset(buf, 0, sizeof(buf));
 107         return rc;
 108     }
 109
 110     buf[0] = 0;
 111     p = buf;
 112
 113     if (inq->data) {
 114         snprintf(buf, sizeof(buf), "%s", inq->data);
 115         xfree(inq->data);
 116         inq->data = NULL;
 117         len = strlen(buf);
 118         p = buf + len;
 119     }
 120
 121     while ((c = fgetc(inq->fp)) != EOF) {
 122         if (len == sizeof(buf)) {
 123             ungetc(c, inq->fp);
 124             break;
 125         }
 126
 127         *p++ = c;
 128         len++;
 129     }
 130
 131     if (!buf[0]) {
 132         memset(buf, 0, sizeof(buf));
 133         return GPG_ERR_EOF;
 134     }
 135
 136     *result = buf;
 137     *result_len = len;
 138     return 0;
 139 }
 140
 141 static int status_msg_cb(void *data, const char *line)
 142 {
 143     fprintf(stderr, "%s\n", line);
 144     return 0;
 145 }
 146
 147 #ifdef DEBUG
 148 static gpg_error_t do_nb_command(int fd, int which)
 149 {
 150     int n;
 151     gpg_error_t error = 0;
 152
 153     fcntl(fd, F_SETFL, O_NONBLOCK);
 154
 155     do {
 156         fd_set fds;
 157         struct timeval tv = {0, 50000};
 158
 159         FD_ZERO(&fds);
 160         FD_SET(fd, &fds);
 161         n = select(fd+1, &fds, NULL, NULL, &tv);
 162
 163         if (n > 0) {
 164             if (FD_ISSET(fd, &fds)) {
 165                 pwmd_nb_status_t status;
 166
 167                 n = read(fd, &status, sizeof(status));
 168
 169                 if (n == -1) {
 170                     error = gpg_error_from_errno(errno);
 171                     goto done;
 172                 }
 173
 174                 if (!which)
 175                     error = pwmd_open_nb_finalize(pwm, &status);
 176                 else
 177                     error = pwmd_save_nb_finalize(pwm, &status);
 178
 179                 if (error)
 180                     goto done;
 181             }
 182         }
 183         else
 184             fputc('.', stderr);
 185     } while (n == 0);
 186
 187 done:
 188     return error;
 189 }
 190 #endif
 191
 192 int main(int argc, char *argv[])
 193 {
 194     int opt;
 195     char *password = NULL;
 196     char *filename = NULL;
 197     char *socketpath = NULL;
 198     char command[ASSUAN_LINELENGTH], *p;
 199     int ret = EXIT_SUCCESS;
 200     gpg_error_t error;
 201     char *result = NULL;
 202     int save = 0;
 203     char *pinentry_path = NULL;
 204     char *display = NULL, *tty = NULL, *ttytype = NULL;
 205     int outfd = STDOUT_FILENO;
 206     FILE *outfp = stdout;
 207     int inquirefd = STDIN_FILENO;
 208     FILE *inquirefp = stdin;
 209     int show_status = 1;
 210     char *clientname = NULL;
 211     char *inquire = NULL;
 212     int iter = -2;
 213     int timeout = 0;
 214 #ifdef DEBUG
 215     int method = 0;
 216     pwmd_async_t s;
 217 #endif
 218
 219     setlocale(LC_ALL, "");
 220     bindtextdomain("libpwmd", LOCALEDIR);
 221
 222 #ifdef DEBUG
 223     while ((opt = getopt(argc, argv, "t:E:c:I:XT:N:D:hvP:p:s:Si:d:")) != EOF) {
 224 #else
 225     while ((opt = getopt(argc, argv, "t:c:I:XT:N:D:hvP:p:s:Si:d:")) != EOF) {
 226 #endif
 227         switch (opt) {
 228 #ifdef DEBUG
 229             case 'E':
 230                 method = atoi(optarg);
 231                 break;
 232 #endif
 233             case 't':
 234                 timeout = atoi(optarg);
 235                 break;
 236             case 'c':
 237                 clientname = xstrdup(optarg);
 238                 break;
 239             case 'X':
 240                 show_status = 0;
 241                 break;
 242             case 'T':
 243                 tty = optarg;
 244                 break;
 245             case 'N':
 246                 ttytype = optarg;
 247                 break;
 248             case 'D':
 249                 display = optarg;
 250                 break;
 251             case 'I':
 252                 inquirefd = atoi(optarg);
 253                 inquirefp = fdopen(inquirefd, "r");
 254
 255                 if (!inquirefp) {
 256                     xfree(password);
 257                     err(EXIT_FAILURE, "%i", inquirefd);
 258                 }
 259                 break;
 260             case 'd':
 261                 outfd = atoi(optarg);
 262                 outfp = fdopen(outfd, "w");
 263
 264                 if (!outfp) {
 265                     xfree(password);
 266                     err(EXIT_FAILURE, "%i", outfd);
 267                 }
 268                 break;
 269             case 'S':
 270                 save = 1;
 271                 break;
 272             case 'i':
 273                 iter = atoi(optarg);
 274
 275                 if (iter < -1) {
 276                     xfree(password);
 277                     usage(argv[0]);
 278                 }
 279                 break;
 280             case 's':
 281                 socketpath = xstrdup(optarg);
 282                 break;
 283             case 'p':
 284                 password = xstrdup(optarg);
 285                 memset(optarg, 0, strlen(optarg));
 286                 break;
 287             case 'P':
 288                 pinentry_path = xstrdup(optarg);
 289                 break;
 290             case 'v':
 291                 xfree(password);
 292                 printf("%s (pwmc)\n%s\n", PACKAGE_STRING, PACKAGE_BUGREPORT);
 293                 exit(EXIT_SUCCESS);
 294             case 'h':
 295             default:
 296                 xfree(password);
 297                 usage(argv[0]);
 298         }
 299     }
 300
 301     filename = argv[optind];
 302     pwmd_init();
 303
 304     if ((pwm = pwmd_connect(socketpath, &error)) == NULL) {
 305         xfree(password);
 306         errx(EXIT_FAILURE, "pwmd_connect(): %s", pwmd_strerror(error));
 307     }
 308
 309     error = pwmd_command(pwm, &result, "OPTION CLIENT NAME=%s", clientname ? clientname : "pwmc");
 310     xfree(clientname);
 311
 312     if (error) {
 313         xfree(password);
 314         errx(EXIT_FAILURE, "pwmd_connect(): %s", pwmd_strerror(error));
 315     }
 316
 317     if (timeout > 0) {
 318         error = pwmd_command(pwm, &result, "OPTION TIMEOUT=%i", timeout);
 319
 320         if (error) {
 321             xfree(password);
 322             errx(EXIT_FAILURE, "pwmd_connect(): %s", pwmd_strerror(error));
 323         }
 324     }
 325
 326     if (password) {
 327         error = pwmd_setopt(pwm, PWMD_OPTION_PASSWORD, password);
 328
 329         if (error) {
 330             xfree(password);
 331             goto done;
 332         }
 333
 334         xfree(password);
 335     }
 336     else {
 337         if (pinentry_path) {
 338             error = pwmd_command(pwm, &result, "OPTION PATH=%s", pinentry_path);
 339
 340             if (error)
 341                 goto done;
 342         }
 343
 344         if (display) {
 345             error = pwmd_command(pwm, &result, "OPTION DISPLAY=%s", display);
 346
 347             if (error)
 348                 goto done;
 349         }
 350
 351         if (tty) {
 352             error = pwmd_command(pwm, &result, "OPTION TTYNAME=%s", tty);
 353
 354             if (error)
 355                 goto done;
 356         }
 357
 358         if (ttytype) {
 359             error = pwmd_command(pwm, &result, "OPTION TTYTYPE=%s", ttytype);
 360
 361             if (error)
 362                 goto done;
 363         }
 364 #ifdef DEBUG
 365         if (method >= 2) {
 366             error = pwmd_setopt(pwm, PWMD_OPTION_PINENTRY, 1);
 367
 368             if (error)
 369                 goto done;
 370         }
 371 #endif
 372     }
 373
 374     if (show_status) {
 375         error = pwmd_setopt(pwm, PWMD_OPTION_STATUS_FUNC, status_msg_cb);
 376
 377         if (error)
 378             goto done;
 379     }
 380
 381     if (filename) {
 382 #ifdef DEBUG
 383         /* This method doesn't support PWMD_OPTION_PINENTRY_TRIES. */
 384         if (method == 1) {
 385             error = pwmd_open_async(pwm, filename);
 386
 387             if (!error) {
 388                 do {
 389                     s = pwmd_process(pwm, &error);
 390                     fputc('.', stderr);
 391                     usleep(50000);
 392                 } while (s == ASYNC_PROCESS);
 393
 394                 pwmd_finalize(pwm);
 395             }
 396         }
 397         else if (method == 2) {
 398             int fd = pwmd_open_nb(pwm, &error, filename, timeout);
 399
 400             if (fd == -1)
 401                 goto done;
 402             else if (fd >= 0)
 403                 error = do_nb_command(fd, 0);
 404         }
 405         else
 406             error = pwmd_open(pwm, filename);
 407 #else
 408         error = pwmd_open(pwm, filename);
 409 #endif
 410
 411         if (error)
 412             goto done;
 413     }
 414
 415     if (filename) {
 416         error = pwmd_command(pwm, &result, "LOCK");
 417
 418         if (error)
 419             goto done;
 420     }
 421
 422     p = fgets(command, sizeof(command), stdin);
 423
 424     if (!p)
 425         goto done;
 426
 427     /*
 428      * This is a known INQUIRE command. We use pwmd_inquire() to send the
 429      * data from the do_inquire() callback function.
 430      */
 431     if (strncasecmp(p, "STORE ", 6) == 0) {
 432         p += 6;
 433         inquire = (char *)"STORE";
 434     }
 435     else if (strncasecmp(p, "IMPORT ", 7) == 0) {
 436         p += 7;
 437         inquire = (char *)"IMPORT";
 438     }
 439
 440     if (inquire) {
 441         struct inquire_s *inq = (struct inquire_s *)malloc(sizeof(struct inquire_s));
 442
 443         if (!inq) {
 444             error = gpg_error_from_errno(ENOMEM);
 445             goto done;
 446         }
 447
 448         inq->data = xstrdup(p);
 449         inq->fp = inquirefp;
 450         error = pwmd_inquire(pwm, inquire, do_inquire, inq);
 451         free(inq);
 452         goto done;
 453     }
 454
 455     if (strcasecmp(p, "BYE") == 0)
 456         goto done;
 457
 458     error = pwmd_command(pwm, &result, command);
 459     memset(command, 0, sizeof(command));
 460
 461     if (error)
 462         goto done;
 463
 464     if (result) {
 465         fwrite(result, 1, strlen(result), outfp);
 466         pwmd_free_result(result);
 467     }
 468
 469 done:
 470     memset(command, 0, sizeof(command));
 471
 472     if (!error && save) {
 473         if (iter != -2) {
 474             error = pwmd_command(pwm, &result, "OPTION ITERATIONS=%i", iter);
 475
 476             if (error)
 477                 goto done;
 478         }
 479
 480 #ifdef DEBUG
 481         if (method == 1) {
 482             error = pwmd_save_async(pwm);
 483
 484             if (!error) {
 485                 do {
 486                     s = pwmd_process(pwm, &error);
 487                     fputc('.', stderr);
 488                     usleep(50000);
 489                 } while (s == ASYNC_PROCESS);
 490
 491                 pwmd_finalize(pwm);
 492             }
 493         }
 494         else if (method == 3) {
 495             int fd = pwmd_save_nb(pwm, &error);
 496
 497             if (fd == -1)
 498                 goto done;
 499             else if (fd >= 0)
 500                 error = do_nb_command(fd, 1);
 501         }
 502         else
 503             error = pwmd_save(pwm);
 504 #else
 505         error = pwmd_save(pwm);
 506 #endif
 507     }
 508
 509     if (!error && filename)
 510         error = pwmd_command(pwm, &result, "UNLOCK");
 511
 512     if (error) {
 513         show_error(error);
 514         ret = EXIT_FAILURE;
 515     }
 516
 517     pwmd_close(pwm);
 518
 519     if (socketpath)
 520         xfree(socketpath);
 521
 522     exit(ret);
 523 }