/*
|
* Copyright (c) 2020, Rockchip Electronics Co., Ltd
|
*
|
* 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 2 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.
|
*/
|
|
#include "j2s.h"
|
#ifdef __ANDROID__
|
#if defined(ISP_HW_V20)
|
#include "j2s_generated_v20.h"
|
#elif defined(ISP_HW_V21)
|
#include "j2s_generated_v21.h"
|
#else
|
#error "Please define supported ISP version!!!, eg: -DISP_HW_V21"
|
#endif
|
#else
|
#include "j2s_generated.h"
|
#endif
|
|
#include <sys/stat.h>
|
|
typedef struct {
|
void* ptr;
|
bool freeable;
|
} j2s_ptr;
|
|
typedef struct {
|
int num_data;
|
j2s_ptr* data;
|
} j2s_priv_data;
|
|
void* j2s_alloc_data(j2s_ctx* ctx, size_t size)
|
{
|
void* ptr = calloc(size, 1);
|
if (!ptr)
|
return NULL;
|
|
if (j2s_add_data(ctx, ptr, false) < 0) {
|
free(ptr);
|
return NULL;
|
}
|
|
return ptr;
|
}
|
|
int j2s_add_data(j2s_ctx* ctx, void* ptr, bool freeable)
|
{
|
j2s_priv_data* priv;
|
|
if (!ctx->priv)
|
ctx->priv = calloc(1, sizeof(j2s_priv_data));
|
|
priv = ctx->priv;
|
for (int i = 0; i < priv->num_data; i++) {
|
j2s_ptr* data = &priv->data[i];
|
if (data->ptr)
|
continue;
|
|
data->ptr = ptr;
|
data->freeable = freeable;
|
return 0;
|
}
|
|
priv->num_data++;
|
priv->data = realloc(priv->data, priv->num_data * sizeof(j2s_ptr));
|
if (!priv->data) {
|
ERR("failed to realloc\n");
|
priv->num_data = 0;
|
return -1;
|
}
|
|
priv->data[priv->num_data - 1].ptr = ptr;
|
priv->data[priv->num_data - 1].freeable = freeable;
|
return 0;
|
}
|
|
void j2s_release_data(j2s_ctx* ctx, void* ptr)
|
{
|
j2s_priv_data* priv = ctx->priv;
|
|
void* free_ptr = ptr;
|
for (int i = 0; priv && i < priv->num_data; i++) {
|
j2s_ptr* data = &priv->data[i];
|
if (ptr != data->ptr)
|
continue;
|
|
if (data->ptr && data->freeable) {
|
free(data->ptr);
|
free_ptr = NULL;
|
}
|
data->ptr = NULL;
|
//return;
|
}
|
|
if (free_ptr)
|
free(ptr);
|
}
|
|
void* j2s_read_file(const char* file, size_t* size)
|
{
|
struct stat st;
|
void* buf;
|
int fd;
|
|
DASSERT_MSG(file && !stat(file, &st), return NULL, "no such file: '%s'\n",
|
file ?: "<null>");
|
|
fd = open(file, O_RDONLY);
|
DASSERT_MSG(fd >= 0, return NULL, "failed to open: '%s'\n", file);
|
|
buf = malloc(st.st_size + 1);
|
DASSERT(buf, return NULL);
|
|
DBG("Read file: '%s'\n", file);
|
|
if (read(fd, buf, st.st_size) != st.st_size) {
|
ERR("failed to read: '%s'\n", file);
|
free(buf);
|
close(fd);
|
return NULL;
|
}
|
|
((char*)buf)[st.st_size] = '\0';
|
*size = st.st_size;
|
|
close(fd);
|
return buf;
|
}
|
|
static char* j2s_cache_file(const char* file)
|
{
|
char cache_file[256];
|
|
if (getenv("J2S_NO_CACHE")) {
|
DBG("Cache not allowed\n");
|
return NULL;
|
}
|
|
strcpy(cache_file, getenv("J2S_CACHE") ?: "/var/cache/j2s-cache");
|
|
/* NULL for ctx cache file */
|
if (!file)
|
return strdup(cache_file);
|
|
strcat(cache_file, "-");
|
strcat(cache_file, strrchr(file, '/') ? strrchr(file, '/') + 1 : file);
|
|
for (int i = 0; cache_file[i]; i++) {
|
if (cache_file[i] == '.')
|
cache_file[i] = '-';
|
}
|
|
return strdup(cache_file);
|
}
|
|
static int j2s_cache_file_valid(const char* cache_file)
|
{
|
struct stat st;
|
|
if (!cache_file || stat(cache_file, &st) < 0) {
|
DBG("invalid cache: '%s'\n", cache_file ?: "<NULL>");
|
return -1;
|
}
|
|
if (getuid() != st.st_uid) {
|
DBG("invalid cache: '%s'\n", cache_file);
|
return -1;
|
}
|
|
return 0;
|
}
|
|
static __attribute__((unused)) int j2s_load_ctx_cache(j2s_ctx* ctx,
|
const char* cache_file)
|
{
|
void *buf, *ptr;
|
size_t size;
|
|
if (j2s_cache_file_valid(cache_file) < 0)
|
return -1;
|
|
buf = j2s_read_file(cache_file, &size);
|
if (!buf || size <= sizeof(*ctx)) {
|
DBG("invalid cache: '%s'\n", cache_file);
|
goto err;
|
}
|
|
DBG("Loading ctx cache: '%s'\n", cache_file);
|
|
ptr = buf;
|
|
*ctx = *(j2s_ctx*)ptr;
|
ctx->priv = NULL;
|
ptr += sizeof(*ctx);
|
|
if (ctx->magic != J2S_MAGIC || ctx->num_obj != J2S_NUM_OBJ || ctx->num_struct != J2S_NUM_STRUCT || ctx->num_enum != J2S_NUM_ENUM || ctx->num_enum_value != J2S_NUM_ENUM_VALUE) {
|
DBG("invalid cache: '%s'\n", cache_file);
|
goto err;
|
}
|
|
ctx->objs = ptr;
|
ptr += ctx->num_obj * sizeof(*ctx->objs);
|
|
ctx->structs = ptr;
|
ptr += ctx->num_struct * sizeof(*ctx->structs);
|
|
ctx->enums = ptr;
|
ptr += ctx->num_enum * sizeof(*ctx->enums);
|
|
ctx->enum_values = ptr;
|
ptr += ctx->num_enum_value * sizeof(*ctx->enum_values);
|
|
if (ptr != buf + size) {
|
DBG("invalid cache: '%s'\n", cache_file);
|
goto err;
|
}
|
|
if (j2s_add_data(ctx, buf, true) < 0)
|
goto err;
|
|
return 0;
|
err:
|
j2s_deinit(ctx);
|
free(buf);
|
return -1;
|
}
|
|
static __attribute__((unused)) void j2s_save_ctx_cache(j2s_ctx* ctx,
|
const char* cache_file)
|
{
|
int fd;
|
ssize_t bytes_written = 0;
|
|
if (!cache_file)
|
return;
|
|
fd = creat(cache_file, S_IRUSR | S_IWUSR);
|
if (fd < 0) {
|
DBG("failed to create: '%s'\n", cache_file);
|
return;
|
}
|
|
DBG("Saving ctx cache: '%s'\n", cache_file);
|
|
ctx->num_desc = 0;
|
|
bytes_written = write(fd, ctx, sizeof(*ctx));
|
bytes_written = write(fd, ctx->objs, ctx->num_obj * sizeof(*ctx->objs));
|
bytes_written = write(fd, ctx->structs, ctx->num_struct * sizeof(*ctx->structs));
|
bytes_written = write(fd, ctx->enums, ctx->num_enum * sizeof(*ctx->enums));
|
bytes_written = write(fd, ctx->enum_values, ctx->num_enum_value * sizeof(*ctx->enum_values));
|
|
close(fd);
|
}
|
|
void j2s_init(j2s_ctx* ctx)
|
{
|
DBG("J2S version: %s\n", J2S_VERSION);
|
|
#ifdef J2S_ENABLE_DESC
|
_j2s_init(ctx);
|
#else
|
char* cache_file = j2s_cache_file(NULL);
|
|
if (j2s_load_ctx_cache(ctx, cache_file) < 0) {
|
_j2s_init(ctx);
|
j2s_save_ctx_cache(ctx, cache_file);
|
}
|
|
if (cache_file)
|
free(cache_file);
|
#endif
|
|
ctx->manage_data = true;
|
}
|
|
void j2s_deinit(j2s_ctx* ctx)
|
{
|
j2s_priv_data* priv = ctx->priv;
|
|
for (int i = 0; priv && i < priv->num_data; i++) {
|
j2s_ptr* data = &priv->data[i];
|
if (!data->ptr || !data->freeable)
|
continue;
|
|
/* Always free the cache file buf */
|
if (ctx->manage_data || data->ptr + sizeof(*ctx) == ctx->objs)
|
free(data->ptr);
|
}
|
|
if (priv) {
|
if (priv->data)
|
free(priv->data);
|
free(priv);
|
}
|
}
|
|
int j2s_load_struct_cache(j2s_ctx* ctx, const char* cache_file, void* ptr,
|
void* auth_data, int auth_size)
|
{
|
int fd, ret = -1;
|
|
if (j2s_cache_file_valid(cache_file) < 0)
|
return -1;
|
|
fd = open(cache_file, O_RDONLY);
|
if (fd < 0) {
|
DBG("failed to open: '%s'\n", cache_file);
|
return -1;
|
}
|
|
DBG("Loading struct cache: '%s'\n", cache_file);
|
|
/* The cache file should start with auth data */
|
if (auth_data && auth_size) {
|
void* buf = malloc(auth_size);
|
if (!buf)
|
goto out;
|
|
if (read(fd, buf, auth_size) != auth_size) {
|
free(buf);
|
goto out;
|
}
|
|
if (memcmp(buf, auth_data, auth_size)) {
|
free(buf);
|
goto out;
|
}
|
|
free(buf);
|
}
|
|
if (j2s_root_struct_from_cache(ctx, fd, ptr) < 0)
|
goto out;
|
|
/* Check end of file */
|
if (read(fd, &ret, 1) > 0)
|
goto out;
|
|
DBG("Loaded struct cache: '%s'\n", cache_file);
|
|
ret = 0;
|
out:
|
close(fd);
|
return ret;
|
}
|
|
void j2s_save_struct_cache(j2s_ctx* ctx, const char* cache_file, void* ptr,
|
void* auth_data, int auth_size)
|
{
|
int fd;
|
ssize_t bytes_written = 0;
|
|
fd = creat(cache_file, S_IRUSR | S_IWUSR);
|
if (fd < 0) {
|
DBG("failed to create: '%s'\n", cache_file);
|
return;
|
}
|
|
DBG("Saving struct cache: '%s'\n", cache_file);
|
|
if (auth_data && auth_size)
|
bytes_written = write(fd, auth_data, auth_size);
|
|
j2s_root_struct_to_cache(ctx, fd, ptr);
|
|
close(fd);
|
}
|
|
int j2s_json_file_to_struct(j2s_ctx* ctx, const char* file, const char* name,
|
void* ptr)
|
{
|
char* cache_file;
|
struct stat st;
|
size_t size;
|
char* buf;
|
int ret = -1;
|
|
DASSERT_MSG(file && !stat(file, &st), return -1, "no such file: '%s'\n",
|
file ?: "<null>");
|
|
cache_file = j2s_cache_file(file);
|
|
/* Using the file stat as auth data */
|
if (!j2s_load_struct_cache(ctx, cache_file, ptr, &st, sizeof(st))) {
|
free(cache_file);
|
return 0;
|
}
|
|
memset(ptr, 0, j2s_struct_size(ctx, ctx->root_index));
|
|
buf = j2s_read_file(file, &size);
|
if (!buf)
|
goto out;
|
|
DBG("Parse file: '%s', content:\n%s\n", file, buf);
|
|
if (j2s_modify_struct(ctx, buf, name, ptr) < 0)
|
goto out;
|
|
j2s_save_struct_cache(ctx, cache_file, ptr, &st, sizeof(st));
|
|
ret = 0;
|
out:
|
free(cache_file);
|
if (buf)
|
free(buf);
|
return ret;
|
}
|
|
char* j2s_dump_struct(j2s_ctx* ctx, const char* name, void* ptr)
|
{
|
cJSON *json, *item;
|
char* buf;
|
|
DBG("Dump: %s\n", name ? name : "root struct");
|
|
if (!name) {
|
json = j2s_root_struct_to_json(ctx, ptr);
|
} else {
|
json = j2s_struct_to_json(ctx, name, ptr);
|
}
|
|
DASSERT(json, return NULL);
|
|
if (ctx->dump_enums) {
|
item = j2s_enums_to_json(ctx);
|
if (item)
|
cJSON_AddItemToObject(json, "@enum", item);
|
}
|
|
if (ctx->format_json) {
|
buf = cJSON_Print(json);
|
} else {
|
buf = cJSON_PrintUnformatted(json);
|
}
|
|
cJSON_Delete(json);
|
return buf;
|
}
|
|
int j2s_modify_struct(j2s_ctx* ctx, const char* str, const char* name,
|
void* ptr)
|
{
|
cJSON* json;
|
int ret = -1;
|
|
json = cJSON_Parse(str);
|
DASSERT_MSG(json, return -1, "failed to parse: '%s'\n", str);
|
|
DBG("Modify:\n%s\n", str);
|
|
ret = j2s_json_to_struct(ctx, json, name, ptr);
|
|
cJSON_Delete(json);
|
return ret;
|
}
|
|
char* j2s_query_struct(j2s_ctx* ctx, const char* str, void* ptr)
|
{
|
cJSON* json;
|
char* buf;
|
|
json = cJSON_Parse(str);
|
DASSERT_MSG(json, return NULL, "failed to parse: '%s'\n", str);
|
|
DBG("Query:\n%s\n", str);
|
|
if (j2s_json_from_root_struct(ctx, json, ptr) < 0) {
|
cJSON_Delete(json);
|
return NULL;
|
}
|
|
if (ctx->format_json) {
|
buf = cJSON_Print(json);
|
} else {
|
buf = cJSON_PrintUnformatted(json);
|
}
|
|
cJSON_Delete(json);
|
return buf;
|
}
|
|
char* j2s_dump_template_struct(j2s_ctx* ctx, const char* name)
|
{
|
cJSON *json, *item;
|
char* buf;
|
|
DBG("Dump template: %s\n", name ? name : "root struct");
|
|
if (!name) {
|
json = j2s_root_struct_to_template_json(ctx);
|
} else {
|
json = j2s_struct_to_template_json(ctx, name);
|
}
|
|
DASSERT(json, return NULL);
|
|
if (ctx->dump_enums) {
|
item = j2s_enums_to_json(ctx);
|
if (item)
|
cJSON_AddItemToObject(json, "@enum", item);
|
}
|
|
if (ctx->format_json) {
|
buf = cJSON_Print(json);
|
} else {
|
buf = cJSON_PrintUnformatted(json);
|
}
|
|
cJSON_Delete(json);
|
return buf;
|
}
|
|
char* j2s_dump_structs(j2s_ctx* ctx, j2s_struct_info* info)
|
{
|
cJSON *json, *item;
|
char* buf;
|
|
if (!info || !info->name)
|
return NULL;
|
|
DBG("Dump structs\n");
|
|
json = cJSON_CreateObject();
|
DASSERT(json, return NULL);
|
|
for (; info->name; info++) {
|
item = j2s_struct_to_json(ctx, info->name, info->ptr);
|
if (!item)
|
continue;
|
|
cJSON_AddItemToObject(json, info->name, item);
|
}
|
|
if (ctx->dump_enums) {
|
item = j2s_enums_to_json(ctx);
|
if (item)
|
cJSON_AddItemToObject(json, "@enum", item);
|
}
|
|
if (ctx->format_json) {
|
buf = cJSON_Print(json);
|
} else {
|
buf = cJSON_PrintUnformatted(json);
|
}
|
|
cJSON_Delete(json);
|
return buf;
|
}
|
