Raphaël G. Git Repositories - ihttpd/blob - SOURCES/index.bin.c

   1 /**
   2  * This program is free software: you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation, either version 3 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  14  *
  15  * Written by Raphaël Gertz <rapsys@rapsys.eu>
  16  */
  17
  18 //Required for mkostemp, O_CLOEXEC, strdup, memmem
  19 #define _GNU_SOURCE
  20
  21 //Required for SSIZE_MAX, LONG_MAX
  22 #include <limits.h>
  23
  24 //Required for pid_t, kill, waitpid
  25 #include <sys/wait.h>
  26 #include <signal.h>
  27
  28 //Required for printf, sscanf, sprintf
  29 #include <stdio.h>
  30
  31 //Required for struct stat, fstat
  32 #include <sys/stat.h>
  33
  34 //Required for closedir, DIR, opendir, readdir, struct dirent
  35 #include <dirent.h>
  36
  37 //Required for close, dup2, execve, fork, read, STDERR_FILENO, STDOUT_FILENO, STDIN_FILENO, write
  38 #include <unistd.h>
  39
  40 //Required for open, O_CLOEXEC, O_NOATIME, O_NOFOLLOW
  41 #include <fcntl.h>
  42
  43 //Required for atoi, calloc, exit, EXIT_FAILURE, EXIT_SUCCESS, free, getenv, malloc, realloc
  44 #include <stdlib.h>
  45
  46 //Required for memchr, memcpy, memmem, strdup, strlen, strncmp
  47 #include <string.h>
  48
  49 //Required for bool
  50 #include <stdbool.h>
  51
  52 //Required for nanosleep
  53 #include <time.h>
  54
  55 //Default passphrase max size
  56 #define DEFAULT_PASSPHRASE_SIZE_MAX 512
  57
  58 //Default keyfile max size
  59 //XXX: file should be maximum 8192*1024-1 character long
  60 #define DEFAULT_KEYFILE_SIZE_MAX (8192 * 1024)
  61
  62 //Default crypttab
  63 #define CRYPTTAB "/etc/crypttab"
  64
  65 //Default cryptsetup
  66 #define CRYPTSETUP "/sbin/cryptsetup"
  67
  68 //Systemd cryptsetup
  69 #define SYSTEMDCRYPTSETUP "/usr/lib/systemd/systemd-cryptsetup"
  70
  71 //Default pid file
  72 #define IHTTPDPID "/run/ihttpd/ihttpd.pid"
  73
  74 //Default systemd ask-password dir
  75 #define ASKPASSWORDDIR "/run/systemd/ask-password"
  76
  77 //Define child log
  78 #define ASKPASSWORDLOG "/run/ihttpd/log/child.askpassword.log"
  79 #define IHTTPDLOG "/run/ihttpd/log/child.ihttpd.log"
  80
  81 //Define form uri
  82 #define FORMID "5903c738"
  83 #define FORMURI "/" FORMID ".html"
  84
  85 //Create struct for http error status
  86 struct httpStatusStruct {
  87         int value;
  88         char *description;
  89 };
  90
  91 //Declare http error status array
  92 const struct httpStatusStruct httpStatuses[] = {
  93         {200, "OK"},
  94         {400, "Bad Request"},
  95         {405, "Method Not Allowed"},
  96         {411, "Length Required"},
  97         {500, "Internal Server Error"},
  98         {503, "Service Unavailable"}
  99 };
 100
 101 /**
 102  * Prototype
 103  */
 104 void die(const int, const char*);
 105 void header(const int, const char*);
 106 void showForm(const char*, const int, const int);
 107 void showMaintenance();
 108 int extractValue(char**, int*, char*, int);
 109 int extractLuksDevice(char**, char**);
 110 int extractIHttpdPid(pid_t *);
 111 int extractAskPasswordPid(pid_t *);
 112
 113 /**
 114  * Die with error
 115  */
 116 void die(const int code, const char *err) {
 117         //TODO: see if we add a nice text/html template ?
 118         //Send content as text
 119         header(code, "text/plain");
 120         //Print error line if available
 121         if (err != NULL)
 122                 printf("%s", err);
 123         //Flush all
 124         if (fflush(NULL) == -1) {
 125                 perror("fflush");
 126         }
 127         //Exit with failure code
 128         exit(EXIT_FAILURE);
 129 }
 130
 131 /**
 132  * Send header
 133  */
 134 void header(const int code, const char *ctype) {
 135         int k;
 136         switch(code) {
 137                 case 400:
 138                         k = 1;
 139                         break;
 140                 case 405:
 141                         k = 2;
 142                         break;
 143                 case 411:
 144                         k = 3;
 145                         break;
 146                 case 500:
 147                         k = 4;
 148                         break;
 149                 case 503:
 150                         k = 5;
 151                         break;
 152                 default:
 153                         k = 0;
 154         }
 155         //Send http status
 156         printf("Status: %d %s\r\n", httpStatuses[k].value, httpStatuses[k].description);
 157         //Make sure no cache
 158         printf("Cache-Control: no-cache, no-store, must-revalidate\r\n");
 159         printf("Pragma: no-cache\r\n");
 160         printf("Expires: 0\r\n");
 161         printf("X-Robots-Tag: noindex, nofollow, noarchive, nosnippet, noodp\r\n");
 162         printf("Content-type: %s\r\n\r\n", ctype);
 163 }
 164
 165 /**
 166  * Show form
 167  */
 168 void showForm(const char *requestUri, const int keyfileSizeMax, const int passphraseSizeMax) {
 169         header(503, "text/html");
 170         printf("<!DOCTYPE HTML>\r\n");
 171         printf("<html>\r\n");
 172         printf("<head>\r\n");
 173         printf("<title>Key upload form!</title>\r\n");
 174         printf("<style type=\"text/css\">body{color:black;background-color:white;}a:link{color:#00c;}p,address{margin-left:3em;}span{font-size:smaller;}</style>\r\n");
 175         printf("</head>\r\n");
 176         printf("<body>\r\n");
 177         printf("<div id=\"wrapper\">\r\n");
 178         printf("<form enctype=\"multipart/form-data\" action=\"%s\" method=\"post\"><fieldset><legend>Upload key</legend><label for=\"file\"></label><input type=\"hidden\" name=\"MAX_FILE_SIZE\" value=\"%d\" /><input id=\"file\" type=\"file\" name=\"key\" /><input type=\"submit\" value=\"Send\" /></fieldset></form>\r\n", requestUri, keyfileSizeMax);
 179         printf("<form action=\"%s\" method=\"post\"><fieldset><legend>Type key</legend><label for=\"password\"></label><input id=\"password\" type=\"password\" name=\"key\" maxlength=\"%d\" /><input type=\"submit\" value=\"Send\" /></fieldset></form>\r\n", requestUri, passphraseSizeMax);
 180         printf("</div>\r\n");
 181         printf("</body>\r\n");
 182         printf("</html>\r\n");
 183 }
 184
 185 /**
 186  * Show maintenance
 187  */
 188 void showMaintenance() {
 189         header(503, "text/html");
 190         printf("<!DOCTYPE HTML>\r\n");
 191         printf("<html>\r\n");
 192         printf("<head>\r\n");
 193         printf("<title>Service unavailable!</title>\r\n");
 194         printf("<style type=\"text/css\">body{color:black;background-color:white;}a:link{color:#00c;}p,address{margin-left:3em;}span{font-size:smaller;}</style>\r\n");
 195         printf("</head>\r\n");
 196         printf("<body>\r\n");
 197         printf("<h1>Service unavailable!</h1>\r\n");
 198         printf("<p>The server is temporarily unable to service your\r\n");
 199         printf("request due to maintenance downtime or capacity\r\n");
 200         printf("problems. Please try again later.</p>\r\n");
 201         printf("<h2>Error 503</h2>\r\n");
 202         printf("<address><a href=\"/\">%s</a><br /><span>%s</span></address>\r\n", getenv("SERVER_NAME"), getenv("SERVER_SOFTWARE"));
 203         printf("<!--crc32:%s-->\r\n", FORMID);
 204         printf("</body>\r\n");
 205         printf("</html>\r\n");
 206 }
 207
 208 /**
 209  * Extract value
 210  */
 211 int extractValue(char **value, int *valueLength, char *contentType, int contentLength) {
 212         //Handle application/x-www-form-urlencoded request
 213         if (contentType != NULL && !strncmp(contentType, "application/x-www-form-urlencoded", 33)) {
 214                 //Indexes and return
 215                 int i, k, v, r;
 216                 //Declare key and buf
 217                 char *key, *buf;
 218                 //Allocate key
 219                 if ((key = malloc(4*sizeof(char))) == NULL) {
 220                         //Unable to allocate key
 221                         return -1;
 222                 }
 223                 //Allocate buf to maximum possible value size + 1 for trailing \0
 224                 if ((buf = calloc(1, (DEFAULT_PASSPHRASE_SIZE_MAX+1)*sizeof(char))) == NULL) {
 225                         //Unable to allocate value
 226                         free(key);
 227                         return -2;
 228                 }
 229                 //Char buffer
 230                 char d = '\0';
 231                 //Char delimiter
 232                 //XXX: initialised as & for new key, becomes = when fetching value
 233                 char delim = '&';
 234                 for (i = 0, k = 0, v = 0; i < contentLength; i++) {
 235                         //Safeguard against a value greater than DEFAULT_PASSPHRASE_SIZE_MAX
 236                         //XXX: this should never happen because we should be protected by contentLength already
 237                         if (v == DEFAULT_PASSPHRASE_SIZE_MAX+1) {
 238                                 //Invalid value
 239                                 free(key);
 240                                 free(buf);
 241                                 return -3;
 242                         }
 243                         //Read one character from stdin
 244                         r = read(STDIN_FILENO, &d, 1);
 245                         //Handle errors
 246                         if (r < 0) {
 247                                 //Error while parsing post data
 248                                 free(key);
 249                                 free(buf);
 250                                 return -4;
 251                         } else if (r == 0) {
 252                                 //Partial receive
 253                                 free(key);
 254                                 free(buf);
 255                                 return -5;
 256                         }
 257                         //Handle case where key has an other name
 258                         if (i == 3) {
 259                                 //Check key is "key" and we get '=' as new char and assign delim to =
 260                                 if (strncmp(key, "key", 3) || (delim = d) != '=') {
 261                                         //Invalid key
 262                                         free(key);
 263                                         free(buf);
 264                                         return -6;
 265                                 }
 266                         //Handle key or value separator in query string
 267                         } else if (d == '&' || d == '=') {
 268                                 //Invalid query string
 269                                 free(key);
 270                                 free(buf);
 271                                 return -7;
 272                         //Handle a value
 273                         } else {
 274                                 //Save key char
 275                                 if (delim == '&') {
 276                                         key[k] = d;
 277                                         k++;
 278                                 //Save buf char
 279                                 } else {
 280                                         buf[v] = d;
 281                                         v++;
 282                                 }
 283                         }
 284                 }
 285                 //Free key
 286                 free(key);
 287                 //Unescape and reduce value if not empty
 288                 if (v > 0) {
 289                         //Declare iterators
 290                         int l,m, s = v;
 291                         //Loop on value and reduce length on the fly
 292                         for(l=0,m=0; m < v; l++,m++) {
 293                                 //Replace + with space
 294                                 if (buf[m] == '+') {
 295                                         buf[l] = ' ';
 296                                 //Skip partial present %XX
 297                                 } else if (
 298                                         //Assign char
 299                                         (buf[l] = buf[m]) == '%' &&
 300                                         //Check we didn't reach valueStrLength
 301                                         (m+2 < v) &&
 302                                         //Check next two digits are valid
 303                                         ((buf[m+1] >= 'A' && buf[m+1] <= 'F') || (buf[m+1] >= 'a' && buf[m+1] <= 'f') || (buf[m+1] >= '0' && buf[m+1] <= '9')) &&
 304                                         ((buf[m+2] >= 'A' && buf[m+2] <= 'F') || (buf[m+2] >= 'a' && buf[m+2] <= 'f') || (buf[m+2] >= '0' && buf[m+2] <= '9'))
 305                                 ) {
 306                                         buf[l] = (buf[m+1] >= 'A' ? (buf[m+1] & 0xdf) - 'A' + 10 : buf[m+1] - '0') * 16 + (buf[m+2] >= 'A' ? (buf[m+2] & 0xdf) - 'A' + 10 : buf[m+2] - '0');
 307                                         m += 2;
 308                                         s -= 2;
 309                                 }
 310                         }
 311                         //Set value length
 312                         *valueLength = s;
 313                         //Alloc value
 314                         if ((*value = malloc((*valueLength)*sizeof(char))) == NULL) {
 315                                 //Unable to alloc value
 316                                 free(key);
 317                                 free(buf);
 318                                 return -8;
 319                         }
 320                         //Copy value
 321                         memcpy(*value, buf, *valueLength);
 322                 }
 323                 //Free buf
 324                 free(buf);
 325         //Handle multipart/form-data request
 326         } else if (contentType != NULL && !strncmp(contentType, "multipart/form-data", 19)) {
 327                 //Indexes and return
 328                 int b, s, r;
 329                 //Boundary length
 330                 int boundaryLength = strlen(contentType) - 30 + 1;
 331                 //Client send LF ending without CR
 332                 int lfstyle = 0;
 333                 //Declare boundary
 334                 char *boundary;
 335                 //Allocate boundary
 336                 if ((boundary = calloc(1, boundaryLength*sizeof(char))) == NULL) {
 337                         //Unable to allocate boundary
 338                         return -9;
 339                 }
 340                 //Extract boundary
 341                 memcpy(boundary, contentType + 30, boundaryLength - 1);
 342
 343                 //Declare buffers
 344                 char *start, *buf;
 345                 //Allocate buffer
 346                 if ((buf = malloc(contentLength*sizeof(char))) == NULL) {
 347                         //Unable to allocate buffer
 348                         free(boundary);
 349                         return -10;
 350                 }
 351                 //Char buffer
 352                 char d = '\0';
 353
 354                 //Loop
 355                 for (b = 0, s = 0; b < contentLength; b++) {
 356                         //Detect possible boundary
 357                         //XXX: b is boundaryLength-1 + 2 after s
 358                         //XXX: d will be a CR(CRLF line ending) or LF(LF line ending) or -(of final --)
 359                         if (b == s + 2 + boundaryLength - 1 && !strncmp(boundary, buf + b - boundaryLength + 1, boundaryLength - 1)) {
 360                                 //Only after first boundary match
 361                                 if (s > 0) {
 362                                         //Trim line jump
 363                                         if (start[0] == '\r' && start[1] == '\n') {
 364                                                 start += 2;
 365                                                 lfstyle = 1;
 366                                         } else if (start[0] == '\n') {
 367                                                 start++;
 368                                         }
 369                                         //Found flag
 370                                         bool found = false;
 371                                         //Allocate pointers
 372                                         char *new = start, *prev = start, *name = NULL;
 373                                         //Search for a new line
 374                                         while ((new = memchr(new, '\n', b - (new - buf)))) {
 375                                                 //Jump to first character after new line
 376                                                 new++;
 377                                                 //Init line length
 378                                                 int lineLength = new - prev - 1;
 379                                                 //Remove chariage return if necessary
 380                                                 if (prev[lineLength] == '\r') {
 381                                                         lineLength--;
 382                                                         lfstyle = 1;
 383                                                 }
 384                                                 //Break loop after headers end
 385                                                 if (lineLength == 1) {
 386                                                         break;
 387                                                 }
 388                                                 //Allocate a name buf of maximum line length
 389                                                 //XXX: need to be filled with zero as we don't know what will comes with sscanf call and we rely on strlen
 390                                                 if ((name = calloc(1, lineLength*sizeof(char))) == NULL) {
 391                                                         //Unable to allocate name
 392                                                         free(boundary);
 393                                                         free(buf);
 394                                                         return -11;
 395                                                 }
 396                                                 //Search for name
 397                                                 if (sscanf(prev, "Content-Disposition: form-data; name=\"%[^\"]\"", name)) {
 398                                                         //Realloc name
 399                                                         if ((name = realloc(name, (strlen(name)+1)*sizeof(char))) == NULL) {
 400                                                                 //Unable to reduce name
 401                                                                 free(boundary);
 402                                                                 free(buf);
 403                                                                 free(name);
 404                                                                 return -12;
 405                                                         }
 406                                                         if (!strncmp(name, "key", 3)) {
 407                                                                 found = true;
 408                                                         }
 409                                                 }
 410                                                 //Free name
 411                                                 free(name);
 412                                                 //Jump to next one
 413                                                 prev = new;
 414                                         }
 415                                         //Init value if found
 416                                         if (found) {
 417                                                 //Declare end
 418                                                 char *end = buf + b - boundaryLength - 3;
 419                                                 //Remove CR at end if provided
 420                                                 //XXX: only remove CR at end if we encountered one before
 421                                                 if (lfstyle) {
 422                                                         end++;
 423                                                 }
 424                                                 //On too big keyfile
 425                                                 if (end - new - 1 >= DEFAULT_KEYFILE_SIZE_MAX) {
 426                                                         //Keyfile too large
 427                                                         free(boundary);
 428                                                         free(buf);
 429                                                         return -13;
 430                                                 }
 431                                                 //On non empty value
 432                                                 if (end - new > 1) {
 433                                                         //Set value length
 434                                                         *valueLength = end - new - 1;
 435                                                         //Allocate value
 436                                                         if ((*value = malloc((*valueLength)*sizeof(char))) == NULL) {
 437                                                                 //Unable to allocate value
 438                                                                 free(boundary);
 439                                                                 free(buf);
 440                                                                 return -14;
 441                                                         }
 442                                                         //Copy value
 443                                                         memcpy(*value, new, *valueLength);
 444                                                 }
 445                                         }
 446                                 }
 447                                 //Set start to matched boundary
 448                                 start = buf + b;
 449                         }
 450                         //Read one character from stdin
 451                         r = read(STDIN_FILENO, &d, 1);
 452                         //Handle errors
 453                         if (r < 0) {
 454                                 //Error while parsing post data
 455                                 free(boundary);
 456                                 free(buf);
 457                                 return -15;
 458                         } else if (r == 0) {
 459                                 //Partial receive
 460                                 free(boundary);
 461                                 free(buf);
 462                                 return -16;
 463                         }
 464                         //New line case
 465                         if (d == '\n') {
 466                                 //Store new possible boundary start
 467                                 s = b + 1;
 468                         }
 469                         buf[b] = d;
 470                 }
 471
 472                 //Free buffers
 473                 free(boundary);
 474                 free(buf);
 475         //Unhandled request
 476         } else {
 477                 return -17;
 478         }
 479
 480         //Send value
 481         return 0;
 482 }
 483
 484 /**
 485  * Extract luks and device
 486  */
 487 int extractLuksDevice(char **luks, char **device) {
 488         //Declare file descriptor
 489         int fd, bufLength;
 490         //Declare buf, device and luks pointer
 491         char *buf, *d, *l;
 492         //Declare stat struct
 493         struct stat *stats;
 494         //Open file
 495         if ((fd = open(CRYPTTAB, O_RDONLY|O_NOATIME|O_NOFOLLOW|O_CLOEXEC)) == -1) {
 496                 //Can't open crypttab file
 497                 return -1;
 498         }
 499         //Allocate stats
 500         if ((stats = calloc(1, sizeof(struct stat))) == NULL) {
 501                 //Unable to allocate stats
 502                 return -2;
 503         }
 504         //Stat file
 505         if (fstat(fd, stats) == -1) {
 506                 //Can't stat crypttab
 507                 return -3;
 508         }
 509         //Check file size
 510         if ((bufLength = stats->st_size) > SSIZE_MAX) {
 511                 //Crypttab too big
 512                 return -4;
 513         }
 514         //Allocate buf
 515         if ((buf = malloc(bufLength*sizeof(char))) == NULL) {
 516                 //Unable to allocate buf
 517                 return -5;
 518         }
 519         //Read file
 520         if ((read(fd, buf, bufLength)) < bufLength) {
 521                 //Fail to read crypttab file
 522                 return -6;
 523         }
 524         //Close file
 525         close(fd);
 526         //Free stats buffer
 527         free(stats);
 528
 529         //Search first separator (\s|\t) after luks
 530         if ((l = memchr(buf, ' ', bufLength)) == NULL && (l = memchr(buf, '     ', bufLength)) == NULL) {
 531                 return -7;
 532         }
 533         //Jump to next char
 534         l++;
 535         //Search first separator (\s|\t) after device
 536         if ((d = memchr(l, ' ', bufLength - (l - buf))) == NULL && (d = memchr(l, '     ', bufLength - (l - buf))) == NULL && (d = memchr(l, '\n', bufLength - (l - buf))) == NULL) {
 537                 return -8;
 538         }
 539         //Jump to next char
 540         d++;
 541
 542         //Alloc luks
 543         if ((*luks = malloc((l - buf - 1)*sizeof(char))) == NULL) {
 544                 return -9;
 545         }
 546         //Allocate device
 547         if ((*device = malloc((d  - l - 1)*sizeof(char))) == NULL) {
 548                 //Free and reset luks
 549                 free(luks);
 550                 luks=NULL;
 551                 return -10;
 552         }
 553
 554         //Copy luks
 555         memcpy(*luks, buf, l  - buf - 1);
 556         //Terminate luks
 557         (*luks)[l - buf - 1] = '\0';
 558
 559         //Copy device
 560         memcpy(*device, l, d  - l - 1);
 561         //Terminate device
 562         (*device)[d - l - 1] = '\0';
 563
 564         //Free buffer
 565         free(buf);
 566
 567         //Success
 568         return 0;
 569 }
 570
 571 /**
 572  * Extract ask-password pid
 573  */
 574 int extractAskPasswordPid(pid_t *pid) {
 575         //Declare stuct dirent
 576         struct dirent *entry;
 577         //Declare askdir
 578         DIR *askdir;
 579         //Declare found
 580         int found = 0;
 581
 582         //Allocate dirent struct
 583         if ((entry = calloc(1, sizeof(struct dirent))) == NULL) {
 584                 //Unable to allocate entry
 585                 return -1;
 586         }
 587
 588         //Open systemd ask-password dir
 589         if ((askdir = opendir(ASKPASSWORDDIR)) == NULL) {
 590                 //Can't open ask dir
 591                 return -2;
 592         }
 593
 594         //Change dir
 595         if (chdir(ASKPASSWORDDIR) == -1) {
 596                 //Can't change to ask dir
 597                 return -3;
 598         }
 599
 600         //Loop on dir content
 601         while((entry = readdir(askdir))) {
 602                 //Handle each ask.XXXXXX file
 603                 if (!strncmp(entry->d_name, "ask.", 4) && strlen(entry->d_name) == 10) {
 604                         //Declare file descriptor
 605                         int fd, bufLength;
 606                         //Declare buf
 607                         char *buf;
 608                         //Declare stat struct
 609                         struct stat *stats;
 610                         //Open file
 611                         if ((fd = open(entry->d_name, O_RDONLY|O_NOATIME|O_NOFOLLOW|O_CLOEXEC)) == -1) {
 612                                 //Can't open ask file
 613                                 return -4;
 614                         }
 615                         //Allocate stats
 616                         if ((stats = calloc(1, sizeof(struct stat))) == NULL) {
 617                                 //Unable to allocate stats
 618                                 return -5;
 619                         }
 620                         //Stat file
 621                         if (fstat(fd, stats) == -1) {
 622                                 //Can't stat ask file
 623                                 return -6;
 624                         }
 625                         //Check file size
 626                         if ((bufLength = stats->st_size) > SSIZE_MAX) {
 627                                 //Ask file too big
 628                                 return -7;
 629                         }
 630                         //Allocate buf
 631                         if ((buf = malloc(bufLength*sizeof(char))) == NULL) {
 632                                 //Unable to allocate buf
 633                                 return -8;
 634                         }
 635                         //Read file
 636                         if ((read(fd, buf, bufLength)) < bufLength) {
 637                                 //Fail to read ask file
 638                                 return -9;
 639                         }
 640                         //Close file
 641                         close(fd);
 642                         //Free stats buffer
 643                         free(stats);
 644
 645                         //Allocate pointers
 646                         char *nl = buf, *pl = buf, *e;
 647                         //Allocate pid
 648                         *pid = 0;
 649
 650                         //Search for a new line
 651                         while ((nl = memmem(nl, bufLength - (nl - buf), "\n", strlen("\n")))) {
 652                                 //Jump to next char
 653                                 nl++;
 654
 655                                 //Check if we have a = in line but not empty value ("=\n")
 656                                 if ((e = memmem(pl, bufLength - (pl - buf), "=", strlen("="))) && e < nl - 2) {
 657                                         //Jump to next char
 658                                         e++;
 659                                         //Look for PID
 660                                         if (!strncmp(pl, "PID", 3)) {
 661                                                 //Declade pid string
 662                                                 char *pidStr;
 663                                                 //Allocate pid string
 664                                                 if ((pidStr = malloc((nl - e)*sizeof(char))) == NULL) {
 665                                                         //Unable to allocate pid string
 666                                                         return -10;
 667                                                 }
 668                                                 //Copy pid
 669                                                 memcpy(pidStr, e, nl - e - 1);
 670                                                 //Terminate pid string
 671                                                 pidStr[nl - e] = '\0';
 672                                                 //Check pid value
 673                                                 if ((*pid = atoi(pidStr)) <= 1) {
 674                                                         //Invalid pid
 675                                                         return -11;
 676                                                 }
 677                                                 //Free pid string
 678                                                 free(pidStr);
 679                                                 //Found a valid process
 680                                                 found++;
 681                                         }
 682                                 }
 683
 684                                 //Jump prev line to new line
 685                                 pl = nl;
 686                         }
 687
 688                         //Free buffers
 689                         free(buf);
 690                 }
 691         }
 692
 693         //Close systemd ask-password dir
 694         if (closedir(askdir) == -1) {
 695                 //Can't close ask dir
 696                 return -13;
 697         }
 698
 699         //Free entry
 700         free(entry);
 701
 702         //Found no valid pid
 703         if (found == 0) {
 704                 //No pid found
 705                 return -14;
 706         //Found more than one pid
 707         } else if (found > 1) {
 708                 //No pid found
 709                 return -15;
 710         }
 711
 712         //Success
 713         return 0;
 714 }
 715
 716 /**
 717  * Extract ihttpd pid
 718  */
 719 int extractIHttpdPid(pid_t *pid) {
 720         //Declare file descriptor
 721         int fd, bufLength;
 722         //Declare buf, device and luks pointer
 723         char *buf, *l, *pidStr;
 724         //Declare stat struct
 725         struct stat *stats;
 726         //Open file
 727         if ((fd = open(IHTTPDPID, O_RDONLY|O_NOATIME|O_NOFOLLOW|O_CLOEXEC)) == -1) {
 728                 //Can't open crypttab file
 729                 return -1;
 730         }
 731         //Allocate stats
 732         if ((stats = calloc(1, sizeof(struct stat))) == NULL) {
 733                 //Unable to allocate stats
 734                 return -2;
 735         }
 736         //Stat file
 737         if (fstat(fd, stats) == -1) {
 738                 //Can't stat crypttab
 739                 return -3;
 740         }
 741         //Check file size
 742         if ((bufLength = stats->st_size) > SSIZE_MAX) {
 743                 //Crypttab too big
 744                 return -4;
 745         }
 746         //Allocate buf
 747         if ((buf = malloc(bufLength*sizeof(char))) == NULL) {
 748                 //Unable to allocate buf
 749                 return -5;
 750         }
 751         //Read file
 752         if ((read(fd, buf, bufLength)) < bufLength) {
 753                 //Fail to read crypttab file
 754                 return -6;
 755         }
 756         //Close file
 757         close(fd);
 758         //Free stats buffer
 759         free(stats);
 760
 761         //Search first separator (\s|\t|\n) after pid
 762         if ((l = memchr(buf, ' ', bufLength)) == NULL && (l = memchr(buf, '     ', bufLength)) == NULL && (l = memchr(buf, '\n', bufLength)) == NULL) {
 763                 return -7;
 764         }
 765         //Jump to next char
 766         l++;
 767
 768         //Alloc pid string
 769         if ((pidStr = malloc((l - buf - 1)*sizeof(char))) == NULL) {
 770                 return -9;
 771         }
 772
 773         //Copy luks
 774         memcpy(pidStr, buf, l  - buf - 1);
 775         //Terminate luks
 776         pidStr[l - buf - 1] = '\0';
 777
 778         //Free buffer
 779         free(buf);
 780
 781         //Store pid
 782         if ((*pid = atoi(pidStr)) <= 1) {
 783                 //Invalid pid
 784                 return -10;
 785         }
 786
 787         //Free pid string
 788         free(pidStr);
 789
 790         //Success
 791         return 0;
 792 }
 793
 794 /**
 795  * Main function
 796  */
 797 int main(int argc, char **argv) {
 798         //Get request method
 799         char *requestMethod = getenv("REQUEST_METHOD");
 800         //Get request uri
 801         char *requestUri = getenv("REQUEST_URI");
 802
 803         //Handle unknown requests
 804         if (requestMethod == NULL || (strncmp(requestMethod, "GET", 3) && strncmp(requestMethod, "HEAD", 4) && strncmp(requestMethod, "POST", 4))) {
 805                 //Send method not allowed
 806                 die(405, "Unsupported request method");
 807         //Handle get and head
 808         } else if (!strncmp(requestMethod, "GET", 3) || !strncmp(requestMethod, "HEAD", 4)) {
 809                 //Check if we have form uri
 810                 if (requestUri != NULL && strlen(requestUri) == strlen(FORMURI) && !strncmp(requestUri, FORMURI, strlen(FORMURI))) {
 811                         //Send form
 812                         showForm(requestUri, DEFAULT_KEYFILE_SIZE_MAX, DEFAULT_PASSPHRASE_SIZE_MAX);
 813                 //Not form uri requested
 814                 } else {
 815                         //Send maintenance page
 816                         showMaintenance();
 817                 }
 818         //Handle post
 819         } else /*if (!strncmp(requestMethod, "POST", 4))*/ {
 820                 //Return value
 821                 int ret;
 822
 823                 //Child pid
 824                 pid_t pid;
 825
 826                 //Value length
 827                 //XXX: will contain number of char in value without trailing \0
 828                 int valueLength;
 829                 //Value string
 830                 //XXX: will contain value without a tailing \0
 831                 char *value = NULL;
 832
 833                 //Content length
 834                 int contentLength;
 835                 //Content length string from env
 836                 char *contentLengthStr = getenv("CONTENT_LENGTH");
 837                 //Content type
 838                 char *contentType = getenv("CONTENT_TYPE");
 839
 840                 //Declare luks and device
 841                 char *luks = NULL, *device = NULL;
 842
 843                 //Declare cargv
 844                 char **cargv = NULL;
 845
 846                 //Pairs of pipe for stdin, stdout and stderr
 847                 int inPipe[2], errPipe[2];
 848
 849                 //Handle unknown content type
 850                 if (contentType == NULL || (strncmp(contentType, "application/x-www-form-urlencoded", 33) && strncmp(contentType, "multipart/form-data", 19))) {
 851                         die(400, "Unknown content type");
 852                 }
 853
 854                 //Handle invalid multipart/form-data content type
 855                 //XXX: max boundary length is 70 as per rfc1521 & rfc2046
 856                 if (!strncmp(contentType, "multipart/form-data", 19) && (strncmp(contentType, "multipart/form-data; boundary=", 30) || strlen(contentType) <= 30 || strlen(contentType) > 100)) {
 857                         die(400, "Malformed boundary in multipart/form-data request");
 858                 }
 859
 860                 //Handle invalid content length
 861                 //XXX: deny empty contentLength as chrome send a contentLength even for a device
 862                 if (contentLengthStr == NULL || (contentLength = atoi(contentLengthStr)) <= 0) {
 863                         die(411, "Invalid content length");
 864                 }
 865
 866                 //Handle application/x-www-form-urlencoded request length
 867                 //XXX: limit to key=xyz where xyz can be all encoded in %XX
 868                 if (!strncmp(contentType, "application/x-www-form-urlencoded", 33) && contentLength > (DEFAULT_PASSPHRASE_SIZE_MAX * 3 + 4)) {
 869                         die(400, "Invalid application/x-www-form-urlencoded request length");
 870                 }
 871
 872                 //Handle multipart/form-data request length
 873                 //XXX: limit to arbitrary 3 times the keyfile max size
 874                 if (!strncmp(contentType, "multipart/form-data", 19) && contentLength > (DEFAULT_KEYFILE_SIZE_MAX * 3)) {
 875                         die(400, "Invalid multipart/form-data request length");
 876                 }
 877
 878                 //Extract value
 879                 if ((ret = extractValue(&value, &valueLength, contentType, contentLength)) < 0) {
 880                         die(500, "Failed to extract value");
 881                 }
 882
 883                 //Extract luks and device
 884                 if ((ret = extractLuksDevice(&luks, &device)) < 0) {
 885                         die(500, "Failed to extract luks and device");
 886                 }
 887
 888                 //Declare cargv array
 889                 char *cargvs[] = { CRYPTSETUP, "-d", "-", "luksOpen", device, luks, NULL };
 890                 //TODO: device cannot be an UUID=xyz, a resolved block device is required for it
 891                 //char *scargvs[] = { SYSTEMDCRYPTSETUP, "attach", luks, device, "-", NULL };
 892
 893                 //Check cryptsetup binary
 894                 if (access(CRYPTSETUP, F_OK|X_OK) == -1) {
 895                         //Check systemdcryptsetup binary
 896                         if (access(SYSTEMDCRYPTSETUP, F_OK|X_OK) == -1) {
 897                                 die(500, "No cryptsetup available");
 898                         } else {
 899                                 //Set contextual env
 900                                 //TODO: resolve UUID in real device name
 901                                 //TODO: passing password through the socket is not possible, as it rely on password ending with \0
 902                                 die(500, "systemd-cryptsetupd is not implementable");
 903                         }
 904                 } else {
 905                         //Set contextual env
 906                         cargv = cargvs;
 907                 }
 908
 909                 //Create stdin pipe
 910                 if (pipe(inPipe) == -1) {
 911                         die(500, "Failed to create in pipe");
 912                 }
 913
 914                 //Create stderr pipe
 915                 if (pipe(errPipe) == -1) {
 916                         die(500, "Failed to create err pipe");
 917                 }
 918
 919                 //Fork process
 920                 if ((pid = fork()) == -1) {
 921                         die(500, "Failed to fork");
 922                 }
 923
 924                 //Child process
 925                 if (pid == 0) {
 926                         //Child arge
 927                         char *carge[] = { NULL };
 928                         //Free value
 929                         free(value);
 930                         //Redirect stdin to pipe
 931                         if (dup2(inPipe[0], STDIN_FILENO) == -1) {
 932                                 die(500, "Failed to redirect in pipe");
 933                         }
 934                         //Close inPipe
 935                         close(inPipe[0]);
 936                         close(inPipe[1]);
 937                         //Redirect stderr to pipe
 938                         if (dup2(errPipe[1], STDERR_FILENO) == -1) {
 939                                 die(500, "Failed to redirect err pipe");
 940                         }
 941                         //Close errPipe
 942                         close(errPipe[0]);
 943                         close(errPipe[1]);
 944
 945                         //Call cryptsetup
 946                         if (execve(cargv[0], cargv, carge) == -1) {
 947                                 die(500, "Failed to call cryptsetup");
 948                         }
 949                 //Parent process
 950                 } else {
 951                         //Free luks
 952                         free(luks);
 953                         //Free device
 954                         free(device);
 955
 956                         //Close unused inPipe end
 957                         close(inPipe[0]);
 958                         //Close unused errPipe end
 959                         close(errPipe[1]);
 960
 961                         //Send password on stdin anyway
 962                         //XXX: this fail if device is already unlocked for example
 963                         write(inPipe[1], value, valueLength);
 964
 965                         //Free value
 966                         free(value);
 967
 968                         //Close stdin with EOF
 969                         close(inPipe[1]);
 970
 971                         //Wait child
 972                         if (waitpid(pid, &ret, 0) == -1) {
 973                                 die(500, "Failed to wait child");
 974                         }
 975
 976                         //Handle already in use device
 977                         if (ret == 5) {
 978                                 die(500, "Device already in use");
 979                         //Handle already unlocked device
 980                         //} else if (ret == 1280) {
 981                         //      die(200, "Device already unlocked");
 982                         //Handle invalid luks device
 983                         //} else if (ret == 256) {
 984                         //      die(500, "Device is now a valid device");
 985                         //Handle no key available with this passphrase
 986                         } else if (ret == 512) {
 987                                 die(500, "No slot for this value");
 988                         //Handle unexisting device or permission denied
 989                         } else if (ret == 1014) {
 990                                 die(500, "Device doesn't exist or access denied");
 991                         //Unknown error
 992                         } else if (ret != 0) {
 993                                 //Err length and counter
 994                                 int errLength = 2048, e = 0;
 995                                 //Declare err buffer
 996                                 char *err;
 997                                 //Buffer char
 998                                 char c;
 999                                 //Alloc err buffer
1000                                 if ((err = malloc(errLength*sizeof(char))) == NULL) {
1001                                         die(500, "Couldn't alloc err buffer");
1002                                 }
1003                                 //Advance after ret code
1004                                 e = sprintf(err, "%d:", ret);
1005                                 //Fetch stderr and store in err buffer
1006                                 while(read(errPipe[0], &c, 1) > 0) {
1007                                         //Grow buffer if we reach end
1008                                         if (e == errLength) {
1009                                                 if ((err = realloc(err, (errLength+2048)*sizeof(char))) == NULL) {
1010                                                         die(500, "Couldn't grow err buffer");
1011                                                 }
1012                                                 errLength += 2048;
1013                                         }
1014                                         //Store character
1015                                         err[e] = c;
1016                                         //Pass to next
1017                                         e++;
1018                                 }
1019                                 //Terminate err buffer
1020                                 err[e] = '\0';
1021                                 //Realloc err buffer
1022                                 if ((err = realloc(err, (e+1)*sizeof(char))) == NULL) {
1023                                         die(500, "Couldn't ungrow err buffer");
1024                                 }
1025                                 //Die with luks error
1026                                 die(500, err);
1027                         }
1028                         //Close errPipe
1029                         close(errPipe[0]);
1030                 }
1031
1032 //Removed as it was making fail the process of booting sometimes
1033 #if 0
1034                 //Fork process
1035                 if ((pid = fork()) == -1) {
1036                         die(500, "Failed to fork");
1037                 }
1038
1039                 //IHttpd killing child process
1040                 if (pid == 0) {
1041                         //File descriptor
1042                         int fd;
1043
1044                         //Declare ihttpd pid
1045                         pid_t ihttpdPid;
1046
1047                         //Close stdin
1048                         close(STDIN_FILENO);
1049
1050                         //Disable line buffering on stdout and stderr
1051                         setvbuf(stdout, NULL, _IONBF, 0);
1052                         setvbuf(stderr, NULL, _IONBF, 0);
1053
1054                         //Redirect output to log
1055                         if ((fd = open(IHTTPDLOG, O_CREAT | O_TRUNC | O_WRONLY, S_IRUSR | S_IWUSR)) == -1) {
1056                                 fprintf(stderr, "Open ihttpd child log failed\n");
1057                         } else {
1058                                 //Close stdout
1059                                 close(STDOUT_FILENO);
1060                                 //Redirect stdout on childlog
1061                                 if (dup2(fd, STDOUT_FILENO) == -1) {
1062                                         fprintf(stderr, "Redirect stdout to ihttpd child log failed\n");
1063                                 }
1064                                 //Close stderr
1065                                 close(STDERR_FILENO);
1066                                 //Redirect stderr on childlog
1067                                 if (dup2(fd, STDERR_FILENO) == -1) {
1068                                         fprintf(stderr, "Redirect stderr to ihttpd child log failed\n");
1069                                 }
1070                                 //Close childlog fd
1071                                 close(fd);
1072                         }
1073
1074                         //Extract ihttpd pid
1075                         if (extractIHttpdPid(&ihttpdPid) < 0) {
1076                                 fprintf(stderr, "Failed to extract ihttpd pid");
1077                                 exit(EXIT_FAILURE);
1078                         }
1079
1080                         //Close stdout and stderr without childlog
1081                         if (fd == -1) {
1082                                 close(STDOUT_FILENO);
1083                                 close(STDERR_FILENO);
1084                         }
1085
1086                         //Wait until get rattached to init(getppid()==1)
1087                         //XXX: we are really blind here
1088                         while(getppid() != 1) {
1089                                 //Sleep half a second
1090                                 if (usleep(500000) == -1 && fd != -1) {
1091                                         printf("Usleep failed\n");
1092                                 }
1093                         }
1094
1095                         //Termiate ihttpd
1096                         if (kill(ihttpdPid, 0) == 0 && kill(ihttpdPid, SIGTERM) == -1 && fd != -1) {
1097                                 printf("Termiate ihttpd failed\n");
1098                         }
1099
1100                         //Sleep half a second
1101                         if (usleep(500000) == -1 && fd != -1) {
1102                                 printf("Usleep failed\n");
1103                         }
1104
1105                         //Kill ihttpd
1106                         if (kill(ihttpdPid, 0) == 0 && kill(ihttpdPid, SIGKILL) == -1) {
1107                                 printf("Kill ihttpd failed\n");
1108                         }
1109
1110                 //Parent process
1111                 } else {
1112 #endif
1113
1114                         //Sleep before killing askpassword process
1115                         if (usleep(500000) == -1) {
1116                                 die(500, "Usleep failed");
1117                         }
1118
1119                         //Fork process
1120                         if ((pid = fork()) == -1) {
1121                                 die(500, "Failed to fork");
1122                         }
1123
1124                         //Ask password killing child process
1125                         //XXX: we are blind here
1126                         if (pid == 0) {
1127                                 //File descriptor
1128                                 int fd;
1129
1130                                 //Declare ask password pid
1131                                 pid_t askPasswordPid;
1132
1133                                 //Close stdin
1134                                 close(STDIN_FILENO);
1135
1136                                 //Disable line buffering on stdout and stderr
1137                                 setvbuf(stdout, NULL, _IONBF, 0);
1138                                 setvbuf(stderr, NULL, _IONBF, 0);
1139
1140                                 //Redirect output to log
1141                                 if ((fd = open(ASKPASSWORDLOG, O_CREAT | O_TRUNC | O_WRONLY, S_IRUSR | S_IWUSR)) == -1) {
1142                                         fprintf(stderr, "Open ask password child log failed\n");
1143                                 } else {
1144                                         //Close stdout
1145                                         close(STDOUT_FILENO);
1146                                         //Redirect stdout on childlog
1147                                         if (dup2(fd, STDOUT_FILENO) == -1) {
1148                                                 fprintf(stderr, "Redirect stdout to ask password child log failed\n");
1149                                         }
1150                                         //Close stderr
1151                                         close(STDERR_FILENO);
1152                                         //Redirect stderr on childlog
1153                                         if (dup2(fd, STDERR_FILENO) == -1) {
1154                                                 fprintf(stderr, "Redirect stderr to ask password child log failed\n");
1155                                         }
1156                                         //Close childlog fd
1157                                         close(fd);
1158                                 }
1159
1160                                 //Extract ask password pid
1161                                 if (extractAskPasswordPid(&askPasswordPid) < 0) {
1162                                         fprintf(stderr, "Failed to extract ask password pid");
1163                                         exit(EXIT_FAILURE);
1164                                 }
1165
1166                                 //Close stdout and stderr without childlog
1167                                 if (fd == -1) {
1168                                         close(STDOUT_FILENO);
1169                                         close(STDERR_FILENO);
1170                                 }
1171
1172                                 //Wait until get rattached to init(getppid()==1)
1173                                 //XXX: we are really blind here
1174                                 while(getppid() != 1) {
1175                                         //Sleep half a second
1176                                         if (usleep(500000) == -1 && fd != -1) {
1177                                                 printf("Usleep failed\n");
1178                                         }
1179                                 }
1180
1181                                 //Termitate ask password
1182                                 if (kill(askPasswordPid, 0) == 0 && kill(askPasswordPid, SIGTERM) == -1 && fd != -1) {
1183                                         printf("Termiate ask password failed\n");
1184                                 }
1185
1186
1187                                 //Sleep half a second
1188                                 if (usleep(500000) == -1 && fd != -1) {
1189                                         printf("Usleep failed\n");
1190                                 }
1191
1192                                 //Kill ask password
1193                                 if (kill(askPasswordPid, 0) == 0 && kill(askPasswordPid, SIGKILL) == -1) {
1194                                         printf("Kill ask password failed\n");
1195                                 }
1196
1197                         //Parent process
1198                         } else {
1199
1200                                 //Process success
1201                                 header(200, "text/plain");
1202                                 printf("Sent value, boot should resume now");
1203                                 fflush(NULL);
1204
1205                         }
1206
1207 #if 0
1208                 }
1209 #endif
1210
1211         }
1212
1213         exit(EXIT_SUCCESS);
1214 }