src/afb-hreq.c

   1 /*
   2  * Copyright (C) 2016, 2017 "IoT.bzh"
   3  * Author: José Bollo <jose.bollo@iot.bzh>
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *   http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #define _GNU_SOURCE
  19
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <assert.h>
  24 #include <errno.h>
  25 #include <fcntl.h>
  26 #include <sys/stat.h>
  27
  28 #include <microhttpd.h>
  29 #include <json-c/json.h>
  30
  31 #if defined(USE_MAGIC_MIME_TYPE)
  32 #include <magic.h>
  33 #endif
  34
  35 #include "afb-method.h"
  36 #include <afb/afb-req-common.h>
  37 #include "afb-msg-json.h"
  38 #include "afb-context.h"
  39 #include "afb-hreq.h"
  40 #include "afb-session.h"
  41 #include "afb-cred.h"
  42 #include "verbose.h"
  43 #include "locale-root.h"
  44
  45 #define SIZE_RESPONSE_BUFFER   8192
  46
  47 static int global_reqids = 0;
  48
  49 static char empty_string[] = "";
  50
  51 static const char long_key_for_uuid[] = "x-afb-uuid";
  52 static const char short_key_for_uuid[] = "uuid";
  53
  54 static const char long_key_for_token[] = "x-afb-token";
  55 static const char short_key_for_token[] = "token";
  56
  57 static const char long_key_for_reqid[] = "x-afb-reqid";
  58 static const char short_key_for_reqid[] = "reqid";
  59
  60 static char *cookie_name = NULL;
  61 static char *cookie_setter = NULL;
  62 static char *tmp_pattern = NULL;
  63
  64 /*
  65  * Structure for storing key/values read from POST requests
  66  */
  67 struct hreq_data {
  68         struct hreq_data *next; /* chain to next data */
  69         char *key;              /* key name */
  70         size_t length;          /* length of the value (used for appending) */
  71         char *value;            /* the value (or original filename) */
  72         char *path;             /* path of the file saved */
  73 };
  74
  75 static struct json_object *req_json(struct afb_xreq *xreq);
  76 static struct afb_arg req_get(struct afb_xreq *xreq, const char *name);
  77 static void req_fail(struct afb_xreq *xreq, const char *status, const char *info);
  78 static void req_success(struct afb_xreq *xreq, json_object *obj, const char *info);
  79 static void req_destroy(struct afb_xreq *xreq);
  80
  81 const struct afb_xreq_query_itf afb_hreq_xreq_query_itf = {
  82         .json = req_json,
  83         .get = req_get,
  84         .success = req_success,
  85         .fail = req_fail,
  86         .unref = req_destroy
  87 };
  88
  89 static struct hreq_data *get_data(struct afb_hreq *hreq, const char *key, int create)
  90 {
  91         struct hreq_data *data = hreq->data;
  92         while (data != NULL) {
  93                 if (!strcasecmp(data->key, key))
  94                         return data;
  95                 data = data->next;
  96         }
  97         if (create) {
  98                 data = calloc(1, sizeof *data);
  99                 if (data != NULL) {
 100                         data->key = strdup(key);
 101                         if (data->key == NULL) {
 102                                 free(data);
 103                                 data = NULL;
 104                         } else {
 105                                 data->next = hreq->data;
 106                                 hreq->data = data;
 107                         }
 108                 }
 109         }
 110         return data;
 111 }
 112
 113 /* a valid subpath is a relative path not looking deeper than root using .. */
 114 static int validsubpath(const char *subpath)
 115 {
 116         int l = 0, i = 0;
 117
 118         while (subpath[i]) {
 119                 switch (subpath[i++]) {
 120                 case '.':
 121                         if (!subpath[i])
 122                                 break;
 123                         if (subpath[i] == '/') {
 124                                 i++;
 125                                 break;
 126                         }
 127                         if (subpath[i++] == '.') {
 128                                 if (!subpath[i]) {
 129                                         if (--l < 0)
 130                                                 return 0;
 131                                         break;
 132                                 }
 133                                 if (subpath[i++] == '/') {
 134                                         if (--l < 0)
 135                                                 return 0;
 136                                         break;
 137                                 }
 138                         }
 139                 default:
 140                         while (subpath[i] && subpath[i] != '/')
 141                                 i++;
 142                         l++;
 143                 case '/':
 144                         break;
 145                 }
 146         }
 147         return 1;
 148 }
 149
 150 static void afb_hreq_reply_v(struct afb_hreq *hreq, unsigned status, struct MHD_Response *response, va_list args)
 151 {
 152         char *cookie;
 153         const char *k, *v;
 154
 155         if (hreq->replied != 0)
 156                 return;
 157
 158         k = va_arg(args, const char *);
 159         while (k != NULL) {
 160                 v = va_arg(args, const char *);
 161                 MHD_add_response_header(response, k, v);
 162                 k = va_arg(args, const char *);
 163         }
 164         v = afb_context_sent_uuid(&hreq->xreq.context);
 165         if (v != NULL && asprintf(&cookie, cookie_setter, v) > 0) {
 166                 MHD_add_response_header(response, MHD_HTTP_HEADER_SET_COOKIE, cookie);
 167                 free(cookie);
 168         }
 169         MHD_queue_response(hreq->connection, status, response);
 170         MHD_destroy_response(response);
 171
 172         hreq->replied = 1;
 173         if (hreq->suspended != 0) {
 174                 extern void run_micro_httpd(struct afb_hsrv *hsrv);
 175                 MHD_resume_connection (hreq->connection);
 176                 hreq->suspended = 0;
 177                 run_micro_httpd(hreq->hsrv);
 178         }
 179 }
 180
 181 void afb_hreq_reply(struct afb_hreq *hreq, unsigned status, struct MHD_Response *response, ...)
 182 {
 183         va_list args;
 184         va_start(args, response);
 185         afb_hreq_reply_v(hreq, status, response, args);
 186         va_end(args);
 187 }
 188
 189 void afb_hreq_reply_empty(struct afb_hreq *hreq, unsigned status, ...)
 190 {
 191         va_list args;
 192         va_start(args, status);
 193         afb_hreq_reply_v(hreq, status, MHD_create_response_from_buffer(0, NULL, MHD_RESPMEM_PERSISTENT), args);
 194         va_end(args);
 195 }
 196
 197 void afb_hreq_reply_static(struct afb_hreq *hreq, unsigned status, size_t size, const char *buffer, ...)
 198 {
 199         va_list args;
 200         va_start(args, buffer);
 201         afb_hreq_reply_v(hreq, status, MHD_create_response_from_buffer((unsigned)size, (char*)buffer, MHD_RESPMEM_PERSISTENT), args);
 202         va_end(args);
 203 }
 204
 205 void afb_hreq_reply_copy(struct afb_hreq *hreq, unsigned status, size_t size, const char *buffer, ...)
 206 {
 207         va_list args;
 208         va_start(args, buffer);
 209         afb_hreq_reply_v(hreq, status, MHD_create_response_from_buffer((unsigned)size, (char*)buffer, MHD_RESPMEM_MUST_COPY), args);
 210         va_end(args);
 211 }
 212
 213 void afb_hreq_reply_free(struct afb_hreq *hreq, unsigned status, size_t size, char *buffer, ...)
 214 {
 215         va_list args;
 216         va_start(args, buffer);
 217         afb_hreq_reply_v(hreq, status, MHD_create_response_from_buffer((unsigned)size, buffer, MHD_RESPMEM_MUST_FREE), args);
 218         va_end(args);
 219 }
 220
 221 #if defined(USE_MAGIC_MIME_TYPE)
 222
 223 #if !defined(MAGIC_DB)
 224 #define MAGIC_DB "/usr/share/misc/magic.mgc"
 225 #endif
 226
 227 static magic_t lazy_libmagic()
 228 {
 229         static int done = 0;
 230         static magic_t result = NULL;
 231
 232         if (!done) {
 233                 done = 1;
 234                 /* MAGIC_MIME tells magic to return a mime of the file,
 235                          but you can specify different things */
 236                 INFO("Loading mimetype default magic database");
 237                 result = magic_open(MAGIC_MIME_TYPE);
 238                 if (result == NULL) {
 239                         ERROR("unable to initialize magic library");
 240                 }
 241                 /* Warning: should not use NULL for DB
 242                                 [libmagic bug wont pass efence check] */
 243                 else if (magic_load(result, MAGIC_DB) != 0) {
 244                         ERROR("cannot load magic database: %s", magic_error(result));
 245                         magic_close(result);
 246                         result = NULL;
 247                 }
 248         }
 249
 250         return result;
 251 }
 252
 253 static const char *magic_mimetype_fd(int fd)
 254 {
 255         magic_t lib = lazy_libmagic();
 256         return lib ? magic_descriptor(lib, fd) : NULL;
 257 }
 258
 259 #endif
 260
 261 static const char *mimetype_fd_name(int fd, const char *filename)
 262 {
 263         const char *result = NULL;
 264
 265 #if defined(INFER_EXTENSION)
 266         /*
 267          * Set some well-known extensions
 268          * Note that it is mandatory for example for css files in order to provide
 269          * right mimetype that must be text/css (otherwise chrome browser will not
 270          * load correctly css file) while libmagic returns text/plain.
 271          */
 272         const char *extension = strrchr(filename, '.');
 273         if (extension) {
 274                 static const char *const known[][2] = {
 275                         { ".js",   "text/javascript" },
 276                         { ".html", "text/html" },
 277                         { ".css",  "text/css" },
 278                         { ".ico",  "image/x-icon"},
 279                         { ".png",  "image/png" },
 280                         { ".svg",  "image/svg+xml" },
 281                         { ".ttf",  "application/x-font-ttf"},
 282                         { NULL, NULL }
 283                 };
 284                 int i = 0;
 285                 while (known[i][0]) {
 286                         if (!strcasecmp(extension, known[i][0])) {
 287                                 result = known[i][1];
 288                                 break;
 289                         }
 290                         i++;
 291                 }
 292         }
 293 #endif
 294 #if defined(USE_MAGIC_MIME_TYPE)
 295         if (result == NULL)
 296                 result = magic_mimetype_fd(fd);
 297 #endif
 298         return result;
 299 }
 300
 301 static void req_destroy(struct afb_xreq *xreq)
 302 {
 303         struct afb_hreq *hreq = CONTAINER_OF_XREQ(struct afb_hreq, xreq);
 304         struct hreq_data *data;
 305
 306         if (hreq->postform != NULL)
 307                 MHD_destroy_post_processor(hreq->postform);
 308         for (data = hreq->data; data; data = hreq->data) {
 309                 hreq->data = data->next;
 310                 if (data->path) {
 311                         unlink(data->path);
 312                         free(data->path);
 313                 }
 314                 free(data->key);
 315                 free(data->value);
 316                 free(data);
 317         }
 318         afb_context_disconnect(&hreq->xreq.context);
 319         json_object_put(hreq->json);
 320         free((char*)hreq->xreq.api);
 321         free((char*)hreq->xreq.verb);
 322         afb_cred_unref(hreq->xreq.cred);
 323         free(hreq);
 324 }
 325
 326 void afb_hreq_addref(struct afb_hreq *hreq)
 327 {
 328         afb_xreq_addref(&hreq->xreq);
 329 }
 330
 331 void afb_hreq_unref(struct afb_hreq *hreq)
 332 {
 333         afb_xreq_unref(&hreq->xreq);
 334 }
 335
 336 /*
 337  * Removes the 'prefix' of 'length' from the tail of 'hreq'
 338  * if and only if the prefix exists and is terminated by a leading
 339  * slash
 340  */
 341 int afb_hreq_unprefix(struct afb_hreq *hreq, const char *prefix, size_t length)
 342 {
 343         /* check the prefix ? */
 344         if (length > hreq->lentail || (hreq->tail[length] && hreq->tail[length] != '/')
 345             || strncasecmp(prefix, hreq->tail, length))
 346                 return 0;
 347
 348         /* removes successives / */
 349         while (length < hreq->lentail && hreq->tail[length + 1] == '/')
 350                 length++;
 351
 352         /* update the tail */
 353         hreq->lentail -= length;
 354         hreq->tail += length;
 355         return 1;
 356 }
 357
 358 int afb_hreq_valid_tail(struct afb_hreq *hreq)
 359 {
 360         return validsubpath(hreq->tail);
 361 }
 362
 363 void afb_hreq_reply_error(struct afb_hreq *hreq, unsigned int status)
 364 {
 365         afb_hreq_reply_empty(hreq, status, NULL);
 366 }
 367
 368 int afb_hreq_redirect_to_ending_slash_if_needed(struct afb_hreq *hreq)
 369 {
 370         char *tourl;
 371
 372         if (hreq->url[hreq->lenurl - 1] == '/')
 373                 return 0;
 374
 375         /* the redirect is needed for reliability of relative path */
 376         tourl = alloca(hreq->lenurl + 2);
 377         memcpy(tourl, hreq->url, hreq->lenurl);
 378         tourl[hreq->lenurl] = '/';
 379         tourl[hreq->lenurl + 1] = 0;
 380         afb_hreq_redirect_to(hreq, tourl, 1);
 381         return 1;
 382 }
 383
 384 int afb_hreq_reply_file_if_exist(struct afb_hreq *hreq, int dirfd, const char *filename)
 385 {
 386         int rc;
 387         int fd;
 388         unsigned int status;
 389         struct stat st;
 390         char etag[1 + 2 * 8];
 391         const char *inm;
 392         struct MHD_Response *response;
 393         const char *mimetype;
 394
 395         /* Opens the file or directory */
 396         if (filename[0]) {
 397                 fd = openat(dirfd, filename, O_RDONLY);
 398                 if (fd < 0) {
 399                         if (errno == ENOENT)
 400                                 return 0;
 401                         afb_hreq_reply_error(hreq, MHD_HTTP_FORBIDDEN);
 402                         return 1;
 403                 }
 404         } else {
 405                 fd = dup(dirfd);
 406                 if (fd < 0) {
 407                         afb_hreq_reply_error(hreq, MHD_HTTP_INTERNAL_SERVER_ERROR);
 408                         return 1;
 409                 }
 410         }
 411
 412         /* Retrieves file's status */
 413         if (fstat(fd, &st) != 0) {
 414                 close(fd);
 415                 afb_hreq_reply_error(hreq, MHD_HTTP_INTERNAL_SERVER_ERROR);
 416                 return 1;
 417         }
 418
 419         /* serve directory */
 420         if (S_ISDIR(st.st_mode)) {
 421                 rc = afb_hreq_redirect_to_ending_slash_if_needed(hreq);
 422                 if (rc == 0) {
 423                         static const char *indexes[] = { "index.html", NULL };
 424                         int i = 0;
 425                         while (indexes[i] != NULL) {
 426                                 if (faccessat(fd, indexes[i], R_OK, 0) == 0) {
 427                                         rc = afb_hreq_reply_file_if_exist(hreq, fd, indexes[i]);
 428                                         break;
 429                                 }
 430                                 i++;
 431                         }
 432                 }
 433                 close(fd);
 434                 return rc;
 435         }
 436
 437         /* Don't serve special files */
 438         if (!S_ISREG(st.st_mode)) {
 439                 close(fd);
 440                 afb_hreq_reply_error(hreq, MHD_HTTP_FORBIDDEN);
 441                 return 1;
 442         }
 443
 444         /* Check the method */
 445         if ((hreq->method & (afb_method_get | afb_method_head)) == 0) {
 446                 close(fd);
 447                 afb_hreq_reply_error(hreq, MHD_HTTP_METHOD_NOT_ALLOWED);
 448                 return 1;
 449         }
 450
 451         /* computes the etag */
 452         sprintf(etag, "%08X%08X", ((int)(st.st_mtim.tv_sec) ^ (int)(st.st_mtim.tv_nsec)), (int)(st.st_size));
 453
 454         /* checks the etag */
 455         inm = MHD_lookup_connection_value(hreq->connection, MHD_HEADER_KIND, MHD_HTTP_HEADER_IF_NONE_MATCH);
 456         if (inm && 0 == strcmp(inm, etag)) {
 457                 /* etag ok, return NOT MODIFIED */
 458                 close(fd);
 459                 DEBUG("Not Modified: [%s]", filename);
 460                 response = MHD_create_response_from_buffer(0, empty_string, MHD_RESPMEM_PERSISTENT);
 461                 status = MHD_HTTP_NOT_MODIFIED;
 462         } else {
 463                 /* check the size */
 464                 if (st.st_size != (off_t) (size_t) st.st_size) {
 465                         close(fd);
 466                         afb_hreq_reply_error(hreq, MHD_HTTP_INTERNAL_SERVER_ERROR);
 467                         return 1;
 468                 }
 469
 470                 /* create the response */
 471                 response = MHD_create_response_from_fd((size_t) st.st_size, fd);
 472                 status = MHD_HTTP_OK;
 473
 474                 /* set the type */
 475                 mimetype = mimetype_fd_name(fd, filename);
 476                 if (mimetype != NULL)
 477                         MHD_add_response_header(response, MHD_HTTP_HEADER_CONTENT_TYPE, mimetype);
 478         }
 479
 480         /* fills the value and send */
 481         afb_hreq_reply(hreq, status, response,
 482                         MHD_HTTP_HEADER_CACHE_CONTROL, hreq->cacheTimeout,
 483                         MHD_HTTP_HEADER_ETAG, etag,
 484                         NULL);
 485         return 1;
 486 }
 487
 488 int afb_hreq_reply_file(struct afb_hreq *hreq, int dirfd, const char *filename)
 489 {
 490         int rc = afb_hreq_reply_file_if_exist(hreq, dirfd, filename);
 491         if (rc == 0)
 492                 afb_hreq_reply_error(hreq, MHD_HTTP_NOT_FOUND);
 493         return 1;
 494 }
 495
 496 int afb_hreq_reply_locale_file_if_exist(struct afb_hreq *hreq, struct locale_search *search, const char *filename)
 497 {
 498         int rc;
 499         int fd;
 500         unsigned int status;
 501         struct stat st;
 502         char etag[1 + 2 * 8];
 503         const char *inm;
 504         struct MHD_Response *response;
 505         const char *mimetype;
 506
 507         /* Opens the file or directory */
 508         fd = locale_search_open(search, filename[0] ? filename : ".", O_RDONLY);
 509         if (fd < 0) {
 510                 if (errno == ENOENT)
 511                         return 0;
 512                 afb_hreq_reply_error(hreq, MHD_HTTP_FORBIDDEN);
 513                 return 1;
 514         }
 515
 516         /* Retrieves file's status */
 517         if (fstat(fd, &st) != 0) {
 518                 close(fd);
 519                 afb_hreq_reply_error(hreq, MHD_HTTP_INTERNAL_SERVER_ERROR);
 520                 return 1;
 521         }
 522
 523         /* serve directory */
 524         if (S_ISDIR(st.st_mode)) {
 525                 rc = afb_hreq_redirect_to_ending_slash_if_needed(hreq);
 526                 if (rc == 0) {
 527                         static const char *indexes[] = { "index.html", NULL };
 528                         int i = 0;
 529                         size_t length = strlen(filename);
 530                         char *extname = alloca(length + 30); /* 30 is enough to old data of indexes */
 531                         memcpy(extname, filename, length);
 532                         if (length && extname[length - 1] != '/')
 533                                 extname[length++] = '/';
 534                         while (rc == 0 && indexes[i] != NULL) {
 535                                 strcpy(extname + length, indexes[i++]);
 536                                 rc = afb_hreq_reply_locale_file_if_exist(hreq, search, extname);
 537                         }
 538                 }
 539                 close(fd);
 540                 return rc;
 541         }
 542
 543         /* Don't serve special files */
 544         if (!S_ISREG(st.st_mode)) {
 545                 close(fd);
 546                 afb_hreq_reply_error(hreq, MHD_HTTP_FORBIDDEN);
 547                 return 1;
 548         }
 549
 550         /* Check the method */
 551         if ((hreq->method & (afb_method_get | afb_method_head)) == 0) {
 552                 close(fd);
 553                 afb_hreq_reply_error(hreq, MHD_HTTP_METHOD_NOT_ALLOWED);
 554                 return 1;
 555         }
 556
 557         /* computes the etag */
 558         sprintf(etag, "%08X%08X", ((int)(st.st_mtim.tv_sec) ^ (int)(st.st_mtim.tv_nsec)), (int)(st.st_size));
 559
 560         /* checks the etag */
 561         inm = MHD_lookup_connection_value(hreq->connection, MHD_HEADER_KIND, MHD_HTTP_HEADER_IF_NONE_MATCH);
 562         if (inm && 0 == strcmp(inm, etag)) {
 563                 /* etag ok, return NOT MODIFIED */
 564                 close(fd);
 565                 DEBUG("Not Modified: [%s]", filename);
 566                 response = MHD_create_response_from_buffer(0, empty_string, MHD_RESPMEM_PERSISTENT);
 567                 status = MHD_HTTP_NOT_MODIFIED;
 568         } else {
 569                 /* check the size */
 570                 if (st.st_size != (off_t) (size_t) st.st_size) {
 571                         close(fd);
 572                         afb_hreq_reply_error(hreq, MHD_HTTP_INTERNAL_SERVER_ERROR);
 573                         return 1;
 574                 }
 575
 576                 /* create the response */
 577                 response = MHD_create_response_from_fd((size_t) st.st_size, fd);
 578                 status = MHD_HTTP_OK;
 579
 580                 /* set the type */
 581                 mimetype = mimetype_fd_name(fd, filename);
 582                 if (mimetype != NULL)
 583                         MHD_add_response_header(response, MHD_HTTP_HEADER_CONTENT_TYPE, mimetype);
 584         }
 585
 586         /* fills the value and send */
 587         afb_hreq_reply(hreq, status, response,
 588                         MHD_HTTP_HEADER_CACHE_CONTROL, hreq->cacheTimeout,
 589                         MHD_HTTP_HEADER_ETAG, etag,
 590                         NULL);
 591         return 1;
 592 }
 593
 594 int afb_hreq_reply_locale_file(struct afb_hreq *hreq, struct locale_search *search, const char *filename)
 595 {
 596         int rc = afb_hreq_reply_locale_file_if_exist(hreq, search, filename);
 597         if (rc == 0)
 598                 afb_hreq_reply_error(hreq, MHD_HTTP_NOT_FOUND);
 599         return 1;
 600 }
 601
 602 struct _mkq_ {
 603         int count;
 604         size_t length;
 605         size_t alloc;
 606         char *text;
 607 };
 608
 609 static void _mkq_add_(struct _mkq_ *mkq, char value)
 610 {
 611         char *text = mkq->text;
 612         if (text != NULL) {
 613                 if (mkq->length == mkq->alloc) {
 614                         mkq->alloc += 100;
 615                         text = realloc(text, mkq->alloc);
 616                         if (text == NULL) {
 617                                 free(mkq->text);
 618                                 mkq->text = NULL;
 619                                 return;
 620                         }
 621                         mkq->text = text;
 622                 }
 623                 text[mkq->length++] = value;
 624         }
 625 }
 626
 627 static void _mkq_add_hex_(struct _mkq_ *mkq, char value)
 628 {
 629         _mkq_add_(mkq, (char)(value < 10 ? value + '0' : value + 'A' - 10));
 630 }
 631
 632 static void _mkq_add_esc_(struct _mkq_ *mkq, char value)
 633 {
 634         _mkq_add_(mkq, '%');
 635         _mkq_add_hex_(mkq, (char)((value >> 4) & 15));
 636         _mkq_add_hex_(mkq, (char)(value & 15));
 637 }
 638
 639 static void _mkq_add_char_(struct _mkq_ *mkq, char value)
 640 {
 641         if (value <= ' ' || value >= 127)
 642                 _mkq_add_esc_(mkq, value);
 643         else
 644                 switch(value) {
 645                 case '=':
 646                 case '&':
 647                 case '%':
 648                         _mkq_add_esc_(mkq, value);
 649                         break;
 650                 default:
 651                         _mkq_add_(mkq, value);
 652                 }
 653 }
 654
 655 static void _mkq_append_(struct _mkq_ *mkq, const char *value)
 656 {
 657         while(*value)
 658                 _mkq_add_char_(mkq, *value++);
 659 }
 660
 661 static int _mkquery_(struct _mkq_ *mkq, enum MHD_ValueKind kind, const char *key, const char *value)
 662 {
 663         _mkq_add_(mkq, mkq->count++ ? '&' : '?');
 664         _mkq_append_(mkq, key);
 665         if (value != NULL) {
 666                 _mkq_add_(mkq, '=');
 667                 _mkq_append_(mkq, value);
 668         }
 669         return 1;
 670 }
 671
 672 static char *url_with_query(struct afb_hreq *hreq, const char *url)
 673 {
 674         struct _mkq_ mkq;
 675
 676         mkq.count = 0;
 677         mkq.length = strlen(url);
 678         mkq.alloc = mkq.length + 1000;
 679         mkq.text = malloc(mkq.alloc);
 680         if (mkq.text != NULL) {
 681                 strcpy(mkq.text, url);
 682                 MHD_get_connection_values(hreq->connection, MHD_GET_ARGUMENT_KIND, (void*)_mkquery_, &mkq);
 683                 _mkq_add_(&mkq, 0);
 684         }
 685         return mkq.text;
 686 }
 687
 688 void afb_hreq_redirect_to(struct afb_hreq *hreq, const char *url, int add_query_part)
 689 {
 690         const char *to;
 691         char *wqp;
 692
 693         wqp = add_query_part ? url_with_query(hreq, url) : NULL;
 694         to = wqp ? : url;
 695         afb_hreq_reply_static(hreq, MHD_HTTP_MOVED_PERMANENTLY, 0, NULL,
 696                         MHD_HTTP_HEADER_LOCATION, to, NULL);
 697         DEBUG("redirect from [%s] to [%s]", hreq->url, url);
 698         free(wqp);
 699 }
 700
 701 const char *afb_hreq_get_cookie(struct afb_hreq *hreq, const char *name)
 702 {
 703         return MHD_lookup_connection_value(hreq->connection, MHD_COOKIE_KIND, name);
 704 }
 705
 706 const char *afb_hreq_get_argument(struct afb_hreq *hreq, const char *name)
 707 {
 708         struct hreq_data *data = get_data(hreq, name, 0);
 709         return data ? data->value : MHD_lookup_connection_value(hreq->connection, MHD_GET_ARGUMENT_KIND, name);
 710 }
 711
 712 const char *afb_hreq_get_header(struct afb_hreq *hreq, const char *name)
 713 {
 714         return MHD_lookup_connection_value(hreq->connection, MHD_HEADER_KIND, name);
 715 }
 716
 717 int afb_hreq_post_add(struct afb_hreq *hreq, const char *key, const char *data, size_t size)
 718 {
 719         void *p;
 720         struct hreq_data *hdat = get_data(hreq, key, 1);
 721         if (hdat->path != NULL) {
 722                 return 0;
 723         }
 724         p = realloc(hdat->value, hdat->length + size + 1);
 725         if (p == NULL) {
 726                 return 0;
 727         }
 728         hdat->value = p;
 729         memcpy(&hdat->value[hdat->length], data, size);
 730         hdat->length += size;
 731         hdat->value[hdat->length] = 0;
 732         return 1;
 733 }
 734
 735 int afb_hreq_init_download_path(const char *directory)
 736 {
 737         struct stat st;
 738         size_t n;
 739         char *p;
 740
 741         if (access(directory, R_OK|W_OK)) {
 742                 /* no read/write access */
 743                 return -1;
 744         }
 745         if (stat(directory, &st)) {
 746                 /* can't get info */
 747                 return -1;
 748         }
 749         if (!S_ISDIR(st.st_mode)) {
 750                 /* not a directory */
 751                 errno = ENOTDIR;
 752                 return -1;
 753         }
 754         n = strlen(directory);
 755         while(n > 1 && directory[n-1] == '/') n--;
 756         p = malloc(n + 8);
 757         if (p == NULL) {
 758                 /* can't allocate memory */
 759                 errno = ENOMEM;
 760                 return -1;
 761         }
 762         memcpy(p, directory, n);
 763         p[n++] = '/';
 764         p[n++] = 'X';
 765         p[n++] = 'X';
 766         p[n++] = 'X';
 767         p[n++] = 'X';
 768         p[n++] = 'X';
 769         p[n++] = 'X';
 770         p[n] = 0;
 771         free(tmp_pattern);
 772         tmp_pattern = p;
 773         return 0;
 774 }
 775
 776 static int opentempfile(char **path)
 777 {
 778         int fd;
 779         char *fname;
 780
 781         fname = strdup(tmp_pattern ? : "XXXXXX"); /* TODO improve the path */
 782         if (fname == NULL)
 783                 return -1;
 784
 785         fd = mkostemp(fname, O_CLOEXEC|O_WRONLY);
 786         if (fd < 0)
 787                 free(fname);
 788         else
 789                 *path = fname;
 790         return fd;
 791 }
 792
 793 int afb_hreq_post_add_file(struct afb_hreq *hreq, const char *key, const char *file, const char *data, size_t size)
 794 {
 795         int fd;
 796         ssize_t sz;
 797         struct hreq_data *hdat = get_data(hreq, key, 1);
 798
 799         if (hdat->value == NULL) {
 800                 hdat->value = strdup(file);
 801                 if (hdat->value == NULL)
 802                         return 0;
 803                 fd = opentempfile(&hdat->path);
 804         } else if (strcmp(hdat->value, file) || hdat->path == NULL) {
 805                 return 0;
 806         } else {
 807                 fd = open(hdat->path, O_WRONLY|O_APPEND);
 808         }
 809         if (fd < 0)
 810                 return 0;
 811         while (size) {
 812                 sz = write(fd, data, size);
 813                 if (sz >= 0) {
 814                         hdat->length += (size_t)sz;
 815                         size -= (size_t)sz;
 816                         data += sz;
 817                 } else if (errno != EINTR)
 818                         break;
 819         }
 820         close(fd);
 821         return !size;
 822 }
 823
 824 static struct afb_arg req_get(struct afb_xreq *xreq, const char *name)
 825 {
 826         const char *value;
 827         struct afb_hreq *hreq = CONTAINER_OF_XREQ(struct afb_hreq, xreq);
 828         struct hreq_data *hdat = get_data(hreq, name, 0);
 829         if (hdat)
 830                 return (struct afb_arg){
 831                         .name = hdat->key,
 832                         .value = hdat->value,
 833                         .path = hdat->path
 834                 };
 835
 836         value = MHD_lookup_connection_value(hreq->connection, MHD_GET_ARGUMENT_KIND, name);
 837         return (struct afb_arg){
 838                 .name = value == NULL ? NULL : name,
 839                 .value = value,
 840                 .path = NULL
 841         };
 842 }
 843
 844 static int _iterargs_(struct json_object *obj, enum MHD_ValueKind kind, const char *key, const char *value)
 845 {
 846         json_object_object_add(obj, key, value ? json_object_new_string(value) : NULL);
 847         return 1;
 848 }
 849
 850 static struct json_object *req_json(struct afb_xreq *xreq)
 851 {
 852         struct hreq_data *hdat;
 853         struct json_object *obj, *val;
 854         struct afb_hreq *hreq = CONTAINER_OF_XREQ(struct afb_hreq, xreq);
 855
 856         obj = hreq->json;
 857         if (obj == NULL) {
 858                 hreq->json = obj = json_object_new_object();
 859                 if (obj == NULL) {
 860                 } else {
 861                         MHD_get_connection_values (hreq->connection, MHD_GET_ARGUMENT_KIND, (void*)_iterargs_, obj);
 862                         for (hdat = hreq->data ; hdat ; hdat = hdat->next) {
 863                                 if (hdat->path == NULL)
 864                                         val = hdat->value ? json_object_new_string(hdat->value) : NULL;
 865                                 else {
 866                                         val = json_object_new_object();
 867                                         if (val == NULL) {
 868                                         } else {
 869                                                 json_object_object_add(val, "file", json_object_new_string(hdat->value));
 870                                                 json_object_object_add(val, "path", json_object_new_string(hdat->path));
 871                                         }
 872                                 }
 873                                 json_object_object_add(obj, hdat->key, val);
 874                         }
 875                 }
 876         }
 877         return obj;
 878 }
 879
 880 static ssize_t send_json_cb(json_object *obj, uint64_t pos, char *buf, size_t max)
 881 {
 882         ssize_t len = stpncpy(buf, json_object_to_json_string_ext(obj, JSON_C_TO_STRING_PLAIN)+pos, max) - buf;
 883         return len ? : (ssize_t)MHD_CONTENT_READER_END_OF_STREAM;
 884 }
 885
 886 static void req_reply(struct afb_hreq *hreq, unsigned retcode, const char *status, const char *info, json_object *resp)
 887 {
 888         struct json_object *reply;
 889         const char *reqid;
 890         struct MHD_Response *response;
 891
 892         reqid = afb_hreq_get_argument(hreq, long_key_for_reqid);
 893         if (reqid == NULL)
 894                 reqid = afb_hreq_get_argument(hreq, short_key_for_reqid);
 895
 896         reply = afb_msg_json_reply(status, info, resp, &hreq->xreq.context, reqid);
 897
 898         response = MHD_create_response_from_callback((uint64_t)strlen(json_object_to_json_string_ext(reply, JSON_C_TO_STRING_PLAIN)), SIZE_RESPONSE_BUFFER, (void*)send_json_cb, reply, (void*)json_object_put);
 899         afb_hreq_reply(hreq, retcode, response, NULL);
 900 }
 901
 902 static void req_fail(struct afb_xreq *xreq, const char *status, const char *info)
 903 {
 904         struct afb_hreq *hreq = CONTAINER_OF_XREQ(struct afb_hreq, xreq);
 905         req_reply(hreq, MHD_HTTP_OK, status, info, NULL);
 906 }
 907
 908 static void req_success(struct afb_xreq *xreq, json_object *obj, const char *info)
 909 {
 910         struct afb_hreq *hreq = CONTAINER_OF_XREQ(struct afb_hreq, xreq);
 911         req_reply(hreq, MHD_HTTP_OK, "success", info, obj);
 912 }
 913
 914 void afb_hreq_call(struct afb_hreq *hreq, struct afb_apiset *apiset, const char *api, size_t lenapi, const char *verb, size_t lenverb)
 915 {
 916         hreq->xreq.api = strndup(api, lenapi);
 917         hreq->xreq.verb = strndup(verb, lenverb);
 918         if (hreq->xreq.api == NULL || hreq->xreq.verb == NULL) {
 919                 ERROR("Out of memory");
 920                 afb_hreq_reply_error(hreq, MHD_HTTP_INTERNAL_SERVER_ERROR);
 921         } else if (afb_hreq_init_context(hreq) < 0) {
 922                 afb_hreq_reply_error(hreq, MHD_HTTP_INTERNAL_SERVER_ERROR);
 923         } else {
 924                 afb_xreq_addref(&hreq->xreq); /* TODO check if needed */
 925                 afb_xreq_process(&hreq->xreq, apiset);
 926         }
 927 }
 928
 929 int afb_hreq_init_context(struct afb_hreq *hreq)
 930 {
 931         const char *uuid;
 932         const char *token;
 933
 934         if (hreq->xreq.context.session != NULL)
 935                 return 0;
 936
 937         uuid = afb_hreq_get_header(hreq, long_key_for_uuid);
 938         if (uuid == NULL)
 939                 uuid = afb_hreq_get_argument(hreq, long_key_for_uuid);
 940         if (uuid == NULL)
 941                 uuid = afb_hreq_get_cookie(hreq, cookie_name);
 942         if (uuid == NULL)
 943                 uuid = afb_hreq_get_argument(hreq, short_key_for_uuid);
 944
 945         token = afb_hreq_get_header(hreq, long_key_for_token);
 946         if (token == NULL)
 947                 token = afb_hreq_get_argument(hreq, long_key_for_token);
 948         if (token == NULL)
 949                 token = afb_hreq_get_argument(hreq, short_key_for_token);
 950
 951         return afb_context_connect(&hreq->xreq.context, uuid, token);
 952 }
 953
 954 int afb_hreq_init_cookie(int port, const char *path, int maxage)
 955 {
 956         int rc;
 957
 958         free(cookie_name);
 959         free(cookie_setter);
 960         cookie_name = NULL;
 961         cookie_setter = NULL;
 962
 963         path = path ? : "/";
 964         rc = asprintf(&cookie_name, "%s-%d", long_key_for_uuid, port);
 965         if (rc < 0)
 966                 return 0;
 967         rc = asprintf(&cookie_setter, "%s=%%s; Path=%s; Max-Age=%d; HttpOnly",
 968                         cookie_name, path, maxage);
 969         if (rc < 0)
 970                 return 0;
 971         return 1;
 972 }
 973
 974 struct afb_xreq *afb_hreq_to_xreq(struct afb_hreq *hreq)
 975 {
 976         return &hreq->xreq;
 977 }
 978
 979 struct afb_hreq *afb_hreq_create()
 980 {
 981         struct afb_hreq *hreq = calloc(1, sizeof *hreq);
 982         if (hreq) {
 983                 /* init the request */
 984                 afb_xreq_init(&hreq->xreq, &afb_hreq_xreq_query_itf);
 985                 hreq->reqid = ++global_reqids;
 986         }
 987         return hreq;
 988 }
 989