src/session.c

   1 /*
   2  * Copyright (C) 2015 "IoT.bzh"
   3  * Author "Fulup Ar Foll"
   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 #include <stdio.h>
  20 #include <time.h>
  21 #include <pthread.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <uuid/uuid.h>
  25 #include <assert.h>
  26 #include <errno.h>
  27
  28 #include <json-c/json.h>
  29
  30 #include "session.h"
  31 #include "verbose.h"
  32
  33 #define NOW (time(NULL))
  34
  35 struct client_value
  36 {
  37         void *value;
  38         void (*free_value)(void*);
  39 };
  40
  41 struct afb_event_listener_list
  42 {
  43         struct afb_event_listener_list *next;
  44         struct afb_event_listener listener;
  45         int refcount;
  46 };
  47
  48 struct AFB_clientCtx
  49 {
  50         unsigned refcount;
  51         time_t expiration;    // expiration time of the token
  52         time_t access;
  53         char uuid[37];        // long term authentication of remote client
  54         char token[37];       // short term authentication of remote client
  55         struct client_value *values;
  56         struct afb_event_listener_list *listeners;
  57 };
  58
  59 // Session UUID are store in a simple array [for 10 sessions this should be enough]
  60 static struct {
  61   pthread_mutex_t mutex;          // declare a mutex to protect hash table
  62   struct AFB_clientCtx **store;          // sessions store
  63   int count;                      // current number of sessions
  64   int max;
  65   int timeout;
  66   int apicount;
  67   char initok[37];
  68   struct afb_event_listener_list *listeners;
  69 } sessions;
  70
  71 /* generate a uuid */
  72 static void new_uuid(char uuid[37])
  73 {
  74         uuid_t newuuid;
  75         uuid_generate(newuuid);
  76         uuid_unparse_lower(newuuid, uuid);
  77 }
  78
  79 // Free context [XXXX Should be protected again memory abort XXXX]
  80 static void ctxUuidFreeCB (struct AFB_clientCtx *client)
  81 {
  82         int idx;
  83
  84         // If application add a handle let's free it now
  85         assert (client->values != NULL);
  86
  87         // Free client handle with a standard Free function, with app callback or ignore it
  88         for (idx=0; idx < sessions.apicount; idx ++)
  89                 ctxClientValueSet(client, idx, NULL, NULL);
  90 }
  91
  92 // Create a new store in RAM, not that is too small it will be automatically extended
  93 void ctxStoreInit (int max_session_count, int timeout, const char *initok, int context_count)
  94 {
  95         // let's create as store as hashtable does not have any
  96         sessions.store = calloc (1 + (unsigned)max_session_count, sizeof(struct AFB_clientCtx));
  97         sessions.max = max_session_count;
  98         sessions.timeout = timeout;
  99         sessions.apicount = context_count;
 100         if (initok == NULL)
 101                 /* without token, a secret is made to forbid creation of sessions */
 102                 new_uuid(sessions.initok);
 103         else if (strlen(initok) < sizeof(sessions.store[0]->token))
 104                 strcpy(sessions.initok, initok);
 105         else {
 106                 ERROR("initial token '%s' too long (max length 36)", initok);
 107                 exit(1);
 108         }
 109 }
 110
 111 static struct AFB_clientCtx *ctxStoreSearch (const char* uuid)
 112 {
 113     int  idx;
 114     struct AFB_clientCtx *client;
 115
 116     assert (uuid != NULL);
 117
 118     pthread_mutex_lock(&sessions.mutex);
 119
 120     for (idx=0; idx < sessions.max; idx++) {
 121         client = sessions.store[idx];
 122         if (client && (0 == strcmp (uuid, client->uuid)))
 123                 goto found;
 124     }
 125     client = NULL;
 126
 127 found:
 128     pthread_mutex_unlock(&sessions.mutex);
 129     return client;
 130 }
 131
 132 static int ctxStoreDel (struct AFB_clientCtx *client)
 133 {
 134     int idx;
 135     int status;
 136
 137     assert (client != NULL);
 138
 139     pthread_mutex_lock(&sessions.mutex);
 140
 141     for (idx=0; idx < sessions.max; idx++) {
 142         if (sessions.store[idx] == client) {
 143                 sessions.store[idx] = NULL;
 144                 sessions.count--;
 145                 status = 1;
 146                 goto deleted;
 147         }
 148     }
 149     status = 0;
 150 deleted:
 151     pthread_mutex_unlock(&sessions.mutex);
 152     return status;
 153 }
 154
 155 static int ctxStoreAdd (struct AFB_clientCtx *client)
 156 {
 157     int idx;
 158     int status;
 159
 160     assert (client != NULL);
 161
 162     pthread_mutex_lock(&sessions.mutex);
 163
 164     for (idx=0; idx < sessions.max; idx++) {
 165         if (NULL == sessions.store[idx]) {
 166                 sessions.store[idx] = client;
 167                 sessions.count++;
 168                 status = 1;
 169                 goto added;
 170         }
 171     }
 172     status = 0;
 173 added:
 174     pthread_mutex_unlock(&sessions.mutex);
 175     return status;
 176 }
 177
 178 // Check if context timeout or not
 179 static int ctxStoreTooOld (struct AFB_clientCtx *ctx, time_t now)
 180 {
 181     assert (ctx != NULL);
 182     return ctx->expiration < now;
 183 }
 184
 185 // Check if context is active or not
 186 static int ctxIsActive (struct AFB_clientCtx *ctx, time_t now)
 187 {
 188     assert (ctx != NULL);
 189     return ctx->uuid[0] != 0 && ctx->expiration >= now;
 190 }
 191
 192 // Loop on every entry and remove old context sessions.hash
 193 static void ctxStoreCleanUp (time_t now)
 194 {
 195         struct AFB_clientCtx *ctx;
 196         long idx;
 197
 198         // Loop on Sessions Table and remove anything that is older than timeout
 199         for (idx=0; idx < sessions.max; idx++) {
 200                 ctx = ctxClientAddRef(sessions.store[idx]);
 201                 if (ctx != NULL && ctxStoreTooOld(ctx, now)) {
 202                         ctxClientClose (ctx);
 203                 }
 204                 ctxClientUnref(ctx);
 205         }
 206 }
 207
 208 // This function will return exiting client context or newly created client context
 209 struct AFB_clientCtx *ctxClientGetSession (const char *uuid, int *created)
 210 {
 211         struct AFB_clientCtx *clientCtx;
 212         time_t now;
 213
 214         /* cleaning */
 215         now = NOW;
 216         ctxStoreCleanUp (now);
 217
 218         /* search for an existing one not too old */
 219         if (uuid != NULL) {
 220                 if (strlen(uuid) >= sizeof clientCtx->uuid) {
 221                         errno = EINVAL;
 222                         goto error;
 223                 }
 224                 clientCtx = ctxStoreSearch(uuid);
 225                 if (clientCtx != NULL) {
 226                         *created = 0;
 227                         goto found;
 228                 }
 229         }
 230
 231         /* returns a new one */
 232         clientCtx = calloc(1, sizeof(struct AFB_clientCtx) + ((unsigned)sessions.apicount * sizeof(*clientCtx->values)));
 233         if (clientCtx == NULL) {
 234                 errno = ENOMEM;
 235                 goto error;
 236         }
 237         clientCtx->values = (void*)(clientCtx + 1);
 238
 239         /* generate the uuid */
 240         if (uuid == NULL) {
 241                 new_uuid(clientCtx->uuid);
 242         } else {
 243                 strcpy(clientCtx->uuid, uuid);
 244         }
 245
 246         /* init the token */
 247         strcpy(clientCtx->token, sessions.initok);
 248         clientCtx->expiration = now + sessions.timeout;
 249         if (!ctxStoreAdd (clientCtx)) {
 250                 errno = ENOMEM;
 251                 goto error2;
 252         }
 253         *created = 1;
 254
 255 found:
 256         clientCtx->access = now;
 257         clientCtx->refcount++;
 258         return clientCtx;
 259
 260 error2:
 261         free(clientCtx);
 262 error:
 263         return NULL;
 264 }
 265
 266 struct AFB_clientCtx *ctxClientAddRef(struct AFB_clientCtx *clientCtx)
 267 {
 268         if (clientCtx != NULL)
 269                 clientCtx->refcount++;
 270         return clientCtx;
 271 }
 272
 273 void ctxClientUnref(struct AFB_clientCtx *clientCtx)
 274 {
 275         if (clientCtx != NULL) {
 276                 assert(clientCtx->refcount != 0);
 277                 --clientCtx->refcount;
 278                 if (clientCtx->refcount == 0 && clientCtx->uuid[0] == 0) {
 279                         ctxStoreDel (clientCtx);
 280                         free(clientCtx);
 281                 }
 282         }
 283 }
 284
 285 // Free Client Session Context
 286 void ctxClientClose (struct AFB_clientCtx *clientCtx)
 287 {
 288         assert(clientCtx != NULL);
 289         if (clientCtx->uuid[0] != 0) {
 290                 clientCtx->uuid[0] = 0;
 291                 ctxUuidFreeCB (clientCtx);
 292                 while(clientCtx->listeners != NULL)
 293                         ctxClientEventListenerRemove(clientCtx, clientCtx->listeners->listener);
 294         }
 295 }
 296
 297 // Sample Generic Ping Debug API
 298 int ctxTokenCheck (struct AFB_clientCtx *clientCtx, const char *token)
 299 {
 300         assert(clientCtx != NULL);
 301         assert(token != NULL);
 302
 303         // compare current token with previous one
 304         if (!ctxIsActive (clientCtx, NOW))
 305                 return 0;
 306
 307         if (clientCtx->token[0] && strcmp (token, clientCtx->token) != 0)
 308                 return 0;
 309
 310         return 1;
 311 }
 312
 313 // generate a new token and update client context
 314 void ctxTokenNew (struct AFB_clientCtx *clientCtx)
 315 {
 316         assert(clientCtx != NULL);
 317
 318         // Old token was valid let's regenerate a new one
 319         new_uuid(clientCtx->token);
 320
 321         // keep track of time for session timeout and further clean up
 322         clientCtx->expiration = NOW + sessions.timeout;
 323 }
 324
 325 static int add_listener(struct afb_event_listener_list **head, struct afb_event_listener listener)
 326 {
 327         struct afb_event_listener_list *iter, **prv;
 328
 329         prv = head;
 330         for (;;) {
 331                 iter = *prv;
 332                 if (iter == NULL) {
 333                         iter = calloc(1, sizeof *iter);
 334                         if (iter == NULL) {
 335                                 errno = ENOMEM;
 336                                 return -1;
 337                         }
 338                         iter->listener = listener;
 339                         iter->refcount = 1;
 340                         *prv = iter;
 341                         return 0;
 342                 }
 343                 if (iter->listener.itf == listener.itf && iter->listener.closure == listener.closure) {
 344                         iter->refcount++;
 345                         return 0;
 346                 }
 347                 prv = &iter->next;
 348         }
 349 }
 350
 351 int ctxClientEventListenerAdd(struct AFB_clientCtx *clientCtx, struct afb_event_listener listener)
 352 {
 353         return add_listener(clientCtx != NULL ? &clientCtx->listeners : &sessions.listeners, listener);
 354 }
 355
 356 static void remove_listener(struct afb_event_listener_list **head, struct afb_event_listener listener)
 357 {
 358         struct afb_event_listener_list *iter, **prv;
 359
 360         prv = head;
 361         for (;;) {
 362                 iter = *prv;
 363                 if (iter == NULL)
 364                         return;
 365                 if (iter->listener.itf == listener.itf && iter->listener.closure == listener.closure) {
 366                         if (!--iter->refcount) {
 367                                 *prv = iter->next;
 368                                 free(iter);
 369                         }
 370                         return;
 371                 }
 372                 prv = &iter->next;
 373         }
 374 }
 375
 376 void ctxClientEventListenerRemove(struct AFB_clientCtx *clientCtx, struct afb_event_listener listener)
 377 {
 378         remove_listener(clientCtx != NULL ? &clientCtx->listeners : &sessions.listeners, listener);
 379 }
 380
 381 static int send(struct afb_event_listener_list *head, const char *event, struct json_object *object)
 382 {
 383         struct afb_event_listener_list *iter;
 384         int result;
 385
 386         result = 0;
 387         iter = head;
 388         while (iter != NULL) {
 389                 if (iter->listener.itf->expects == NULL || iter->listener.itf->expects(iter->listener.closure, event)) {
 390                         iter->listener.itf->send(iter->listener.closure, event, json_object_get(object));
 391                         result++;
 392                 }
 393                 iter = iter->next;
 394         }
 395
 396         return result;
 397 }
 398
 399 int ctxClientEventSend(struct AFB_clientCtx *clientCtx, const char *event, struct json_object *object)
 400 {
 401         long idx;
 402         time_t now;
 403         int result;
 404
 405         now = NOW;
 406         if (clientCtx != NULL) {
 407                 result = ctxIsActive(clientCtx, now) ? send(clientCtx->listeners, event, object) : 0;
 408         } else {
 409                 result = send(sessions.listeners, event, object);
 410                 for (idx=0; idx < sessions.max; idx++) {
 411                         clientCtx = ctxClientAddRef(sessions.store[idx]);
 412                         if (clientCtx != NULL && ctxIsActive(clientCtx, now)) {
 413                                 clientCtx = ctxClientAddRef(clientCtx);
 414                                 result += send(clientCtx->listeners, event, object);
 415                         }
 416                         ctxClientUnref(clientCtx);
 417                 }
 418         }
 419         return result;
 420 }
 421
 422 const char *ctxClientGetUuid (struct AFB_clientCtx *clientCtx)
 423 {
 424         assert(clientCtx != NULL);
 425         return clientCtx->uuid;
 426 }
 427
 428 const char *ctxClientGetToken (struct AFB_clientCtx *clientCtx)
 429 {
 430         assert(clientCtx != NULL);
 431         return clientCtx->token;
 432 }
 433
 434 void *ctxClientValueGet(struct AFB_clientCtx *clientCtx, int index)
 435 {
 436         assert(clientCtx != NULL);
 437         assert(index >= 0);
 438         assert(index < sessions.apicount);
 439         return clientCtx->values[index].value;
 440 }
 441
 442 void ctxClientValueSet(struct AFB_clientCtx *clientCtx, int index, void *value, void (*free_value)(void*))
 443 {
 444         struct client_value prev;
 445         assert(clientCtx != NULL);
 446         assert(index >= 0);
 447         assert(index < sessions.apicount);
 448         prev = clientCtx->values[index];
 449         clientCtx->values[index] = (struct client_value){.value = value, .free_value = free_value};
 450         if (prev.value !=  NULL && prev.free_value != NULL)
 451                 prev.free_value(prev.value);
 452 }