New tree organization, update CMake req. to 2.8.8.

Use CMake-2.8.8-specific feature to allow building the
daemon from various source directories.

Signed-off-by: Manuel Bachmann <manuel.bachmann@iot.bzh>

6 files changed, 1186 insertions, 0 deletions

diff --git a/plugins/CMakeLists.txt b/plugins/CMakeLists.txt
new file mode 100644
index 00000000..269517ad
--- /dev/null
+++ b/plugins/CMakeLists.txt
@@ -0,0 +1,8 @@
+SET(PLUGINS_SOURCES audio/audio-api.c session/token-api.c)
+
+IF(librtlsdr_FOUND)
+  SET(PLUGINS_SOURCES ${PLUGINS_SOURCES} radio/radio-api.c)
+ENDIF(librtlsdr_FOUND)
+
+ADD_LIBRARY(plugins OBJECT ${PLUGINS_SOURCES})
+INCLUDE_DIRECTORIES(${include_dirs})
diff --git a/plugins/audio/audio-api.c b/plugins/audio/audio-api.c
new file mode 100644
index 00000000..9d4f3cb6
--- /dev/null
+++ b/plugins/audio/audio-api.c
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2015 "IoT.bzh"
+ * Author "Fulup Ar Foll"
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "local-def.h"
+
+STATIC json_object* wrongApi (AFB_request *request, void* handle) {
+    int zero=0;
+    int bug=1234;
+    int impossible;
+    
+    impossible=bug/zero;
+}
+
+
+
+STATIC struct {
+    void * somedata;
+} handle;
+
+
+STATIC  AFB_restapi pluginApis[]= {
+  {"ping"     , AFB_SESSION_NONE, (AFB_apiCB)apiPingTest,"Ping Application Framework"},
+  {"error"    , AFB_SESSION_NONE, (AFB_apiCB)wrongApi   , "Ping Application Framework"},
+
+  {NULL}
+};
+
+PUBLIC AFB_plugin *alsaRegister () {
+    AFB_plugin *plugin = malloc (sizeof (AFB_plugin));
+    plugin->type  = AFB_PLUGIN_JSON;
+    plugin->info  = "Application Framework Binder Service";
+    plugin->prefix= "alsa";        
+    plugin->apis  = pluginApis;
+    return (plugin);
+};
\ No newline at end of file
diff --git a/plugins/radio/radio-api.c b/plugins/radio/radio-api.c
new file mode 100644
index 00000000..a3e230b1
--- /dev/null
+++ b/plugins/radio/radio-api.c
@@ -0,0 +1,644 @@
+/*
+ * Copyright (C) 2015 "IoT.bzh"
+ * Author "Manuel Bachmann"
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "local-def.h"
+
+/* -------------- RADIO DEFINITIONS ------------------ */
+
+#include <math.h>
+#include <pthread.h>
+#include <rtl-sdr.h>
+
+#define pthread_signal(n, m) pthread_mutex_lock(m); pthread_cond_signal(n); pthread_mutex_unlock(m)
+#define pthread_wait(n, m) pthread_mutex_lock(m); pthread_cond_wait(n, m); pthread_mutex_unlock(m)
+#define BUF_LEN 16*16384
+
+typedef enum { FM, AM } Mode;
+typedef struct dongle_ctx dongle_ctx;
+typedef struct demod_ctx demod_ctx;
+typedef struct output_ctx output_ctx;
+typedef struct dev_ctx dev_ctx_T;
+
+struct dongle_ctx {
+    pthread_t thr;
+    unsigned char thr_finished;
+    uint16_t buf[BUF_LEN];
+    uint32_t buf_len;
+};
+
+struct demod_ctx {
+    pthread_t thr;
+    unsigned char thr_finished;
+    pthread_rwlock_t lck;
+    pthread_cond_t ok;
+    pthread_mutex_t ok_m;
+    int pre_r, pre_j, now_r, now_j, index;
+    int pre_index, now_index;
+    int16_t buf[BUF_LEN];
+    int buf_len;
+    int16_t res[BUF_LEN];
+    int res_len;
+};
+
+struct output_ctx {
+    pthread_t thr;
+    unsigned char thr_finished;
+    pthread_rwlock_t lck;
+    pthread_cond_t ok;
+    pthread_mutex_t ok_m;
+    int16_t buf[BUF_LEN];
+    int buf_len;
+};
+
+struct dev_ctx {
+    int used;  // radio is free ???
+    rtlsdr_dev_t* dev;
+    Mode mode;
+    float freq;
+    unsigned char mute;
+    unsigned char should_run;
+     /* thread contexts */
+    dongle_ctx *dongle;
+    demod_ctx *demod;
+    output_ctx *output;
+};
+
+
+STATIC void* _dongle_thread_fn (void *);
+STATIC void* _demod_thread_fn (void *);
+STATIC void* _output_thread_fn (void *);
+STATIC unsigned int _radio_dev_count (void);
+STATIC const char* _radio_dev_name (unsigned int);
+STATIC unsigned char _radio_dev_init (struct dev_ctx *, unsigned int);
+STATIC unsigned char _radio_dev_free (struct dev_ctx *);
+STATIC void _radio_apply_params (struct dev_ctx *);
+STATIC void _radio_start_threads (struct dev_ctx *);
+STATIC void _radio_stop_threads (struct dev_ctx *);
+
+static unsigned int init_dev_count;
+static struct dev_ctx **dev_ctx;
+
+/* ------------- RADIO IMPLEMENTATION ----------------- */
+
+
+// Radio initialization should be done only when user start the radio and not at plugin initialization
+// Making this call too early would impose to restart the binder to detect a radio.
+STATIC void initRadio () {
+ 
+    init_dev_count = _radio_dev_count();
+    int i;
+
+    dev_ctx = (dev_ctx_T**) malloc(init_dev_count * sizeof(dev_ctx_T));
+
+    for (i = 0; i < init_dev_count; i++) {
+        dev_ctx[i] = (dev_ctx_T*) malloc(sizeof(dev_ctx_T));
+        dev_ctx[i]->dev = NULL;
+        dev_ctx[i]->mode = FM;
+        dev_ctx[i]->freq = 100.0;
+        dev_ctx[i]->mute = 0;
+        dev_ctx[i]->should_run = 0;
+        dev_ctx[i]->dongle = NULL;
+        dev_ctx[i]->demod = NULL;
+        dev_ctx[i]->output = NULL;
+        _radio_dev_init(dev_ctx[i], i);
+    }
+}
+
+STATIC void radio_off () {
+    int i;
+
+    for (i = 0; i < init_dev_count; i++) {
+        _radio_dev_free(dev_ctx[i]);
+        free(dev_ctx[i]);
+    }
+    free(dev_ctx);
+}
+
+STATIC void radio_set_mode (dev_ctx_T *dev_ctx, Mode mode) {
+    dev_ctx->mode = mode;
+    _radio_apply_params(dev_ctx);
+}
+
+STATIC void radio_set_freq (dev_ctx_T *dev_ctx, float freq) {
+    dev_ctx->freq = freq;
+    _radio_apply_params(dev_ctx);
+}
+
+STATIC void radio_set_mute (dev_ctx_T *dev_ctx, unsigned char mute) {
+    dev_ctx->mute = mute;
+    _radio_apply_params(dev_ctx);
+}
+
+STATIC void radio_play (dev_ctx_T *dev_ctx) {
+    _radio_start_threads(dev_ctx);
+}
+
+STATIC void radio_stop (dev_ctx_T *dev_ctx) {
+    _radio_stop_threads(dev_ctx);
+}
+
+ /* --- HELPER FUNCTIONS --- */
+
+STATIC unsigned int _radio_dev_count () {
+    return rtlsdr_get_device_count();
+}
+
+STATIC const char* _radio_dev_name (unsigned int num) {
+    return rtlsdr_get_device_name(num);
+}
+
+STATIC unsigned char _radio_dev_init (dev_ctx_T *dev_ctx, unsigned int num) {
+    rtlsdr_dev_t *dev = dev_ctx->dev;
+
+    if (rtlsdr_open(&dev, num) < 0)
+        return 0;
+
+    rtlsdr_set_tuner_gain_mode(dev, 0);
+
+    if (rtlsdr_reset_buffer(dev) < 0)
+        return 0;
+
+    dev_ctx->dev = dev;
+
+    _radio_apply_params(dev_ctx);
+
+    return 1;
+}
+
+STATIC unsigned char _radio_dev_free (dev_ctx_T *dev_ctx) {
+    rtlsdr_dev_t *dev = dev_ctx->dev;
+
+    if (rtlsdr_close(dev) < 0)
+        return 0;
+    dev = NULL;
+
+    dev_ctx->dev = dev;
+
+    return 1;
+}
+
+STATIC void _radio_apply_params (dev_ctx_T *dev_ctx) {
+    rtlsdr_dev_t *dev = dev_ctx->dev;
+    Mode mode = dev_ctx->mode;
+    float freq = dev_ctx->freq;
+    int rate;
+
+    freq *= 1000000;
+    rate = ((1000000 / 200000) + 1) * 200000;
+
+    if (mode == FM)
+        freq += 16000;
+    freq += rate / 4;
+
+    rtlsdr_set_center_freq(dev, freq);
+    rtlsdr_set_sample_rate(dev, rate);
+
+    dev_ctx->dev = dev;
+}
+
+STATIC void _radio_start_threads (dev_ctx_T *dev_ctx) {
+    rtlsdr_dev_t *dev = dev_ctx->dev;
+    dev_ctx->dongle = (dongle_ctx*) malloc(sizeof(dongle_ctx));
+    dev_ctx->demod = (demod_ctx*) malloc(sizeof(demod_ctx));
+    dev_ctx->output = (output_ctx*) malloc(sizeof(output_ctx));
+
+    dongle_ctx *dongle = dev_ctx->dongle;
+    demod_ctx *demod = dev_ctx->demod;
+    output_ctx *output = dev_ctx->output;
+
+    pthread_rwlock_init(&demod->lck, NULL);
+    pthread_cond_init(&demod->ok, NULL);
+    pthread_mutex_init(&demod->ok_m, NULL);
+    pthread_rwlock_init(&output->lck, NULL);
+    pthread_cond_init(&output->ok, NULL);
+    pthread_mutex_init(&output->ok_m, NULL);
+
+    dev_ctx->should_run = 1;
+
+     /* dongle thread */
+    dongle->thr_finished = 0;
+    pthread_create(&dongle->thr, NULL, _dongle_thread_fn, (void*)dev_ctx);
+
+     /* demod thread */
+    demod->pre_r = demod->pre_j = 0;
+    demod->now_r = demod->now_j = 0;
+    demod->index = demod->pre_index = demod->now_index = 0;
+    demod->thr_finished = 0;
+    pthread_create(&demod->thr, NULL, _demod_thread_fn, (void*)dev_ctx);
+
+     /* output thread */
+    output->thr_finished = 0;
+    pthread_create(&output->thr, NULL, _output_thread_fn, (void*)dev_ctx);
+}
+
+STATIC void _radio_stop_threads (dev_ctx_T *dev_ctx) {
+    rtlsdr_dev_t *dev = dev_ctx->dev;
+    dongle_ctx *dongle = dev_ctx->dongle;
+    demod_ctx *demod = dev_ctx->demod;
+    output_ctx *output = dev_ctx->output;
+
+    if (!dongle || !demod || !output)
+        return;
+
+     /* stop each "while" loop in threads */
+    dev_ctx->should_run = 0;
+
+    rtlsdr_cancel_async(dev);
+    pthread_signal(&demod->ok, &demod->ok_m);
+    pthread_signal(&output->ok, &output->ok_m);
+
+    while (!dongle->thr_finished ||
+           !demod->thr_finished ||
+           !output->thr_finished)
+        usleep(100000);
+
+    pthread_join(dongle->thr, NULL);
+    pthread_join(demod->thr, NULL);
+    pthread_join(output->thr, NULL);
+    pthread_rwlock_destroy(&demod->lck);
+    pthread_cond_destroy(&demod->ok);
+    pthread_mutex_destroy(&demod->ok_m);
+    pthread_rwlock_destroy(&output->lck);
+    pthread_cond_destroy(&output->ok);
+    pthread_mutex_destroy(&output->ok_m);
+
+    free(dongle); dev_ctx->dongle = NULL;
+    free(demod); dev_ctx->demod = NULL;
+    free(output); dev_ctx->output = NULL;
+}
+
+ /* ---- LOCAL THREADED FUNCTIONS ---- */
+
+STATIC void _rtlsdr_callback (unsigned char *buf, uint32_t len, void *ctx) {
+    dev_ctx_T *dev_ctx = (dev_ctx_T *)ctx;
+    dongle_ctx *dongle = dev_ctx->dongle;
+    demod_ctx *demod = dev_ctx->demod;
+    unsigned char tmp;
+    int i;
+
+    if (!dev_ctx->should_run)
+        return;
+
+     /* rotate 90° */
+    for (i = 0; i < (int)len; i += 8) {
+        tmp = 255 - buf[i+3];
+        buf[i+3] = buf[i+2];
+        buf[i+2] = tmp;
+
+        buf[i+4] = 255 - buf[i+4];
+        buf[i+5] = 255 - buf[i+5];
+
+        tmp = 255 - buf[i+6];
+        buf[i+6] = buf[i+7];
+        buf[i+7] = tmp;
+    }
+
+     /* write data */
+    for (i = 0; i < (int)len; i++)
+        dongle->buf[i] = (int16_t)buf[i] - 127;
+
+     /* lock demod thread, write to it, unlock */
+       pthread_rwlock_wrlock(&demod->lck);
+    memcpy(demod->buf, dongle->buf, 2 * len);
+    demod->buf_len = len;
+       pthread_rwlock_unlock(&demod->lck);
+       pthread_signal(&demod->ok, &demod->ok_m);
+}
+ /**/
+STATIC void* _dongle_thread_fn (void *ctx) {
+    dev_ctx_T *dev_ctx = (dev_ctx_T *)ctx;
+    dongle_ctx *dongle = dev_ctx->dongle;
+
+    rtlsdr_read_async(dev_ctx->dev, _rtlsdr_callback, dev_ctx, 0, 0);
+
+    dongle->thr_finished = 1;
+    return 0;
+}
+
+STATIC void _lowpass_demod (void *ctx) {
+    demod_ctx *demod = (demod_ctx *)ctx;
+    int i=0, i2=0;
+
+    while (i < demod->buf_len) {
+        demod->now_r += demod->buf[i];
+        demod->now_j += demod->buf[i+1];
+        i += 2;
+        demod->index++;
+        if (demod->index < ((1000000 / 200000) + 1))
+            continue;
+        demod->buf[i2] = demod->now_r;
+        demod->buf[i2+1] = demod->now_j;
+        demod->index = 0;
+        demod->now_r = demod->now_j = 0;
+        i2 += 2;
+    }
+    demod->buf_len = i2;
+}
+ /**/
+STATIC void _lowpassreal_demod (void *ctx) {
+    demod_ctx *demod = (demod_ctx *)ctx;
+    int i=0, i2=0;
+    int fast = 200000;
+    int slow = 48000;
+
+    while (i < demod->res_len) {
+        demod->now_index += demod->res[i];
+        i++;
+        demod->pre_index += slow;
+        if (demod->pre_index < fast)
+            continue;
+        demod->res[i2] = (int16_t)(demod->now_index / (fast/slow));
+        demod->pre_index -= fast;
+        demod->now_index = 0;
+        i2 += 1;
+    }
+    demod->res_len = i2;
+}
+ /**/
+STATIC void _multiply (int ar, int aj, int br, int bj, int *cr, int *cj) {
+    *cr = ar*br - aj*bj;
+    *cj = aj*br + ar*bj;
+}
+ /**/
+STATIC int _polar_discriminant (int ar, int aj, int br, int bj) {
+    int cr, cj;
+    double angle;
+    _multiply(ar, aj, br, -bj, &cr, &cj);
+    angle = atan2((double)cj, (double)cr);
+    return (int)(angle / 3.14159 * (1<<14));
+}
+ /**/
+STATIC void _fm_demod (void *ctx) {
+    demod_ctx *demod = (demod_ctx *)ctx;
+    int16_t *buf = demod->buf;
+    int buf_len = demod->buf_len;
+    int pcm, i;
+
+    pcm = _polar_discriminant(buf[0], buf[1], demod->pre_r, demod->pre_j);
+    demod->res[0] = (int16_t)pcm;
+
+    for (i = 2; i < (buf_len-1); i += 2) {
+        pcm = _polar_discriminant(buf[i], buf[i+1], buf[i-2], buf[i-1]);
+        demod->res[i/2] = (int16_t)pcm;
+    }
+    demod->pre_r = buf[buf_len - 2];
+    demod->pre_j = buf[buf_len - 1];
+    demod->res_len = buf_len/2;
+}
+ /**/
+STATIC void _am_demod (void *ctx) {
+    demod_ctx *demod = (demod_ctx *)ctx;
+    int16_t *buf = demod->buf;
+    int buf_len = demod->buf_len;
+    int pcm, i;
+
+    for (i = 0; i < buf_len; i += 2) {
+        pcm = buf[i] * buf[i];
+        pcm += buf[i+1] * buf[i+1];
+        demod->res[i/2] = (int16_t)sqrt(pcm);
+    }
+    demod->res_len = buf_len/2;
+}
+ /**/
+STATIC void* _demod_thread_fn (void *ctx) {
+    dev_ctx_T *dev_ctx = (dev_ctx_T *)ctx;
+    demod_ctx *demod = dev_ctx->demod;
+    output_ctx *output = dev_ctx->output;
+
+    while(dev_ctx->should_run) {
+            pthread_wait(&demod->ok, &demod->ok_m);
+            pthread_rwlock_wrlock(&demod->lck);
+        _lowpass_demod(demod);
+        if (dev_ctx->mode == FM)
+            _fm_demod(demod);
+        else
+            _am_demod(demod);
+        _lowpassreal_demod(demod);
+           pthread_rwlock_unlock(&demod->lck);
+
+         /* lock demod thread, write to it, unlock */
+           pthread_rwlock_wrlock(&output->lck);
+        memcpy(output->buf, demod->res, 2 * demod->res_len);
+        output->buf_len = demod->res_len;
+           pthread_rwlock_unlock(&output->lck);
+           pthread_signal(&output->ok, &output->ok_m);
+    }
+
+    demod->thr_finished = 1;
+    return 0;
+}
+
+STATIC void* _output_thread_fn (void *ctx) {
+    dev_ctx_T *dev_ctx = (dev_ctx_T *)ctx;
+    output_ctx *output = dev_ctx->output;
+
+    while (dev_ctx->should_run) {
+           pthread_wait(&output->ok, &output->ok_m);
+           pthread_rwlock_rdlock(&output->lck);
+        //if (!dev_ctx->mute)
+        //    mRadio->PlayAlsa((void*)&output->buf, output->buf_len);
+           pthread_rwlock_unlock(&output->lck);
+    }
+
+    output->thr_finished = 1;
+    return 0;
+}
+
+
+// ********************************************************
+
+// FULUP integration proposal with client session context
+
+// ********************************************************
+
+
+#define MAX_RADIO 10
+
+// Structure holding existing radio with current usage status
+typedef struct {
+    int   idx;
+    char *name;
+    int  used;
+} radioDevT;
+
+// Radio plugin handle should store everething API may need
+typedef struct {
+  radioDevT *radios[MAX_RADIO];  // pointer to existing radio
+  int devCount;
+} pluginHandleT;
+
+// Client Context Structure Hold any specific to client [will be destroyed when client leave]
+typedef struct {
+    dev_ctx_T radio;       // pointer to client radio
+    int idx;               // index of radio within global array
+} ctxHandleT;
+
+
+// It his was not a demo only, it should be smarter to enable hot plug/unplug
+STATIC void updateRadioDevList(pluginHandleT *handle) {
+  int idx;  
+
+  // loop on existing radio if any
+  for (idx = 0; idx < _radio_dev_count(); idx++) {
+      if (idx == MAX_RADIO) break;
+      handle->radios[idx] = calloc(1, sizeof(radioDevT)); // use calloc to set used to FALSE
+      handle->radios[idx]->name = (char *) _radio_dev_name(idx); 
+  }
+  handle->devCount = _radio_dev_count();
+}
+
+
+// This is call at plugin load time [radio devices might still not be visible]
+STATIC pluginHandleT* initRadioPlugin() {
+
+  // Allocate Plugin handle  
+  pluginHandleT *handle = calloc (1,sizeof (pluginHandleT)); // init handle with zero
+
+  // Some initialization steps
+  updateRadioDevList(handle);
+
+  return (handle);
+}
+
+// Stop a radio free related ressource and make it avaliable for other clients
+STATIC AFB_error releaseRadio (pluginHandleT* handle, ctxHandleT *ctx) {
+    
+   // change radio status
+   (handle->radios[ctx->idx])->used = FALSE;
+
+   // stop related threads and free attached resources
+   radio_stop (&ctx->radio);
+
+   // May be some further cleanup ????
+
+   return (AFB_SUCCESS); // Could it fails ????
+}
+
+
+// Start a radio and reserve exclusive usage to requesting client
+STATIC ctxHandleT  *reserveRadio (pluginHandleT* handle) {
+    ctxHandleT *client;
+    int idx;
+    
+   // loop on existing radio if any
+    for (idx = 0; idx < _radio_dev_count(); idx++) {
+        if ((handle->radios[client->idx])->used = FALSE) break;
+    }
+    
+    // No avaliable radio return now
+    if (idx == MAX_RADIO) return (NULL);
+    
+   // Book radio
+   (handle->radios[client->idx])->used = TRUE;
+   
+   // create client handle 
+   client = calloc (1, sizeof (ctxHandleT));
+   
+   // stop related threads and free attached resources
+   _radio_start_threads (&client->radio);
+   
+   // May be some things to do ????
+   
+   
+   return (client);
+}
+
+// This is called when client session died [ex; client quit for more than 15mn]
+STATIC json_object* freeRadio () {
+    
+    //releaseRadio (client->handle, client);
+    //free (client);
+}
+
+
+STATIC json_object* powerOnOff (AFB_request *request) {
+    json_object *jresp;
+    AFB_clientCtx *client = request->client; // get client context from request
+   
+    // Make sure binder was started with client session
+    if (client == NULL) {
+        request->errcode=MHD_HTTP_FORBIDDEN;
+        return (jsonNewMessage(AFB_FAIL, "Radio binder need session [--token=xxxx]"));        
+    }
+     
+    // If we have a handle radio was on let power it down
+    if (client->ctx != NULL) {
+        dev_ctx_T *dev_ctx = (dev_ctx_T *)client->ctx;
+
+        releaseRadio (client->plugin->handle, client->ctx);  // poweroff client related radio
+        
+        jresp = json_object_new_object();
+        json_object_object_add(jresp, "power", json_object_new_string ("off"));        
+        return (jresp);
+    }
+        
+    // request a new client context token and check result 
+    if (AFB_UNAUTH == ctxTokenCreate (request)) {
+        request->errcode=MHD_HTTP_UNAUTHORIZED;
+        jresp= jsonNewMessage(AFB_FAIL, "You're not authorized to request a radio [make sure you have the right authentication token");
+        return (jresp);
+    }
+    
+    // Client is clean let's look it we have an avaliable radio to propose
+    
+    // make sure we have last hot plug dongle visible
+    updateRadioDevList (client->plugin->handle); 
+    
+    // get try to get an unused radio
+    client->ctx = reserveRadio (client->plugin->handle);  
+    if (client->ctx == NULL) {
+       return (jsonNewMessage(AFB_FAIL, "Sory No More Radio Avaliable")); 
+    }  
+    
+    // At this point we should have something to retreive radio status before last poweroff [but this is only a demonstrator]
+}
+
+STATIC json_object* start (AFB_request *request) {
+    return NULL;
+}
+
+STATIC json_object* stop (AFB_request *request) {
+    return NULL;
+}
+
+STATIC json_object* status (AFB_request *request) {
+    return NULL;
+}
+
+
+STATIC  AFB_restapi pluginApis[]= {
+  {"power"  , AFB_SESSION_CREATE, (AFB_apiCB)powerOnOff , "Ping Application Framework"},
+  {"start"  , AFB_SESSION_CHECK,  (AFB_apiCB)start      , "Ping Application Framework"},
+  {"stop"   , AFB_SESSION_CHECK,  (AFB_apiCB)stop       , "Ping Application Framework"},
+  {"status" , AFB_SESSION_RENEW,  (AFB_apiCB)status     , "Ping Application Framework"},
+  {NULL}
+};
+
+PUBLIC AFB_plugin *radioRegister (AFB_session *session) {
+    AFB_plugin *plugin = malloc (sizeof (AFB_plugin));
+    plugin->type  = AFB_PLUGIN_JSON;
+    plugin->info  = "Application Framework Binder - Radio plugin";
+    plugin->prefix  = "radio";
+    plugin->apis  = pluginApis;
+    
+    plugin->handle = initRadioPlugin();
+    plugin->freeCtxCB = freeRadio;
+
+    return (plugin);
+};
diff --git a/plugins/samples/HelloWorld.c b/plugins/samples/HelloWorld.c
new file mode 100644
index 00000000..70de03f0
--- /dev/null
+++ b/plugins/samples/HelloWorld.c
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2015 "IoT.bzh"
+ * Author "Fulup Ar Foll"
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "local-def.h"
+
+STATIC json_object* pingSample (AFB_request *request) {
+    static pingcount = 0;
+    json_object *response;
+    char query [512];
+    int len;
+
+    // request all query key/value
+    len = getQueryAll (request, query, sizeof(query));
+    if (len == 0) strcpy (query,"NoSearchQueryList");
+    
+    // check if we have some post data
+    if (request->post == NULL)  request->post->data="NoData";  
+        
+    // return response to caller
+    response = jsonNewMessage(AFB_SUCCESS, "Ping Binder Daemon %d query={%s} PostData: \'%s\' ", pingcount++, query, request->post);
+    
+    if (verbose) fprintf(stderr, "%d: \n", pingcount);
+    return (response);
+}
+
+STATIC json_object* pingFail (AFB_request *request) {
+    return NULL;
+}
+
+STATIC json_object* pingBug (AFB_request *request) {
+    int a,b,c;
+    
+    fprintf (stderr, "Use --timeout=10 to trap error\n");
+    b=4;
+    c=0;
+    a=b/c;
+    
+    // should never return
+    return NULL;
+}
+
+
+// For samples https://linuxprograms.wordpress.com/2010/05/20/json-c-libjson-tutorial/
+STATIC json_object* pingJson (AFB_session *session, AFB_request *request) {
+    json_object *jresp, *embed;    
+    
+    jresp = json_object_new_object();
+    json_object_object_add(jresp, "myString", json_object_new_string ("Some String"));
+    json_object_object_add(jresp, "myInt", json_object_new_int (1234));
+     
+    embed  = json_object_new_object();
+    json_object_object_add(embed, "subObjString", json_object_new_string ("Some String"));
+    json_object_object_add(embed, "subObjInt", json_object_new_int (5678));
+    
+    json_object_object_add(jresp,"eobj", embed);
+    
+    return jresp;
+}
+
+
+STATIC  AFB_restapi pluginApis[]= {
+  {"ping"     , AFB_SESSION_NONE, (AFB_apiCB)pingSample  , "Ping Application Framework"},
+  {"pingnull" , AFB_SESSION_NONE, (AFB_apiCB)pingFail    , "Return NULL"},
+  {"pingbug"  , AFB_SESSION_NONE, (AFB_apiCB)pingBug     , "Do a Memory Violation"},
+  {"pingJson" , AFB_SESSION_NONE, (AFB_apiCB)pingJson    , "Return a JSON object"},
+  {"ctx-store", AFB_SESSION_NONE, (AFB_apiCB)pingSample  , "Verbose Mode"},
+  {"ctx-load" , AFB_SESSION_NONE, (AFB_apiCB)pingSample  , "Verbose Mode"},
+  {NULL}
+};
+
+
+PUBLIC AFB_plugin *dbusRegister () {
+    AFB_plugin *plugin = malloc (sizeof (AFB_plugin));
+    plugin->type  = AFB_PLUGIN_JSON;
+    plugin->info  = "Application Framework Binder Service";
+    plugin->prefix= "dbus";        
+    plugin->apis  = pluginApis;
+    return (plugin);
+};
\ No newline at end of file
diff --git a/plugins/samples/SamplePost.c b/plugins/samples/SamplePost.c
new file mode 100644
index 00000000..9e1c7660
--- /dev/null
+++ b/plugins/samples/SamplePost.c
@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2015 "IoT.bzh"
+ * Author "Fulup Ar Foll"
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "local-def.h"
+
+// Dummy sample of Client Application Context
+typedef struct {
+  int  something;       
+  void *whateveryouwant;
+} MyClientApplicationHandle;
+
+
+// Request Creation of new context if it does not exist
+STATIC json_object* clientContextCreate (AFB_request *request) {
+    json_object *jresp;
+
+    // add an application specific client context to session
+    request->client->ctx = malloc (sizeof (MyClientApplicationHandle));
+    
+    // Send response to UI
+    jresp = json_object_new_object();               
+    json_object_object_add(jresp, "token", json_object_new_string ("A New Token and Session Context Was Created"));
+
+    return (jresp);
+}
+
+// Before entering here token will be check and renew
+STATIC json_object* clientContextRefresh (AFB_request *request) {
+    json_object *jresp;
+
+  
+    jresp = json_object_new_object();
+    json_object_object_add(jresp, "token", json_object_new_string ("Token was refreshed"));              
+    
+    return (jresp);
+}
+
+
+// Session token will we verified before entering here
+STATIC json_object* clientContextCheck (AFB_request *request) {
+    
+    json_object *jresp = json_object_new_object();    
+    json_object_object_add(jresp, "isvalid", json_object_new_boolean (TRUE));       
+        
+    return (jresp); 
+}
+
+
+// Close and Free context
+STATIC json_object* clientContextReset (AFB_request *request) {
+    json_object *jresp;
+   
+    jresp = json_object_new_object();
+    json_object_object_add(jresp, "uuid", json_object_new_string (request->client->uuid));              
+    
+    return (jresp); 
+}
+
+// In this case or handle is quite basic
+typedef struct {
+   int fd; 
+} appPostCtx;
+
+// This function is call when PostForm processing is completed
+STATIC void DonePostForm (AFB_request *request) {
+    AFB_PostHandle  *postHandle = (AFB_PostHandle*)request->post->data;
+    appPostCtx *appCtx= postHandle->ctx;
+    
+    // Close upload file ID
+    close (appCtx->fd);
+
+    // Free application specific handle
+    free (postHandle->ctx);
+    
+    if (verbose) fprintf (stderr, "DonePostForm upload done\n");
+}
+
+
+// WARNING: PostForm callback are call multiple time (one or each key within form)
+// When processing POST_JSON request->data hold a PostHandle and not data directly as for POST_JSON
+STATIC json_object* ProcessPostForm (AFB_request *request, AFB_PostItem *item) {
+
+    AFB_PostHandle  *postHandle;
+    appPostCtx *appCtx;
+    char filepath[512];
+            
+    // When Post is fully processed the same callback is call with a item==NULL
+    if (item == NULL) {
+        // Close file, Free handle
+        
+        request->errcode = MHD_HTTP_OK;
+        return(jsonNewMessage(AFB_SUCCESS,"File [%s] uploaded at [%s] error=\n", item->filename, request->config->sessiondir));  
+    }
+    
+    // Let's make sure this is a valid PostForm request
+    if (!request->post && request->post->type != AFB_POST_FORM) {
+        request->errcode = MHD_HTTP_FORBIDDEN;
+        return(jsonNewMessage(AFB_FAIL,"This is not a valid PostForm request\n"));          
+    } else {
+        // In AFB_POST_FORM case post->data is a PostForm handle
+        postHandle = (AFB_PostHandle*) request->post->data;
+        appCtx = (appPostCtx*) postHandle->ctx;
+    }
+
+    // Check this is a file element
+    if (0 != strcmp (item->key, "file")) {
+        request->errcode = MHD_HTTP_FORBIDDEN;
+        return (jsonNewMessage(AFB_FAIL,"No File within element key=%s\n", item->key));
+    }
+
+    // This is the 1st Item iteration let's open output file and allocate necessary resources
+    if (postHandle->ctx == NULL)  {
+        int fd;
+        
+        strncpy (filepath, request->config->sessiondir, sizeof(filepath));
+        strncat (filepath, "/", sizeof(filepath));
+        strncat (filepath, item->filename, sizeof(filepath));  
+
+        if((fd = open(request->config->sessiondir, O_RDONLY)) < 0) {
+            request->errcode = MHD_HTTP_FORBIDDEN;
+            return (jsonNewMessage(AFB_FAIL,"Fail to Upload file [%s] at [%s] error=\n", item->filename, request->config->sessiondir, strerror(errno)));
+        };            
+
+        // Create an application specific context
+        appCtx = malloc (sizeof(appPostCtx)); // May place anything here until post->completeCB handle resources liberation
+        appCtx->fd = fd;
+        
+        // attach application to postHandle
+        postHandle->ctx = (void*) appCtx;   // May place anything here until post->completeCB handle resources liberation        
+        postHandle->completeCB = (AFB_apiCB)DonePostForm; // CallBack when Form Processing is finished
+        
+    } else {
+        // this is not the call, FD is already open
+        appCtx = (appPostCtx*) postHandle->ctx;
+    }
+
+    // We have something to write
+    if (item->len > 0) {
+        
+        if (!write (appCtx->fd, item->data, item->len)) {
+            request->errcode = MHD_HTTP_FORBIDDEN;
+            return (jsonNewMessage(AFB_FAIL,"Fail to write file [%s] at [%s] error=\n", item->filename, strerror(errno)));
+        }
+    }
+  
+    // every event should return Sucess or Form processing stop
+    request->errcode = MHD_HTTP_OK;
+    return NULL;
+}
+
+// This function is call when Client Session Context is removed
+// Note: when freeCtxCB==NULL standard free/malloc is called
+STATIC void clientContextFree(AFB_clientCtx *client) {
+    fprintf (stderr,"Plugin[%s] Closing Session uuid=[%s]\n", client->plugin->prefix, client->uuid);
+    free (client->ctx);
+}
+
+STATIC  AFB_restapi pluginApis[]= {
+  {"ping"          , AFB_SESSION_NONE  , (AFB_apiCB)apiPingTest         ,"Ping Rest Test Service"},
+  {"token-create"  , AFB_SESSION_CREATE, (AFB_apiCB)clientContextCreate ,"Request Client Context Creation"},
+  {"token-refresh" , AFB_SESSION_RENEW , (AFB_apiCB)clientContextRefresh,"Refresh Client Context Token"},
+  {"token-check"   , AFB_SESSION_CHECK , (AFB_apiCB)clientContextCheck  ,"Check Client Context Token"},
+  {"token-reset"   , AFB_SESSION_CLOSE , (AFB_apiCB)clientContextReset  ,"Close Client Context and Free resources"},
+  {"file-upload"   , AFB_SESSION_NONE  , (AFB_apiCB)ProcessPostForm     ,"Demo for file upload"},
+  {NULL}
+};
+
+PUBLIC AFB_plugin *afsvRegister () {
+    AFB_plugin *plugin = malloc (sizeof (AFB_plugin));
+    plugin->type  = AFB_PLUGIN_JSON; 
+    plugin->info  = "Application Framework Binder Service";
+    plugin->prefix= "afbs";  // url base
+    plugin->apis  = pluginApis;
+    plugin->handle= (void*) "What ever you want";
+    plugin->freeCtxCB= (void*) clientContextFree;
+    
+    return (plugin);
+};
\ No newline at end of file
diff --git a/plugins/session/token-api.c b/plugins/session/token-api.c
new file mode 100644
index 00000000..9e1c7660
--- /dev/null
+++ b/plugins/session/token-api.c
@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2015 "IoT.bzh"
+ * Author "Fulup Ar Foll"
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "local-def.h"
+
+// Dummy sample of Client Application Context
+typedef struct {
+  int  something;       
+  void *whateveryouwant;
+} MyClientApplicationHandle;
+
+
+// Request Creation of new context if it does not exist
+STATIC json_object* clientContextCreate (AFB_request *request) {
+    json_object *jresp;
+
+    // add an application specific client context to session
+    request->client->ctx = malloc (sizeof (MyClientApplicationHandle));
+    
+    // Send response to UI
+    jresp = json_object_new_object();               
+    json_object_object_add(jresp, "token", json_object_new_string ("A New Token and Session Context Was Created"));
+
+    return (jresp);
+}
+
+// Before entering here token will be check and renew
+STATIC json_object* clientContextRefresh (AFB_request *request) {
+    json_object *jresp;
+
+  
+    jresp = json_object_new_object();
+    json_object_object_add(jresp, "token", json_object_new_string ("Token was refreshed"));              
+    
+    return (jresp);
+}
+
+
+// Session token will we verified before entering here
+STATIC json_object* clientContextCheck (AFB_request *request) {
+    
+    json_object *jresp = json_object_new_object();    
+    json_object_object_add(jresp, "isvalid", json_object_new_boolean (TRUE));       
+        
+    return (jresp); 
+}
+
+
+// Close and Free context
+STATIC json_object* clientContextReset (AFB_request *request) {
+    json_object *jresp;
+   
+    jresp = json_object_new_object();
+    json_object_object_add(jresp, "uuid", json_object_new_string (request->client->uuid));              
+    
+    return (jresp); 
+}
+
+// In this case or handle is quite basic
+typedef struct {
+   int fd; 
+} appPostCtx;
+
+// This function is call when PostForm processing is completed
+STATIC void DonePostForm (AFB_request *request) {
+    AFB_PostHandle  *postHandle = (AFB_PostHandle*)request->post->data;
+    appPostCtx *appCtx= postHandle->ctx;
+    
+    // Close upload file ID
+    close (appCtx->fd);
+
+    // Free application specific handle
+    free (postHandle->ctx);
+    
+    if (verbose) fprintf (stderr, "DonePostForm upload done\n");
+}
+
+
+// WARNING: PostForm callback are call multiple time (one or each key within form)
+// When processing POST_JSON request->data hold a PostHandle and not data directly as for POST_JSON
+STATIC json_object* ProcessPostForm (AFB_request *request, AFB_PostItem *item) {
+
+    AFB_PostHandle  *postHandle;
+    appPostCtx *appCtx;
+    char filepath[512];
+            
+    // When Post is fully processed the same callback is call with a item==NULL
+    if (item == NULL) {
+        // Close file, Free handle
+        
+        request->errcode = MHD_HTTP_OK;
+        return(jsonNewMessage(AFB_SUCCESS,"File [%s] uploaded at [%s] error=\n", item->filename, request->config->sessiondir));  
+    }
+    
+    // Let's make sure this is a valid PostForm request
+    if (!request->post && request->post->type != AFB_POST_FORM) {
+        request->errcode = MHD_HTTP_FORBIDDEN;
+        return(jsonNewMessage(AFB_FAIL,"This is not a valid PostForm request\n"));          
+    } else {
+        // In AFB_POST_FORM case post->data is a PostForm handle
+        postHandle = (AFB_PostHandle*) request->post->data;
+        appCtx = (appPostCtx*) postHandle->ctx;
+    }
+
+    // Check this is a file element
+    if (0 != strcmp (item->key, "file")) {
+        request->errcode = MHD_HTTP_FORBIDDEN;
+        return (jsonNewMessage(AFB_FAIL,"No File within element key=%s\n", item->key));
+    }
+
+    // This is the 1st Item iteration let's open output file and allocate necessary resources
+    if (postHandle->ctx == NULL)  {
+        int fd;
+        
+        strncpy (filepath, request->config->sessiondir, sizeof(filepath));
+        strncat (filepath, "/", sizeof(filepath));
+        strncat (filepath, item->filename, sizeof(filepath));  
+
+        if((fd = open(request->config->sessiondir, O_RDONLY)) < 0) {
+            request->errcode = MHD_HTTP_FORBIDDEN;
+            return (jsonNewMessage(AFB_FAIL,"Fail to Upload file [%s] at [%s] error=\n", item->filename, request->config->sessiondir, strerror(errno)));
+        };            
+
+        // Create an application specific context
+        appCtx = malloc (sizeof(appPostCtx)); // May place anything here until post->completeCB handle resources liberation
+        appCtx->fd = fd;
+        
+        // attach application to postHandle
+        postHandle->ctx = (void*) appCtx;   // May place anything here until post->completeCB handle resources liberation        
+        postHandle->completeCB = (AFB_apiCB)DonePostForm; // CallBack when Form Processing is finished
+        
+    } else {
+        // this is not the call, FD is already open
+        appCtx = (appPostCtx*) postHandle->ctx;
+    }
+
+    // We have something to write
+    if (item->len > 0) {
+        
+        if (!write (appCtx->fd, item->data, item->len)) {
+            request->errcode = MHD_HTTP_FORBIDDEN;
+            return (jsonNewMessage(AFB_FAIL,"Fail to write file [%s] at [%s] error=\n", item->filename, strerror(errno)));
+        }
+    }
+  
+    // every event should return Sucess or Form processing stop
+    request->errcode = MHD_HTTP_OK;
+    return NULL;
+}
+
+// This function is call when Client Session Context is removed
+// Note: when freeCtxCB==NULL standard free/malloc is called
+STATIC void clientContextFree(AFB_clientCtx *client) {
+    fprintf (stderr,"Plugin[%s] Closing Session uuid=[%s]\n", client->plugin->prefix, client->uuid);
+    free (client->ctx);
+}
+
+STATIC  AFB_restapi pluginApis[]= {
+  {"ping"          , AFB_SESSION_NONE  , (AFB_apiCB)apiPingTest         ,"Ping Rest Test Service"},
+  {"token-create"  , AFB_SESSION_CREATE, (AFB_apiCB)clientContextCreate ,"Request Client Context Creation"},
+  {"token-refresh" , AFB_SESSION_RENEW , (AFB_apiCB)clientContextRefresh,"Refresh Client Context Token"},
+  {"token-check"   , AFB_SESSION_CHECK , (AFB_apiCB)clientContextCheck  ,"Check Client Context Token"},
+  {"token-reset"   , AFB_SESSION_CLOSE , (AFB_apiCB)clientContextReset  ,"Close Client Context and Free resources"},
+  {"file-upload"   , AFB_SESSION_NONE  , (AFB_apiCB)ProcessPostForm     ,"Demo for file upload"},
+  {NULL}
+};
+
+PUBLIC AFB_plugin *afsvRegister () {
+    AFB_plugin *plugin = malloc (sizeof (AFB_plugin));
+    plugin->type  = AFB_PLUGIN_JSON; 
+    plugin->info  = "Application Framework Binder Service";
+    plugin->prefix= "afbs";  // url base
+    plugin->apis  = pluginApis;
+    plugin->handle= (void*) "What ever you want";
+    plugin->freeCtxCB= (void*) clientContextFree;
+    
+    return (plugin);
+};
\ No newline at end of file