chenyf
/
work_tmp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
work_tmp/property.c

2973 lines
71 KiB
C
Raw Normal View History

1
2024-02-07 06:42:32 +00:00
#include "property.h"
#include <string.h>
#include <math.h>
#include <errno.h>
#include <limits.h>
#include "errcode_inc.h"
#if ((defined PROPERTY_PROV_FS_EN) && (PROPERTY_PROV_FS_EN != 0))
// #include "ff.h"
#if (((defined DISTRIBUTION) || (PROPERTY_CHECKSUM_ENABLED != 0)) && (PROPERTY_CHECKSUM_DISABLED == 0))
#include "sha2.h"
#endif
#endif
#if ((defined PROPERTY_PROV_REMOTE_EN) && (PROPERTY_PROV_REMOTE_EN != 0))
#include "mod_bus.h"
#endif
#if (((!defined PROPERTY_PROV_FS_EN) || (PROPERTY_PROV_FS_EN == 0)) && ((!defined PROPERTY_PROV_REMOTE_EN) || (PROPERTY_PROV_REMOTE_EN == 0)))
#error "define PROPERTY_PROV_FS_EN or PROPERTY_PROV_REMOTE_EN in config.h"
#endif
/**
* 引入pthread库,确保线程安全
*/
#ifdef __linux__
#include <pthread.h>
#include <stdlib.h>
static pthread_mutex_t prop_mutex;
void prop_lock()
{
pthread_mutex_lock(&prop_mutex);
}
void prop_unlock()
{
pthread_mutex_unlock(&prop_mutex);
}
void prop_lock_init()
{
pthread_mutex_init(&prop_mutex, NULL);
}
void prop_wait(INT32U time)
{
}
#else
#include <stdlib.h>
#include <stdio.h>
void prop_lock()
{
;
}
void prop_unlock()
{
;
}
void prop_lock_init()
{
;
}
void prop_wait(INT32U time)
{
;
}
#endif
#define config_path "./conf"
#define COPY_BUF_SIZE 1024
#define FLOAT_STRING_LEN 32
#define UPDATE_LOG "0:/conf/update.%d.log"
typedef struct
{
const char *key;
const char *value;
INT8U success : 1;
} property_string_item;
typedef INT32U (*property_get)(const char *store, const char *id, const char *key, char *value, INT32U sizeOfValue, BOOL *isLocal, void *obj);
typedef INT32U (*property_set)(const char *store, const char *id, property_string_item *list, INT32U count, void *obj);
typedef INT32U (*property_clear_cache)(const char *store, const char *id, void *obj);
typedef struct _sbt_node
{
struct _sbt_node *ch[2];
INT8U valid : 1;
INT8U tryLocal : 1;
INT8U isLocal : 1;
char *key;
char *value;
INT32U size;
} sbt_node;
static sbt_node sbt_nil = {{&sbt_nil, &sbt_nil}, 0, 0, 0, NULL, NULL, 0};
typedef struct _prop_cache
{
char *store;
char *id;
sbt_node *sbt;
struct _prop_cache *next;
} prop_cache;
typedef struct
{
struct
{
INT32U init : 1;
INT32U initPending : 1;
INT32U cache : 1;
INT32U lock : 1;
} flag;
char *id;
#if (defined RTOS_UCOS)
OS_EVENT *sem;
#endif
property_get get;
property_set set;
property_clear_cache clear;
prop_cache *cache;
void *obj;
} property_provider;
static property_provider pp[PROPERTY_PROVIDER_MAX];
static INT8U file_test_random = 0;
#if ((defined PROPERTY_PROV_FS_EN) && (PROPERTY_PROV_FS_EN != 0))
static INT32U FilePropertyInit(INT32U providerId, const PropertyInitParam *param);
#endif
#if ((defined PROPERTY_PROV_REMOTE_EN) && (PROPERTY_PROV_REMOTE_EN != 0))
static INT32U RemotePropertyInit(INT32U providerId, const PropertyInitParam *param);
#endif
// linux下malloc是线程安全的
static void *malloc_mt(size_t size)
{
return malloc(size);
}
// linux下malloc是线程安全的
static void free_mt(void *ptr)
{
free(ptr);
}
/**
* SBT（Spine Binary Tree）是一种特殊的二叉树结构，它主要用于处理字符串模式匹配问题。
SBT的特点是将所有模式字符串的字符按照字典序排列，并将它们连接成一个字符串作为树的主干（Spine），每个模式字符串作为树的一个分支。在SBT中，模式字符串的公共前缀被共享，从而减少了树的高度，提高了匹配效率。
*/
static void SBT_Rotate(sbt_node **x, BOOL flag)
{
// 旋转：flag == 0为左旋，否则为右旋
sbt_node *y = (*x)->ch[!flag];
(*x)->ch[!flag] = y->ch[flag];
y->ch[flag] = *x;
y->size = (*x)->size;
(*x)->size = (*x)->ch[0]->size + (*x)->ch[1]->size + 1;
*x = y;
}
static void SBT_Maintain(sbt_node **t, BOOL flag)
{
// 维护操作的核心：保持
if ((*t)->ch[flag]->ch[flag]->size > (*t)->ch[!flag]->size)
{ // 情况1
SBT_Rotate(t, !flag);
}
else if ((*t)->ch[flag]->ch[!flag]->size > (*t)->ch[!flag]->size)
{ // 情况2
SBT_Rotate(&(*t)->ch[flag], flag);
SBT_Rotate(t, !flag);
}
else
{ // 无需修复
return;
}
SBT_Maintain(&(*t)->ch[0], 0); // 修复左子树
SBT_Maintain(&(*t)->ch[1], 1); // 修复右子树
SBT_Maintain(t, 0); // 修复整棵树
SBT_Maintain(t, 1);
}
static INT32U SBT_Depth(sbt_node *t)
{
INT32U d[2];
if (t == &sbt_nil)
return 0;
d[0] = SBT_Depth(t->ch[0]);
d[1] = SBT_Depth(t->ch[1]);
if (d[0] > d[1])
return (d[0] + 1);
return (d[1] + 1);
}
// static INT32U SBT_Check(sbt_node* t) {
// if (((INT32U)t < 0xa0000000) || ((INT32U)t >= 0xa0800000))
// return RET_OS_HEAP_CORRUPTED;
// if (t == &sbt_nil)
// return RET_EXT_NO_ERROR;
// if (!SBT_Check(t->ch[0]))
// return RET_OS_HEAP_CORRUPTED;
// if (!SBT_Check(t->ch[1]))
// return RET_OS_HEAP_CORRUPTED;
// return RET_EXT_NO_ERROR;
// }
static int SBT_NodeCmp(sbt_node *x, BOOL yl, const char *ykey)
{
if ((x->tryLocal != 0) && (yl == 0))
return 1;
if ((x->tryLocal == 0) && (yl != 0))
return -1;
if (x->key == ykey) // 两者均为NULL返回0
return 0;
if (ykey == NULL) // 至少有一个不为NULL, y->key == NULL 则 x->key != NULL
return 1;
if (x->key == NULL)
return -1;
return strcmp(x->key, ykey);
}
static sbt_node *SBT_Search(sbt_node *t, BOOL local, const char *key)
{
// 在T中中寻找关键字为key的结点
// 若能找到则返回指向它的指针，否则返回NULL
int cmp;
if (t == &sbt_nil)
return NULL;
cmp = SBT_NodeCmp(t, local, key);
if (cmp == 0)
return t;
return SBT_Search(t->ch[cmp < 0], local, key);
}
static void SBT_Insert(sbt_node **t, sbt_node *x)
{
// 将节点x插入树中
if ((*t) == &sbt_nil)
{
(*t) = x;
}
else
{
int cmp = SBT_NodeCmp(x, (*t)->tryLocal, (*t)->key);
if (cmp == 0)
{
sbt_node *old = *t;
x->ch[0] = old->ch[0];
x->ch[1] = old->ch[1];
*t = x;
free_mt(old->key);
if (old->value != NULL)
free_mt(old->value);
free_mt(old);
}
else
{
(*t)->size++;
SBT_Insert(&(*t)->ch[cmp > 0], x);
SBT_Maintain(t, (cmp > 0));
}
}
}
static void SBT_Delete(sbt_node *t)
{
if (t == &sbt_nil)
return;
SBT_Delete(t->ch[0]);
SBT_Delete(t->ch[1]);
free_mt(t->key);
if (t->value != NULL)
free_mt(t->value);
}
/**
* ram缓存
*/
static sbt_node *CacheGet(property_provider *p, const char *store, const char *id, BOOL local, const char *key)
{
prop_cache *ptr;
sbt_node *node;
if ((p == NULL) || (store == NULL) || (*store == 0) || (key == NULL) || (*key == 0))
return NULL;
for (ptr = p->cache; ptr != NULL; ptr = ptr->next)
if ((strcmp(store, ptr->store) == 0) && ((((id == NULL) || (*id == 0)) && ((ptr->id == NULL) || (*ptr->id == 0))) || ((id != NULL) && (ptr->id != NULL) && (strcmp(id, ptr->id) == 0))))
break;
if (ptr == NULL)
return NULL;
node = SBT_Search(ptr->sbt, local, key);
if (node == NULL)
return NULL;
if (!node->valid)
return NULL;
return node;
}
static INT32U CacheSet(property_provider *p, const char *store, const char *id, BOOL tryLocal, const char *key, const char *value, BOOL isLocal)
{
prop_cache *ptr;
sbt_node *node;
INT32U keyLen, valLen;
if ((p == NULL) || (store == NULL) || (*store == 0) || (key == NULL) || (*key == 0))
return RET_OS_INVALID_PARAM;
node = (sbt_node *)malloc_mt(sizeof(sbt_node));
if (node == NULL)
return RET_PROPERTY_HEAP_FULL;
keyLen = strlen(key);
valLen = strlen(value);
node->ch[0] = &sbt_nil;
node->ch[1] = &sbt_nil;
node->valid = TRUE;
node->tryLocal = tryLocal;
node->isLocal = isLocal;
node->size = 1;
node->key = (char *)malloc_mt(keyLen + 1);
if (node->key == NULL)
{
free_mt(node);
return RET_PROPERTY_HEAP_FULL;
}
else
{
strncpy(node->key, key, keyLen);
node->key[keyLen] = 0;
}
if (value == NULL)
{
node->value = NULL;
}
else
{
node->value = (char *)malloc_mt(valLen + 1);
if (value == NULL)
{
free_mt(node->key);
free_mt(node);
return RET_PROPERTY_HEAP_FULL;
}
else
{
strncpy(node->value, value, valLen);
node->value[valLen] = 0;
}
}
for (ptr = p->cache; ptr != NULL; ptr = ptr->next)
if ((strcmp(store, ptr->store) == 0) && ((((id == NULL) || (*id == 0)) && ((ptr->id == NULL) || (*ptr->id == 0))) || ((id != NULL) && (ptr->id != NULL) && (strcmp(id, ptr->id) == 0))))
break;
if (ptr == NULL)
{
ptr = (prop_cache *)malloc_mt(sizeof(prop_cache));
if (ptr != NULL)
{
BOOL mallocErr = FALSE;
ptr->store = NULL;
ptr->id = NULL;
if ((id != NULL) && (*id != 0))
{
INT32U idLen = strlen(id);
ptr->id = (char *)malloc_mt(idLen + 1);
if (ptr->id == NULL)
{
mallocErr = TRUE;
}
else
{
strncpy(ptr->id, id, idLen);
ptr->id[idLen] = 0;
}
}
if (!mallocErr)
{
INT32U storeLen = strlen(store);
ptr->store = (char *)malloc_mt(storeLen + 1);
if (ptr->store == NULL)
{
mallocErr = TRUE;
}
else
{
strncpy(ptr->store, store, storeLen);
ptr->store[storeLen] = 0;
}
}
if (mallocErr)
{
if (ptr->store != NULL)
free_mt(ptr->store);
if (ptr->id != NULL)
free_mt(ptr->id);
free_mt(ptr);
ptr = NULL;
}
else
{
ptr->sbt = &sbt_nil;
ptr->next = p->cache;
p->cache = ptr;
}
}
}
if (ptr == NULL)
{
free_mt(node->key);
if (node->value != NULL)
free_mt(node->value);
free_mt(node);
return RET_PROPERTY_HEAP_FULL;
}
SBT_Insert(&ptr->sbt, node);
return RET_EXT_NO_ERROR;
}
static INT32U CacheInvalid(property_provider *p, const char *store, const char *id, BOOL tryLocal, const char *key)
{
prop_cache *ptr;
sbt_node *node;
if ((p == NULL) || (store == NULL) || (*store == 0) || (key == NULL) || (*key == 0))
return RET_OS_INVALID_PARAM;
for (ptr = p->cache; ptr != NULL; ptr = ptr->next)
if ((strcmp(store, ptr->store) == 0) && ((((id == NULL) || (*id == 0)) && ((ptr->id == NULL) || (*ptr->id == 0))) || ((id != NULL) && (ptr->id != NULL) && (strcmp(id, ptr->id) == 0))))
break;
if (ptr == NULL)
return RET_EXT_NO_ERROR;
node = SBT_Search(ptr->sbt, tryLocal, key);
if (node != NULL)
node->valid = FALSE;
return RET_EXT_NO_ERROR;
}
// store == NULL时清除全部cache
// store != NULL && id == NULL时清除store相关的全部cache
// store != NULL && id != NULL时清除(store, id)的cache
static INT32U CacheClear(property_provider *p, const char *store, const char *id)
{
if (p == NULL)
return NULL;
if ((store == NULL) || (*store == 0))
{
prop_cache *ptr;
for (ptr = p->cache; ptr != NULL;)
{
prop_cache *tmp = ptr;
ptr = ptr->next;
free_mt(tmp->store);
if (tmp->id != NULL)
free_mt(tmp->id);
SBT_Delete(tmp->sbt);
free_mt(tmp);
}
p->cache = NULL;
}
else if ((id == NULL) || (*id == 0))
{
prop_cache *ptr;
prop_cache *tail = NULL;
for (ptr = p->cache; ptr != NULL;)
{
if (strcmp(store, ptr->store) == 0)
{
prop_cache *tmp = ptr;
if (ptr == p->cache)
p->cache = ptr->next;
else
tail->next = ptr->next;
ptr = ptr->next;
free_mt(tmp->store);
if (tmp->id != NULL)
free_mt(tmp->id);
SBT_Delete(tmp->sbt);
free_mt(tmp);
}
else
{
tail = ptr;
ptr = ptr->next;
}
}
}
else
{
prop_cache *ptr;
prop_cache *tail = NULL;
for (ptr = p->cache; ptr != NULL; tail = ptr, ptr = ptr->next)
if ((strcmp(store, ptr->store) == 0) && ((ptr->id != NULL) && (strcmp(id, ptr->id) == 0)))
break;
if (ptr != NULL)
{
if (ptr == p->cache)
p->cache = ptr->next;
else
tail->next = ptr->next;
free_mt(ptr->store);
if (ptr->id != NULL)
free_mt(ptr->id);
SBT_Delete(ptr->sbt);
free_mt(ptr);
}
}
return RET_EXT_NO_ERROR;
}
static void CheckInit(void)
{
static INT8U init = 0;
prop_lock();
if (init == 0)
{
INT8U i;
for (i = 0; i < PROPERTY_PROVIDER_MAX; i++)
{
pp[i].flag.init = 0;
pp[i].flag.initPending = 0;
pp[i].flag.cache = 0;
pp[i].id = NULL;
pp[i].get = NULL;
pp[i].set = NULL;
pp[i].clear = NULL;
pp[i].cache = NULL;
pp[i].obj = NULL;
}
init = 1;
}
prop_unlock();
}
// key规则检查
static INT32U CheckKey(const char *key)
{
if ((key == NULL) || (*key == '\0'))
return RET_OS_INVALID_PARAM;
if (((key[0] >= 'a') && (key[0] <= 'z')) || ((key[0] >= 'A') && (key[0] <= 'Z')))
{
INT32U i;
for (i = 1; key[i] != '\0'; i++)
{
if (((key[i] >= 'a') && (key[i] <= 'z')) || ((key[i] >= 'A') && (key[i] <= 'Z')) || ((key[i] >= '0') && (key[i] <= '9')) || (key[i] == '-') || (key[i] == '_') || (key[i] == '.') || (key[i] == '[') || (key[i] == ']'))
continue;
return RET_PROPERTY_INVALID_KEY;
}
}
else
{
return RET_PROPERTY_INVALID_KEY;
}
// printf("key name is ok\n");
return RET_EXT_NO_ERROR;
}
// TODO:
INT32U PropertyInit(INT32U providerId, const PropertyInitParam *param)
{
INT32U ret = RET_EXT_NO_ERROR;
BOOL doInit = FALSE;
CheckInit();
if ((providerId >= PROPERTY_PROVIDER_MAX) || (param == NULL) || ((param->id != NULL) && (strlen(param->id) > PROPERTY_ID_MAX)))
return RET_OS_INVALID_PARAM;
#if 0 // 这段代码没必要存在 CheckInit()——>pp[providerId].flag.initPending=0
for (;;)
{
BOOL quit = FALSE;
prop_lock();
if (pp[providerId].flag.initPending == 0)
{
if (pp[providerId].flag.init == 0)
{
doInit = TRUE;
pp[providerId].flag.initPending = 1;
}
quit = TRUE;
}
prop_unlock();
if (quit)
break;
prop_wait(1000);
}
#else // 直接启动初始化
doInit = TRUE;
#endif
if (doInit)
{
char *id = NULL;
if ((ret == RET_EXT_NO_ERROR) && (param->id != NULL) && (*param->id != 0))
{
INT32U idLen = strlen(param->id);
id = (char *)malloc_mt(idLen + 1);
if (id == NULL)
{
ret = RET_PROPERTY_HEAP_FULL;
}
else
{
strncpy(id, param->id, idLen);
id[idLen] = 0;
}
}
if (ret == RET_EXT_NO_ERROR)
{
pp[providerId].id = id;
if (param->type == PropertyTypeFS)
{
#if ((defined PROPERTY_PROV_FS_EN) && (PROPERTY_PROV_FS_EN != 0))
// 锁初始化
prop_lock_init();
ret = FilePropertyInit(providerId, param);
#else
ret = RET_OS_NOT_IMPLEMENT;
#endif
}
else if (param->type == PropertyTypeRemote)
{
#if ((defined PROPERTY_PROV_REMOTE_EN) && (PROPERTY_PROV_REMOTE_EN != 0))
#if (defined RTOS_UCOS)
pp[providerId].sem = OSSemCreate(1);
if (pp[providerId].sem == NULL)
{
ret = RET_OS_NO_AVAILABLE_EVENT_CTRL_BLK;
}
else
{
#endif
ret = RemotePropertyInit(providerId, param);
#if (defined RTOS_UCOS)
if (ret != RET_EXT_NO_ERROR)
{
INT8U osErr = OS_ERR_NONE;
OSSemDel(pp[providerId].sem, OS_DEL_ALWAYS, &osErr);
pp[providerId].sem = NULL;
}
}
#endif
#else
ret = RET_OS_NOT_IMPLEMENT;
#endif
}
else
{
ret = RET_OS_INVALID_PARAM;
}
}
if (ret != RET_EXT_NO_ERROR)
{
if (id != NULL)
free_mt(id);
pp[providerId].id = NULL;
}
pp[providerId].flag.initPending = 0;
}
// PROP_ENABLE_IRQ();
return ret;
}
INT32U GetProperty(INT32U providerId, const char *store, const char *id, const char *key, BOOL tryLocal, char *value, INT32U sizeOfValue, BOOL *isLocal)
{
INT32U ret = RET_EXT_NO_ERROR;
sbt_node *node = NULL;
if ((providerId >= PROPERTY_PROVIDER_MAX) || (store == NULL) || (*store == 0) || (key == NULL) || (*key == 0) || (value == NULL) || (sizeOfValue == 0))
return RET_OS_INVALID_PARAM;
// 检查key命名规范
ret = CheckKey(key);
if (ret != RET_EXT_NO_ERROR)
return ret;
// 检查是否init
CheckInit();
if (pp[providerId].flag.init == 0)
return RET_PROPERTY_NOT_INIT;
if (pp[providerId].get == NULL)
return RET_PROPERTY_NOT_INIT;
if ((id == NULL) || (*id == 0))
id = pp[providerId].id;
if (tryLocal && ((id == NULL) || (*id == 0)))
return RET_PROPERTY_INVALID_STORE_ID;
// 加锁
prop_lock();
if (pp[providerId].flag.cache)
node = CacheGet(&pp[providerId], store, id, tryLocal, key);
if (node == NULL)
{
BOOL lt = TRUE;
ret = pp[providerId].get(store, key, (tryLocal ? id : NULL), value, sizeOfValue, &lt, pp[providerId].obj);
if (pp[providerId].flag.cache)
{
if (ret == RET_EXT_NO_ERROR)
CacheSet(&pp[providerId], store, id, tryLocal, key, value, lt);
else if (ret == RET_PROPERTY_NOT_FOUND)
CacheSet(&pp[providerId], store, id, tryLocal, key, NULL, lt);
}
if (isLocal != NULL)
*isLocal = lt;
}
else if (node->value == NULL)
{
ret = RET_PROPERTY_NOT_FOUND;
}
else
{
INT32U valLen = strlen(node->value);
if (valLen > sizeOfValue - 1)
{
valLen = sizeOfValue - 1;
ret = RET_PROPERTY_OUT_OF_VAL_BUF;
}
strncpy(value, node->value, valLen);
value[valLen] = 0;
if (isLocal != NULL)
*isLocal = node->isLocal;
}
prop_unlock();
return ret;
}
INT32U SetProperty(INT32U providerId, const char *store, const char *id, const char *key, const char *value)
{
PropertyItem item;
if ((providerId >= PROPERTY_PROVIDER_MAX) || (store == NULL) || (*store == 0) || (key == NULL) || (*key == 0))
return RET_OS_INVALID_PARAM;
CheckInit();
if (pp[providerId].flag.init == 0)
return RET_PROPERTY_NOT_INIT;
item.key = key;
if (value == NULL)
{
item.type = VT_NULL;
item.value.str = NULL;
}
else
{
item.type = VT_STR;
item.value.str = value;
}
item.success = 0;
return SetPropertyList(providerId, store, id, &item, 1);
}
INT32U SetPropertyList(INT32U providerId, const char *store, const char *id, PropertyItem *list, INT32U count)
{
INT32U ret = RET_EXT_NO_ERROR;
property_string_item *bufList;
char *stringList;
BOOL fpChked = FALSE;
INT32U idx;
if (providerId >= PROPERTY_PROVIDER_MAX)
return RET_OS_INVALID_PARAM;
CheckInit();
if (pp[providerId].flag.init == 0)
return RET_PROPERTY_NOT_INIT;
if (pp[providerId].set == NULL)
return RET_PROPERTY_NOT_INIT;
if ((id == NULL) || (*id == 0))
id = pp[providerId].id;
if ((id == NULL) || (*id == 0))
return RET_PROPERTY_INVALID_STORE_ID;
if (count == 0)
return RET_EXT_NO_ERROR;
bufList = (property_string_item *)malloc_mt(sizeof(property_string_item) * count);
stringList = ((bufList == NULL) ? NULL : (char *)malloc_mt((FLOAT_STRING_LEN + 1) * count));
if ((bufList == NULL) || (stringList == NULL))
{
if (bufList != NULL)
free_mt(bufList);
if (stringList != NULL)
free_mt(stringList);
return RET_PROPERTY_HEAP_FULL;
}
memset(stringList, 0, ((FLOAT_STRING_LEN + 1) * count));
for (idx = 0; idx < count; idx++)
{
ret = CheckKey(list[idx].key);
if (ret != RET_EXT_NO_ERROR)
break;
bufList[idx].key = list[idx].key;
switch (list[idx].type)
{
case VT_NULL:
bufList[idx].value = NULL;
break;
case VT_I4:
bufList[idx].value = &stringList[(FLOAT_STRING_LEN + 1) * idx];
snprintf(&stringList[(FLOAT_STRING_LEN + 1) * idx], FLOAT_STRING_LEN, "%d", list[idx].value.i4);
break;
case VT_I2:
bufList[idx].value = &stringList[(FLOAT_STRING_LEN + 1) * idx];
snprintf(&stringList[(FLOAT_STRING_LEN + 1) * idx], FLOAT_STRING_LEN, "%d", list[idx].value.i2);
break;
case VT_I1:
bufList[idx].value = &stringList[(FLOAT_STRING_LEN + 1) * idx];
snprintf(&stringList[(FLOAT_STRING_LEN + 1) * idx], FLOAT_STRING_LEN, "%d", list[idx].value.i1);
break;
case VT_UI4:
bufList[idx].value = &stringList[(FLOAT_STRING_LEN + 1) * idx];
snprintf(&stringList[(FLOAT_STRING_LEN + 1) * idx], FLOAT_STRING_LEN, "0x%08x", list[idx].value.ui4);
break;
case VT_UI2:
bufList[idx].value = &stringList[(FLOAT_STRING_LEN + 1) * idx];
snprintf(&stringList[(FLOAT_STRING_LEN + 1) * idx], FLOAT_STRING_LEN, "0x%08x", list[idx].value.ui2);
break;
case VT_UI1:
bufList[idx].value = &stringList[(FLOAT_STRING_LEN + 1) * idx];
snprintf(&stringList[(FLOAT_STRING_LEN + 1) * idx], FLOAT_STRING_LEN, "0x%08x", list[idx].value.ui1);
break;
case VT_R4:
if (!fpChked)
{
char str[10];
snprintf(str, sizeof(str), "%e", PI);
if (strncmp(str, "3.14159", strlen("3.14159")) == 0)
fpChked = TRUE;
else
ret = RET_OS_FLOAT_TEST_FAILED;
}
if (ret == RET_EXT_NO_ERROR)
{
bufList[idx].value = &stringList[(FLOAT_STRING_LEN + 1) * idx];
snprintf(&stringList[(FLOAT_STRING_LEN + 1) * idx], FLOAT_STRING_LEN, "%e", ((isfinite(list[idx].value.r4) || isinf(list[idx].value.r4)) ? list[idx].value.r4 : NAN));
}
break;
case VT_STR:
bufList[idx].value = list[idx].value.str;
break;
case VT_BIT4:
bufList[idx].value = &stringList[(FLOAT_STRING_LEN + 1) * idx];
snprintf(&stringList[(FLOAT_STRING_LEN + 1) * idx], FLOAT_STRING_LEN, "0x%08x", ((GetUnsigned(providerId, store, list[idx].key, TRUE, 0, NULL, NULL) & (~list[idx].value.bit4.mask)) | (list[idx].value.bit4.val & list[idx].value.bit4.mask)));
break;
}
if (ret != RET_EXT_NO_ERROR)
break;
bufList[idx].success = 0;
}
prop_lock();
if (ret == RET_EXT_NO_ERROR)
{
if (ret == RET_EXT_NO_ERROR)
ret = pp[providerId].set(store, id, bufList, count, pp[providerId].obj);
if (ret == RET_EXT_NO_ERROR)
{
for (idx = 0; idx < count; idx++)
{
if ((bufList[idx].value == NULL) || (CacheSet(&pp[providerId], store, id, TRUE, bufList[idx].key, bufList[idx].value, TRUE) != RET_EXT_NO_ERROR))
CacheInvalid(&pp[providerId], store, id, TRUE, bufList[idx].key);
}
}
}
prop_unlock();
free_mt(bufList);
free_mt(stringList);
return ret;
}
INT32S GetInteger(INT32U providerId, const char *store, const char *key, BOOL tryLocal, INT32S defaultValue, INT32U *retCode, BOOL *isLocal)
{
char result[PROPERTY_LINE_MAX + 1];
INT32U ret = GetProperty(providerId, store, NULL, key, tryLocal, result, sizeof(result), isLocal);
INT32S val = 0;
if (ret == RET_EXT_NO_ERROR)
{
char *endptr = NULL;
val = strtol(result, &endptr, 0);
if (endptr == result)
{
ret = RET_PROPERTY_EFORMAT;
}
else
{
for (; ((*endptr == ' ') || (*endptr == '\t')); endptr++)
;
if (*endptr != 0)
ret = RET_PROPERTY_EFORMAT;
else if ((errno == ERANGE) && ((val == LONG_MIN) || (val == LONG_MAX)))
ret = RET_PROPERTY_ERANGE;
}
}
if (ret != RET_EXT_NO_ERROR)
val = defaultValue;
if (retCode != NULL)
*retCode = ret;
return val;
}
INT32U GetUnsigned(INT32U providerId, const char *store, const char *key, BOOL tryLocal, INT32U defaultValue, INT32U *retCode, BOOL *isLocal)
{
char result[PROPERTY_LINE_MAX + 1];
INT32U ret = GetProperty(providerId, store, NULL, key, tryLocal, result, sizeof(result), isLocal);
INT32U val = 0;
if (ret == RET_EXT_NO_ERROR)
{
char *endptr = NULL;
val = strtoul(result, &endptr, 0);
if (endptr == result)
{
ret = RET_PROPERTY_EFORMAT;
}
else
{
for (; ((*endptr == ' ') || (*endptr == '\t')); endptr++)
;
if (*endptr != 0)
ret = RET_PROPERTY_EFORMAT;
else if ((errno == ERANGE) && (val == ULONG_MAX))
ret = RET_PROPERTY_ERANGE;
}
}
if (ret != RET_EXT_NO_ERROR)
val = defaultValue;
if (retCode != NULL)
*retCode = ret;
return val;
}
FP32 GetFloat(INT32U providerId, const char *store, const char *key, BOOL tryLocal, FP32 defaultValue, INT32U *retCode, BOOL *isLocal)
{
char result[PROPERTY_LINE_MAX + 1];
INT32U ret = GetProperty(providerId, store, NULL, key, tryLocal, result, sizeof(result), isLocal);
FP32 val = FP_ZERO;
if (ret == RET_EXT_NO_ERROR)
{
char *endptr = NULL;
val = strtof(result, &endptr);
if (!isfinite(val) && !isinf(val))
{
ret = RET_PROPERTY_EFORMAT;
}
else if (endptr == result)
{
ret = RET_PROPERTY_EFORMAT;
}
else
{
for (; ((*endptr == ' ') || (*endptr == '\t')); endptr++)
;
if (*endptr != 0)
ret = RET_PROPERTY_EFORMAT;
else if ((errno == ERANGE) && isinf(val))
ret = RET_PROPERTY_ERANGE;
}
}
if (ret != RET_EXT_NO_ERROR)
val = defaultValue;
if (retCode != NULL)
*retCode = ret;
return val;
}
BOOL GetBoolean(INT32U providerId, const char *store, const char *key, BOOL tryLocal, BOOL defaultValue, INT32U *retCode, BOOL *isLocal)
{
INT32U i;
char result[PROPERTY_LINE_MAX + 1];
INT32U ret = GetProperty(providerId, store, NULL, key, tryLocal, result, sizeof(result), isLocal);
BOOL val = defaultValue;
if (ret == RET_EXT_NO_ERROR)
{
for (i = 0; ((i < sizeof(result)) && (result[i] != '\0')); i++)
if ((result[i] >= 'A') && (result[i] <= 'Z'))
result[i] += ('a' - 'A');
if ((strcmp("true", result) == 0) || (strcmp("yes", result) == 0) || (strcmp("1", result) == 0))
{
val = TRUE;
}
else if ((strcmp("false", result) == 0) || (strcmp("no", result) == 0) || (strcmp("0", result) == 0))
{
val = FALSE;
}
else
{
ret = RET_PROPERTY_EFORMAT;
}
}
if (ret != RET_EXT_NO_ERROR)
val = defaultValue;
if (retCode != NULL)
*retCode = ret;
return val;
}
INT32U SetInteger(INT32U providerId, const char *store, const char *key, INT32S value)
{
PropertyItem item;
if ((providerId >= PROPERTY_PROVIDER_MAX) || (store == NULL) || (*store == 0) || (key == NULL) || (*key == 0))
return RET_OS_INVALID_PARAM;
CheckInit();
if (pp[providerId].flag.init == 0)
return RET_PROPERTY_NOT_INIT;
item.key = key;
item.type = VT_I4;
item.value.i4 = value;
item.success = 0;
return SetPropertyList(providerId, store, NULL, &item, 1);
}
INT32U SetUnsigned(INT32U providerId, const char *store, const char *key, INT32U value)
{
PropertyItem item;
if ((providerId >= PROPERTY_PROVIDER_MAX) || (store == NULL) || (*store == 0) || (key == NULL) || (*key == 0))
return RET_OS_INVALID_PARAM;
CheckInit();
if (pp[providerId].flag.init == 0)
return RET_PROPERTY_NOT_INIT;
item.key = key;
item.type = VT_UI4;
item.value.ui4 = value;
item.success = 0;
return SetPropertyList(providerId, store, NULL, &item, 1);
}
INT32U SetFloat(INT32U providerId, const char *store, const char *key, FP32 value)
{
PropertyItem item;
if ((providerId >= PROPERTY_PROVIDER_MAX) || (store == NULL) || (*store == 0) || (key == NULL) || (*key == 0))
return RET_OS_INVALID_PARAM;
CheckInit();
if (pp[providerId].flag.init == 0)
return RET_PROPERTY_NOT_INIT;
item.key = key;
item.type = VT_R4;
item.value.r4 = value;
item.success = 0;
return SetPropertyList(providerId, store, NULL, &item, 1);
}
INT32U SetBits(INT32U providerId, const char *store, const char *key, INT32U value, INT32U mask)
{
PropertyItem item;
if ((providerId >= PROPERTY_PROVIDER_MAX) || (store == NULL) || (*store == 0) || (key == NULL) || (*key == 0))
return RET_OS_INVALID_PARAM;
CheckInit();
if (pp[providerId].flag.init == 0)
return RET_PROPERTY_NOT_INIT;
if (mask == 0)
return RET_EXT_NO_ERROR;
item.key = key;
item.type = VT_BIT4;
item.value.bit4.val = value;
item.value.bit4.mask = mask;
item.success = 0;
return SetPropertyList(providerId, store, NULL, &item, 1);
}
INT32U ClearPropertyCache(INT32U providerId, const char *store, const char *id)
{
INT32U ret = RET_EXT_NO_ERROR;
if (providerId >= PROPERTY_PROVIDER_MAX)
return RET_OS_INVALID_PARAM;
CheckInit();
if (pp[providerId].flag.init == 0)
return RET_PROPERTY_NOT_INIT;
if (pp[providerId].clear == NULL)
return RET_EXT_NO_ERROR;
if ((id == NULL) || (*id == 0))
id = pp[providerId].id;
if ((id == NULL) || (*id == 0))
id = NULL;
prop_lock();
CacheClear(&pp[providerId], store, id);
ret = pp[providerId].clear(store, id, pp[providerId].obj);
prop_unlock();
return ret;
}
INT32U SetPropertyTestCase(INT32U caseId)
{
if (caseId == 1)
file_test_random = 1; // 随机数设为非0表示启用测试, 也可以设成其他非0值, 该值在测试过程中会被随机更新
else
file_test_random = 0; // 随机数设为0表示禁用测试, 不会再被更新
return RET_EXT_NO_ERROR;
}
// INT32U VerifyPropertyCache(INT32U providerId) {
// INT32U ret = RET_EXT_NO_ERROR;
// prop_cache* ptr;
// #if (defined RTOS_UCOS)
// INT8U osErr = OS_ERR_NONE;
// #endif
//
// if (providerId >= PROPERTY_PROVIDER_MAX)
// return RET_OS_INVALID_PARAM;
// CheckInit();
// if (pp[providerId].flag.init == 0)
// return RET_PROPERTY_NOT_INIT;
//
// #if (defined RTOS_UCOS)
// OSSemPend(pp[providerId].sem, OSmsToTick(1000UL), &osErr);
// if (osErr != OS_ERR_NONE)
// return RET_OS_SYNC_OBJ_FAILED;
// #elif ((defined TARGET_LPC11XX) || (defined TARGET_STM32F1))
// PROP_DISABLE_IRQ();
// if (pp[providerId].flag.lock != 0)
// ret = RET_OS_SYNC_OBJ_FAILED;
// else
// pp[providerId].flag.lock = 1;
// PROP_ENABLE_IRQ();
// if (ret != RET_EXT_NO_ERROR)
// return ret;
// #else
// #error "Target error"
// #endif
//
// for (ptr = pp[providerId].cache; ptr != NULL; ptr = ptr->next) {
// if (((INT32U)ptr < 0xa0000000) || ((INT32U)ptr >= 0xa0800000)) {
// ret = RET_OS_HEAP_CORRUPTED;
// break;
// }
// ret = SBT_Check(ptr->sbt);
// if (ret != RET_EXT_NO_ERROR)
// break;
// }
//
// PROP_UNLOCK(pp[providerId]);
//
// return ret;
//}
#if ((defined PROPERTY_PROV_FS_EN) && (PROPERTY_PROV_FS_EN != 0))
/**************************************************************
* File property provider
*************************************************************
*/
typedef struct _fileprop_cache
{
char *key;
char *value;
INT32U size;
struct _fileprop_cache *next;
} fileprop_cache;
typedef struct _file_cache
{
BOOL allCache;
char *store;
char *id;
fileprop_cache *cache;
struct _file_cache *next;
} file_cache;
typedef struct
{
#if (!defined RTOS_UCOS) && ((defined TARGET_LPC11XX) || (defined TARGET_STM32F1))
struct
{
INT8U lock : 1;
} flag;
#endif
struct
{
INT8U cache : 1;
INT8U prefetch : 1;
} config;
#if (defined RTOS_UCOS)
OS_EVENT *sem;
#endif
file_cache *cache;
struct
{
INT32U flag;
#if 1
FILE *fil;
FILE *tmp;
#endif
} stream;
} file_provider;
#define STREAM_FLAG_FOPEN (1UL << 0)
static INT32U FileCacheGet(file_cache **head, const char *store, const char *id, const char *key, char *value, INT32U size, BOOL *isNull)
{
file_cache *fc;
fileprop_cache *pc;
for (fc = *head; fc != NULL; fc = fc->next)
{
if ((strcmp(store, fc->store) == 0) && ((((id == NULL) || (*id == 0)) && ((fc->id == NULL) || (*fc->id == 0))) || ((id != NULL) && (fc->id != NULL) && (strcmp(id, fc->id) == 0))))
break;
}
if (fc == NULL)
return RET_PROPERTY_NOT_FOUND;
*isNull = TRUE;
for (pc = fc->cache; pc != NULL; pc = pc->next)
{
if (strcmp(key, pc->key) == 0)
{
INT32U ret = RET_EXT_NO_ERROR;
if (pc->value != NULL)
{
INT32U cpLen = pc->size;
if (cpLen > size - 1)
{
cpLen = size - 1;
ret = RET_PROPERTY_OUT_OF_VAL_BUF;
}
*isNull = FALSE;
strncpy(value, pc->value, cpLen);
value[cpLen] = 0;
}
return ret;
}
}
if (fc->allCache)
return RET_EXT_NO_ERROR;
return RET_PROPERTY_NOT_FOUND;
}
static INT32U FileCacheTouch(file_cache **head, const char *store, const char *id, BOOL allCache, file_cache **found)
{
INT32U ret = RET_EXT_NO_ERROR;
file_cache *fc;
for (fc = *head; fc != NULL; fc = fc->next)
{
if ((strcmp(store, fc->store) == 0) && ((((id == NULL) || (*id == 0)) && ((fc->id == NULL) || (*fc->id == 0))) || ((id != NULL) && (fc->id != NULL) && (strcmp(id, fc->id) == 0))))
break;
}
if (fc == NULL)
{
BOOL fail = FALSE;
fc = (file_cache *)malloc_mt(sizeof(file_cache));
if (fc == NULL)
fail = TRUE;
else
memset(fc, 0, sizeof(file_cache));
if (!fail)
{
INT32U lenStore = strlen(store);
fc->store = (char *)malloc_mt(lenStore + 1);
if (fc->store == NULL)
{
fail = TRUE;
}
else
{
strncpy(fc->store, store, lenStore);
fc->store[lenStore] = 0;
}
}
if (!fail && (id != NULL) && (*id != 0))
{
INT32U lenId = strlen(id);
fc->id = (char *)malloc_mt(lenId + 1);
if (fc->id == NULL)
{
fail = TRUE;
}
else
{
strncpy(fc->id, id, lenId);
fc->id[lenId] = 0;
}
}
if (fail)
{
if (fc != NULL)
{
if (fc->store != NULL)
free_mt(fc->store);
if (fc->id != NULL)
free_mt(fc->id);
free_mt(fc);
fc = NULL;
}
ret = RET_PROPERTY_HEAP_FULL;
}
else
{
fc->allCache = allCache;
fc->next = *head;
*head = fc;
}
}
if (found != NULL)
*found = fc;
return ret;
}
static INT32U FileCacheSet(file_cache **head, const char *store, const char *id, const char *key, const char *value, BOOL allCache)
{
INT32U ret = RET_EXT_NO_ERROR;
file_cache *fc = NULL;
ret = FileCacheTouch(head, store, id, allCache, &fc);
if ((ret == RET_EXT_NO_ERROR) && (fc != NULL))
{
fileprop_cache *pc;
fileprop_cache *ptail = NULL;
for (pc = fc->cache; pc != NULL; ptail = pc, pc = pc->next)
{
if (strcmp(key, pc->key) == 0)
break;
}
if (pc == NULL)
{
BOOL fail = FALSE;
pc = (fileprop_cache *)malloc_mt(sizeof(fileprop_cache));
if (pc == NULL)
fail = TRUE;
else
memset(pc, 0, sizeof(fileprop_cache));
if (!fail)
{
INT32U keyLen = strlen(key);
pc->key = (char *)malloc_mt(keyLen + 1);
if (pc->key == NULL)
{
fail = TRUE;
}
else
{
strncpy(pc->key, key, keyLen);
pc->key[keyLen] = 0;
}
}
if (!fail && (value != NULL))
{
pc->size = strlen(value);
pc->value = (char *)malloc_mt(pc->size + 1);
if (pc->value == NULL)
{
fail = TRUE;
}
else
{
strncpy(pc->value, value, pc->size);
pc->value[pc->size] = 0;
}
}
if (fail)
{
if (pc != NULL)
{
if (pc->key != NULL)
free_mt(pc->key);
if (pc->value != NULL)
free_mt(pc->value);
free_mt(pc);
pc = NULL;
}
fc->allCache = FALSE;
ret = RET_PROPERTY_HEAP_FULL;
}
else
{
pc->next = fc->cache;
fc->cache = pc;
}
}
else
{
BOOL alloc = FALSE;
if (value == NULL)
{
free_mt(pc->key);
if (pc->value != NULL)
free_mt(pc->value);
if (pc == fc->cache)
fc->cache = pc->next;
else
ptail->next = pc->next;
free_mt(pc);
}
else if (pc->value == NULL)
{
alloc = TRUE;
}
else if (pc->size >= strlen(value))
{
strncpy(pc->value, value, strlen(value));
}
else
{
if (pc->value != NULL)
free_mt(pc->value);
pc->value = NULL;
pc->size = 0;
alloc = TRUE;
}
if (alloc)
{
pc->size = strlen(value);
pc->value = (char *)malloc_mt(pc->size + 1);
if (pc->value == NULL)
{
free_mt(pc->key);
if (pc == fc->cache)
fc->cache = pc->next;
else
ptail->next = pc->next;
free_mt(pc);
fc->allCache = FALSE;
ret = RET_PROPERTY_HEAP_FULL;
}
else
{
strncpy(pc->value, value, pc->size);
pc->value[pc->size] = 0;
}
}
}
}
return ret;
}
static INT32U FileCacheClearLinkList(fileprop_cache *ptr)
{
for (; ptr != NULL;)
{
fileprop_cache *tmp = ptr;
ptr = ptr->next;
free_mt(tmp->key);
if (tmp->value != NULL)
free_mt(tmp->value);
free_mt(tmp);
}
return RET_EXT_NO_ERROR;
}
static INT32U FileCacheClear(file_cache **head, const char *store, const char *id)
{
file_cache *fc;
if ((store == NULL) || (*store == 0))
{
for (fc = *head; fc != NULL;)
{
file_cache *tmp = fc;
fc = fc->next;
FileCacheClearLinkList(tmp->cache);
free_mt(tmp->store);
if (tmp->id != NULL)
free_mt(tmp->id);
free_mt(tmp);
}
*head = NULL;
}
else if ((id == NULL) || (*id == 0))
{
file_cache *ftail = NULL;
for (fc = *head; fc != NULL;)
{
if (strcmp(store, fc->store) == 0)
{
file_cache *del = fc;
FileCacheClearLinkList(fc->cache);
free_mt(fc->store);
if (fc->id != NULL)
free_mt(fc->id);
if (fc == *head)
*head = fc->next;
else
ftail->next = fc->next;
fc = fc->next;
free_mt(del);
}
else
{
ftail = fc;
fc = fc->next;
}
}
}
else
{
file_cache *ftail = NULL;
for (fc = *head; fc != NULL; ftail = fc, fc = fc->next)
{
if ((strcmp(store, fc->store) == 0) && ((fc->id != NULL) && (strcmp(id, fc->id) == 0)))
break;
}
if (fc != NULL)
{
FileCacheClearLinkList(fc->cache);
free_mt(fc->store);
if (fc->id != NULL)
free_mt(fc->id);
if (fc == *head)
*head = fc->next;
else
ftail->next = fc->next;
free_mt(fc);
}
}
return RET_EXT_NO_ERROR;
}
static INT32U INT32U2err(INT32U fres)
{
#if 0
switch (fres)
{
case FR_OK:
return RET_EXT_NO_ERROR;
case FR_DISK_ERR:
return RET_FILE_FR_DISK_ERR;
case FR_INT_ERR:
return RET_FILE_FR_INT_ERR;
case FR_NOT_READY:
return RET_FILE_FR_NOT_READY;
case FR_NO_FILE:
return RET_FILE_FR_NO_FILE;
case FR_NO_PATH:
return RET_FILE_FR_NO_PATH;
case FR_INVALID_NAME:
return RET_FILE_FR_INVALID_NAME;
case FR_DENIED:
return RET_FILE_FR_DENIED;
case FR_EXIST:
return RET_FILE_FR_EXIST;
case FR_INVALID_OBJECT:
return RET_FILE_FR_INVALID_OBJECT;
case FR_WRITE_PROTECTED:
return RET_FILE_FR_WRITE_PROTECTED;
case FR_INVALID_DRIVE:
return RET_FILE_FR_INVALID_DRIVE;
case FR_NOT_ENABLED:
return RET_FILE_FR_NOT_ENABLED;
case FR_NO_FILESYSTEM:
return RET_FILE_FR_NO_FILESYSTEM;
case FR_MKFS_ABORTED:
return RET_FILE_FR_MKFS_ABORTED;
case FR_TIMEOUT:
return RET_FILE_FR_TIMEOUT;
// case FR_LOCKED:
// return RET_FILE_FR_LOCKED;
// case FR_NOT_ENOUGH_CORE:
// return RET_FILE_FR_NOT_ENOUGH_CORE;
// case FR_TOO_MANY_OPEN_FILES:
// return RET_FILE_FR_TOO_MANY_OPEN_FILES;
// case FR_INVALID_PARAMETER:
// return RET_FILE_FR_INVALID_PARAMETER;
}
return RET_FILE_UNKNOWN;
#else
return 0;
#endif
}
static void FILE_TEST_RANDOM(INT8U max)
{
if ((file_test_random > 0) && (max > 0))
{
file_test_random = (rand() % max) + 1;
printf("[TEST] file_test_random = %d", file_test_random);
}
}
static void FILE_TEST_RESET(INT8U num)
{
#if 0
if (file_test_random == num)
{
printf("[TEST] swReset() called. file_test_random = %d", file_test_random);
swReset();
}
#endif
}
static INT32U f_copy(const char *src, const char *dest)
{
#if 0
FIL filSrc, filDest;
INT32U fres;
BYTE *buf;
INT32U ret = RET_EXT_NO_ERROR;
fres = f_open(&filSrc, src, FA_OPEN_EXISTING | FA_READ);
if (fres != FR_OK)
return INT32U2err(fres);
fres = f_open(&filDest, dest, FA_CREATE_ALWAYS | FA_WRITE);
if (fres != FR_OK)
{
f_close(&filSrc);
return INT32U2err(fres);
}
buf = malloc_mt(COPY_BUF_SIZE);
if (buf == NULL)
{
f_close(&filSrc);
f_close(&filDest);
return RET_OS_HEAP_FULL;
}
for (;;)
{
INT32U rsize, wsize;
fres = f_read(&filSrc, buf, COPY_BUF_SIZE, &rsize);
if (fres != FR_OK)
{
ret = INT32U2err(fres);
break;
}
if (rsize == 0)
break;
fres = f_write(&filDest, buf, rsize, &wsize);
if (rsize != wsize)
{
ret = RET_FILE_DISK_FULL;
break;
}
if (fres != FR_OK)
{
ret = INT32U2err(fres);
break;
}
}
free_mt(buf);
f_close(&filSrc);
f_close(&filDest);
return ret;
#else
return 0;
#endif
}
static INT32U PropWriteLogClear(INT32U providerId)
{
#if 0
INT32U fres;
char logname[PROPERTY_STORE_MAX + PROPERTY_ID_MAX + 16];
snprintf(logname, sizeof(logname), UPDATE_LOG, providerId);
fres = f_unlink(logname);
if ((fres != FR_OK) && (fres != FR_NO_FILE) && (fres != FR_NO_PATH))
return RET_PROPERTY_FILE_WRITE_ERR;
return RET_EXT_NO_ERROR;
#else
return 0;
#endif
}
static INT32U PropWriteLogWrite(INT32U providerId, const char *path)
{
#if 0
FIL fil;
INT32U fres;
char logname[PROPERTY_STORE_MAX + PROPERTY_ID_MAX + 16];
INT32U wsize;
if (path == NULL)
return RET_OS_INVALID_PARAM;
snprintf(logname, sizeof(logname), UPDATE_LOG, providerId);
fres = f_open(&fil, logname, FA_CREATE_ALWAYS | FA_WRITE);
if (fres != FR_OK)
return INT32U2err(fres);
fres = f_write(&fil, path, strlen(path), &wsize);
f_close(&fil);
if ((fres == FR_OK) && (wsize != strlen(path)))
return RET_FILE_DISK_FULL;
return INT32U2err(fres);
#else
return 0;
#endif
}
static INT32U PropWriteLogLoad(INT32U providerId, char *path, INT32U size)
{
#if 0
FIL fil;
INT32U fres;
INT32U rsize = 0;
INT32U i;
char logname[PROPERTY_STORE_MAX + PROPERTY_ID_MAX + 16];
if (path == NULL || size == 0)
return RET_OS_INVALID_PARAM;
path[0] = '\0';
snprintf(logname, sizeof(logname), UPDATE_LOG, providerId);
fres = f_open(&fil, logname, FA_OPEN_EXISTING | FA_READ);
if ((fres == FR_NO_FILE) || (fres == FR_NO_PATH))
return RET_EXT_NO_ERROR;
if (fres != FR_OK)
return INT32U2err(fres);
fres = f_read(&fil, path, size, &rsize);
f_close(&fil);
if (rsize == size)
path[size - 1] = '\0';
for (i = 0; path[i] != '\0'; i++)
if (path[i] == '\r' || path[i] == '\n')
{
path[i] = '\0';
break;
}
if (fres == FR_OK)
{
char filetmp[PROPERTY_STORE_MAX + PROPERTY_ID_MAX + 16];
snprintf(filetmp, sizeof(filetmp), "%s.tmp", path);
fres = f_open(&fil, filetmp, FA_OPEN_EXISTING | FA_READ);
f_close(&fil);
if ((fres == FR_NO_FILE) || (fres == FR_NO_PATH))
{
fres = FR_OK;
path[0] = '\0';
}
}
if (fres != FR_OK)
path[0] = '\0';
return INT32U2err(fres);
#else
return 0;
#endif
}
static INT32U PropWriteLogCommit(INT32U providerId, const char *filename)
{
#if 0
INT32U ret = RET_EXT_NO_ERROR;
INT32U fres;
char filetmp[PROPERTY_STORE_MAX + PROPERTY_ID_MAX + 16];
snprintf(filetmp, sizeof(filetmp), "%s.tmp", filename);
FILE_TEST_RESET(1);
fres = f_unlink(filename);
if ((fres != FR_OK) && (fres != FR_NO_FILE) && (fres != FR_NO_PATH))
ret = RET_PROPERTY_FILE_WRITE_ERR;
FILE_TEST_RESET(2);
if (ret == RET_EXT_NO_ERROR)
ret = f_copy(filetmp, filename);
FILE_TEST_RESET(3);
if (ret == RET_EXT_NO_ERROR)
ret = PropWriteLogClear(providerId);
FILE_TEST_RESET(4);
if (ret == RET_EXT_NO_ERROR)
{
INT32U fres = f_unlink(filetmp);
if ((fres != FR_OK) && (fres != FR_NO_FILE) && (fres != FR_NO_PATH))
ret = RET_PROPERTY_FILE_WRITE_ERR;
}
FILE_TEST_RESET(5);
return ret;
#else
return 0;
#endif
}
#if (((defined DISTRIBUTION) || (PROPERTY_CHECKSUM_ENABLED != 0)) && (PROPERTY_CHECKSUM_DISABLED == 0))
static void FormatSHA1sum(char *buf, INT32U lenOfBuf, INT8U *sig, INT32U lenOfSig)
{
INT8U i = 0;
for (i = 0; i < lenOfSig; i++)
snprintf(&buf[i << 1], (lenOfBuf - (i << 1)), "%02x", sig[i]);
buf[lenOfBuf - 1] = '\0';
}
#endif
// TODO:启用sha校验
static INT32U FileStreamChecksum(const char *filename)
{
#if (((defined DISTRIBUTION) || (PROPERTY_CHECKSUM_ENABLED != 0)) && (PROPERTY_CHECKSUM_DISABLED == 0))
FIL fil;
INT8U buf[128];
INT8U hash[32];
char sigStr[sizeof(hash) * 2 + 1];
char sigName[PROPERTY_STORE_MAX + 20];
sha2_context ctx;
INT32U fres;
INT32U br;
INT32U ret = RET_EXT_NO_ERROR;
if ((filename == NULL) || (*filename == 0))
return RET_EXT_NO_ERROR;
fres = f_open(&fil, filename, FA_OPEN_EXISTING | FA_READ);
if ((fres == FR_NO_FILE) || (fres == FR_NO_PATH))
return RET_EXT_NO_ERROR;
if (fres != FR_OK)
return RET_PROPERTY_INVALID_SIGNATURE; // RET_PROPERTY_FILE_OPEN_ERR
sha2_starts(&ctx, 0);
// TODO: 加入其他信息校验信息
for (;;)
{
if (f_read(&fil, buf, sizeof(buf), &br) != FR_OK)
{
ret = RET_PROPERTY_INVALID_SIGNATURE; // RET_PROPERTY_FILE_READ_ERR
break;
}
if (br == 0)
break;
// TODO: 加入加密算法
sha2_update(&ctx, buf, br);
}
f_close(&fil);
sha2_finish(&ctx, hash);
if (ret != RET_EXT_NO_ERROR)
return ret;
snprintf(sigName, sizeof(sigName), "%s.sig", filename);
fres = f_open(&fil, sigName, FA_OPEN_EXISTING | FA_READ);
if (fres != FR_OK)
return RET_PROPERTY_INVALID_SIGNATURE;
if ((f_read(&fil, sigStr, (sizeof(hash) * 2), &br) != FR_OK) || (br != (sizeof(hash) * 2)))
ret = RET_PROPERTY_INVALID_SIGNATURE;
f_close(&fil);
sigStr[sizeof(hash) * 2] = '\0';
if (ret == RET_EXT_NO_ERROR)
{
char hashStr[sizeof(hash) * 2 + 1];
FormatSHA1sum(hashStr, sizeof(hashStr), hash, sizeof(hash));
if (strcmp(hashStr, sigStr) != 0)
ret = RET_PROPERTY_INVALID_SIGNATURE;
}
return ret;
#else
return RET_EXT_NO_ERROR;
#endif
}
static INT32U FileStreamOpen(const char *filename, file_provider *fp)
{
#if 0
INT32U ret = RET_EXT_NO_ERROR;
INT32U fres;
if ((filename == NULL) || (*filename == 0) || (fp == NULL))
return RET_OS_INVALID_PARAM;
fp->stream.flag = 0;
fres = f_open(&fp->stream.fil, filename, FA_OPEN_EXISTING | FA_READ);
if (fres == FR_OK)
{
fp->stream.flag |= STREAM_FLAG_FOPEN;
}
else if ((fres != FR_NO_FILE) && (fres != FR_NO_PATH))
{
ret = RET_PROPERTY_FILE_OPEN_ERR;
}
return ret;
#else
INT32U ret = RET_EXT_NO_ERROR;
INT32U fres;
if ((filename == NULL) || (*filename == 0) || (fp == NULL))
return RET_OS_INVALID_PARAM;
fp->stream.flag = 0;
fp->stream.fil = fopen(filename, "r");
// printf("file name : %s\n",filename);
if (fp->stream.fil != NULL)
{
// printf("file read ok \n");
// 读取到文件了
fp->stream.flag |= STREAM_FLAG_FOPEN;
}
else
{
ret = RET_PROPERTY_FILE_OPEN_ERR;
}
return ret;
#endif
}
static INT32U FileStreamClose(file_provider *fp)
{
#if 0
if (fp == NULL)
return RET_OS_INVALID_PARAM;
if ((fp->stream.flag & STREAM_FLAG_FOPEN) != 0)
f_close(&fp->stream.fil);
fp->stream.flag = 0;
return RET_EXT_NO_ERROR;
#else
// 指针检查
if (fp == NULL)
return RET_OS_INVALID_PARAM;
// 关闭文件
if ((fp->stream.flag & STREAM_FLAG_FOPEN) != 0)
fclose(fp->stream.fil);
fp->stream.fil = NULL;
fp->stream.flag = 0;
return 0;
#endif
}
static INT32U FileStreamGet(char *ch, file_provider *fp)
{
#if 0
if ((ch == NULL) || (fp == NULL))
return RET_OS_INVALID_PARAM;
if ((fp->stream.flag & STREAM_FLAG_FOPEN) == 0)
{
*ch = 0;
}
else
{
INT32U br;
if (f_read(&fp->stream.fil, ch, 1, &br) != FR_OK)
return RET_PROPERTY_FILE_READ_ERR;
if (br == 0)
*ch = 0;
}
return RET_EXT_NO_ERROR;
#else
// 指针检查
if ((ch == NULL) || (fp == NULL))
return RET_OS_INVALID_PARAM;
// 检查下文件是否打开
if ((fp->stream.flag & STREAM_FLAG_FOPEN) == 0)
{
// ch = 0 的话，后续程序会直接退出
*ch = 0;
}
else
{
*ch = fgetc(fp->stream.fil);
// 检查是是否读取错误
if (ferror(fp->stream.fil) != 0)
{
*ch = 0;
}
}
return 0;
#endif
}
static INT32U FileStreamParseLine(BOOL *eof, BOOL *valid, char *lineBuffer, INT32U bufferSize, INT32U *keyIndex, INT32U *keyLen, INT32U *valIndex, INT32U *valLen, file_provider *fp)
{
#if 0
static const INT8U PARSE_STATE_NEW = 0;
static const INT8U PARSE_STATE_SKIP = 1;
static const INT8U PARSE_STATE_KEY_READING = 2;
static const INT8U PARSE_STATE_KEY_FINISHED = 3;
static const INT8U PARSE_STATE_STRING_TRIM = 4;
static const INT8U PARSE_STATE_STRING_READING = 5;
INT8U state = PARSE_STATE_NEW;
INT32U ptr = 0;
BOOL stop = FALSE;
if ((eof == NULL) || (valid == NULL) || (lineBuffer == NULL) || (bufferSize == 0) || (keyIndex == NULL) || (keyLen == NULL) || (valIndex == NULL) || (valLen == NULL) || (fp == NULL))
return RET_OS_INVALID_PARAM;
*valid = FALSE;
for (; !stop;)
{
char ch = 0;
INT32U ret = FileStreamGet(&ch, fp);
if (ret != RET_EXT_NO_ERROR)
return ret;
if (ch != 0)
{
if (ptr < bufferSize - 1)
{
lineBuffer[ptr++] = ch;
}
else
{
if (((ch == '\r') || (ch == '\n')) && (ptr == bufferSize - 1))
lineBuffer[ptr - 1] = ch;
state = PARSE_STATE_SKIP;
*valid = FALSE;
}
}
switch (state)
{
case PARSE_STATE_NEW:
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
{
*keyIndex = ptr - 1;
state = PARSE_STATE_KEY_READING;
}
else if (ch == ' ' || ch == '\t')
{
// do nothing
}
else if (ch == '\r' || ch == '\n' || ch == 0)
{
*eof = (ch == 0);
stop = TRUE;
}
else
{
state = PARSE_STATE_SKIP;
}
break;
case PARSE_STATE_KEY_READING:
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || (ch == '.') || (ch == '-') || (ch == '_') || (ch == '[') || (ch == ']'))
{
}
else if (ch == '=')
{
*keyLen = ptr - *keyIndex - 1;
state = PARSE_STATE_STRING_TRIM;
}
else if (ch == ' ' || ch == '\t')
{
*keyLen = ptr - *keyIndex - 1;
state = PARSE_STATE_KEY_FINISHED;
}
else if (ch == '\r' || ch == '\n' || ch == 0)
{
*eof = (ch == 0);
stop = TRUE;
}
else
{
state = PARSE_STATE_SKIP;
}
break;
case PARSE_STATE_KEY_FINISHED:
if (ch == '=')
{
state = PARSE_STATE_STRING_TRIM;
}
else if (ch == '\r' || ch == '\n' || ch == 0)
{
*eof = (ch == 0);
stop = TRUE;
}
else if (ch != ' ' && ch != '\t')
{
state = PARSE_STATE_SKIP;
}
break;
case PARSE_STATE_STRING_TRIM:
if (ch == '\r' || ch == '\n' || ch == 0)
{
*valIndex = ptr - 1;
*valLen = 0;
*valid = TRUE;
*eof = (ch == 0);
stop = TRUE;
}
else if (ch != ' ' && ch != '\t')
{
*valIndex = ptr - 1;
*valLen = 1;
*valid = TRUE;
state = PARSE_STATE_STRING_READING;
}
break;
case PARSE_STATE_STRING_READING:
if (ch == '\r' || ch == '\n' || ch == 0)
{
*eof = (ch == 0);
stop = TRUE;
}
else if ((ch != ' ') && (ch != '\t'))
{
*valLen = ptr - *valIndex;
}
break;
case PARSE_STATE_SKIP:
default:
if (ch == '\r' || ch == '\n' || ch == 0)
{
*eof = (ch == 0);
stop = TRUE;
}
// state = PARSE_STATE_SKIP;
break;
}
}
lineBuffer[ptr] = 0;
return RET_EXT_NO_ERROR;
#else
#define PARSE_STATE_NEW 0
#define PARSE_STATE_SKIP 1
#define PARSE_STATE_KEY_READING 2
#define PARSE_STATE_KEY_FINISHED 3
#define PARSE_STATE_STRING_TRIM 4
#define PARSE_STATE_STRING_READING 5
INT8U state = PARSE_STATE_NEW;
INT32U ptr = 0;
BOOL stop = FALSE;
if ((eof == NULL) || (valid == NULL) || (lineBuffer == NULL) || (bufferSize == 0) || (keyIndex == NULL) || (keyLen == NULL) || (valIndex == NULL) || (valLen == NULL) || (fp == NULL))
return RET_OS_INVALID_PARAM;
*valid = FALSE;
for (; !stop;)
{
char ch = 0;
INT32U ret = FileStreamGet(&ch, fp);
if (ret != RET_EXT_NO_ERROR)
return ret;
if (ch != 0)
{
if (ptr < bufferSize - 1)
{
lineBuffer[ptr++] = ch;
}
else
{
if (((ch == '\r') || (ch == '\n')) && (ptr == bufferSize - 1))
lineBuffer[ptr - 1] = ch;
state = PARSE_STATE_SKIP;
*valid = FALSE;
}
}
switch (state)
{
case PARSE_STATE_NEW:
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
{
*keyIndex = ptr - 1;
state = PARSE_STATE_KEY_READING;
}
else if (ch == ' ' || ch == '\t')
{
// do nothing
}
else if (ch == '\r' || ch == '\n' || ch == 0)
{
*eof = (ch == 0);
stop = TRUE;
}
else
{
state = PARSE_STATE_SKIP;
}
break;
case PARSE_STATE_KEY_READING:
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || (ch == '.') || (ch == '-') || (ch == '_') || (ch == '[') || (ch == ']'))
{
}
else if (ch == '=')
{
*keyLen = ptr - *keyIndex - 1;
state = PARSE_STATE_STRING_TRIM;
}
else if (ch == ' ' || ch == '\t')
{
*keyLen = ptr - *keyIndex - 1;
state = PARSE_STATE_KEY_FINISHED;
}
else if (ch == '\r' || ch == '\n' || ch == 0)
{
*eof = (ch == 0);
stop = TRUE;
}
else
{
state = PARSE_STATE_SKIP;
}
break;
case PARSE_STATE_KEY_FINISHED:
if (ch == '=')
{
state = PARSE_STATE_STRING_TRIM;
}
else if (ch == '\r' || ch == '\n' || ch == 0)
{
*eof = (ch == 0);
stop = TRUE;
}
else if (ch != ' ' && ch != '\t')
{
state = PARSE_STATE_SKIP;
}
break;
case PARSE_STATE_STRING_TRIM:
if (ch == '\r' || ch == '\n' || ch == 0)
{
*valIndex = ptr - 1;
*valLen = 0;
*valid = TRUE;
*eof = (ch == 0);
stop = TRUE;
}
else if (ch != ' ' && ch != '\t')
{
*valIndex = ptr - 1;
*valLen = 1;
*valid = TRUE;
state = PARSE_STATE_STRING_READING;
}
break;
case PARSE_STATE_STRING_READING:
if (ch == '\r' || ch == '\n' || ch == 0)
{
*eof = (ch == 0);
stop = TRUE;
}
else if ((ch != ' ') && (ch != '\t'))
{
*valLen = ptr - *valIndex;
}
break;
case PARSE_STATE_SKIP:
default:
if (ch == '\r' || ch == '\n' || ch == 0)
{
*eof = (ch == 0);
stop = TRUE;
}
// state = PARSE_STATE_SKIP;
break;
}
}
lineBuffer[ptr] = 0;
#undef PARSE_STATE_NEW
#undef PARSE_STATE_SKIP
#undef PARSE_STATE_KEY_READING
#undef PARSE_STATE_KEY_FINISHED
#undef PARSE_STATE_STRING_TRIM
#undef PARSE_STATE_STRING_READING
return RET_EXT_NO_ERROR;
#endif
}
static INT32U FileStreamPropertyGet(const char *store, const char *id, const char *key, char *value, INT32U size, BOOL *isNull, file_provider *fp)
{
#if 0
char filename[PROPERTY_STORE_MAX + PROPERTY_ID_MAX + 16];
char buffer[PROPERTY_LINE_MAX + 2];
INT32U ret = RET_EXT_NO_ERROR;
#if (defined RTOS_UCOS)
INT8U osRet = OS_ERR_NONE;
#endif
if ((store == NULL) || (*store == 0) || (key == NULL) || (*key == 0) || (fp == NULL) || (isNull == NULL))
return RET_OS_INVALID_PARAM;
if ((id == NULL) || (*id == 0))
snprintf(filename, sizeof(filename), "0:/conf/%s.conf", store);
else
snprintf(filename, sizeof(filename), "0:/conf/%s.%s.conf", store, id);
#if (defined RTOS_UCOS)
OSSemPend(fp->sem, OSmsToTick(1000UL), &osRet);
if (osRet != OS_ERR_NONE)
return RET_OS_SYNC_OBJ_FAILED;
#elif ((defined TARGET_LPC11XX) || (defined TARGET_STM32F1))
PROP_DISABLE_IRQ();
if (pp[providerId].flag.lock != 0)
ret = RET_OS_SYNC_OBJ_FAILED;
else
pp[providerId].flag.lock = 1;
PROP_ENABLE_IRQ();
if (ret != RET_EXT_NO_ERROR)
return ret;
#else
#error "Target error"
#endif
ret = FileCacheGet(&fp->cache, store, id, key, value, size, isNull);
if ((ret != RET_EXT_NO_ERROR) && (ret != RET_PROPERTY_OUT_OF_VAL_BUF))
{
*isNull = TRUE;
if ((id == NULL) || (*id == 0)) // global config file, checksum is required.
ret = FileStreamChecksum(filename);
else
ret = RET_EXT_NO_ERROR;
if (ret == RET_EXT_NO_ERROR)
ret = FileStreamOpen(filename, fp);
if (ret == RET_EXT_NO_ERROR)
{
for (;;)
{
BOOL eof = FALSE;
BOOL valid = FALSE;
INT32U keyIndex = 0;
INT32U keyLen = 0;
INT32U valIndex = 0;
INT32U valLen = 0;
ret = FileStreamParseLine(&eof, &valid, buffer, sizeof(buffer), &keyIndex, &keyLen, &valIndex, &valLen, fp);
if (ret != RET_EXT_NO_ERROR)
break;
if (valid)
{
BOOL match = FALSE;
if ((keyLen == strlen(key)) && (strncmp(&buffer[keyIndex], key, keyLen) == 0))
{
if (valLen > size - 1)
{
valLen = size - 1;
ret = RET_PROPERTY_OUT_OF_VAL_BUF;
}
*isNull = FALSE;
strncpy(value, &buffer[valIndex], valLen);
value[valLen] = 0;
match = TRUE;
}
if (fp->config.cache && (match || fp->config.prefetch))
{
buffer[keyIndex + keyLen] = 0;
buffer[valIndex + valLen] = 0;
FileCacheSet(&fp->cache, store, id, &buffer[keyIndex], &buffer[valIndex], fp->config.prefetch);
}
if (match && !fp->config.prefetch)
break;
}
if (eof)
break;
}
if ((ret == RET_EXT_NO_ERROR) && fp->config.prefetch)
{
file_cache *cache = NULL;
FileCacheTouch(&fp->cache, store, id, TRUE, &cache);
if (cache != NULL)
cache->allCache = TRUE;
}
}
FileStreamClose(fp);
}
PROP_UNLOCK(*fp);
return ret;
#else
char filename[PROPERTY_STORE_MAX + PROPERTY_ID_MAX + 16];
char buffer[PROPERTY_LINE_MAX + 2];
INT32U ret = RET_EXT_NO_ERROR;
if ((store == NULL) || (*store == 0) || (key == NULL) || (*key == 0) || (fp == NULL) || (isNull == NULL))
return RET_OS_INVALID_PARAM;
if ((id == NULL) || (*id == 0))
snprintf(filename, sizeof(filename), "%s/%s.conf", config_path, store);
ret = FileCacheGet(&fp->cache, store, id, key, value, size, isNull);
if ((ret != RET_EXT_NO_ERROR) && (ret != RET_PROPERTY_OUT_OF_VAL_BUF))
{
*isNull = TRUE;
// TODO:
#if 0
if ((id == NULL) || (*id == 0)) // global config file, checksum is required.
ret = FileStreamChecksum(filename);
else
ret = RET_EXT_NO_ERROR;
#else
ret = RET_EXT_NO_ERROR;
#endif
if (ret == RET_EXT_NO_ERROR)
{
// 打开文件
ret = FileStreamOpen(filename, fp);
// printf("ret = %d\n", ret);
}
if (ret == RET_EXT_NO_ERROR)
{
#if 0
//逻辑重写
for (;;)
{
BOOL eof = FALSE;
BOOL valid = FALSE;
INT32U keyIndex = 0;
INT32U keyLen = 0;
INT32U valIndex = 0;
INT32U valLen = 0;
// 读取单条
ret = FileStreamParseLine(&eof, &valid, buffer, sizeof(buffer), &keyIndex, &keyLen, &valIndex, &valLen, fp);
if (ret != RET_EXT_NO_ERROR)
break;
if (valid)
{
BOOL match = FALSE;
if ((keyLen == strlen(key)) && (strncmp(&buffer[keyIndex], key, keyLen) == 0))
{
if (valLen > size - 1)
{
valLen = size - 1;
ret = RET_PROPERTY_OUT_OF_VAL_BUF;
}
*isNull = FALSE;
strncpy(value, &buffer[valIndex], valLen);
value[valLen] = 0;
match = TRUE;
}
if (fp->config.cache && (match || fp->config.prefetch))
{
buffer[keyIndex + keyLen] = 0;
buffer[valIndex + valLen] = 0;
FileCacheSet(&fp->cache, store, id, &buffer[keyIndex], &buffer[valIndex], fp->config.prefetch);
}
if (match && !fp->config.prefetch)
break;
}
if (eof)
break;
}
#else
while (1)
{
char temp[100];
void *result = fgets(temp, sizeof(temp), fp->stream.fil);
if (result != NULL)
{
// printf("%s\n", temp);
// 搜索到正常的头部
if ((temp[0] >= 'a' && temp[0] <= 'z') || (temp[0] >= 'A' && temp[0] <= 'Z'))
{
// 比对key的情况，key必须顶格写
int i = 0;
int result = 1;
while (key[i] != '\0')
{
if (temp[i] != key[i])
{
result = 0;
break;
}
if (temp[i] == '=')
{
result = 0;
break;
}
i++;
}
// 防守配置文件里面的key更长，但是后面不相符的情况
if (temp[i] != '=')
{
result = 0;
}
//截断字符串
temp[i] = '\0';
// printf("result : %d ; key = %s ; serch = %s\n", result, key, temp);
// 找到目标
if (result == 1)
{
// 将值拷贝出去
*isNull = FALSE;
i++;
int j = 0;
while (1)
{
value[j] = temp[i];
j++;
i++;
if (temp[i] == ' ' || temp[i] == '\r' || temp[i] == '\t' || temp[i] == '\n')
{
break;
}
if (j >= (size - 1))
{
// 给的缓存太小了，报个错
return RET_PROPERTY_OUT_OF_VAL_BUF;
}
}
value[j] = '\0';
printf("get value = %s\n", value);
// 设置chache
if (fp->config.cache && (fp->config.prefetch))
{
FileCacheSet(&fp->cache, store, id, temp, value, fp->config.prefetch);
}
}
}
// 说明读到尾部了
if (feof(fp->stream.fil) == 1)
{
// printf("file end\n");
break;
}
}
else
{
// 读取失败，退出循环
// printf("file read error\n");
break;
}
}
#endif
if ((ret == RET_EXT_NO_ERROR) && fp->config.prefetch)
{
file_cache *cache = NULL;
FileCacheTouch(&fp->cache, store, id, TRUE, &cache);
if (cache != NULL)
cache->allCache = TRUE;
}
}
FileStreamClose(fp);
}
return ret;
#endif
}
static INT32U FileStreamPropertySet(const char *store, const char *id, property_string_item *list, INT32U count, file_provider *fp)
{
#if 0
char filename[PROPERTY_STORE_MAX + PROPERTY_ID_MAX + 16];
char filetmp[PROPERTY_STORE_MAX + PROPERTY_ID_MAX + 20];
char buffer[PROPERTY_LINE_MAX + 2];
INT32U ret = RET_EXT_NO_ERROR;
#if (defined RTOS_UCOS)
INT8U osRet = OS_ERR_NONE;
#endif
BOOL newLine = FALSE;
BOOL changed = FALSE;
INT32U idx;
if ((store == NULL) || (*store == 0) || (list == NULL) || (count == 0) || (fp == NULL))
return RET_OS_INVALID_PARAM;
if ((id == NULL) || (*id == 0))
return RET_PROPERTY_INVALID_STORE_ID;
for (idx = 0; idx < count; idx++)
{
if ((list[idx].key == NULL) || (*list[idx].key == 0))
return RET_OS_INVALID_PARAM;
list[idx].success = 0;
}
snprintf(filename, sizeof(filename), "%s/%s.%s.conf", config_path, store, id);
snprintf(filetmp, sizeof(filetmp), "%s/%s.%s.conf.tmp", config_path, store, id);
FILE_TEST_RANDOM(8);
if (f_open(&fp->stream.tmp, filetmp, FA_CREATE_ALWAYS | FA_WRITE) != FR_OK)
ret = RET_PROPERTY_FILE_OPEN_ERR;
if (ret == RET_EXT_NO_ERROR)
{
ret = FileStreamOpen(filename, fp);
if (ret == RET_EXT_NO_ERROR)
{
for (;;)
{
BOOL skip = FALSE;
BOOL eof = FALSE;
BOOL valid = FALSE;
INT32U keyIndex = 0;
INT32U keyLen = 0;
INT32U valIndex = 0;
INT32U valLen = 0;
INT32U bw;
char lastCh;
ret = FileStreamParseLine(&eof, &valid, buffer, sizeof(buffer), &keyIndex, &keyLen, &valIndex, &valLen, fp);
if (ret != RET_EXT_NO_ERROR)
break;
bw = strlen(buffer);
lastCh = ((bw > 0) ? buffer[bw - 1] : '\0');
if ((lastCh != '\r') && (lastCh != '\n') && (bw > 0))
newLine = TRUE;
if (valid)
{
for (idx = 0; idx < count; idx++)
{
if (list[idx].success)
continue;
if ((keyLen != strlen(list[idx].key)) || (strncmp(&buffer[keyIndex], list[idx].key, keyLen) != 0))
continue;
if (list[idx].value == NULL)
{
skip = TRUE;
}
else
{
if ((lastCh == '\r') || (lastCh == '\n'))
snprintf(buffer, sizeof(buffer), "%s=%s%c", list[idx].key, list[idx].value, lastCh);
else
snprintf(buffer, sizeof(buffer), "%s=%s", list[idx].key, list[idx].value);
bw = strlen(buffer);
}
if (fp->config.cache)
FileCacheSet(&fp->cache, store, id, list[idx].key, list[idx].value, FALSE);
list[idx].success = 1;
changed = TRUE;
break;
}
}
if (!skip)
{
if (f_write(&fp->stream.tmp, buffer, bw, &bw) != FR_OK)
{
ret = RET_PROPERTY_FILE_WRITE_ERR;
break;
}
}
if (eof)
break;
}
}
if (ret == RET_EXT_NO_ERROR)
{
for (idx = 0; idx < count; idx++)
{
INT32U bw;
if (list[idx].success)
continue;
if (list[idx].value == NULL)
{
list[idx].success = 1;
continue;
}
if (newLine)
{
newLine = FALSE;
bw = strlen("\r\n");
if (f_write(&fp->stream.tmp, "\r\n", bw, &bw) != FR_OK)
{
ret = RET_PROPERTY_FILE_WRITE_ERR;
break;
}
}
snprintf(buffer, sizeof(buffer), "%s=%s\r\n", list[idx].key, list[idx].value);
bw = strlen(buffer);
if (f_write(&fp->stream.tmp, buffer, bw, &bw) != 0)
{
ret = RET_PROPERTY_FILE_WRITE_ERR;
break;
}
if (fp->config.cache)
FileCacheSet(&fp->cache, store, id, list[idx].key, list[idx].value, FALSE);
list[idx].success = 1;
changed = TRUE;
}
}
FileStreamClose(fp);
f_close(&fp->stream.tmp);
// a. 将修改后的配置写入*.conf.tmp
// b. 将字符串"*.conf"写入update.log
// c. 删除*.conf
// d. 复制*.conf.tmp-> *.conf
// e. 删除update.log
// f. 删除 *.conf.tmp
if (ret == RET_EXT_NO_ERROR)
ret = PropWriteLogWrite(0, filename);
if (ret == RET_EXT_NO_ERROR)
PropWriteLogCommit(0, filename);
}
if (changed && (ret != RET_EXT_NO_ERROR))
FileCacheClear(&fp->cache, store, id);
PROP_UNLOCK(*fp);
if (ret != RET_EXT_NO_ERROR)
{
for (idx = 0; idx < count; idx++)
list[idx].success = 0;
}
return ret;
#else
return 0;
#endif
}
/** function comment
* @description:
* @param {char} *store
* @param {char} *key
* @param {char} *id 看上去没有用,直接用的NULL
* @param {char} *value
* @param {INT32U} sizeOfValue
* @param {BOOL} *isLocal
* @param {void} *obj
* @return {*}
*/
static INT32U FilePropertyGet(const char *store, const char *key, const char *id, char *value, INT32U sizeOfValue, BOOL *isLocal, void *obj)
{
BOOL isNull = TRUE;
INT32U ret = RET_PROPERTY_NOT_FOUND;
file_provider *fp = (file_provider *)obj;
if (fp == NULL)
return RET_OS_INVALID_PARAM;
if (isLocal != NULL)
*isLocal = FALSE;
// id在实际应用中没有找到
if ((id != NULL) && (*id != 0))
{
ret = FileStreamPropertyGet(store, id, key, value, sizeOfValue, &isNull, fp);
if ((ret == RET_EXT_NO_ERROR) && isNull)
ret = RET_PROPERTY_NOT_FOUND;
if ((ret == RET_EXT_NO_ERROR) && (isLocal != NULL))
*isLocal = TRUE;
}
if (ret == RET_PROPERTY_NOT_FOUND)
{
ret = FileStreamPropertyGet(store, NULL, key, value, sizeOfValue, &isNull, fp);
if ((ret == RET_EXT_NO_ERROR) && isNull)
ret = RET_PROPERTY_NOT_FOUND;
}
return ret;
}
static INT32U FilePropertySet(const char *store, const char *id, property_string_item *list, INT32U count, void *obj)
{
file_provider *fp = (file_provider *)obj;
if (fp == NULL)
return RET_OS_INVALID_PARAM;
if ((id != NULL) && (*id != 0))
return FileStreamPropertySet(store, id, list, count, fp);
else
return RET_PROPERTY_INVALID_STORE_ID;
}
static INT32U FilePropertyClear(const char *store, const char *id, void *obj)
{
INT32U ret = RET_EXT_NO_ERROR;
file_provider *fp = (file_provider *)obj;
if (fp == NULL)
return RET_OS_INVALID_PARAM;
if (!fp->config.cache)
return RET_EXT_NO_ERROR;
if ((id == NULL) || (*id == 0))
id = NULL;
if (ret == RET_EXT_NO_ERROR)
ret = FileCacheClear(&fp->cache, store, id);
return ret;
}
static INT32U FilePropertyInit(INT32U providerId, const PropertyInitParam *param)
{
INT32U ret = RET_EXT_NO_ERROR;
file_provider *fp = NULL;
if (ret == RET_EXT_NO_ERROR)
{
fp = (file_provider *)malloc_mt(sizeof(file_provider));
if (fp == NULL)
ret = RET_PROPERTY_HEAP_FULL;
}
if (ret == RET_EXT_NO_ERROR)
{
char storename[PROPERTY_STORE_MAX + PROPERTY_ID_MAX + 16];
INT32U ret2 = RET_EXT_NO_ERROR;
memset(fp, 0, sizeof(file_provider));
fp->config.cache = param->config.cache;
fp->config.prefetch = (param->config.cache && param->config.prefetch);
fp->cache = NULL;
pp[providerId].get = FilePropertyGet;
pp[providerId].set = FilePropertySet;
pp[providerId].clear = FilePropertyClear;
pp[providerId].obj = fp;
pp[providerId].flag.cache = param->config.cache;
pp[providerId].flag.init = 1;
#if 0 // 意义不明，没有storename
ret2 = PropWriteLogLoad(providerId, storename, sizeof(storename));
if ((ret2 == RET_EXT_NO_ERROR) && (storename[0] != '\0'))
{
printf("PropWriteLogCommit(providerId=%d, storename=%s)\n\r", providerId, storename);
PropWriteLogCommit(providerId, storename);
}
#endif
}
else
{
if (fp != NULL)
free_mt(fp);
}
return ret;
}
#endif
#if ((defined PROPERTY_PROV_REMOTE_EN) && (PROPERTY_PROV_REMOTE_EN != 0))
/**************************************************************
* Remote property provider
*************************************************************
*/
typedef struct
{
INT32U destId;
} remote_provider;
static INT32U RemotePropertyGet(const char *store, const char *key, const char *id, char *value, INT32U sizeOfValue, BOOL *isLocal, void *obj)
{
INT8U outBuf[PROPERTY_LINE_MAX + sizeof(INT32U)];
INT8U *inBuf;
INT8U *ptr;
INT32U sizeOfIn;
INT32U sizeOfOut;
INT32U ret = RET_EXT_NO_ERROR;
if ((store == NULL) || (*store == 0) || (key == NULL) || (*key == 0) || (value == NULL) || (obj == NULL))
return RET_OS_INVALID_PARAM;
sizeOfIn = strlen(store) + strlen(key) + 3;
if (id != NULL)
sizeOfIn += strlen(id);
inBuf = (INT8U *)malloc_mt(sizeOfIn);
if (inBuf == NULL)
return RET_PROPERTY_HEAP_FULL;
ptr = inBuf;
memcpy(ptr, store, (strlen(store) + 1));
ptr += (strlen(store) + 1);
if (id == NULL)
{
*ptr = 0;
ptr++;
}
else
{
memcpy(ptr, id, (strlen(id) + 1));
ptr += (strlen(id) + 1);
}
memcpy(ptr, key, (strlen(key) + 1));
sizeOfOut = (PROPERTY_LINE_MAX + sizeof(INT32U));
ret = bus_host_execute(((remote_provider *)obj)->destId, 2, CMD_mgrGetProp, inBuf, sizeOfIn, outBuf, &sizeOfOut, NULL, NULL, NULL, NULL);
if (ret == RET_EXT_NO_ERROR)
{
if ((sizeOfOut > sizeof(INT32U)) && (outBuf[sizeOfOut - 1] == '\0'))
{
if (isLocal != NULL)
*isLocal = (((outBuf[0] & 0x01) == 0) ? FALSE : TRUE);
strncpy(value, (const char *)&outBuf[sizeof(INT32U)], sizeOfValue);
value[sizeOfValue - 1] = 0;
}
else
{
ret = RET_BUS_INVALID_RET_FORMAT;
}
}
free_mt(inBuf);
return ret;
}
static INT32U RemotePropertySet(const char *store, const char *id, property_string_item *list, INT32U count, void *obj)
{
INT32U i;
INT8U *inBuf;
INT8U *ptr;
INT32U sizeOfIn;
INT32U sizeOfOut = 0;
INT32U ret = RET_EXT_NO_ERROR;
if ((store == NULL) || (*store == 0) || (list == NULL) || (count == 0) || (obj == NULL))
return RET_OS_INVALID_PARAM;
if (count > 0xff)
return RET_PROPERTY_SETP_LIST_EXCEED_MAX;
sizeOfIn = (strlen(store) + 2);
if ((id != NULL) && (*id != 0))
sizeOfIn += strlen(id);
sizeOfIn += sizeof(INT8U);
for (i = 0; i < count; i++)
{
if ((list[i].key == NULL) || (*list[i].key == 0))
return RET_OS_INVALID_PARAM;
sizeOfIn += sizeof(INT8U);
sizeOfIn += (strlen(list[i].key) + 2);
if ((list[i].value != NULL) && (*list[i].value != 0))
sizeOfIn += strlen(list[i].value);
}
inBuf = (INT8U *)malloc_mt(sizeOfIn);
if (inBuf == NULL)
return RET_PROPERTY_HEAP_FULL;
ptr = inBuf;
memcpy(ptr, store, (strlen(store) + 1));
ptr += (strlen(store) + 1);
if (id == NULL)
{
*ptr = 0;
ptr++;
}
else
{
memcpy(ptr, id, (strlen(id) + 1));
ptr += (strlen(id) + 1);
}
*ptr = (count & 0xff);
ptr++;
for (i = 0; i < count; i++)
{
list[i].success = 0;
if (list[i].value == NULL)
*ptr = 0x01; // clear property
else
*ptr = 0x00; // set property
ptr++;
memcpy(ptr, list[i].key, (strlen(list[i].key) + 1));
ptr += (strlen(list[i].key) + 1);
if (list[i].value == NULL)
{
*ptr = 0;
ptr++;
}
else
{
memcpy(ptr, list[i].value, (strlen(list[i].value) + 1));
ptr += (strlen(list[i].value) + 1);
}
}
ret = bus_host_execute(((remote_provider *)obj)->destId, 2, CMD_mgrSetPropL, inBuf, sizeOfIn, NULL, &sizeOfOut, NULL, NULL, NULL, NULL);
if (ret == RET_EXT_NO_ERROR)
{
for (i = 0; i < count; i++)
list[i].success = 0;
}
free_mt(inBuf);
return ret;
}
static INT32U RemotePropertyClear(const char *store, const char *id, void *obj)
{
// RemotePropertyClear(), 远端缓存不需要客户端清除, 由远端根据实际情况自行决定
return RET_EXT_NO_ERROR;
}
static INT32U RemotePropertyInit(INT32U providerId, const PropertyInitParam *param)
{
INT32U ret = RET_EXT_NO_ERROR;
remote_provider *rp = (remote_provider *)malloc_mt(sizeof(remote_provider));
if (rp == NULL)
ret = RET_PROPERTY_HEAP_FULL;
if (ret == RET_EXT_NO_ERROR)
{
memset(rp, 0, sizeof(remote_provider));
rp->destId = param->destId;
pp[providerId].get = RemotePropertyGet;
pp[providerId].set = RemotePropertySet;
pp[providerId].clear = RemotePropertyClear;
pp[providerId].obj = rp;
pp[providerId].flag.cache = param->config.cache;
pp[providerId].flag.init = 1;
}
else
{
if (rp != NULL)
free_mt(rp);
}
return ret;
}
#endif
#if 1
// store name
static char propStoreSystem[40] = "0x1820_system";
static char propStorePanel[40] = "0x1820_0x0000_panel";
static char propStoreTarget[40] = "0x1820_0x0000_target";
static char propStorePipette[40] = "0x1820_0x0000_pipette";
static char propStoreTip[40] = "0x1820_0x0000_tip";
static char propStoreContainer[40] = "0x1820_0x0000_container";
static char propStoreMotor[40] = "0x1820_0x0000_motor";
static char propStoreDispense[40] = "0x1820_0x0000_dispense";
static char propStoreDevMapping[40] = "0x1820_0x0000_dm";
static char propStoreRoute[40] = "0x1820_0x0000_route";
static char propStoreDiv[40] = "0x1820_0x0000_div";
static char propStoreModule[40] = "0x1820_0x0000_module";
static char propStoreWash[40] = "0x1820_0x0000_wash";
static char propStoreRea[40] = "0x1820_0x0000_reagentplate";
const char *GetStoreName(const char *store)
{
if (store == NULL)
return NULL;
if (strcmp(store, "motor") == 0)
return propStoreMotor;
if (strcmp(store, "panel") == 0)
return propStorePanel;
if (strcmp(store, "target") == 0)
return propStoreTarget;
if (strcmp(store, "pipette") == 0)
return propStorePipette;
if (strcmp(store, "tip") == 0)
return propStoreTip;
if (strcmp(store, "container") == 0)
return propStoreContainer;
if (strcmp(store, "dispense") == 0)
return propStoreDispense;
if (strcmp(store, "module") == 0)
return propStoreModule;
if (strcmp(store, "dm") == 0)
return propStoreDevMapping;
if (strcmp(store, "route") == 0)
return propStoreRoute;
if (strcmp(store, "div") == 0)
return propStoreDiv;
if (strcmp(store, "system") == 0)
return propStoreSystem;
if (strcmp(store, "wash") == 0)
return propStoreWash;
return NULL;
}
//unit test
int main(void)
{
INT32U retCode = RET_EXT_NO_ERROR;
PropertyInitParam param;
param.config.cache = 1;
param.config.prefetch = 1;
param.id = 0;
param.type = PropertyTypeFS;
PropertyInit(0, &param);
INT32U ret = 0;
INT32U val = GetUnsigned(0, "0x1820_0x0000_container", "Container0.Bottom", 0, 0, &ret, NULL);
printf("%d,%d\n", val, ret);
val = GetUnsigned(0, "0x1820_0x0000_container", "Container0.Bottom", 0, 0, &ret, NULL);
printf("%d,%d\n", val, ret);
}
#endif