SmartPDCode/pro/src/paras.c

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


#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 {
    PARA_CHECK=0,
    PARA_READ,
    PARA_WRITE,
};

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 int proc_prod(dictionary *dic, int op, ProductInfo_t *prod)
{
    int r=0;
    char *p=NULL;
    char temp[100];
    char *token=NULL;

    if(op==PARA_CHECK) {
        if(prod->language>=4) {
            LOGE("___ product.language %d is wrong\n", prod->language);
            r = -1;
        }
        if(prod->type>=2) {
            LOGE("___ product.type %d is wrong\n", prod->type);
            r = -1;
        }
        if(prod->pwr_type>SmartPDU_Tree_AC_One_B) {
            LOGE("___ product.pwr_type %d is wrong\n", prod->pwr_type);
            r = -1;
        }
        return r;
    }
    else if(op==PARA_WRITE) {
        r = proc_prod(dic, PARA_CHECK, prod);
        if(r) {
            return -1;
        }
    }

    token = "product:id";
    if(op==PARA_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        prod->count = 0;
        prod->status[0] = 0;
        r = proc_prod(dic, PARA_CHECK, prod);
        if(r) {
            return -1;
        }
    }
    
    return 0;
}
static int proc_modbus(dictionary *dic, int op, ModbusInfo_t *mb)
{
    int r=0;
    char temp[100];
    char *p,*token=NULL;

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

        if(mb->mode==1 && (mb->addr==0 || mb->addr>CASCADE_MAX)) {    //slave
            LOGE("___ set modbus, slave addr %d is invalid\n", mb->addr);
            r = -1;
        }

        return r;
    }
    else if (op==PARA_WRITE) {
        r = proc_modbus(dic, PARA_CHECK, mb);
        if(r) {
            return -1;
        }
    }

    token = "modbus:mode";
    if(op==PARA_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        r = proc_modbus(dic, PARA_CHECK, mb);
        if(r) {
            return -1;
        }
    }

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

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

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

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

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

    token = "ptotal:voltage";
    if(op==PARA_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;
        }
    }

    token = "ptotal:current";
    if(op==PARA_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        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==PARA_READ) {
        r = proc_ptotal(dic, PARA_CHECK, ptotal);
        if(r) {
            return -1;
        }
    }

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

    if(op==PARA_CHECK) {
        if(ntp->mode<0 || ntp->mode>1) {
            LOGE("___ set ntp, mode is wrong, correct value is 0/1\n");
            r = -1;
        }

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

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

        if(ntp->tzone>12 || ntp->tzone<-12) {
            LOGE("___ set ntp, tzong is wrong, correct range is -12~12\n");
            r = -1;
        }
        return r;
    }
    else if (op==PARA_WRITE) {
        r = proc_ntp(dic, PARA_CHECK, ntp);
        if(r) {
            return -1;
        }
    }

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

    token = "ntp:name";
    if(op==PARA_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        strcpy(ntp->ntpName, p);
    }
    else {
        r = iniparser_set(dic, token, ntp->ntpName);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "ntp:address";
    if(op==PARA_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        strcpy(ntp->ntpaddress, p);
    }
    else {
        r = iniparser_set(dic, token, ntp->ntpaddress);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

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

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

    if(op==PARA_READ) {
        ntp->time[0] = 0;
        ntp->weekday = 0;
        ntp->product_id = 0;

        r = proc_ntp(dic, PARA_CHECK, ntp);
        if(r) {
            return -1;
        }
    }

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

    if(op==PARA_CHECK) {
        if(snmp->mode<0 || snmp->mode>1) {
            LOGE("___ set snmp, mode %d is wrong, correct value is 0/1\n", snmp->mode);
            r = -1; 
        }

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

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

        if(sys_ip_check(snmp->nmsIP)==IP_ERR) {
            LOGE("___ set snmp, nms ip is invalid\n");
            r = -1;
        }

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

        if(snmp->version==2) {

            if(snmp->crypt.user[0]==0 || strlen(snmp->crypt.user)<8 || strlen(snmp->crypt.user)>32) {
                if(snmp->crypt.auth.alg[0]==0) {
                    LOGE("___ set snmp, crypt user is null\n");
                }
                else {
                    LOGE("___ set snmp, crypt user length is wrong, correct range is 8~32 characters(english)\n");
                }
                r = -1;
            }

            if(snmp->crypt.auth.alg[0]==0 || strcmp(snmp->crypt.auth.alg, "MD5") ||
                                            strcmp(snmp->crypt.auth.alg, "SHA") ||
                                            strcmp(snmp->crypt.auth.alg, "SHA-224") ||
                                            strcmp(snmp->crypt.auth.alg, "SHA-256") ||
                                            strcmp(snmp->crypt.auth.alg, "SHA-384") ||
                                            strcmp(snmp->crypt.auth.alg, "SHA-512")) {
                if(snmp->crypt.auth.alg[0]==0) {
                    LOGE("___ set snmp, crypt auth algorithm is null\n");
                }
                else {
                    LOGE("___ set snmp, crypt auth algorithm %s is wrong, correct value is: MD5/SHA/SHA-224/SHA-256/SHA-384/SHA-512\n");
                }
                r = -1;
            }
            if(snmp->crypt.auth.passwd[0]==0 || strlen(snmp->crypt.auth.passwd)<8 || strlen(snmp->crypt.auth.passwd)>32) {
                if(snmp->crypt.auth.passwd[0]==0) {
                    LOGE("___ set snmp, crypt auth password is null\n");
                }
                else {
                    LOGE("___ set snmp, crypt auth password length is wrong, correct range is 8~32 characters(english)\n");
                }
                r = -1;
            }

            if(snmp->crypt.priv.alg[0]==0 || strcmp(snmp->crypt.priv.alg, "NO")  ||
                                            strcmp(snmp->crypt.priv.alg, "DES") ||
                                            strcmp(snmp->crypt.priv.alg, "AES")) {
                if(snmp->crypt.priv.alg[0]==0) {
                    LOGE("___ set snmp, crypt priv algorithm is null\n");
                }
                else {
                    LOGE("___ set snmp, crypt priv algorithm %s is wrong, correct value is: NO/DES/AES\n");
                }
                r = -1;
            }
            if(snmp->crypt.priv.passwd[0]==0 || strlen(snmp->crypt.priv.passwd)<8 || strlen(snmp->crypt.priv.passwd)>32) {
                if(snmp->crypt.priv.passwd[0]==0) {
                    LOGE("___ set snmp, crypt priv password is null\n");
                }
                else {
                    LOGE("___ set snmp, crypt priv password length is wrong, correct range is 8~32 characters(english)\n");
                }
                r = -1;
            }
        }
        return r;
    }
    else if (op==PARA_WRITE) {
        r = proc_snmp(dic, PARA_CHECK, snmp);
        if(r) {
            return -1;
        }
    }

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

    token = "snmp:public";
    if(op==PARA_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        strcpy(snmp->public, p);
    }
    else {
        r = iniparser_set(dic, token, snmp->public);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "snmp:version";
    if(op==PARA_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        snmp->version = r-1;
    }
    else {
        sprintf(temp, "%d", snmp->version+1);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    if(snmp->version==2) {
        token = "snmp:crypt_user";
        if(op==PARA_READ) {
            p = (char*)iniparser_getstring(dic, token, NULL);
            if(!p) {
                LOGE("___ iniparser_getstring %s failed\n", token);
                return -1; 
            }
            strcpy(snmp->crypt.user, p);
        }
        else {
            r = iniparser_set(dic, token, snmp->crypt.user);
            if(r) {
                LOGE("___ iniparser_set %s failed\n", token);
                return -1;
            }
        }

        token = "snmp:crypt_auth_alg";
        if(op==PARA_READ) {
            p = (char*)iniparser_getstring(dic, token, NULL);
            if(!p) {
                LOGE("___ iniparser_getstring %s failed\n", token);
                return -1; 
            }
            strcpy(snmp->crypt.auth.alg, p);
        }
        else {
            r = iniparser_set(dic, token, snmp->crypt.auth.alg);
            if(r) {
                LOGE("___ iniparser_set %s failed\n", token);
                return -1;
            }
        }

        token = "snmp:crypt_auth_pwd";
        if(op==PARA_READ) {
            p = (char*)iniparser_getstring(dic, token, NULL);
            if(!p) {
                LOGE("___ iniparser_getstring %s failed\n", token);
                return -1; 
            }
            strcpy(snmp->crypt.auth.passwd, p);
        }
        else {
            r = iniparser_set(dic, token, snmp->crypt.auth.passwd);
            if(r) {
                LOGE("___ iniparser_set %s failed\n", token);
                return -1;
            }
        }

        token = "snmp:crypt_priv_alg";
        if(op==PARA_READ) {
            p = (char*)iniparser_getstring(dic, token, NULL);
            if(!p) {
                LOGE("___ iniparser_getstring %s failed\n", token);
                return -1; 
            }
            strcpy(snmp->crypt.priv.alg, p);
        }
        else {
            r = iniparser_set(dic, token, snmp->crypt.priv.alg);
            if(r) {
                LOGE("___ iniparser_set %s failed\n", token);
                return -1;
            }
        }

        token = "snmp:crypt_priv_pwd";
        if(op==PARA_READ) {
            p = (char*)iniparser_getstring(dic, token, NULL);
            if(!p) {
                LOGE("___ iniparser_getstring %s failed\n", token);
                return -1; 
            }
            strcpy(snmp->crypt.priv.passwd, p);
        }
        else {
            r = iniparser_set(dic, token, snmp->crypt.priv.passwd);
            if(r) {
                LOGE("___ iniparser_set %s failed\n", token);
                return -1;
            }
        }
    }

    if(op==PARA_READ) {
        r = proc_snmp(dic, PARA_CHECK, snmp);
        if(r) {
            return -1;
        }
    }

    return 0;
}
static int proc_mqtt(dictionary *dic, int op, mqtt_info_t *info)
{
    int r=-1;
    char temp[100];
    char *p,*token=NULL;


    return 0;
}
static int proc_mail(dictionary *dic, int op, mail_info_t *info)
{
    int r=-1;
    char temp[100];
    char *p,*token=NULL;

    return 0;
}
static int proc_role(dictionary *dic, int op, RoleInfo *info)
{
    int r=-1;
    char temp[100];
    char *p,*token=NULL;

    return 0;
}
static int proc_group(dictionary *dic, int op, GroupInfo *info)
{
    int r=-1;
    char temp[100];
    char *p,*token=NULL;

    return 0;
}
static int proc_sensor(dictionary *dic, int op, NTPManager *ntp)
{

    return 0;
}
static int proc_power(dictionary *dic, int op, NTPManager *ntp)
{
    int r=-1;
    char temp[100];
    char *p,*token=NULL;

    return 0;
}
static int proc_power3(dictionary *dic, int op, NTPManager *ntp)
{
    int r=-1;
    char temp[100];
    char *p,*token=NULL;

    return 0;
}
static int proc_breaker(dictionary *dic, int op, NTPManager *ntp)
{
    int r=-1;
    char temp[100];
    char *p,*token=NULL;

    return 0;
}
static int proc_alarm(dictionary *dic, int op, NTPManager *ntp)
{
    int r=-1;
    char temp[100];
    char *p,*token=NULL;

    return 0;
}
static int proc_timer(dictionary *dic, int op, NTPManager *ntp)
{
    int r=-1;
    char temp[100];
    char *p,*token=NULL;

    return 0;
}

/////////////////////////////////////////////////////////////////////////////////


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, PARA_READ, &info->product);
    if(r) {
        LOGE("___ini_r_dev failed\n");
        iniparser_freedict(dic);
        return NULL;
    }

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

    r = proc_ptotal(dic, PARA_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, PARA_WRITE, &h->info->product);
    if(r) {
        LOGE("___ini_w_dev failed\n");
        return -1;
    }

    r = proc_modbus(h->dic, PARA_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

static GlobalDeviceInfo *get_info(void)
{
    return &__globalDeviceManage._globalDevInfo;
}
////////////////////////////////////////////////////////////


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