src/afb-session.c

   1 /*
   2  * Copyright (C) 2015, 2016, 2017 "IoT.bzh"
   3  * Author "Fulup Ar Foll"
   4  * Author: José Bollo <jose.bollo@iot.bzh>
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *   http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #define _GNU_SOURCE
  20 #include <stdio.h>
  21 #include <time.h>
  22 #include <pthread.h>
  23 #include <stdlib.h>
  24 #include <stdint.h>
  25 #include <string.h>
  26 #include <uuid/uuid.h>
  27 #include <errno.h>
  28
  29 #include <json-c/json.h>
  30
  31 #include "afb-session.h"
  32 #include "afb-hook.h"
  33 #include "verbose.h"
  34
  35 #define SIZEUUID        37
  36 #define HEADCOUNT       16
  37 #define COOKIECOUNT     8
  38 #define COOKIEMASK      (COOKIECOUNT - 1)
  39
  40 #define _MAXEXP_        ((time_t)(~(time_t)0))
  41 #define _MAXEXP2_       ((time_t)((((unsigned long long)_MAXEXP_) >> 1)))
  42 #define MAX_EXPIRATION  (_MAXEXP_ >= 0 ? _MAXEXP_ : _MAXEXP2_)
  43 #define NOW             (time(NULL))
  44
  45 /* structure for a cookie added to sessions */
  46 struct cookie
  47 {
  48         struct cookie *next;    /* link to next cookie */
  49         const void *key;        /* pointer key */
  50         void *value;            /* value */
  51         void (*freecb)(void*);  /* function to call when session is closed */
  52 };
  53
  54 /*
  55  * structure for session
  56  */
  57 struct afb_session
  58 {
  59         struct afb_session *next; /* link to the next */
  60         unsigned refcount;      /* external reference count of the session */
  61         int timeout;            /* timeout of the session */
  62         time_t expiration;      /* expiration time of the token */
  63         pthread_mutex_t mutex;  /* mutex of the session */
  64         struct cookie *cookies[COOKIECOUNT]; /* cookies of the session */
  65         uint8_t closed: 1;      /* is the session closed ? */
  66         uint8_t autoclose: 1;   /* close the session when unreferenced */
  67         uint8_t notinset: 1;    /* session removed from the set of sessions */
  68         char uuid[SIZEUUID];    /* long term authentication of remote client */
  69         char token[SIZEUUID];   /* short term authentication of remote client */
  70 };
  71
  72 /* Session UUID are store in a simple array [for 10 sessions this should be enough] */
  73 static struct {
  74         int count;              /* current number of sessions */
  75         int max;                /* maximum count of sessions */
  76         int timeout;            /* common initial timeout */
  77         struct afb_session *heads[HEADCOUNT]; /* sessions */
  78         char initok[SIZEUUID];  /* common initial token */
  79         pthread_mutex_t mutex;  /* declare a mutex to protect hash table */
  80 } sessions = {
  81         .count = 0,
  82         .max = 10,
  83         .timeout = 3600,
  84         .heads = { 0 },
  85         .initok = { 0 },
  86         .mutex = PTHREAD_MUTEX_INITIALIZER
  87 };
  88
  89 /* generate a new fresh 'uuid' */
  90 static void new_uuid(char uuid[SIZEUUID])
  91 {
  92         uuid_t newuuid;
  93         uuid_generate(newuuid);
  94         uuid_unparse_lower(newuuid, uuid);
  95 }
  96
  97 /*
  98  * Returns a tiny hash value for the 'text'.
  99  *
 100  * Tiny hash function inspired from pearson
 101  */
 102 static uint8_t pearson4(const char *text)
 103 {
 104         static uint8_t T[16] = {
 105                  4,  1,  6,  0,  9, 14, 11,  5,
 106                  2,  3, 12, 15, 10,  7,  8, 13
 107         };
 108         uint8_t r, c;
 109
 110         for (r = 0; (c = (uint8_t)*text) ; text++) {
 111                 r = T[r ^ (15 & c)];
 112                 r = T[r ^ (c >> 4)];
 113         }
 114         return r; // % HEADCOUNT;
 115 }
 116
 117 /* lock the set of sessions for exclusive access */
 118 static inline void sessionset_lock()
 119 {
 120         pthread_mutex_lock(&sessions.mutex);
 121 }
 122
 123 /* unlock the set of sessions of exclusive access */
 124 static inline void sessionset_unlock()
 125 {
 126         pthread_mutex_unlock(&sessions.mutex);
 127 }
 128
 129 /*
 130  * search within the set of sessions the session of 'uuid'.
 131  * 'hashidx' is the precomputed hash for 'uuid'
 132  * return the session or NULL
 133  */
 134 static struct afb_session *sessionset_search(const char *uuid, uint8_t hashidx)
 135 {
 136         struct afb_session *session;
 137
 138         session = sessions.heads[hashidx];
 139         while (session && strcmp(uuid, session->uuid))
 140                 session = session->next;
 141
 142         return session;
 143 }
 144
 145 /* add 'session' to the set of sessions */
 146 static int sessionset_add(struct afb_session *session, uint8_t hashidx)
 147 {
 148         /* check availability */
 149         if (sessions.count >= sessions.max) {
 150                 errno = EBUSY;
 151                 return -1;
 152         }
 153
 154         /* add the session */
 155         session->next = sessions.heads[hashidx];
 156         sessions.heads[hashidx] = session;
 157         sessions.count++;
 158         return 0;
 159 }
 160
 161 /* make a new uuid not used in the set of sessions */
 162 static uint8_t sessionset_make_uuid (char uuid[SIZEUUID])
 163 {
 164         uint8_t hashidx;
 165
 166         do {
 167                 new_uuid(uuid);
 168                 hashidx = pearson4(uuid);
 169         } while(sessionset_search(uuid, hashidx));
 170         return hashidx;
 171 }
 172
 173 /* lock the 'session' for exclusive access */
 174 static inline void session_lock(struct afb_session *session)
 175 {
 176         pthread_mutex_lock(&session->mutex);
 177 }
 178
 179 /* unlock the 'session' of exclusive access */
 180 static inline void session_unlock(struct afb_session *session)
 181 {
 182         pthread_mutex_unlock(&session->mutex);
 183 }
 184
 185 /* close the 'session' */
 186 static void session_close(struct afb_session *session)
 187 {
 188         int idx;
 189         struct cookie *cookie;
 190
 191         /* close only one time */
 192         if (!session->closed) {
 193                 /* close it now */
 194                 session->closed = 1;
 195
 196                 /* emit the hook */
 197                 afb_hook_session_close(session);
 198
 199                 /* release cookies */
 200                 for (idx = 0 ; idx < COOKIECOUNT ; idx++) {
 201                         while ((cookie = session->cookies[idx])) {
 202                                 session->cookies[idx] = cookie->next;
 203                                 if (cookie->freecb != NULL)
 204                                         cookie->freecb(cookie->value);
 205                                 free(cookie);
 206                         }
 207                 }
 208         }
 209 }
 210
 211 /* destroy the 'session' */
 212 static void session_destroy (struct afb_session *session)
 213 {
 214         afb_hook_session_destroy(session);
 215         pthread_mutex_destroy(&session->mutex);
 216         free(session);
 217 }
 218
 219 /* update expiration of 'session' according to 'now' */
 220 static void session_update_expiration(struct afb_session *session, time_t now)
 221 {
 222         int timeout;
 223         time_t expiration;
 224
 225         /* compute expiration */
 226         timeout = session->timeout;
 227         if (timeout == AFB_SESSION_TIMEOUT_INFINITE)
 228                 expiration = MAX_EXPIRATION;
 229         else {
 230                 if (timeout == AFB_SESSION_TIMEOUT_DEFAULT)
 231                         expiration = now + sessions.timeout;
 232                 else
 233                         expiration = now + timeout;
 234                 if (expiration < 0)
 235                         expiration = MAX_EXPIRATION;
 236         }
 237
 238         /* record the expiration */
 239         session->expiration = expiration;
 240 }
 241
 242 /*
 243  * Add a new session with the 'uuid' (of 'hashidx')
 244  * and the 'timeout' starting from 'now'.
 245  * Add it to the set of sessions
 246  * Return the created session
 247  */
 248 static struct afb_session *session_add(const char *uuid, int timeout, time_t now, uint8_t hashidx)
 249 {
 250         struct afb_session *session;
 251
 252         /* check arguments */
 253         if (!AFB_SESSION_TIMEOUT_IS_VALID(timeout)
 254          || (uuid && strlen(uuid) >= sizeof session->uuid)) {
 255                 errno = EINVAL;
 256                 return NULL;
 257         }
 258
 259         /* allocates a new one */
 260         session = calloc(1, sizeof *session);
 261         if (session == NULL) {
 262                 errno = ENOMEM;
 263                 return NULL;
 264         }
 265
 266         /* initialize */
 267         pthread_mutex_init(&session->mutex, NULL);
 268         session->refcount = 1;
 269         strcpy(session->uuid, uuid);
 270         strcpy(session->token, sessions.initok);
 271         session->timeout = timeout;
 272         session_update_expiration(session, now);
 273
 274         /* add */
 275         if (sessionset_add(session, hashidx)) {
 276                 free(session);
 277                 return NULL;
 278         }
 279
 280         afb_hook_session_create(session);
 281
 282         return session;
 283 }
 284
 285 /* Remove expired sessions and return current time (now) */
 286 static time_t sessionset_cleanup (int force)
 287 {
 288         struct afb_session *session, **prv;
 289         int idx;
 290         time_t now;
 291
 292         /* Loop on Sessions Table and remove anything that is older than timeout */
 293         now = NOW;
 294         for (idx = 0 ; idx < HEADCOUNT; idx++) {
 295                 prv = &sessions.heads[idx];
 296                 while ((session = *prv)) {
 297                         session_lock(session);
 298                         if (force || session->expiration < now)
 299                                 session_close(session);
 300                         if (!session->closed)
 301                                 prv = &session->next;
 302                         else {
 303                                 *prv = session->next;
 304                                 sessions.count--;
 305                                 session->notinset = 1;
 306                                 if ( !session->refcount) {
 307                                         session_destroy(session);
 308                                         continue;
 309                                 }
 310                         }
 311                         session_unlock(session);
 312                 }
 313         }
 314         return now;
 315 }
 316
 317 /**
 318  * Initialize the session manager with a 'max_session_count',
 319  * an initial common 'timeout' and an initial common token 'initok'.
 320  *
 321  * @param max_session_count  maximum allowed session count in the same time
 322  * @param timeout            the initial default timeout of sessions
 323  * @param initok             the initial default token of sessions
 324  *
 325  */
 326 int afb_session_init (int max_session_count, int timeout, const char *initok)
 327 {
 328         /* check parameters */
 329         if (initok && strlen(initok) >= sizeof sessions.initok) {
 330                 ERROR("initial token '%s' too long (max length %d)",
 331                         initok, ((int)(sizeof sessions.initok)) - 1);
 332                 errno = EINVAL;
 333                 return -1;
 334         }
 335
 336         /* init the sessionset (after cleanup) */
 337         sessionset_lock();
 338         sessionset_cleanup(1);
 339         sessions.max = max_session_count;
 340         sessions.timeout = timeout;
 341         if (initok == NULL)
 342                 new_uuid(sessions.initok);
 343         else
 344                 strcpy(sessions.initok, initok);
 345         sessionset_unlock();
 346         return 0;
 347 }
 348
 349 /**
 350  * Cleanup the sessionset of its closed or expired sessions
 351  */
 352 void afb_session_purge()
 353 {
 354         sessionset_lock();
 355         sessionset_cleanup(0);
 356         sessionset_unlock();
 357 }
 358
 359 /**
 360  * @return the initial token set at initialization
 361  */
 362 const char *afb_session_initial_token()
 363 {
 364         return sessions.initok;
 365 }
 366
 367 /* Searchs the session of 'uuid' */
 368 struct afb_session *afb_session_search (const char *uuid)
 369 {
 370         struct afb_session *session;
 371
 372         sessionset_lock();
 373         sessionset_cleanup(0);
 374         session = sessionset_search(uuid, pearson4(uuid));
 375         session = afb_session_addref(session);
 376         sessionset_unlock();
 377         return session;
 378
 379 }
 380
 381 /**
 382  * Creates a new session with 'timeout'
 383  */
 384 struct afb_session *afb_session_create (int timeout)
 385 {
 386         return afb_session_get(NULL, timeout, NULL);
 387 }
 388
 389 /* This function will return exiting session or newly created session */
 390 struct afb_session *afb_session_get (const char *uuid, int timeout, int *created)
 391 {
 392         char _uuid_[SIZEUUID];
 393         uint8_t hashidx;
 394         struct afb_session *session;
 395         time_t now;
 396         int c;
 397
 398         /* cleaning */
 399         sessionset_lock();
 400         now = sessionset_cleanup(0);
 401
 402         /* search for an existing one not too old */
 403         if (!uuid) {
 404                 hashidx = sessionset_make_uuid(_uuid_);
 405                 uuid = _uuid_;
 406         } else {
 407                 hashidx = pearson4(uuid);
 408                 session = sessionset_search(uuid, hashidx);
 409                 if (session) {
 410                         /* session found */
 411                         afb_session_addref(session);
 412                         c = 0;
 413                         goto end;
 414                 }
 415         }
 416         /* create the session */
 417         session = session_add(uuid, timeout, now, hashidx);
 418         c = 1;
 419 end:
 420         sessionset_unlock();
 421         if (created)
 422                 *created = c;
 423
 424         return session;
 425 }
 426
 427 /* increase the use count on 'session' (can be NULL) */
 428 struct afb_session *afb_session_addref(struct afb_session *session)
 429 {
 430         if (session != NULL) {
 431                 afb_hook_session_unref(session);
 432                 afb_hook_session_addref(session);
 433                 session->refcount++;
 434                 session_unlock(session);
 435         }
 436         return session;
 437 }
 438
 439 /* decrease the use count of 'session' (can be NULL) */
 440 void afb_session_unref(struct afb_session *session)
 441 {
 442         if (session == NULL)
 443                 return;
 444
 445         session_lock(session);
 446         afb_hook_session_unref(session);
 447         if (!--session->refcount) {
 448                 if (session->autoclose)
 449                         session_close(session);
 450                 if (session->notinset) {
 451                         session_destroy(session);
 452                         return;
 453                 }
 454         }
 455         session_unlock(session);
 456 }
 457
 458 /* close 'session' */
 459 void afb_session_close (struct afb_session *session)
 460 {
 461         session_lock(session);
 462         session_close(session);
 463         session_unlock(session);
 464 }
 465
 466 /**
 467  * Set the 'autoclose' flag of the 'session'
 468  *
 469  * A session whose autoclose flag is true will close as
 470  * soon as it is no more referenced.
 471  *
 472  * @param session    the session to set
 473  * @param autoclose  the value to set
 474  */
 475 void afb_session_set_autoclose(struct afb_session *session, int autoclose)
 476 {
 477         session->autoclose = !!autoclose;
 478 }
 479
 480 /* is 'session' closed? */
 481 int afb_session_is_closed (struct afb_session *session)
 482 {
 483         return session->closed;
 484 }
 485
 486 /*
 487  * check whether the token of 'session' is 'token'
 488  * return 1 if true or 0 otherwise
 489  */
 490 int afb_session_check_token (struct afb_session *session, const char *token)
 491 {
 492         int r;
 493
 494         session_unlock(session);
 495         r = !session->closed
 496           && session->expiration >= NOW
 497           && !(session->token[0] && strcmp (token, session->token));
 498         session_unlock(session);
 499         return r;
 500 }
 501
 502 /* generate a new token and update client context */
 503 void afb_session_new_token (struct afb_session *session)
 504 {
 505         session_unlock(session);
 506         new_uuid(session->token);
 507         session_update_expiration(session, NOW);
 508         afb_hook_session_renew(session);
 509         session_unlock(session);
 510 }
 511
 512 /* Returns the uuid of 'session' */
 513 const char *afb_session_uuid (struct afb_session *session)
 514 {
 515         return session->uuid;
 516 }
 517
 518 /* Returns the token of 'session' */
 519 const char *afb_session_token (struct afb_session *session)
 520 {
 521         return session->token;
 522 }
 523
 524 /**
 525  * Get the index of the 'key' in the cookies array.
 526  * @param key the key to scan
 527  * @return the index of the list for key within cookies
 528  */
 529 static int cookeyidx(const void *key)
 530 {
 531         intptr_t x = (intptr_t)key;
 532         unsigned r = (unsigned)((x >> 5) ^ (x >> 15));
 533         return r & COOKIEMASK;
 534 }
 535
 536 /**
 537  * Set, get, replace, remove a cookie of 'key' for the 'session'
 538  *
 539  * The behaviour of this function depends on its parameters:
 540  *
 541  * @param session       the session
 542  * @param key           the key of the cookie
 543  * @param makecb        the creation function or NULL
 544  * @param freecb        the release function or NULL
 545  * @param closure       an argument for makecb or the value if makecb==NULL
 546  * @param replace       a boolean enforcing replecement of the previous value
 547  *
 548  * @return the value of the cookie
 549  *
 550  * The 'key' is a pointer and compared as pointers.
 551  *
 552  * For getting the current value of the cookie:
 553  *
 554  *   afb_session_cookie(session, key, NULL, NULL, NULL, 0)
 555  *
 556  * For storing the value of the cookie
 557  *
 558  *   afb_session_cookie(session, key, NULL, NULL, value, 1)
 559  */
 560 void *afb_session_cookie(struct afb_session *session, const void *key, void *(*makecb)(void *closure), void (*freecb)(void *item), void *closure, int replace)
 561 {
 562         int idx;
 563         void *value;
 564         struct cookie *cookie, **prv;
 565
 566         /* get key hashed index */
 567         idx = cookeyidx(key);
 568
 569         /* lock session and search for the cookie of 'key' */
 570         session_lock(session);
 571         prv = &session->cookies[idx];
 572         for (;;) {
 573                 cookie = *prv;
 574                 if (!cookie) {
 575                         /* 'key' not found, create value using 'closure' and 'makecb' */
 576                         value = makecb ? makecb(closure) : closure;
 577                         /* store the the only if it has some meaning */
 578                         if (replace || makecb || freecb) {
 579                                 cookie = malloc(sizeof *cookie);
 580                                 if (!cookie) {
 581                                         errno = ENOMEM;
 582                                         /* calling freecb if there is no makecb may have issue */
 583                                         if (makecb && freecb)
 584                                                 freecb(value);
 585                                         value = NULL;
 586                                 } else {
 587                                         cookie->key = key;
 588                                         cookie->value = value;
 589                                         cookie->freecb = freecb;
 590                                         cookie->next = NULL;
 591                                         *prv = cookie;
 592                                 }
 593                         }
 594                         break;
 595                 } else if (cookie->key == key) {
 596                         /* cookie of key found */
 597                         if (!replace)
 598                                 /* not replacing, get the value */
 599                                 value = cookie->value;
 600                         else {
 601                                 /* create value using 'closure' and 'makecb' */
 602                                 value = makecb ? makecb(closure) : closure;
 603
 604                                 /* free previous value is needed */
 605                                 if (cookie->value != value && cookie->freecb)
 606                                         cookie->freecb(cookie->value);
 607
 608                                 /* if both value and freecb are NULL drop the cookie */
 609                                 if (!value && !freecb) {
 610                                         *prv = cookie->next;
 611                                         free(cookie);
 612                                 } else {
 613                                         /* store the value and its releaser */
 614                                         cookie->value = value;
 615                                         cookie->freecb = freecb;
 616                                 }
 617                         }
 618                         break;
 619                 } else {
 620                         prv = &(cookie->next);
 621                 }
 622         }
 623
 624         /* unlock the session and return the value */
 625         session_unlock(session);
 626         return value;
 627 }
 628
 629 /**
 630  * Get the cookie of 'key' in the 'session'.
 631  *
 632  * @param session  the session to search in
 633  * @param key      the key of the data to retrieve
 634  *
 635  * @return the data staored for the key or NULL if the key isn't found
 636  */
 637 void *afb_session_get_cookie(struct afb_session *session, const void *key)
 638 {
 639         return afb_session_cookie(session, key, NULL, NULL, NULL, 0);
 640 }
 641
 642 /**
 643  * Set the cookie of 'key' in the 'session' to the 'value' that can be
 644  * cleaned using 'freecb' (if not null).
 645  *
 646  * @param session  the session to set
 647  * @param key      the key of the data to store
 648  * @param value    the value to store at key
 649  * @param freecb   a function to use when the cookie value is to remove (or null)
 650  *
 651  * @return the data staored for the key or NULL if the key isn't found
 652  *
 653  */
 654 int afb_session_set_cookie(struct afb_session *session, const void *key, void *value, void (*freecb)(void*))
 655 {
 656         return -(value != afb_session_cookie(session, key, NULL, freecb, value, 1));
 657 }
 658