SmartPDCode/f427/applications/paras.c

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <rtklibc.h>
#include "sys.h"
#include "fs.h"
#include "lock.h"
#include "list.h"
#include "paras.h"
#include "dictionary.h"
#include "iniparser.h"
#include "db.h"
#include "log.h"



#define MALLOC   malloc
#define FREE     free

enum {
    TYPE_INT=0,
    TYPE_STR,
    TYPE_FLOAT,
};

enum {
    PARAS_CHECK=0,
    PARAS_READ,
    PARAS_WRITE,
    PARAS_CREATE,
};

extern const paras_data_t DFLT_PARAS;

typedef struct {
    dictionary          *dic;
    paras_data_t        paras;
    char                path[100];
    
    lock_t              lck;
}paras_handle_t;
static paras_handle_t  paraHandle={0};


#if 1
static int is_power3(void)
{
    paras_handle_t *h=&paraHandle;
    if(h->paras.prod.type>=PDU_AC_I3O3) {
        return 1;
    }
    return 0;
}
static int feq(double a, double b)
{
    return (fabs(a-b)<(1e-6))?1:0;
}
static int str_cnt(char *buf, char *s)
{
    int cnt=0;
    char *p=buf;
    while(1) {
        p = strstr(p, s);
        if(!p) break;
        cnt++;
    }
    return cnt;
}
static int str_del(char *b, char *s)
{
    if(!b || !b[0]) {
        return -1;
    }

    int sl=strlen(s);
    char *p1,*p2,*b2=rt_strdup(b);
    if(!b2) return -1;

    p1=b2;
    while(1) {
        p2=strstr(p1,s); if(!p2) break;

        memcpy(b,p1,p2-p1);
        b += p2-p1; p1 = p2+sl;
    }
    strcpy(b,p1); FREE(b2);
    
    return 0;
}
static int str_replace(char *b, char *s1, char *s2)
{
    if(!b || !b[0] || !s1 || !s1[0] || !s2 || !s2[0]) {
        return -1;
    }

    int l1=strlen(s1),l2=strlen(s2);
    if(l1 != l2) {
        return -1;
    }

    char *p=b;
    while(1) {
        p = strstr(p,s1);
        if(!p) break;
        memcpy(p, s2, l1);
        p += l1;
    }
    return 0;
}
static int ini_dump(char *path, dictionary *dic)
{
    FILE *fp=fopen(path, "a+");
    if(!fp) {
        return -1;
    }
    iniparser_dump_ini(dic, fp);
    return fclose(fp);
}
static void sec_cpy(char *sec, char *key)
{
    while((*key)!=':') *sec++ = *key++;
    *sec = 0;
}
static int ini_write(dictionary *dic, char *key, void *val, int len, int type, int str_chk)
{
    int r=-1;
    char *p,sec[100],tmp[100];

    sec_cpy(sec, key);
    r = iniparser_set(dic, sec, NULL);
    if (r<0) {
        LOGE("___ini_rw section %s failed\n", sec);
        return -1;
    }
    
    if(type==TYPE_INT) {
        sprintf(tmp, "%d", *((int*)val)); p = tmp;
    }
    else if(type==TYPE_STR) {
        p = (char*)val;
        if(str_chk && p[0]==0) {
            return -1;
        }
    }
    else if(type==TYPE_FLOAT) {
        sprintf(tmp, "%0.2f", *((float*)val)); p = tmp;
    }
    else {
        return -1;
    }

    r = iniparser_set(dic, key, p);
    if(r<0) {
        LOGE("___ini_rw %s failed\n", key);
    }

    return r;
}
static int ini_read(dictionary *dic, char *key, void *val, int len, int type, int str_chk)
{
    int r=0;

    if(type==TYPE_INT) {
        int t = iniparser_getint(dic, key, -1);
        if(t==-1) {
            return -1;
        }
        *(((int*)val)) = t;
    }
    else if(type==TYPE_STR) {
        ((char*)val)[0] = 0;
        char *p = (char*)iniparser_getstring(dic, key, NULL);
        if(!p) {
            return -1;
        }

        int xlen=strlen(p);
        if(str_chk && xlen==0) {
            return -1;
        }
        if(len<=xlen) {
            LOGE("___ %s val len %d longer than recv buf len %d\n", key, xlen, len);
            return -1;
        }
        strcpy((char*)val, p);
    }
    else if(type==TYPE_FLOAT) {
        double c=-10000.0;
        double f = (float)iniparser_getdouble(dic, key, c);
        if(feq(f,c)) {
            return -1;
        }
        *((float*)val) = (float)f;
    }

    return 0;
}
static int ini_rw(dictionary *dic, char *key, void *val, int len, int type, int io, int str_chk)
{
    int r=-1;
    if(io==PARAS_READ) {
        r = ini_read(dic,key,val,len,type,str_chk);
    }
    else if(io==PARAS_WRITE) {
        r = ini_write(dic,key,val,len,type,str_chk);
    }
    return r;
}


static int proc_prod(dictionary *dic, int op, product_data_t *prod)
{
    int r=0;
    char *p=NULL;
    char temp[100];
    char *token=NULL;

    if(op==PARAS_CHECK) {
        if(prod->type>PDU_AC_I3O1_H) {
            LOGE("___ check product.type %d is wrong\n", prod->type);
            r = -1;
        }
        return r;
    }
    else if(op==PARAS_WRITE) {
        r = proc_prod(dic, PARAS_CHECK, prod);
        if(r) {
            return -1;
        }
    }

    token = "product:id";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            prod->id = r;
        }
    }
    else {
        sprintf(temp, "%d", prod->id);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    /*
    token = "product:number";
    if(op==PARAS_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1;
        } else {
            strcpy(prod->number, p);
        }
    }
    else {
        r = iniparser_set(dic, token, prod->number);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }
    */
    token = "product:name";
    if(op==PARAS_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1;
        } else {
            strcpy(prod->name, p);
        }
    }
    else {
        r = iniparser_set(dic, token, prod->name);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }
 
    token = "product:type";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            prod->type = r;
        }
    }
    else {
        sprintf(temp, "%d", prod->type);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

#if 0
    token = "product:version";
    if(op==PARAS_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1;
        } else {
            strcpy(prod->version, p);
        }
    }
    else {
        r = iniparser_set(dic, token, prod->version);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }
#endif

    token = "product:samptime";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            prod->samp_time = r;
        }
    }
    else {
        sprintf(temp, "%d", prod->samp_time);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "product:savetime";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            prod->save_time = r;
        }
    }
    else {
        sprintf(temp, "%d", prod->save_time);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "product:ph_group";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            prod->ph_group = r;
        }
    }
    else {
        sprintf(temp, "%d", prod->ph_group);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "product:ch_delay";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            prod->ch_delay = r;
        }
    }
    else {
        sprintf(temp, "%d", prod->ch_delay);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    r = 0;
    if(op==PARAS_READ) {
        prod->count = 0;
        prod->status[0] = 0;
        r = proc_prod(dic, PARAS_CHECK, prod);
    }

    return r;
}
static int proc_modbus(dictionary *dic, int op, modbus_data_t *mb)
{
    int r=0;
    char temp[100];
    char *p,*token=NULL;

    if(op==PARAS_CHECK) {
        if(mb->mode!=0 && mb->mode!=1) {
            LOGE("___ check modbus, mode %d is invalid\n", mb->mode);
            r = -1; 
        }

        if(mb->mode==1 && (mb->addr==0 || mb->addr>POWER_CASCADE_MAX)) {    //slave
            LOGE("___ check modbus, slave addr %d is invalid\n", mb->addr);
            r = -1;
        }
        return r;
    }
    else if (op==PARAS_WRITE) {
        r = proc_modbus(dic, PARAS_CHECK, mb);
        if(r) {
            return -1;
        }
    }

    token = "modbus:mode";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            mb->mode = r;
        }
    }
    else {
        sprintf(temp, "%d", mb->mode);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "modbus:address";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            mb->addr = r;
        }
    }
    else {
        sprintf(temp, "%d", mb->addr);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "modbus:baudrate";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            mb->baud = r;
        }
    }
    else {
        sprintf(temp, "%d", mb->baud);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    r = 0;
    if(op==PARAS_READ) {
        r = proc_modbus(dic, PARAS_CHECK, mb);
    }

    return r;
}



static int proc_phase_3_1(dictionary *dic,int op,phase_seq_3_1_t *ph_1)
{
    int r=0;
    char temp[100];
    char *p,*token=NULL;

    if(op==PARAS_CHECK) {
			return 0;
    }
    else if (op==PARAS_CREATE) {
			return 0;
    }
    else if (op==PARAS_WRITE) {
        r = proc_phase_3_1(dic, PARAS_CHECK, ph_1);
        if(r) {
            return -1;
        }
    }	
		token = "ph_3_1:phase";
    if(op==PARAS_READ) {
        const char * str = iniparser_getstring(dic, token,NULL);
        if(str == NULL) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1;
        } else {
            memcpy(&ph_1->phase_seq[0],str,strlen(str));
        }
    }
    else {
        sprintf(temp, "%s", ph_1->phase_seq);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
				}
		}
		
	   r = 0;
    if(op==PARAS_READ) {
        r = proc_phase_3_1(dic, PARAS_CHECK, ph_1);
    }

    return r;			
}

static int proc_phase_3_2(dictionary *dic,int op,phase_seq_3_2_t *ph_2)
{
    int r=0;
    char temp[100];
    char *p,*token=NULL;

    if(op==PARAS_CHECK) {
			return 0;
    }
    else if (op==PARAS_CREATE) {
			return 0;
    }
    else if (op==PARAS_WRITE) {
        r = proc_phase_3_2(dic, PARAS_CHECK, ph_2);
        if(r) {
            return -1;
        }
    }	
		token = "ph_3_2:phase_left";
    if(op==PARAS_READ) {
        const char * str = iniparser_getstring(dic, token,NULL);
        if(str == NULL) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1;
        } else {
            memcpy(&ph_2->phase_left[0],str,strlen(str));
        }
    }
    else {
        sprintf(temp, "%s", ph_2->phase_left);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
				}
		}
		
		token = "ph_3_2:phase_right";
    if(op==PARAS_READ) {
        const char * str = iniparser_getstring(dic, token,NULL);
        if(str == NULL) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1;
        } else {
            memcpy(&ph_2->phase_right[0],str,strlen(str));
        }
    }
    else {
        sprintf(temp, "%s", ph_2->phase_right);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
				}
		}
				
		
	   r = 0;
    if(op==PARAS_READ) {
        r = proc_phase_3_2(dic, PARAS_CHECK, ph_2);
    }

    return r;		
				
}



static int proc_sensor(dictionary *dic, int op, sensor_th_t sensor[])
{
    int r=0;
    char temp[100];
    char *p,*token=NULL;

    if(op==PARAS_CHECK) {
			return 0;
    }
    else if (op==PARAS_CREATE) {
			return 0;
    }
    else if (op==PARAS_WRITE) {
        r = proc_sensor(dic, PARAS_CHECK, sensor);
        if(r) {
            return -1;
        }
    }	
		
// 1
		token = "sensor_1:th_max_1";
		 if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            sensor[0].th_max_1 = r;
        }
    }
    else {
        sprintf(temp, "%d", sensor[0].th_max_1);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }
		token = "sensor_1:th_min_1";
		 if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            sensor[0].th_min_1 = r;
        }
    }
    else {
        sprintf(temp, "%d", sensor[0].th_min_1);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

		token = "sensor_1:th_max_2";
		 if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            sensor[0].th_max_2 = r;
        }
    }
    else {
        sprintf(temp, "%d", sensor[0].th_max_2);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }
		
		token = "sensor_1:th_min_2";
		 if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            sensor[0].th_min_2 = r;
        }
    }
    else {
        sprintf(temp, "%d", sensor[0].th_min_2);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }	
// 2	
		token = "sensor_2:th_max_1";
		 if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            sensor[1].th_max_1 = r;
        }
    }
    else {
        sprintf(temp, "%d", sensor[1].th_max_1);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }
		token = "sensor_2:th_min_1";
		 if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            sensor[1].th_min_1 = r;
        }
    }
    else {
        sprintf(temp, "%d", sensor[1].th_min_1);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

		token = "sensor_2:th_max_2";
		 if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            sensor[1].th_max_2 = r;
        }
    }
    else {
        sprintf(temp, "%d", sensor[1].th_max_2);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }
		
		token = "sensor_2:th_min_2";
		 if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            sensor[1].th_min_2 = r;
        }
    }
    else {
        sprintf(temp, "%d", sensor[1].th_min_2);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }			
//3
		token = "sensor_3:th_max_1";
		 if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            sensor[2].th_max_1 = r;
        }
    }
    else {
        sprintf(temp, "%d", sensor[2].th_max_1);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }
		token = "sensor_3:th_min_1";
		 if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            sensor[2].th_min_1 = r;
        }
    }
    else {
        sprintf(temp, "%d", sensor[2].th_min_1);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

		token = "sensor_3:th_max_2";
		 if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            sensor[2].th_max_2 = r;
        }
    }
    else {
        sprintf(temp, "%d", sensor[2].th_max_2);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }
		
		token = "sensor_3:th_min_2";
		 if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            sensor[2].th_min_2 = r;
        }
    }
    else {
        sprintf(temp, "%d", sensor[2].th_min_2);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }			
		
    r = 0;
    if(op==PARAS_READ) {
        r = proc_sensor(dic, PARAS_CHECK, sensor);
    }

    return r;		
}


static int proc_snmp_n(dictionary *dic, int op, snmp_data_t *snmp)
{

    int r=0;
    char temp[100];
    char *p,*token=NULL;
		if(op==PARAS_CHECK) {
			return 0;
		}else if (op==PARAS_CREATE) {
			return 0;
		}else if (op==PARAS_WRITE) {
        r = proc_snmp_n(dic, PARAS_CHECK, snmp);
        if(r) {
            return -1;
        }
		}
		token = "snmp:mode";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            snmp->mode = r;
        }
    }
    else {
        sprintf(temp, "%d", snmp->mode);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }			
		token = "snmp:version";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            snmp->version = r;
        }
    }
    else {
        sprintf(temp, "%d", snmp->version);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

		token = "snmp:public";
    if(op==PARAS_READ) {
        const char * str = iniparser_getstring(dic, token,NULL);
        if(str == NULL) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1;
        } else {
            memcpy(snmp->publics,str,strlen(str));
        }
    }
    else {
        sprintf(temp, "%s", snmp->publics);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

		token = "snmp:trap_mode";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            snmp->trapmode = r;
        }
    }
    else {
        sprintf(temp, "%d", snmp->trapmode);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }		
		token = "snmp:nms_ip";
    if(op==PARAS_READ) {
        const char * str = iniparser_getstring(dic, token,NULL);
        if(str == NULL) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1;
        } else {
            memcpy(snmp->nms_ip,str,strlen(str));
        }
    }
    else {
        sprintf(temp, "%s", snmp->nms_ip);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }
		r = 0;
    if(op==PARAS_READ) {
        r = proc_snmp_n(dic, PARAS_CHECK, snmp);
    }	
		return r;
}



static int proc_net(dictionary *dic, int op,network_data_t *net)
{
    int r=0;
    char temp[100];
    char *p,*token=NULL;
		if(op==PARAS_CHECK) {
			return 0;
		}else if (op==PARAS_CREATE) {
			return 0;
		}else if (op==PARAS_WRITE) {
        r = proc_net(dic, PARAS_CHECK, net);
        if(r) {
            return -1;
        }
		}
		token = "network:mode";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            net->mode = r;
        }
    }
    else {
        sprintf(temp, "%d", net->mode);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }	
		token = "network:ipaddr";
    if(op==PARAS_READ) {
        const char * str = iniparser_getstring(dic, token,NULL);
        if(str == NULL) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1;
        } else {
            memcpy(net->ipaddr,str,strlen(str));
        }
    }
    else {
        sprintf(temp, "%s", net->ipaddr);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }
		token = "network:mask";
    if(op==PARAS_READ) {
        const char * str = iniparser_getstring(dic, token,NULL);
        if(str == NULL) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1;
        } else {
            memcpy(net->mask,str,strlen(str));
        }
    }
    else {
        sprintf(temp, "%s", net->mask);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }			

		token = "network:gateway";
    if(op==PARAS_READ) {
        const char * str = iniparser_getstring(dic, token,NULL);
        if(str == NULL) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1;
        } else {
            memcpy(net->gateway,str,strlen(str));
        }
    }
    else {
        sprintf(temp, "%s", net->gateway);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }				

		token = "network:dns1";
    if(op==PARAS_READ) {
        const char * str = iniparser_getstring(dic, token,NULL);
        if(str == NULL) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1;
        } else {
            memcpy(net->dns1,str,strlen(str));
        }
    }
    else {
        sprintf(temp, "%s", net->dns1);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }					

		token = "network:dns2";
    if(op==PARAS_READ) {
        const char * str = iniparser_getstring(dic, token,NULL);
        if(str == NULL) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1;
        } else {
            memcpy(net->dns2,str,strlen(str));
        }
    }
    else {
        sprintf(temp, "%s", net->dns2);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }		
    r = 0;
    if(op==PARAS_READ) {
        r = proc_net(dic, PARAS_CHECK, net);
    }		
		
		return r;
}


static int proc_misc(dictionary *dic, int op, misc_data_t *misc)
{
    int r=0;
    char temp[100];
    char *p,*token=NULL;

    if(op==PARAS_CHECK) {
        if(misc->watchdog<0 || misc->watchdog>1) {
            LOGE("___ check misc, watchdog is invalid, correct value is 0/1\n");
            r = -1; 
        }

        if(misc->flip_time<0) {
            LOGE("___ check misc, flip_time is invalid, must greater than 0\n");
            r = -1; 
        }

        if(misc->led<0 || misc->led>1) {
            LOGE("___ check misc, led is invalid, correct value is 0/1\n");
            r = -1; 
        }

        if(misc->beep<0 || misc->beep>1) {
            LOGE("___ check misc, beep is invalid, correct value is 0/1\n");
            r = -1; 
        }

        if(misc->rotate!=0 && misc->rotate!=90 && misc->rotate!=180 && misc->rotate!=270) {
            LOGE("___ check misc, rotate is invalid, correct value is 0/90/180/270\n");
            r = -1; 
        }
    }
    else if (op==PARAS_CREATE) {

    }
    else if (op==PARAS_WRITE) {
        r = proc_misc(dic, PARAS_CHECK, misc);
        if(r) {
            return -1;
        }
    }

    token = "misc:watchdog";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            misc->watchdog = r;
        }
    }
    else {
        sprintf(temp, "%d", misc->watchdog);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "misc:fliptime";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            misc->flip_time = r;
        }
    }
    else {
        sprintf(temp, "%d", misc->flip_time);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "misc:led";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            misc->led = r;
        }
    }
    else {
        sprintf(temp, "%d", misc->led);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "misc:beep";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            misc->beep = r;
        }
    }
    else {
        sprintf(temp, "%d", misc->beep);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "misc:rotate";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            misc->rotate = r;
        }
    }
    else {
        sprintf(temp, "%d", misc->rotate);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    r = 0;
    if(op==PARAS_READ) {
        r = proc_misc(dic, PARAS_CHECK, misc);
    }

    return r;
}

#if 0
static int proc_ntp(char *path, int op, NTPManager *ntp)
{
    int r=0;
    char temp[100];
    char *p,*token=NULL;
    FILE *fp=NULL;
    dictionary *dic=NULL;
    GlobalDeviceManager *dm=get_dm();
    NTPManager ntp2,*pntp=ntp;

    switch(op) {
        case PARAS_CHECK:
        {
            if(pntp->mode<0 || pntp->mode>1) {
                LOGE("___ check ntp, mode is wrong, correct value is 0/1\n");
                r = -1;
            }

            if(!pntp->ntpName[0]) {
                LOGE("___ check ntp, name is null\n");
                r = -1;
            }

            if(!pntp->ntpaddress[0]) {
                LOGE("___ check ntp, addr is null\n");
                r = -1;
            }

            if(pntp->tzone>12 || pntp->tzone<-12) {
                LOGE("___ check ntp, tzong is wrong, correct range is -12~12\n");
                r = -1;
            }
            return r;
        }
        break;

        case PARAS_CREATE:
        {
            FILE *fp = fopen(path, "a+");
            if(!fp) {
                LOGE("___ %s open failed\n", path);
                return -1;
            }

            fprintf(fp, "[ntp]\n");
            fprintf(fp, "mode        = \"%d\"\n", pntp->mode);
            fprintf(fp, "name        = \"%s\"\n", pntp->ntpName);
            fprintf(fp, "address     = \"%s\"\n", pntp->ntpaddress);
            fprintf(fp, "port        = \"%d\"\n", pntp->port);
            fprintf(fp, "tzone       = \"%d\"\n", pntp->tzone);
            fprintf(fp, "\n");

            fclose(fp);
            return 0;
        }
        break;

        case PARAS_READ:
        {
            pntp = &ntp2;
            dic = iniparser_load(path); if(!dic) return -1;

            memset(pntp, 0, sizeof(NTPManager));
            r = ini_rw(dic, "ntp:mode",    &pntp->mode,      sizeof(pntp->mode),       TYPE_INT, op, 1); if(r) goto quit;
            r = ini_rw(dic, "ntp:name",    pntp->ntpName,    sizeof(pntp->ntpName),    TYPE_STR, op, 1); if(r) goto quit;
            r = ini_rw(dic, "ntp:address", pntp->ntpaddress, sizeof(pntp->ntpaddress), TYPE_STR, op, 1); if(r) goto quit;
            r = ini_rw(dic, "ntp:port",    &pntp->port,      sizeof(pntp->port),       TYPE_INT, op, 1); if(r) goto quit;
            r = ini_rw(dic, "ntp:tzone",   &pntp->tzone,     sizeof(pntp->tzone),      TYPE_INT, op, 1); if(r) goto quit;
            r = ini_rw(dic, "ntp:time",    pntp->time,       sizeof(pntp->time),       TYPE_STR, op, 1); if(r) goto quit;

            pntp->product_id = 0;
            r = proc_ntp(path, PARAS_CHECK, pntp);      if(r) goto quit;
            //r = dev_clear_table(dm->db, TAB_ID_NTP);  if(r) goto quit;
            r = dev_update_ntp_info(dm->db, 0, pntp);
        }
        break;

        case PARAS_WRITE:
        {
            pntp = &ntp2;
            r = dev_get_ntp_info(dm->db, pntp);    if(r) return -1;
            r = proc_ntp(path, PARAS_CHECK, pntp); if(r) return -1;
            dic = dictionary_new(0);               if(!dic) return -1;

            r = ini_rw(dic, "ntp:mode",    &pntp->mode,      sizeof(pntp->mode),       TYPE_INT, op, 1); if(r) goto quit;
            r = ini_rw(dic, "ntp:name",    pntp->ntpName,    sizeof(pntp->ntpName),    TYPE_STR, op, 1); if(r) goto quit;
            r = ini_rw(dic, "ntp:address", pntp->ntpaddress, sizeof(pntp->ntpaddress), TYPE_STR, op, 1); if(r) goto quit;
            r = ini_rw(dic, "ntp:port",    &pntp->port,      sizeof(pntp->port),       TYPE_INT, op, 1); if(r) goto quit;
            r = ini_rw(dic, "ntp:tzone",   &pntp->tzone,     sizeof(pntp->tzone),      TYPE_INT, op, 1); if(r) goto quit;
            r = ini_rw(dic, "ntp:time",    pntp->time,       sizeof(pntp->time),       TYPE_STR, op, 1); if(r) goto quit;
            r = ini_dump(path, dic);
        }
        break;

        default:
        return -1;
    }

quit:
    iniparser_freedict(dic);
    return r;
}
#endif





static int proc_snmp(char *path, int op, snmp_data_t *snmp)
{
    int r=0,len=0;
    char temp[100];
    char *p,*token=NULL;
    dictionary *dic=NULL;
    snmp_data_t *psnmp=snmp;
    //GlobalDeviceManager *dm=get_dm();

    switch(op) {
        case PARAS_CHECK:
        {
            if(psnmp->mode<0 || psnmp->mode>1) {
                LOGE("___ check snmp, mode %d is wrong, correct value is 0/1\n", psnmp->mode);
                r = -1; 
            }

            if(psnmp->mode==1) {
                if(!psnmp->publics[0]) {
                    LOGE("___ check snmp, no public input\n");
                    r = -1; 
                }

                if(psnmp->trapmode<0 || psnmp->trapmode>1) {
                    LOGE("___ check snmp, trapmode %d is wrong, correct value is 0/1\n", psnmp->trapmode);
                    r = -1; 
                }
#if 0
                if(psnmp->version>=1 && sys_ip_check(psnmp->nmsIP)==IP_ERR) {
                    LOGE("___ check snmp, nms ip is invalid\n");
                    r = -1;
                }
#endif
                if(psnmp->version<0 || psnmp->version>2) {
                    LOGE("___ check snmp, version %d is wrong, correct value is 0/1/2\n");
                    r = -1;
                }
#if 0
                if(psnmp->version==2) {

                    if(!psnmp->crypt.user[0]) {
                        LOGE("___ check snmp, crypt user is null\n");
                        r = -1;
                    }

                    len = strlen(psnmp->crypt.user);
                    if(len<8 || len>32) {
                        LOGE("___ check snmp, crypt user length  %d is wrong, correct range is 8~32 characters(english)\n", len);
                        r = -1;
                    }

                    if(!psnmp->crypt.auth.alg[0]) {
                        LOGE("___ check snmp, crypt auth algorithm is null\n");
                        r = -1;
                    }

                    if(strcmp(psnmp->crypt.auth.alg, "MD5") && strcmp(psnmp->crypt.auth.alg, "SHA") && strcmp(psnmp->crypt.auth.alg, "SHA-224") &&
                       strcmp(psnmp->crypt.auth.alg, "SHA-256") && strcmp(psnmp->crypt.auth.alg, "SHA-384") && strcmp(psnmp->crypt.auth.alg, "SHA-512")) {
                       LOGE("___ check snmp, crypt auth algorithm %s is wrong, correct value is: MD5/SHA/SHA-224/SHA-256/SHA-384/SHA-512\n", psnmp->crypt.auth.alg);
                       r = -1;
                    }
                    
                    if(!psnmp->crypt.auth.passwd[0]) {
                        LOGE("___ check snmp, crypt auth password is null\n");
                        r = -1;
                    }

                    len = strlen(psnmp->crypt.auth.passwd);
                    if(len<8 || len>32) {
                        LOGE("___ check snmp, crypt auth password length %d is wrong, correct range is 8~32 characters(english)\n", len);
                        r = -1;
                    }

                    if(!psnmp->crypt.priv.alg[0]) {
                        LOGE("___ check snmp, crypt priv algorithm is null\n");
                        r = -1;
                    }

                    if(strcmp(psnmp->crypt.priv.alg, "DES") && strcmp(psnmp->crypt.priv.alg, "AES")) {
                        
                        LOGE("___ check snmp, crypt priv algorithm %s is wrong, correct value is: 0/DES/AES\n", psnmp->crypt.priv.alg);
                        r = -1;
                    }

                    if(!psnmp->crypt.priv.passwd[0]) {
                        LOGE("___ check snmp, crypt priv password is null\n");
                        r = -1;
                    }

                    len = strlen(psnmp->crypt.priv.passwd);
                    if(len<8 || len>32) {
                        LOGE("___ check snmp, crypt priv password length %d is wrong, correct range is 8~32 characters(english)\n", len);
                        r = -1;
                    }
                }
#endif
            }
            return r;
        }
        break;

        case PARAS_CREATE:
        {
            FILE *fp = fopen(path, "a+");
            if(!fp) {
                LOGE("___ %s open failed\n", path);
                return -1;
            }

            fprintf(fp, "[snmp]\n");
            fprintf(fp, "mode        = \"%d\"\n", snmp->mode);
            fprintf(fp, "version     = \"%d\"\n", snmp->version);
            fprintf(fp, "public      = \"%s\"\n", snmp->publics);
            fprintf(fp, "trap_mode   = \"%d\"\n", snmp->trapmode);
            fprintf(fp, "nms_ip      = \"%s\"\n", snmp->nms_ip);
#if 0
            fprintf(fp, "crypt.user  = \"%s\"\n", snmp->crypt.user);
            fprintf(fp, "crypt.auth.proto     = \"%s\"\n", snmp->crypt.auth.alg);
            fprintf(fp, "crypt.auth.password  = \"%s\"\n", snmp->crypt.auth.passwd);
            fprintf(fp, "crypt.priv.proto     = \"%s\"\n", snmp->crypt.priv.alg);
            fprintf(fp, "crypt.priv.password  = \"%s\"\n", snmp->crypt.priv.passwd);

            fprintf(fp, "nms_ip      = \"%s\"\n", snmp->nms_ip);
#endif
            fprintf(fp, "\n");

            fclose(fp);
        }
        break;

        case PARAS_READ:
        {
           // char ver[32];

            //psnmp = &snmp2;
            dic = iniparser_load(path); if(!dic) return -1;

            memset(psnmp, 0, sizeof(snmp_data_t));
            r = ini_rw(dic, "snmp:mode",     &psnmp->mode,     sizeof(psnmp->mode),    TYPE_INT, op, 1); if(r) goto quit;
            r = ini_rw(dic, "snmp:public",   psnmp->publics,    sizeof(psnmp->publics),  TYPE_STR, op, 1); if(r) goto quit;
            r = ini_rw(dic, "snmp:version",  &psnmp->version,              sizeof(psnmp->version),  TYPE_INT, op, 1); if(r) goto quit;
//            if(strcmp(ver, "V1")==0)       psnmp->version = 0;
//            else if(strcmp(ver, "V2c")==0) psnmp->version = 1;
//            else if(strcmp(ver, "V3")==0)  psnmp->version = 2;
//            else {r=-1; goto quit;}

            r = ini_rw(dic, "snmp:trap_mode",  &psnmp->trapmode,  sizeof(psnmp->trapmode), TYPE_INT, op, 1); if(r) goto quit;
            //if(psnmp->version>=1) {
            r = ini_rw(dic, "snmp:nms_ip",     psnmp->nms_ip,      sizeof(psnmp->nms_ip), TYPE_STR, op, 1); if(r) goto quit;
            //}
#if 0
            if(psnmp->version==2) {
                r = ini_rw(dic, "snmp:crypt.user",          psnmp->crypt.user,        sizeof(psnmp->crypt.user),        TYPE_STR, op, 1); if(r) goto quit;
                r = ini_rw(dic, "snmp:crypt.auth.proto",    psnmp->crypt.auth.alg,    sizeof(psnmp->crypt.auth.alg),    TYPE_STR, op, 1); if(r) goto quit;
                r = ini_rw(dic, "snmp:crypt.auth.password", psnmp->crypt.auth.passwd, sizeof(psnmp->crypt.auth.passwd), TYPE_STR, op, 1); if(r) goto quit;

                r = ini_rw(dic, "snmp:crypt.priv.proto",    psnmp->crypt.priv.alg,    sizeof(psnmp->crypt.priv.alg),    TYPE_STR, op, 1); if(r) goto quit;
                if(strcmp(psnmp->crypt.priv.alg, "NO")==0) {
                    strcpy(psnmp->crypt.priv.alg, "0");
                }

                r = ini_rw(dic, "snmp:crypt.priv.password", psnmp->crypt.priv.passwd, sizeof(psnmp->crypt.priv.passwd), TYPE_STR, op, 1); if(r) goto quit;
            }
#endif
            r = proc_snmp(path, PARAS_CHECK, psnmp);
            if(r==0) {
#if 0
                //r = dev_clear_table(dm->db, TAB_ID_SNMP);  if(r) goto quit;
                r = dev_update_snmp_info(dm->db, 0, psnmp);  if(r) goto quit;

                extern int snmp_config(SNMPManager *m, int quit);
                snmp_config(psnmp, 0);
#endif
						return 0;
            }
        }
        break;

        case PARAS_WRITE:
        {
            //char ver[32];
				
            //psnmp = &snmp2;
						dic = iniparser_load(path); if(!dic) return -1;
            //r = dev_get_snmp_info(dm->db, psnmp);    if(r) return -1;
            r = proc_snmp(path, PARAS_CHECK, psnmp); if(r) return -1;
            //dic = dictionary_new(0);                 if(r) return -1;
            
            r = ini_rw(dic, "snmp:mode",     &psnmp->mode,     sizeof(psnmp->mode),    TYPE_INT, op, 1); if(r) goto quit;
            r = ini_rw(dic, "snmp:public",   psnmp->publics,    sizeof(psnmp->publics),  TYPE_STR, op, 1); if(r) goto quit;

           //if(psnmp->version==0)       strcpy(ver, "V1");
           //else if(psnmp->version==1)  strcpy(ver, "V2c");
           // else if(psnmp->version==2)  strcpy(ver, "V3");
            r = ini_rw(dic, "snmp:version",  &psnmp->version,  sizeof(psnmp->version), TYPE_INT, op, 1); if(r) goto quit;

            r = ini_rw(dic, "snmp:trap_mode",  &psnmp->trapmode,  sizeof(psnmp->trapmode), TYPE_INT, op, 1); if(r) goto quit;
            r = ini_rw(dic, "snmp:nms_ip",     psnmp->nms_ip,      sizeof(psnmp->nms_ip), TYPE_STR, op, 1); if(r) goto quit;
#if 0
            if(psnmp->version==2) {
                r = ini_rw(dic, "snmp:crypt.user",          psnmp->crypt.user,        sizeof(psnmp->crypt.user),        TYPE_STR, op, 1); if(r) goto quit;
                r = ini_rw(dic, "snmp:crypt.auth.proto",    psnmp->crypt.auth.alg,    sizeof(psnmp->crypt.auth.alg),    TYPE_STR, op, 1); if(r) goto quit;
                r = ini_rw(dic, "snmp:crypt.auth.password", psnmp->crypt.auth.passwd, sizeof(psnmp->crypt.auth.passwd), TYPE_STR, op, 1); if(r) goto quit;

                if(strcmp(psnmp->crypt.priv.alg, "0")==0) {
                    strcpy(psnmp->crypt.priv.alg, "NO");
                }
                r = ini_rw(dic, "snmp:crypt.priv.proto",    psnmp->crypt.priv.alg,    sizeof(psnmp->crypt.priv.alg),    TYPE_STR, op, 1); if(r) goto quit;
                r = ini_rw(dic, "snmp:crypt.priv.password", psnmp->crypt.priv.passwd, sizeof(psnmp->crypt.priv.passwd), TYPE_STR, op, 1); if(r) goto quit;
            }

            r = ini_dump(path, dic);
#endif
						//iniparser_freedict(dic);
        }
        break;

        default:
        return -1;
    }
quit:
    return r;
}

#if 0
static int proc_mqtt(char *path, int op, mqtt_info_t *mqtt)
{
    char *p;
    int i,j=0,r=0;
    char temp[100],token[9000];
    mqtt_server_t *ser=NULL;
    dictionary *dic=NULL;
    GlobalDeviceManager *dm=get_dm();
    mqtt_info_t mqtt2,*pmqtt=mqtt;

    switch(op) {
        case PARAS_CHECK:
        {
            for(i=0; i<MQTT_SER_MAX; i++) {
                ser = &pmqtt->ser[i];
                if(ser->mode<0 || ser->mode>1) {
                    LOGE("___ check mqtt[%d], mode %d is invalid, correct is 0/1\n", i,ser->mode);
                    r = -1;
                }

                if(ser->mode==1) {
                    if(!ser->name[0]) {
                        LOGE("___ check mqtt[%d], name %d is null\n", i);
                        r = -1;
                    }

                    if(!ser->user[0]) {
                        LOGE("___ check mqtt[%d], user is null\n", i);
                        r = -1;
                    }

                    if(!ser->password[0]) {
                        LOGE("___ check mqtt[%d], password is null\n", i);
                        r = -1;
                    }

                    if(!ser->cid[0]) {
                        LOGE("___ check mqtt[%d], cid is null\n", i);
                        r = -1;
                    }

                    if(!ser->port[0]) {
                        LOGE("___ check mqtt[%d], port is null\n", i);
                        r = -1;
                    }

                    if(ser->id!=-1 && ser->id != i) {
                        LOGE("___ check mqtt[%d], id %d is mismatch the index\n", i, ser->id);
                        r = -1;
                    }

                    if(!ser->server[0]) {
                        LOGE("___ check mqtt[%d], server is null\n", i);
                        r = -1;
                    }
                }
                if(r) {
                    break;
                }
            }
            return r;
        }
        break;

        case PARAS_CREATE:
        {
            FILE *fp = fopen(path, "a+");
            if(!fp) {
                LOGE("___ %s open failed\n", path);
                return -1;
            }

            fprintf(fp, "[mqtt]\n");
            for(i=0; i<MQTT_SER_MAX; i++) {
                ser = &pmqtt->ser[i];
                if(ser->id>=0) {
                    fprintf(fp, "broker%d.plat      = \"%d\"\n", i+1,ser->plat);
                    fprintf(fp, "broker%d.mode      = \"%d\"\n", i+1,ser->mode);
                    //fprintf(fp, "broker%d.proto     = \"%s\"\n", i+1,ser->proto);
                    fprintf(fp, "broker%d.name      = \"%s\"\n", i+1,ser->name);
                    fprintf(fp, "broker%d.server    = \"%s\"\n", i+1,ser->server);
                    fprintf(fp, "broker%d.port      = \"%s\"\n", i+1,ser->port);
                    fprintf(fp, "broker%d.client_id = \"%s\"\n", i+1,ser->cid);
                    fprintf(fp, "broker%d.user      = \"%s\"\n", i+1,ser->user);
                    fprintf(fp, "broker%d.password  = \"%s\"\n", i+1,ser->password);
                    fprintf(fp, "broker%d.cert      = \"%s\"\n", i+1,ser->cert);
                    fprintf(fp, "\n");
                }
            }

            fclose(fp);
            return 0;
        }
        break;

        case PARAS_READ:
        {
            pmqtt = &mqtt2;
            dic = iniparser_load(path); if(!dic) return -1;

            memset(pmqtt, 0, sizeof(mqtt_info_t));
            for(i=0; i<MQTT_SER_MAX; i++) {
                ser = &pmqtt->ser[j];
                ser->id = -1;

                sprintf(token, "mqtt:broker%d.plat", i+1);
                r = ini_rw(dic, token, &ser->plat, sizeof(ser->plat), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "mqtt:broker%d.mode", i+1);
                r = ini_rw(dic, token, &ser->mode, sizeof(ser->mode), TYPE_INT, op, 1); if(r) break;
                
        #if 0
                sprintf(token, "mqtt:broker%d.proto", i+1);
                r = ini_rw(dic, token, ser->proto, TYPE_STR, op, 1); if(r) break;
        #endif

                sprintf(token, "mqtt:broker%d.name", i+1);
                r = ini_rw(dic, token, ser->name, sizeof(ser->name), TYPE_STR, op, 1); if(r) break;
               
                sprintf(token, "mqtt:broker%d.server", i+1);
                r = ini_rw(dic, token, ser->server, sizeof(ser->server), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "mqtt:broker%d.port", i+1);
                r = ini_rw(dic, token, ser->port, sizeof(ser->port), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "mqtt:broker%d.client_id", i+1);
                r = ini_rw(dic, token, ser->cid, sizeof(ser->cid), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "mqtt:broker%d.user", i+1);
                r = ini_rw(dic, token, ser->user, sizeof(ser->user), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "mqtt:broker%d.password", i+1);
                r = ini_rw(dic, token, ser->password, sizeof(ser->password), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "mqtt:broker%d.cert", i+1);
                r = ini_rw(dic, token, ser->cert, sizeof(ser->cert), TYPE_STR, op, 0); if(r) break;
                str_replace(ser->cert,";;", "\r\n");

                ser->id = j;
                j++;
            }

            r = proc_mqtt(path, PARAS_CHECK, pmqtt); if(r) goto quit;
            r = dev_clear_table(dm->db, TAB_ID_MQTT); if(r) goto quit;
            r = dev_mqtt_update_info(dm->db, pmqtt);
        }
        break;

        case PARAS_WRITE:
        {
            int cnt=0;
            pmqtt = &mqtt2;
            r = dev_mqtt_get(dm->db, pmqtt);         if(r) return -1;
            r = proc_mqtt(path, PARAS_CHECK, pmqtt); if(r) return -1;
            dic = dictionary_new(0);                 if(!dic) return -1;

            for(i=0; i<MQTT_SER_MAX; i++) {
                ser = &pmqtt->ser[i];

                if(ser->id==-1) break;

                sprintf(token, "mqtt:broker%d.plat", i+1);
                r = ini_rw(dic, token, &ser->plat, sizeof(ser->plat), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "mqtt:broker%d.mode", i+1);
                r = ini_rw(dic, token, &ser->mode, sizeof(ser->mode), TYPE_INT, op, 1); if(r) break;
                
        #if 0
                sprintf(token, "mqtt:broker%d.proto", i+1);
                r = ini_rw(dic, token, ser->proto, TYPE_STR, op, 1); if(r) break;
        #endif

                sprintf(token, "mqtt:broker%d.name", i+1);
                r = ini_rw(dic, token, ser->name, sizeof(ser->name), TYPE_STR, op, 1); if(r) break;
            
                sprintf(token, "mqtt:broker%d.server", i+1);
                r = ini_rw(dic, token, ser->server, sizeof(ser->server), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "mqtt:broker%d.port", i+1);
                r = ini_rw(dic, token, ser->port, sizeof(ser->port), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "mqtt:broker%d.client_id", i+1);
                r = ini_rw(dic, token, ser->cid, sizeof(ser->cid), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "mqtt:broker%d.user", i+1);
                r = ini_rw(dic, token, ser->user, sizeof(ser->user), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "mqtt:broker%d.password", i+1);
                r = ini_rw(dic, token, ser->password, sizeof(ser->password), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "mqtt:broker%d.cert", i+1);
                str_replace(ser->cert, "\r\n", ";;");
                r = ini_rw(dic, token, ser->cert, sizeof(ser->cert), TYPE_STR, op, 0); if(r) break;
                cnt++;
            }

            if(cnt>0) {
                r = ini_dump(path, dic);
            }
        }
        break;

        default:
        return -1;
    }

quit:
    iniparser_freedict(dic);
    return r;
}
static int proc_mail(char *path, int op, mail_info_t *mail)
{
    int i,r=0;
    dictionary *dic=NULL;
    char *p,*tok,token[100],temp[100];
    GlobalDeviceManager *dm=get_dm();
    mail_info_t mail2,*pmail=mail;
    mail_send_t *send=&pmail->send;

    switch(op) {
        case PARAS_CHECK:
        {
            send->id = 0;
            if(send->mode<0 || send->mode>1) {
                LOGE("___ check mail, send.mode is invalid, correct value is 0/1\n");
                r = -1; 
            }

            if(send->mode==1) {
                if(!send->server[0]) {
                    LOGE("___ check mail, send.server is null\n");
                    r = -1; 
                }

                if(!send->port[0]) {
                    LOGE("___ check mail, send.server is null\n");
                    r = -1; 
                }

                if(!send->account[0]) {
                    LOGE("___ check mail, send.account is null\n");
                    r = -1; 
                }

                if(!send->password[0]) {
                    LOGE("___ check mail, send.password is null\n");
                    r = -1; 
                }

                if(!send->auth[0]) {
                    LOGE("___ check mail, send.account is null\n");
                    r = -1; 
                }

                for(i=0; i<MAIL_RECV_MAX; i++) {
                    mail_recv_t *recv=&pmail->recv[i];

                    if(recv->use<0 || recv->use>1) {
                        LOGE("___ check mail, recv[%d].use is invalid, correct value is 0/1", i);
                        r = -1; 
                    }

                    if(recv->use==1) {
                        if(recv->id != i) {
                            LOGE("___ check mail, recv[%d].id %d mismatch it's index\n", i,recv->id);
                            r = -1; 
                        }

                        if(!recv[i].account[0]) {
                            LOGE("___ check mail, recv[%d].account is null", i);
                            r = -1; 
                        }
                    }

                    if(r) {
                        break;
                    }
                }
            }
            return r;
        }
        break;

        case PARAS_CREATE:
        {
            FILE *fp = fopen(path, "a+");
            if(!fp) {
                LOGE("___ %s open failed\n", path);
                return -1;
            }

            fprintf(fp, "[mail]\n");
            fprintf(fp, "send.mode      = \"%d\"\n", send->mode);
            fprintf(fp, "send.server    = \"%s\"\n", send->account);
            fprintf(fp, "send.password  = \"%s\"\n", send->password);
            fprintf(fp, "send.server    = \"%s\"\n", send->server);
            fprintf(fp, "send.port      = \"%s\"\n", send->port);
            fprintf(fp, "send.auth      = \"%s\"\n", send->auth);
            fprintf(fp, "send.ca        = \"%s\"\n", send->ca[0]?send->ca:"");
            fprintf(fp, "\n");

            for(i=0; i<MAIL_RECV_MAX; i++) {
                mail_recv_t *recv=&pmail->recv[i];
                if(recv->use==1) {
                    fprintf(fp, "recv%d.use        = \"%d\"\n", i+1,recv->use);
                    fprintf(fp, "recv%d.account    = \"%s\"\n", i+1,recv->account);
                    fprintf(fp, "\n");
                }
            }

            fclose(fp);
            return 0;
        }
        break;

        case PARAS_READ:
        {
            pmail = &mail2;
            send = &pmail->send;
            send->id = 0;
            mail_recv_t *recv=NULL;

            dic = iniparser_load(path); if(!dic) return -1;

            memset(pmail, 0, sizeof(mail_info_t));
            send->id = 0;

            r = ini_rw(dic, "mail:send.mode",     &send->mode,    sizeof(send->mode),     TYPE_INT, op, 1); if(r) goto quit;
            r = ini_rw(dic, "mail:send.server",   send->server,   sizeof(send->server),   TYPE_STR, op, 1); if(r) goto quit;
            r = ini_rw(dic, "mail:send.port",     send->port,     sizeof(send->port),     TYPE_STR, op, 1); if(r) goto quit;
            r = ini_rw(dic, "mail:send.auth",     send->auth,     sizeof(send->auth),     TYPE_STR, op, 1); if(r) goto quit;
            r = ini_rw(dic, "mail:send.ca",       send->ca,       sizeof(send->ca),       TYPE_STR, op, 0); if(r) goto quit;
            r = ini_rw(dic, "mail:send.account",  send->account,  sizeof(send->account),  TYPE_STR, op, 1); if(r) goto quit;
            r = ini_rw(dic, "mail:send.password", send->password, sizeof(send->password), TYPE_STR, op, 1); if(r) goto quit;

            for(i=0; i<MAIL_RECV_MAX; i++) {
                recv = &pmail->recv[i];
                recv->id = i;

                sprintf(token, "mail:recv%d.account", i+1);
                r = ini_rw(dic, token, recv->account, sizeof(recv->account), TYPE_STR, op, 1);  if(r) break;
                recv->use = 1;
            }

            r = dev_clear_table(dm->db, TAB_ID_MAIL);  if(r) goto quit;
            r = dev_mail_update_send(dm->db, &pmail->send); if(r) goto quit;
            r = dev_mail_update_recv(dm->db, pmail->recv);  if(r) goto quit;
        }
        break;

        case PARAS_WRITE:
        {
            int cnt=0;

            pmail = &mail2;
            send = &pmail->send;
            
            r = dev_mail_get(dm->db, pmail); if(r) return -1;
            dic = dictionary_new(0); if(!dic) return -1;

            r = ini_rw(dic, "mail:send.mode",     &send->mode,    sizeof(send->mode),     TYPE_INT, op, 1); if(r) goto quit;
            r = ini_rw(dic, "mail:send.server",   send->server,   sizeof(send->server),   TYPE_STR, op, 1); if(r) goto quit;
            r = ini_rw(dic, "mail:send.port",     send->port,     sizeof(send->port),     TYPE_STR, op, 1); if(r) goto quit;
            r = ini_rw(dic, "mail:send.auth",     send->auth,     sizeof(send->auth),     TYPE_STR, op, 1); if(r) goto quit;
            r = ini_rw(dic, "mail:send.ca",       send->ca,       sizeof(send->ca),       TYPE_STR, op, 0); if(r) goto quit;
            r = ini_rw(dic, "mail:send.account",  send->account,  sizeof(send->account),  TYPE_STR, op, 1); if(r) goto quit;
            r = ini_rw(dic, "mail:send.password", send->password, sizeof(send->password), TYPE_STR, op, 1); if(r) goto quit;

            for(i=0; i<MAIL_RECV_MAX; i++) {
                mail_recv_t *recv=&pmail->recv[i];

                sprintf(token, "mail:recv%d.account", i+1);
                r = ini_rw(dic, token, recv->account, sizeof(recv->account), TYPE_STR, op, 1); if(r) break;
            }
            r = ini_dump(path, dic);
        }
        break;

        default:
        return -1;
    }

quit:
    iniparser_freedict(dic);
    return r;
}


static int proc_role(char *path, int op, role_data_t *role, handle_t l)
{
    int i=1,r=0;
    char temp[100];
    char *p,token[100];
    dictionary *dic=NULL;
    role_data_t role2,*prole=role;

    switch(op) {
        case PARAS_CHECK:
        {
            if(!prole->roleName[0]) {
                LOGE("___ check role, roleName is null\n");
                r = -1; 
            }

            if(prole->roleLevel<0) {
                LOGE("___ check role, roleLevel is invalid\n");
                r = -1; 
            }

            if(!prole->roleAuthority[0]) {
                LOGE("___ check role, roleAuthority is null\n");
                r = -1; 
            }
            return r;
        }
        break;

        case PARAS_CREATE:
        {
            FILE *fp=fopen(path, "a+");
            if(!fp) {
                LOGE("___ %s open failed\n", path);
                return -1;
            }

            get_time_str(temp, sizeof(temp), time(NULL));
            fprintf(fp, "[role]\n");
            fprintf(fp, "role1.name      = \"super admin\"\n");
            fprintf(fp, "role1.level     = \"0\"\n");
            fprintf(fp, "role1.auth      = \"1,2,3,4,5,6\"\n");
            fprintf(fp, "role1.sort      = \"1\"\n");
            fprintf(fp, "role1.time      = \"%s\"\n", temp);
            fprintf(fp, "\n");

            fprintf(fp, "role2.name      = \"admin\"\n");
            fprintf(fp, "role2.level     = \"1\"\n");
            fprintf(fp, "role2.auth      = \"1,2,3\"\n");
            fprintf(fp, "role2.sort      = \"2\"\n");
            fprintf(fp, "role3.time      = \"%s\"\n", temp);
            fprintf(fp, "\n");

            fprintf(fp, "role3.name      = \"normal\"\n");
            fprintf(fp, "role3.level     = \"2\"\n");
            fprintf(fp, "role3.auth      = \"1,2\"\n");
            fprintf(fp, "role3.sort      = \"3\"\n");
            fprintf(fp, "role3.time      = \"%s\"\n", temp);
            fprintf(fp, "\n");

            fclose(fp);
            return 0;
        }
        break;

        case PARAS_READ:
        {
            int x,chk_ok=0,cnt_ok=0;

            prole = &role2;
            dic = iniparser_load(path); if(!dic) return -1;

            memset(prole, 0, sizeof(RoleInfo));
            for(x=0; x<2; x++) {
                i = 1;
                while(1) {
                    prole->roleID = i;

                    sprintf(token, "role:role%d.name", i);
                    r = ini_rw(dic, token, prole->roleName, sizeof(prole->roleName), TYPE_STR, op, 1);    if(r) break;

                    sprintf(token, "role:role%d.level", i);
                    r = ini_rw(dic, token, &prole->roleLevel, sizeof(prole->roleLevel), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "role:role%d.auth", i);
                    r = ini_rw(dic, token, prole->roleAuthority, sizeof(prole->roleAuthority), TYPE_STR, op, 1); if(r) break;

                    sprintf(token, "role:role%d.sort", i);
                    r = ini_rw(dic, token, &prole->roleSort, sizeof(prole->roleAuthority), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "role:role%d.time", i);
                    r = ini_rw(dic, token, prole->createTime, sizeof(prole->createTime), TYPE_STR, op, 1); if(r) break;

                    if(chk_ok==0) {
                        r = proc_role(path, PARAS_CHECK, prole, NULL); if(r) break;
                        xlist_append(l, 0, prole, sizeof(RoleInfo));
                        cnt_ok++;
                    }
                    else {
                        r = dev_insert_role_info(dm->db, prole); if(r) break;
                    }

                    i++;
                }

                if(x==0) {
                    if(cnt_ok==0) break;
                    chk_ok = 1;
                    r = dev_clear_table(dm->db, TAB_ID_ROLE); if(r) break;
                }
                else {
                    if(r) {
                        if(i>cnt_ok) r = 0;
                        break;
                    }
                }
            }
        }
        break;

        case PARAS_WRITE:
        {
            int cnt=0;
            RoleInfo *tmp,*node,*next;
            
            prole = &role2;
            INIT_LIST_HEAD(&prole->list);
            r = dev_get_role_info(dm->db, prole);    if(r) return -1;
            dic = dictionary_new(0);                 if(!dic) return -1;

            list_for_each_entry(tmp, &prole->list, list) {
                if(!tmp) break;

                r = proc_role(path, PARAS_CHECK, tmp, NULL); if(r) break;

                sprintf(token, "role:role%d.name", i);
                r = ini_rw(dic, token, tmp->roleName, sizeof(tmp->roleName), TYPE_STR, op, 1);    if(r) break;

                sprintf(token, "role:role%d.level", i);
                r = ini_rw(dic, token, &tmp->roleLevel, sizeof(tmp->roleLevel), TYPE_INT, op, 1);  if(r) break;

                sprintf(token, "role:role%d.auth", i);
                r = ini_rw(dic, token, tmp->roleAuthority, sizeof(tmp->roleAuthority), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "role:role%d.sort", i);
                r = ini_rw(dic, token, &tmp->roleSort, sizeof(tmp->roleAuthority), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "role:role%d.time", i);
                get_curtime_str(temp, sizeof(temp));
                r = ini_rw(dic, token, temp, sizeof(temp), TYPE_STR, op, 1); if(r) break;
                i++;
                cnt++;
            }

            if(cnt>0) {
                r = ini_dump(path, dic);
            }
        }
        break;

        default:
        return -1;
    }
    iniparser_freedict(dic);

    return r;
}

static int find_role_id(handle_t l, node_t *node, node_t *xd, void *arg, int *act)
{
    int id=(*(int*)arg);
    role_data_t *info=(RoleInfo*)xd->buf;

    if(id==info->roleID) {
        *act = LIST_ACT_STOP;
        return 0;
    }
    return -1;
}
static int proc_user(char *path, int op, user_data_t *user, handle_t l)
{
    int i=1,r=0;
    char temp[100];
    char *p,token[100];
    dictionary *dic=NULL;
    user_data_t user2,*puser=user;

    switch(op) {
        case PARAS_CHECK:
        {
            if(!puser->userName[0]) {
                LOGE("___ check user, userName is null\n");
                r = -1; 
            }

            if(!puser->userPW[0]) {
                LOGE("___ check user, userPW is invalid\n");
                r = -1; 
            }

            if(!puser->nickName[0]) {
                LOGE("___ check user, nickName is null\n");
                r = -1; 
            }

            if(!puser->createTime[0]) {
                LOGE("___ check user, createTime is null\n");
                r = -1; 
            }

            return r;
        }
        break;

        case PARAS_CREATE:
        {
            FILE *fp=fopen(path, "a+");
            if(!fp) {
                LOGE("___ %s open failed\n", path);
                return -1;
            }

            get_time_str(temp, sizeof(temp), time(NULL));
            fprintf(fp, "[user]\n");
            fprintf(fp, "user1.userName    = \"admin\"\n");
            fprintf(fp, "user1.userPW      = \"admin\"\n");
            fprintf(fp, "user1.nickName    = \"administer\"\n");
            fprintf(fp, "user1.roleID      = \"1\"\n");
            fprintf(fp, "user1.createTime  = \"%s\"\n", temp);
            fprintf(fp, "\n");

            fprintf(fp, "user2.userName    = \"user\"\n");
            fprintf(fp, "user2.userPW      = \"123456\"\n");
            fprintf(fp, "user2.nickName    = \"users\"\n");
            fprintf(fp, "user2.roleID      = \"3\"\n");
            fprintf(fp, "user2.createTime  = \"%s\"\n", temp);
            fprintf(fp, "\n");

            fclose(fp);
            return 0;
        }
        break;

        case PARAS_READ:
        {
            int x,chk_ok=0,cnt_ok=0;
            RoleInfo role;

            puser = &user2;
            dic = iniparser_load(path); if(!dic) return -1;

            memset(puser, 0, sizeof(UserInfo));
            for(x=0; x<2; x++) {
                i = 1;
                while(1) {
                    puser->userID = i;

                    sprintf(token, "user:user%d.name", i);
                    r = ini_rw(dic, token, puser->userName, sizeof(puser->userName), TYPE_STR, op, 1); if(r) break;

                    sprintf(token, "user:user%d.password", i);
                    r = ini_rw(dic, token, &puser->userPW, sizeof(puser->userPW), TYPE_STR, op, 1); if(r) break;

                    sprintf(token, "user:user%d.nick_name", i);
                    r = ini_rw(dic, token, puser->nickName, sizeof(puser->nickName), TYPE_STR, op, 1); if(r) break;

                    sprintf(token, "user:user%d.role_id", i);
                    r = ini_rw(dic, token, &puser->roleID, sizeof(puser->roleID), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "user:user%d.time", i);
                    r = ini_rw(dic, token, puser->createTime, sizeof(puser->createTime), TYPE_STR, op, 1); if(r) break;

                    if(chk_ok==0) {
                        r = proc_user(path, PARAS_CHECK, puser, NULL); if(r) break;

                        if(l) {
                            r = xlist_iterator(l, NULL, find_role_id, &puser->roleID);
                            if(r) {
                                LOGE("___ roleID %d not found in role sett options!\n", puser->roleID);
                                break;
                            }
                        }
                        cnt_ok++;
                    }
                    else {
                        r = dev_insert_user_info(dm->db, puser); if(r) break;
                    }
                    i++;
                }

                if(x==0) {
                    if(cnt_ok==0) break;
                    chk_ok = 1;
                    r = dev_clear_table(dm->db, TAB_ID_USER);  if(r) break;
                }
                else {
                    if(r) {
                        if(i>cnt_ok) r = 0;
                        break;
                    }
                }
            }
        }
        break;

        case PARAS_WRITE:
        {
            int cnt=0;
            UserInfo *tmp,*node,*next;
            
            puser = &user2;
            INIT_LIST_HEAD(&puser->list);
            r = dev_get_user_info(dm->db, puser);    if(r) return -1;
            dic = dictionary_new(0);                 if(!dic) return -1;

            list_for_each_entry(tmp, &puser->list, list) {
                if(!tmp) break;

                r = proc_user(path, PARAS_CHECK, tmp, NULL); if(r) break;

                sprintf(token, "user:user%d.name", i);
                r = ini_rw(dic, token, tmp->userName, sizeof(tmp->userName), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "user:user%d.password", i);
                r = ini_rw(dic, token, &tmp->userPW, sizeof(tmp->userPW), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "user:user%d.nick_name", i);
                r = ini_rw(dic, token, tmp->nickName, sizeof(tmp->nickName), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "user:user%d.role_id", i);
                r = ini_rw(dic, token, &tmp->roleID, sizeof(tmp->roleID), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "user:user%d.time", i);
                r = ini_rw(dic, token, tmp->createTime, sizeof(tmp->createTime), TYPE_STR, op, 1); if(r) break;

                i++;
                cnt++;
            }

            list_for_each_entry_safe(node,next,&puser->list,list) {
                list_del(&node->list); free(node);
            }

            if(cnt>0) {
                r = ini_dump(path, dic);
            }
        }
        break;

        default:
        return -1;
    }
    iniparser_freedict(dic);

    return r;
}
static int proc_group(char *path, int op, GroupInfo *group)
{
    int i=1,r=0;
    char temp[100];
    char *p,token[100];
    dictionary *dic=NULL;
    GroupInfo group2,*pgroup=group;

    switch(op) {
        case PARAS_CHECK:
        {
            if(!pgroup->GroupChList[0]) {
                LOGE("___ check group, GroupChList is null\n");
                r = -1; 
            }

            if(!pgroup->GroupName[0]) {
                LOGE("___ check group, GroupName is null\n");
                r = -1; 
            }
            return r;
        }
        break;

        case PARAS_CREATE:
        {
            FILE *fp=fopen(path, "a+");
            if(!fp) {
                LOGE("___ %s open failed\n", path);
                return -1;
            }

            fprintf(fp, "[group]\n");
            fprintf(fp, "\n");
            fclose(fp);
            return 0;
        }
        break;

        case PARAS_READ:
        {
            int x,chk_ok=0,cnt_ok=0;
            pgroup = &group2;
            dic = iniparser_load(path); if(!dic) return -1;

            memset(pgroup, 0, sizeof(GroupInfo));
            for(x=0; x<2; x++) {
                i = 1;
                while(1) {
                    sprintf(token, "group:group%d.id", i);
                    r = ini_rw(dic, token, &pgroup->GroupID,    sizeof(pgroup->GroupID),     TYPE_STR, op, 1); if(r) break;

                    sprintf(token, "group:group%d.name", i);
                    r = ini_rw(dic, token, pgroup->GroupName,   sizeof(pgroup->GroupName),   TYPE_STR, op, 1); if(r) break;

                    sprintf(token, "group:group%d.ch_list", i);
                    r = ini_rw(dic, token, pgroup->GroupChList, sizeof(pgroup->GroupChList), TYPE_STR, op, 1); if(r) break;

                    if(chk_ok==0) {
                        r = proc_group(path, PARAS_CHECK, pgroup);  if(r) break;
                        cnt_ok++;
                    }
                    else {
                        r = dev_insert_group_info(dm->db, pgroup);  if(r) break;
                    }
                    i++;
                }
                
                if(x==0) {
                    if(cnt_ok==0) break;
                    chk_ok = 1;
                    r = dev_clear_table(dm->db, TAB_ID_GROUP);  if(r) break;
                }
                else {
                    if(r) {
                        if(i>cnt_ok) r = 0;
                        break;
                    }
                }
            }
        }
        break;

        case PARAS_WRITE:
        {
            int cnt=0;
            GroupInfo *tmp,*node,*next;

            pgroup = &group2;

            INIT_LIST_HEAD(&pgroup->list);
            r = dev_get_group_info(dm->db, pgroup); if(r) return -1;
            r = proc_group(path, PARAS_CHECK, pgroup); if(r) return -1;
            dic = dictionary_new(0); if(!dic) return -1;

            list_for_each_entry(tmp, &pgroup->list, list) {
                if(!tmp) break;

                sprintf(token, "group:group%d.id", i);
                r = ini_rw(dic, token, &tmp->GroupID, sizeof(tmp->GroupID), TYPE_INT, op, 1);   if(r) break;

                sprintf(token, "group:group%d.name", i);
                r = ini_rw(dic, token, tmp->GroupName, sizeof(tmp->GroupName), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "group%d.ch_list", i);
                sprintf(temp, "%s", tmp->GroupChList);
                r = ini_rw(dic, token, tmp->GroupChList, sizeof(tmp->GroupChList), TYPE_STR, op, 1); if(r) break;
                i++;
                cnt++;
            }

            list_for_each_entry_safe(node,next,&pgroup->list,list) {
                list_del(&node->list); free(node);
            }

            if(cnt>0) {
                r = ini_dump(path, dic);
            }
        }
        break;

        default:
        return -1;
    }
    iniparser_freedict(dic);

    return r;
}
static int proc_sensor(char *path, int op, GlobalSensorManger *sensor)
{
    int i=1,j,k,r=0;
    char temp[100];
    char *p,token[100];
    dictionary *dic=NULL;
    GlobalSensorManger sensor2,*psensor=sensor;
    GlobalDeviceManager *dm=get_dm();

    switch(op) {
        case PARAS_CHECK:
        {
            p = strstr(psensor->sensor_port_name, "IN");
            if(psensor->sensor_id<0) {
                LOGE("___ check sensor, sensor_id %d is invalid, must >0\n",psensor->sensor_id);
                r = -1; 
            }

            if(!p && psensor->sensor_addr<=0) {
                LOGE("___ check sensor, sensor_addr %d is invalid, must >0\n",psensor->sensor_addr);
                r = -1; 
            }

            if(!p && psensor->sensor_baud<=0) {
                LOGE("___ check sensor, sensor_baud %d is invalid, must >0\n",psensor->sensor_baud);
                r = -1; 
            }

            if(!psensor->sensor_name[0]) {
                LOGE("___ check sensor, sensor_name is null\n");
                r = -1; 
            }

            if(psensor->sensor_interface_type<1 || psensor->sensor_interface_type>2) {
                LOGE("___ check sensor, sensor_interface_type %d is invalid, must be 1/2\n",psensor->sensor_interface_type);
                r = -1; 
            }
            return r;
        }
        break;

        case PARAS_CREATE:
        {
            FILE *fp = fopen(path, "a+");
            if(!fp) {
                LOGE("___ %s open failed\n", path);
                return -1;
            }

            typedef struct {
                int  iface;
                int  type;
                char *name;
                char *port;
                int  baudrate;
                int  addr;
                int  vcnt;
            }sensor_info_t;
            #define SENSOR_MAX 7
            sensor_info_t sinfo[SENSOR_MAX]={
                { .iface = 1, .type=SENSOR_TYPE_TEMP_HUMI,          .name="A", .port="COM2", .baudrate=9600, .addr=1, .vcnt=2 },
                { .iface = 2, .type=SENSOR_TYPE_SMOKE,              .name="B", .port="IN1",  .baudrate=9600, .addr=0, .vcnt=1 },
                { .iface = 2, .type=SENSOR_TYPE_WATER,              .name="C", .port="IN2",  .baudrate=9600, .addr=0, .vcnt=1 },
                { .iface = 2, .type=SENSOR_TYPE_ACCESS,             .name="D", .port="IN3",  .baudrate=9600, .addr=0, .vcnt=1 },
                { .iface = 1, .type=SENSOR_TYPE_GAS,                .name="E", .port="COM1", .baudrate=9600, .addr=2, .vcnt=1 },
                { .iface = 1, .type=SENSOR_TYPE_AIR_PRESS,          .name="F", .port="COM3", .baudrate=9600, .addr=3, .vcnt=2 },
                { .iface = 1, .type=SENSOR_TYPE_AIR_COND,           .name="G", .port="COM4", .baudrate=9600, .addr=4, .vcnt=1 },
            };

            fprintf(fp, "[sensor]\n");
            for(i=0; i<SENSOR_MAX; i++) {
                fprintf(fp, "sensor%d.id        = \"%d\"",   i+1, i+1);
                fprintf(fp, "sensor%d.type      = \"%d\"",   i+1, sinfo[i].type);
                fprintf(fp, "sensor%d.name      = \"%s\"",   i+1, sinfo[i].name);
                fprintf(fp, "sensor%d.iface     = \"%d\"",   i+1, sinfo[i].iface);
                fprintf(fp, "sensor%d.port      = \"%s\"",   i+1, sinfo[i].port);
                fprintf(fp, "sensor%d.baudrate  = \"%d\"",   i+1, sinfo[i].baudrate);
                fprintf(fp, "sensor%d.addr      = \"%d\"",   i+1, sinfo[i].addr);
                fprintf(fp, "sensor%d.staus     = \"0\"",    i+1);
                fprintf(fp, "sensor%d.vcnt      = \"%d\"",   i+1, sinfo[i].vcnt);
                for(j=0; j<2; j++) {
                    fprintf(fp, "sensor%d.v%d.up.en    = \"0\"", i+1, j+1);
                    fprintf(fp, "sensor%d.v%d.up.th    = \"0\"", i+1, j+1);
                    fprintf(fp, "sensor%d.v%d.up.th_t  = \"0\"", i+1, j+1);
                    fprintf(fp, "sensor%d.v%d.up.th_p  = \"0\"", i+1, j+1);
                    fprintf(fp, "sensor%d.v%d.lo.en    = \"0\"", i+1, j+1);
                    fprintf(fp, "sensor%d.v%d.lo.th    = \"0\"", i+1, j+1);
                    fprintf(fp, "sensor%d.v%d.lo.th_t  = \"0\"", i+1, j+1);
                    fprintf(fp, "sensor%d.v%d.lo.th_p  = \"0\"", i+1, j+1);
                }
                fprintf(fp, "\n");
            }
            fclose(fp);
            return 0;
        }
        break;

        case PARAS_READ:
        {
            float f;
            int x,chk_ok=0,cnt_ok=0;

            psensor = &sensor2;
            dic = iniparser_load(path); if(!dic) return -1;

            memset(psensor, 0, sizeof(GlobalSensorManger));
            for(x=0; x<2; x++) {
                i = 1;
                while(1) {
                    sprintf(token, "sensor:sensor%d.id", i);
                    r = ini_rw(dic, token, &psensor->sensor_id, sizeof(psensor->sensor_id), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "sensor:sensor%d.type", i);
                    r = ini_rw(dic, token, &psensor->sensor_type, sizeof(psensor->sensor_type), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "sensor:sensor%d.name", i);
                    r = ini_rw(dic, token, psensor->sensor_name, sizeof(psensor->sensor_name), TYPE_STR, op, 1); if(r) break;

                    sprintf(token, "sensor:sensor%d.iface", i);
                    r = ini_rw(dic, token, &psensor->sensor_interface_type, sizeof(psensor->sensor_interface_type), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "sensor:sensor%d.port", i);
                    r = ini_rw(dic, token, psensor->sensor_port_name, sizeof(psensor->sensor_port_name), TYPE_STR, op, 1); if(r) break;

                    sprintf(token, "sensor:sensor%d.addr", i);
                    r = ini_rw(dic, token, &psensor->sensor_addr, sizeof(psensor->sensor_addr), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "sensor:sensor%d.baudrate", i);
                    r = ini_rw(dic, token, &psensor->sensor_baud, sizeof(psensor->sensor_baud), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "sensor:sensor%d.vcnt", i);
                    r = ini_rw(dic, token, &psensor->sensor_val_count, sizeof(psensor->sensor_val_count), TYPE_INT, op, 1); if(r) break;

                    //////////////////////
                    GlobalSensorOverManage *pover=&psensor->over_manager;
                    for(j=1; j<=2; j++) {
                        for(k=1; k<=2; k++) {
                            if(j==1) {
                                if(k==1) {
                                    sprintf(token, "sensor:sensor%d.v%d.up.en", i, j);
                                    r = ini_rw(dic, token, &pover->sensor_val1_upper_enabled, sizeof(pover->sensor_val1_upper_enabled), TYPE_INT, op, 1); if(r) break;

                                    sprintf(token, "sensor:sensor%d.v%d.up.th", i, j);
                                    r = ini_rw(dic, token, &pover->sensor_val1_upper_threshold, sizeof(pover->sensor_val1_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                                    sprintf(token, "sensor:sensor%d.v%d.up.th_act", i, j);
                                    r = ini_rw(dic, token, &pover->sensor_val1_upper_threshold_ctrl, sizeof(pover->sensor_val1_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                                    sprintf(token, "sensor:sensor%d.v%d.up.th_para", i, j);
                                    r = ini_rw(dic, token, &pover->sensor_val1_upper_threshold_ctrl_para, sizeof(pover->sensor_val1_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;
                                }
                                else {
                                    sprintf(token, "sensor:sensor%d.v%d.lo.en", i, j);
                                    r = ini_rw(dic, token, &pover->sensor_val1_lower_enabled, sizeof(pover->sensor_val1_lower_enabled), TYPE_INT, op, 1); if(r) break;

                                    sprintf(token, "sensor:sensor%d.v%d.lo.th", i, j);
                                    r = ini_rw(dic, token, &pover->sensor_val1_lower_threshold, sizeof(pover->sensor_val1_lower_threshold), TYPE_FLOAT, op, 1); if(r) break;

                                    sprintf(token, "sensor:sensor%d.v%d.lo.th_act", i, j);
                                    r = ini_rw(dic, token, &pover->sensor_val1_lower_threshold_ctrl, sizeof(pover->sensor_val1_lower_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                                    sprintf(token, "sensor:sensor%d.v%d.lo.th_para", i, j);
                                    r = ini_rw(dic, token, &pover->sensor_val1_lower_threshold_ctrl_para, sizeof(pover->sensor_val1_lower_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;
                                }
                            }
                            else {
                                if(k==1) {
                                    sprintf(token, "sensor:sensor%d.v%d.up.en", i, j);
                                    r = ini_rw(dic, token, &pover->sensor_val2_upper_enabled, sizeof(pover->sensor_val2_upper_enabled), TYPE_INT, op, 1); if(r) break;

                                    sprintf(token, "sensor:sensor%d.v%d.up.th", i, j);
                                    r = ini_rw(dic, token, &pover->sensor_val2_upper_threshold, sizeof(pover->sensor_val2_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                                    sprintf(token, "sensor:sensor%d.v%d.up.th_act", i, j);
                                    r = ini_rw(dic, token, &pover->sensor_val2_upper_threshold_ctrl, sizeof(pover->sensor_val2_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                                    sprintf(token, "sensor:sensor%d.v%d.up.th_para", i, j);
                                    r = ini_rw(dic, token, &pover->sensor_val2_upper_threshold_ctrl_para, sizeof(pover->sensor_val2_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;
                                }
                                else {
                                    sprintf(token, "sensor:sensor%d.v%d.lo.en", i, j);
                                    r = ini_rw(dic, token, &pover->sensor_val2_lower_enabled, sizeof(pover->sensor_val2_lower_enabled), TYPE_INT, op, 1); if(r) break;

                                    sprintf(token, "sensor:sensor%d.v%d.lo.th", i, j);
                                    r = ini_rw(dic, token, &pover->sensor_val2_lower_threshold, sizeof(pover->sensor_val2_lower_threshold), TYPE_FLOAT, op, 1); if(r) break;

                                    sprintf(token, "sensor:sensor%d.v%d.lo.th_act", i, j);
                                    r = ini_rw(dic, token, &pover->sensor_val2_lower_threshold_ctrl, sizeof(pover->sensor_val2_lower_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                                    sprintf(token, "sensor:sensor%d.v%d.lo.th_para", i, j);
                                    r = ini_rw(dic, token, &pover->sensor_val2_lower_threshold_ctrl_para, sizeof(pover->sensor_val2_lower_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;
                                }
                            }
                            if(r) break;
                        }
                        if(r) break;
                    }

                    if(chk_ok==0) {
                        r = proc_sensor(path, PARAS_CHECK, psensor);   if(r) break;
                        cnt_ok++;
                    }
                    else {
                        r = dev_insert_sensor_genera_manage(dm->db, psensor);  if(r) break;
                        r = dev_update_sensor_over_manage(dm->db, 0, psensor->sensor_id, psensor);    if(r) break;
                    }
                    i++;
                }
                
                if(x==0) {
                    if(cnt_ok==0) break;
                    chk_ok = 1;
                    r = dev_clear_table(dm->db, TAB_ID_SENSOR);  if(r) break;
                }
                else {
                    if(r) {
                        if(i>cnt_ok) r = 0;
                        break;
                    }
                }
            }
        }
        break;

        case PARAS_WRITE:
        {
            int cnt=0;
            GlobalSensorManger *tmp,*node,*next;

            psensor = &sensor2;

            INIT_LIST_HEAD(&psensor->list);
            r = dev_get_sensor_manage_info(dm->db, 0, psensor); if(r) return -1;
            dic = dictionary_new(0); if(!dic) return -1;

            list_for_each_entry(tmp, &psensor->list, list) {
                if(!tmp) break;
                r = proc_sensor(path, PARAS_CHECK, tmp); if(r) break;

                sprintf(token, "sensor:sensor%d.id", i);
                r = ini_rw(dic, token, &tmp->sensor_id, sizeof(tmp->sensor_id), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "sensor:sensor%d.type", i);
                r = ini_rw(dic, token, &tmp->sensor_type, sizeof(tmp->sensor_type), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "sensor:sensor%d.name", i);
                r = ini_rw(dic, token, tmp->sensor_name, sizeof(tmp->sensor_name), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "sensor:sensor%d.iface", i);
                r = ini_rw(dic, token, &tmp->sensor_interface_type, sizeof(tmp->sensor_interface_type), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "sensor:sensor%d.port", i);
                r = ini_rw(dic, token, tmp->sensor_port_name, sizeof(tmp->sensor_port_name), TYPE_STR, op, 1); if(r) break;

                sprintf(token, "sensor:sensor%d.addr", i);
                r = ini_rw(dic, token, &tmp->sensor_addr, sizeof(tmp->sensor_addr), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "sensor:sensor%d.baudrate", i);
                r = ini_rw(dic, token, &tmp->sensor_baud, sizeof(tmp->sensor_baud), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "sensor:sensor%d.vcnt", i);
                r = ini_rw(dic, token, &tmp->sensor_val_count, sizeof(tmp->sensor_val_count), TYPE_INT, op, 1); if(r) break;

                //////////////////////
                GlobalSensorOverManage *pover=&tmp->over_manager;
                for(j=1; j<=2; j++) {
                    for(k=1; k<=2; k++) {
                        if(j==1) {
                            if(k==1) {
                                sprintf(token, "sensor:sensor%d.v%d.up.en", i, j);
                                r = ini_rw(dic, token, &pover->sensor_val1_upper_enabled, sizeof(pover->sensor_val1_upper_enabled), TYPE_INT, op, 1); if(r) break;

                                sprintf(token, "sensor:sensor%d.v%d.up.th", i, j);
                                r = ini_rw(dic, token, &pover->sensor_val1_upper_threshold, sizeof(pover->sensor_val1_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                                sprintf(token, "sensor:sensor%d.v%d.up.th_act", i, j);
                                r = ini_rw(dic, token, &pover->sensor_val1_upper_threshold_ctrl, sizeof(pover->sensor_val1_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                                sprintf(token, "sensor:sensor%d.v%d.up.th_para", i, j);
                                r = ini_rw(dic, token, &pover->sensor_val1_upper_threshold_ctrl_para, sizeof(pover->sensor_val1_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;
                            }
                            else {
                                sprintf(token, "sensor:sensor%d.v%d.lo.en", i, j);
                                r = ini_rw(dic, token, &pover->sensor_val1_lower_enabled, sizeof(pover->sensor_val1_lower_enabled), TYPE_INT, op, 1); if(r) break;

                                sprintf(token, "sensor:sensor%d.v%d.lo.th", i, j);
                                r = ini_rw(dic, token, &pover->sensor_val1_lower_threshold, sizeof(pover->sensor_val1_lower_threshold), TYPE_FLOAT, op, 1); if(r) break;

                                sprintf(token, "sensor:sensor%d.v%d.lo.th_act", i, j);
                                r = ini_rw(dic, token, &pover->sensor_val1_lower_threshold_ctrl, sizeof(pover->sensor_val1_lower_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                                sprintf(token, "sensor:sensor%d.v%d.lo.th_para", i, j);
                                r = ini_rw(dic, token, &pover->sensor_val1_lower_threshold_ctrl_para, sizeof(pover->sensor_val1_lower_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;
                            }
                        }
                        else {
                            if(k==1) {
                                sprintf(token, "sensor:sensor%d.v%d.up.en", i, j);
                                r = ini_rw(dic, token, &pover->sensor_val2_upper_enabled, sizeof(pover->sensor_val2_upper_enabled), TYPE_INT, op, 1); if(r) break;

                                sprintf(token, "sensor:sensor%d.v%d.up.th", i, j);
                                r = ini_rw(dic, token, &pover->sensor_val2_upper_threshold, sizeof(pover->sensor_val2_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                                sprintf(token, "sensor:sensor%d.v%d.up.th_act", i, j);
                                r = ini_rw(dic, token, &pover->sensor_val2_upper_threshold_ctrl, sizeof(pover->sensor_val2_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                                sprintf(token, "sensor:sensor%d.v%d.up.th_para", i, j);
                                r = ini_rw(dic, token, &pover->sensor_val2_upper_threshold_ctrl_para, sizeof(pover->sensor_val2_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;
                            }
                            else {
                                sprintf(token, "sensor:sensor%d.v%d.lo.en", i, j);
                                r = ini_rw(dic, token, &pover->sensor_val2_lower_enabled, sizeof(pover->sensor_val2_lower_enabled), TYPE_INT, op, 1); if(r) break;

                                sprintf(token, "sensor:sensor%d.v%d.lo.th", i, j);
                                r = ini_rw(dic, token, &pover->sensor_val2_lower_threshold, sizeof(pover->sensor_val2_lower_threshold), TYPE_FLOAT, op, 1); if(r) break;

                                sprintf(token, "sensor:sensor%d.v%d.lo.th_act", i, j);
                                r = ini_rw(dic, token, &pover->sensor_val2_lower_threshold_ctrl, sizeof(pover->sensor_val2_lower_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                                sprintf(token, "sensor:sensor%d.v%d.lo.th_para", i, j);
                                r = ini_rw(dic, token, &pover->sensor_val2_lower_threshold_ctrl_para, sizeof(pover->sensor_val2_lower_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;
                            }
                        }
                        if(r) break;
                    }
                    if(r) break;
                }
                if(r) break;
                cnt++;
                i++;
            }

            list_for_each_entry_safe(node,next,&psensor->list,list) {
                list_del(&node->list); free(node);
            }

            if(cnt>0) {
                r = ini_dump(path, dic);
            }
        }
        break;

        default:
        return -1;
    }
    iniparser_freedict(dic);

    return r;
}

static int get_power(int ch_id, GlobalPowerManger *power)
{
    int quit=0;
    GlobalDeviceManager *dm=get_dm();
    GlobalPowerManger *hd,*tmp;

    hd = tmp = &dm->_globalPowerManger;
    while(tmp) {
        if(tmp->product_ch_id==ch_id) {
            if(power) *power = *tmp;
            return 0;
        }

        if(tmp->list.next==&hd->list) break;
        tmp = (GlobalPowerManger*)((uint32_t)tmp->list.next - offsetof(typeof(*tmp),list));
    }
    return -1;
}

static int proc_power(char *path, int op, GlobalPowerManger *power)
{
    int i,j,r=0;
    char temp[100];
    char *p,token[100];
    dictionary *dic=NULL;
    GlobalPowerManger power2,*ppower=power;
    GlobalDeviceManager *dm=get_dm();

    switch(op) {
        case PARAS_CHECK:
        {
            if(ppower->product_ch_addr<0) {
                LOGE("___ check power, product_ch_addr %d is invalid, must greater than 0\n", ppower->product_ch_addr);
                r = -1; 
            }
            return r;
        }
        break;

        case PARAS_CREATE:
        {
            FILE *fp=fopen(path, "a+");
            if(!fp) {
                LOGE("___ %s open failed\n", path);
                return -1;
            }

            fprintf(fp, "[power]\n");
            fprintf(fp, "\n");
            fclose(fp);
            return 0;
        }
        break;

        case PARAS_READ:
        {
            float f;
            int x,chk_ok=0,cnt_ok=0;

            GlobalPowerManger *tmp=&power2;
            dic = iniparser_load(path); if(!dic) return -1;

            memset(tmp, 0, sizeof(GlobalPowerManger));
            for(x=0; x<2; x++) {
                for(i=1; i<=dm->brdMax; i++) {+
                    sprintf(token, "power:channel%d.addr",i);
                    r = ini_rw(dic, token, &tmp->product_saddr, sizeof(tmp->product_saddr), TYPE_INT, op, 1); if(r) break;
                    tmp->product_ch_id = i;

                    sprintf(token, "power:channel%d.ch_addr",tmp->product_ch_id);
                    r = ini_rw(dic, token, &tmp->product_ch_addr, sizeof(tmp->product_ch_addr), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.name",tmp->product_ch_id);
                    r = ini_rw(dic, token, tmp->product_ch_name, sizeof(tmp->product_ch_name), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.type",tmp->product_ch_id);
                    r = ini_rw(dic, token, &tmp->product_ch_type, sizeof(tmp->product_ch_type), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.status",tmp->product_ch_id);
                    r = ini_rw(dic, token, &tmp->product_ch_status, sizeof(tmp->product_ch_status), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.start_delay",tmp->product_ch_id);
                    r = ini_rw(dic, token, &tmp->product_ch_start_delay, sizeof(tmp->product_ch_start_delay), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.stop_delay",tmp->product_ch_id);
                    r = ini_rw(dic, token, &tmp->product_ch_stop_delay, sizeof(tmp->product_ch_stop_delay), TYPE_INT, op, 1); if(r) break;

                    ///////////voltage//////////
                    GlobalOverManager *pover=&tmp->global_over_manager;
                    //upper
                    sprintf(token, "power:channel%d.threshold.voltate.up.en",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_vol_upper_enable, sizeof(pover->product_vol_upper_enable), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.voltate.up.val",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_vol_upper_threshold, sizeof(pover->product_vol_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.voltate.up.act",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_vol_over_upper_threshold_ctrl, sizeof(pover->product_vol_over_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.voltate.up.para",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_vol_over_upper_threshold_ctrl_para, sizeof(pover->product_vol_over_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;

                    //lower
                    sprintf(token, "power:channel%d.threshold.voltate.lo.en",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_vol_lower_enable, sizeof(pover->product_vol_lower_enable), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.voltate.lo.val",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_vol_lower_threshold, sizeof(pover->product_vol_lower_threshold), TYPE_FLOAT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.voltate.lo.act",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_vol_over_lower_threshold_ctrl, sizeof(pover->product_vol_over_lower_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.voltate.lo.para",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_vol_over_lower_threshold_ctrl_para, sizeof(pover->product_vol_over_lower_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;

                    ///////////current//////////
                    sprintf(token, "power:channel%d.threshold.current.up.en",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_cur_upper_enable, sizeof(pover->product_cur_upper_enable), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.current.up.val",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_cur_upper_threshold, sizeof(pover->product_cur_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.current.up.act",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_cur_over_upper_threshold_ctrl, sizeof(pover->product_cur_over_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.current.up.para",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_cur_over_upper_threshold_ctrl_para, sizeof(pover->product_cur_over_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;

                    ///////////power//////////
                    sprintf(token, "power:channel%d.threshold.power.up.en",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_pwr_upper_enable, sizeof(pover->product_pwr_upper_enable), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.power.up.val",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_pwr_upper_threshold, sizeof(pover->product_pwr_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.power.up.act",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_pwr_over_upper_threshold_ctrl, sizeof(pover->product_pwr_over_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.power.up.para",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_pwr_over_upper_threshold_ctrl_para, sizeof(pover->product_pwr_over_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;

                    ///////////power consumption//////////
                    sprintf(token, "power:channel%d.threshold.powerc.up.en",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_pwrcon_upper_enable, sizeof(pover->product_pwrcon_upper_enable), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.powerc.up.val",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_pwrcon_upper_threshold, sizeof(pover->product_pwrcon_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.powerc.up.act",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_pwrcon_over_upper_threshold_ctrl, sizeof(pover->product_pwrcon_over_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.powerc.up.para",tmp->product_ch_id);
                    r = ini_rw(dic, token, &pover->product_pwrcon_over_upper_threshold_ctrl_para, sizeof(pover->product_pwrcon_over_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break; 
                    
                    if(chk_ok==0) {
                        r = proc_power(path, PARAS_CHECK, tmp); if(r) break;
                        cnt_ok++;
                    }
                    else {
                        GlobalPowerManger pwr;
                        
                        r = dev_update_power_manage_genera_info(dm->db, 0, tmp->product_ch_id, tmp);  if(r) break;
                        r = dev_update_power_manage_over_info(dm->db, 0, tmp->product_ch_id, tmp);    if(r) break;

                        r = get_power(tmp->product_ch_id, &pwr); if(r) break;
                        tmp->_PowerInfo = pwr._PowerInfo;
                        r = g_switch_set_all_single_threshold(&dm->_globalRelaySampManger,
                                                    tmp->product_ch_type, tmp->product_saddr,
                                                    tmp->product_ch_addr, tmp);
                    }
                }

                if(x==0) {
                    if(cnt_ok==0) break;
                    chk_ok = 1;
                }
                else {
                    if(r) {
                        if(i>cnt_ok) {
                            r = 0; break;
                        }
                    }
                }
            }
        }
        break;

        case PARAS_WRITE:
        {
            int cnt=0;
            GlobalPowerManger *tmp,*node,*next;

            ppower = &power2;

            INIT_LIST_HEAD(&ppower->list);
            r = dev_get_power_info(dm->db, ppower); if(r) return -1;
            dic = dictionary_new(0);                if(!dic) return -1;

            list_for_each_entry(tmp, &ppower->list, list) {
                if(!tmp) break;
                r = proc_power(path, PARAS_CHECK, tmp); if(r) break;

                sprintf(token, "power:channel%d.addr",tmp->product_ch_id);
                r = ini_rw(dic, token, &tmp->product_saddr, sizeof(tmp->product_saddr), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.ch_addr",tmp->product_ch_id);
                r = ini_rw(dic, token, &tmp->product_ch_addr, sizeof(tmp->product_ch_addr), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.name",tmp->product_ch_id);
                r = ini_rw(dic, token, tmp->product_ch_name, sizeof(tmp->product_ch_name), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.type",tmp->product_ch_id);
                r = ini_rw(dic, token, &tmp->product_ch_type, sizeof(tmp->product_ch_type), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.status",tmp->product_ch_id);
                r = ini_rw(dic, token, &tmp->product_ch_status, sizeof(tmp->product_ch_status), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.start_delay",tmp->product_ch_id);
                r = ini_rw(dic, token, &tmp->product_ch_start_delay, sizeof(tmp->product_ch_start_delay), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.stop_delay",tmp->product_ch_id);
                r = ini_rw(dic, token, &tmp->product_ch_stop_delay, sizeof(tmp->product_ch_stop_delay), TYPE_INT, op, 1); if(r) break;

                ///////////voltage//////////
                GlobalOverManager *pover=&tmp->global_over_manager;
                //upper
                sprintf(token, "power:channel%d.threshold.voltate.up.en",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_vol_upper_enable, sizeof(pover->product_vol_upper_enable), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.voltate.up.val",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_vol_upper_threshold, sizeof(pover->product_vol_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.voltate.up.act",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_vol_over_upper_threshold_ctrl, sizeof(pover->product_vol_over_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.voltate.up.para",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_vol_over_upper_threshold_ctrl_para, sizeof(pover->product_vol_over_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;

                //lower
                sprintf(token, "power:channel%d.threshold.voltate.lo.en",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_vol_lower_enable, sizeof(pover->product_vol_lower_enable), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.voltate.lo.val",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_vol_lower_threshold, sizeof(pover->product_vol_lower_threshold), TYPE_FLOAT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.voltate.lo.act",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_vol_over_lower_threshold_ctrl, sizeof(pover->product_vol_over_lower_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.voltate.lo.para",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_vol_over_lower_threshold_ctrl_para, sizeof(pover->product_vol_over_lower_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;

                ///////////current//////////
                sprintf(token, "power:channel%d.threshold.current.up.en",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_cur_upper_enable, sizeof(pover->product_cur_upper_enable), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.current.up.val",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_cur_upper_threshold, sizeof(pover->product_cur_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.current.up.act",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_cur_over_upper_threshold_ctrl, sizeof(pover->product_cur_over_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.current.up.para",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_cur_over_upper_threshold_ctrl_para, sizeof(pover->product_cur_over_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;

                ///////////power//////////
                sprintf(token, "power:channel%d.threshold.power.up.en",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_pwr_upper_enable, sizeof(pover->product_pwr_upper_enable), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.power.up.val",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_pwr_upper_threshold, sizeof(pover->product_pwr_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.power.up.act",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_pwr_over_upper_threshold_ctrl, sizeof(pover->product_pwr_over_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.power.up.para",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_pwr_over_upper_threshold_ctrl_para, sizeof(pover->product_pwr_over_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;

                ///////////power consumption//////////
                sprintf(token, "power:channel%d.threshold.powerc.up.en",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_pwrcon_upper_enable, sizeof(pover->product_pwrcon_upper_enable), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.powerc.up.val",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_pwrcon_upper_threshold, sizeof(pover->product_pwrcon_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.powerc.up.act",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_pwrcon_over_upper_threshold_ctrl, sizeof(pover->product_pwrcon_over_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.powerc.up.para",tmp->product_ch_id);
                r = ini_rw(dic, token, &pover->product_pwrcon_over_upper_threshold_ctrl_para, sizeof(pover->product_pwrcon_over_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;
                cnt++;
            }

            list_for_each_entry_safe(node,next,&ppower->list,list) {
                list_del(&node->list); free(node);
            }

            if(cnt>0) {
                r = ini_dump(path, dic);
            } 
        }
        break;

        default:
        return -1;
    }
    iniparser_freedict(dic);

    return r;
}
static int proc_power3(char *path, int op, GlobalTreeACManager *power)
{
   int i,j,r=0;
    char temp[100];
    char *p,token[100];
    dictionary *dic=NULL;
    GlobalTreeACManager power2,*ppower=power;
    GlobalDeviceManager *dm=get_dm();
    int pwrtype=dm->_globalDevInfo.product.pwr_type;

    switch(op) {
        case PARAS_CHECK:
        {
            if(ppower->product_ch_addr<0) {
                LOGE("___ check power, product_ch_addr %d is invalid, must greater than 0\n", ppower->product_ch_addr);
                r = -1; 
            }
            return r;
        }
        break;

        case PARAS_CREATE:
        {
            FILE *fp=fopen(path, "a+");
            if(!fp) {
                LOGE("___ %s open failed\n", path);
                return -1;
            }

            fprintf(fp, "[power]\n");
            fprintf(fp, "\n");
            fclose(fp);
            return 0;
        }
        break;

        case PARAS_READ:
        {
            float f;
            int x,chk_ok=0,cnt_ok=0;
            GlobalPowerManger pwr;
            GlobalTreeACManager *tmp=&power2;
            dic = iniparser_load(path); if(!dic) return -1;

            memset(tmp, 0, sizeof(GlobalTreeACManager));
            for(x=0; x<2; x++) {
                for(i=1; i<=dm->brdMax*3; i++) {
                    int channelID = i;

                    sprintf(token, "power:channel%d.addr",i);
                    r = ini_rw(dic, token, &tmp->product_saddr, sizeof(tmp->product_saddr), TYPE_INT, op, 1); if(r) break;

                    tmp->product_ph_id = channelID-1;

                    sprintf(token, "power:channel%d.ch_addr",channelID);
                    r = ini_rw(dic, token, &tmp->product_ch_addr, sizeof(tmp->product_ch_addr), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.ch_id",channelID);
                    r = ini_rw(dic, token, &tmp->product_ch_id, sizeof(tmp->product_ch_id), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.ph_type",channelID);
                    r = ini_rw(dic, token, &tmp->product_ph_type, sizeof(tmp->product_ph_type), TYPE_INT, op, 1); if(r) break;
/*
                    sprintf(token, "power:channel%d.ph_otype",channelID);
                    r = ini_rw(dic, token, &tmp->product_ph_outputType, sizeof(tmp->product_ph_outputType), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.ph_ostat",channelID);
                    r = ini_rw(dic, token, &tmp->product_ph_outputStatus, sizeof(tmp->product_ph_outputStatus), TYPE_INT, op, 1); if(r) break;
*/
                    ///////////voltage//////////
                    GlobalOverManager *pover=&tmp->global_over_manager;
                    //upper
                    sprintf(token, "power:channel%d.threshold.voltage.up.en",channelID);
                    r = ini_rw(dic, token, &pover->product_vol_upper_enable, sizeof(pover->product_vol_upper_enable), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.voltage.up.val",channelID);
                    r = ini_rw(dic, token, &pover->product_vol_upper_threshold, sizeof(pover->product_vol_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.voltage.up.act",channelID);
                    r = ini_rw(dic, token, &pover->product_vol_over_upper_threshold_ctrl, sizeof(pover->product_vol_over_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.voltage.up.para",channelID);
                    r = ini_rw(dic, token, &pover->product_vol_over_upper_threshold_ctrl_para, sizeof(pover->product_vol_over_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;

                    //lower
                    sprintf(token, "power:channel%d.threshold.voltage.lo.en",channelID);
                    r = ini_rw(dic, token, &pover->product_vol_lower_enable, sizeof(pover->product_vol_lower_enable), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.voltage.lo.val",channelID);
                    r = ini_rw(dic, token, &pover->product_vol_lower_threshold, sizeof(pover->product_vol_lower_threshold), TYPE_FLOAT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.voltage.lo.act",channelID);
                    r = ini_rw(dic, token, &pover->product_vol_over_lower_threshold_ctrl, sizeof(pover->product_vol_over_lower_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.voltage.lo.para",channelID);
                    r = ini_rw(dic, token, &pover->product_vol_over_lower_threshold_ctrl_para, sizeof(pover->product_vol_over_lower_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;

                    ///////////current//////////
                    sprintf(token, "power:channel%d.threshold.current.up.en",channelID);
                    r = ini_rw(dic, token, &pover->product_cur_upper_enable, sizeof(pover->product_cur_upper_enable), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.current.up.val",channelID);
                    r = ini_rw(dic, token, &pover->product_cur_upper_threshold, sizeof(pover->product_cur_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.current.up.act",channelID);
                    r = ini_rw(dic, token, &pover->product_cur_over_upper_threshold_ctrl, sizeof(pover->product_cur_over_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.current.up.para",channelID);
                    r = ini_rw(dic, token, &pover->product_cur_over_upper_threshold_ctrl_para, sizeof(pover->product_cur_over_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;

                    ///////////power//////////
                    sprintf(token, "power:channel%d.threshold.power.up.en",channelID);
                    r = ini_rw(dic, token, &pover->product_pwr_upper_enable, sizeof(pover->product_pwr_upper_enable), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.power.up.val",channelID);
                    r = ini_rw(dic, token, &pover->product_pwr_upper_threshold, sizeof(pover->product_pwr_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.power.up.act",channelID);
                    r = ini_rw(dic, token, &pover->product_pwr_over_upper_threshold_ctrl, sizeof(pover->product_pwr_over_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.power.up.para",channelID);
                    r = ini_rw(dic, token, &pover->product_pwr_over_upper_threshold_ctrl_para, sizeof(pover->product_pwr_over_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;

                    ///////////power consumption//////////
                    sprintf(token, "power:channel%d.threshold.powerc.up.en",channelID);
                    r = ini_rw(dic, token, &pover->product_pwrcon_upper_enable, sizeof(pover->product_pwrcon_upper_enable), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.powerc.up.val",channelID);
                    r = ini_rw(dic, token, &pover->product_pwrcon_upper_threshold, sizeof(pover->product_pwrcon_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.powerc.up.act",channelID);
                    r = ini_rw(dic, token, &pover->product_pwrcon_over_upper_threshold_ctrl, sizeof(pover->product_pwrcon_over_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                    sprintf(token, "power:channel%d.threshold.powerc.up.para",channelID);
                    r = ini_rw(dic, token, &pover->product_pwrcon_over_upper_threshold_ctrl_para, sizeof(pover->product_pwrcon_over_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;
                    
                    if(chk_ok==0) {
                        r = proc_power3(path, PARAS_CHECK, tmp); if(r) break;
                        cnt_ok++;
                    }
                    else {
                        //PowerInfo tt;
                        //r = g_switch_get_t_ac_out_info(&dm->_globalRelaySampManger, tmp->product_saddr, tmp->product_ch_id, &tt); if(r) break;

                        //r = dev_get_power_manage_info2(dm->db, tmp->product_ch_id, &pwr); if(r) break;
                        r = get_power(tmp->product_ch_id, &pwr); if(r) break;

                        pwr.global_over_manager = tmp->global_over_manager;
                        r = dev_update_power_manage_over_info(dm->db, 0, pwr.product_ch_id, &pwr);  if(r) break;

                        r = dev_update_t_ac_power_manage_over_info(dm->db, tmp);    if(r) break;

                        r = g_switch_set_all_single_threshold(&dm->_globalRelaySampManger,
                                                    pwr.product_ch_type,
                                                    tmp->product_saddr,
                                                    tmp->product_ch_addr,
                                                    &pwr);
                    }
                }

                if(x==0) {
                    if(cnt_ok==0) break;
                    chk_ok = 1;
                }
                else {
                    if(i>cnt_ok) {
                        r = 0; break;
                    }
                }
            }
        }
        break;

        case PARAS_WRITE:
        {
            int cnt=0,channelID=-1;
            GlobalTreeACManager *tmp,*node,*next;

            ppower = &power2;

            INIT_LIST_HEAD(&ppower->list_Tree_AC);
            r = dev_get_ac_power_info(dm->db, ppower); if(r) return -1;
            dic = dictionary_new(0);                   if(!dic) return -1;

            list_for_each_entry(tmp, &ppower->list_Tree_AC, list_Tree_AC) {
                if(!tmp) break;

                //if(tmp->product_ph_id%3) continue;
                //channelID = tmp->product_ph_id/3+1;
                channelID = tmp->product_ph_id+1;

                r = proc_power3(path, PARAS_CHECK, tmp); if(r) break;

                sprintf(token, "power:channel%d.addr",channelID);
                r = ini_rw(dic, token, &tmp->product_saddr, sizeof(tmp->product_saddr), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.ch_id",channelID);
                r = ini_rw(dic, token, &tmp->product_ch_id, sizeof(tmp->product_ch_id), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.ch_addr",channelID);
                r = ini_rw(dic, token, &tmp->product_ch_addr, sizeof(tmp->product_ch_addr), TYPE_INT, op, 1); if(r) break;

                //sprintf(token, "power:channel%d.ph_id",channelID);
                //r = ini_rw(dic, token, &tmp->product_ph_id, sizeof(tmp->product_ph_id), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.ph_type",channelID);
                r = ini_rw(dic, token, &tmp->product_ph_type, sizeof(tmp->product_ph_type), TYPE_INT, op, 1); if(r) break;
/*
                sprintf(token, "power:channel%d.ph_otype",channelID);
                r = ini_rw(dic, token, &tmp->product_ph_outputType, sizeof(tmp->product_ph_outputType), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.ph_ostat",channelID);
                r = ini_rw(dic, token, &tmp->product_ph_outputStatus, sizeof(tmp->product_ph_outputStatus), TYPE_INT, op, 1); if(r) break;
*/
                ///////////voltage//////////
                GlobalOverManager *pover=&tmp->global_over_manager;
                //upper
                sprintf(token, "power:channel%d.threshold.voltage.up.en",channelID);
                r = ini_rw(dic, token, &pover->product_vol_upper_enable, sizeof(pover->product_vol_upper_enable), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.voltage.up.val",channelID);
                r = ini_rw(dic, token, &pover->product_vol_upper_threshold, sizeof(pover->product_vol_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.voltage.up.act",channelID);
                r = ini_rw(dic, token, &pover->product_vol_over_upper_threshold_ctrl, sizeof(pover->product_vol_over_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.voltage.up.para",channelID);
                r = ini_rw(dic, token, &pover->product_vol_over_upper_threshold_ctrl_para, sizeof(pover->product_vol_over_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;

                //lower
                sprintf(token, "power:channel%d.threshold.voltage.lo.en",channelID);
                r = ini_rw(dic, token, &pover->product_vol_lower_enable, sizeof(pover->product_vol_lower_enable), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.voltage.lo.val",channelID);
                r = ini_rw(dic, token, &pover->product_vol_lower_threshold, sizeof(pover->product_vol_lower_threshold), TYPE_FLOAT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.voltage.lo.act",channelID);
                r = ini_rw(dic, token, &pover->product_vol_over_lower_threshold_ctrl, sizeof(pover->product_vol_over_lower_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.voltage.lo.para",channelID);
                r = ini_rw(dic, token, &pover->product_vol_over_lower_threshold_ctrl_para, sizeof(pover->product_vol_over_lower_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;

                ///////////current//////////
                sprintf(token, "power:channel%d.threshold.current.up.en",channelID);
                r = ini_rw(dic, token, &pover->product_cur_upper_enable, sizeof(pover->product_cur_upper_enable), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.current.up.val",channelID);
                r = ini_rw(dic, token, &pover->product_cur_upper_threshold, sizeof(pover->product_cur_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.current.up.act",channelID);
                r = ini_rw(dic, token, &pover->product_cur_over_upper_threshold_ctrl, sizeof(pover->product_cur_over_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.current.up.para",channelID);
                r = ini_rw(dic, token, &pover->product_cur_over_upper_threshold_ctrl_para, sizeof(pover->product_cur_over_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;

                ///////////power//////////
                sprintf(token, "power:channel%d.threshold.power.up.en",channelID);
                r = ini_rw(dic, token, &pover->product_pwr_upper_enable, sizeof(pover->product_pwr_upper_enable), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.power.up.val",channelID);
                r = ini_rw(dic, token, &pover->product_pwr_upper_threshold, sizeof(pover->product_pwr_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.power.up.act",channelID);
                r = ini_rw(dic, token, &pover->product_pwr_over_upper_threshold_ctrl, sizeof(pover->product_pwr_over_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.power.up.para",channelID);
                r = ini_rw(dic, token, &pover->product_pwr_over_upper_threshold_ctrl_para, sizeof(pover->product_pwr_over_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;

                ///////////power consumption//////////
                sprintf(token, "power:channel%d.threshold.powerc.up.en",channelID);
                r = ini_rw(dic, token, &pover->product_pwrcon_upper_enable, sizeof(pover->product_pwrcon_upper_enable), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.powerc.up.val",channelID);
                r = ini_rw(dic, token, &pover->product_pwrcon_upper_threshold, sizeof(pover->product_pwrcon_upper_threshold), TYPE_FLOAT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.powerc.up.act",channelID);
                r = ini_rw(dic, token, &pover->product_pwrcon_over_upper_threshold_ctrl, sizeof(pover->product_pwrcon_over_upper_threshold_ctrl), TYPE_INT, op, 1); if(r) break;

                sprintf(token, "power:channel%d.threshold.powerc.up.para",channelID);
                r = ini_rw(dic, token, &pover->product_pwrcon_over_upper_threshold_ctrl_para, sizeof(pover->product_pwrcon_over_upper_threshold_ctrl_para), TYPE_INT, op, 1); if(r) break;
                cnt++;
            }

            list_for_each_entry_safe(node,next,&ppower->list_Tree_AC,list_Tree_AC) {
                list_del(&node->list_Tree_AC); free(node);
            }

            if(cnt>0) {
                r = ini_dump(path, dic);
            } 
        }
        break;

        default:
        return -1;
    }
    iniparser_freedict(dic);

    return r;
}


static int proc_timer(char *path, int op, timer_data_t *timer)
{
    int r=0;
    char temp[100];
    char *p,*token=NULL;
    FILE *fp=NULL;
    dictionary *dic=NULL;

    if(op==PARAS_CHECK) {
        if(ptotal->voltage<=0) {
            LOGE("___ check timer, voltage is invalid, must greater than 0\n");
            r = -1; 
        }

        return r;
    }
    else if(op==PARAS_CREATE) {
        fp = fopen(path, "a+");
        if(!fp) {
            LOGE("___ %s open failed\n", path);
            return -1;
        }

        fprintf(fp, "[mqtt]\n");
        for(i=0; i<MQTT_SER_MAX; i++) {
            if(mqtt->ser[i].id>=0) {
                fprintf(fp, "broker%d.plat      = \"%d\"\n", i+1,mqtt->ser[i].plat);
                fprintf(fp, "broker%d.mode      = \"%d\"\n", i+1,mqtt->ser[i].mode);
                //fprintf(fp, "broker%d.proto     = \"%s\"\n", i+1,mqtt->ser[i].proto);
                fprintf(fp, "broker%d.name      = \"%s\"\n", i+1,mqtt->ser[i].name);
                fprintf(fp, "broker%d.server    = \"%s\"\n", i+1,mqtt->ser[i].server);
                fprintf(fp, "broker%d.port      = \"%s\"\n", i+1,mqtt->ser[i].port);
                fprintf(fp, "broker%d.clientID  = \"%s\"\n", i+1,mqtt->ser[i].clientID);
                fprintf(fp, "broker%d.user      = \"%s\"\n", i+1,mqtt->ser[i].user);
                fprintf(fp, "broker%d.password  = \"%s\"\n", i+1,mqtt->ser[i].password);
                fprintf(fp, "broker%d.cert      = \"%s\"\n", i+1,mqtt->ser[i].cert);
                fprintf(fp, "\n");
            }
        }

        fclose(fp);
        return 0;
    }
    else {
        if (op==PARAS_WRITE) {
            r = proc_timer(path, PARAS_CHECK, timer);
            if(r) {
                return -1;
            }
        }
        dic = iniparser_load(path);
    }

    token = "ptotal:voltage";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        ptotal->voltage = r;
    }
    else {
        sprintf(temp, "%d", ptotal->voltage);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    if(op==PARAS_READ) {
        r = proc_timer(path, PARAS_CHECK, timer);
        if(r) {
            return -1;
        }
    }

quit:
    iniparser_freedict(dic);
    return r;
}
static int proc_breaker(char *path, int op, GlobalBreakerManager *breaker)
{
    int i,r=0;
    char temp[100];
    char *p,*token=NULL;
    FILE *fp=NULL;
    dictionary *dic=NULL;

    if(op==PARAS_CHECK) {
        if(breaker->voltage<=0) {
            LOGE("___ check breaker, voltage is invalid, must greater than 0\n");
            r = -1; 
        }

        return r;
    }
    else if(op==PARAS_CREATE) {
        fp = fopen(path, "a+");
        if(!fp) {
            LOGE("___ %s open failed\n", path);
            return -1;
        }

        fprintf(fp, "[mqtt]\n");
        for(i=0; i<MQTT_SER_MAX; i++) {
            if(mqtt->ser[i].id>=0) {
                fprintf(fp, "broker%d.plat      = \"%d\"\n", i+1,mqtt->ser[i].plat);
                fprintf(fp, "broker%d.mode      = \"%d\"\n", i+1,mqtt->ser[i].mode);
                //fprintf(fp, "broker%d.proto     = \"%s\"\n", i+1,mqtt->ser[i].proto);
                fprintf(fp, "broker%d.name      = \"%s\"\n", i+1,mqtt->ser[i].name);
                fprintf(fp, "broker%d.server    = \"%s\"\n", i+1,mqtt->ser[i].server);
                fprintf(fp, "broker%d.port      = \"%s\"\n", i+1,mqtt->ser[i].port);
                fprintf(fp, "broker%d.clientID  = \"%s\"\n", i+1,mqtt->ser[i].clientID);
                fprintf(fp, "broker%d.user      = \"%s\"\n", i+1,mqtt->ser[i].user);
                fprintf(fp, "broker%d.password  = \"%s\"\n", i+1,mqtt->ser[i].password);
                fprintf(fp, "broker%d.cert      = \"%s\"\n", i+1,mqtt->ser[i].cert);
                fprintf(fp, "\n");
            }
        }

        fclose(fp);
        return 0;
    }
    else {
         if(op==PARAS_WRITE) {
            r = proc_breaker(path, PARAS_CHECK, breaker);
            if(r) {
                return -1;
            }
        }
        dic = iniparser_load(path);
    }

    token = "ptotal:voltage";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        ptotal->voltage = r;
    }
    else {
        sprintf(temp, "%d", ptotal->voltage);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    if(op==PARAS_READ) {
        r = proc_breaker(path, PARAS_CHECK, breaker);
        if(r) {
            return -1;
        }
    }

quit:
    iniparser_freedict(dic);
    return r;
}
#endif
/////////////////////////////////////////////////////////////////
static dictionary* ini_load(char *path, paras_data_t *info)
{
    int r=-1;
    
    dictionary *dic=iniparser_load(path);
    if(dic == NULL){
        return NULL;
    }
   
    r = proc_prod(dic, PARAS_READ, &info->prod);
    if(r) {
        LOGE("___proc_prod failed\n");
    }

    r = proc_modbus(dic, PARAS_READ, &info->cas);
    if(r) {
        LOGE("___proc_modbus failed\n");
    }

    r = proc_misc(dic, PARAS_READ, &info->misc);
    if(r) {
        LOGE("___proc_misc failed\n");
    }
    
		r = proc_sensor(dic, PARAS_READ, info->sensor);
    if(r) {
        LOGE("___proc_sensor failed\n");
    }	
		
		r = proc_net(dic, PARAS_READ, &info->netwk);
    if(r) {
        LOGE("proc_net failed\n");
    }	
		r = proc_snmp_n(dic, PARAS_READ, &info->snmp);
		if(r){
			LOGE("proc_snmp failed\n");
		}
		
		r=proc_phase_3_1(dic,PARAS_READ,&info->phase_seq);
		if(r){
			LOGE("proc_phase_3_1 failed\n");
		}	

		r=proc_phase_3_2(dic,PARAS_READ,&info->phase_seq_2);
		if(r){
			LOGE("proc_phase_3_2 failed\n");
		}			
    return dic;
}
static int ini_check(char *path)
{
    paras_data_t *p=(paras_data_t*)MALLOC(sizeof(paras_data_t));
    
    if(!p) {
        return -1;
    }
    
    dictionary *dic=ini_load(path, p);
    iniparser_freedict(dic);

    return 0;
}
static int ini_reset(paras_handle_t *h)
{
    int r;
    FILE *fp=NULL;
    char tmp[100];
    paras_data_t *p=&DFLT_PARAS;

    fp = fopen(h->path, "w");
    if (fp==NULL) {
        LOGE("ini_reset, fopen %s failed\n", h->path);
        return -1;
    }

    fprintf(fp, "[product]\n");
    fprintf(fp, "id          = \"%d\"\n", p->prod.id);
    fprintf(fp, "number      = \"%s\"\n", p->prod.number);
    fprintf(fp, "name        = \"%s\"\n", p->prod.name);
    fprintf(fp, "type        = \"%d\"\n", p->prod.type);
    //fprintf(fp, "version     = %s\\"n", p->prod.version);
    fprintf(fp, "samptime    = \"%d\"\n", p->prod.samp_time);
    fprintf(fp, "savetime    = \"%d\"\n", p->prod.save_time);
    fprintf(fp, "ph_group    = \"%d\"\n", p->prod.ph_group);
    fprintf(fp, "ch_delay    = \"%d\"\n", p->prod.ch_delay);
    fprintf(fp, "\n");

    fprintf(fp, "[modbus]\n");
    fprintf(fp, "mode        = \"%d\"\n", p->cas.mode);
    fprintf(fp, "address     = \"%d\"\n", p->cas.addr);
    fprintf(fp, "baudrate    = \"%d\"\n", p->cas.baud);
    fprintf(fp, "\n");

    fprintf(fp, "[misc]\n");
    fprintf(fp, "watchdog    = \"%d\"\n", p->misc.watchdog);
    fprintf(fp, "fliptime    = \"%d\"\n", p->misc.flip_time);
    fprintf(fp, "led         = \"%d\"\n", p->misc.led);
    fprintf(fp, "beep        = \"%d\"\n", p->misc.beep);
    fprintf(fp, "rotate      = \"%d\"\n", p->misc.rotate);
    fprintf(fp, "\n");
		
		fprintf(fp, "[sensor_1]\n");
		fprintf(fp, "th_max_1    = \"%d\"\n", p->sensor[0].th_max_1);
		fprintf(fp, "th_min_1    = \"%d\"\n", p->sensor[0].th_min_1);
		fprintf(fp, "th_max_2    = \"%d\"\n", p->sensor[0].th_max_2);
		fprintf(fp, "th_min_2    = \"%d\"\n", p->sensor[0].th_min_2);

		fprintf(fp, "[sensor_2]\n");
		fprintf(fp, "th_max_1    = \"%d\"\n", p->sensor[1].th_max_1);
		fprintf(fp, "th_min_1    = \"%d\"\n", p->sensor[1].th_min_1);
		fprintf(fp, "th_max_2    = \"%d\"\n", p->sensor[1].th_max_2);
		fprintf(fp, "th_min_2    = \"%d\"\n", p->sensor[1].th_min_2);
		fprintf(fp, "[sensor_3]\n");
		fprintf(fp, "th_max_1    = \"%d\"\n", p->sensor[2].th_max_1);
		fprintf(fp, "th_min_1    = \"%d\"\n", p->sensor[2].th_min_1);
		fprintf(fp, "th_max_2    = \"%d\"\n", p->sensor[2].th_max_2);
		fprintf(fp, "th_min_2    = \"%d\"\n", p->sensor[2].th_min_2);
		fprintf(fp, "\n");
		
    fprintf(fp, "[network]\n");
    fprintf(fp, "mode      = \"%d\"\n", p->netwk.mode);
    fprintf(fp, "ipaddr    = \"%s\"\n", p->netwk.ipaddr);
    fprintf(fp, "gateway   = \"%s\"\n", p->netwk.gateway);
    fprintf(fp, "mask      = \"%s\"\n", p->netwk.mask);
    fprintf(fp, "dns1      = \"%s\"\n", p->netwk.dns1);
		fprintf(fp, "dns2      = \"%s\"\n", p->netwk.dns2);
    fprintf(fp, "\n");		
		
    fprintf(fp, "[snmp]\n");
    fprintf(fp, "mode        = \"%d\"\n", p->snmp.mode);
    fprintf(fp, "version     = \"%d\"\n", p->snmp.version);
    fprintf(fp, "public      = \"%s\"\n", p->snmp.publics);
    fprintf(fp, "trap_mode   = \"%d\"\n", p->snmp.trapmode);
    fprintf(fp, "nms_ip      = \"%s\"\n", p->snmp.nms_ip);
		fprintf(fp, "\n");	
		
		fprintf(fp, "[ph_3_1]\n");
		fprintf(fp, "phase       = \"%s\"\n", p->phase_seq.phase_seq);
		fprintf(fp, "\n");
		
		fprintf(fp, "[ph_3_2]\n");
		fprintf(fp, "phase_left  = \"%s\"\n", p->phase_seq_2.phase_left);
		fprintf(fp, "phase_right = \"%s\"\n", p->phase_seq_2.phase_right);
		fprintf(fp, "\n");
		
    fclose(fp);
    if(h->dic) {
        iniparser_freedict(h->dic);
    }
    h->dic = ini_load(h->path, &h->paras);

    return 0;
}
static int ini_free(paras_handle_t *h)
{
    iniparser_freedict(h->dic);
    return 0;
}
static int ini_save(paras_handle_t *h)
{
    int r=-1;
    
    r = proc_prod(h->dic, PARAS_WRITE, &h->paras.prod);
    if(r) {
        LOGE("___ini_w_dev failed\n");
        return -1;
    }

    r = proc_modbus(h->dic, PARAS_WRITE, &h->paras.cas);
    if(r) {
        LOGE("___ini_w_modbus failed\n");
        return -1;
    }
		
		r= proc_net(h->dic, PARAS_WRITE, &h->paras.netwk);
    if(r) {
        LOGE("___ini_w_net failed\n");
        return -1;
    }		
		r = proc_snmp_n(h->dic,PARAS_WRITE,&h->paras.snmp);
    if(r) {
        LOGE("___ini_w_snmp failed\n");
        return -1;
    }
		r=proc_phase_3_1(h->dic,PARAS_WRITE,&h->paras.phase_seq);
		if(r){
			LOGE("proc_phase_3_1 failed\n");
			return -1;
		}	

		r=proc_phase_3_2(h->dic,PARAS_WRITE,&h->paras.phase_seq_2);
		if(r){
			LOGE("proc_phase_3_2 failed\n");
			return -1;
		}		

		
    FILE *fp=fopen(h->path, "w");
    if(!fp) {
        LOGE("___%s open failed\n", h->path);
        return -1;
    }
    iniparser_dump_ini(h->dic, fp);
    fclose(fp);

    return 0;
}
#endif
////////////////////////////////////////////////////////////
int paras_init(void)
{
    int r=0;
    char tmp[50];
    paras_handle_t *h=&paraHandle;
    version_data_t *pv=&h->paras.ver;
    
    memset(h, 0, sizeof(paraHandle));
    h->lck = lock_init();
    h->paras = DFLT_PARAS;
    sprintf(h->path, "%s/%s", CFG_PATH, INI_NAME);
    h->dic = ini_load(h->path, &h->paras);
    if(h->dic==NULL) {
        r = ini_reset(h);
    }
    strcpy(pv->ver, VERSION);
    sprintf(tmp, "%s/%s", CFG_PATH, INF_NAME);
    sys_get_prod(tmp, &h->paras);
    sys_get_bldtime(pv->bldtime, sizeof(pv->bldtime));
    
    return r;
}


int paras_deinit(void)
{
    int r=0;
    paras_handle_t *h=&paraHandle;
    
    r = ini_free(h);
    lock_deinit(h->lck);
    
    return 0;
}


paras_data_t* paras_get(void)
{
    paras_handle_t *h=&paraHandle;
    return &h->paras;
}


int paras_check(char *path)
{
    int r=0;
    paras_handle_t *h=&paraHandle;
    
    lock_on(h->lck);
    r = ini_check(path);
    lock_off(h->lck);
    
    return r;
}


int paras_load(char *path)
{
    int r=-1;
    paras_handle_t *h=&paraHandle;

    lock_on(h->lck);
    ini_free(h);
    h->dic = ini_load(path, &h->paras);
    if(h->dic) r = 0;
    lock_off(h->lck);
    
    return r;
}


int paras_reset(void)
{
    int r=0;
    paras_handle_t *h=&paraHandle;
    
    lock_on(h->lck);
    ini_reset(h);
    lock_off(h->lck);
    
    return r;
}


int paras_copy(char *dst, char *src)
{
    int r=-1;
    paras_handle_t *h=&paraHandle;

    lock_on(h->lck);
    r = fs_copy(dst, src);
    lock_off(h->lck);

    return r;
}


int paras_save(void)
{
    int r=0;
    paras_handle_t *h=&paraHandle;
    
    lock_on(h->lck);
    r = ini_save(h);
    lock_off(h->lck);
    
    return r;
}


int paras_serv_xport(char *path, int io)
{
    int r=-1;
    char temp[100];
    handle_t l;
    list_cfg_t lc={0,LIST_FULL_FIFO,100};

    if(io==PARAS_IMPORT) {
        l = NULL;//xlist_init(&lc);

        //r *= proc_role(path,  PARAS_READ, NULL, l);
        //r *= proc_user(path,  PARAS_READ, NULL, l);
        //r *= proc_group(path, PARAS_READ, NULL);
        //r *= proc_ntp(path,   PARAS_READ, NULL);
        //r *= proc_mqtt(path,  PARAS_READ, NULL);
        //r *= proc_mail(path,  PARAS_READ, NULL);
        //r *= proc_snmp(path,  PARAS_READ, NULL);
        //r *= proc_timer(path, PARAS_READ, NULL);

        //xlist_free(l);
    }
    else if(io==PARAS_EXPORT) {
        //get_curtime_str(temp,sizeof(temp));
        //sprintf(path, "/tmp/service_%s.ini", temp);

        //r *= proc_role(path,  PARAS_WRITE, NULL, NULL);
        //r *= proc_user(path,  PARAS_WRITE, NULL, NULL);
        //r *= proc_group(path, PARAS_WRITE, NULL);
        //r *= proc_ntp(path,   PARAS_WRITE, NULL);
        //r *= proc_mqtt(path,  PARAS_WRITE, NULL);
        //r *= proc_mail(path,  PARAS_WRITE, NULL);
        //r *= proc_snmp(path,  PARAS_WRITE, NULL);
        //r *= proc_timer(path, PARAS_WRITE, NULL);
    }

    return r;
}

int paras_alarm_xport(char *path, int io)
{
    int r=-1,pwr3;
    char temp[100];

    pwr3 = is_power3();
    if(io==PARAS_IMPORT) {
        if(pwr3) {
            //r = proc_power3(path, PARAS_READ, NULL);
        }
        else {
            //r = proc_power(path, PARAS_READ, NULL);
        }
    }
    else if(io==PARAS_EXPORT) {
        //get_curtime_str(temp,sizeof(temp));
        sprintf(path, "/tmp/power_%s.ini", temp);

        if(pwr3) {
            //r = proc_power3(path, PARAS_WRITE, NULL);
        }
        else {
            //r = proc_power(path, PARAS_WRITE, NULL);
        }
    }

    return r;
}

int paras_sensor_xport(char *path, int io)
{
    int r=-1;
    char temp[100];
    
    if(io==PARAS_IMPORT) {
        //r = proc_sensor(path, PARAS_READ, NULL);
    }
    else if(io==PARAS_EXPORT) {
        //get_curtime_str(temp,sizeof(temp));
        sprintf(path, "/tmp/sensor_%s.ini", temp);

        //r = proc_sensor(path, PARAS_WRITE, NULL);
    }

    return r;
}