X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fsession.c;h=781ecd94495abb56ff37049c62cd24d0e566738c;hb=06d422d1de5c505366f6a029d8af85548c2b646f;hp=55098b41bd17657f03d6bf2a9ccc62549226981b;hpb=4e43e3b53482bff8cb835271eb3207aeaf593812;p=src%2Fapp-framework-binder.git diff --git a/src/session.c b/src/session.c index 55098b41..781ecd94 100644 --- a/src/session.c +++ b/src/session.c @@ -16,8 +16,8 @@ * along with this program. If not, see . * * Reference: - * https://github.com/json-c/json-c/blob/master/linkhash.c - * https://github.com/json-c/json-c/blob/master/linkhash.h + * http://stackoverflow.com/questions/25971505/how-to-delete-element-from-hsearch + * */ @@ -32,15 +32,20 @@ #define AFB_SESSION_JTYPE "AFB_session" -#define AFB_SESSION_JLIST "AFB_sessions" +#define AFB_SESSION_JLIST "AFB_sessions.hash" #define AFB_SESSION_JINFO "AFB_infos" #define AFB_CURRENT_SESSION "active-session" // file link name within sndcard dir #define AFB_DEFAULT_SESSION "current-session" // should be in sync with UI -static pthread_mutex_t mutexHash; // declare a mutex to protect hash table -static struct hsearch_data sessions = {0}; // Create an empty hash table for sessions +// Session UUID are store in a simple array [for 10 sessions this should be enough] +static struct { + pthread_mutex_t mutex; // declare a mutex to protect hash table + AFB_clientCtx **store; // sessions store + int count; // current number of sessions + int max; +} sessions; // verify we can read/write in session dir PUBLIC AFB_error sessionCheckdir (AFB_session *session) { @@ -67,7 +72,7 @@ PUBLIC AFB_error sessionCheckdir (AFB_session *session) { return AFB_SUCCESS; } -// let's return only sessions files +// let's return only sessions.hash files STATIC int fileSelect (const struct dirent *entry) { return (strstr (entry->d_name, ".afb") != NULL); } @@ -76,8 +81,8 @@ STATIC json_object *checkCardDirExit (AFB_session *session, AFB_request *reques int sessionDir, cardDir; // card name should be more than 3 character long !!!! - if (strlen (request->plugin) < 3) { - return (jsonNewMessage (AFB_FAIL,"Fail invalid plugin=%s", request->plugin)); + if (strlen (request->prefix) < 3) { + return (jsonNewMessage (AFB_FAIL,"Fail invalid plugin=%s", request->prefix)); } // open session directory @@ -87,11 +92,11 @@ STATIC json_object *checkCardDirExit (AFB_session *session, AFB_request *reques } // create session sndcard directory if it does not exit - cardDir = openat (sessionDir, request->plugin, O_DIRECTORY); + cardDir = openat (sessionDir, request->prefix, O_DIRECTORY); if (cardDir < 0) { - cardDir = mkdirat (sessionDir, request->plugin, O_RDWR | S_IRWXU | S_IRGRP); + cardDir = mkdirat (sessionDir, request->prefix, O_RDWR | S_IRWXU | S_IRGRP); if (cardDir < 0) { - return (jsonNewMessage (AFB_FAIL,"Fail to create directory [%s/%s] error=%s", session->config->sessiondir, request->plugin, strerror(cardDir))); + return (jsonNewMessage (AFB_FAIL,"Fail to create directory [%s/%s] error=%s", session->config->sessiondir, request->prefix, strerror(cardDir))); } } close (sessionDir); @@ -105,7 +110,7 @@ PUBLIC json_object *sessionList (AFB_session *session, AFB_request *request) { struct dirent **namelist; int count, sessionDir; - // if directory for card's sessions does not exist create it + // if directory for card's sessions.hash does not exist create it ajgResponse = checkCardDirExit (session, request); if (ajgResponse != NULL) return ajgResponse; @@ -115,13 +120,13 @@ PUBLIC json_object *sessionList (AFB_session *session, AFB_request *request) { return (jsonNewMessage (AFB_FAIL,"Fail to open directory [%s] error=%s", session->config->sessiondir, strerror(sessionDir))); } - count = scandirat (sessionDir, request->plugin, &namelist, fileSelect, alphasort); + count = scandirat (sessionDir, request->prefix, &namelist, fileSelect, alphasort); close (sessionDir); if (count < 0) { - return (jsonNewMessage (AFB_FAIL,"Fail to scan sessions directory [%s/%s] error=%s", session->config->sessiondir, request->plugin, strerror(sessionDir))); + return (jsonNewMessage (AFB_FAIL,"Fail to scan sessions.hash directory [%s/%s] error=%s", session->config->sessiondir, request->prefix, strerror(sessionDir))); } - if (count == 0) return (jsonNewMessage (AFB_EMPTY,"[%s] no session at [%s]", request->plugin, session->config->sessiondir)); + if (count == 0) return (jsonNewMessage (AFB_EMPTY,"[%s] no session at [%s]", request->prefix, session->config->sessiondir)); // loop on each session file, retrieve its date and push it into json response object sessionsJ = json_object_new_array(); @@ -189,12 +194,12 @@ PUBLIC json_object *sessionFromDisk (AFB_session *session, AFB_request *request, // check for current session request defsession = (strcmp (name, AFB_DEFAULT_SESSION) ==0); - // if directory for card's sessions does not exist create it + // if directory for card's sessions.hash does not exist create it response = checkCardDirExit (session, request); if (response != NULL) return response; // add name and file extension to session name - strncpy (filename, request->plugin, sizeof(filename)); + strncpy (filename, request->prefix, sizeof(filename)); strncat (filename, "/", sizeof(filename)); if (defsession) strncat (filename, AFB_CURRENT_SESSION, sizeof(filename)-1); else strncat (filename, name, sizeof(filename)-1); @@ -219,7 +224,7 @@ PUBLIC json_object *sessionFromDisk (AFB_session *session, AFB_request *request, } // create a link to keep track of last uploaded session for this card - if (!defsession) makeSessionLink (request->plugin, name); + if (!defsession) makeSessionLink (request->prefix, name); return (jsonSession); } @@ -238,12 +243,12 @@ PUBLIC json_object * sessionToDisk (AFB_session *session, AFB_request *request, // check for current session request defsession = (strcmp (name, AFB_DEFAULT_SESSION) ==0); - // if directory for card's sessions does not exist create it + // if directory for card's sessions.hash does not exist create it response = checkCardDirExit (session, request); if (response != NULL) return response; // add cardname and file extension to session name - strncpy (filename, request->plugin, sizeof(filename)); + strncpy (filename, request->prefix, sizeof(filename)); strncat (filename, "/", sizeof(filename)); if (defsession) strncat (filename, AFB_CURRENT_SESSION, sizeof(filename)-1); else strncat (filename, name, sizeof(filename)-1); @@ -266,13 +271,13 @@ PUBLIC json_object * sessionToDisk (AFB_session *session, AFB_request *request, // extract session info from args info = json_tokener_parse (request->post->data); if (!info) { - response = jsonNewMessage (AFB_FATAL,"sndcard=%s session=%s invalid json args=%s", request->plugin, name, request->post); + response = jsonNewMessage (AFB_FATAL,"sndcard=%s session=%s invalid json args=%s", request->prefix, name, request->post); goto OnErrorExit; } // info is a valid AFB_info type if (!json_object_object_get_ex (info, "jtype", &jtype)) { - response = jsonNewMessage (AFB_EMPTY,"sndcard=%s session=%s No 'AFB_pluginT' args=%s", request->plugin, name, request->post); + response = jsonNewMessage (AFB_EMPTY,"sndcard=%s session=%s No 'AFB_pluginT' args=%s", request->prefix, name, request->post); goto OnErrorExit; } @@ -297,7 +302,7 @@ PUBLIC json_object * sessionToDisk (AFB_session *session, AFB_request *request, // create a link to keep track of last uploaded session for this card - if (!defsession) makeSessionLink (request->plugin, name); + if (!defsession) makeSessionLink (request->prefix, name); // we're donne let's return status message response = jsonNewMessage (AFB_SUCCESS,"Session= [%s] saved on disk", filename); @@ -310,91 +315,133 @@ OnErrorExit: } - - // Free context [XXXX Should be protected again memory abort XXXX] STATIC void ctxUuidFreeCB (AFB_clientCtx *client) { - + + AFB_plugin **plugins = client->plugins; + AFB_freeCtxCB freeCtxCB; + int idx; + // If application add a handle let's free it now - if (client->ctx != NULL) { - + if (client->contexts != NULL) { + // Free client handle with a standard Free function, with app callback or ignore it - if (client->plugin->freeCtxCB == NULL) free (client->ctx); - else if (client->plugin->freeCtxCB != (void*)-1) client->plugin->freeCtxCB(client); + for (idx=0; client->plugins[idx] != NULL; idx ++) { + if (client->contexts[idx] != NULL) { + freeCtxCB = client->plugins[idx]->freeCtxCB; + if (freeCtxCB == NULL) free (client->contexts[idx]); + else if (freeCtxCB != (void*)-1) freeCtxCB(client->contexts[idx], plugins[idx]->handle, client->uuid); + } + } } } // Create a new store in RAM, not that is too small it will be automatically extended PUBLIC void ctxStoreInit (int nbSession) { - int res; - // let's create session hash table - res = hcreate_r(nbSession, &sessions); + int res; + + // let's create as store as hashtable does not have any + sessions.store = calloc (nbSession+1, sizeof(AFB_clientCtx)); + sessions.max=nbSession; } STATIC AFB_clientCtx *ctxStoreSearch (const char* uuid) { - ENTRY item = {(char*) uuid}; - ENTRY *pitem = &item; - // printf ("searching uuid=%s\n", uuid); - - pthread_mutex_lock(&mutexHash); - if (hsearch_r(item, FIND, &pitem, &sessions)) { - pthread_mutex_unlock(&mutexHash); - return (AFB_clientCtx*) pitem->data; + int idx; + AFB_clientCtx *client; + + if (uuid == NULL) return NULL; + + pthread_mutex_lock(&sessions.mutex); + + for (idx=0; idx < sessions.max; idx++) { + if (sessions.store[idx] && (0 == strcmp (uuid, sessions.store[idx]->uuid))) break; } - pthread_mutex_unlock(&mutexHash); - return NULL; + + if (idx == sessions.max) client=NULL; + else client= sessions.store[idx]; + pthread_mutex_unlock(&sessions.mutex); + + return (client); } -// Reference http://stackoverflow.com/questions/25971505/how-to-delete-element-from-hsearch -void ctxStoreAdd (AFB_clientCtx *client) { - ENTRY item = {client->uuid, (void*)client}; - ENTRY *pitem = &item; - pthread_mutex_lock(&mutexHash); - if (hsearch_r(item, ENTER, &pitem, &sessions)) { - // printf ("storing uuid=%s\n", client->uuid); - pitem->data = (void *)client; +STATIC AFB_error ctxStoreDel (AFB_clientCtx *client) { + int idx; + int status; + if (client == NULL) return (AFB_FAIL); + + pthread_mutex_lock(&sessions.mutex); + + for (idx=0; idx < sessions.max; idx++) { + if (sessions.store[idx] && (0 == strcmp (client->uuid, sessions.store[idx]->uuid))) break; + } + + if (idx == sessions.max) status=AFB_FAIL; + else { + sessions.count --; + ctxUuidFreeCB (sessions.store[idx]); + sessions.store[idx]=NULL; + status=AFB_SUCCESS; } - pthread_mutex_unlock(&mutexHash); + + pthread_mutex_unlock(&sessions.mutex); + return (status); } -void ctxStoreDel (AFB_clientCtx *client) { - ENTRY item = {client->uuid}; - ENTRY *pitem = &item; +STATIC AFB_error ctxStoreAdd (AFB_clientCtx *client) { + int idx; + int status; + if (client == NULL) return (AFB_FAIL); - pthread_mutex_lock(&mutexHash); - if (hsearch_r(item, FIND, &pitem, &sessions)) { - pitem->data = NULL; + //fprintf (stderr, "ctxStoreAdd request uuid=%s count=%d\n", client->uuid, sessions.count); + + pthread_mutex_lock(&sessions.mutex); + + for (idx=0; idx < sessions.max; idx++) { + if (NULL == sessions.store[idx]) break; + } + + if (idx == sessions.max) status=AFB_FAIL; + else { + status=AFB_SUCCESS; + sessions.count ++; + sessions.store[idx]= client; } - pthread_mutex_unlock(&mutexHash); + + pthread_mutex_unlock(&sessions.mutex); + return (status); } // Check if context timeout or not -STATIC int ctxStoreToOld (const void *k1, int timeout) { +STATIC int ctxStoreToOld (AFB_clientCtx *ctx, int timeout) { int res; - AFB_clientCtx *ctx = (AFB_clientCtx*) k1; time_t now = time(NULL); res = ((ctx->timeStamp + timeout) <= now); return (res); } -// Loop on every entry and remove old context sessions -PUBLIC int ctxStoreGarbage (struct lh_table *lht, const int timeout) { - - if (verbose) fprintf (stderr, "****** Garbage Count=%d timeout=%d\n", lht->count, timeout); - - +// Loop on every entry and remove old context sessions.hash +PUBLIC int ctxStoreGarbage (const int timeout) { + AFB_clientCtx *ctx; + long idx; + + // Loop on Sessions Table and remove anything that is older than timeout + for (idx=0; idx < sessions.max; idx++) { + ctx=sessions.store[idx]; + if ((ctx != NULL) && (ctxStoreToOld(ctx, timeout))) { + ctxStoreDel (ctx); + } + } } // This function will return exiting client context or newly created client context -PUBLIC AFB_error ctxClientGet (AFB_request *request, AFB_plugin *plugin) { - static int cid=0; +PUBLIC AFB_clientCtx *ctxClientGet (AFB_request *request, int idx) { AFB_clientCtx *clientCtx=NULL; const char *uuid; uuid_t newuuid; int ret; - if (request->config->token == NULL) return AFB_EMPTY; + if (request->config->token == NULL) return NULL; // Check if client as a context or not inside the URL uuid = MHD_lookup_connection_value(request->connection, MHD_GET_ARGUMENT_KIND, "uuid"); @@ -410,51 +457,62 @@ PUBLIC AFB_error ctxClientGet (AFB_request *request, AFB_plugin *plugin) { if ((uuid != NULL) && (strnlen (uuid, 10) >= 10)) { int search; // search if client context exist and it not timeout let's use it - printf ("search old UID=%s\n", uuid); clientCtx = ctxStoreSearch (uuid); - if (clientCtx && ! ctxStoreToOld (clientCtx, request->config->cntxTimeout)) { - request->client=clientCtx; - return; + if (clientCtx) { + if (ctxStoreToOld (clientCtx, request->config->cntxTimeout)) { + // this session is too old let's delete it + ctxStoreDel (clientCtx); + clientCtx=NULL; + } else { + request->context=clientCtx->contexts[idx]; + request->handle = clientCtx->plugins[idx]->handle; + request->uuid= uuid; + return (clientCtx); + } } } // we have no session let's create one otherwise let's clean any exiting values - if (clientCtx == NULL) clientCtx = calloc(1, sizeof(AFB_clientCtx)); // init NULL clientContext + if (clientCtx == NULL) { + clientCtx = calloc(1, sizeof(AFB_clientCtx)); // init NULL clientContext + clientCtx->contexts = calloc (1, request->config->pluginCount * (sizeof (void*))); + clientCtx->plugins = request->plugins; + } + uuid_generate(newuuid); // create a new UUID uuid_unparse_lower(newuuid, clientCtx->uuid); - clientCtx->cid=cid++; // simple application uniqueID - clientCtx->plugin = plugin; // provide plugin callbacks a hook to plugin - clientCtx->plugin; // provide plugin callbacks a hook to plugin - + // if table is full at 50% let's clean it up - // if(clientCtxs->count > (clientCtxs->size / 2)) ctxStoreGarbage(clientCtxs, request->config->cntxTimeout); + if(sessions.count > (sessions.max / 2)) ctxStoreGarbage(request->config->cntxTimeout); // finally add uuid into hashtable - ctxStoreAdd (clientCtx); - - // if (ret < 0) return (AFB_FAIL); + if (AFB_SUCCESS != ctxStoreAdd (clientCtx)) { + free (clientCtx); + return(NULL); + } - if (verbose) fprintf (stderr, "ctxClientGet New uuid=[%s] token=[%s] timestamp=%d\n", clientCtx->uuid, clientCtx->token, clientCtx->timeStamp); - request->client = clientCtx; - - return (AFB_SUCCESS); + // if (verbose) fprintf (stderr, "ctxClientGet New uuid=[%s] token=[%s] timestamp=%d\n", clientCtx->uuid, clientCtx->token, clientCtx->timeStamp); + request->context = clientCtx->contexts[idx]; + request->handle = clientCtx->plugins[idx]->handle; + request->uuid=clientCtx->uuid; + return(clientCtx); } // Sample Generic Ping Debug API -PUBLIC AFB_error ctxTokenCheck (AFB_request *request) { +PUBLIC AFB_error ctxTokenCheck (AFB_clientCtx *clientCtx, AFB_request *request) { const char *token; - if (request->client == NULL) return AFB_EMPTY; + if (clientCtx->contexts == NULL) return AFB_EMPTY; // this time have to extract token from query list token = MHD_lookup_connection_value(request->connection, MHD_GET_ARGUMENT_KIND, "token"); // if not token is providing we refuse the exchange - if ((token == NULL) || (request->client->token == NULL)) return (AFB_FALSE); + if ((token == NULL) || (clientCtx->token == NULL)) return (AFB_FALSE); // compare current token with previous one - if ((0 == strcmp (token, request->client->token)) && (!ctxStoreToOld (request->client, request->config->cntxTimeout))) { + if ((0 == strcmp (token, clientCtx->token)) && (!ctxStoreToOld (clientCtx, request->config->cntxTimeout))) { return (AFB_SUCCESS); } @@ -463,14 +521,13 @@ PUBLIC AFB_error ctxTokenCheck (AFB_request *request) { } // Free Client Session Context -PUBLIC AFB_error ctxTokenReset (AFB_request *request) { +PUBLIC AFB_error ctxTokenReset (AFB_clientCtx *clientCtx, AFB_request *request) { int ret; - AFB_clientCtx *clientCtx; - if (request->client == NULL) return AFB_EMPTY; + if (clientCtx == NULL) return AFB_EMPTY; // Search for an existing client with the same UUID - clientCtx = ctxStoreSearch (request->client->uuid); + clientCtx = ctxStoreSearch (clientCtx->uuid); if (clientCtx == NULL) return AFB_FALSE; // Remove client from table @@ -480,13 +537,13 @@ PUBLIC AFB_error ctxTokenReset (AFB_request *request) { } // generate a new token -PUBLIC AFB_error ctxTokenCreate (AFB_request *request) { +PUBLIC AFB_error ctxTokenCreate (AFB_clientCtx *clientCtx, AFB_request *request) { int oldTnkValid; const char *ornew; uuid_t newuuid; const char *token; - if (request->client == NULL) return AFB_EMPTY; + if (clientCtx == NULL) return AFB_EMPTY; // if config->token!="" then verify that we have the right initial share secret if (request->config->token[0] != '\0') { @@ -495,16 +552,16 @@ PUBLIC AFB_error ctxTokenCreate (AFB_request *request) { token = MHD_lookup_connection_value(request->connection, MHD_GET_ARGUMENT_KIND, "token"); if (token == NULL) return AFB_UNAUTH; - // verify that presented initial tokens fit + // verify that it fits with initial tokens fit if (strcmp(request->config->token, token)) return AFB_UNAUTH; } // create a UUID as token value uuid_generate(newuuid); - uuid_unparse_lower(newuuid, request->client->token); + uuid_unparse_lower(newuuid, clientCtx->token); // keep track of time for session timeout and further clean up - request->client->timeStamp=time(NULL); + clientCtx->timeStamp=time(NULL); // Token is also store in context but it might be convenient for plugin to access it directly return (AFB_SUCCESS); @@ -512,19 +569,19 @@ PUBLIC AFB_error ctxTokenCreate (AFB_request *request) { // generate a new token and update client context -PUBLIC AFB_error ctxTokenRefresh (AFB_request *request) { +PUBLIC AFB_error ctxTokenRefresh (AFB_clientCtx *clientCtx, AFB_request *request) { int oldTnkValid; const char *oldornew; uuid_t newuuid; - if (request->client == NULL) return AFB_EMPTY; + if (clientCtx == NULL) return AFB_EMPTY; // Check if the old token is valid - if (ctxTokenCheck (request) != AFB_SUCCESS) return (AFB_FAIL); + if (ctxTokenCheck (clientCtx, request) != AFB_SUCCESS) return (AFB_FAIL); // Old token was valid let's regenerate a new one uuid_generate(newuuid); // create a new UUID - uuid_unparse_lower(newuuid, request->client->token); + uuid_unparse_lower(newuuid, clientCtx->token); return (AFB_SUCCESS); }