Avoid lock when child dies
[src/app-framework-binder.git] / src / afb-session.c
index 17ca7af..61aa3f6 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015, 2016, 2017 "IoT.bzh"
+ * Copyright (C) 2015-2019 "IoT.bzh"
  * Author "Fulup Ar Foll"
  * Author: José Bollo <jose.bollo@iot.bzh>
  *
 #include <pthread.h>
 #include <stdlib.h>
 #include <stdint.h>
+#include <limits.h>
 #include <string.h>
-#include <uuid/uuid.h>
 #include <errno.h>
 
-#include <json-c/json.h>
-
 #include "afb-session.h"
 #include "afb-hook.h"
 #include "verbose.h"
+#include "pearson.h"
+#include "uuid.h"
 
-#define SIZEUUID       37
 #define HEADCOUNT      16
 #define COOKIECOUNT    8
 #define COOKIEMASK     (COOKIECOUNT - 1)
 #define _MAXEXP_       ((time_t)(~(time_t)0))
 #define _MAXEXP2_      ((time_t)((((unsigned long long)_MAXEXP_) >> 1)))
 #define MAX_EXPIRATION (_MAXEXP_ >= 0 ? _MAXEXP_ : _MAXEXP2_)
-#define NOW            (time(NULL))
+#define NOW            (time_now())
 
-/* structure for a cookie added to sessions */
+/**
+ * structure for a cookie added to sessions
+ */
 struct cookie
 {
-       struct cookie *next;    /* link to next cookie */
-       const void *key;        /* pointer key */
-       void *value;            /* value */
-       void (*freecb)(void*);  /* function to call when session is closed */
+       struct cookie *next;    /**< link to next cookie */
+       const void *key;        /**< pointer key */
+       void *value;            /**< value */
+       void (*freecb)(void*);  /**< function to call when session is closed */
 };
 
-/*
+/**
  * structure for session
  */
 struct afb_session
 {
-       struct afb_session *next; /* link to the next */
-       unsigned refcount;      /* external reference count of the session */
-       int timeout;            /* timeout of the session */
-       time_t expiration;      /* expiration time of the token */
-       pthread_mutex_t mutex;  /* mutex of the session */
-       struct cookie *cookies[COOKIECOUNT]; /* cookies of the session */
-       uint8_t closed: 1;      /* is the session closed ? */
-       uint8_t autoclose: 1;   /* close the session when unreferenced */
-       uint8_t notinset: 1;    /* session removed from the set of sessions */
-       char uuid[SIZEUUID];    /* long term authentication of remote client */
-       char token[SIZEUUID];   /* short term authentication of remote client */
+       struct afb_session *next; /**< link to the next */
+       unsigned refcount;      /**< count of reference to the session */
+       int timeout;            /**< timeout of the session */
+       time_t expiration;      /**< expiration time of the token */
+       pthread_mutex_t mutex;  /**< mutex of the session */
+       struct cookie *cookies[COOKIECOUNT]; /**< cookies of the session */
+       char *lang;             /**< current language setting for the session */
+       uint8_t closed: 1;      /**< is the session closed ? */
+       uint8_t autoclose: 1;   /**< close the session when unreferenced */
+       uint8_t notinset: 1;    /**< session removed from the set of sessions */
+       uuid_stringz_t uuid;    /**< long term authentication of remote client */
+       uuid_stringz_t token;   /**< short term authentication of remote client */
 };
 
-/* Session UUID are store in a simple array [for 10 sessions this should be enough] */
+/**
+ * structure for managing sessions
+ */
 static struct {
-       int count;              /* current number of sessions */
-       int max;                /* maximum count of sessions */
-       int timeout;            /* common initial timeout */
-       struct afb_session *heads[HEADCOUNT]; /* sessions */
-       char initok[SIZEUUID];  /* common initial token */
-       pthread_mutex_t mutex;  /* declare a mutex to protect hash table */
+       int count;              /**< current number of sessions */
+       int max;                /**< maximum count of sessions */
+       int timeout;            /**< common initial timeout */
+       struct afb_session *heads[HEADCOUNT]; /**< sessions */
+       uuid_stringz_t initok;  /**< common initial token */
+       pthread_mutex_t mutex;  /**< declare a mutex to protect hash table */
 } sessions = {
        .count = 0,
        .max = 10,
@@ -86,32 +90,14 @@ static struct {
        .mutex = PTHREAD_MUTEX_INITIALIZER
 };
 
-/* generate a new fresh 'uuid' */
-static void new_uuid(char uuid[SIZEUUID])
-{
-       uuid_t newuuid;
-       uuid_generate(newuuid);
-       uuid_unparse_lower(newuuid, uuid);
-}
-
-/*
- * Returns a tiny hash value for the 'text'.
- *
- * Tiny hash function inspired from pearson
+/**
+ * Get the actual raw time
  */
-static uint8_t pearson4(const char *text)
+static inline time_t time_now()
 {
-       static uint8_t T[16] = {
-                4,  1,  6,  0,  9, 14, 11,  5,
-                2,  3, 12, 15, 10,  7,  8, 13
-       };
-       uint8_t r, c;
-
-       for (r = 0; (c = (uint8_t)*text) ; text++) {
-               r = T[r ^ (15 & c)];
-               r = T[r ^ (c >> 4)];
-       }
-       return r; // % HEADCOUNT;
+       struct timespec ts;
+       clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
+       return ts.tv_sec;
 }
 
 /* lock the set of sessions for exclusive access */
@@ -146,7 +132,7 @@ static struct afb_session *sessionset_search(const char *uuid, uint8_t hashidx)
 static int sessionset_add(struct afb_session *session, uint8_t hashidx)
 {
        /* check availability */
-       if (sessions.count >= sessions.max) {
+       if (sessions.max && sessions.count >= sessions.max) {
                errno = EBUSY;
                return -1;
        }
@@ -159,12 +145,12 @@ static int sessionset_add(struct afb_session *session, uint8_t hashidx)
 }
 
 /* make a new uuid not used in the set of sessions */
-static uint8_t sessionset_make_uuid (char uuid[SIZEUUID])
+static uint8_t sessionset_make_uuid (uuid_stringz_t uuid)
 {
        uint8_t hashidx;
 
        do {
-               new_uuid(uuid);
+               uuid_new_stringz(uuid);
                hashidx = pearson4(uuid);
        } while(sessionset_search(uuid, hashidx));
        return hashidx;
@@ -193,8 +179,10 @@ static void session_close(struct afb_session *session)
                /* close it now */
                session->closed = 1;
 
+#if WITH_AFB_HOOK
                /* emit the hook */
                afb_hook_session_close(session);
+#endif
 
                /* release cookies */
                for (idx = 0 ; idx < COOKIECOUNT ; idx++) {
@@ -211,29 +199,23 @@ static void session_close(struct afb_session *session)
 /* destroy the 'session' */
 static void session_destroy (struct afb_session *session)
 {
+#if WITH_AFB_HOOK
        afb_hook_session_destroy(session);
+#endif
        pthread_mutex_destroy(&session->mutex);
+       free(session->lang);
        free(session);
 }
 
 /* update expiration of 'session' according to 'now' */
 static void session_update_expiration(struct afb_session *session, time_t now)
 {
-       int timeout;
        time_t expiration;
 
        /* compute expiration */
-       timeout = session->timeout;
-       if (timeout == AFB_SESSION_TIMEOUT_INFINITE)
+       expiration = now + afb_session_timeout(session);
+       if (expiration < 0)
                expiration = MAX_EXPIRATION;
-       else {
-               if (timeout == AFB_SESSION_TIMEOUT_DEFAULT)
-                       expiration = now + sessions.timeout;
-               else
-                       expiration = now + timeout;
-               if (expiration < 0)
-                       expiration = MAX_EXPIRATION;
-       }
 
        /* record the expiration */
        session->expiration = expiration;
@@ -277,7 +259,9 @@ static struct afb_session *session_add(const char *uuid, int timeout, time_t now
                return NULL;
        }
 
+#if WITH_AFB_HOOK
        afb_hook_session_create(session);
+#endif
 
        return session;
 }
@@ -321,7 +305,7 @@ static time_t sessionset_cleanup (int force)
  * @param max_session_count  maximum allowed session count in the same time
  * @param timeout            the initial default timeout of sessions
  * @param initok             the initial default token of sessions
- * 
+ *
  */
 int afb_session_init (int max_session_count, int timeout, const char *initok)
 {
@@ -339,7 +323,7 @@ int afb_session_init (int max_session_count, int timeout, const char *initok)
        sessions.max = max_session_count;
        sessions.timeout = timeout;
        if (initok == NULL)
-               new_uuid(sessions.initok);
+               uuid_new_stringz(sessions.initok);
        else
                strcpy(sessions.initok, initok);
        sessionset_unlock();
@@ -408,10 +392,34 @@ struct afb_session *afb_session_create (int timeout)
        return afb_session_get(NULL, timeout, NULL);
 }
 
+/**
+ * Returns the timeout of 'session' in seconds
+ */
+int afb_session_timeout(struct afb_session *session)
+{
+       int timeout;
+
+       /* compute timeout */
+       timeout = session->timeout;
+       if (timeout == AFB_SESSION_TIMEOUT_DEFAULT)
+               timeout = sessions.timeout;
+       if (timeout < 0)
+               timeout = INT_MAX;
+       return timeout;
+}
+
+/**
+ * Returns the second remaining before expiration of 'session'
+ */
+int afb_session_what_remains(struct afb_session *session)
+{
+       return (int)(session->expiration - NOW);
+}
+
 /* This function will return exiting session or newly created session */
 struct afb_session *afb_session_get (const char *uuid, int timeout, int *created)
 {
-       char _uuid_[SIZEUUID];
+       uuid_stringz_t _uuid_;
        uint8_t hashidx;
        struct afb_session *session;
        time_t now;
@@ -450,7 +458,10 @@ end:
 struct afb_session *afb_session_addref(struct afb_session *session)
 {
        if (session != NULL) {
+#if WITH_AFB_HOOK
                afb_hook_session_addref(session);
+#endif
+               session_lock(session);
                session->refcount++;
                session_unlock(session);
        }
@@ -463,9 +474,11 @@ void afb_session_unref(struct afb_session *session)
        if (session == NULL)
                return;
 
-       session_lock(session);
+#if WITH_AFB_HOOK
        afb_hook_session_unref(session);
-       if (--session->refcount) {
+#endif
+       session_lock(session);
+       if (!--session->refcount) {
                if (session->autoclose)
                        session_close(session);
                if (session->notinset) {
@@ -488,7 +501,7 @@ void afb_session_close (struct afb_session *session)
  * Set the 'autoclose' flag of the 'session'
  *
  * A session whose autoclose flag is true will close as
- * soon as it is no more referenced. 
+ * soon as it is no more referenced.
  *
  * @param session    the session to set
  * @param autoclose  the value to set
@@ -512,7 +525,7 @@ int afb_session_check_token (struct afb_session *session, const char *token)
 {
        int r;
 
-       session_unlock(session);
+       session_lock(session);
        r = !session->closed
          && session->expiration >= NOW
          && !(session->token[0] && strcmp (token, session->token));
@@ -523,10 +536,12 @@ int afb_session_check_token (struct afb_session *session, const char *token)
 /* generate a new token and update client context */
 void afb_session_new_token (struct afb_session *session)
 {
-       session_unlock(session);
-       new_uuid(session->token);
+       session_lock(session);
+       uuid_new_stringz(session->token);
        session_update_expiration(session, NOW);
+#if WITH_AFB_HOOK
        afb_hook_session_renew(session);
+#endif
        session_unlock(session);
 }
 
@@ -564,7 +579,7 @@ static int cookeyidx(const void *key)
  * @param makecb       the creation function or NULL
  * @param freecb       the release function or NULL
  * @param closure      an argument for makecb or the value if makecb==NULL
- * @param replace      a boolean enforcing replecement of the previous value
+ * @param replace      a boolean enforcing replacement of the previous value
  *
  * @return the value of the cookie
  *
@@ -669,11 +684,44 @@ void *afb_session_get_cookie(struct afb_session *session, const void *key)
  * @param value    the value to store at key
  * @param freecb   a function to use when the cookie value is to remove (or null)
  *
- * @return the data staored for the key or NULL if the key isn't found
- * 
+ * @return 0 in case of success or -1 in case of error
  */
 int afb_session_set_cookie(struct afb_session *session, const void *key, void *value, void (*freecb)(void*))
 {
        return -(value != afb_session_cookie(session, key, NULL, freecb, value, 1));
 }
 
+/**
+ * Set the language attached to the session
+ *
+ * @param session the session to set
+ * @param lang    the language specifiction to set to session
+ *
+ * @return 0 in case of success or -1 in case of error
+ */
+int afb_session_set_language(struct afb_session *session, const char *lang)
+{
+       char *oldl, *newl;
+
+       newl = strdup(lang);
+       if (newl == NULL)
+               return -1;
+
+       oldl = session->lang;
+       session->lang = newl;
+       free(oldl);
+       return 0;
+}
+
+/**
+ * Get the language attached to the session
+ *
+ * @param session the session to query
+ * @param lang    a default language specifiction
+ *
+ * @return the langauage specification to use for session
+ */
+const char *afb_session_get_language(struct afb_session *session, const char *lang)
+{
+       return session->lang ?: lang;
+}