/* Returns 1 if application controller within the "app_id"
* application directory is OK.
* Returns 0 otherwise.
*/
inline int is_registered(const char *dir,
const char *app_id,
const char *fname)
{
int status;
char file [strlen(dir) + strlen(app_id) + strlen(fname) + 3];
struct stat stat_buf;
const mode_t perms = S_IRUSR | S_IXUSR;
sprintf(file, "%s/%s/%s", dir, app_id, fname);
if(stat((const char *)file, &stat_buf) < 0) {
/* File does not exist */
fprintf(stderr, "%s does not exist.\n", file);
return 0;
}
if((stat_buf.st_mode & perms) != perms) {
/* Permissions wrong */
fprintf(stderr, "%s exists but has wrong permissions.\n", file);
return 0;
}
rp_bazaar_app_t app;
ngx_memset(&app, 0, sizeof(rp_bazaar_app_t));
/* Open and check init, exit and desc symbols - if they exist,
* controller is OK.
*/
status = rp_bazaar_app_load_module(file, &app);
if(status < 0) {
fprintf(stderr, "Problem loading app (return %d): %s\n", status, dlerror());
rp_bazaar_app_unload_module(&app);
return 0;
}
int is_reg = 1;
if(app.verify_app_license_func)
is_reg = !app.verify_app_license_func(app_id); // 1 - is registered
rp_bazaar_app_unload_module(&app);
if(is_reg)
fprintf(stderr, "App '%s' is registered\n", app_id);
else
fprintf(stderr, "App '%s' is not registered\n", app_id);
return is_reg;
}
/*----------------------------------------------------------------------------*/
int rp_bazaar_stop(ngx_http_request_t *r,
cJSON **json_root, int argc, char **argv)
{
/* if(argc != 0) {
return rp_module_cmd_error(json_root,
"Incorrect number of arguments (should be 0)",
NULL, r->pool);
}*/
if(rp_module_ctx.app.handle == NULL) {
/* Ignore requests to unload the application controller, if none is loaded. */
return rp_module_cmd_ok(json_root, r->pool);
}
if(rp_bazaar_app_unload_module(&rp_module_ctx.app) < 0) {
return rp_module_cmd_error(json_root,
"Can not unload application.", NULL, r->pool);
}
return rp_module_cmd_ok(json_root, r->pool);
}
int rp_bazaar_app_load_module(const char *app_file, rp_bazaar_app_t *app)
{
if(app->handle != NULL) {
rp_bazaar_app_unload_module(app);
}
app->handle = dlopen(app_file, RTLD_LAZY);
if(!app->handle)
return -1;
dlerror(); /* clear error */
app->init_func = dlsym(app->handle, c_rp_app_init_str);
if(!app->init_func)
return -2;
dlerror(); /* clear error */
app->exit_func = dlsym(app->handle, c_rp_app_exit_str);
if(!app->exit_func)
return -3;
dlerror(); /* clear error */
app->desc_func = dlsym(app->handle, c_rp_app_desc_str);
if(!app->desc_func)
return -4;
app->set_params_func = dlsym(app->handle, c_rp_set_params_str);
if(!app->set_params_func)
return -5;
app->get_params_func = dlsym(app->handle, c_rp_get_params_str);
if(!app->get_params_func)
return -6;
app->get_signals_func = dlsym(app->handle, c_rp_get_signals_str);
if(!app->get_signals_func)
return -7;
// start web socket functionality
app->ws_api_supported = 1;
app->ws_set_params_interval_func = dlsym(app->handle, c_ws_set_params_interval_str);
if(!app->ws_set_params_interval_func)
{
app->ws_api_supported = 0;
fprintf(stderr, "Cannot resolve '%s' function.\n", c_ws_set_params_interval_str);
}
app->ws_set_signals_interval_func = dlsym(app->handle, c_ws_set_signals_interval_str);
if(!app->ws_set_signals_interval_func)
{
app->ws_api_supported = 0;
fprintf(stderr, "Cannot resolve '%s' function.\n", c_ws_set_signals_interval_str);
}
app->ws_get_params_interval_func = dlsym(app->handle, c_ws_get_params_interval_str);
if(!app->ws_get_params_interval_func)
{
app->ws_api_supported = 0;
fprintf(stderr, "Cannot resolve '%s' function.\n", c_ws_get_params_interval_str);
}
app->ws_get_signals_interval_func = dlsym(app->handle, c_ws_get_signals_interval_str);
if(!app->ws_get_signals_interval_func)
{
app->ws_api_supported = 0;
fprintf(stderr, "Cannot resolve '%s' function.\n", c_ws_get_signals_interval_str);
}
app->ws_set_params_func = dlsym(app->handle, c_ws_set_params_str);
if(!app->ws_set_params_func)
{
app->ws_api_supported = 0;
fprintf(stderr, "Cannot resolve '%s' function.\n", c_ws_set_params_str);
}
app->ws_get_params_func = dlsym(app->handle, c_ws_get_params_str);
if(!app->ws_get_params_func)
{
app->ws_api_supported = 0;
fprintf(stderr, "Cannot resolve '%s' function.\n", c_ws_get_params_str);
}
app->ws_set_signals_func = dlsym(app->handle, c_ws_set_signals_str);
if(!app->ws_set_signals_func)
{
app->ws_api_supported = 0;
fprintf(stderr, "Cannot resolve '%s' function.\n", c_ws_set_signals_str);
}
app->ws_get_signals_func = dlsym(app->handle, c_ws_get_signals_str);
if(!app->ws_get_signals_func)
{
app->ws_api_supported = 0;
fprintf(stderr, "Cannot resolve '%s' function.\n", c_ws_get_signals_str);
}
app->ws_set_params_demo_func = dlsym(app->handle, c_ws_set_demo_mode_str);
if(!app->ws_set_params_demo_func)
{
app->ws_api_supported = 0;
fprintf(stderr, "Cannot resolve '%s' function.\n", c_ws_set_demo_mode_str);
}
app->verify_app_license_func = dlsym(app->handle, c_verify_app_license_str);
if(!app->verify_app_license_func)
{
app->ws_api_supported = 0;
fprintf(stderr, "Cannot resolve '%s' function.\n", c_verify_app_license_str);
}
// end web socket functionality
app->file_name = (char *)malloc(strlen(app_file)+1);
if(app->file_name == NULL)
return -8;
strncpy(app->file_name, app_file, strlen(app_file));
app->file_name[strlen(app_file)] = '\0';
return 0;
}
/*----------------------------------------------------------------------------*/
int rp_bazaar_start(ngx_http_request_t *r,
cJSON **json_root, int argc, char **argv)
{
char* url = strstr(argv[0], "?type=demo");
if (url)
{
*url = '\0';
}
else
{
url = strstr(argv[0], "?type=run");
if(url)
*url = '\0';
}
int unsigned len;
ngx_http_rp_loc_conf_t *lc =
ngx_http_get_module_loc_conf(r, ngx_http_rp_module);
if(argc != 1) {
return rp_module_cmd_error(json_root,
"Incorrect number of arguments (should be 1)",
NULL, r->pool);
}
/* Check if application is already running and unload it if so. */
if(rp_module_ctx.app.handle != NULL) {
if(rp_bazaar_app_unload_module(&rp_module_ctx.app)) {
return rp_module_cmd_error(json_root,
"Can not unload existing application.",
NULL, r->pool);
}
}
/* Application id string */
len = strlen(argv[0]) + 1;
rp_module_ctx.app.id = (char *)malloc(len);
if(rp_module_ctx.app.id == NULL) {
return rp_module_cmd_error(json_root, "Can not allocate memory",
strerror(errno), r->pool);
}
strcpy(rp_module_ctx.app.id, argv[0]);
/* Assemble the application and FPGA filename: <app_dir>/<app_id>/controllerhf.so */
len = strlen((char *)lc->bazaar_dir.data) + strlen(argv[0]) + strlen("/controllerhf.so") + 2;
char app_name[len];
sprintf(app_name, "%s/%s/controllerhf.so", lc->bazaar_dir.data, argv[0]);
app_name[len-1]='\0';
/* Unload existing application before, new fpga load */
if(rp_module_ctx.app.handle != NULL){
if(rp_bazaar_app_unload_module(&rp_module_ctx.app)){
return rp_module_cmd_error(json_root,
"Cannot unload existing application.",
NULL, r->pool);
}
}
/* Get FPGA config file in <app_dir>/<app_id>/fpga.conf */
char *fpga_name = NULL;
if (system("/opt/redpitaya/rmamba_pl.sh"))
fprintf(stderr, "Problem running /opt/redpitaya/rmamba_pl.sh\n");
if(get_fpga_path((const char *)argv[0], (const char *)lc->bazaar_dir.data, &fpga_name) == 0) { // FIXME !!!
/* Here we do not have application running anymore - load new FPGA */
fprintf(stderr, "Loading specific FPGA from: '%s'\n", fpga_name);
/* Try loading FPGA code
* - Test if fpga loaded correctly
* - Read/write permissions
* - File exists/not exists */
switch (rp_bazaar_app_load_fpga(fpga_name)) {
case FPGA_FIND_ERR:
if (fpga_name) free(fpga_name);
return rp_module_cmd_error(json_root, "Cannot find fpga file.", NULL, r->pool);
case FPGA_READ_ERR:
if (fpga_name) free(fpga_name);
return rp_module_cmd_error(json_root, "Unable to read FPGA file.", NULL, r->pool);
case FPGA_WRITE_ERR:
if (fpga_name) free(fpga_name);
return rp_module_cmd_error(json_root, "Unable to write FPGA file into memory.", NULL, r->pool);
/* App is a new app and doesn't need custom fpga.bit */
case FPGA_NOT_REQ:
if (fpga_name) free(fpga_name);
break;
case FPGA_OK:
{
if (fpga_name) free(fpga_name);
char dmaDrv[len];
len = strlen((char *)lc->bazaar_dir.data) + strlen(argv[0]) + strlen("/fpga.sh") + 2;
sprintf(dmaDrv, "%s/%s/fpga.sh", lc->bazaar_dir.data, argv[0]);
if (system(dmaDrv))
fprintf(stderr, "Problem running %s\n", dmaDrv);
break;
}
default:
if (fpga_name) free(fpga_name);
return rp_module_cmd_error(json_root, "Unknown error.", NULL, r->pool);
}
} else {
fprintf(stderr, "Not loading specific FPGA, since no fpga.conf file was found.\n");
}
/* Load new application. */
fprintf(stderr, "Loading application: '%s'\n", app_name);
if(rp_bazaar_app_load_module(&app_name[0], &rp_module_ctx.app) < 0) {
rp_bazaar_app_unload_module(&rp_module_ctx.app);
return rp_module_cmd_error(json_root, "Can not load application.",
NULL, r->pool);
}
if(rp_module_ctx.app.init_func() < 0) {
rp_module_cmd_error(json_root,
"Application init failed, aborting",
NULL, r->pool);
rp_bazaar_app_unload_module(&rp_module_ctx.app);
return -1;
}
rp_module_ctx.app.initialized=1;
fprintf(stderr, "Application loaded succesfully!\n");
//start web socket server
if(rp_module_ctx.app.ws_api_supported)
{
struct server_parameters params;
ngx_memset(¶ms, 0, sizeof(struct server_parameters));
params.set_params_interval_func = rp_module_ctx.app.ws_set_params_interval_func;
params.set_signals_interval_func = rp_module_ctx.app.ws_set_signals_interval_func;
params.get_params_interval_func = rp_module_ctx.app.ws_get_params_interval_func;
params.get_signals_interval_func = rp_module_ctx.app.ws_get_signals_interval_func;
params.get_params_func = rp_module_ctx.app.ws_get_params_func;
params.set_params_func = rp_module_ctx.app.ws_set_params_func;
params.get_signals_func = rp_module_ctx.app.ws_get_signals_func;
params.set_signals_func = rp_module_ctx.app.ws_set_signals_func;
params.gzip_func = rp_module_ctx.app.ws_gzip_func;
fprintf(stderr, "Starting WS-server\n");
start_ws_server(¶ms);
}
return rp_module_cmd_ok(json_root, r->pool);
}
