diff options
Diffstat (limited to 'plugins')
| -rw-r--r-- | plugins/CMakeLists.txt | 8 | ||||
| -rw-r--r-- | plugins/audio/audio-api.c | 51 | ||||
| -rw-r--r-- | plugins/radio/radio-api.c | 644 | ||||
| -rw-r--r-- | plugins/samples/HelloWorld.c | 95 | ||||
| -rw-r--r-- | plugins/samples/SamplePost.c | 194 | ||||
| -rw-r--r-- | plugins/session/token-api.c | 194 |
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 |