SmartPDCode/pro/src/paras.c

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "sys.h"
#include "file.h"
#include "lock.h"
#include "xlist.h"
#include "paras.h"
#include "cascade.h"
#include "dictionary.h"
#include "iniparser.h"
#include "sqlite_handle.h"


//#define READ_INI


#if 1
    #define LOGD            log_d
    #define LOGE            log_e
    #define LOGW            log_w
#else
    #define LOGD            printf
    #define LOGE            printf
    #define LOGW            printf
#endif

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

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

extern GlobalDeviceInfo DFLT_PARAS;

typedef struct {
    dictionary          *dic;
    GlobalDeviceInfo    *info;
    char                path[200];
}paras_handle_t;
static paras_handle_t  paraHandle={0};


#if 1
static GlobalDeviceManager *get_dm(void)
{
    return &__globalDeviceManage;
}
static int is_power3(void)
{
    GlobalDeviceManager *dm=get_dm();
    if(dm->_globalDevInfo.product.pwr_type>=SmartPDU_Tree_AC_Tree) {
        return 1;
    }
    return 0;
}
static GlobalDeviceInfo *get_info(void)
{
    return &get_dm()->_globalDevInfo;
}
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=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 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;
    }
    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 r=-1;
    if(type==TYPE_INT) {
        int t = iniparser_getint(dic, key, -1);
        if(t>=0) {
            *(((int*)val)) = t;
            r = 0;
        }
    }
    else if(type==TYPE_STR) {
        char *p = (char*)iniparser_getstring(dic, key, NULL);
        if(p) {
            int xlen=strlen(p);
            if(xlen<len) {
                strcpy((char*)val, p);
                r = 0;
            }
            else {
                LOGE("___ %s val len %d longer than recv buf len %d\n", key, xlen, len);
            }
        }
    }
    else if(type==TYPE_FLOAT) {
        double c=-10000.0;
        double f = (float)iniparser_getdouble(dic, key, c);
        if(!feq(f,c)) {
            *((float*)val) = (float)f;
            r = 0;
        }
    }

    if(r) {
        LOGE("___ init_get %s failed\n", key);
    }

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


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

    if(op==PARAS_CHECK) {
        if(prod->language>=4) {
            LOGE("___ check product.language %d is wrong\n", prod->language);
            r = -1;
        }
        if(prod->type>=2) {
            LOGE("___ check product.type %d is wrong\n", prod->type);
            r = -1;
        }
        if(prod->pwr_type>SmartPDU_Tree_AC_One_B) {
            LOGE("___ check product.pwr_type %d is wrong\n", prod->pwr_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;
        }
    }

    token = "product:pwrtype";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            prod->pwr_type = r;
        }
    }
    else {
        sprintf(temp, "%d", prod->pwr_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:language";
    if(op==PARAS_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1;
        } else {
            prod->language = r;
        }
    }
    else {
        sprintf(temp, "%d", prod->language);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    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;
        }
    }

    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, ModbusInfo_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>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->baudrate = r;
        }
    }
    else {
        sprintf(temp, "%d", mb->baudrate);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

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

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

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

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

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

        if(ptotal->brdMax<=0) {
            LOGE("___ check ptotal, brdMax is invalid, must greater than 0\n");
            r = -1; 
        }
        return r;
    }
    else if (op==PARAS_WRITE) {
        r = proc_ptotal(dic, PARAS_CHECK, ptotal);
        if(r) {
            return -1;
        }
    }

    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;
        } else {
            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;
        }
    }

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

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

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

    if(op==PARAS_READ) {
        r = proc_ptotal(dic, PARAS_CHECK, ptotal);
    }

    return r;
}
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); if(r) goto quit;
            r = ini_rw(dic, "ntp:name",    pntp->ntpName,    sizeof(pntp->ntpName),    TYPE_STR, op); if(r) goto quit;
            r = ini_rw(dic, "ntp:address", pntp->ntpaddress, sizeof(pntp->ntpaddress), TYPE_STR, op); if(r) goto quit;
            r = ini_rw(dic, "ntp:port",    &pntp->port,      sizeof(pntp->port),       TYPE_INT, op); if(r) goto quit;
            r = ini_rw(dic, "ntp:tzone",   &pntp->tzone,     sizeof(pntp->tzone),      TYPE_INT, op); if(r) goto quit;
            r = ini_rw(dic, "ntp:time",    pntp->time,       sizeof(pntp->time),       TYPE_STR, op); if(r) goto quit;

            pntp->time[0] = 0;
            pntp->weekday = 0;
            pntp->product_id = 0;
            r = proc_ntp(path, PARAS_CHECK, pntp);
            if(r==0) {
                //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); if(r) goto quit;
            r = ini_rw(dic, "ntp:name",    pntp->ntpName,    sizeof(pntp->ntpName),    TYPE_STR, op); if(r) goto quit;
            r = ini_rw(dic, "ntp:address", pntp->ntpaddress, sizeof(pntp->ntpaddress), TYPE_STR, op); if(r) goto quit;
            r = ini_rw(dic, "ntp:port",    &pntp->port,      sizeof(pntp->port),       TYPE_INT, op); if(r) goto quit;
            r = ini_rw(dic, "ntp:tzone",   &pntp->tzone,     sizeof(pntp->tzone),      TYPE_INT, op); if(r) goto quit;
            r = ini_rw(dic, "ntp:time",    pntp->time,       sizeof(pntp->time),       TYPE_STR, op); if(r) goto quit;
            r = ini_dump(path, dic);
        }
        break;

        default:
        return -1;
    }

quit:
    iniparser_freedict(dic);
    return r;
}
static int proc_snmp(char *path, int op, SNMPManager *snmp)
{
    int r=0,len=0;
    char temp[100];
    char *p,*token=NULL;
    dictionary *dic=NULL;
    SNMPManager snmp2,*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->public[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(sys_ip_check(psnmp->nmsIP)==IP_ERR) {
                    LOGE("___ check snmp, nms ip is invalid\n");
                    r = -1;
                }

                if(psnmp->version<0 || psnmp->version>2) {
                    LOGE("___ check snmp, version %d is wrong, correct value is 0/1/2\n");
                    r = -1;
                }

                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;
                    }
                }
            }
            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+1);
            fprintf(fp, "public      = \"%s\"\n", snmp->public);
            fprintf(fp, "trapmode    = \"%d\"\n", snmp->trapmode);
            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->nmsIP);
            fprintf(fp, "\n");

            fclose(fp);
            return 0;
        }
        break;

        case PARAS_READ:
        {
            char ver[32];

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

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

            if(psnmp->version==2) {
                r = ini_rw(dic, "snmp:crypt.user",          psnmp->crypt.user,        sizeof(psnmp->crypt.user),        TYPE_STR, op); if(r) goto quit;
                r = ini_rw(dic, "snmp:crypt.auth.proto",    psnmp->crypt.auth.alg,    sizeof(psnmp->crypt.auth.alg),    TYPE_STR, op); if(r) goto quit;
                r = ini_rw(dic, "snmp:crypt.auth.password", psnmp->crypt.auth.passwd, sizeof(psnmp->crypt.auth.passwd), TYPE_STR, op); if(r) goto quit;

                r = ini_rw(dic, "snmp:crypt.priv.proto",    psnmp->crypt.priv.alg,    sizeof(psnmp->crypt.priv.alg),    TYPE_STR, op); 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); if(r) goto quit;
            }

            r = proc_snmp(path, PARAS_CHECK, psnmp);
            if(r==0) {
                //r = dev_clear_table(dm->db, TAB_ID_SNMP);  if(r) goto quit;
                r = dev_update_snmp_info(dm->db, 0, psnmp);
            }
        }
        break;

        case PARAS_WRITE:
        {
            char ver[32];

            psnmp = &snmp2;
            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); if(r) goto quit;
            r = ini_rw(dic, "snmp:public",   psnmp->public,    sizeof(psnmp->public),  TYPE_STR, op); 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",  ver,  sizeof(ver), TYPE_STR, op); if(r) goto quit;

            if(psnmp->version==2) {
                r = ini_rw(dic, "snmp:crypt.user",          psnmp->crypt.user,        sizeof(psnmp->crypt.user),        TYPE_STR, op); if(r) goto quit;
                r = ini_rw(dic, "snmp:crypt.auth.proto",    psnmp->crypt.auth.alg,    sizeof(psnmp->crypt.auth.alg),    TYPE_STR, op); if(r) goto quit;
                r = ini_rw(dic, "snmp:crypt.auth.password", psnmp->crypt.auth.passwd, sizeof(psnmp->crypt.auth.passwd), TYPE_STR, op); 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); if(r) goto quit;
                r = ini_rw(dic, "snmp:crypt.priv.password", psnmp->crypt.priv.passwd, sizeof(psnmp->crypt.priv.passwd), TYPE_STR, op); if(r) goto quit;
            }
            r = ini_dump(path, dic);
        }
        break;

        default:
        return -1;
    }

quit:
    iniparser_freedict(dic);
    return r;
}
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.clientID  = \"%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];
                
                sprintf(token, "mqtt:broker%d.plat", i+1);
                r = ini_rw(dic, token, &ser->plat, sizeof(ser->plat), TYPE_INT, op); if(r) goto quit;

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

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

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

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

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

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

                j++;
            }
            if(r) {
                memset(ser, 0, sizeof(mqtt_server_t));
                ser->id = -1;
            }

            r = proc_mqtt(path, PARAS_CHECK, pmqtt);
            if(r==0) {
                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:
        {
            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->mode) {
                    sprintf(token, "mqtt:broker%d.plat", i+1);
                    r = ini_rw(dic, token, &ser->plat, sizeof(ser->plat), TYPE_INT, op); if(r) goto quit;

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

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

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

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

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

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

                    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); if(r) goto quit;
                }
            }
            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->idx != i) {
                            LOGE("___ check mail, recv[%d].idx %d mismatch it's index\n", i,recv->idx);
                            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));
            r = ini_rw(dic, "mail:send.mode",     &send->mode,    sizeof(send->mode),     TYPE_INT, op); if(r) goto quit;
            r = ini_rw(dic, "mail:send.server",   send->server,   sizeof(send->server),   TYPE_STR, op); if(r) goto quit;
            r = ini_rw(dic, "mail:send.port",     send->port,     sizeof(send->port),     TYPE_STR, op); if(r) goto quit;
            r = ini_rw(dic, "mail:send.auth",     send->auth,     sizeof(send->auth),     TYPE_STR, op); if(r) goto quit;
            r = ini_rw(dic, "mail:send.ca",       send->ca,       sizeof(send->ca),       TYPE_STR, op); if(r) goto quit;
            r = ini_rw(dic, "mail:send.account",  send->account,  sizeof(send->account),  TYPE_STR, op); if(r) goto quit;
            r = ini_rw(dic, "mail:send.password", send->password, sizeof(send->password), TYPE_STR, op); if(r) goto quit;

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

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

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

            r = proc_mail(path, PARAS_CHECK, pmail);  if(r) goto quit;
            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:
        {
            pmail = &mail2;
            send = &pmail->send;
            
            r = dev_mail_get(dm->db, pmail); if(r) return -1;
            r = proc_mail(path, PARAS_CHECK, 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); if(r) goto quit;
            r = ini_rw(dic, "mail:send.server",   send->server,   sizeof(send->server),   TYPE_STR, op); if(r) goto quit;
            r = ini_rw(dic, "mail:send.port",     send->port,     sizeof(send->port),     TYPE_STR, op); if(r) goto quit;
            r = ini_rw(dic, "mail:send.auth",     send->auth,     sizeof(send->auth),     TYPE_STR, op); if(r) goto quit;
            r = ini_rw(dic, "mail:send.ca",       send->ca,       sizeof(send->ca),       TYPE_STR, op); if(r) goto quit;
            r = ini_rw(dic, "mail:send.account",  send->account,  sizeof(send->account),  TYPE_STR, op); if(r) goto quit;
            r = ini_rw(dic, "mail:send.password", send->password, sizeof(send->password), TYPE_STR, op); if(r) goto quit;

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

                recv->idx = i;
                if(recv->use) {
                    sprintf(token, "mail:recv%d.use", i+1);
                    r = ini_rw(dic, token, &recv->use, sizeof(recv->use), TYPE_INT, op); if(r) goto quit;

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

        default:
        return -1;
    }

quit:
    iniparser_freedict(dic);
    return r;
}
static int proc_role(char *path, int op, RoleInfo *role, handle_t l)
{
    int i=1,r=0;
    char temp[100];
    char *p,token[100];
    dictionary *dic=NULL;
    RoleInfo role2,*prole=role;
    GlobalDeviceManager *dm=get_dm();

    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) {
                    sprintf(token, "role:role%d.name", i);
                    r = ini_rw(dic, token, prole->roleName, sizeof(prole->roleName), TYPE_STR, op);    if(r) break;

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

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

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

                    sprintf(token, "role:role%d.time", i);
                    r = ini_rw(dic, token, prole->createTime, sizeof(prole->createTime), TYPE_STR, op); 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:
        {
            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);    if(r) break;

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

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

                sprintf(token, "role:role%d.sort", i);
                r = ini_rw(dic, token, &tmp->roleSort, sizeof(tmp->roleAuthority), TYPE_INT, op); 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); if(r) break;
                i++;
            }

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

            if(r==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);
    RoleInfo *info=(RoleInfo*)xd->buf;

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

    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->roleID>3) {
            //    LOGE("___ check user, roleID is invalid, correct value is 1/2/3\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) {
                    sprintf(token, "role:role%d.name", i);
                    r = ini_rw(dic, token, puser->userName, sizeof(puser->userName), TYPE_STR, op); if(r) break;

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

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

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

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

                    if(chk_ok==0) {
                        r = proc_user(path, PARAS_CHECK, puser, NULL); if(r) break;
                        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:
        {
            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, "role:role%d.name", i);
                r = ini_rw(dic, token, tmp->userName, sizeof(tmp->userName), TYPE_STR, op); if(r) break;

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

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

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

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

                i++;
            }

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

            if(r==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;
    GlobalDeviceManager *dm=get_dm();

    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); if(r) break;

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

                    sprintf(token, "group:group%d.ch_list", i);
                    r = ini_rw(dic, token, pgroup->GroupChList, sizeof(pgroup->GroupChList), TYPE_STR, op); 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:
        {
            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);   if(r) break;

                sprintf(token, "group:group%d.name", i);
                r = ini_rw(dic, token, tmp->GroupName, sizeof(tmp->GroupName), TYPE_STR, op); 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); if(r) break;
                i++;
            }

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

            if(r==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_TEMPERATURE,        .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_DOOR,               .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_Conditioner,    .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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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:
        {
            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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); if(r) break;
                            }
                        }
                        if(r) break;
                    }
                    if(r) break;
                }
                if(r) break;

                i++;
            }

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

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

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

    return r;
}
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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); if(r) break; 
                    
                    if(chk_ok==0) {
                        r = proc_power(path, PARAS_CHECK, tmp); if(r) break;
                        cnt_ok++;
                    }
                    else {
                        r = dev_update_power_manage_genera_info(dm->db, 0, i, tmp);  if(r) break;
                        r = dev_update_power_manage_over_info(dm->db, 0, i, tmp);    if(r) break;
                    }
                }

                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:
        {
            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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); if(r) break;
            }

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

            if(r==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;

            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; i++) {
                    sprintf(token, "power:channel%d.addr",i);
                    r = ini_rw(dic, token, &tmp->product_saddr, sizeof(tmp->product_saddr), TYPE_INT, op); if(r) break;

                    int channelID = i;
                    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); 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); 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); 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); 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); if(r) break;

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

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

                    sprintf(token, "power:channel%d.threshold.voltate.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); if(r) break;

                    sprintf(token, "power:channel%d.threshold.voltate.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); if(r) break;

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

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

                    sprintf(token, "power:channel%d.threshold.voltate.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); if(r) break;

                    sprintf(token, "power:channel%d.threshold.voltate.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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); if(r) break;
                    
                    if(chk_ok==0) {
                        r = proc_power3(path, PARAS_CHECK, tmp); if(r) break;
                        cnt_ok++;
                    }
                    else {
                        r = dev_update_t_ac_power_manage_info(dm->db, tmp);      if(r) break;
                        r = dev_update_t_ac_power_manage_over_info(dm->db, tmp); if(r) break;
                    }
                }

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

        case PARAS_WRITE:
        {
            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;

                int 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); 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); 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); 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); 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); 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); if(r) break;

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

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

                sprintf(token, "power:channel%d.threshold.voltate.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); if(r) break;

                sprintf(token, "power:channel%d.threshold.voltate.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); if(r) break;

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

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

                sprintf(token, "power:channel%d.threshold.voltate.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); if(r) break;

                sprintf(token, "power:channel%d.threshold.voltate.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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); if(r) break;
            }

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

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

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

    return r;
}

#if 0
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, GlobalDeviceInfo *info)
{
    int r=-1;
    
    dictionary *dic=iniparser_load(path);
    if(dic == NULL){
        return NULL;
    }
    
    r = proc_prod(dic, PARAS_READ, &info->product);
    if(r) {
        LOGE("___ini_r_dev failed\n");
        iniparser_freedict(dic);
        return NULL;
    }

    r = proc_modbus(dic, PARAS_READ, &info->cascade);
    if(r) {
        LOGE("___ini_r_modbus failed\n");
        iniparser_freedict(dic);
        return NULL;
    }

    r = proc_ptotal(dic, PARAS_READ, &info->ptotal);
    if(r) {
        LOGE("___ini_r_modbus failed\n");
        iniparser_freedict(dic);
        return NULL;
    }

    return dic;
}
static int ini_check(char *path)
{
    GlobalDeviceInfo info=DFLT_PARAS;
    dictionary *dic=ini_load(path, &info);

    if(!dic) {
        return -1;
    }
    iniparser_freedict(dic);

    return 0;
}
static int ini_reset(paras_handle_t *h)
{
    int r;
    FILE *fp=NULL;
    char tmp[200];
    GlobalDeviceInfo *info=&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", info->product.id);
    fprintf(fp, "number      = \"%s\"\n", info->product.number);
    fprintf(fp, "name        = \"%s\"\n", info->product.name);
    fprintf(fp, "type        = \"%d\"\n", info->product.type);
    fprintf(fp, "pwrtype     = \"%d\"\n", info->product.pwr_type);
    //fprintf(fp, "version     = %s\\"n", info->product.version);
    fprintf(fp, "language    = \"%d\"\n", info->product.language);
    fprintf(fp, "samptime    = \"%d\"\n", info->product.samp_time);
    fprintf(fp, "savetime    = \"%d\"\n", info->product.save_time);
    fprintf(fp, "ph_group    = \"%d\"\n", info->product.ph_group);
    fprintf(fp, "ch_delay    = \"%d\"\n", info->product.ch_delay);
    fprintf(fp, "\n");

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

    fprintf(fp, "[ptotal]\n");
    fprintf(fp, "voltage     = \"%d\"\n", info->ptotal.voltage);
    fprintf(fp, "current     = \"%d\"\n", info->ptotal.current);
    fprintf(fp, "power       = \"%d\"\n", info->ptotal.power);
    fprintf(fp, "brd_max     = \"%d\"\n", info->ptotal.brdMax);
    fprintf(fp, "\n");

    fclose(fp);

    sys_get_path(tmp, INI_FILE_BAK_NAME);
    file_copy(tmp, h->path);

    if(h->dic) {
        iniparser_freedict(h->dic);
    }
    h->dic = ini_load(h->path, h->info);

    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->info->product);
    if(r) {
        LOGE("___ini_w_dev failed\n");
        return -1;
    }

    r = proc_modbus(h->dic, PARAS_WRITE, &h->info->cascade);
    if(r) {
        LOGE("___ini_w_modbus 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;
    paras_handle_t  *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    memset(&paraHandle, 0, sizeof(paraHandle));
    h->info = get_info();
    sys_get_path(h->path, INI_FILE_NAME);
    h->dic = ini_load(h->path, h->info);
    if(h->dic==NULL) {
        r = ini_reset(h);
    }
    lock_s_release(LOCK_ID_PARAS);
    
    return r;
}


int paras_deinit(void)
{
    int r=0;
    paras_handle_t *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    r = ini_free(h);
    lock_s_release(LOCK_ID_PARAS);
    
    return 0;
}


int paras_check(char *path)
{
    int r=0;
    
    lock_s_hold(LOCK_ID_PARAS);
    r = ini_check(path);
    lock_s_release(LOCK_ID_PARAS);
    
    return r;
}


int paras_load(char *path)
{
    int r=-1;
    paras_handle_t *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    ini_free(h);
    h->dic = ini_load(path, h->info);
    if(h->dic) r = 0;
    lock_s_release(LOCK_ID_PARAS);
    
    return r;
}


int paras_reset(void)
{
    int r=0;
    paras_handle_t *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    ini_reset(h);
    lock_s_release(LOCK_ID_PARAS);
    
    return r;
}


int paras_copy(char *dst, char *src)
{
    int r=-1;

    lock_s_hold(LOCK_ID_PARAS);
    r = file_copy(dst, src);
    lock_s_release(LOCK_ID_PARAS);

    return r;
}


int paras_save(void)
{
    int r=0;
    paras_handle_t *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    r = ini_save(h);
    lock_s_release(LOCK_ID_PARAS);
    
    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 = 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;
}