int hinfc610_dbgfs_debug_init(struct hinfc_host *host)
{
struct dentry *dentry;
if (dbgfs_root)
return 0;
dbgfs_root = debugfs_create_dir("nand", NULL);
if (!dbgfs_root) {
PR_ERR("Can't create 'nand' dir.\n");
return -ENOENT;
}
dentry = debugfs_create_file("debug", S_IFREG | S_IRUSR | S_IWUSR,
dbgfs_root, NULL, &dbgfs_debug_fops);
if (!dentry) {
PR_ERR("Can't create 'debug' file.\n");
goto fail;
}
dbgfs_host = host;
if (dbgfs_options)
dbgfs_debug_ops(dbgfs_options, hinfc610_dbg_inf);
return 0;
fail:
debugfs_remove_recursive(dbgfs_root);
dbgfs_root = NULL;
return -ENOENT;
}
static inline int __regf_cell_check_basic(const struct regf_cell *cell,
unsigned off, const char *cell_type)
{
if (off % 8) {
PR_ERR(off, cell_type, "unaligned cell offset\n");
return -1;
}
if (cell->sz > 0) {
PR_ERR(off, cell_type, "cell is marked as free\n");
return -1;
}
if (cell->sz == 0) {
PR_ERR(off, cell_type, "zero cell size\n");
return -1;
}
if (-cell->sz % 8) {
PR_ERR(off, cell_type, "unaligned cell length 0x%08X\n",
-cell->sz);
return -1;
}
return 0;
}
static int __init knamed_init(void)
{
struct file *filp;
int ret;
int err;
PR_INFO("starting");
PR_INFO("Author: Gu Feng <*****@*****.**>");
PR_INFO("Version: %s", KNAMED_VERSION);
PR_INFO("Repository: https://github.com/flygoast/knamed.git");
filp = filp_open(KNAMED_CONF, O_RDONLY, 0);
if (IS_ERR(filp)) {
PR_INFO("conf file \"%s\" didn't existed, ignored", KNAMED_CONF);
goto init;
}
if (filp) {
fput(filp);
}
init:
ret = nf_register_hooks(knamed_ops, ARRAY_SIZE(knamed_ops));
if (ret < 0) {
PR_ERR("can't register hooks.");
goto cleanup;
}
knamed_memory_init();
knamed_procfs_init();
knamed_sysctl_register();
dns_init();
knamed_task = kthread_run(knamed_loop, NULL, "knamedtask");
if (IS_ERR(knamed_task)) {
PR_ERR("Create kernel thread failed");
err = PTR_ERR(knamed_task);
return err;
}
PR_INFO("started");
return 0;
cleanup:
return ret;
}
/***********************************************************
*************************function define********************
***********************************************************/
VOID device_cb(SMART_CMD_E cmd,cJSON *root)
{
CHAR *buf = cJSON_PrintUnformatted(root);
if(NULL == buf) {
PR_ERR("malloc error");
return;
}
OPERATE_RET op_ret = sf_obj_dp_report(get_single_wf_dev()->dev_if.id,buf);
if(OPRT_OK != op_ret) {
PR_ERR("sf_obj_dp_report err:%d",op_ret);
PR_DEBUG_RAW("%s\r\n",buf);
Free(buf);
return;
}
Free(buf);
}
/***********************************************************
* Function: check_dev_need_update
* Input:
* Output:
* Return:
* Note: user need to fill the content in the function before
call it
***********************************************************/
VOID check_dev_need_update(IN CONST DEV_CNTL_N_S *dev_cntl)
{
if(NULL == dev_cntl) {
PR_ERR("invalid param");
return;
}
if((get_gw_status() > UN_ACTIVE) && \
((dev_cntl->dev_if.sync && dev_cntl->dev_if.bind) || \
(!dev_cntl->dev_if.bind))) { // 启动信息更新操作
if(os_timer_is_active(&dev_ul_timer) != WM_SUCCESS) {
int ret = os_timer_activate(&dev_ul_timer);
if(WM_SUCCESS != ret) {
PR_ERR("activeate timer error");
}
}
}
}
static void gw_actv_timer_cb(os_timer_arg_t arg)
{
GW_WIFI_STAT_E wf_stat;
wf_stat = get_wf_gw_status();
if(wf_stat != STAT_STA_CONN) {
// PR_DEBUG("we can not active gw,because the wifi state is :%d",wf_stat);
return;
}
else {
PR_DEBUG("now,we'll go to active gateway");
}
OPERATE_RET op_ret;
#if NO_DEF_GW_DEV_ACTV_IF
op_ret = httpc_gw_active();
if(OPRT_OK != op_ret) {
PR_ERR("op_ret:%d",op_ret);
return;
}
#else
op_ret = httpc_gw_dev_active(&(gw_cntl.dev->dev_if));
if(OPRT_OK != op_ret) {
PR_ERR("httpc_gw_dev_active error:%d",op_ret);
return;
}
os_mutex_get(&gw_mutex, OS_WAIT_FOREVER);
gw_cntl.dev->dev_if.bind = TRUE;
gw_cntl.dev->dev_if.sync = FALSE;
os_mutex_put(&gw_mutex);
op_ret = ws_db_set_dev_if(&gw_cntl.dev->dev_if);
if(OPRT_OK != op_ret) {
PR_ERR("ws_db_set_dev_if error,op_ret:%d",op_ret);
}
#endif
check_all_dev_if_update();
os_timer_deactivate(&gw_actv_timer);
}
static inline int __regf_cell_check_sign(const struct regf_cell *cell,
unsigned off, const char *sign)
{
const char *__sign = (void *)cell->data;
if (*(uint16_t *)__sign ^ *(uint16_t *)sign) {
PR_ERR(off, sign, "invalid cell signature %02X %02X (%.2s)\n",
__sign[0], __sign[1], __sign);
return -1;
}
return 0;
}
static inline int __regf_cell_check_len(const struct regf_cell *cell,
unsigned off, const char *cell_type,
unsigned data_min_len)
{
unsigned len = (sizeof(*cell) + data_min_len + 7) & ~7; /* Align */
if (len > -cell->sz) {
PR_ERR(off, cell_type,
"cell space (0x%08X) is too small for 0x%08X bytes of data\n",
-cell->sz - sizeof(*cell), data_min_len);
return -1;
}
return 0;
}
static int
knamed_default_ttl_sysctl(ctl_table *table, int write, void __user *buffer,
size_t *lenp, loff_t *ppos)
{
int *valp = table->data;
int val = *valp;
int rc;
rc = proc_dointvec(table, write, buffer, lenp, ppos);
if (write && (*valp != val)) {
if (*valp < 0) {
PR_ERR("Invalid ttl: %d, must be positive", *valp);
/* Restore the correct value */
*valp = val;
} else {
PR_INFO("Change ttl from %d to %d", val, *valp);
}
}
return rc;
}
static int
knamed_port_sysctl(ctl_table *table, int write, void __user *buffer,
size_t *lenp, loff_t *ppos)
{
int *valp = table->data;
int val = *valp;
int rc;
rc = proc_dointvec(table, write, buffer, lenp, ppos);
if (write && (*valp != val)) {
if ((*valp < 0) || (*valp > 65535)) {
PR_ERR("invalid port: %d, must be between 0-65535", *valp);
/* Restore the correct value */
*valp = val;
} else {
PR_INFO("change port from %d to %d", val, *valp);
}
}
return rc;
}
static ssize_t dbgfs_debug_read(struct file *filp, char __user *buffer,
size_t count, loff_t *ppos)
{
char *msg, *p;
struct hinfc610_dbg_inf_t **inf;
if (*ppos != 0)
return 0;
msg = (char *)__get_free_page(GFP_TEMPORARY);
if (!msg)
return -ENOMEM;
p = msg;
if (count > PAGE_SIZE)
count = PAGE_SIZE;
for (inf = hinfc610_dbg_inf; *inf; inf++) {
if ((p - msg) + MAX_OPTION_SIZE + 2 > count) {
PR_ERR("Not enough memory.\n");
break;
}
p += snprintf(p, (MAX_OPTION_SIZE + 2), "%c%s,",
((*inf)->enable ? '+' : '-'),
(*inf)->name);
}
p += sprintf(p, "\n");
count = (p - msg);
if (copy_to_user(buffer, msg, count)) {
free_page((unsigned long) msg);
return -EFAULT;
}
free_page((unsigned long) msg);
*ppos += count;
return count;
}
VOID update_dev_ol_status(IN CONST CHAR *id,IN CONST BOOL online)
{
if(id == NULL) {
return;
}
DEV_CNTL_N_S *dev_cntl = get_dev_cntl(id);
if(NULL == dev_cntl) {
PR_ERR("do not get dev cntl");
return;
}
if((get_gw_status() <= UN_ACTIVE) || \
FALSE == dev_cntl->dev_if.bind) {
return;
}
os_mutex_get(&gw_mutex, OS_WAIT_FOREVER);
dev_cntl->online = online;
os_mutex_put(&gw_mutex);
check_dev_need_update(dev_cntl);
}
/***********************************************************
* Function: check_and_update_dev_desc_if
* Input:
* Output:
* Return:
***********************************************************/
VOID check_and_update_dev_desc_if(IN CONST CHAR *id,\
IN CONST CHAR *name,\
IN CONST CHAR *sw_ver,\
IN CONST CHAR *schema_id,\
IN CONST CHAR *ui_id)
{
if(id == NULL) {
return;
}
DEV_CNTL_N_S *dev_cntl = get_dev_cntl(id);
if(NULL == dev_cntl) {
PR_ERR("do not get dev cntl");
return;
}
CONST CHAR *str[] = {name,sw_ver,schema_id,ui_id};
CHAR *oldstr[] = {dev_cntl->dev_if.name,dev_cntl->dev_if.sw_ver,\
dev_cntl->dev_if.schema_id,dev_cntl->dev_if.ui_id};
INT i;
os_mutex_get(&gw_mutex, OS_WAIT_FOREVER);
for(i = 0;i < CNTSOF(str);i++) {
if(NULL == str[i]) {
continue;
}
if(strcmp(str[i],oldstr[i]) || \
(strlen(str[i]) != strlen(oldstr[i]))) {
dev_cntl->dev_if.sync = TRUE;
strcpy(oldstr[i],str[i]);
}
}
os_mutex_put(&gw_mutex);
check_dev_need_update(dev_cntl);
}
/***********************************************************
* Function: gw_cntl_init
* Input:
* Output:
* Return:
***********************************************************/
OPERATE_RET gw_cntl_init(VOID)
{
OPERATE_RET op_ret;
op_ret = httpc_aes_init();
if(OPRT_OK != op_ret) {
PR_ERR("op_ret:%d",op_ret);
return op_ret;
}
op_ret = ws_db_init();
if(OPRT_OK != op_ret) {
return op_ret;
}
memset(&gw_cntl,0,sizeof(gw_cntl));
memset(&gw_mutex,0,sizeof(gw_mutex));
// create mutex
int ret;
ret = os_mutex_create(&gw_mutex, "gw_mutex", 1);
if(ret != WM_SUCCESS) {
return OPRT_CR_MUTEX_ERR;
}
// create gw active timer
ret = os_timer_create(&gw_actv_timer,
"gw_actv_timer",
os_msec_to_ticks(1000),
&gw_actv_timer_cb,
NULL,
OS_TIMER_PERIODIC,
OS_TIMER_NO_ACTIVATE);
if (ret != WM_SUCCESS) {
return OPRT_COM_ERROR;
}
PROD_IF_REC_S prod_if;
#if 1
memset(&prod_if,0,sizeof(prod_if));
ws_db_get_prod_if(&prod_if);
if(!prod_if.mac[0] || !prod_if.prod_idx[0]) { // un init
set_gw_status(UN_INIT);
return OPRT_OK;
}
#else
strcpy(prod_if.mac,"112233445566");
strcpy(prod_if.prod_idx,"0da02001");
#endif
op_ret = ws_db_get_gw_actv(&gw_cntl.active);
if(OPRT_OK != op_ret) {
memset(&gw_cntl.active,0,sizeof(gw_cntl.active));
ws_db_set_gw_actv(&gw_cntl.active);
set_gw_status(UN_ACTIVE);
}else {
if(!gw_cntl.active.key[0] || !gw_cntl.active.uid_cnt) { // un active
if(!gw_cntl.active.token[0]) {
set_gw_status(UN_ACTIVE);
}else {
start_active_gateway();
}
}else {
set_gw_status(STAT_WORK);
}
}
strcpy(gw_cntl.gw.sw_ver,GW_VER);
#if 0
strcpy(gw_cntl.gw.name,GW_DEF_NAME);
#else
snprintf(gw_cntl.gw.name,sizeof(gw_cntl.gw.name),"%s-%s",GW_DEF_NAME,&prod_if.mac[8]);
#endif
snprintf(gw_cntl.gw.id,sizeof(gw_cntl.gw.id),"%s%s",prod_if.prod_idx,prod_if.mac);
gw_cntl.gw.ability = GW_DEF_ABI;
// create dev upload timer
ret = os_timer_create(&dev_ul_timer,
"dev_ul_timer",
os_msec_to_ticks(600),
&dev_ul_timer_cb,
NULL,
OS_TIMER_PERIODIC,
OS_TIMER_NO_ACTIVATE);
if (ret != WM_SUCCESS) {
return OPRT_COM_ERROR;
}
return OPRT_OK;
}
static int
parse_query(struct dns_query *query)
{
int len, datalen, pos, dnslen;
uint8_t *buf, *p;
dnslen = query->plen;
buf = query->packet + sizeof(struct dnshdr);
p = &query->name[0];
pos = 0;
datalen = dnslen - sizeof(struct dnshdr);
while (1) {
len = buf[pos];
if (len & 0xc0) {
PR_ERR("Lable compression detected in query");
return -1;
}
if (len > MAX_LABEL_LEN) {
PR_ERR("Lable too long in query");
return -1;
}
pos++;
if (len == 0) {
*p++ = '\0';
break;
}
if (pos + len >= datalen) {
PR_ERR("Query name truncated");
return -1;
}
if (pos + len > MAX_DOMAIN_LEN) {
PR_ERR("Query domain name too long");
return -1;
}
while (len--) {
if (buf[pos] > 0x40 && buf[pos] < 0x5B) {
*p++ = buf[pos] | 0x20;
} else {
*p++ = buf[pos];
}
pos++;
}
*p++ = '.';
}
/* length of the lowercased name */
query->len = (uint8_t) (p - query->name - 1);
query->qlen = (uint8_t) pos;
if (pos + 4 > datalen) {
PR_ERR("Length exhausted before parsing query type/class");
return -1;
} else {
query->qtype = ntohs(*(uint16_t *) &buf[pos]);
pos += 2;
query->qclass = ntohs(*(uint16_t *) &buf[pos]);
pos += 2;
}
return 0;
}
/*
* Test main function.
*/
sns_ddf_status_e sns_dd_alt_bmp085_on_target_test_main(void)
{
sns_ddf_device_access_s device_info;
sns_ddf_i2c_config_s i2c_config;
uint32_t num_sensors = 0;
sns_ddf_sensor_e *sensors = NULL;
sns_ddf_handle_t dd_handle = NULL;
sns_ddf_handle_t smgr_handle = NULL;
sns_ddf_nv_params_s *nv_params = NULL;
sns_ddf_memhandler_s memhandler;
sns_ddf_sensor_data_s *data = NULL;
sns_ddf_status_e status;
/* Device Info */
device_info.device_select = 0;
device_info.port_config.bus = SNS_DDF_BUS_I2C;
device_info.port_config.bus_config.i2c = &i2c_config;
/* I2C Info */
i2c_config.addr_type = SNS_DDF_I2C_ADDR_7BIT;
i2c_config.bus_acq_timeout = -1;
i2c_config.xfer_timeout = -1;
i2c_config.bus_freq = 400;
i2c_config.dev_type = SNS_DDF_I2C_DEVICE_REGADDR;
i2c_config.read_opt = SNS_DDF_I2C_START_BEFORE_RD;
i2c_config.slave_addr = 0xEE/2;
/* get memory handler */
sns_ddf_memhandler_init(&memhandler);
status = sns_alt_bmp085_driver_fn_list.init(
&dd_handle,
smgr_handle,
nv_params,
&device_info,
1,
&memhandler,
&sensors,
&num_sensors);
if (status != SNS_DDF_SUCCESS)
{
PR_ERR("error initializing\n", status);
return status;
}
PR_DBG("num_sensors = %d.\n", num_sensors);
PR_DBG("sensor type is %d.\n", *sensors);
status = sns_alt_bmp085_driver_fn_list.get_data(
dd_handle,
&sensors[0],
1,
&memhandler,
&data);
if (data[0].sensor != SNS_DDF_SENSOR_PRESSURE)
{
return SNS_DDF_EFAIL;
}
/* Expected Range 80K-120K Pascals = 800-1200 hPa*/
/* P=1013.25 hPa At sea level */
if ((data[0].samples->sample < FX_FLTTOFIX_Q16(800.0)) ||
(data[0].samples->sample > FX_FLTTOFIX_Q16(1200.0)))
{
return SNS_DDF_EFAIL;
}
status = sns_alt_bmp085_driver_fn_list.get_data(
dd_handle,
&sensors[1],
1,
&memhandler,
&data);
if (data[0].sensor != SNS_DDF_SENSOR_TEMP)
{
return SNS_DDF_EFAIL;
}
/* Expected Range 30-40 °C (Celcius).
Expected 22°C at the lab + It is hotter inside the Fluid/Surf/FFA. */
if ((data[0].samples->sample < FX_FLTTOFIX_Q16(30.0)) ||
(data[0].samples->sample > FX_FLTTOFIX_Q16(40.0)))
{
return SNS_DDF_EFAIL;
}
status = bmp085_get_all_attrib(dd_handle, memhandler);
if (status != SNS_DDF_SUCCESS)
{
PR_ERR("Get attrib err=%d.\n", status);
return SNS_DDF_EFAIL;
}
status = bmp085_set_all_attrib(dd_handle);
if (status != SNS_DDF_SUCCESS)
{
PR_ERR("Set attrib err=%d.\n", status);
return SNS_DDF_EFAIL;
}
return SNS_DDF_SUCCESS;
}
/***********************************************************
* Function: gw_lc_bind_device
* Input:
* Output:
* Return:
***********************************************************/
OPERATE_RET gw_lc_bind_device(IN CONST DEV_DESC_IF_S *dev_if,\
IN CONST CHAR *sch_json_arr)
{
if(NULL == dev_if || \
NULL == sch_json_arr) {
return OPRT_INVALID_PARM;
}
if(get_dev_cntl(dev_if->id)) {
return OPRT_OK;
}
cJSON *root = NULL;
OPERATE_RET op_ret = OPRT_OK;
root = cJSON_Parse(sch_json_arr);
if(NULL == root) {
return OPRT_CJSON_PARSE_ERR;
}
INT dp_num;
DEV_CNTL_N_S *dev_cntl = NULL;
dp_num = cJSON_GetArraySize(root);
if(0 == dp_num) {
op_ret = OPRT_INVALID_PARM;
goto ERR_EXIT;
}
dev_cntl = (DEV_CNTL_N_S *)Malloc(sizeof(DEV_CNTL_N_S)+dp_num*sizeof(DP_CNTL_S));
if(NULL == dev_cntl) {
op_ret = OPRT_MALLOC_FAILED;
goto ERR_EXIT;
}
memset(dev_cntl,0,sizeof(DEV_CNTL_N_S)+dp_num*sizeof(DP_CNTL_S));
memcpy(&dev_cntl->dev_if,dev_if,sizeof(DEV_DESC_IF_S));
dev_cntl->dp_num = dp_num;
// dp schema parse
INT i;
DP_DESC_IF_S *dp_desc;
DP_PROP_VALUE_U *prop;
cJSON *cjson;
cJSON *next;
for(i = 0;i < dev_cntl->dp_num;i++) {
dp_desc = &(dev_cntl->dp[i].dp_desc);
prop = &(dev_cntl->dp[i].prop);
cjson = cJSON_GetArrayItem(root,i);
if(NULL == cjson) {
op_ret = OPRT_CJSON_GET_ERR;
goto ERR_EXIT;
}
// id
next = cJSON_GetObjectItem(cjson,"id");
if(NULL == next) {
PR_ERR("get id null");
op_ret = OPRT_CJSON_GET_ERR;
goto ERR_EXIT;
}
if(next->type == cJSON_String) {
dp_desc->dp_id = atoi(next->valuestring);
}else {
dp_desc->dp_id = next->valueint;
}
// mode
next = cJSON_GetObjectItem(cjson,"mode");
if(NULL == next) {
PR_ERR("get mode null");
op_ret = OPRT_CJSON_GET_ERR;
goto ERR_EXIT;
}
if(!strcmp(next->valuestring,"rw")) {
dp_desc->mode = M_RW;
}else if(!strcmp(next->valuestring,"ro")) {
dp_desc->mode = M_RO;
}else {
dp_desc->mode = M_WR;
}
// passive
next = cJSON_GetObjectItem(cjson,"passive");
if(next == NULL) {
dp_desc->passive = FALSE;
}else {
dp_desc->passive = next->type;
dev_cntl->preprocess = TRUE;
}
// trigger
next = cJSON_GetObjectItem(cjson,"trigger");
if(NULL == next) {
dp_desc->trig_t = TRIG_PULSE;
}else {
if(!strcmp(next->valuestring,"pulse")) {
dp_desc->trig_t = TRIG_PULSE;
}else {
dp_desc->trig_t = TRIG_DIRECT;
}
}
// type
next = cJSON_GetObjectItem(cjson,"type");
if(NULL == next) {
PR_ERR("get type null");
op_ret = OPRT_CJSON_GET_ERR;
goto ERR_EXIT;
}
if(!strcmp(next->valuestring,"obj")) {
dp_desc->type = T_OBJ;
}else if(!strcmp(next->valuestring,"raw")) {
dp_desc->type = T_RAW;
continue;
}else {
dp_desc->type = T_FILE;
continue;
}
// property
next = cJSON_GetObjectItem(cjson,"property");
if(NULL == next) {
PR_ERR("get property null");
op_ret = OPRT_CJSON_GET_ERR;
goto ERR_EXIT;
}
cJSON *child;
child = cJSON_GetObjectItem(next,"type");
if(NULL == next) {
PR_ERR("get type null");
op_ret = OPRT_CJSON_GET_ERR;
goto ERR_EXIT;
}
if(!strcmp(child->valuestring,"bool")) {
dp_desc->prop_tp = PROP_BOOL;
}else if(!strcmp(child->valuestring,"value")) {
dp_desc->prop_tp = PROP_VALUE;
CHAR *str[] = {"max","min","scale"};
INT i;
for(i = 0; i < CNTSOF(str);i++) {
child = cJSON_GetObjectItem(next,str[i]);
if(NULL == child && (i != CNTSOF(str)-1)) {
PR_ERR("get property null");
op_ret = OPRT_CJSON_GET_ERR;
goto ERR_EXIT;
}else if(NULL == child && (i == CNTSOF(str)-1)) {
prop->prop_value.scale = 0;
}else {
switch(i) {
case 0: prop->prop_value.max = child->valueint; break;
case 1: prop->prop_value.min = child->valueint; break;
//case 2: prop->prop_value.step = child->valueint; break;
case 2: prop->prop_value.scale = child->valueint; break;
}
}
}
}else if(!strcmp(child->valuestring,"string")) {
dp_desc->prop_tp = PROP_STR;
child = cJSON_GetObjectItem(next,"maxlen");
if(NULL == child) {
PR_ERR("get maxlen null");
op_ret = OPRT_CJSON_GET_ERR;
goto ERR_EXIT;
}
prop->prop_str.max_len = child->valueint;
prop->prop_str.value = Malloc(prop->prop_str.max_len+1);
if(NULL == prop->prop_str.value) {
PR_ERR("malloc error");
op_ret = OPRT_MALLOC_FAILED;
goto ERR_EXIT;
}
}else {
dp_desc->prop_tp = PROP_ENUM;
child = cJSON_GetObjectItem(next,"range");
if(NULL == child) {
PR_ERR("get range null");
op_ret = OPRT_CJSON_GET_ERR;
goto ERR_EXIT;
}
INT i,num;
num = cJSON_GetArraySize(child);
if(num == 0) {
PR_ERR("get array size error");
op_ret = OPRT_CJSON_GET_ERR;
goto ERR_EXIT;
}
prop->prop_enum.pp_enum = Malloc(num*sizeof(CHAR *));
if(NULL == prop->prop_enum.pp_enum) {
PR_ERR("malloc error");
op_ret = OPRT_MALLOC_FAILED;
goto ERR_EXIT;
}
prop->prop_enum.cnt = num;
for(i = 0;i < num;i++) {
cJSON *c_child = cJSON_GetArrayItem(child,i);
if(NULL == c_child) {
PR_ERR("get array null");
op_ret = OPRT_CJSON_GET_ERR;
goto ERR_EXIT;
}
prop->prop_enum.pp_enum[i] = cJSON_strdup(c_child->valuestring);
if(NULL == prop->prop_enum.pp_enum[i]) {
PR_ERR("malloc error");
op_ret = OPRT_MALLOC_FAILED;
goto ERR_EXIT;
}
}
}
}
os_mutex_get(&gw_mutex, OS_WAIT_FOREVER);
if(NULL == gw_cntl.dev) {
gw_cntl.dev = dev_cntl;
}else {
DEV_CNTL_N_S *tmp_dev_cntl = gw_cntl.dev;
while(tmp_dev_cntl->next) {
tmp_dev_cntl = tmp_dev_cntl->next;
}
tmp_dev_cntl->next = dev_cntl;
}
gw_cntl.dev_num++;
os_mutex_put(&gw_mutex);
if(root) {
cJSON_Delete(root);
}
return OPRT_OK;
ERR_EXIT:
if(dev_cntl) {
Free(dev_cntl);
}
if(root) {
cJSON_Delete(root);
}
return op_ret;
}
static void dev_ul_timer_cb(os_timer_arg_t arg)
{
if(get_gw_status() <= ACTIVE_RD) {
os_timer_deactivate(&dev_ul_timer);
}
GW_WIFI_STAT_E wf_stat;
wf_stat = get_wf_gw_status();
if(wf_stat != STAT_STA_CONN) {
// PR_DEBUG("we can not update info,because the wifi state is :%d",wf_stat);
return;
}
else {
PR_DEBUG("now,we'll go to update device info");
}
// TODO 1 http device bind
// 2 device info update
GW_CNTL_S *gw_cntl = get_gw_cntl();
DEV_CNTL_N_S *dev_cntl = NULL;
BOOL close_timer = TRUE;
OPERATE_RET op_ret = OPRT_OK;
for(dev_cntl = gw_cntl->dev;dev_cntl;dev_cntl = dev_cntl->next) {
// device bind
if(FALSE == dev_cntl->dev_if.bind) {
PR_DEBUG("bind");
op_ret = httpc_dev_bind(&dev_cntl->dev_if);
if(OPRT_OK != op_ret) {
close_timer = FALSE;
continue;
}
os_mutex_get(&gw_mutex, OS_WAIT_FOREVER);
dev_cntl->dev_if.bind = TRUE;
dev_cntl->dev_if.sync = FALSE;
os_mutex_put(&gw_mutex);
op_ret = ws_db_set_dev_if(&dev_cntl->dev_if);
if(OPRT_OK != op_ret) {
PR_ERR("ws_db_set_dev_if error,op_ret:%d",op_ret);
}
}
// device info update
if(TRUE == dev_cntl->dev_if.sync && \
TRUE == dev_cntl->dev_if.bind) {
PR_DEBUG("update");
op_ret = httpc_dev_update(&dev_cntl->dev_if);
if(OPRT_OK != op_ret) {
close_timer = FALSE;
continue;
}
os_mutex_get(&gw_mutex, OS_WAIT_FOREVER);
dev_cntl->dev_if.sync = FALSE;
os_mutex_put(&gw_mutex);
op_ret = ws_db_set_dev_if(&dev_cntl->dev_if);
if(OPRT_OK != op_ret) {
PR_ERR("ws_db_set_dev_if error,op_ret:%d",op_ret);
}
}
}
if(TRUE == close_timer) {
int ret = os_timer_deactivate(&dev_ul_timer);;
PR_DEBUG("close timer ret:%d",ret);
}
}
static void process_skb(struct sk_buff *oskb)
{
int ulen, len, dnslen;
struct sk_buff *nskb;
struct iphdr *oiph, *niph;
struct udphdr *oudph, *nudph, _oudph;
struct dnshdr *dnsh;
oiph = ip_hdr(oskb);
oudph = skb_header_pointer(oskb, ip_hdrlen(oskb),
sizeof(_oudph), &_oudph);
if (oudph == NULL) {
PR_ERR("Invalid UDP packet, dropped");
return;
}
/*
* 5 is the minimal question length
* (1 byte root, 2 bytes each type and class)
*/
dnslen = ntohs(oudph->len) - sizeof(struct udphdr);
if (dnslen < sizeof(struct dnshdr) + 5) {
PR_ERR("Incomplete DNS packet, dropped");
return;
}
dnsh = (struct dnshdr *) ((unsigned char *) oudph + sizeof(struct udphdr));
ulen = sizeof(struct udphdr) + MAX_DNS_PACKET_LEN;
nskb = alloc_skb(LL_MAX_HEADER + sizeof(struct iphdr) + ulen, GFP_ATOMIC);
if (nskb == NULL) {
PR_CRIT("alloc_skb failed, dropped");
return;
}
skb_reserve(nskb, LL_MAX_HEADER
+ sizeof(struct iphdr)
+ sizeof(struct udphdr));
len = process_query(oiph, oudph, dnsh, dnslen, nskb->data);
if (len < 0) {
kfree_skb(nskb);
PR_CRIT("process dns query failed, dropped");
return;
}
nskb->len += len;
nudph = (struct udphdr *) skb_push(nskb, sizeof(struct udphdr));
skb_reset_transport_header(nskb);
ulen = sizeof(struct udphdr) + len;
nudph->source = oudph->dest;
nudph->dest = oudph->source;
nudph->len = htons(ulen);
nudph->check = 0;
nudph->check = csum_tcpudp_magic(oiph->daddr,
oiph->saddr,
ulen,
IPPROTO_UDP,
csum_partial(nudph, ulen, 0));
if (nudph->check == 0) {
nudph->check = CSUM_MANGLED_0;
}
niph = (struct iphdr *) skb_push(nskb, sizeof(struct iphdr));
skb_reset_network_header(nskb);
/* niph->version = 4; niph->ihl = 5; */
put_unaligned(0x45, (unsigned char *) niph);
niph->tos = 0;
put_unaligned(htons(nskb->len), &(niph->tot_len));
niph->id = 0x8659; /* birthday of my wife ^o^ */
niph->frag_off = htons(IP_DF);
niph->ttl = 64;
niph->protocol = IPPROTO_UDP;
niph->check = 0;
put_unaligned(oiph->daddr, &(niph->saddr));
put_unaligned(oiph->saddr, &(niph->daddr));
ip_send_check(niph);
skb_dst_set(nskb, dst_clone(skb_dst(oskb)));
if (ip_route_me_harder(nskb, RTN_LOCAL)) {
goto free_nskb;
}
nf_ct_attach(nskb, oskb);
ip_local_out(nskb);
return;
free_nskb:
kfree_skb(nskb);
}
