microser/cfg_parse/cfg_parser.cpp

using namespace std;

#include <QFile>
#include <QXmlStreamWriter>
#include <QtXml/QDomDocument>
#include <QtXml/QDomElement>
#include <QtXml/QDomNode>
#include <QtXml/QDomNodeList>
#include <QtCore/qglobal.h>
#include <QStringList>
#include <QSettings>
#include <QDateTime>
#include <QDir>
#include <QFileInfo>
#include <QDebug>
#include <QMutex>
#include <QMap>
#include <ctime>
#define OTL_ODBC_ODBC
#define OTL_ODBC_UNIX
#include <unistd.h>

#include "otlv4.h"
#include <stdio.h>

#include <sstream> //lnk 2024-10-16
#include <set>	//дȥ<D0B4>ص<EFBFBD><D8B5>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD>
#include <fstream>//<2F>ϴ<EFBFBD><CFB4>ļ<EFBFBD>

#include "../mms/db_interface.h"
#include "../json/save2json.h"
#include "../json/mms_json_inter.h"

#include "../mms/rdb_client.h"
#include "../mms/interface.h"
#include "../json/cjson.h"//WW 2023-08-27<32><37><EFBFBD><EFBFBD>json<6F><6E><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#include "../include/curl/curl.h" 

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

	extern pt61850app_t* 	g_pt61850app;
	extern node_t* 			g_node;
	extern apr_pool_t* 		g_cfg_pool;
	extern apr_pool_t* 		g_init_pool;
	extern apr_pool_t* 		g_temp_dev_pool;
	extern char				subdir[128];
	extern int 				g_front_seg_index;

	extern unsigned int		g_no_auth;
	extern char				g_onlyIP[255];			//ֱ<><D6B1>ij<EFBFBD><C4B3>IP<49><50><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

	int						g_DevFlag = 0;

#ifdef __cplusplus
}
#endif
///////////////////////////////lnk20250118̨<38>˱<EFBFBD><CBB1><EFBFBD>ʹ<EFBFBD>õ<EFBFBD><C3B5>ڴ<EFBFBD><DAB4>أ<EFBFBD><D8A3><EFBFBD>̬<EFBFBD>ڴ<EFBFBD><DAB4>صķ<D8B5>ʽ<EFBFBD><CABD>ÿ<EFBFBD><C3BF><EFBFBD>ڴ<EFBFBD><DAB4>ط<EFBFBD>һ<EFBFBD><D2BB>ied<65><64><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݣ<EFBFBD><DDA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݲ<EFBFBD>ʹ<EFBFBD>ã<EFBFBD>ֻ<EFBFBD><D6BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʵ<EFBFBD>ֺ<EFBFBD><D6BA><EFBFBD>
// <20><><EFBFBD>ڴ洢<DAB4>ն<EFBFBD> ID <20>Ͷ<EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD>ӳ<EFBFBD>
std::list<std::pair<std::string, apr_pool_t*> > pool_list;
///////////////////////////////////////////////////

//ZW 2023-10-10 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>нṹ
class RecallInfo
{
public:
	long long starttime;
	long long endtime;
};

//CZY 2023-09-17 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
class ProgramParam
{
public:
	QList<QString> terminal_list;//<2F>ն<EFBFBD>id<69>б<EFBFBD>
	QString file_name;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>װ<EFBFBD><D7B0><EFBFBD>ã<EFBFBD><C3A3><EFBFBD>װ<EFBFBD><D7B0><EFBFBD><EFBFBD><EFBFBD><EFBFBD>oss<73>е<EFBFBD>λ<EFBFBD><CEBB>
};

//CZY 2023-09-17 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
class RecallParam
{
public:
	QString mp_id;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>id
	QString start;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼʱ<CABC><CAB1>
	QString end;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݽ<EFBFBD><DDBD><EFBFBD>ʱ<EFBFBD><CAB1>
	int voltage;//<2F><>̬<EFBFBD><CCAC><EFBFBD>ݱ<EFBFBD>־
	int stat;//<2F><>̬<EFBFBD><CCAC><EFBFBD>ݱ<EFBFBD>־
};

//CZY 2023-10-12 װ<><D7B0>ʶ<EFBFBD><CAB6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Կ
class terminal_ext //
{
public:
	char terminal_identify_code[100];//<2F>ն<EFBFBD>ʶ<EFBFBD><CAB6><EFBFBD><EFBFBD>
	char terminal_key[100];//<2F>ն<EFBFBD><D5B6><EFBFBD>Կ
};

class CJournalRecall //<2F><>־<EFBFBD><D6BE><EFBFBD>нṹ<D0BD><E1B9B9>
{
public:
	QString MonitorID; //<2F><>·<EFBFBD><C2B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	QString StartTime; //<2F><><EFBFBD>ݲ<EFBFBD><DDB2><EFBFBD><EFBFBD><EFBFBD>ʼʱ<CABC><CAB1>
	QString EndTime;   //<2F><><EFBFBD>ݲ<EFBFBD><DDB2>н<EFBFBD><D0BD><EFBFBD>ʱ<EFBFBD><CAB1>
	QString STEADY;    //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʷͳ<CAB7><CDB3><EFBFBD><EFBFBD><EFBFBD>ݱ<EFBFBD>ʶ 0-<2D><><EFBFBD><EFBFBD><EFBFBD>У<EFBFBD>1-<2D><><EFBFBD><EFBFBD>     
	QString VOLTAGE;   //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̬<EFBFBD>¼<EFBFBD><C2BC><EFBFBD>ʶ 0-<2D><><EFBFBD><EFBFBD><EFBFBD>У<EFBFBD>1-<2D><><EFBFBD><EFBFBD>
};

/*lnk 2024-10-15 */
class ledger_monitor //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̨<EFBFBD><CCA8>
{
public:
	char monitor_id[64];
    char terminal_code[64];
    char monitor_name[64];
    char logical_device_seq[64];
    char voltage_level[64];
    char terminal_connect[64];
    char timestamp[64];
	char status[255];
	char count_cfg[64];	//<2F><><EFBFBD><EFBFBD>̨<EFBFBD>˵<EFBFBD>һ<EFBFBD><D2BB><EFBFBD>֣<EFBFBD><D6A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>¼<EFBFBD><C2BC><EFBFBD>ݿ<EFBFBD><DDBF><EFBFBD>ҵ<EFBFBD><D2B5><EFBFBD><EFBFBD>̨<EFBFBD><CCA8>̨<EFBFBD><CCA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
};

class terminal_dev //<2F>ն<EFBFBD>̨<EFBFBD><CCA8>
{
public:
	char terminal_id[64];
    char terminal_code[64];
    char org_name[64];
    char maint_name[64];
    char station_name[64];
    char tmnl_factory[64];
    char tmnl_status[64];
    char dev_type[64];
    char dev_key[255];
    char dev_series[255];
    char addr_str[64];
    char port[64];
    char timestamp[64];

	//lnk20250210<31><30><EFBFBD>ӽ<EFBFBD><D3BD>̺<EFBFBD>
	char processNo[64];

    ledger_monitor line[10];

	char count_cfg[64];	//<2F><><EFBFBD><EFBFBD>̨<EFBFBD>˵<EFBFBD>һ<EFBFBD><D2BB><EFBFBD>֣<EFBFBD><D6A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>¼<EFBFBD><C2BC><EFBFBD>ݿ<EFBFBD><DDBF><EFBFBD>ҵ<EFBFBD><D2B5><EFBFBD><EFBFBD>̨<EFBFBD><CCA8>̨<EFBFBD><CCA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
};

class icd_model //icdģ<64><C4A3>
{
public:
	char model_id[64];
    char tmnl_type[64];
	char tmnl_type_id[64];	//<2F><>ʹ<EFBFBD><CAB9>
    char tmnl_factory[64];	//<2F><>ʹ<EFBFBD><CAB9>
    char file_name[128];
	char file_path[128];
    char timestamp[64];
};

/*lnk 2024-10-15 */

list<CJournalRecall> g_StatisticLackList; //<2F><>־<EFBFBD><D6BE><EFBFBD>нṹ<D0BD><E1B9B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

QMutex g_StatisticLackList_list_mutex; //recall<6C><6C><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

QString DEVIE_CONFIG_FN = QString("Device_Config.xml");//<2F><><EFBFBD><EFBFBD>
QString LINE_CONFIG_FN = QString("Line_Config.xml");//<2F><><EFBFBD><EFBFBD>
QString JSON_CONFIG_FN_old = QString("JiangSu_Config.xml");//Ĭ<><C4AC>ӳ<EFBFBD><D3B3><EFBFBD>ļ<EFBFBD>
QString THREE_SECS_CONFIG_FN = QString("Trigger3S.xml");//ʵʱ<CAB5><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
QString RECALL_CONFIG_FN = QString("Recall.xml");//<2F><><EFBFBD><EFBFBD>

//lnk20241220<32><30><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̨<EFBFBD>˸<EFBFBD><CBB8>µ<EFBFBD><C2B5>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>֤<EFBFBD><D6A4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>¸<EFBFBD><C2B8><EFBFBD>̨<EFBFBD><CCA8>
std::string LEDGER_UPDATE_FN = "LedgerUpdate.log";

const int MAX_CPUNO = 10;

//lnk20250121<32>ն<EFBFBD>̨<EFBFBD><CCA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int IED_COUNT = 300;	//Ĭ<><C4AC>300

extern int INITFLAG;

//lnk2024-8-14<31><34><EFBFBD>ӽ<EFBFBD><D3BD>ͽ<EFBFBD><CDBD>߱<EFBFBD>־,0<><30><EFBFBD><EFBFBD><EFBFBD>ڽ<EFBFBD><DABD>ν<EFBFBD><CEBD>ߣ<EFBFBD>1<EFBFBD><31><EFBFBD>ڽ<EFBFBD><DABD>ν<EFBFBD><CEBD><EFBFBD>
int isdelta_flag = 0;

//////CZY 2023-09-06 config
//<2F><>ǰ<EFBFBD><C7B0>flag:1Ϊ<31><CEAA><EFBFBD><EFBFBD>,0Ϊ<30>ر<EFBFBD>
int MULTIPLE_NODE_FLAG = 1;
extern const char* PROGRAM_VERSION;

extern int FRONT_MP_NUM;

int ACCOUNT_UPDATE_INTERVAL;
char* ACCOUNT_UPDATE_LAST_TIME;

int MULIT_NODE_INTERVAL;

int COMMUNICATION_LOG_STATUS_TIME;
int COMMUNICATION_LOG_ABNORMAL_TIME;

char* POSTGRES_DATABASE;//<2F><><EFBFBD>ݿ<EFBFBD><DDBF><EFBFBD><EFBFBD><EFBFBD>
char* POSTGRES_USERNAME;//<2F><><EFBFBD>ݿ<EFBFBD><DDBF>û<EFBFBD><C3BB><EFBFBD>
char* POSTGRES_PASSWORD;//<2F><><EFBFBD>ݿ<EFBFBD><DDBF><EFBFBD><EFBFBD><EFBFBD>
char* POSTGRES_SCHEMA;//<2F><><EFBFBD>ݿ<EFBFBD>ģʽ<C4A3><CABD>
char* POSTGRES_DNSNAME;//ȡpostgres/guass<73><73>
char* POSTGRES_TABLEPREFIX;//<2F><><EFBFBD><EFBFBD>ǰ׺

char* CLIENT_ID;//<2F><>̨CLIENT_ID
char* CLIENT_SECRET;//<2F><>̨CLIENT_SECRET
char* TOKEN_URL;//<2F><>̨ȡtoken<65>ӿ<EFBFBD>
char* DEVICE_URL;//<2F><>̨ȡ<CCA8>ն˽ӿ<CBBD>
char* GRANT_TYPE;//<2F><>̨GRANT_TYPE

char* UDS_UPLOAD_URL;
char* UDS_DOWNLOAD_URL;
char* UDS_DELETE_URL;

int  FILE_FLAG;
int  SEND_FLAG;
int FRONT_INST;
char* FRONT_IP;
int CITY_FLAG;

int recall_len;
int recall_sta;
int recall_daily;

char* BROKER_LIST;
char* TOPIC_STAT;
char* TOPIC_PST;
char* TOPIC_PLT;
char* TOPIC_EVENT;
char* TOPIC_ALARM;
char* TOPIC_SNG;

//lnk20241220
char* TOPIC_RTDATA;

char* PROTOCOL;
char* MECHANISMS;
char* KEYTAB_FILE;
char* SERVICE_NAME;
char* PRINCIPAL;
char* DOMAIN_NAME;

extern int     g_front_seg_index;
extern int     g_front_seg_num;

/*<2A><>ֲ<EFBFBD><D6B2><EFBFBD>ñ<EFBFBD><C3B1><EFBFBD>lnk10-9*/
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
std::string G_ROCKETMQ_PRODUCER = "";//rocketmq producer
std::string G_ROCKETMQ_IPPORT = "";//rocketmq ip+port
std::string G_ROCKETMQ_TOPIC = "";//topie
std::string G_ROCKETMQ_TAG = "";//tag
std::string G_ROCKETMQ_KEY = "";//key
int QUEUENUM = 0;
std::string BROKERNAME = "";
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
std::string G_ROCKETMQ_CONSUMER = "";//rocketmq consumer
std::string G_MQCONSUMER_IPPORT = "";//consumer ip+port
std::string G_MQCONSUMER_TOPIC_RT = "";//consumer topie
std::string G_MQCONSUMER_TAG_RT = "";//consumer tag
std::string G_MQCONSUMER_KEY_RT = "";//consumer key
std::string G_MQCONSUMER_ACCESSKEY = "";
std::string G_MQCONSUMER_SECRETKEY = "";
std::string G_MQCONSUMER_CHANNEL = "";
std::string G_MQCONSUMER_TOPIC_UD = "";//consumer topie
std::string G_MQCONSUMER_TAG_UD = "";//consumer tag
std::string G_MQCONSUMER_KEY_UD = "";//consumer key
std::string G_MQCONSUMER_TOPIC_RC = "";//consumer topie
std::string G_MQCONSUMER_TAG_RC = "";//consumer tag
std::string G_MQCONSUMER_KEY_RC = "";//consumer key
std::string G_MQCONSUMER_TOPIC_SET = "";//consumer topie
std::string G_MQCONSUMER_TAG_SET = "";//consumer tag
std::string G_MQCONSUMER_KEY_SET = "";//consumer key
std::string G_LOG_TOPIC = "";//topie
std::string G_LOG_TAG = "";//tag
std::string G_LOG_KEY = "";//key
std::string G_MQCONSUMER_TOPIC_LOG = "";//consumer topie
std::string G_MQCONSUMER_TAG_LOG = "";//consumer tag
std::string G_MQCONSUMER_KEY_LOG = "";//consumer key
std::string G_CONNECT_TOPIC = "";//consumer topie
std::string G_CONNECT_TAG = "";//consumer tag
std::string G_CONNECT_KEY = "";//consumer key

int G_TEST_FLAG = 0;
int G_TEST_NUM = 0;
int TEST_PORT = 11000;//<2F><><EFBFBD>ڵ<EFBFBD>ǰ<EFBFBD><C7B0><EFBFBD>̵<EFBFBD>¼<EFBFBD><C2BC><EFBFBD><EFBFBD>shell<6C>Ķ˿<C4B6>

std::string G_TEST_LIST = "";//<2F><><EFBFBD><EFBFBD><EFBFBD>õķ<C3B5><C4B7><EFBFBD>ʵ<EFBFBD><CAB5><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD><DDB5>ն<EFBFBD><D5B6>б<EFBFBD>
std::vector<std::string> TESTARRAY;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD><D0B1><EFBFBD><EFBFBD><EFBFBD>

//<2F>ն˺ͼ<CBBA><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>״̬ɸѡ
std::string TERMINAL_STATUS = "";
std::string MONITOR_STATUS = "";
std::string ICD_FLAG = "";

//<2F><><EFBFBD><EFBFBD>socket<65><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ÿ<EFBFBD><C3BF><EFBFBD>
int SOCKET_PORT = 13000;
int SOCKETENABLE = 0;

//<2F><><EFBFBD><EFBFBD>http<74><70><EFBFBD>ú<EFBFBD>̨<EFBFBD><CCA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>lnk20241031
int HTTPENABLE = 0;
std::string HTTP_IP = "";
int HTTP_PORT = 12000;

/*<2A><><EFBFBD><EFBFBD>web<65>ӿ<EFBFBD>lnk202411-6*/
std::string WEB_DEVICE = "";
std::string WEB_ICD = "";
std::string WEB_INTEGRITY = "";	//<2F>ݲ<EFBFBD>ʹ<EFBFBD><CAB9>
std::string WEB_COMFLAG = "";
std::string WEB_EVENT = "";
std::string WEB_FILEUPLOAD = "";
std::string WEB_FILEDOWNLOAD = "";

//lnk20250115<31><35><EFBFBD><EFBFBD>̨<EFBFBD><CCA8><EFBFBD><EFBFBD>
extern pthread_mutex_t mtx;

/*lnk 2024-10-21 */
std::string intToString(int number);
//////////////////////////////////////////////////////////////////////////

extern int server_socket; //Web Socket<65><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʵ<EFBFBD><CAB5>
extern unsigned int	g_node_id; //ǰ<>ó<EFBFBD><C3B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(100-500)
//WW 2023-08-20 end
////////////////////////////////////////////////////////////////////////////////////////////////////

void parse_log_switch_ini(unsigned int* error, unsigned int* warn, unsigned int* info)
{
	QString pt61850netd_pqfe_IniFilename = QString("../etc/pt61850netd_pqfe.ini");
	QSettings settings(pt61850netd_pqfe_IniFilename, QSettings::IniFormat);

	settings.beginGroup("Log");
	*error = settings.value("error", 0).toUInt();
	*warn = settings.value("warn", 0).toUInt();
	*info = settings.value("info", 0).toUInt();

	g_no_auth = settings.value("no_auth", 0).toUInt();

	g_DevFlag = settings.value("DevFlag", 0).toUInt();

	settings.endGroup();
}


//lnk20250328<32><38><EFBFBD>Ӳ<EFBFBD><D3B2><EFBFBD><EFBFBD>б<EFBFBD><D0B1>õĺ<C3B5><C4BA><EFBFBD>
void parseTestList(const std::string& input) {
    TESTARRAY.clear(); // <20><><EFBFBD>վ<EFBFBD><D5BE><EFBFBD><EFBFBD><EFBFBD>

    size_t start = 0;
    size_t end = 0;

    while ((end = input.find(',', start)) != std::string::npos) {
        std::string id = input.substr(start, end - start);
        if (!id.empty()) {
            TESTARRAY.push_back(id);
			std::cout << "use realdata device id:" << id << std::endl;
        }
        start = end + 1;
    }

    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB> ID<49><44><EFBFBD><EFBFBD><EFBFBD><EFBFBD>û<EFBFBD>ж<EFBFBD><D0B6>Ž<EFBFBD>β<EFBFBD><CEB2>
    if (start < input.length()) {
        std::string lastId = input.substr(start);
        if (!lastId.empty()) {
            TESTARRAY.push_back(lastId);
			std::cout << "use realdata device id:" << lastId << std::endl;
        }
    }
}

//CZY 2023-09-06 config
void init_config() {
	QByteArray ba;
	QString MyKafkaIniFilename = QString("../etc/config/") + QString("mykafka.ini"); //+QString::fromAscii(subdir)
	QSettings settings(MyKafkaIniFilename, QSettings::IniFormat);

	ACCOUNT_UPDATE_INTERVAL = settings.value("AccountUpdate/Interval", 0).toInt();
	qDebug() << "Read ACCOUNT_UPDATE_INTERVAL:" << ACCOUNT_UPDATE_INTERVAL << endl;
	ba = settings.value("AccountUpdate/LastUpdateTime", "").toString().toLatin1();
	ACCOUNT_UPDATE_LAST_TIME = strdup(ba.data());
	qDebug() << "Read ACCOUNT_UPDATE_LAST_TIME:" << ACCOUNT_UPDATE_LAST_TIME << endl;

	MULIT_NODE_INTERVAL = settings.value("MultiNode/Interval", 0).toInt();
	qDebug() << "Read MULIT_NODE_INTERVAL:" << MULIT_NODE_INTERVAL << endl;

	SEND_FLAG = settings.value("Flag/SendFlag", 0).toInt();
	qDebug() << "Read SEND_FLAG:" << SEND_FLAG << endl;
	FILE_FLAG = settings.value("Flag/FileFlag", 0).toInt();
	qDebug() << "Read FILE_FLAG:" << FILE_FLAG << endl;
	FRONT_INST = settings.value("Flag/FrontInst", 0).toInt();
	qDebug() << "Read FRONT_INST:" << FRONT_INST << endl;
	ba = settings.value("Flag/FrontIP", "").toString().toLatin1();
	FRONT_IP = strdup(ba.data());
	qDebug() << "Read FRONT_IP:" << FRONT_IP << endl;
	CITY_FLAG = settings.value("Flag/CityFlag", 0).toInt();
	qDebug() << "Read CITY_FLAG:" << CITY_FLAG << endl;

//̨<><CCA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>lnk20241031//////////////////////////////////////////////////////////////
	TERMINAL_STATUS = settings.value("Ledger/TerminalStatus", 0).toString().toStdString();
	std::cout << "Read TERMINAL_STATUS:" << TERMINAL_STATUS << std::endl;
	MONITOR_STATUS = settings.value("Ledger/MonitorStatus", 0).toString().toStdString();
	std::cout << "Read MONITOR_STATUS:" << MONITOR_STATUS << std::endl;
	ICD_FLAG = settings.value("Ledger/IcdFlag", 0).toString().toStdString();
	std::cout << "Read ICD_FLAG:" << ICD_FLAG << std::endl;
	IED_COUNT = settings.value("Ledger/IedCount", 0).toInt();

//////////////////////////////////////////////////<2F><><EFBFBD><EFBFBD>socket<65><74><EFBFBD><EFBFBD>///////////////////
	SOCKETENABLE = settings.value("Socket/SocketEnable", 0).toInt();
	SOCKET_PORT = settings.value("Socket/SocketPort", 0).toInt();
//////<2F><><EFBFBD><EFBFBD>http<74><70><EFBFBD><EFBFBD>//////////////////////////////////////////////////////////////////
	HTTPENABLE = settings.value("Http/HttpEnable", 0).toInt();
	ba = settings.value("Http/HttpIp", "").toString().toLatin1();
	HTTP_IP = strdup(ba.data());
	std::cout << "Read HTTP_IP:" << HTTP_IP << std::endl;
	HTTP_PORT = settings.value("Http/HttpPort", 0).toInt();
	std::cout << "Read HTTP_PORT:" << HTTP_PORT << std::endl;

	ba = settings.value("Http/WebDevice", "").toString().toLatin1();
	WEB_DEVICE = strdup(ba.data());
	std::cout << "Read WEB_DEVICE:" << WEB_DEVICE << std::endl;
	ba = settings.value("Http/WebIcd", "").toString().toLatin1();
	WEB_ICD = strdup(ba.data());
	std::cout << "Read WEB_ICD:" << WEB_ICD << std::endl;
	ba = settings.value("Http/WebIntegrity", "").toString().toLatin1();
	WEB_INTEGRITY = strdup(ba.data());
	std::cout << "Read WEB_INTEGRITY:" << WEB_INTEGRITY << std::endl;
	ba = settings.value("Http/WebComflag", "").toString().toLatin1();
	WEB_COMFLAG = strdup(ba.data());
	std::cout << "Read WEB_COMFLAG:" << WEB_COMFLAG << std::endl;
	ba = settings.value("Http/WebEvent", "").toString().toLatin1();
	WEB_EVENT = strdup(ba.data());
	std::cout << "Read WEB_EVENT:" << WEB_EVENT << std::endl;
	ba = settings.value("Http/WebFileupload", "").toString().toLatin1();
	WEB_FILEUPLOAD = strdup(ba.data());
	std::cout << "Read WEB_FILEUPLOAD:" << WEB_FILEUPLOAD << std::endl;
	ba = settings.value("Http/WebFiledownload", "").toString().toLatin1();
	WEB_FILEDOWNLOAD = strdup(ba.data());
	std::cout << "Read WEB_FILEDOWNLOAD:" << WEB_FILEDOWNLOAD << std::endl;

///////////////////////////////////////////////////////////////////////////////////////////////////////
	recall_len = settings.value("Recall/recall_lenth", 0).toInt();
	qDebug() << "Read recall_lenth:" << recall_len << endl;
	recall_sta = settings.value("Recall/recall_start", 0).toInt();
	qDebug() << "Read recall_start:" << recall_sta << endl;
	recall_daily = settings.value("Recall/recall_dailytime", 0).toInt();
	qDebug() << "Read recall_dailytime:" << recall_daily << endl;

	COMMUNICATION_LOG_STATUS_TIME = settings.value("CommunicationLog/StatusRecordDuration", 0).toInt();
	qDebug() << "Read COMMUNICATION_LOG_STATUS_TIME:" << COMMUNICATION_LOG_STATUS_TIME << endl;
	COMMUNICATION_LOG_ABNORMAL_TIME = settings.value("CommunicationLog/AbnormalRecordDuration", 0).toInt();
	qDebug() << "Read COMMUNICATION_LOG_ABNORMAL_TIME:" << COMMUNICATION_LOG_ABNORMAL_TIME << endl;


	ba = settings.value("Postgres/Database", "").toString().toLatin1();
	POSTGRES_DATABASE = strdup(ba.data());
	ba = settings.value("Postgres/Username", "").toString().toLatin1();
	POSTGRES_USERNAME = strdup(ba.data());

	ba = settings.value("Postgres/Password", "").toString().toLatin1();
	POSTGRES_PASSWORD = strdup(ba.data());

	ba = settings.value("Postgres/Schema", "").toString().toLatin1();
	POSTGRES_SCHEMA = strdup(ba.data());
	ba = settings.value("Postgres/Dnsname", "").toString().toLatin1();
	POSTGRES_DNSNAME = strdup(ba.data());
	ba = settings.value("Postgres/TablePrefix", "").toString().toLatin1();
	POSTGRES_TABLEPREFIX = strdup(ba.data());


	qDebug() << "Read POSTGRES_DATABASE:" << POSTGRES_DATABASE << endl;
	qDebug() << "Read POSTGRES_USERNAME:" << POSTGRES_USERNAME << endl;
	qDebug() << "Read POSTGRES_PASSWORD:" << POSTGRES_PASSWORD << endl;
	qDebug() << "Read POSTGRES_SCHEMA:" << POSTGRES_SCHEMA << endl;
	qDebug() << "Read POSTGRES_DNSNAME:" << POSTGRES_DNSNAME << endl;
	qDebug() << "Read POSTGRES_TABLEPREFIX:" << POSTGRES_TABLEPREFIX << endl;


	ba = settings.value("Oss/OssEndpoint", "").toString().toLatin1();
	OSS_ENDPOINT = strdup(ba.data());
	ba = settings.value("Oss/AccessKeyID", "").toString().toLatin1();
	ACCESS_KEY_ID = strdup(ba.data());
	ba = settings.value("Oss/AccessKeySecret", "").toString().toLatin1();
	ACCESS_KEY_SECRET = strdup(ba.data());
	ba = settings.value("Oss/BucketName", "").toString().toLatin1();
	BUCKET_NAME = strdup(ba.data());

	qDebug() << "Read OSS_ENDPOINT:" << OSS_ENDPOINT << endl;
	qDebug() << "Read ACCESS_KEY_ID:" << ACCESS_KEY_ID << endl;
	qDebug() << "Read ACCESS_KEY_SECRET:" << ACCESS_KEY_SECRET << endl;
	qDebug() << "Read BUCKET_NAME:" << BUCKET_NAME << endl;

	ba = settings.value("Kafka/brokerlist", "").toString().toLatin1();
	BROKER_LIST = strdup(ba.data());
	ba = settings.value("Kafka/HisTopic", "").toString().toLatin1();
	TOPIC_STAT = strdup(ba.data());
	ba = settings.value("Kafka/PSTTopic", "").toString().toLatin1();
	TOPIC_PST = strdup(ba.data());
	ba = settings.value("Kafka/PLTTopic", "").toString().toLatin1();
	TOPIC_PLT = strdup(ba.data());

	ba = settings.value("Kafka/EventTopic", "").toString().toLatin1();
	TOPIC_EVENT = strdup(ba.data());

	ba = settings.value("Kafka/AlmTopic", "").toString().toLatin1();
	TOPIC_ALARM = strdup(ba.data());
	ba = settings.value("Kafka/SngTopic", "").toString().toLatin1();
	TOPIC_SNG = strdup(ba.data());

	ba = settings.value("Kafka/RTDataTopic", "").toString().toLatin1();
	TOPIC_RTDATA = strdup(ba.data());

	qDebug() << "Read BROKER_LIST:" << BROKER_LIST << endl;
	qDebug() << "Read TOPIC_STAT:" << TOPIC_STAT << endl;
	qDebug() << "Read TOPIC_PST:" << TOPIC_PST << endl;
	qDebug() << "Read TOPIC_PLT:" << TOPIC_PLT << endl;
	qDebug() << "Read TOPIC_EVENT:" << TOPIC_EVENT << endl;
	qDebug() << "Read TOPIC_ALARM:" << TOPIC_ALARM << endl;
	qDebug() << "Read TOPIC_SNG:" << TOPIC_SNG << endl;
	qDebug() << "Read TOPIC_RTDATA:" << TOPIC_RTDATA << endl;


	ba = settings.value("Kafka/Protocol", "").toString().toLatin1();
	PROTOCOL = strdup(ba.data());
	ba = settings.value("Kafka/Mechanisms", "").toString().toLatin1();
	MECHANISMS = strdup(ba.data());
	ba = settings.value("Kafka/KeytabFile", "").toString().toLatin1();
	KEYTAB_FILE = strdup(ba.data());
	ba = settings.value("Kafka/ServiceName", "").toString().toLatin1();
	SERVICE_NAME = strdup(ba.data());
	ba = settings.value("Kafka/Principal", "").toString().toLatin1();
	PRINCIPAL = strdup(ba.data());
	ba = settings.value("Kafka/DomainName", "").toString().toLatin1();
	DOMAIN_NAME = strdup(ba.data());

	qDebug() << "Read PROTOCOL:" << PROTOCOL << endl;
	qDebug() << "Read MECHANISMS:" << MECHANISMS << endl;
	qDebug() << "Read KEYTAB_FILE:" << KEYTAB_FILE << endl;
	qDebug() << "Read SERVICE_NAME:" << SERVICE_NAME << endl;
	qDebug() << "Read PRINCIPAL:" << PRINCIPAL << endl;
	qDebug() << "Read DOMAIN_NAME:" << DOMAIN_NAME << endl;

	ba = settings.value("Web/ClientId", "").toString().toLatin1();
	CLIENT_ID = strdup(ba.data());
	ba = settings.value("Web/ClientSecret", "").toString().toLatin1();
	CLIENT_SECRET = strdup(ba.data());
	ba = settings.value("Web/TokenUrl", "").toString().toLatin1();
	TOKEN_URL = strdup(ba.data());
	ba = settings.value("Web/DeviceUrl", "").toString().toLatin1();
	DEVICE_URL = strdup(ba.data());
	ba = settings.value("Web/GrantType", "").toString().toLatin1();
	GRANT_TYPE = strdup(ba.data());

	qDebug() << "Read CLIENT_ID:" << CLIENT_ID << endl;
	qDebug() << "Read CLIENT_SECRET:" << CLIENT_SECRET << endl;
	qDebug() << "Read TOKEN_URL:" << TOKEN_URL << endl;
	qDebug() << "Read DEVICE_URL:" << DEVICE_URL << endl;
	qDebug() << "Read GRANT_TYPE:" << GRANT_TYPE << endl;

	ba = settings.value("Uds/UdsUploadUrl", "").toString().toLatin1();
	UDS_UPLOAD_URL = strdup(ba.data());
	ba = settings.value("Uds/UdsDownloadUrl", "").toString().toLatin1();
	UDS_DOWNLOAD_URL = strdup(ba.data());

	qDebug() << "Read UDS_UPLOAD_URL:" << UDS_UPLOAD_URL << endl;
	qDebug() << "Read UDS_DOWNLOAD_URL:" << UDS_DOWNLOAD_URL << endl;

/*<2A><><EFBFBD><EFBFBD>rocketmq<6D>Ľ<EFBFBD><C4BD><EFBFBD>10-9 */////////////////////////////////////////////////////////////////
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	ba = settings.value("RocketMq/producer", "").toString().toLatin1();
	G_ROCKETMQ_PRODUCER = strdup(ba.data());
	ba = settings.value("RocketMq/Ipport", "").toString().toLatin1();
	G_ROCKETMQ_IPPORT = strdup(ba.data());
	ba = settings.value("RocketMq/Topic", "").toString().toLatin1();
	G_ROCKETMQ_TOPIC = strdup(ba.data());
	ba = settings.value("RocketMq/Tag", "").toString().toLatin1();
	G_ROCKETMQ_TAG = strdup(ba.data());
	ba = settings.value("RocketMq/Key", "").toString().toLatin1();
	G_ROCKETMQ_KEY = strdup(ba.data());
	QUEUENUM = settings.value("RocketMq/Queuenum", 0).toInt();
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	ba = settings.value("RocketMq/consumer", "").toString().toLatin1();
	G_ROCKETMQ_CONSUMER = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerIpport", "").toString().toLatin1();
	G_MQCONSUMER_IPPORT = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerTopicRT", "").toString().toLatin1();
	G_MQCONSUMER_TOPIC_RT = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerTagRT", "").toString().toLatin1();
	G_MQCONSUMER_TAG_RT = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerKeyRT", "").toString().toLatin1();
	G_MQCONSUMER_KEY_RT = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerAccessKey", "").toString().toLatin1();
	G_MQCONSUMER_ACCESSKEY = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerSecretKey", "").toString().toLatin1();
	G_MQCONSUMER_SECRETKEY = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerChannel", "").toString().toLatin1();
	G_MQCONSUMER_CHANNEL = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerTopicUD", "").toString().toLatin1();
	G_MQCONSUMER_TOPIC_UD = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerTagUD", "").toString().toLatin1();
	G_MQCONSUMER_TAG_UD = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerKeyUD", "").toString().toLatin1();
	G_MQCONSUMER_KEY_UD = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerTopicRC", "").toString().toLatin1();
	G_MQCONSUMER_TOPIC_RC = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerTagRC", "").toString().toLatin1();
	G_MQCONSUMER_TAG_RC = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerKeyRC", "").toString().toLatin1();
	G_MQCONSUMER_KEY_RC = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerTopicSET", "").toString().toLatin1();
	G_MQCONSUMER_TOPIC_SET = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerTagSET", "").toString().toLatin1();
	G_MQCONSUMER_TAG_SET = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerKeySET", "").toString().toLatin1();
	G_MQCONSUMER_KEY_SET = strdup(ba.data());

	ba = settings.value("RocketMq/ConsumerTopicLOG", "").toString().toLatin1();
	G_MQCONSUMER_TOPIC_LOG = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerTagLOG", "").toString().toLatin1();
	G_MQCONSUMER_TAG_LOG = strdup(ba.data());
	ba = settings.value("RocketMq/ConsumerKeyLOG", "").toString().toLatin1();
	G_MQCONSUMER_KEY_LOG = strdup(ba.data());
	ba = settings.value("RocketMq/LOGTopic", "").toString().toLatin1();
	G_LOG_TOPIC = strdup(ba.data());
	ba = settings.value("RocketMq/LOGTag", "").toString().toLatin1();
	G_LOG_TAG = strdup(ba.data());
	ba = settings.value("RocketMq/LOGKey", "").toString().toLatin1();
	G_LOG_KEY = strdup(ba.data());
	ba = settings.value("RocketMq/CONNECTTopic", "").toString().toLatin1();
	G_CONNECT_TOPIC = strdup(ba.data());
	ba = settings.value("RocketMq/CONNECTTag", "").toString().toLatin1();
	G_CONNECT_TAG = strdup(ba.data());
	ba = settings.value("RocketMq/CONNECTKey", "").toString().toLatin1();
	G_CONNECT_KEY = strdup(ba.data());
//MQ<4D><51><EFBFBD><EFBFBD>
	G_TEST_FLAG = settings.value("RocketMq/Testflag", 0).toInt();
	G_TEST_NUM = settings.value("RocketMq/Testnum", 0).toInt();

	ba = settings.value("RocketMq/TestList", 0).toString().toLatin1();
	G_TEST_LIST = strdup(ba.data());
	parseTestList(G_TEST_LIST);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>õ<EFBFBD><C3B5>ն<EFBFBD><D5B6>б<EFBFBD>

//<2F><><EFBFBD><EFBFBD>shell
	TEST_PORT = settings.value("RocketMq/TestPort", 0).toInt();
	
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ش<EFBFBD>ӡ
	std::cout << "Read G_ROCKETMQ_PRODUCER:" << G_ROCKETMQ_PRODUCER << std::endl;
	std::cout << "Read G_ROCKETMQ_IPPORT:" << G_ROCKETMQ_IPPORT << std::endl;
	std::cout << "Read G_ROCKETMQ_TOPIC:" << G_ROCKETMQ_TOPIC << std::endl;
	std::cout << "Read G_ROCKETMQ_TAG:" << G_ROCKETMQ_TAG << std::endl;
	std::cout << "Read G_ROCKETMQ_KEY:" << G_ROCKETMQ_KEY << std::endl;
	std::cout << "Read QUEUENUM:" << QUEUENUM << std::endl;
	std::cout << "Read G_LOG_TOPIC:" << G_LOG_TOPIC << std::endl;
	std::cout << "Read G_LOG_TAG:" << G_LOG_TAG << std::endl;
	std::cout << "Read G_LOG_KEY:" << G_LOG_KEY << std::endl;
	std::cout << "Read G_CONNECT_TOPIC:" << G_CONNECT_TOPIC << std::endl;
	std::cout << "Read G_CONNECT_TAG:" << G_CONNECT_TAG << std::endl;
	std::cout << "Read G_CONNECT_KEY:" << G_CONNECT_KEY << std::endl;
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ش<EFBFBD>ӡ
	std::cout << "Read G_ROCKETMQ_CONSUMER:" << G_ROCKETMQ_CONSUMER << std::endl;
	std::cout << "Read G_MQCONSUMER_IPPORT:" << G_MQCONSUMER_IPPORT << std::endl;
	std::cout << "Read G_MQCONSUMER_TOPIC_RT:" << G_MQCONSUMER_TOPIC_RT << std::endl;
	std::cout << "Read G_MQCONSUMER_TAG_RT:" << G_MQCONSUMER_TAG_RT << std::endl;
	std::cout << "Read G_MQCONSUMER_KEY_RT:" << G_MQCONSUMER_KEY_RT << std::endl;
	std::cout << "Read G_MQCONSUMER_ACCESSKEY:" << G_MQCONSUMER_ACCESSKEY << std::endl;
	std::cout << "Read G_MQCONSUMER_SECRETKEY:" << G_MQCONSUMER_SECRETKEY << std::endl;
	std::cout << "Read G_MQCONSUMER_CHANNEL:" << G_MQCONSUMER_CHANNEL << std::endl;
	std::cout << "Read G_MQCONSUMER_TOPIC_UD:" << G_MQCONSUMER_TOPIC_UD << std::endl;
	std::cout << "Read G_MQCONSUMER_TAG_UD:" << G_MQCONSUMER_TAG_UD << std::endl;
	std::cout << "Read G_MQCONSUMER_KEY_UD:" << G_MQCONSUMER_KEY_UD << std::endl;
	std::cout << "Read G_MQCONSUMER_TOPIC_RC:" << G_MQCONSUMER_TOPIC_RC << std::endl;
	std::cout << "Read G_MQCONSUMER_TAG_RC:" << G_MQCONSUMER_TAG_RC << std::endl;
	std::cout << "Read G_MQCONSUMER_KEY_RC:" << G_MQCONSUMER_KEY_RC << std::endl;
	std::cout << "Read G_MQCONSUMER_TOPIC_SET:" << G_MQCONSUMER_TOPIC_SET << std::endl;
	std::cout << "Read G_MQCONSUMER_TAG_SET:" << G_MQCONSUMER_TAG_SET << std::endl;
	std::cout << "Read G_MQCONSUMER_KEY_SET:" << G_MQCONSUMER_KEY_SET << std::endl;
	std::cout << "Read G_MQCONSUMER_TOPIC_LOG:" << G_MQCONSUMER_TOPIC_LOG << std::endl;
	std::cout << "Read G_MQCONSUMER_TAG_LOG:" << G_MQCONSUMER_TAG_LOG << std::endl;
	std::cout << "Read G_MQCONSUMER_KEY_LOG:" << G_MQCONSUMER_KEY_LOG << std::endl;
//Mq<4D><71><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ش<EFBFBD>ӡ
	std::cout << "Read G_TEST_FLAG:" << G_TEST_FLAG << std::endl;
	std::cout << "Read G_TEST_NUM:" << G_TEST_NUM << std::endl;


//20241212lnk<6E><6B><EFBFBD>Ӷ<EFBFBD>ǰ<EFBFBD><C7B0>
	if (g_front_seg_index != 0 && g_front_seg_num != 0) {
		MULTIPLE_NODE_FLAG = 1;
		std::cout << "this is multiple process of index:" << g_front_seg_index << std::endl;
	}
	else{
		MULTIPLE_NODE_FLAG = 0;
		std::cout << "this is single process" << std::endl;
	}
	
//20250109lnk<6E><6B><EFBFBD>ӽ<EFBFBD><D3BD>̲<EFBFBD><CCB2>Դ<EFBFBD>ӡ<EFBFBD>˿<EFBFBD>
	if (g_node_id == STAT_DATA_BASE_NODE_ID)//ͳ<>Ʋɼ<C6B2>
		TEST_PORT = TEST_PORT + STAT_DATA_BASE_NODE_ID +  g_front_seg_index;
	else if (g_node_id == RECALL_HIS_DATA_BASE_NODE_ID) {//<2F><><EFBFBD><EFBFBD>
		TEST_PORT = TEST_PORT + RECALL_HIS_DATA_BASE_NODE_ID +  g_front_seg_index;
	}
	else if (g_node_id == THREE_SECS_DATA_BASE_NODE_ID) {//3<><33><EFBFBD>ɼ<EFBFBD>
		TEST_PORT = TEST_PORT + THREE_SECS_DATA_BASE_NODE_ID +  g_front_seg_index;
	}
	else if (g_node_id == SOE_COMTRADE_BASE_NODE_ID) {//<2F><>̬¼<CCAC><C2BC>
		TEST_PORT = TEST_PORT + SOE_COMTRADE_BASE_NODE_ID +  g_front_seg_index;
	}	
	
}

// CZY <20><><EFBFBD><EFBFBD> ping IP
// ִ<><D6B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EEB2A2>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
std::string executeCommand(const std::string& command) {
	std::string result = "";
	FILE* pipe = popen(command.c_str(), "r");
	if (!pipe) {
		std::cerr << "Error executing command." << std::endl;
		return result;
	}

	char buffer[128];
	while (!feof(pipe)) {
		if (fgets(buffer, 128, pipe) != NULL)
			result += buffer;
	}

	pclose(pipe);
	return result;
}

bool telnet_port_socket(const char* ip, int port) {
	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(port);
	inet_pton(AF_INET, ip, &server_addr.sin_addr);

	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (sockfd < 0) {
		perror("socket");
		return false;
	}

	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӳ<EFBFBD>ʱʱ<CAB1><CAB1>Ϊ5<CEAA><35>
	struct timeval timeout;
	timeout.tv_sec = 5;
	timeout.tv_usec = 0;
	if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(timeout)) < 0) {
		perror("setsockopt");
		close(sockfd);
		return false;
	}
	if (setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout, sizeof(timeout)) < 0) {
		perror("setsockopt");
		close(sockfd);
		return false;
	}

	if (connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
		if (errno == EINPROGRESS) {
			fd_set fds;
			FD_ZERO(&fds);
			FD_SET(sockfd, &fds);

			int ret = select(sockfd + 1, NULL, &fds, NULL, &timeout);
			if (ret == -1) {
				perror("select");
				close(sockfd);
				return false;
			}
			else if (ret == 0) {
				// <20><><EFBFBD>ӳ<EFBFBD>ʱ
				close(sockfd);
				return false;
			}
			else {
				int error;
				socklen_t len = sizeof(error);
				getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len);
				if (error == 0) {
					// <20><><EFBFBD>ӳɹ<D3B3>
					close(sockfd);
					return true;
				}
				else {
					// <20><><EFBFBD><EFBFBD>ʧ<EFBFBD><CAA7>
					close(sockfd);
					return false;
				}
			}
		}
		else {
			// <20><><EFBFBD><EFBFBD>ʧ<EFBFBD><CAA7>
			close(sockfd);
			return false;
		}
	}

	// <20><><EFBFBD>ӳɹ<D3B3>
	close(sockfd);
	return true;
}

// ping IP
bool ping_ip(const std::string& ip) {
	std::string command = "ping -c 1 -w 2.5 " + ip;
	std::string result = executeCommand(command);

	// <20>ж<EFBFBD><D0B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD> "1 packets transmitted, 1 received" <20>ַ<EFBFBD><D6B7><EFBFBD>
	if (result.find("1 packets transmitted, 1 received") != std::string::npos) {
		return true;
	}
	else {
		return false;
	}
}
void pingPrint(QTcpSocket* clientSocket, const std::string &msg) {
    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>׼<EFBFBD><D7BC><EFBFBD><EFBFBD>
    std::cout << msg << std::endl;
    // <20><>¼<EFBFBD><C2BC><EFBFBD><EFBFBD>־<EFBFBD>ļ<EFBFBD>
    add_comm_log(const_cast<char*>(msg.c_str()));
    // <20><><EFBFBD><EFBFBD> clientSocket <20><>Ϊ<EFBFBD>գ<EFBFBD><D5A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>͵<EFBFBD> shell
    if (clientSocket != nullptr) {
        clientSocket->write((msg + "\r\n").c_str());
        clientSocket->flush();
    }
}
int Worker::init_ping_telnet(QTcpSocket* clientSocket, int& ip_count, int& telnet_count) {
    pingPrint(clientSocket, "start test ping telnet");
    ied_t* ied = NULL;
    int iedno;
    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>豸
    for (iedno = 0; iedno < g_node->n_clients && !g_stopTelnetTest; iedno++) {
        // **1. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>룬<EFBFBD>û<EFBFBD><C3BB><EFBFBD><EFBFBD><EFBFBD> ``` <20>˳<EFBFBD>**
        if (clientSocket->waitForReadyRead(100)) {  // ? <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
            QByteArray input = clientSocket->readAll().trimmed();
            if (input == "`") {  // ? <20>û<EFBFBD><C3BB><EFBFBD><EFBFBD><EFBFBD> ```<60><><EFBFBD>˳<EFBFBD><CBB3><EFBFBD>־ģʽ
                std::cout << "Received '`' from shell socket! Exiting viewlog...\n";
				g_stopTelnetTest = true;
                break;
            }
        }

        ied = g_node->clients[iedno];
        if (ied) {
            if (g_onlyIP[0] != 0 && (strcmp(g_onlyIP, ied->channel[0].addr_str) != 0)) {
                continue;
            }
            bool pingResult = ping_ip(ied->channel[0].addr_str);
            bool telnetResult = telnet_port_socket(ied->channel[0].addr_str, ied->channel[0].port);

            std::string logMsg;
            logMsg.append("Ping to IP ");
            logMsg.append(ied->channel[0].addr_str);
            if (pingResult) {
                ip_count++;
                logMsg.append(" is successful.");
            } else {
                logMsg.append(" is unsuccessful.");
            }
            pingPrint(clientSocket, logMsg);
            add_comm_log(const_cast<char*>(logMsg.c_str()));

            logMsg = "";
            logMsg.append("Telnet port ");
            logMsg.append(QString::number(ied->channel[0].port).toStdString());
            if (telnetResult) {
                telnet_count++;
                logMsg.append(" is open on IP ");
            } else {
                logMsg.append(" is closed on IP ");
            }
            logMsg.append(ied->channel[0].addr_str);
            add_comm_log(const_cast<char*>(logMsg.c_str()));
            pingPrint(clientSocket, logMsg);

            std::string countMsg = "iedno:" + intToString(iedno) +
                                   " ip_count:" + intToString(ip_count) +
                                   " telnet_count:" + intToString(telnet_count);
            pingPrint(clientSocket, countMsg);

            // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
            QString MyKafkaIniFilename = QString("../etc/") + QString("testping.ini");
            QSettings settings(MyKafkaIniFilename, QSettings::IniFormat);
            settings.setValue("test/IpCount", ip_count);
            settings.setValue("test/TelnetCount", telnet_count);
            settings.setValue("test/IedCount", iedno);
        }
    }
    pingPrint(clientSocket, "end test ping telnet");
    return 1;
}

//CZY 2023-08-30 chat* null or emptry
bool isCharPtrEmpty(const char* str) {
	return str == nullptr || str[0] == '\0' || str == "";
}

// CZY 2024-07-24 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD>Ƿ<EFBFBD>ȫΪ<C8AB><CEAA><EFBFBD><EFBFBD>  
int isAllDigits(const char* str) {
	while (*str) {
		if (!isdigit((unsigned char)*str)) {
			return 0; // <20><><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD>  
		}
		str++;
	}
	return 1; // <20><><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>  
}

// CZY 2024-07-24<32><34><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>ת<EFBFBD><D7AA>Ϊint<6E><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ܣ<EFBFBD>  
int stringToInt(const char* str, int* result) {
	if (isAllDigits(str)) {
		*result = atoi(str); // ʹ<><CAB9>atoi<6F><69><EFBFBD><EFBFBD>ת<EFBFBD><D7AA><EFBFBD><EFBFBD>ע<EFBFBD><D7A2>atoi<6F><69><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>  
		return 1; // ת<><D7AA><EFBFBD>ɹ<EFBFBD>  
	}
	return 0; // ת<><D7AA>ʧ<EFBFBD><CAA7>  
}


int GetServerIndexFromDB() //<2F><>ȡǰ<C8A1>÷<EFBFBD><C3B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{

	register int fd, interface;
	const int MAXINTERFACES = 100;
	struct ifreq buf[MAXINTERFACES];
	struct arpreq arp;
	struct ifconf ifc;
	char mac[32] = "";

	if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) >= 0) {
		ifc.ifc_len = sizeof buf;
		ifc.ifc_buf = (caddr_t)buf;

		if (!ioctl(fd, SIOCGIFCONF, (char*)&ifc)) {
			
			interface = ifc.ifc_len / sizeof(struct ifreq);
			printf("\ninterface num is interface= %d\n", interface);

			while (interface-- > 0) {
				printf("net device %s\n", buf[interface].ifr_name);

				/*ȷ<><C8B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD>֧<EFBFBD>ֻ<EFBFBD><D6BB><EFBFBD>ģʽ Jugde whether the net card status is promisc */
				if (!(ioctl(fd, SIOCGIFFLAGS, (char*)&buf[interface]))) {
					if (buf[interface].ifr_flags & IFF_PROMISC) {
						printf("the interface is PROMISC \n");
					}
				}
				else {
					char str[256] = "";
					sprintf(str, "cpm: ioctl device %s", buf[interface].ifr_name);
					perror(str);
				}

				/*<2A>ж<EFBFBD><D0B6><EFBFBD><EFBFBD><EFBFBD>״̬<D7B4>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD> Judge whether the net card status is up */
				if (buf[interface].ifr_flags & IFF_UP) {
					printf("the interface status is UP\n");
				}
				else {
					printf("the interface status is DOWN\n");
				}

				/*<2A><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>IP<49><50>ַ Get IP of the net card */
				if (!(ioctl(fd, SIOCGIFADDR, (char*)&buf[interface]))) {
					printf("IP address is: %s\n", inet_ntoa(((struct sockaddr_in*)(&buf[interface].ifr_addr))->sin_addr));

				}
				else {
					char str[256] = "";
					sprintf(str, "cpm: ioctl device %s", buf[interface].ifr_name);
					perror(str);
				}

				/*<2A><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>HW<48><57>ַ Get HW ADDRESS of the net card */
				if (!(ioctl(fd, SIOCGIFHWADDR, (char*)&buf[interface]))) {
					printf("HW address is: ");
					sprintf(mac, "%02x:%02x:%02x:%02x:%02x:%02x",
						(unsigned char)buf[interface].ifr_hwaddr.sa_data[0],
						(unsigned char)buf[interface].ifr_hwaddr.sa_data[1],
						(unsigned char)buf[interface].ifr_hwaddr.sa_data[2],
						(unsigned char)buf[interface].ifr_hwaddr.sa_data[3],
						(unsigned char)buf[interface].ifr_hwaddr.sa_data[4],
						(unsigned char)buf[interface].ifr_hwaddr.sa_data[5]);
					printf("%s\n\n", mac);
				}
				else {
					char str[256];
					sprintf(str, "cpm: ioctl device %s", buf[interface].ifr_name);
					perror(str);
				}
			}
		}
		else
			perror("cpm: ioctl");
	}
	else
		perror("cpm: socket");

	close(fd);
	return 0;
}
/////////////////////////////////////////////////////////CZY

void parse_one_rpt_log_ini(int idx, QStringList* rpt_cfg_strlist, QStringList* log_cfg_strlist, char* type)
{
	char* tmp;
	tmp = Get_xmlpath(type);//<2F><>ȡģ<C8A1><C4A3>id<69><64>
	if (tmp == NULL) {//<2F>Ҳ<EFBFBD><D2B2><EFBFBD>ģ<EFBFBD>ͱ<EFBFBD><CDB1><EFBFBD>ʹ<EFBFBD><CAB9>Ĭ<EFBFBD>ϵ<EFBFBD><CFB5>ͺź<CDBA><C5BA><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
		//zw<7A>޸<EFBFBD> 2023 - 8 - 15 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ľ<EFBFBD><C4BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>XML ԭ<><D4AD><EFBFBD><EFBFBD>RptLogCfg.iniȡ<69><C8A1>
		if (strcmp(subdir, "cfg_stat_data") == 0)
		{
			QString devtype;
			devtype.append(type);
			QString devtype2;
			devtype2.append("HL-6810");//<2F><>̬Ĭ<CCAC><C4AC><EFBFBD>ͺ<EFBFBD>HL-6810

			qDebug() << "cfg_stat_data";
			QString xml_dir = QString("../") + QString("etc/"); //Linux<75>µ<EFBFBD><C2B5><EFBFBD>·<EFBFBD><C2B7>

			QDomDocument doc;   //<2F>½<EFBFBD>QDomDocument<6E><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>XML<4D>ĵ<EFBFBD>
			QFile file(xml_dir + QString("JiangSu_Config.xml"));//Ĭ<><C4AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>JiangSu_Config.xml
			if (!file.open(QIODevice::ReadOnly | QFile::Text)) //<2F><>ֻ<EFBFBD><D6BB><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD><EFBFBD><EFBFBD>xml
			{
				qDebug() << "Read RPT Error1";
				return;
			}
			if (!doc.setContent(&file)) //<2F><><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>ݶ<EFBFBD><DDB6><EFBFBD>doc<6F><63>
			{
				qDebug() << "Read RPT Error2";
				file.close();
				return;
			}
			file.close();
			QDomNode firstNode = doc.firstChild(); //<2F><><EFBFBD>ڵ<EFBFBD>"JSConfigTemplate"
			QDomElement docElem = doc.documentElement();  //<2F><><EFBFBD>ظ<EFBFBD><D8B8>ڵ<EFBFBD>Ԫ<EFBFBD><D4AA>
			QDomNode n = docElem.firstChild(); //<2F><><EFBFBD><EFBFBD>doc<6F>ĵ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ڵ㣬<DAB5><E3A3AC>"Topic"
			while (!n.isNull()) //<2F><><EFBFBD><EFBFBD>Topic<69>ڵ㲻Ϊ<E3B2BB><CEAA> 
			{
				if (n.isElement())
				{
					QDomElement e = n.toElement(); //<2F><><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>ΪԪ<CEAA><D4AA>
					QString strTag = e.tagName(); //
					if ("ReportMap" == strTag)//zw<7A>޸<EFBFBD> 2023 - 8 - 15 <20><><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ľ<EFBFBD><C4BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>XML ԭ<><D4AD><EFBFBD><EFBFBD>RptLogCfg.iniȡ<69><C8A1>
					{
						qDebug() << "ReportStat";
						QDomNodeList list = e.childNodes(); //<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD>ص<EFBFBD><D8B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӽڵ<D3BD><DAB5><EFBFBD><EFBFBD>б<EFBFBD>
						for (int i = 0; i < list.count(); i++) //<2F><><EFBFBD><EFBFBD> DataType<70>б<EFBFBD>
						{
							QDomNode node = list.at(i); //node1 <DataType>
							if (node.isElement())
							{
								QString strTag2 = node.toElement().tagName(); //DataType<70>ڵ<EFBFBD>
								if ("ReportStat" == strTag2)
								{
									QDomNodeList list2 = node.childNodes(); //<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>DataType<70><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӽڵ<D3BD><DAB5><EFBFBD><EFBFBD>б<EFBFBD> 
									for (int i2 = 0; i2 < list2.count(); i2++) //<2F><><EFBFBD><EFBFBD> Monitor<6F>б<EFBFBD>
									{
										QDomNode node2 = list2.at(i2); //node2 <Monitor>
										if (node2.isElement())
										{
											rpt_cfg_strlist->append(node2.toElement().attribute("ReportControl"));
											qDebug() << "devtype:" << devtype << node2.toElement().attribute("ReportControl").toAscii().data();
										}
									}
								}
							}

						}
					}
				}
				n = n.nextSibling();
			}

			QString log_cfg_str = "LLN0$LG$lcStatisticData,dsStatisticData,PQM1,0,600000,1,0,0,0";
			log_cfg_strlist->append(log_cfg_str);
		}
		if (strcmp(subdir, "cfg_soe_comtrade") == 0)
		{
			qDebug() << "cfg_soe_comtrade";
			QString xml_dir = QString("../") + QString("etc/"); //Linux<75>µ<EFBFBD><C2B5><EFBFBD>·<EFBFBD><C2B7>

			QDomDocument doc;   //<2F>½<EFBFBD>QDomDocument<6E><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>XML<4D>ĵ<EFBFBD>
			QFile file(xml_dir + QString("JiangSu_Config.xml"));
			if (!file.open(QIODevice::ReadOnly | QFile::Text)) //<2F><>ֻ<EFBFBD><D6BB><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD><EFBFBD><EFBFBD>xml
			{
				qDebug() << "Read RPT Error1";
				return;
			}
			if (!doc.setContent(&file)) //<2F><><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>ݶ<EFBFBD><DDB6><EFBFBD>doc<6F><63>
			{
				qDebug() << "Read RPT Error2";
				file.close();
				return;
			}
			file.close();
			QDomNode firstNode = doc.firstChild(); //<2F><><EFBFBD>ڵ<EFBFBD>"JSConfigTemplate"
			QDomElement docElem = doc.documentElement();  //<2F><><EFBFBD>ظ<EFBFBD><D8B8>ڵ<EFBFBD>Ԫ<EFBFBD><D4AA>
			QDomNode n = docElem.firstChild(); //<2F><><EFBFBD><EFBFBD>doc<6F>ĵ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ڵ㣬<DAB5><E3A3AC>"Topic"
			while (!n.isNull()) //<2F><><EFBFBD><EFBFBD>Topic<69>ڵ㲻Ϊ<E3B2BB><CEAA> 
			{
				if (n.isElement())
				{
					QDomElement e = n.toElement(); //<2F><><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>ΪԪ<CEAA><D4AA>
					QString strTag = e.tagName(); //
					if ("ReportMap" == strTag)//zw<7A>޸<EFBFBD> 2023 - 8 - 15 <20><><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ľ<EFBFBD><C4BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>XML ԭ<><D4AD><EFBFBD><EFBFBD>RptLogCfg.iniȡ<69><C8A1>
					{
						qDebug() << "ReportEvent";
						QDomNodeList list = e.childNodes(); //<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD>ص<EFBFBD><D8B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӽڵ<D3BD><DAB5><EFBFBD><EFBFBD>б<EFBFBD>
						for (int i = 0; i < list.count(); i++) //<2F><><EFBFBD><EFBFBD> DataType<70>б<EFBFBD>
						{
							QDomNode node = list.at(i); //node1 <DataType>
							if (node.isElement())
							{
								QString strTag2 = node.toElement().tagName(); //DataType<70>ڵ<EFBFBD>
								if ("ReportEvent" == strTag2)
								{
									QDomNodeList list2 = node.childNodes(); //<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>DataType<70><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӽڵ<D3BD><DAB5><EFBFBD><EFBFBD>б<EFBFBD> 
									for (int i2 = 0; i2 < list2.count(); i2++) //<2F><><EFBFBD><EFBFBD> Monitor<6F>б<EFBFBD>
									{
										QDomNode node2 = list2.at(i2); //node2 <Monitor>
										if (node2.isElement())
										{
											rpt_cfg_strlist->append(node2.toElement().attribute("ReportControl"));
											qDebug() << node2.toElement().attribute("ReportControl").toAscii().data();
										}
									}
								}
							}

						}
					}
				}
				n = n.nextSibling();
			}

			QString log_cfg_str = "LLN0$LG$lcStatisticData,dsStatisticData,PQM1,0,600000,1,0,0,0";
			log_cfg_strlist->append(log_cfg_str);
		}
		if (strcmp(subdir, "cfg_his_data") == 0 || strcmp(subdir, "cfg_newhis_data") == 0 || strcmp(subdir, "cfg_recallhis_data") == 0 || strcmp(subdir, "cfg_recallall_data") == 0)
		{
			QString log_cfg_str = "LLN0$LG$lcStatisticData,dsStatisticData,PQM1,0,600000,1,0,0,0";
			log_cfg_strlist->append(log_cfg_str);
		}
	}
	else//<2F>ͺŲ<CDBA>Ϊ<EFBFBD>ն<EFBFBD>ȡָ<C8A1><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
	{
		QString tmppath;
		tmppath.append("/FeProject/dat/").append(tmp).append(".xml");
		qDebug() << tmppath;

		//lnk20241126<32><36><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		std::cout << "rptcfgfile:" << tmppath.toStdString() << std::endl;

		//zw<7A>޸<EFBFBD> 2023 - 8 - 15 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ľ<EFBFBD><C4BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>XML ԭ<><D4AD><EFBFBD><EFBFBD>RptLogCfg.iniȡ<69><C8A1>
		if (strcmp(subdir, "cfg_stat_data") == 0)
		{
			qDebug() << "cfg_stat_data";
			QDomDocument doc;   //<2F>½<EFBFBD>QDomDocument<6E><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>XML<4D>ĵ<EFBFBD>
			QFile file(tmppath);
			if (!file.open(QIODevice::ReadOnly | QFile::Text)) //<2F><>ֻ<EFBFBD><D6BB><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD><EFBFBD><EFBFBD>xml
			{
				qDebug() << "Read RPT Error1";		

				//lnk20241126<32><36><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				std::cout << "Read RPT Error1" << std::endl;

				return;
			}
			if (!doc.setContent(&file)) //<2F><><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>ݶ<EFBFBD><DDB6><EFBFBD>doc<6F><63>
			{
				qDebug() << "Read RPT Error2";

				//lnk20241126<32><36><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				std::cout << "Read RPT Error2" << std::endl;

				file.close();
				return;
			}
			file.close();
			QDomNode firstNode = doc.firstChild(); //<2F><><EFBFBD>ڵ<EFBFBD>"JSConfigTemplate"
			QDomElement docElem = doc.documentElement();  //<2F><><EFBFBD>ظ<EFBFBD><D8B8>ڵ<EFBFBD>Ԫ<EFBFBD><D4AA>
			QDomNode n = docElem.firstChild(); //<2F><><EFBFBD><EFBFBD>doc<6F>ĵ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ڵ㣬<DAB5><E3A3AC>"Topic"
			while (!n.isNull()) //<2F><><EFBFBD><EFBFBD>Topic<69>ڵ㲻Ϊ<E3B2BB><CEAA> 
			{
				if (n.isElement())
				{
					QDomElement e = n.toElement(); //<2F><><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>ΪԪ<CEAA><D4AA>
					QString strTag = e.tagName(); //
					if ("ReportMap" == strTag)//zw<7A>޸<EFBFBD> 2023 - 8 - 15 <20><><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ľ<EFBFBD><C4BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>XML ԭ<><D4AD><EFBFBD><EFBFBD>RptLogCfg.iniȡ<69><C8A1>
					{
						qDebug() << "ReportStat";
						QDomNodeList list = e.childNodes(); //<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD>ص<EFBFBD><D8B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӽڵ<D3BD><DAB5><EFBFBD><EFBFBD>б<EFBFBD>
						for (int i = 0; i < list.count(); i++) //<2F><><EFBFBD><EFBFBD> DataType<70>б<EFBFBD>
						{
							QDomNode node = list.at(i); //node1 <DataType>
							if (node.isElement())
							{
								QString strTag2 = node.toElement().tagName(); //DataType<70>ڵ<EFBFBD>
								if ("ReportStat" == strTag2)
								{
									QDomNodeList list2 = node.childNodes(); //<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>DataType<70><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӽڵ<D3BD><DAB5><EFBFBD><EFBFBD>б<EFBFBD> 
									for (int i2 = 0; i2 < list2.count(); i2++) //<2F><><EFBFBD><EFBFBD> Monitor<6F>б<EFBFBD>
									{
										QDomNode node2 = list2.at(i2); //node2 <Monitor>
										if (node2.isElement())
										{
											rpt_cfg_strlist->append(node2.toElement().attribute("ReportControl"));
											qDebug() << node2.toElement().attribute("ReportControl").toAscii().data();//<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
										}
									}
								}
							}

						}
					}
				}
				n = n.nextSibling();
			}

			QString log_cfg_str = "LLN0$LG$lcStatisticData,dsStatisticData,PQM1,0,600000,1,0,0,0";//<2F><>־<EFBFBD><D6BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD>
			log_cfg_strlist->append(log_cfg_str);
		}
		
		//lnk<6E><6B><EFBFBD><EFBFBD>ʵʱ<CAB5><CAB1><EFBFBD><EFBFBD>20241125
		if (strcmp(subdir, "cfg_3s_data") == 0)
		{
			qDebug() << "cfg_3s_data";
			QDomDocument doc;   //<2F>½<EFBFBD>QDomDocument<6E><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>XML<4D>ĵ<EFBFBD>
			QFile file(tmppath);
			if (!file.open(QIODevice::ReadOnly | QFile::Text)) //<2F><>ֻ<EFBFBD><D6BB><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD><EFBFBD><EFBFBD>xml
			{
				qDebug() << "Read RPT Error1";
				return;
			}
			if (!doc.setContent(&file)) //<2F><><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>ݶ<EFBFBD><DDB6><EFBFBD>doc<6F><63>
			{
				qDebug() << "Read RPT Error2";
				file.close();
				return;
			}
			file.close();
			QDomNode firstNode = doc.firstChild(); //<2F><><EFBFBD>ڵ<EFBFBD>"JSConfigTemplate"
			QDomElement docElem = doc.documentElement();  //<2F><><EFBFBD>ظ<EFBFBD><D8B8>ڵ<EFBFBD>Ԫ<EFBFBD><D4AA>
			QDomNode n = docElem.firstChild(); //<2F><><EFBFBD><EFBFBD>doc<6F>ĵ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ڵ㣬<DAB5><E3A3AC>"Topic"
			while (!n.isNull()) //<2F><><EFBFBD><EFBFBD>Topic<69>ڵ㲻Ϊ<E3B2BB><CEAA> 
			{
				if (n.isElement())
				{
					QDomElement e = n.toElement(); //<2F><><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>ΪԪ<CEAA><D4AA>
					QString strTag = e.tagName(); //
					if ("ReportMap" == strTag)//zw<7A>޸<EFBFBD> 2023 - 8 - 15 <20><><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ľ<EFBFBD><C4BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>XML ԭ<><D4AD><EFBFBD><EFBFBD>RptLogCfg.iniȡ<69><C8A1>
					{
						qDebug() << "ReportReal";
						QDomNodeList list = e.childNodes(); //<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD>ص<EFBFBD><D8B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӽڵ<D3BD><DAB5><EFBFBD><EFBFBD>б<EFBFBD>
						for (int i = 0; i < list.count(); i++) //<2F><><EFBFBD><EFBFBD> DataType<70>б<EFBFBD>
						{
							QDomNode node = list.at(i); //node1 <DataType>
							if (node.isElement())
							{
								QString strTag2 = node.toElement().tagName(); //DataType<70>ڵ<EFBFBD>
								if ("ReportReal" == strTag2)
								{
									QDomNodeList list2 = node.childNodes(); //<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>DataType<70><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӽڵ<D3BD><DAB5><EFBFBD><EFBFBD>б<EFBFBD> 
									for (int i2 = 0; i2 < list2.count(); i2++) //<2F><><EFBFBD><EFBFBD> Monitor<6F>б<EFBFBD>
									{
										QDomNode node2 = list2.at(i2); //node2 <Monitor>
										if (node2.isElement())
										{
											rpt_cfg_strlist->append(node2.toElement().attribute("ReportControl"));
											qDebug() << node2.toElement().attribute("ReportControl").toAscii().data();
										}
									}
								}
							}

						}
					}
				}
				n = n.nextSibling();
			}

			//ʵʱ<CAB5><CAB1><EFBFBD><EFBFBD>û<EFBFBD><C3BB><EFBFBD><EFBFBD>־
			//QString log_cfg_str = "LLN0$LG$lcStatisticData,dsStatisticData,PQM1,0,600000,1,0,0,0";
			//log_cfg_strlist->append(log_cfg_str);
		}
		
		if (strcmp(subdir, "cfg_soe_comtrade") == 0)
		{
			qDebug() << "cfg_soe_comtrade";
			QDomDocument doc;   //<2F>½<EFBFBD>QDomDocument<6E><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>XML<4D>ĵ<EFBFBD>
			QFile file(tmppath);
			if (!file.open(QIODevice::ReadOnly | QFile::Text)) //<2F><>ֻ<EFBFBD><D6BB><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD><EFBFBD><EFBFBD>xml
			{
				qDebug() << "Read RPT Error1";
				return;
			}
			if (!doc.setContent(&file)) //<2F><><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>ݶ<EFBFBD><DDB6><EFBFBD>doc<6F><63>
			{
				qDebug() << "Read RPT Error2";
				file.close();
				return;
			}
			file.close();
			QDomNode firstNode = doc.firstChild(); //<2F><><EFBFBD>ڵ<EFBFBD>"JSConfigTemplate"
			QDomElement docElem = doc.documentElement();  //<2F><><EFBFBD>ظ<EFBFBD><D8B8>ڵ<EFBFBD>Ԫ<EFBFBD><D4AA>
			QDomNode n = docElem.firstChild(); //<2F><><EFBFBD><EFBFBD>doc<6F>ĵ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ڵ㣬<DAB5><E3A3AC>"Topic"
			while (!n.isNull()) //<2F><><EFBFBD><EFBFBD>Topic<69>ڵ㲻Ϊ<E3B2BB><CEAA> 
			{
				if (n.isElement())
				{
					QDomElement e = n.toElement(); //<2F><><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>ΪԪ<CEAA><D4AA>
					QString strTag = e.tagName(); //
					if ("ReportMap" == strTag)//zw<7A>޸<EFBFBD> 2023 - 8 - 15 <20><><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ľ<EFBFBD><C4BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>XML ԭ<><D4AD><EFBFBD><EFBFBD>RptLogCfg.iniȡ<69><C8A1>
					{
						qDebug() << "ReportEvent";
						QDomNodeList list = e.childNodes(); //<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD>ص<EFBFBD><D8B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӽڵ<D3BD><DAB5><EFBFBD><EFBFBD>б<EFBFBD>
						for (int i = 0; i < list.count(); i++) //<2F><><EFBFBD><EFBFBD> DataType<70>б<EFBFBD>
						{
							QDomNode node = list.at(i); //node1 <DataType>
							if (node.isElement())
							{
								QString strTag2 = node.toElement().tagName(); //DataType<70>ڵ<EFBFBD>
								if ("ReportEvent" == strTag2)//<2F><><EFBFBD>ֵ<EFBFBD>
								{
									QDomNodeList list2 = node.childNodes(); //<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>DataType<70><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӽڵ<D3BD><DAB5><EFBFBD><EFBFBD>б<EFBFBD> 
									for (int i2 = 0; i2 < list2.count(); i2++) //<2F><><EFBFBD><EFBFBD> Monitor<6F>б<EFBFBD>
									{
										QDomNode node2 = list2.at(i2); //node2 <Monitor>
										if (node2.isElement())
										{
											rpt_cfg_strlist->append(node2.toElement().attribute("ReportControl"));
											qDebug() << node2.toElement().attribute("ReportControl").toAscii().data();
										}
									}
								}
							}

						}
					}
				}
				n = n.nextSibling();
			}

			QString log_cfg_str = "LLN0$LG$lcStatisticData,dsStatisticData,PQM1,0,600000,1,0,0,0";
			log_cfg_strlist->append(log_cfg_str);
		}
		if (strcmp(subdir, "cfg_his_data") == 0 || strcmp(subdir, "cfg_newhis_data") == 0 || strcmp(subdir, "cfg_recallhis_data") == 0 || strcmp(subdir, "cfg_recallall_data") == 0)
		{
			QString log_cfg_str = "LLN0$LG$lcStatisticData,dsStatisticData,PQM1,0,600000,1,0,0,0";
			log_cfg_strlist->append(log_cfg_str);
		}
		delete[] tmp;
	}
}

int parse_rpt_log_ini()
{
	const int MAX_DEV_FLAG = 10;
	bool not_loaded[MAX_DEV_FLAG];

	QMap<QString, QStringList*> rpt_cfg_strlists;
	QMap<QString, QStringList*> log_cfg_strlists;

	int			iedno, cpuno;
	ied_t* ied;
	ied_usr_t* ied_usr;
	LD_info_t* LD_info;
	char		buf[256];


	for (iedno = 0; iedno < g_node->n_clients; iedno++) {
		ied = g_node->clients[iedno];
		ied_usr = GET_IEDEXT_ADDR(ied);
		QString type;
		type.append(ied_usr->dev_type);
		if (!rpt_cfg_strlists.contains(type))
		{
			QStringList* rpt_temp = new QStringList();
			QStringList* log_temp = new QStringList();
			rpt_cfg_strlists.insert(type, rpt_temp);
			log_cfg_strlists.insert(type, log_temp);
			//g_DevFlagû<67><C3BB>ʹ<EFBFBD><CAB9>
			parse_one_rpt_log_ini(g_DevFlag, rpt_cfg_strlists[type], log_cfg_strlists[type], ied_usr->dev_type);

		}

		for (cpuno = 0; cpuno < ied->cpucount; cpuno++) {
			LD_info = &(ied_usr->LD_info[cpuno]);
			char str[256];					//256<35><36>С
			char* tmp = Get_IED(ied_usr->dev_type);
			if(tmp == NULL){std::cerr << "front read ied config error!" << std::endl;continue;}
			qDebug() << tmp << endl;

			apr_snprintf(str, sizeof(str), tmp, cpuno + 1);

			delete[] tmp;

			init_rptctrl_by_count(LD_info, rpt_cfg_strlists[type]->size());

			for (int i = 0; i < rpt_cfg_strlists[type]->size(); ++i) {

				apr_snprintf(buf, sizeof(buf), "%s", rpt_cfg_strlists[type]->at(i).toAscii().constData());

				fill_rptctrl_by_cfg(LD_info, i, buf);

			}

			init_logctrl_by_count(LD_info, log_cfg_strlists[type]->size());
			for (int i = 0; i < log_cfg_strlists[type]->size(); ++i) {
				apr_snprintf(buf, sizeof(buf), "%s", log_cfg_strlists[type]->at(i).toAscii().constData());
				char* tmp = Get_LDevice(ied_usr->dev_type);
				if(tmp == NULL){std::cerr << "front read monitor config error!" << std::endl;continue;}
				fill_logctrl_by_cfg(LD_info, i, buf, tmp);
				delete[] tmp;
			}

		}
	}

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƿ<EFBFBD><C6BF><EFBFBD><EFBFBD><EFBFBD>־<EFBFBD><D6BE><EFBFBD>ƿ鴦<C6BF><E9B4A6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	for (QMap<QString, QStringList*>::iterator it1 = log_cfg_strlists.begin(); it1 != log_cfg_strlists.end(); ++it1)
	{
		delete it1.value();
	}
	for (QMap<QString, QStringList*>::iterator it2 = rpt_cfg_strlists.begin(); it2 != rpt_cfg_strlists.end(); ++it2)
	{
		delete it2.value();
	}
	rpt_cfg_strlists.clear();
	log_cfg_strlists.clear();

	return APR_SUCCESS;
}

//̨<>˸<EFBFBD><CBB8>²<EFBFBD><C2B2><EFBFBD>///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
std::string LEDGER_UPDATE_DIR = "../etc/ledgerupdate/";

std::list<std::string> find_xml_belong_to_this_process() 
{
    char prefix[20];  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ20<32><30><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʵ<EFBFBD><CAB5><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    sprintf(prefix, "%d_%d", g_node_id, g_front_seg_index);  // <20><>g_node_id<69><64>g_front_seg_index<65><78>ʽ<EFBFBD><CABD>Ϊ<EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>

    DIR *dir = opendir(LEDGER_UPDATE_DIR.c_str());  // <20><><EFBFBD><EFBFBD>Ŀ¼
    struct dirent *entry;
    std::list<std::string> found_files;  // <20><><EFBFBD>ڴ洢<DAB4>ҵ<EFBFBD><D2B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƥ<EFBFBD><C6A5><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>

    if (dir == NULL) {
        std::cout << "Failed to open directory: " << LEDGER_UPDATE_DIR << std::endl;
        return found_files;  // <20><><EFBFBD>ؿյ<D8BF>list
    }

    // <20><><EFBFBD><EFBFBD>Ŀ¼<C4BF>е<EFBFBD><D0B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
    while ((entry = readdir(dir)) != NULL) {
        std::string filename = entry->d_name;

		// <20>ų<EFBFBD> "." <20><> ".." Ŀ¼
    	if (filename == "." || filename == "..") {
        	continue;
    	}

		std::cout << "find" << filename << "in" << LEDGER_UPDATE_DIR << std::endl;


        // <20>ж<EFBFBD><D0B6>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>Ƿ<EFBFBD><C7B7><EFBFBD> prefix <20><>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD>չ<EFBFBD><D5B9><EFBFBD><EFBFBD> .xml
        if (filename.find(prefix) == 0 && filename.substr(filename.find_last_of('.') + 1) == "xml") {
            std::string full_path = LEDGER_UPDATE_DIR + filename;
            found_files.push_back(full_path);  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>·<EFBFBD><C2B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
        }
    }

    closedir(dir);  // <20>ر<EFBFBD>Ŀ¼

    return found_files;  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ҵ<EFBFBD><D2B5><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>
}

// <20><>ȡ<EFBFBD><C8A1>ǩ<EFBFBD>е<EFBFBD>ֵ<EFBFBD><D6B5>ͨ<EFBFBD>ú<EFBFBD><C3BA><EFBFBD>
std::string extract_value(const std::string& data, const std::string& tag) {
    size_t start_pos = data.find("<" + tag + ">");
    if (start_pos == std::string::npos) return "";
    size_t end_pos = data.find("</" + tag + ">", start_pos);
    if (end_pos == std::string::npos) return "";

    return data.substr(start_pos + tag.length() + 2, end_pos - start_pos - tag.length() - 2);
}

// <20><><EFBFBD><EFBFBD> str_tag <20><> terminal <20><><EFBFBD>ӵ<EFBFBD><D3B5><EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
void add_terminal_to_trigger_update(trigger_update_xml_t* trigger_update_xml, const std::string& str_tag, const terminal& work_terminal) {
    if (str_tag == "add") {
		std::cout << "new ledger!!!!"<<std::endl;
        if (trigger_update_xml->new_update_num < MAX_UPDATEA_NUM) {
            trigger_update_xml->new_updates[trigger_update_xml->new_update_num] = work_terminal;
            trigger_update_xml->new_update_num+= 1;  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ն˵<D5B6><CBB5><EFBFBD><EFBFBD><EFBFBD>
        } else {
            std::cerr << "Exceeded MAX_UPDATEA_NUM limit for new updates!" << std::endl;
        }
    } 
    else if (str_tag == "modify") {
		std::cout << "modify ledger!!!"<<std::endl;
        if (trigger_update_xml->modify_update_num < MAX_UPDATEA_NUM) {
            trigger_update_xml->modify_updates[trigger_update_xml->modify_update_num] = work_terminal;
            trigger_update_xml->modify_update_num+= 1;  // <20><><EFBFBD><EFBFBD><EFBFBD>޸<EFBFBD><DEB8>ն˵<D5B6><CBB5><EFBFBD><EFBFBD><EFBFBD>
        } else {
            std::cerr << "Exceeded MAX_UPDATEA_NUM limit for modify updates!" << std::endl;
        }
    }
    else {
        std::cerr << "Unknown tag: " << str_tag << std::endl;
    }
}

// <20><><EFBFBD><EFBFBD> XML <20><><EFBFBD>ݲ<EFBFBD><DDB2><EFBFBD>ȡ terminal <20><>Ϣ
void parse_terminal_from_data(trigger_update_xml_t* trigger_update_xml, const std::string& str_tag, const std::string& data) {
    terminal work_terminal = {};  // <20><><EFBFBD><EFBFBD><EFBFBD>µ<EFBFBD> terminal <20><><EFBFBD><EFBFBD>

    // <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD>ֶ<EFBFBD>
    strcpy(work_terminal.terminal_id, extract_value(data, "id").c_str());
    strcpy(work_terminal.terminal_code, extract_value(data, "terminalCode").c_str());
    strcpy(work_terminal.org_name, extract_value(data, "orgName").c_str());
    strcpy(work_terminal.maint_name, extract_value(data, "maintName").c_str());
    strcpy(work_terminal.station_name, extract_value(data, "stationName").c_str());
    strcpy(work_terminal.tmnl_factory, extract_value(data, "manufacturer").c_str());
    strcpy(work_terminal.tmnl_status, extract_value(data, "status").c_str());
    strcpy(work_terminal.dev_type, extract_value(data, "devType").c_str());
    strcpy(work_terminal.dev_key, extract_value(data, "devKey").c_str());
    strcpy(work_terminal.dev_series, extract_value(data, "series").c_str());
	strcpy(work_terminal.processNo, extract_value(data, "processNo").c_str());
    strcpy(work_terminal.addr_str, extract_value(data, "ip").c_str());
    strcpy(work_terminal.port, extract_value(data, "port").c_str());
    strcpy(work_terminal.timestamp, extract_value(data, "updateTime").c_str());

    size_t monitor_pos = 0;
	size_t monitor_count = 0;

	// <20><><EFBFBD><EFBFBD>ÿ<EFBFBD><C3BF> monitorData<74><61><EFBFBD><EFBFBD><EFBFBD>ദ<EFBFBD><E0B4A6> 10 <20><>
	while ((monitor_pos = data.find("<monitorData", monitor_pos)) != std::string::npos && monitor_count < 10) {
	    monitor work_monitor = {};  // <20><><EFBFBD><EFBFBD><EFBFBD>µ<EFBFBD> monitor <20><><EFBFBD><EFBFBD>

	    // <20>ҵ<EFBFBD><D2B5><EFBFBD>ǰ monitorData <20>Ľ<EFBFBD><C4BD><EFBFBD>λ<EFBFBD><CEBB>
	    size_t monitor_end_pos = data.find("</monitorData", monitor_pos);
	    std::string monitor_data = data.substr(monitor_pos, monitor_end_pos - monitor_pos);

	    // <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD>ֶβ<D6B6><CEB2><EFBFBD><EFBFBD>䵽 work_monitor <20><>
	    std::string monitor_id = extract_value(monitor_data, "id");
	    std::string monitor_name = extract_value(monitor_data, "name");
	    std::string voltage_level = extract_value(monitor_data, "voltageLevel");
	    std::string terminal_connect = extract_value(monitor_data, "ptType");
	    std::string line_no = extract_value(monitor_data, "lineNo");
	    std::string timestamp = extract_value(monitor_data, "timestamp");
	    std::string terminal_code = extract_value(monitor_data, "terminal_code");
	    std::string status = extract_value(monitor_data, "status");

	    // <20><><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD>ݸ<EFBFBD><DDB8>Ƶ<EFBFBD> work_monitor <20>У<EFBFBD><D0A3><EFBFBD>û<EFBFBD><C3BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> "N/A"
	    strcpy(work_monitor.monitor_id, monitor_id.empty() ? "N/A" : monitor_id.c_str());
	    strcpy(work_monitor.monitor_name, monitor_name.empty() ? "N/A" : monitor_name.c_str());
	    strcpy(work_monitor.voltage_level, voltage_level.empty() ? "N/A" : voltage_level.c_str());
	    strcpy(work_monitor.terminal_connect, terminal_connect.empty() ? "N/A" : terminal_connect.c_str());
	    strcpy(work_monitor.logical_device_seq, line_no.empty() ? "N/A" : line_no.c_str());
	    strcpy(work_monitor.timestamp, timestamp.empty() ? "N/A" : timestamp.c_str());
	    strcpy(work_monitor.terminal_code, terminal_code.empty() ? "N/A" : terminal_code.c_str());
	    strcpy(work_monitor.status, status.empty() ? "N/A" : status.c_str());

	    // <20><><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1> monitor <20><><EFBFBD>ݴ<EFBFBD><DDB4><EFBFBD> work_terminal.line[monitor_count]
	    work_terminal.line[monitor_count] = work_monitor;

	    monitor_count++;  // <20><><EFBFBD><EFBFBD> monitor <20>ļ<EFBFBD><C4BC><EFBFBD>
	    monitor_pos = monitor_end_pos;  // <20>ƶ<EFBFBD> monitor_pos <20><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB> <monitorData> <20><>λ<EFBFBD><CEBB>
	}


    // <20><><EFBFBD><EFBFBD> str_tag <20><> terminal <20><><EFBFBD>ӵ<EFBFBD><D3B5><EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    add_terminal_to_trigger_update(trigger_update_xml, str_tag, work_terminal);
}

void parse_ledger_update(trigger_update_xml_t* trigger_update_xml, const std::string& strTag, const std::string& data) 
{
	std::cout << "record one xml.."<<std::endl;
    // <20><><EFBFBD><EFBFBD> strTag <20><><EFBFBD><EFBFBD>ͬ<EFBFBD><CDAC><EFBFBD><EFBFBD>
    if (strTag == "add" || strTag == "modify") {

        // <20><><EFBFBD><EFBFBD><EFBFBD>ն<EFBFBD><D5B6><EFBFBD>Ϣ
        parse_terminal_from_data(trigger_update_xml, strTag, data);

    }else if (strTag == "delete") {

        terminal delete_terminal;
        memset(&delete_terminal, 0, sizeof(delete_terminal));
        
        if (strTag == "delete") {
			// <20><><EFBFBD><EFBFBD><EFBFBD>ն<EFBFBD><D5B6><EFBFBD>Ϣ
			strcpy(delete_terminal.terminal_id, extract_value(data, "id").c_str());
            // <20><>ɾ<EFBFBD><C9BE><EFBFBD><EFBFBD>Ϣд<CFA2><D0B4> delete_updates
			std::cout << "delete ledger!!!!!"<<std::endl;
            if (trigger_update_xml->delete_update_num < MAX_UPDATEA_NUM) {
                trigger_update_xml->delete_updates[trigger_update_xml->delete_update_num] = delete_terminal;
                trigger_update_xml->delete_update_num += 1;  // <20><><EFBFBD>Ӽ<EFBFBD><D3BC><EFBFBD>
            }
		}

    } else {
        std::cerr << "Unsupported strTag: " << strTag << std::endl;
    }
}


int load_ledger_update_from_xml(trigger_update_xml_t* trigger_update_xml, const std::string& xml_fn)
{
	std::cout << "start to load one xml.."<<std::endl;
    std::ifstream file(xml_fn.c_str());  // <20><><EFBFBD><EFBFBD>XML<4D>ļ<EFBFBD>
    if (!file.is_open()) {
        std::cerr << "Failed to open file: " << xml_fn << std::endl;
        return -1;
    }

    std::string line;
    std::stringstream file_content;
    
    // <20><>ȡ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
    while (std::getline(file, line)) {
        file_content << line << "\n";
    }
    file.close();

    std::string content = file_content.str();

    // <20><><EFBFBD><EFBFBD> <ledger_update> <20><>ǩ
    size_t ledger_pos = content.find("<ledger_update>");
    if (ledger_pos == std::string::npos) {
        std::cerr << "ledger_update tag not found!" << std::endl;
        return -1;
    }

    // <20><><EFBFBD><EFBFBD> <add>, <delete>, <modify> <20><>ǩ
    size_t add_pos = content.find("<add>", ledger_pos);
    size_t delete_pos = content.find("<delete>", ledger_pos);
    size_t modify_pos = content.find("<modify>", ledger_pos);

    // ȷ<><C8B7><EFBFBD>ĸ<EFBFBD><C4B8><EFBFBD>ǩ<EFBFBD><C7A9><EFBFBD>ڣ<EFBFBD><DAA3><EFBFBD><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1>Ӧ<EFBFBD><D3A6>λ<EFBFBD><CEBB>
    size_t target_pos = std::string::npos;
    std::string target_tag;

    if (add_pos != std::string::npos) {
        target_pos = add_pos;
        target_tag = "add";
    } else if (delete_pos != std::string::npos) {
        target_pos = delete_pos;
        target_tag = "delete";
    } else if (modify_pos != std::string::npos) {
        target_pos = modify_pos;
        target_tag = "modify";
    }

	//û<>ҵ<EFBFBD><D2B5><EFBFBD>ȷ<EFBFBD>ı<EFBFBD>ǩ<EFBFBD>˳<EFBFBD><CBB3><EFBFBD><EFBFBD><EFBFBD>
    if (target_pos == std::string::npos) {
        std::cerr << "No <add>, <delete>, or <modify> tag found!" << std::endl;
        return -1;
    }

    // <20><><EFBFBD><EFBFBD>Ŀ<EFBFBD><C4BF><EFBFBD><EFBFBD>ǩ<EFBFBD>Ľ<EFBFBD><C4BD><EFBFBD>λ<EFBFBD><CEBB>
    size_t end_pos = content.find("</" + target_tag + ">", target_pos);
    if (end_pos == std::string::npos) {
        std::cerr << "Closing </" + target_tag + "> tag not found!" << std::endl;
        return -1;
    }

    // <20><>ȡĿ<C8A1><C4BF><EFBFBD><EFBFBD>ǩ<EFBFBD><C7A9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    std::string target_content = content.substr(target_pos + target_tag.length() + 2, end_pos - (target_pos + target_tag.length() + 2));

    // <20><><EFBFBD><EFBFBD> <data> <20><><EFBFBD><EFBFBD><EFBFBD>е<EFBFBD><D0B5><EFBFBD><EFBFBD><EFBFBD>
    size_t data_pos = 0;
    while ((data_pos = target_content.find("<terminalData>", data_pos)) != std::string::npos) {
        size_t data_end_pos = target_content.find("</terminalData>", data_pos);
        if (data_end_pos == std::string::npos) {
            std::cerr << "Closing </terminalData> tag not found!" << std::endl;
            return -1;
        }

        std::string data_content = target_content.substr(data_pos + 14, data_end_pos - (data_pos + 14));
        
		std::cout << "ledger data_content is " << data_content <<std::endl;

        // <20><><EFBFBD><EFBFBD>parse_ledger_update<74><65><EFBFBD><EFBFBD>̨<EFBFBD>˵<EFBFBD><CBB5><EFBFBD><EFBFBD><EFBFBD>
        parse_ledger_update(trigger_update_xml, target_tag, data_content);

        // <20>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><terminalData><3E><>ǩ<EFBFBD><C7A9>Ŀǰÿ<C7B0><C3BF><EFBFBD>ļ<EFBFBD>ֻ<EFBFBD><D6BB>һ<EFBFBD><D2BB>̨<EFBFBD><CCA8>
        data_pos = data_end_pos + 15;
    }

	std::cout << "load one xml finish"<<std::endl;

    return 0;  // <20>ɹ<EFBFBD><C9B9><EFBFBD><EFBFBD><EFBFBD>
}

int parse_ledger_update_xml(trigger_update_xml_t* trigger_update_xml)
{
	//printf("begin ledger update xml...\n");

	std::list<std::string> result = find_xml_belong_to_this_process();

    if (!result.empty()) {
        std::cout << "Found XML files:" << std::endl;
        for (std::list<std::string>::iterator it = result.begin(); it != result.end(); ++it) {
		    const std::string& filename = *it;
		    std::cout << filename << std::endl;
		    //<2F><><EFBFBD><EFBFBD>ÿ<EFBFBD><C3BF><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>ȡ<EFBFBD>նˣ<D5B6><CBA3>ж<EFBFBD><D0B6>ն<EFBFBD><D5B6>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		    apr_sleep(apr_time_from_sec(1) / 10);
		    //<2F><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD><DDB5><EFBFBD><EFBFBD>ݽṹ
		    if (!load_ledger_update_from_xml(trigger_update_xml, filename)) {
		        std::cout << "read /etc/ledgerupdate/" << filename << " success..." << std::endl;
		    }
		    //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>ɾ<EFBFBD><C9BE><EFBFBD><EFBFBD>
		    
		    if (std::remove(filename.c_str()) != 0) {
		        std::cerr << "Failed to remove file: " << filename << " Error: " << strerror(errno) << std::endl;
		        return APR_EGENERAL;
		    }
			else{
				std::cout << "remove file: " << filename << " success..." << std::endl;
			}
		}
    } 
	else {
        //std::cout << "No matching XML files found." << std::endl;//<2F><><EFBFBD>ٲ<EFBFBD><D9B2><EFBFBD>Ҫ<EFBFBD>Ĵ<EFBFBD>ӡ
		return APR_EGENERAL;
    }

	//<2F><><EFBFBD><EFBFBD><EFBFBD>ݷ<EFBFBD><DDB7>سɹ<D8B3><C9B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD>
	//printf("Modify Update Count: %d\n", trigger_update_xml->modify_update_num);
	//printf("Delete Update Count: %d\n", trigger_update_xml->delete_update_num);
	//printf("New Update Count: %d\n", trigger_update_xml->new_update_num);
	if(trigger_update_xml->modify_update_num || trigger_update_xml->delete_update_num || trigger_update_xml->new_update_num){
		printf("ledger update xml have data...\n");
		return APR_SUCCESS;
	}
	else{//<2F><><EFBFBD><EFBFBD><EFBFBD>ݷ<EFBFBD><DDB7><EFBFBD>ʧ<EFBFBD>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		printf("ledger update xml no data...\n");
		return APR_EGENERAL;
	}
		
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ʵʱ<CAB5><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
QString THREE_SECS_WEBSERVICE_DIR = QString("../etc/trigger3s/");

QString get_3s_trig_fn()
{
	QDir directory(THREE_SECS_WEBSERVICE_DIR);
	QStringList filters = QStringList() << "*.xml";
	QStringList fileNames = directory.entryList(filters, QDir::Files, QDir::Time/*|QDir::Reversed*/);
	if (fileNames.size() > 0)
		return fileNames.at(0);
	else
		return "";
}
///////////////////////////////////////////////////////////////
int getValueFromElemAttrStr(QString str)
{
	if (str == "true")
		return 1;
	else if (str == "false")
		return 0;
	else
		return -1;
}

//lnk20241125<32><35><EFBFBD>Ӵ<EFBFBD>ӡ<EFBFBD><D3A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>/////////////////////////////////////////////////////////////////////////////////////////////////
// <20><>ӡ trigger_t <20>ṹ<EFBFBD><E1B9B9><EFBFBD>ĺ<EFBFBD><C4BA><EFBFBD>
void print_trigger(const trigger_t& trigger) {
    printf("  dev_idx: %d, line_id: %d, real_data: %d, soe_data: %d, limit: %d, count: %d\n",
           trigger.dev_idx, trigger.line_id, trigger.real_data, trigger.soe_data, trigger.limit, trigger.count);
}
// <20><>ӡ trigger_3s_xml_t <20>ṹ<EFBFBD><E1B9B9><EFBFBD>ĺ<EFBFBD><C4BA><EFBFBD>
void print_trigger_3s_xml(const trigger_3s_xml_t& trigger_3s_xml) {
    printf("Work Trigger Count: %d\n", trigger_3s_xml.work_trigger_num);
    for (int i = 0; i < trigger_3s_xml.work_trigger_num; ++i) {
        printf("  Work Trigger [%d]:\n", i + 1);
        print_trigger(trigger_3s_xml.work_triggers[i]);
    }

    printf("New Trigger Count: %d\n", trigger_3s_xml.new_trigger_num);
    for (int i = 0; i < trigger_3s_xml.new_trigger_num; ++i) {
        printf("  New Trigger [%d]:\n", i + 1);
        print_trigger(trigger_3s_xml.new_triggers[i]);
    }

    printf("Delete Trigger Count: %d\n", trigger_3s_xml.delete_trigger_num);
    for (int i = 0; i < trigger_3s_xml.delete_trigger_num; ++i) {
        printf("  Delete Trigger [%d]:\n", i + 1);
        print_trigger(trigger_3s_xml.delete_triggers[i]);
    }

    printf("Modify Trigger Count: %d\n", trigger_3s_xml.modify_trigger_num);
    for (int i = 0; i < trigger_3s_xml.modify_trigger_num; ++i) {
        printf("  Modify Trigger [%d]:\n", i + 1);
        print_trigger(trigger_3s_xml.modify_triggers[i]);
    }
}

//ʵʱ<CAB5><CAB1><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void parse_3s_trigger(trigger_3s_xml_t* trigger_3s_xml, QString parentTag, QDomElement& trigger_e)
{
	QString e_atr("");
	trigger_t trigger;

	trigger.dev_idx = trigger_e.attribute("DevSeries").toInt();
	trigger.line_id = trigger_e.attribute("Line").toInt();

	e_atr = trigger_e.attribute("RealData").toLower();
	trigger.real_data = getValueFromElemAttrStr(e_atr);

	e_atr = trigger_e.attribute("SOEData").toLower();
	trigger.soe_data = getValueFromElemAttrStr(e_atr);

	trigger.limit = trigger_e.attribute("Limit").toInt();
	trigger.count = trigger_e.attribute("Count").toInt();
	//qDebug()<<parentTag << "-> " << dev_idx<<" "<<line_id<<" "<<real_data<<" "<<soe_data <<" " <<  limit<<" " << count;

	if (parentTag == "Work") {
		trigger_3s_xml->work_triggers[trigger_3s_xml->work_trigger_num++] = trigger;
	}
	else if (parentTag == "New") {
		trigger_3s_xml->new_triggers[trigger_3s_xml->new_trigger_num++] = trigger;
	}
	else if (parentTag == "Delete") {
		trigger_3s_xml->delete_triggers[trigger_3s_xml->delete_trigger_num++] = trigger;
	}
	else if (parentTag == "Modify") {
		trigger_3s_xml->modify_triggers[trigger_3s_xml->modify_trigger_num++] = trigger;
	}
	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>lnk20241125
	print_trigger_3s_xml(*trigger_3s_xml);

}

int load_3s_data_from_xml(trigger_3s_xml_t* trigger_3s_xml, QString xml_fn)
{
	QDomDocument doc;   //<2F>½<EFBFBD>QDomDocument<6E><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>XML<4D>ĵ<EFBFBD>
	QFile file(xml_fn);
	if (!file.open(QIODevice::ReadOnly))
		return APR_EBADPATH;  //<2F><>ֻ<EFBFBD><D6BB><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD><EFBFBD><EFBFBD>
	bool ret = doc.setContent(&file);
	file.close();
	if (!ret)
		return APR_EBADF;

	//<2F><><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>ݶ<EFBFBD><DDB6><EFBFBD>doc<6F><63>
	QDomElement docElem = doc.documentElement();  //<2F><><EFBFBD>ظ<EFBFBD>Ԫ<EFBFBD><D4AA>  
	QDomNode n = docElem.firstChild();   //<2F><><EFBFBD>ظ<EFBFBD><D8B8>ڵ<EFBFBD><DAB5>ĵ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ӽڵ<D3BD> 
	while (!n.isNull()) {   //<2F><><EFBFBD><EFBFBD><EFBFBD>ڵ㲻Ϊ<E3B2BB><CEAA>  
		if (n.isElement()) {   //<2F><><EFBFBD><EFBFBD><EFBFBD>ڵ<EFBFBD><DAB5><EFBFBD>Ԫ<EFBFBD><D4AA>  	
			QDomElement e = n.toElement();  //<2F><><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>ΪԪ<CEAA><D4AA>  
			QString strTag = e.tagName();
			if (strTag == "Work" || strTag == "New" || strTag == "Delete" || strTag == "Modify") {
				QDomNodeList list = e.childNodes(); //<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>e<EFBFBD><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӽڵ<D3BD><DAB5><EFBFBD><EFBFBD>б<EFBFBD>  
				for (int i = 0; i < list.count(); i++) {  //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD>  				
					QDomNode node = list.at(i);
					if (node.isElement()) {
						QDomElement trigger_e = node.toElement();
						QString strTag2 = trigger_e.tagName();
						if (strTag2 == "Trigger") {
							parse_3s_trigger(trigger_3s_xml, strTag, trigger_e);
						} //else if ( strTag == "Trigger" )
					}
				}
			}
		}
		n = n.nextSibling();  //<2F><>һ<EFBFBD><D2BB><EFBFBD>ֵܽڵ<DCBD>
	}

	return APR_SUCCESS;
}

QString BAK_WEBSERVICE_3S_TRIG_COMMAND_XML_FN = THREE_SECS_WEBSERVICE_DIR + "bak_3s_trig_command.txt";
int parse_3s_xml(trigger_3s_xml_t* trigger_3s_xml)
{
	printf("begin 3s xml...\n");
	memset(trigger_3s_xml, 0, sizeof(trigger_3s_xml_t));

	//<2F><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>¼<EFBFBD><C2BC><EFBFBD>ڽ<EFBFBD><DABD><EFBFBD><EFBFBD>е<EFBFBD>ʵʱ<CAB5><CAB1><EFBFBD><EFBFBD>
	QString cfg_dir = QString("../")/*+QString::fromAscii(subdir)*/ + QString("etc/");
	load_3s_data_from_xml(trigger_3s_xml, (cfg_dir + THREE_SECS_CONFIG_FN));	//<2F><><EFBFBD><EFBFBD>/Feproject/etc/Trigger3S.xml

	QString the_webservice_xml_fn = get_3s_trig_fn();//  ../etc/trigger3s/Ŀ¼<C4BF>µ<EFBFBD><C2B5><EFBFBD><EFBFBD>µ<EFBFBD>xml<6D>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʵʱ<CAB5><CAB1><EFBFBD><EFBFBD><EFBFBD>Ŀ<EFBFBD><C4BF><EFBFBD>

	printf("the_webservice_xml_fn.size():%d\n",the_webservice_xml_fn.size());

	if (the_webservice_xml_fn.size() > 4) {//<2F>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>4˵<34><CBB5><EFBFBD>ҵ<EFBFBD><D2B5>ļ<EFBFBD>
		apr_sleep(apr_time_from_sec(1) / 10);
		the_webservice_xml_fn = THREE_SECS_WEBSERVICE_DIR + the_webservice_xml_fn;
		load_3s_data_from_xml(trigger_3s_xml, the_webservice_xml_fn);
		QFile::remove(BAK_WEBSERVICE_3S_TRIG_COMMAND_XML_FN);
		QFile::rename(the_webservice_xml_fn, BAK_WEBSERVICE_3S_TRIG_COMMAND_XML_FN);

		printf("/etc/trigger3s/*.xml success...\n");
		return APR_SUCCESS;
	}

	printf("3s xml fail...\n");
	return APR_EGENERAL;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//3s<33><73><EFBFBD><EFBFBD><EFBFBD><EFBFBD>¼д<C2BC><D0B4><EFBFBD>ļ<EFBFBD>
void append_triggers(QDomDocument& doc, QDomElement& root, QString parentTag, trigger_t* trigger, int trigger_num)
{
	QString str;
	QDomElement funcItem = doc.createElement(parentTag);
	root.appendChild(funcItem);
	for (int i = 0; i < trigger_num; i++) {
		if (trigger[i].dev_idx == INVALID_DEV_IDX)
			continue;
		if (trigger[i].real_data == 0 && trigger[i].soe_data == 0)
			continue;
		QDomElement triggerItem = doc.createElement("Trigger");
		triggerItem.setAttribute("DevSeries", trigger[i].dev_idx);
		triggerItem.setAttribute("Line", trigger[i].line_id);
		str = trigger[i].real_data ? "true" : "false";
		triggerItem.setAttribute("RealData", str);
		str = trigger[i].soe_data ? "true" : "false";
		triggerItem.setAttribute("SOEData", str);
		triggerItem.setAttribute("Limit", trigger[i].limit);
		triggerItem.setAttribute("Count", trigger[i].count);
		funcItem.appendChild(triggerItem);
	}
}

int create_3s_xml(trigger_3s_xml_t* trigger_3s_xml)
{

	QDomDocument doc;
	doc.appendChild(doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"gb2312\""));

	QDomElement root = doc.createElement("Trigger3S");
	doc.appendChild(root);

	append_triggers(doc, root, "Work", trigger_3s_xml->work_triggers, trigger_3s_xml->work_trigger_num);
	append_triggers(doc, root, "New", trigger_3s_xml->new_triggers, 0);
	append_triggers(doc, root, "Delete", trigger_3s_xml->delete_triggers, 0);
	append_triggers(doc, root, "Modify", trigger_3s_xml->modify_triggers, 0);

	QString cfg_dir = QString("../")/*+QString::fromAscii(subdir)*/ + QString("etc/");
	QFile file(cfg_dir + THREE_SECS_CONFIG_FN /*+".bak.xml"*/);
	if (!file.open(QIODevice::ReadWrite | QIODevice::Truncate | QIODevice::Text)) {
		return -1;
	}
	QTextStream out(&file);
	out.setCodec("gb2312");
	doc.save(out, 4);
	file.close();

	return APR_SUCCESS;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ܣ<EFBFBD><DCA3><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD> .cfg <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1>ʼʱ<CABC><CAB1><EFBFBD>ʹ<EFBFBD><CDB4><EFBFBD>ʱ<EFBFBD>䣬<EFBFBD><E4A3AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>Ϊ<EFBFBD><CEAA><EFBFBD>뼶ʱ<EBBCB6><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//    - comtrade_fn<66><6E><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD>ο<EFBFBD><CEBF><EFBFBD><EFBFBD>ڶ<EFBFBD>λ<EFBFBD><CEBB>Ӧ<EFBFBD><D3A6> .cfg <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//    - start_tm<74><6D><EFBFBD><EFBFBD><EFBFBD>ص<EFBFBD><D8B5><EFBFBD>ʼʱ<CABC><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD>룩<EFBFBD><EBA3A9>
//    - trig_tm<74><6D><EFBFBD><EFBFBD><EFBFBD>صĴ<D8B5><C4B4><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD>룩<EFBFBD><EBA3A9>
// <20><><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5>
//    - <20><><EFBFBD><EFBFBD> APR_SUCCESS <20><>ʾ<EFBFBD>ɹ<EFBFBD><C9B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> APR_EBADF <20><>ʾ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int extract_timestamp_from_cfg_file(char* comtrade_fn, long long* start_tm, long long* trig_tm)
{
    // <20><>ȡ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>Ϣ<EFBFBD><CFA2>·<EFBFBD><C2B7><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>ȡ
    QFileInfo fi(QString::fromAscii(comtrade_fn));
    QString fn = fi.fileName();
    QString cfgFileName_temp = QString("../comtrade/") + fn;  // ƴ<><C6B4>.cfg<66>ļ<EFBFBD><C4BC><EFBFBD>·<EFBFBD><C2B7>

    // <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC>Ƿ<EFBFBD><C7B7><EFBFBD> ".cfg" <20><> ".CFG" <20><>β
    if (!cfgFileName_temp.endsWith(".cfg", Qt::CaseInsensitive) && !cfgFileName_temp.endsWith(".CFG", Qt::CaseInsensitive))
        return APR_EBADF;  // <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD>󣬷<EFBFBD><F3A3ACB7><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>

    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
    QFile cfgFile_temp(cfgFileName_temp);
    if (!cfgFile_temp.exists()) {  // <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
        qDebug() << QString("Cannot find corresponding .cfg file: %1").arg(cfgFileName_temp);
        cfgFile_temp.close();
        return APR_EBADF;
    }
    else if (!cfgFile_temp.open(QFile::ReadOnly | QFile::Text)) {  // <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC>޷<EFBFBD><DEB7><EFBFBD><EFBFBD><EFBFBD>
        qDebug() << QString("Cannot open file %1:\n%2.").arg(cfgFileName_temp).arg(cfgFile_temp.errorString());
        return APR_EBADF;
    }
    else {
        QStringList datContentList_temp;
        QTextStream in_temp(&cfgFile_temp);  // <20><><EFBFBD><EFBFBD><EFBFBD>ı<EFBFBD><C4B1><EFBFBD><EFBFBD><EFBFBD>ȡ<EFBFBD>ļ<EFBFBD>
        // <20><><EFBFBD><EFBFBD> GBK <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>صĴ<D8B5><C4B4>루<EFBFBD><EBA3A8>ע<EFBFBD>͵<EFBFBD><CDB5>ˣ<EFBFBD>

        QString start_time_str("");  // <20><><EFBFBD>ڴ洢<DAB4><E6B4A2>ʼʱ<CABC><CAB1><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>
        QString trigger_time_str("");  // <20><><EFBFBD>ڴ洢<DAB4><E6B4A2><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>

        // <20><><EFBFBD>ж<EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
        while (!in_temp.atEnd()) {
            QString line_temp = in_temp.readLine().trimmed();  // <20><>ȡ<EFBFBD><C8A1>ȥ<EFBFBD><C8A5><EFBFBD>հ<EFBFBD><D5B0>ַ<EFBFBD>
            QString upper_line_temp = line_temp.toUpper();  // ת<><D7AA>Ϊ<EFBFBD><CEAA>д<EFBFBD>ַ<EFBFBD>

            // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1> "ASCII" <20><> "BINARY" <20>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֹͣ<CDA3><D6B9><EFBFBD><EFBFBD>
            if ((upper_line_temp == QString("ASCII")) || (upper_line_temp == QString("BINARY")))
                break;
            else {
                // <20><><EFBFBD><EFBFBD>û<EFBFBD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼʱ<CABC><CAB1><EFBFBD>ʹ<EFBFBD><CDB4><EFBFBD>ʱ<EFBFBD><CAB1>
                start_time_str = trigger_time_str;
                trigger_time_str = line_temp;
            }
        }

        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD> start_time_str <20><><EFBFBD>ȴ<EFBFBD><C8B4><EFBFBD>3<EFBFBD><33><EFBFBD><EFBFBD>ȥ<EFBFBD><C8A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>3<EFBFBD><33><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>ͨ<EFBFBD><CDA8><EFBFBD>Ǻ<EFBFBD><C7BA>벿<EFBFBD>֣<EFBFBD>
        if (start_time_str.size() > 3)
            start_time_str = start_time_str.left(start_time_str.size() - 3);

        // <20><> start_time_str ת<><D7AA>Ϊ QDateTime <20><><EFBFBD>󣬲<EFBFBD>ת<EFBFBD><D7AA>Ϊ<EFBFBD>Լ<EFBFBD>Ԫ<EFBFBD><D4AA><EFBFBD><EFBFBD><EFBFBD>ĺ<EFBFBD><C4BA><EFBFBD><EFBFBD><EFBFBD>
        QDateTime start_time_dt = QDateTime::fromString(start_time_str, "dd/MM/yyyy,hh:mm:ss.zzz");
        *start_tm = start_time_dt.toMSecsSinceEpoch();  // ת<><D7AA>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5> start_tm

        // ͬ<><CDAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD>䣨ȥ<E4A3A8><C8A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>3<EFBFBD><33><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>ת<EFBFBD><D7AA>Ϊʱ<CEAA><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
        if (trigger_time_str.size() > 3)
            trigger_time_str = trigger_time_str.left(trigger_time_str.size() - 3);

        QDateTime trigger_time_dt = QDateTime::fromString(trigger_time_str, "dd/MM/yyyy,hh:mm:ss.zzz");
        *trig_tm = trigger_time_dt.toMSecsSinceEpoch();  // ת<><D7AA>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5> trig_tm

        cfgFile_temp.close();  // <20>ر<EFBFBD><D8B1>ļ<EFBFBD>
    }
    
    return APR_SUCCESS;  // <20>ɹ<EFBFBD><C9B9><EFBFBD><EFBFBD><EFBFBD>
}

//¼<><C2BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>///////////////////////////////////////////////////////////////////////////////
//WW 2023-11-01 <20><><EFBFBD><EFBFBD>¼<EFBFBD><C2BC><EFBFBD>κŲ<CEBA><C5B2><EFBFBD>int<6E><74><EFBFBD><EFBFBD>ƥ<EFBFBD><C6A5>
int parse_file_names_by_fltnum(int fltnum, char* domname, char** filenames, int filenum, int* cfg_idx, int* dat_idx, char* file_base_name, char* file_yyyymm)
{
	int j;
	printf(">>>>>>>>>>>>>>>>>>pares_file_names file list match fltnum=%d", fltnum);

	*cfg_idx = -1;
	*dat_idx = -1;
	for (j = 0; j < filenum; ++j) {

		char fileNameTemp[64];
		strcpy(fileNameTemp, filenames[j]); //<2F><>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD> װ<><D7B0>¼<EFBFBD><C2BC><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>
		printf(" %s ", fileNameTemp);
		if (strstr(fileNameTemp, domname) == NULL) //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:"PQMonitor_PQM1" <20><><EFBFBD><EFBFBD> װ<><D7B0>¼<EFBFBD><C2BC><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>:"PQMonitor_PQM1_000001_20191121_154534_689.CFG/.DAT/.HDR"<22><><EFBFBD>Ӵ<EFBFBD>
			continue;
		char* p = strtok(fileNameTemp, "_"); //PQMonitor
		p = strtok(NULL, "_"); //PQM1
		p = strtok(NULL, "_"); //000001
		int nFltNum = atoi(p); //<2F><><EFBFBD>ַ<EFBFBD>ת<EFBFBD><D7AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

		if (nFltNum == fltnum) {

			QString fn_str = QString::fromAscii(filenames[j]);
			if (fn_str.endsWith(".cfg", Qt::CaseInsensitive) || fn_str.endsWith(".CFG", Qt::CaseInsensitive)) {
				//PQMonitor_PQM4_000349_20180531_113701_618.CFG
				*cfg_idx = j;

				QFileInfo fi(fn_str);
				QString fn = fi.baseName();
				strcpy(file_base_name, fn.toAscii().data());

				QString remain_str = fn_str.split(QString::fromAscii(p)).at(1);
				QString yyyymm_str = remain_str.mid(1, 6);
				strcpy(file_yyyymm, yyyymm_str.toAscii().data());
			}
			else if (fn_str.endsWith(".dat", Qt::CaseInsensitive) || fn_str.endsWith(".DAT", Qt::CaseInsensitive))
				*dat_idx = j;

		}
		if (*cfg_idx != -1 && *dat_idx != -1)//<2F><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>Ѿ<EFBFBD><D1BE>ҵ<EFBFBD>
			break;
	}

	printf("\n<<<<<<<<<<<<<<<<<<<<<pares_file_names file list match end cfg_inx=%d dat_idx=%d  \n", *cfg_idx, *dat_idx);
	if ((*cfg_idx) >= 0 && (*dat_idx) >= 0)
		return APR_SUCCESS;
	else
		return APR_EBADF;
}
//WW2023-11-01 end

//<2F><><EFBFBD>в<EFBFBD><D0B2><EFBFBD>////////////////////////////////////////////////////////////////////////////////
void parse_recall(recall_xml_t* recall_xml, QString parentTag, QDomElement& recall_e, char* id)
{
	recall_t recall;

	recall.line_id = id;

	QDateTime start_dt = QDateTime::fromString(recall_e.attribute("StartTime"), "yyyy-MM-dd hh:mm:ss");
	recall.start_time = start_dt.toMSecsSinceEpoch() / 1000;
	QDateTime end_dt = QDateTime::fromString(recall_e.attribute("EndTime"), "yyyy-MM-dd hh:mm:ss");
	recall.end_time = end_dt.toMSecsSinceEpoch() / 1000;

	recall.need_steady = recall_e.attribute("STEADY").toInt();
	recall.need_voltage = recall_e.attribute("VOLTAGE").toInt();

	qDebug() << parentTag << "-> " << " " << recall.line_id << " " << recall.need_steady << " " << recall.need_voltage
		<< " " << recall.start_time << " " << recall.end_time;

	if (parentTag == "Work") {
		recall_xml->work_recalls[recall_xml->work_recall_num++] = recall;
	}
	else if (parentTag == "New") {
		recall_xml->new_recalls[recall_xml->new_recall_num++] = recall;
	}
}

int delete_recall_xml(char* id)
{
	QString cfg_dir = QString("../")/*+QString::fromAscii(subdir)*/ + QString("etc/recall");
	QString file_name = QString(subdir) + QString("_") + QString(QString::number(g_front_seg_index, 10)) + QString("_") + QString(id) + QString("_") + QString("*") + QString("_Recall.xml");

	//ָ<><D6B8><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
	QDir dir(cfg_dir);
	if (!dir.exists()) {
		qDebug() << "folder does not exist!";
		return false;
	}
	//ָ<><D6B8><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>׺<EFBFBD><D7BA><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	QStringList filter(file_name);
	//ָ<><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͺ<EFBFBD><CDBA><EFBFBD><EFBFBD>򣬰<EFBFBD><F2A3ACB0><EFBFBD><EFBFBD>µ<EFBFBD><C2B5>޸<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>ȡ
	QStringList files = dir.entryList(filter, QDir::Files | QDir::Readable | QDir::NoDotAndDotDot, QDir::Name | QDir::Time);
	for (int i = 0; i < files.size(); i++) {//<2F><><EFBFBD>ն<EFBFBD>ȡ<EFBFBD>ļ<EFBFBD>
		QString qstrRecallPath = cfg_dir + QString("/") + files[i];
		QFile::remove(qstrRecallPath);
	}
	return APR_SUCCESS;
}

int parse_recall_xml(recall_xml_t* recall_xml, char* id)
{

	QString cfg_dir = QString("../")/*+QString::fromAscii(subdir)*/ + QString("etc/recall");
	QString file_name = QString(subdir) + QString("_") + QString(QString::number(g_front_seg_index, 10)) + QString("_") + QString(id) + QString("_") + QString("*") + QString("_Recall.xml");
	//lnk20241225<32><35><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>
	//ָ<><D6B8><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
	QDir dir(cfg_dir);
	if (!dir.exists()) {
		qDebug() << "folder does not exist!";
		return false;
	}
	//ָ<><D6B8><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>׺<EFBFBD><D7BA><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	QStringList filter(file_name);
	//ָ<><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͺ<EFBFBD><CDBA><EFBFBD><EFBFBD>򣬰<EFBFBD><F2A3ACB0><EFBFBD><EFBFBD>µ<EFBFBD><C2B5>޸<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>ȡ
	QStringList files = dir.entryList(filter, QDir::Files | QDir::Readable | QDir::NoDotAndDotDot, QDir::Name | QDir::Time);
	for (int i = 0; i < files.size(); i++) {
		QString qstrRecallPath = cfg_dir + QString("/") + files[i];
		qDebug() << qstrRecallPath;

		QDomDocument doc;   //<2F>½<EFBFBD>QDomDocument<6E><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>XML<4D>ĵ<EFBFBD>
		QFile file(qstrRecallPath);
		if (!file.open(QIODevice::ReadOnly))
		{
			qDebug() << "file.open error";
			continue;  //<2F><>ֻ<EFBFBD><D6BB><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD><EFBFBD><EFBFBD>
		}
		bool ret = doc.setContent(&file);
		file.close();
		if (!ret)
		{
			qDebug() << "doc.setContent error";
			continue;
		}
		//<2F><><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>ݶ<EFBFBD><DDB6><EFBFBD>doc<6F><63>
		QDomElement docElem = doc.documentElement();  //<2F><><EFBFBD>ظ<EFBFBD>Ԫ<EFBFBD><D4AA>  
		QDomNode n = docElem.firstChild();   //<2F><><EFBFBD>ظ<EFBFBD><D8B8>ڵ<EFBFBD><DAB5>ĵ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ӽڵ<D3BD> 
		while (!n.isNull()) {   //<2F><><EFBFBD><EFBFBD><EFBFBD>ڵ㲻Ϊ<E3B2BB><CEAA>  
			if (n.isElement()) {   //<2F><><EFBFBD><EFBFBD><EFBFBD>ڵ<EFBFBD><DAB5><EFBFBD>Ԫ<EFBFBD><D4AA>  	
				QDomElement e = n.toElement();  //<2F><><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>ΪԪ<CEAA><D4AA>  
				QString strTag = e.tagName();
				if (strTag == "Work" || strTag == "New") {
					QDomNodeList list = e.childNodes(); //<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>e<EFBFBD><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӽڵ<D3BD><DAB5><EFBFBD><EFBFBD>б<EFBFBD>  
					for (int i = 0; i < list.count(); i++) {  //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD>  				
						QDomNode node = list.at(i);
						if (node.isElement()) {
							QDomElement  recall_e = node.toElement();
							QString strTag2 = recall_e.tagName();
							if (strTag2 == "Recall") {
								parse_recall(recall_xml, strTag, recall_e, id);
							} //else if ( strTag == "Trigger" )
						}
					}
				}
			}
			n = n.nextSibling();  //<2F><>һ<EFBFBD><D2BB><EFBFBD>ֵܽڵ<DCBD>
		}
	}

	return APR_SUCCESS;
}

void process_recall_config(recall_xml_t* recall_xml)
{
	int			i, j;
	recall_t* recall;
	recall_t* recall_work;
	int			recall_num;
	int			need_write_file;
	QList<RecallInfo> recallinfo_list_hour;               //<2F><><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>-<2D><>СʱΪ<CAB1><CEAA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

	need_write_file = FALSE;
	recall = recall_xml->new_recalls;
	recall_num = recall_xml->new_recall_num;
	for (i = 0; i < recall_num; i++) {
		recall_xml->work_recalls[recall_xml->work_recall_num++] = recall[i];
		need_write_file = TRUE;
	}

	recall = recall_xml->work_recalls;
	recall_num = recall_xml->work_recall_num;

	if (recall_num > 0) {
		LD_info_t* LD_info = find_LD_info_only_from_mp_id(recall[0].line_id);
		printf("\n recall[0].line_id == %s \n", recall[0].line_id);
		printf("\n recall[0].start_time == %d \n", recall[0].start_time);
		if (LD_info == NULL || LD_info->read_flag == 0) {
			printf("\n recall[0].line_id == NULL \n");
			printf("\n Find LD_info == null \n");
		}
		else {
			printf("\n Find LD_info != null \n");
			if (LD_info->autorecallflag != 0 || LD_info->autorecallcount == 0) {	//
				if (LD_info->autorecallcount != 0) {
					for (int j = 0; j < LD_info->autorecallcount; j++) {
						delete LD_info->autorecall[j];
					}
					delete LD_info->autorecall;
					LD_info->autorecallcount = 0;
				}
				LD_info->autorecallcount = recall_num;
				LD_info->autorecall = new autorecall_t * [recall_num];
				for (int j = 0; j < recall_num; j++) {
					printf("\n %d ===== %d\n", recall[j].start_time, recall[j].end_time);
					LD_info->autorecall[j] = new autorecall_t[1];
					LD_info->autorecall[j]->start = recall[j].start_time;

					LD_info->autorecall[j]->end = recall[j].end_time;

					//lnk20241030<33><30><EFBFBD>䲹<EFBFBD><E4B2B9><EFBFBD><EFBFBD>̬<EFBFBD><CCAC>̬<EFBFBD><CCAC>־<EFBFBD><D6BE>ÿ<EFBFBD><C3BF><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>кܶ<D0BA><DCB6><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>¼
					LD_info->autorecall[j]->need_steady = recall[j].need_steady;
					LD_info->autorecall[j]->need_voltage = recall[j].need_voltage;

				}
				LD_info->autorecallflag = 0;


			}
		}
	}

}

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

void WebSocketThread::run()
{
	//if (g_node_id != THREE_SECS_DATA_BASE_NODE_ID)
	//	return;

	printf("WebSocketThread::run() is called ...... \n");
	struct sockaddr_in client_sockaddr;
	memset(&client_sockaddr, 0, sizeof(client_sockaddr));
	socklen_t address_len = 0;
	while (1) {
		address_len = sizeof(struct sockaddr_in);
		int client_socket = accept(server_socket, (struct sockaddr*)&client_sockaddr, &address_len);
		if (client_socket == -1)
		{
			printf("accept client %s:%d failed,error msg=%s\n\a", inet_ntoa(client_sockaddr.sin_addr), htons(client_sockaddr.sin_port), strerror(errno));
			continue;
		}
		printf("\naccept client %s:%d succes<65><73>address_len= %d<><64>client_socket= %d\n", inet_ntoa(client_sockaddr.sin_addr), htons(client_sockaddr.sin_port), address_len, client_socket);

		char buffer[256];
		int iRet = 0;
		while (1) {
			memset(buffer, 0, sizeof(buffer));
			int recvLength = recv(client_socket, buffer, sizeof(buffer), 0);
			if (recvLength > 0)
			{
				iRet = HandleReceiveMessage(client_socket, buffer);

				//if (0 != iRet)
				//	iRet = SendMessageToWeb(client_socket, iRet);
				break;
			}
			else
			{
				if (errno == EINTR)
					continue;
				printf("end socket client %d(%s:%d) msg,disconnetc Socket client\n", client_socket, inet_ntoa(client_sockaddr.sin_addr), htons(client_sockaddr.sin_port));
				break;
			}
		}

		close(client_socket);
		printf("close socket client %d(%s:%d) \n", client_socket, inet_ntoa(client_sockaddr.sin_addr), htons(client_sockaddr.sin_port));
		msleep(1);
	}

	close(server_socket);
	return;
}

string MatchErrorMessage(int errorCode) //<2F><><EFBFBD>ݴ<EFBFBD><DDB4><EFBFBD><EFBFBD><EFBFBD>ƥ<EFBFBD><C6A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
{
	string strErrorMessage = "";
	switch (errorCode)
	{
	case 0:
		strErrorMessage = "success"; //"<22>ɹ<EFBFBD>"
		break;
	default:
		strErrorMessage = "error"; //"<22><><EFBFBD><EFBFBD>";
		break;
		//case 10002:
		//	strErrorMessage = "Incorrect message length structure"; //"<22><><EFBFBD>ij<EFBFBD><C4B3>Ƚṹ<C8BD><E1B9B9><EFBFBD><EFBFBD>";
		//	break;
		//case 10003:
		//	strErrorMessage = "JSON string parsing error"; //"JSON<4F>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
		//	break;
		//case 10004:
		//	strErrorMessage = "Socket handling error"; //"socket<65><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣";
		//	break;
		//case 10005:
		//	strErrorMessage = "The device corresponding to ID was not found"; //"ID<49><44>Ӧ<EFBFBD><D3A6>װ<EFBFBD><D7B0>δ<EFBFBD>ҵ<EFBFBD>";
		//	break;
		//case 10006:
		//	strErrorMessage = "The monitoring point corresponding to ID has not been found"; //"ID<49><44>Ӧ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>δ<EFBFBD>ҵ<EFBFBD>";
		//	break;
		//case 10007:
		//	strErrorMessage = "Wrong parameter passed in"; //"<22><><EFBFBD><EFBFBD><EFBFBD>IJ<EFBFBD><C4B2><EFBFBD><EFBFBD>쳣";
		//	break;
		//case 10008:
		//	strErrorMessage = "The same type of operation is being performed"; //"<22><>ͬһ<CDAC><D2BB><EFBFBD>͵IJ<CDB5><C4B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD><D6B4>";
		//	break;
		//case 10009:
		//	strErrorMessage = "The device turned off the corresponding function"; //"װ<>ùر<C3B9><D8B1>˶<EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD><EFBFBD>";
		//	break;
		//case 10010:
		//	strErrorMessage = "The TYPE parameter passed in is exceptional"; //"<22><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>TYPE<50><45><EFBFBD><EFBFBD><EFBFBD>쳣";
		//	break;
		//default:
		//	strErrorMessage = "An unknown error"; //"δ֪<CEB4><D6AA><EFBFBD><EFBFBD>";
		//	break;
	}

	return strErrorMessage;
}

int SendMessageToWeb(int socketClient, int iErrorCode) //<2F><>Web Socket<65>ͻ<EFBFBD><CDBB>˷<EFBFBD><CBB7><EFBFBD><EFBFBD><EFBFBD>Ϣ
{
	string strSendJson = "";
	char cTemp[8];
	string strErrorCode = "";
	sprintf(cTemp, "%06d", iErrorCode);
	strErrorCode = cTemp;
	char sendBuffer[256];
	int sendLength = 0;

	string strErrorMessage = MatchErrorMessage(iErrorCode);
	//if (2 == Log_Enable)
	//	printf("<22><><EFBFBD><EFBFBD><EFBFBD>룺%d<><64>ƥ<EFBFBD>䵽<EFBFBD><E4B5BD><EFBFBD><EFBFBD>Ϣ<EFBFBD><CFA2>%s\n", iErrorCode, strErrorMessage.c_str());

	strSendJson = "{\"errors\":\"" + strErrorMessage + "\",\"status\":\"" + strErrorCode + "\"}";
	strcpy(sendBuffer, strSendJson.c_str());
	sendLength = send(socketClient, strSendJson.c_str(), strSendJson.length() + 1, 0);
	if (-1 == sendLength)
	{
		printf("server to client[%d] send[%d] message error,error message:%s\n", socketClient, iErrorCode, strSendJson.c_str());
		return -1;
	}

	//if (1 == Log_Enable)
	//	printf("<22><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͻ<EFBFBD><CDBB><EFBFBD>%d<><64><EFBFBD><EFBFBD>[%d]<5D><>Ϣ<EFBFBD><CFA2>%s\n", socketClient, iErrorCode, sendBuffer);

	return sendLength;
}

int ExecuteWebCommand(LD_info_t* LD_info, int iType) //ִ<><D6B4>Web Socket<65><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
{
	try
	{
		//if (1 == Log_Enable)
		//	printf(">>><3E><>·%d<><64>\"%s\"<22><>iType= %d<><64>real_data= %s<><73>soe_data= %s<><73>limit= %d<><64>count= %d\n", LD_info->line_id, LD_info->name,
		//		iType, 0 == LD_info->real_data ? "False" : "True", 0 == LD_info->soe_data ? "False" : "True", 20, LD_info->count);

		if (0 == iType || 1 == iType)
		{
			LD_info->count = 0;
			if (0 == iType)
			{
				LD_info->real_data = 1;
				LD_info->soe_data = 1;
				//if (1 == Log_Enable)
				//	printf(">>><3E><><EFBFBD><EFBFBD>%d<><64>\"%s\"<22><>iType= %d<><64>real_data= %s<><73>soe_data= %s<><73>limit= %d<><64>count= %d\n", LD_info->line_id, LD_info->name,
				//		iType, 0 == LD_info->real_data ? "False" : "True", 0 == LD_info->soe_data ? "False" : "True", 20, LD_info->count);
			}
			else
			{
				//LD_info->heart_beat = 1;
				//if (1 == Log_Enable)
				//	printf(">>><3E><><EFBFBD><EFBFBD>%d<><64>\"%s\"<22><>iType= %d<><64>real_data= %s<><73>soe_data= %s<><73>limit= %d<><64>count= %d\n", LD_info->line_id, LD_info->name,
				//		iType, 0 == LD_info->real_data ? "False" : "True", 0 == LD_info->soe_data ? "False" : "True", 20, LD_info->count);
			}
		}

		if (2 == iType)
		{
			LD_info->real_data = 0;
			LD_info->soe_data = 0;
			//if (1 == Log_Enable)
			//	printf(">>>ֹͣ%d<><64>\"%s\"<22><>iType= %d<><64>real_data= %s<><73>soe_data= %s<><73>limit= %d<><64>count= %d\n", LD_info->line_id, LD_info->name,
			//		iType, 0 == LD_info->real_data ? "False" : "True", 0 == LD_info->soe_data ? "False" : "True", 20, LD_info->count);
		}
	}
	catch (exception& e)
	{
		printf("<EFBFBD><EFBFBD><EFBFBD><EFBFBD>/ֹͣ<CDA3><D6B9>·%d<><64>\"%s\"ʧ<EFBFBD>ܣ<EFBFBD>ԭ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>%s\n", LD_info->line_id, LD_info->name, e.what());
		return 10004;
	}

	return 10000;
}

void Get_Recall_Time_Char(char* start_time, char* end_time, QList<RecallInfo>& recallinfo_list_hour) //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Բ<EFBFBD><D4B2><EFBFBD><EFBFBD>ж<EFBFBD>
{

	QDateTime start_dt = QDateTime::fromString(start_time, "yyyy-MM-dd HH:mm:ss");
	QDateTime end_dt = QDateTime::fromString(end_time, "yyyy-MM-dd HH:mm:ss");

	long long starttime = start_dt.toMSecsSinceEpoch() / 1000;  //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼʱ<CABC><CAB1>
	long long endtime = end_dt.toMSecsSinceEpoch() / 1000;                //<2F><><EFBFBD>н<EFBFBD><D0BD><EFBFBD>ʱ<EFBFBD><CAB1>
	QList<long long> timestamp_list;                      //<2F><><EFBFBD>ݿ<EFBFBD><DDBF><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Լ<EFBFBD>¼ʱ<C2BC><CAB1><EFBFBD><EFBFBD>
	QList<RecallInfo> recallinfo_list;                    //<2F><><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>

	RecallInfo info;
	info.starttime = starttime;
	info.endtime = endtime;
	recallinfo_list.append(info);

	for (int i = 0; i < recallinfo_list.size(); i++)
	{
		//printf("\n %lld ----- %11d\n", recallinfo_list[i].starttime, recallinfo_list[i].endtime);
		long long duration = recallinfo_list[i].endtime - recallinfo_list[i].starttime;
		long long max_interval = 3600;
		for (long long j = 0; j <= duration; j += max_interval)
		{
			if (j + max_interval > duration) {
				long long start = recallinfo_list[i].starttime + j;
				long long end = recallinfo_list[i].endtime;

				RecallInfo info;
				info.starttime = start;
				info.endtime = end;
				recallinfo_list_hour.append(info);
			}
			else {
				long long start = recallinfo_list[i].starttime + j;
				long long end = recallinfo_list[i].starttime + j + max_interval;

				RecallInfo info;
				info.starttime = start;
				info.endtime = end - 1;
				recallinfo_list_hour.append(info);
			}
		}
	}

}

int HandleReceiveMessage(int socketClient, char buffer[256]) //<2F><><EFBFBD>ղ<EFBFBD><D5B2><EFBFBD><EFBFBD><EFBFBD>Web Socket<65>ͻ<EFBFBD><CDBB>˷<EFBFBD><CBB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
{
	int iErrorCode = 000000;

	try
	{
		QString qstrBuffer = QString(QLatin1String(buffer));
		printf("<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ffe<EFBFBD>ͻ<EFBFBD><EFBFBD><EFBFBD>%d<><64>Ϣ<EFBFBD><CFA2>qstrBur= %s\n", socketClient, qstrBuffer.toAscii().data());
		cJSON* json_root = cJSON_Parse(qstrBuffer.toUtf8().constData());   //json<6F><6E>ʽ<EFBFBD><CABD><EFBFBD>л<EFBFBD>
		if (json_root == NULL) {
			return 10000;
		}
		QString qstrCode = NULL;//<2F><>¼ָ<C2BC><D6B8>
		cJSON* json_code = NULL;
		cJSON* json_param = NULL;
		cJSON* json_program_param = NULL;
		cJSON* json_recall_param = NULL;
		cJSON* json_wave_param = NULL;
		cJSON* json_update_time = NULL;
		cJSON* json_node = NULL;

		QString update_time;
		QList<QString> wave_param;
		ProgramParam program_param;

		json_code = cJSON_GetObjectItem(json_root, "code");    //<2F><>ȡcode
		if (json_code != NULL) {
			qstrCode = json_code->valuestring;
		}
		else {
			return 10000;
		}
		json_param = cJSON_GetObjectItem(json_root, "param");    //<2F><>ȡparam
		if (json_param == NULL) {
			return 10000;
		}
		if (qstrCode == "dev_update" || qstrCode == "model_update" || qstrCode == "program_update") {
			//<2F>豸<EFBFBD><E8B1B8><EFBFBD>¼<EFBFBD>¼<EFBFBD><C2BC><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>
			json_update_time = cJSON_GetObjectItem(json_param, "update_time");    //<2F><>ȡupdate_time
			if (json_update_time != NULL) {
				update_time = json_update_time->valuestring;
			}
		}
		else if (qstrCode == "manual_wave") {
			//<2F>ֶ<EFBFBD>¼<EFBFBD><C2BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>δ<EFBFBD><CEB4><EFBFBD><EFBFBD>
			json_wave_param = cJSON_GetObjectItem(json_param, "wave_param");    //<2F><>ȡwave_param
			int array_size = cJSON_GetArraySize(json_wave_param);    //<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С
			int i;

			for (i = 0; i < array_size; i++)
			{
				json_node = cJSON_GetArrayItem(json_wave_param, i);//array
				if (json_node != NULL) {
					wave_param.append(json_node->valuestring);
				}
			}

		}
		else if (qstrCode == "model_update") {
			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ն<EFBFBD><D5B6>б<EFBFBD><D0B1>ͳ<EFBFBD><CDB3><EFBFBD><EFBFBD>ļ<EFBFBD>
			json_program_param = cJSON_GetObjectItem(json_param, "program_param");    //<2F><>ȡprogram_param
			cJSON* json_temp = NULL;
			json_temp = cJSON_GetObjectItem(json_program_param, "terminal_list");    //<2F><>ȡ
			int array_size = cJSON_GetArraySize(json_temp);    //<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С
			int i;

			for (i = 0; i < array_size; i++)
			{
				json_node = cJSON_GetArrayItem(json_temp, i);//array
				if (json_node != NULL) {
					program_param.terminal_list.append(json_node->valuestring);
				}
			}
			json_node = cJSON_GetObjectItem(json_program_param, "file_name");    //<2F><>ȡfile_name
			if (json_node != NULL) {
				program_param.file_name = json_node->valuestring;
			}
		}
		else if (qstrCode == "manual_recall") {//<2F>ֶ<EFBFBD><D6B6><EFBFBD><EFBFBD>е<EFBFBD>ָ<EFBFBD><D6B8>
			//<2F><><EFBFBD>в<EFBFBD><D0B2><EFBFBD>
			json_recall_param = cJSON_GetObjectItem(json_param, "recall_param");    //<2F><>ȡrecall_param
			cJSON* json_temp = NULL;
			int array_size = cJSON_GetArraySize(json_recall_param);    //<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С
			int i;
			QList<RecallInfo> recallinfo_list_hour;
			char start_time[64];
			char end_time[64];
			QString mp_id;
			for (i = 0; i < array_size; i++)
			{
				json_temp = cJSON_GetArrayItem(json_recall_param, i);//array
				if (json_temp != NULL) {
					json_node = cJSON_GetObjectItem(json_temp, "mp_id");    //<2F><>ȡmp_id
					if (json_node != NULL) {
						mp_id = QString::fromUtf8(json_node->valuestring);
					}
					if (i == 0) {
						json_node = cJSON_GetObjectItem(json_temp, "start");    //<2F><>ȡstart
						if (json_node != NULL) {
							apr_snprintf(start_time, sizeof(start_time), "%s", json_node->valuestring);//start_time
						}
						json_node = cJSON_GetObjectItem(json_temp, "end");    //<2F><>ȡend
						if (json_node != NULL) {
							apr_snprintf(end_time, sizeof(end_time), "%s", json_node->valuestring);//end_time
						}
						Get_Recall_Time_Char(start_time, end_time, recallinfo_list_hour);
					}
					for (int j = 0; j < recallinfo_list_hour.size(); j++) {
						CJournalRecall jr;
						jr.MonitorID = mp_id;
						jr.StartTime = QDateTime::fromTime_t(recallinfo_list_hour[j].starttime).toString("yyyy-MM-dd hh:mm:ss");
						jr.EndTime = QDateTime::fromTime_t(recallinfo_list_hour[j].endtime).toString("yyyy-MM-dd hh:mm:ss");
						jr.STEADY = QString::number(1, 10);//Ĭ<>϶<EFBFBD><CFB6><EFBFBD>1<EFBFBD><31>1<EFBFBD><31>ʮ<EFBFBD><CAAE><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>
						jr.VOLTAGE = QString::number(1, 10);
						g_StatisticLackList_list_mutex.lock();
						g_StatisticLackList.push_back(jr);
						g_StatisticLackList_list_mutex.unlock();
					}
				}
			}
		}
		cJSON_Delete(json_root);
		SendMessageToWeb(socketClient, 000000);//<2F><>Ӧweb
	}
	catch (exception& e)
	{
		printf("<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͻ<EFBFBD><EFBFBD>ˣ<EFBFBD>%d<><64><EFBFBD>͵<EFBFBD><CDB5><EFBFBD>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD><EFBFBD><EFBFBD>%s\n", socketClient, e.what());
		return 10004;
	}
	return 000000;
}

///////////////////////////////////////////////////////////////////////////////////////
void Cout_account_information() {
	ied_t* ied = NULL;
	int			iedno;
	LD_info_t* LD_info = NULL;

	for (iedno = 0; iedno < g_node->n_clients; iedno++) {
		ied = g_node->clients[iedno];
		if (ied) {
			LD_info_t* LD_info = NULL;
			ied_usr_t* ied_usr = GET_IEDEXT_ADDR(ied);
			int			cpuno;
			QString text;//<2F><><EFBFBD><EFBFBD>װ<EFBFBD><D7B0>pgsql<71><6C><EFBFBD><EFBFBD>
			text.append(QString("terminal_code: \"%1\"  ,ip:\"%2\" ,port:\"%3\" ,cpucount:\"%4\" ").arg(ied_usr->terminal_code).arg(ied->channel[0].addr_str).arg(ied->channel[0].port).arg(ied->cpucount));
			add_comm_log(const_cast<char*>(text.toLocal8Bit().constData()));
			for (cpuno = 0; cpuno < ied->cpucount; cpuno++) {
				LD_info = &(ied_usr->LD_info[cpuno]);
				QString text2;//<2F><><EFBFBD><EFBFBD>װ<EFBFBD><D7B0>pgsql<71><6C><EFBFBD><EFBFBD>
				text2.append(QString("mp_id: \"%1\" terminal_code:\"%2\" ").arg(LD_info->mp_id).arg(LD_info->terminal_code));
				add_comm_log(const_cast<char*>(text2.toLocal8Bit().constData()));
			}
		}
	}
}

/// <summary>
/// ɾ<><C9BE><EFBFBD><EFBFBD><EFBFBD>ڵ<EFBFBD>xml
/// </summary>
void DeletcRecallXml() {
	QString cfg_dir = QString("../")/*+QString::fromAscii(subdir)*/ + QString("etc/recall");
	QString file_name = QString(subdir) + QString("_") + QString("*") + QString("_Recall.xml");

	//ָ<><D6B8><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
	QDir dir(cfg_dir);
	if (!dir.exists()) {
		qDebug() << "folder does not exist!";
		return;
	}
	QStringList filter(file_name);
	//ָ<><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͺ<EFBFBD><CDBA><EFBFBD><EFBFBD>򣬰<EFBFBD><F2A3ACB0><EFBFBD><EFBFBD>µ<EFBFBD><C2B5>޸<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>ȡ
	QStringList files = dir.entryList(filter, QDir::Files | QDir::Readable | QDir::NoDotAndDotDot, QDir::Name | QDir::Time);

	// <20>趨<EFBFBD><E8B6A8><EFBFBD>˵<EFBFBD><CBB5><EFBFBD><EFBFBD>ں<EFBFBD>ʱ<EFBFBD><CAB1>  
	QDateTime saveDaysAgo = QDateTime::currentDateTime().addDays(-2);

	for (int i = 0; i < files.size(); i++) {//<2F><><EFBFBD>ն<EFBFBD>ȡ<EFBFBD>ļ<EFBFBD>
		QFileInfo fileInfo(dir.filePath(files[i]));
		if (fileInfo.lastModified() < saveDaysAgo) {
			QFile::remove(fileInfo.absoluteFilePath());

		}
	}

}

void CreateRecallXml()
{
	apr_time_t	previousTime = apr_time_now();
	long long stamp = static_cast<long long>(previousTime) / 1000000;
	QDateTime deltime_Qtime = QDateTime::fromTime_t(stamp);

	g_StatisticLackList_list_mutex.lock();
	if (g_StatisticLackList.size() > 0)
	{
		printf("insert ID_CJournalRecall_Map<61><70>\n");
		QMap<QString, QList<CJournalRecall> > ID_CJournalRecall_Map;

		list<CJournalRecall>::iterator sl = g_StatisticLackList.begin();
		while (sl != g_StatisticLackList.end())
		{
			CJournalRecall jr = *sl++;
			if (ID_CJournalRecall_Map.contains(jr.MonitorID))
			{
				ID_CJournalRecall_Map[jr.MonitorID].append(jr);
			}
			else
			{
				QList<CJournalRecall> TempList;
				TempList.append(jr);
				ID_CJournalRecall_Map.insert(jr.MonitorID, TempList);
			}
		}

		for (QMap<QString, QList<CJournalRecall> >::iterator it2 = ID_CJournalRecall_Map.begin(); it2 != ID_CJournalRecall_Map.end(); ++it2)
		{
			QString key2 = it2.key();
			QList<CJournalRecall> value2 = it2.value();

			QString cfg_dir = QString("../")/*+QString::fromAscii(subdir)*/ + QString("etc/recall/");
			QString qstrRecallPath = cfg_dir + QString(subdir) + QString("_") + QString(QString::number(g_front_seg_index, 10)) + QString("_") + key2 + QString("_") + QString(deltime_Qtime.toString("yyyyMMddhhmmss")) + QString("_Recall.xml");

			std::string strRecallPath = qstrRecallPath.toStdString();
			QFile file(strRecallPath.c_str());
			if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
				printf("<EFBFBD><EFBFBD><EFBFBD>в<EFBFBD>ѯ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,<2C><><EFBFBD><EFBFBD>%sʧ<73><CAA7>,<2C>޷<EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD>·<EFBFBD><C2B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ã<EFBFBD>\n", qstrRecallPath.toAscii().data());
				QMap<QString, QList<CJournalRecall> >().swap(ID_CJournalRecall_Map);
				return;
			}

			QXmlStreamWriter writer(&file);
			writer.setAutoFormatting(true);
			writer.writeStartDocument();
			writer.writeStartElement("RecallList");
			writer.writeStartElement("Work");
			writer.writeEndElement();

			writer.writeStartElement("New");

			while (!value2.isEmpty())
			{
				CJournalRecall jr = value2.takeFirst();
				writer.writeStartElement("Recall");
				writer.writeAttribute("MonitorID", jr.MonitorID);
				writer.writeAttribute("StartTime", jr.StartTime);
				writer.writeAttribute("EndTime", jr.EndTime);
				writer.writeAttribute("STEADY", jr.STEADY);
				writer.writeAttribute("VOLTAGE", jr.VOLTAGE);
				writer.writeEndElement();
			}
			writer.writeEndElement();
			writer.writeEndElement();
			writer.writeEndDocument();
			file.close();
		}

		QMap<QString, QList<CJournalRecall> >().swap(ID_CJournalRecall_Map);
	}
	g_StatisticLackList.clear();
	g_StatisticLackList_list_mutex.unlock();
}
///////zw<7A>޸<EFBFBD> 2023-8-30 end

/*/////////////////////////////////////////////////////////lnk2024-10-11<31>Ƴ<EFBFBD>sql<71>IJ<EFBFBD><C4B2>Դ<EFBFBD><D4B4><EFBFBD>/////////////////////////////////////////////////////////////*/
std::string intToString(int number) {
    if (number == 0) return "0";
    std::string str;
    bool isNegative = number < 0;
    if (isNegative) number = -number;

    while (number > 0) {
        str.insert(str.begin(), '0' + (number % 10));
        number /= 10;
    }

    if (isNegative) str.insert(str.begin(), '-');
    return str;
}

otl_datetime parseTimestamp(const std::string timestampStr) {
    otl_datetime timestamp;
	
	// <20><><EFBFBD><EFBFBD><EFBFBD>ꡢ<EFBFBD>¡<EFBFBD><C2A1>ա<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD>֡<EFBFBD><D6A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    int year, month, day, hour, minute, second;

    // ʹ<><CAB9><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>н<EFBFBD><D0BD><EFBFBD>
    std::istringstream ss(timestampStr);
    char discard; // <20><><EFBFBD>ڶ<EFBFBD><DAB6><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD>

    // <20><><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>
    ss >> year >> discard >> month >> discard >> day >> hour >> discard >> minute >> discard >> second;

    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD> otl_datetime
    timestamp.year = year;
    timestamp.month = month;
    timestamp.day = day;
    timestamp.hour = hour;
    timestamp.minute = minute;
    timestamp.second = second;

	return timestamp;
}

size_t req_reply_web(void* ptr, size_t size, size_t nmemb, void* stream)
{
	string* str = (string*)stream;
	(*str).append((char*)ptr, size * nmemb);
	return size * nmemb;
}

void SendWebAPI_web(const string strUrl, const char* code, char** ptr)
{
	// curl<72><6C>ʼ<EFBFBD><CABC>  
	CURL* curl = curl_easy_init();
	// curl<72><6C><EFBFBD><EFBFBD>ֵ 
	CURLcode res;
	if (curl)
	{
		char url[100];
		sprintf(url, "%s?%s", strUrl.c_str(), code);
		//printf(">>>json %s\n", url);//<2F><><EFBFBD>ٲ<EFBFBD><D9B2><EFBFBD>Ҫ<EFBFBD>Ĵ<EFBFBD>ӡ
		// <20><><EFBFBD><EFBFBD>URL
		curl_easy_setopt(curl, CURLOPT_URL, url);

		//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݽ<EFBFBD><DDBD>պ<EFBFBD>д<EFBFBD>뺯<EFBFBD><EBBAAF>
		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, req_reply_web);

		//<2F><><EFBFBD>ݽ<EFBFBD><DDBD><EFBFBD>
		string resPost0;
		curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&resPost0);

		//<2F><><EFBFBD>ó<EFBFBD>ʱʱ<CAB1><CAB1>
		curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10);
		curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10);

		//<2F><><EFBFBD><EFBFBD>header
		curl_slist* headers = NULL;
		headers = curl_slist_append(headers, "Content-Type: application/json");
		curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
		
		// <20><><EFBFBD><EFBFBD>post<73><74><EFBFBD><EFBFBD>
		res = curl_easy_perform(curl);

		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD><C7B7>ɹ<EFBFBD>
		if (res != CURLE_OK) {
			printf("web failed res code: ");
		}
		else {
			printf(">>> web return str:%s \n", resPost0.c_str());

			*ptr = (char*)malloc(strlen(resPost0.c_str()) + 1); // <20><><EFBFBD><EFBFBD><EFBFBD>㹻<EFBFBD><E3B9BB><EFBFBD>ڴ<EFBFBD><DAB4>ռ<EFBFBD>
			if (*ptr != NULL) {
				strcpy(*ptr, resPost0.c_str());
			}
			else {
				printf("Memory allocation failed!\n");
			}
		}
	}
	else
	{
		printf(">>> web curl init failed");
	}
	curl_easy_cleanup(curl);
}

/*/////////////////////////////////////////////////////////lnk10-24<32><34><EFBFBD><EFBFBD>web<65>ӿ<EFBFBD><D3BF>޸<EFBFBD>/////////////////////////////////////////////////////////////*/
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>json<6F>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20>ص<EFBFBD><D8B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֱ<EFBFBD><D6B1>׷<EFBFBD>ӵ<EFBFBD> *ptr <20><>
size_t req_reply_http(void* contents, size_t size, size_t nmemb, void* userp) {
    size_t realsize = size * nmemb;
    char** responsePtr = (char**)userp;

    size_t oldLen = strlen(*responsePtr);  // <20><>ǰ<EFBFBD><C7B0><EFBFBD>г<EFBFBD><D0B3><EFBFBD>
    char* temp = (char*)realloc(*responsePtr, oldLen + realsize + 1); // +1 <20><><EFBFBD>ռ<EFBFBD><D5BC><EFBFBD> '\0'
    if (temp == NULL) {
        printf("Memory reallocation failed!\n");
        return 0;
    }

    *responsePtr = temp;
    memcpy(*responsePtr + oldLen, contents, realsize);  // ֱ<>ӿ<EFBFBD><D3BF><EFBFBD>ԭʼ<D4AD><CABC><EFBFBD><EFBFBD>
    (*responsePtr)[oldLen + realsize] = '\0';           // <20>ֶ<EFBFBD><D6B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

    return realsize;
}

void SendJsonAPI_web(const std::string& strUrl, const char* code, const std::string& json, char** ptr) {
    CURL* curl = curl_easy_init();
    CURLcode res;

    // <20><>ʼ<EFBFBD><CABC> *ptr <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>
    *ptr = (char*)malloc(1);
    if (*ptr == NULL) {
        printf("Memory allocation failed!\n");
        return;
    }
    (*ptr)[0] = '\0';  // Ϊ<><CEAA><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD>Ա<EFBFBD> strncat <20><><EFBFBD><EFBFBD>

    if (curl) {
        char url[256];
        snprintf(url, sizeof(url), "%s?%s", strUrl.c_str(), code);
        //printf(">>>json %s\n", url);//<2F><><EFBFBD>ٲ<EFBFBD><D9B2><EFBFBD>Ҫ<EFBFBD>Ĵ<EFBFBD>ӡ

        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, req_reply_http);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, ptr);
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10);
        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10);

        if (!json.empty()) {
            curl_easy_setopt(curl, CURLOPT_POST, 1L);
            curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json.c_str());
        }

        struct curl_slist* headers = NULL;
        headers = curl_slist_append(headers, "Content-Type: application/json");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

        res = curl_easy_perform(curl);

        if (res != CURLE_OK) {
            printf("web failed res code: %s\n", curl_easy_strerror(res));
        } else {
            //printf(">>> web return str: %s \n", *ptr);
        }

        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    } else {
        printf(">>> web curl init failed\n");
    }
}
/*void SendJsonAPI_web(const std::string& strUrl, const char* code, const std::string& json, char** ptr) {
    // curl <20><>ʼ<EFBFBD><CABC>  
    CURL* curl = curl_easy_init();
    CURLcode res;

    if (curl) {
		char url[100];
		sprintf(url, "%s?%s", strUrl.c_str(), code);
		printf(">>>json %s\n", url);

        // <20><><EFBFBD><EFBFBD> URL
        curl_easy_setopt(curl, CURLOPT_URL, url);

        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݽ<EFBFBD><DDBD>պ<EFBFBD>д<EFBFBD>뺯<EFBFBD><EBBAAF>
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, req_reply_web);

        // <20><><EFBFBD>ݽ<EFBFBD><DDBD><EFBFBD>
        std::string resPost0;
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&resPost0);

        // <20><><EFBFBD>ó<EFBFBD>ʱʱ<CAB1><CAB1>
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10);
        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10);

		if(json != ""){
			// <20><><EFBFBD><EFBFBD> HTTP <20><><EFBFBD><EFBFBD>Ϊ POST
        	curl_easy_setopt(curl, CURLOPT_POST, 1L);

        	// <20><><EFBFBD><EFBFBD> JSON <20><>ʽ<EFBFBD><CABD> body <20><><EFBFBD><EFBFBD>
        	curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json.c_str());
		}

        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͷ
        struct curl_slist* headers = NULL;
        headers = curl_slist_append(headers, "Content-Type: application/json");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        
        // ִ<><D6B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
        res = curl_easy_perform(curl);

        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD><C7B7>ɹ<EFBFBD>
        if (res != CURLE_OK) {
            printf("web failed res code: %s\n", curl_easy_strerror(res));
        } else {
            printf(">>> web return str: %s \n", resPost0.c_str());

            // <20><><EFBFBD><EFBFBD><EFBFBD>ڴ沢<DAB4><E6B2A2><EFBFBD>Ʒ<EFBFBD><C6B7>ؽ<EFBFBD><D8BD><EFBFBD>
            *ptr = (char*)malloc(resPost0.size() + 1); // <20><><EFBFBD><EFBFBD><EFBFBD>㹻<EFBFBD><E3B9BB><EFBFBD>ڴ<EFBFBD><DAB4>ռ<EFBFBD>
            if (*ptr != NULL) {
                strcpy(*ptr, resPost0.c_str());
            } else {
                printf("Memory allocation failed!\n");
            }
        }

        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͷ
        curl_slist_free_all(headers);
    } else {
        printf(">>> web curl init failed");
    }
    curl_easy_cleanup(curl);
}*/

// <20><>ӡ terminal_dev_map <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݵĺ<DDB5><C4BA><EFBFBD>
void printTerminalDevMap(const QMap<QString, terminal_dev*>& terminal_dev_map) {
	QMap<QString, terminal_dev*>::const_iterator it;
    for (it = terminal_dev_map.constBegin(); it != terminal_dev_map.constEnd(); ++it) {
        QString key = it.key();
        terminal_dev* dev = it.value();
        
        if (dev) {
            qDebug() << "Key:" << key
                     << ", Terminal ID:" << QString(dev->terminal_id)
                     << ", Terminal Code:" << QString(dev->terminal_code)
                     << ", Organization Name:" << QString(dev->org_name)
                     << ", Maintenance Name:" << QString(dev->maint_name)
                     << ", Station Name:" << QString(dev->station_name)
                     << ", Factory:" << QString(dev->tmnl_factory)
                     << ", Status:" << QString(dev->tmnl_status)
                     << ", Device Type:" << QString(dev->dev_type)
                     << ", Device Key:" << QString(dev->dev_key)
                     << ", Device Series:" << QString(dev->dev_series)
					 << ", Device processNo:" << QString(dev->processNo)
                     << ", Address:" << QString(dev->addr_str)
                     << ", Port:" << QString(dev->port)
                     << ", Timestamp:" << QString(dev->timestamp);

            // <20><>ӡ<EFBFBD><D3A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
            for (int i = 0; i < 10; ++i) {
                qDebug() << " Monitor ID:" << QString(dev->line[i].monitor_id)
                         << ", Terminal Code:" << QString(dev->line[i].terminal_code)
                         << ", Monitor Name:" << QString(dev->line[i].monitor_name)
                         << ", Logical Device Seq:" << QString(dev->line[i].logical_device_seq)
                         << ", Voltage Level:" << QString(dev->line[i].voltage_level)
                         << ", Terminal Connect:" << QString(dev->line[i].terminal_connect)
                         << ", Timestamp:" << QString(dev->line[i].timestamp)
                         << ", Status:" << QString(dev->line[i].status);
            }
        } else {
            qDebug() << "Key:" << key << ", Value is nullptr";
        }
    }
}

//<2F><>ӡ<EFBFBD><D3A1>ǰ<EFBFBD><C7B0><EFBFBD>̵<EFBFBD>̨<EFBFBD><CCA8>//////////////////////////////////////////////////////////////////////////
// <20><>ӡ<EFBFBD>ṹ<EFBFBD><E1B9B9><EFBFBD><EFBFBD>Ϣ<EFBFBD>ĵݹ麯<DDB9><E9BAAF>
void printLedger(const ied_usr_t& ied_usr) {
    std::cout << "------------------------------------" << std::endl;
    std::cout << "|-- terminal_id: " << ied_usr.terminal_id << std::endl;
	std::cout << "|-- dev_index: " << ied_usr.dev_idx << std::endl;
    std::cout << "|-- dev_type: " << ied_usr.dev_type << std::endl;
    std::cout << "|-- dev_key: " << ied_usr.dev_key << std::endl;
    std::cout << "|-- dev_series: " << ied_usr.dev_series << std::endl;
    std::cout << "|-- dev_flag: " << ied_usr.dev_flag << std::endl;

    std::cout << "|-- last_call_wavelist_time: " << ied_usr.last_call_wavelist_time << std::endl;

    std::cout << "|-- org_name: " << ied_usr.org_name << std::endl;
    std::cout << "|-- maint_name: " << ied_usr.maint_name << std::endl;
    std::cout << "|-- station_name: " << ied_usr.station_name << std::endl;
    std::cout << "|-- tmnl_factory: " << ied_usr.tmnl_factory << std::endl;
    std::cout << "|-- time: " << ied_usr.time << std::endl;
    std::cout << "|-- tmnl_status: " << ied_usr.tmnl_status << std::endl;
    std::cout << "|-- terminal_code: " << ied_usr.terminal_code << std::endl;
    std::cout << "|-- update_flag: " << ied_usr.update_flag << std::endl;

    // <20><>ӡÿ<D3A1><C3BF>LD_info<66><6F><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    for (int i = 0; i < 10; ++i) {
        if (strcmp(ied_usr.LD_info[i].mp_id, "") != 0) {
            std::cout << "|-- LD_info[" << i << "]:" << std::endl;
//name
            std::cout << "    |-- name: " << ied_usr.LD_info[i].name << std::endl;
			std::cout << "    |-- LD_name: " 
                      << (strlen(ied_usr.LD_info[i].LD_name) == 0 ? "NA" : ied_usr.LD_info[i].LD_name) 
                      << std::endl;
			std::cout << "    |-- read_flag: " << ied_usr.LD_info[i].read_flag << std::endl;
//index
			std::cout << "    |-- line_id: " << ied_usr.LD_info[i].line_id << std::endl;
//monitorledger
            std::cout << "    |-- mp_id: " << ied_usr.LD_info[i].mp_id << std::endl;
            std::cout << "    |-- terminal_code: " << ied_usr.LD_info[i].terminal_code << std::endl;
            std::cout << "    |-- voltage_level: " << ied_usr.LD_info[i].voltage_level << std::endl;
            std::cout << "    |-- v_wiring_type: " << ied_usr.LD_info[i].v_wiring_type << std::endl;
            std::cout << "    |-- time: " << ied_usr.LD_info[i].time << std::endl;
            std::cout << "    |-- update_flag: " << ied_usr.LD_info[i].update_flag << std::endl;
            std::cout << "    |-- monitor_status: " << ied_usr.LD_info[i].monitor_status << std::endl;
//count<6E>ݲ<EFBFBD><DDB2><EFBFBD>ӡ<EFBFBD><D3A1><EFBFBD><EFBFBD>
			std::cout << "    |-- rptcount: " << ied_usr.LD_info[i].rptcount << std::endl;
			std::cout << "    |-- logcount: " << ied_usr.LD_info[i].logcount << std::endl;
//rpt
			std::cout << "    |-- rptRecvFlag: " << ied_usr.LD_info[i].rptRecvFlag << std::endl;
			std::cout << "    |-- rptRecvCheckFlag: " << ied_usr.LD_info[i].rptRecvCheckFlag << std::endl;
			std::cout << "    |-- rptPstRecvFlag: " << ied_usr.LD_info[i].rptPstRecvFlag << std::endl;
			std::cout << "    |-- rptPstRecvCheckFlag: " << ied_usr.LD_info[i].rptPstRecvCheckFlag << std::endl;
//rtdata
			std::cout << "    |-- real_data: " << ied_usr.LD_info[i].real_data << std::endl;
			std::cout << "    |-- soe_data: " << ied_usr.LD_info[i].soe_data << std::endl;
			std::cout << "    |-- limit: " << ied_usr.LD_info[i].limit << std::endl;
			std::cout << "    |-- count: " << ied_usr.LD_info[i].count << std::endl;
//RDRE
			std::cout << "    |-- RDRE_FltNum: " << ied_usr.LD_info[i].RDRE_FltNum << std::endl;
			for (int j = 0; j < 256; ++j) { 
                if (ied_usr.LD_info[i].FltNum[j] != 0) {
					std::cout << "        |-- FltNum[" << j << "]:" << ied_usr.LD_info[i].FltNum[j] << std::endl;
				}
			}
//QVVR
			std::cout << "    |-- qvvr_idx: " << ied_usr.LD_info[i].qvvr_idx << std::endl;
            std::cout << "    |-- QVVRs:" << std::endl;
            for (int j = 0; j < 256; ++j) {  
                if (ied_usr.LD_info[i].qvvr[j].used_status != 0) {
                    std::cout << "        |-- QVVR[" << j << "]:" << std::endl;
                    std::cout << "		      |-- used_status: " << ied_usr.LD_info[i].qvvr[j].used_status << std::endl;
                    std::cout << "		      |-- QVVR_start: " << ied_usr.LD_info[i].qvvr[j].QVVR_start << std::endl;
                    std::cout << "		      |-- QVVR_type: " << ied_usr.LD_info[i].qvvr[j].QVVR_type << std::endl;
                    std::cout << "		      |-- QVVR_time: " << ied_usr.LD_info[i].qvvr[j].QVVR_time << std::endl;
                    std::cout << "		      |-- QVVR_PerTime: " << ied_usr.LD_info[i].qvvr[j].QVVR_PerTime << std::endl;
                    std::cout << "		      |-- QVVR_Amg: " << ied_usr.LD_info[i].qvvr[j].QVVR_Amg << std::endl;
                    std::cout << "		      |-- QVVR_Rptname: " << ied_usr.LD_info[i].qvvr[j].QVVR_Rptname << std::endl;
                    std::cout << "		      |-- timestamp: " << ied_usr.LD_info[i].qvvr[j].timestamp << std::endl;
                }
            }
        }
    }
    std::cout << "------------------------------------" << std::endl;
}
void printLedgerinshell(const ied_usr_t& ied_usr, QIODevice* outputDevice) {
	ied_t* ied;
	ied = find_ied_from_dev_idx(ied_usr.dev_idx);

    outputDevice->write("\r\x1B[K");outputDevice->write("------------------------------------\n");
    outputDevice->write("\r\x1B[K");outputDevice->write("|-- terminal_id: " + QByteArray(ied_usr.terminal_id) + "\n");
    outputDevice->write("\r\x1B[K");outputDevice->write("|-- dev_index: " + QByteArray::number(ied_usr.dev_idx) + "\n");
	outputDevice->write("\r\x1B[K");outputDevice->write("|-- dev_cpucount: " + QByteArray::number(ied->cpucount) + "\n");
	outputDevice->write("\r\x1B[K");outputDevice->write("|-- dev_ip: " + QByteArray(ied->channel[0].addr_str) + "\n");
	char portStr[20];  // <20><><EFBFBD>ڴ<EFBFBD><DAB4>Ŷ˿ںŵ<DABA><C5B5>ַ<EFBFBD><D6B7><EFBFBD>
	sprintf(portStr, "%u", ied->channel[0].port);  // <20><><EFBFBD>˿ں<CBBF>תΪ<D7AA>ַ<EFBFBD><D6B7><EFBFBD>
	outputDevice->write("\r\x1B[K");outputDevice->write("|-- dev_port: " + QByteArray(portStr) + "\n");

	char statusStr[20];  // <20><><EFBFBD>ڴ<EFBFBD><DAB4><EFBFBD>״̬<D7B4><CCAC><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>
	sprintf(statusStr, "%u", ied->channel[0].status);  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>״̬תΪ<D7AA>ַ<EFBFBD><D6B7><EFBFBD>
	outputDevice->write("\r\x1B[K");outputDevice->write("|-- dev_connect_status: " + QByteArray(statusStr) + "\n");
    outputDevice->write("\r\x1B[K");outputDevice->write("|-- dev_type: " + QByteArray(ied_usr.dev_type) + "\n");
    outputDevice->write("\r\x1B[K");outputDevice->write("|-- dev_key: " + QByteArray(ied_usr.dev_key) + "\n");
    outputDevice->write("\r\x1B[K");outputDevice->write("|-- dev_series: " + QByteArray(ied_usr.dev_series) + "\n");
	outputDevice->write("\r\x1B[K");outputDevice->write("|-- dev_processNo: " + QByteArray(ied_usr.processNo) + "\n");
    outputDevice->write("\r\x1B[K");outputDevice->write("|-- dev_flag: " + QByteArray::number(ied_usr.dev_flag) + "\n");
    outputDevice->write("\r\x1B[K");outputDevice->write("|-- last_call_wavelist_time: " + QByteArray::number(ied_usr.last_call_wavelist_time) + "\n");
    outputDevice->write("\r\x1B[K");outputDevice->write("|-- org_name: " + QByteArray(ied_usr.org_name) + "\n");
    outputDevice->write("\r\x1B[K");outputDevice->write("|-- maint_name: " + QByteArray(ied_usr.maint_name) + "\n");
    outputDevice->write("\r\x1B[K");outputDevice->write("|-- station_name: " + QByteArray(ied_usr.station_name) + "\n");
    outputDevice->write("\r\x1B[K");outputDevice->write("|-- tmnl_factory: " + QByteArray(ied_usr.tmnl_factory) + "\n");
    outputDevice->write("\r\x1B[K");outputDevice->write("|-- time: " + QByteArray::number(ied_usr.time) + "\n");
    outputDevice->write("\r\x1B[K");outputDevice->write("|-- tmnl_status: " + QByteArray(ied_usr.tmnl_status) + "\n");
    outputDevice->write("\r\x1B[K");outputDevice->write("|-- terminal_code: " + QByteArray(ied_usr.terminal_code) + "\n");
    outputDevice->write("\r\x1B[K");outputDevice->write("|-- update_flag: " + QByteArray::number(ied_usr.update_flag) + "\n");

    // <20><>ӡÿ<D3A1><C3BF>LD_info<66><6F><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    for (int i = 0; i < 10; ++i) {
        if (strcmp(ied_usr.LD_info[i].mp_id, "") != 0) {
            outputDevice->write("\r\x1B[K");outputDevice->write("|-- LD_info[" + QByteArray::number(i) + "]:\n");
            
            // name
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- name: " + QByteArray(ied_usr.LD_info[i].name) + "\n");
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- LD_name: " 
                + (strlen(ied_usr.LD_info[i].LD_name) == 0 ? QByteArray("NA") : QByteArray(ied_usr.LD_info[i].LD_name))
                + "\n");
				outputDevice->write("\r\x1B[K");outputDevice->write("    |-- read_flag: " + QByteArray::number(ied_usr.LD_info[i].read_flag) + "\n");

            // index
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- line_id: " + QByteArray::number(ied_usr.LD_info[i].line_id) + "\n");

            // monitorledger
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- mp_id: " + QByteArray(ied_usr.LD_info[i].mp_id) + "\n");
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- terminal_code: " + QByteArray(ied_usr.LD_info[i].terminal_code) + "\n");
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- voltage_level: " + QByteArray(ied_usr.LD_info[i].voltage_level) + "\n");
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- v_wiring_type: " + QByteArray(ied_usr.LD_info[i].v_wiring_type) + "\n");
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- time: " + QByteArray::number(ied_usr.LD_info[i].time) + "\n");
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- update_flag: " + QByteArray::number(ied_usr.LD_info[i].update_flag) + "\n");
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- monitor_status: " + QByteArray(ied_usr.LD_info[i].monitor_status) + "\n");

            // count<6E>ݲ<EFBFBD><DDB2><EFBFBD>ӡ<EFBFBD><D3A1><EFBFBD><EFBFBD>
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- rptcount: " + QByteArray::number(ied_usr.LD_info[i].rptcount) + "\n");
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- logcount: " + QByteArray::number(ied_usr.LD_info[i].logcount) + "\n");

			//recall
			outputDevice->write("\r\x1B[K");outputDevice->write("    |-- autorecallflag: " + QByteArray::number(ied_usr.LD_info[i].autorecallflag) + "\n");
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- autorecallcount: " + QByteArray::number(ied_usr.LD_info[i].autorecallcount) + "\n");
			for (int j = 0; 
				j < ied_usr.LD_info[i].autorecallcount && 
				ied_usr.LD_info[i].autorecall != NULL &&  // <20><><EFBFBD><EFBFBD> LD_info->autorecall <20><><EFBFBD><EFBFBD>
				ied_usr.LD_info[i].autorecall[j] != NULL; 
				j++) 
		   {
			   outputDevice->write("\r\x1B[K");
			   outputDevice->write("        |-- autorecall_t[" + QByteArray::number(j) + "]:\n");
		   
			   if (ied_usr.LD_info[i].autorecall[j] == NULL) {
				   outputDevice->write("            |-- [Error] autorecall[j] is NULL\n");
				   continue;  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> NULL ָ<><D6B8>
			   }
		   
			   outputDevice->write("\r\x1B[K");
			   outputDevice->write("            |-- start_time: " + QByteArray::number(ied_usr.LD_info[i].autorecall[j]->start) + "\n");		   
			   outputDevice->write("\r\x1B[K");
			   outputDevice->write("            |-- end_time: " + QByteArray::number(ied_usr.LD_info[i].autorecall[j]->end) + "\n");	   
			   outputDevice->write("\r\x1B[K");
			   outputDevice->write("            |-- need_steady: " + QByteArray::number(ied_usr.LD_info[i].autorecall[j]->need_steady) + "\n");	   
			   outputDevice->write("\r\x1B[K");
			   outputDevice->write("            |-- need_voltage: " + QByteArray::number(ied_usr.LD_info[i].autorecall[j]->need_voltage) + "\n");
		   }
            // rpt
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- rptRecvFlag: " + QByteArray::number(ied_usr.LD_info[i].rptRecvFlag) + "\n");
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- rptRecvCheckFlag: " + QByteArray::number(ied_usr.LD_info[i].rptRecvCheckFlag) + "\n");
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- rptPstRecvFlag: " + QByteArray::number(ied_usr.LD_info[i].rptPstRecvFlag) + "\n");
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- rptPstRecvCheckFlag: " + QByteArray::number(ied_usr.LD_info[i].rptPstRecvCheckFlag) + "\n");

            // rtdata
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- real_data: " + QByteArray::number(ied_usr.LD_info[i].real_data) + "\n");
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- soe_data: " + QByteArray::number(ied_usr.LD_info[i].soe_data) + "\n");
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- limit: " + QByteArray::number(ied_usr.LD_info[i].limit) + "\n");
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- count: " + QByteArray::number(ied_usr.LD_info[i].count) + "\n");

            // RDRE
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- RDRE_FltNum: " + QByteArray::number(ied_usr.LD_info[i].RDRE_FltNum) + "\n");
            for (int j = 0; j < 256; ++j) {
                if (ied_usr.LD_info[i].FltNum[j] != 0) {
                    outputDevice->write("\r\x1B[K");outputDevice->write("        |-- FltNum[" + QByteArray::number(j) + "]: " 
                        + QByteArray::number(ied_usr.LD_info[i].FltNum[j]) + "\n");
                }
            }

            // QVVR
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- qvvr_idx: " + QByteArray::number(ied_usr.LD_info[i].qvvr_idx) + "\n");
            outputDevice->write("\r\x1B[K");outputDevice->write("    |-- QVVRs:\n");
            for (int j = 0; j < 256; ++j) {
                if (ied_usr.LD_info[i].qvvr[j].used_status != QVVR_DATA_NOT_USED) {
                    outputDevice->write("\r\x1B[K");outputDevice->write("        |-- QVVR[" + QByteArray::number(j) + "]:\n");
                    outputDevice->write("\r\x1B[K");outputDevice->write("            |-- used_status: " + QByteArray::number(ied_usr.LD_info[i].qvvr[j].used_status) + "\n");
                    outputDevice->write("\r\x1B[K");outputDevice->write("            |-- QVVR_start: " + QByteArray::number(ied_usr.LD_info[i].qvvr[j].QVVR_start) + "\n");
                    outputDevice->write("\r\x1B[K");outputDevice->write("            |-- QVVR_type: " + QByteArray::number(ied_usr.LD_info[i].qvvr[j].QVVR_type) + "\n");
                    outputDevice->write("\r\x1B[K");outputDevice->write("            |-- QVVR_time: " + QByteArray::number(ied_usr.LD_info[i].qvvr[j].QVVR_time) + "\n");
                    outputDevice->write("\r\x1B[K");outputDevice->write("            |-- QVVR_PerTime: " + QByteArray::number(ied_usr.LD_info[i].qvvr[j].QVVR_PerTime) + "\n");
                    outputDevice->write("\r\x1B[K");outputDevice->write("            |-- QVVR_Amg: " + QByteArray::number(ied_usr.LD_info[i].qvvr[j].QVVR_Amg) + "\n");
                    outputDevice->write("\r\x1B[K");outputDevice->write("            |-- QVVR_Rptname: " + QByteArray(ied_usr.LD_info[i].qvvr[j].QVVR_Rptname) + "\n");
                    outputDevice->write("\r\x1B[K");outputDevice->write("            |-- timestamp: " + QByteArray::number(ied_usr.LD_info[i].qvvr[j].timestamp) + "\n");
                }
            }
        }
    }
    outputDevice->write("\r\x1B[K");outputDevice->write("------------------------------------\n");
}

// <20><>ӡ<EFBFBD><D3A1><EFBFBD><EFBFBD><EFBFBD>豸<EFBFBD><E8B1B8>Ϣ<EFBFBD><CFA2><EFBFBD>ض<EFBFBD><D8B6>ն<EFBFBD><D5B6><EFBFBD>Ϣ
void ledger(const char* terminal_id, QIODevice* outputDevice) {
	outputDevice->write("\r\x1B[K");
	outputDevice->write("print ledger in shell");
	pthread_mutex_lock(&mtx);   std::cout << "ledger()hold lock !!!!!!!!!!!" << std::endl;
    bool found = false;
    ied_t* ied;
    ied_usr_t* ied_usr;
    for (int t = 0; t < g_node->n_clients; t++) {
        ied = (ied_t*)g_node->clients[t];
		if(ied != NULL){
			ied_usr = (ied_usr_t*)ied->usr_ext;
        	if (ied_usr != NULL && (terminal_id == NULL || strcmp(ied_usr->terminal_id, terminal_id) == 0)) {
            	printLedgerinshell(*ied_usr, outputDevice);  // ʹ<><CAB9> QIODevice <20><><EFBFBD><EFBFBD>
				//std::cout << "!!! print to log !!!"<< std::endl;
				//printLedger(*ied_usr);
				if(terminal_id != NULL && strcmp(ied_usr->terminal_id, terminal_id) == 0){
					found = true;
				}
            	
        	}
		}
        
    }
	pthread_mutex_unlock(&mtx); std::cout << "ledger()free lock !!!!!!!!!!!" << std::endl;
    if (terminal_id != NULL && !found) {
		std::cout << "terminal not exsist: " << terminal_id << std::endl;
        QByteArray msg = "terminal not exsist: " + QByteArray(terminal_id) + "\n";
		outputDevice->write("\r\x1B[K");
        outputDevice->write(msg);  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> QIODevice
    }
	
}

//lnk20250210<31><30>ӡָ<D3A1><D6B8><EFBFBD>ı<EFBFBD><C4B1><EFBFBD><EFBFBD><EFBFBD>
void value_print(const char *variableName, QTcpSocket *clientSocket) {
    char buffer[256];  // <20><><EFBFBD>ڴ洢<DAB4><E6B4A2><EFBFBD><EFBFBD>ֵ<EFBFBD>Ļ<EFBFBD><C4BB><EFBFBD><EFBFBD><EFBFBD>

	pthread_mutex_lock(&mtx); std::cout << "value_print hold lock !!!!!!!!!!!" << std::endl;
    // <20><>ӡ<EFBFBD><D3A1><EFBFBD><EFBFBD>ֵ
	
    if (strcmp(variableName, "frontindex") == 0) {
        sprintf(buffer, "frontindex = %d", g_front_seg_index);  // <20><> int ת<><D7AA>Ϊ<EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>
		clientSocket->write("\r\x1B[K");
        clientSocket->write(buffer);  // <20><><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͻ<EFBFBD><CDBB><EFBFBD>
    }
	else if (strcmp(variableName, "remtable") == 0) {
        sprintf(buffer, "remtable = %d",g_pt61850app->chnl_counts);
		clientSocket->write("\r\x1B[K");
        clientSocket->write(buffer);
    } 
	else if (strcmp(variableName, "iedcount") == 0) {
        sprintf(buffer, "g_node->n_clients = %d, ied config count = %d",g_node->n_clients ,IED_COUNT);
		clientSocket->write("\r\x1B[K");
        clientSocket->write(buffer);
    } else if (strcmp(variableName, "frontfun") == 0) {
        sprintf(buffer, "frontfun = %s", subdir);
		clientSocket->write("\r\x1B[K");
        clientSocket->write(buffer); 
	} else if (strcmp(variableName, "log") == 0) {
		sprintf(buffer, "showinshellflag = %d,debugOutputEnabled = %d,normalOutputEnabled = %d,warnOutputEnabled = %d,errorOutputEnabled = %d", showinshellflag,debugOutputEnabled,normalOutputEnabled,warnOutputEnabled,errorOutputEnabled);
		clientSocket->write("\r\x1B[K");
		clientSocket->write(buffer);
	}else if (strcmp(variableName, "init") == 0) {
		sprintf(buffer, "INITFLAG = %d",INITFLAG);
		clientSocket->write("\r\x1B[K");
		clientSocket->write(buffer);
	}else {
		clientSocket->write("\r\x1B[K");
        clientSocket->write("Unknown variable name\n> ");
    }
	pthread_mutex_unlock(&mtx); std::cout << "value_print free lock !!!!!!!!!!!" << std::endl;
    clientSocket->flush();
}

std::list<std::string>* getLogList(const QString& level) {
	if (level == "ERROR") return &errorList;
	if (level == "WARN") return &warnList;
	if (level == "NORMAL") return &normalList;
	if (level == "DEBUG") return &debugList;
	return NULL;
}

pthread_mutex_t* getLogMutex(const QString& level) {
	if (level == "ERROR") return &errorListMutex;
	if (level == "WARN") return &warnListMutex;
	if (level == "NORMAL") return &normalListMutex;
	if (level == "DEBUG") return &debugListMutex;
	return NULL;
}

void Worker::handleViewLogCommand(const QString& command, QTcpSocket* clientSocket) {
    QStringList parts = command.split(" ");
    if (parts.size() != 2) {
		clientSocket->write("\r\x1B[K");
        clientSocket->write("Usage: viewlog [ERROR|WARN|NORMAL|DEBUG]\n> ");
        clientSocket->flush();
        return;
    }

    QString logLevel = parts[1].toUpper();
    std::list<std::string>* logList = getLogList(logLevel);
    pthread_mutex_t* logMutex = getLogMutex(logLevel);

    if (!logList || !logMutex) {
		clientSocket->write("\r\x1B[K");
        clientSocket->write("Invalid log level! Use ERROR, WARN, NORMAL, or DEBUG.\n> ");
        clientSocket->flush();
        return;
    }

    stopViewLog = false;
    activeClient = clientSocket;  // <20><>¼<EFBFBD><C2BC>ǰ shell socket

	clientSocket->write("\r\x1B[K");
    clientSocket->write(QString("Viewing logs for level: %1 (Press '`' to exit)\n> ").arg(logLevel).toUtf8());
    clientSocket->flush();

    while (!stopViewLog) {
        // **1. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>룬<EFBFBD>û<EFBFBD><C3BB><EFBFBD><EFBFBD><EFBFBD> ``` <20>˳<EFBFBD>**
        if (clientSocket->waitForReadyRead(500)) {  // ? <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
            QByteArray input = clientSocket->readAll().trimmed();
            if (input == "`") {  // ? <20>û<EFBFBD><C3BB><EFBFBD><EFBFBD><EFBFBD> ```<60><><EFBFBD>˳<EFBFBD><CBB3><EFBFBD>־ģʽ
                std::cout << "Received '`' from shell socket! Exiting viewlog...\n";
                stopViewLog = true;
				showinshellflag = false;
                break;
            }
        }

        // **2. <20><>ȡ<EFBFBD><C8A1>־<EFBFBD><D6BE><EFBFBD>ݲ<EFBFBD><DDB2><EFBFBD><EFBFBD><EFBFBD>**
        pthread_mutex_lock(logMutex);
        if (!logList->empty()) {
            std::string logEntry = logList->front();
            logList->pop_front();
            pthread_mutex_unlock(logMutex);

            if (!logEntry.empty()) {
				clientSocket->write("\r\x1B[K");
                clientSocket->write((logEntry + "\n").c_str());
                clientSocket->flush();
            }
        } else {
            pthread_mutex_unlock(logMutex);
            usleep(500000);  // ? <20><>ֹ CPU 100% ռ<><D5BC>
        }
    }

    // **3. <20>˳<EFBFBD> `viewlog`<60><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Shell**
	clientSocket->write("\r\x1B[K");
    clientSocket->write("\nLog view stopped. Returning to shell.\n> ");
    clientSocket->flush();
}

//////////////////////////////////////////////////////////////////////////////////////////////////
// <20><><EFBFBD><EFBFBD> JSON <20>ĺ<EFBFBD><C4BA><EFBFBD>  <20><>ǰ<EFBFBD>ö<EFBFBD>̬<EFBFBD><CCAC><EFBFBD><EFBFBD>
int terminal_ledger_web(QMap<QString, terminal_dev*>* terminal_dev_map,
                        const std::vector<std::string>& codes,
                        int index,
                        int num)
{
	//<2F><><EFBFBD><EFBFBD><EFBFBD>޸<EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>index<65><78><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1>Ӧ<EFBFBD><D3A6>̨<EFBFBD>ˣ<EFBFBD>num<75><6D>û<EFBFBD><C3BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ˣ<EFBFBD>index<65><78><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD>Ҳû<D2B2><C3BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	if(1 == MULTIPLE_NODE_FLAG){
		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>֤
    	if (num <= 0) {
    	    std::cerr << "Error: 'num' must be greater than 0." << std::endl;
    	    return 1; // <20><><EFBFBD><EFBFBD><EFBFBD>ʵ<EFBFBD><CAB5>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD>
    	}

		index = index - 1;
    	if (index < 0 || index >= num) {
    	    std::cerr << "Error: 'index' must be in the range [0, num-1]." << std::endl;
    	    return 1; // <20><><EFBFBD><EFBFBD><EFBFBD>ʵ<EFBFBD><CAB5>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD>
    	}
	}    

    // <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>
    if (codes.empty()) {
        std::cerr << "Error: 'codes' vector is empty." << std::endl;
        return 1;
    }

    std::string parm = codes[0];

    char* ptr = NULL;

    // <20><><EFBFBD><EFBFBD> API <20><><EFBFBD><EFBFBD>
    SendJsonAPI_web(WEB_DEVICE, "",parm.c_str(), &ptr);

    if (ptr == NULL) {
        std::cerr << "Error: Received NULL response from SendJsonAPI_web." << std::endl;
        return 1;
    }

    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    printf("ptr:%s\n", ptr);

    cJSON* root = cJSON_Parse(ptr);   //json<6F><6E>ʽ<EFBFBD><CABD><EFBFBD>л<EFBFBD>

	int retry = 0;

	if (root == NULL) {
		printf("web error %s\n", cJSON_GetErrorPtr());

		//<2F>ط<EFBFBD><D8B7><EFBFBD><EFBFBD><EFBFBD>
		while(root == NULL){
			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ǰ<EFBFBD>ͷ<EFBFBD>֮ǰ<D6AE><C7B0> ptr <20>Ա<EFBFBD><D4B1><EFBFBD><EFBFBD>ڴ<EFBFBD>й©
            if (ptr != NULL) {
                free(ptr);
                ptr = NULL;
            }
			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>url<72><6C><EFBFBD><EFBFBD>
			//SendJsonAPI_web("http://192.168.1.149:8091/powerQuality/getProperties", parm.c_str(), "",&ptr);
			SendJsonAPI_web(WEB_DEVICE, "",parm.c_str(), &ptr);

			if(ptr == NULL){
				retry++;if(retry>3)break;
				continue;
			}

			root = cJSON_Parse(ptr);
			retry++;if(retry>3)break;
		}
		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ժ<EFBFBD><D4BA><EFBFBD>Ȼʧ<C8BB>ܣ<EFBFBD>ȷ<EFBFBD><C8B7><EFBFBD>˳<EFBFBD>ǰ<EFBFBD>ͷ<EFBFBD><CDB7>κ<EFBFBD><CEBA>ѷ<EFBFBD><D1B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD>
        if (root == NULL) {
			printf("web error %s\n", cJSON_GetErrorPtr());
            return 1; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD>ʵ<EFBFBD><CAB5>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD>
        }
	}

    // <20><>ȡ "code" <20><> "msg"
    cJSON* codeItem = cJSON_GetObjectItem(root, "code");
    cJSON* msgItem = cJSON_GetObjectItem(root, "msg");

    // ʹ<><CAB9> std::string <20><>ȡֵ
    std::string code = (codeItem != NULL && codeItem->type == cJSON_String) ? codeItem->valuestring : "not found";
    std::string msg = (msgItem != NULL && msgItem->type == cJSON_String) ? msgItem->valuestring : "not found";

    // <20><>ӡ<EFBFBD><D3A1><EFBFBD><EFBFBD>
    std::cout << "code: " << code << std::endl;
    std::cout << "msg: " << msg << std::endl;

    // <20><>ȡ "data" <20><><EFBFBD><EFBFBD>
    cJSON* data = cJSON_GetObjectItem(root, "data");
    if (!data || data->type != cJSON_Array) {
        std::cerr << "Error: 'data' is not an array." << std::endl;
        cJSON_Delete(root);
        free(ptr);
        return 1;
    }

    int data_size = cJSON_GetArraySize(data);

	std::cout << "data_size " << data_size << std::endl;

    if (data_size == 0) {
        std::cerr << "Error: 'data' array is empty." << std::endl;
        cJSON_Delete(root);
        free(ptr);
        return 1;
    }

	//<2F><><EFBFBD><EFBFBD><EFBFBD>޸<EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>index<65><78><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1>Ӧ<EFBFBD><D3A6>̨<EFBFBD>ˣ<EFBFBD><CBA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>پ<EFBFBD><D9BE>֣<EFBFBD><D6A3><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>̨<EFBFBD>˲<EFBFBD><CBB2>жϽ<D0B6><CFBD>̺<EFBFBD>
#if 0
	int base_size = 0;
	int remainder = 0;
	int start_index = 0;
	int end_index = data_size;

	if(1 == MULTIPLE_NODE_FLAG){
		// <20><><EFBFBD><EFBFBD>ÿ<EFBFBD>ݵĴ<DDB5>С
    	base_size = data_size / num;
    	remainder = data_size % num;

    	// <20><><EFBFBD>㵱ǰ<E3B5B1>ݵ<EFBFBD><DDB5><EFBFBD>ʼ<EFBFBD>ͽ<EFBFBD><CDBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    	start_index = index * base_size + (index < remainder ? index : remainder);
    	end_index = start_index + base_size + (index < remainder ? 1 : 0);

    	// ȷ<><C8B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С
    	if (end_index > data_size) {
    	    end_index = data_size;
    	}
	}
#endif
	int start_index = 0;
	int end_index = data_size;

    // <20><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>Χ<EFBFBD>ڵ<EFBFBD>Ԫ<EFBFBD><D4AA>
    for (int i = start_index; i < end_index; ++i) {
        cJSON* item = cJSON_GetArrayItem(data, i);
        if (!item || item->type != cJSON_Object) {
            std::cerr << "Warning: Invalid item at index " << i << "." << std::endl;
            continue; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ч<EFBFBD><D0A7><EFBFBD><EFBFBD>
        }

        terminal_dev* dev = new terminal_dev();
        memset(dev, 0, sizeof(terminal_dev)); // <20><>ʼ<EFBFBD><CABC><EFBFBD>ṹ<EFBFBD><E1B9B9>

        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֶ<EFBFBD>
        cJSON* id = cJSON_GetObjectItem(item, "id"); // terminal_id
        if (id && id->type == cJSON_String) strncpy(dev->terminal_id, id->valuestring, sizeof(dev->terminal_id) - 1);
        else strncpy(dev->terminal_id, "N/A", sizeof(dev->terminal_id) - 1);

        cJSON* ip = cJSON_GetObjectItem(item, "ip"); // addr_str
        if (ip && ip->type == cJSON_String) strncpy(dev->addr_str, ip->valuestring, sizeof(dev->addr_str) - 1);
        else strncpy(dev->addr_str, "N/A", sizeof(dev->addr_str) - 1);

        cJSON* terminalCode = cJSON_GetObjectItem(item, "name"); // terminal_code
        if (terminalCode && terminalCode->type == cJSON_String) strncpy(dev->terminal_code, terminalCode->valuestring, sizeof(dev->terminal_code) - 1);
        else strncpy(dev->terminal_code, "N/A", sizeof(dev->terminal_code) - 1);

        cJSON* orgName = cJSON_GetObjectItem(item, "org_name"); // org_name
        if (orgName && orgName->type == cJSON_String) strncpy(dev->org_name, orgName->valuestring, sizeof(dev->org_name) - 1);
        else strncpy(dev->org_name, "N/A", sizeof(dev->org_name) - 1);

        cJSON* maintName = cJSON_GetObjectItem(item, "maint_name"); // maint_name
        if (maintName && maintName->type == cJSON_String) strncpy(dev->maint_name, maintName->valuestring, sizeof(dev->maint_name) - 1);
        else strncpy(dev->maint_name, "N/A", sizeof(dev->maint_name) - 1);

        cJSON* stationName = cJSON_GetObjectItem(item, "stationName"); // station_name
        if (stationName && stationName->type == cJSON_String) strncpy(dev->station_name, stationName->valuestring, sizeof(dev->station_name) - 1);
        else strncpy(dev->station_name, "N/A", sizeof(dev->station_name) - 1);

        cJSON* manufacturer = cJSON_GetObjectItem(item, "manufacturer"); // tmnl_factory
        if (manufacturer && manufacturer->type == cJSON_String) strncpy(dev->tmnl_factory, manufacturer->valuestring, sizeof(dev->tmnl_factory) - 1);
        else strncpy(dev->tmnl_factory, "N/A", sizeof(dev->tmnl_factory) - 1);

        cJSON* status = cJSON_GetObjectItem(item, "status"); // tmnl_status
        if (status && status->type == cJSON_String) strncpy(dev->tmnl_status, status->valuestring, sizeof(dev->tmnl_status) - 1);
        else strncpy(dev->tmnl_status, "N/A", sizeof(dev->tmnl_status) - 1);

        cJSON* devType = cJSON_GetObjectItem(item, "devType"); // dev_type
        if (devType && devType->type == cJSON_String) strncpy(dev->dev_type, devType->valuestring, sizeof(dev->dev_type) - 1);
        else strncpy(dev->dev_type, "N/A", sizeof(dev->dev_type) - 1);

        cJSON* devKey = cJSON_GetObjectItem(item, "devKey"); // dev_key
        if (devKey && devKey->type == cJSON_String) strncpy(dev->dev_key, devKey->valuestring, sizeof(dev->dev_key) - 1);
        else strncpy(dev->dev_key, "N/A", sizeof(dev->dev_key) - 1);

        cJSON* series = cJSON_GetObjectItem(item, "series"); // dev_series
        if (series && series->type == cJSON_String) strncpy(dev->dev_series, series->valuestring, sizeof(dev->dev_series) - 1);
        else strncpy(dev->dev_series, "N/A", sizeof(dev->dev_series) - 1);

		//lnk20250210̨<30>˽<EFBFBD><CBBD>̺<EFBFBD>
		cJSON* processNo = cJSON_GetObjectItem(item, "processNo"); // processNoתΪ<D7AA>ַ<EFBFBD><D6B7><EFBFBD>
        if (processNo && processNo->type == cJSON_Number) snprintf(dev->processNo, sizeof(dev->processNo), "%d", processNo->valueint);
        else strncpy(dev->processNo, "N/A", sizeof(dev->processNo) - 1);

        cJSON* port = cJSON_GetObjectItem(item, "port"); // port
        if (port && port->type == cJSON_String) strncpy(dev->port, port->valuestring, sizeof(dev->port) - 1);
        else strncpy(dev->port, "N/A", sizeof(dev->port) - 1);

        cJSON* updateTime = cJSON_GetObjectItem(item, "updateTime"); // timestamp
        if (updateTime && updateTime->type == cJSON_String) strncpy(dev->timestamp, updateTime->valuestring, sizeof(dev->timestamp) - 1);
        else strncpy(dev->timestamp, "N/A", sizeof(dev->timestamp) - 1);

        // <20><><EFBFBD><EFBFBD> monitorData <20><><EFBFBD><EFBFBD>
        cJSON* monitorData = cJSON_GetObjectItem(item, "monitorData");
        if (monitorData && monitorData->type == cJSON_Array) {
            int j = 0;
            cJSON* monitorItem;
            cJSON_ArrayForEach(monitorItem, monitorData) {
                if (j >= 10){
                    std::cout << "һ<EFBFBD><EFBFBD><EFBFBD>ն<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֻ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʮ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>" << std::endl;
                    break;  // <20><><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>10<31><30>
                }

                cJSON* monitor_id = cJSON_GetObjectItem(monitorItem, "id"); // monitor_id
                if (monitor_id && monitor_id->type == cJSON_String) strncpy(dev->line[j].monitor_id, monitor_id->valuestring, sizeof(dev->line[j].monitor_id) - 1);
                else strncpy(dev->line[j].monitor_id, "N/A", sizeof(dev->line[j].monitor_id) - 1);

                cJSON* monitor_name = cJSON_GetObjectItem(monitorItem, "name"); // monitor_name
                if (monitor_name && monitor_name->type == cJSON_String) strncpy(dev->line[j].monitor_name, monitor_name->valuestring, sizeof(dev->line[j].monitor_name) - 1);
                else strncpy(dev->line[j].monitor_name, "N/A", sizeof(dev->line[j].monitor_name) - 1);

                cJSON* lineNo = cJSON_GetObjectItem(monitorItem, "lineNo"); // logical_device_seq
                if (lineNo && lineNo->type == cJSON_String) strncpy(dev->line[j].logical_device_seq, lineNo->valuestring, sizeof(dev->line[j].logical_device_seq) - 1);
                else strncpy(dev->line[j].logical_device_seq, "N/A", sizeof(dev->line[j].logical_device_seq) - 1);

                cJSON* voltageLevel = cJSON_GetObjectItem(monitorItem, "voltageLevel"); // voltage_level
                if (voltageLevel && voltageLevel->type == cJSON_String) strncpy(dev->line[j].voltage_level, voltageLevel->valuestring, sizeof(dev->line[j].voltage_level) - 1);
                else strncpy(dev->line[j].voltage_level, "N/A", sizeof(dev->line[j].voltage_level) - 1);

                cJSON* ptType = cJSON_GetObjectItem(monitorItem, "ptType"); // terminal_connect
                if (ptType && ptType->type == cJSON_String) strncpy(dev->line[j].terminal_connect, ptType->valuestring, sizeof(dev->line[j].terminal_connect) - 1);
                else strncpy(dev->line[j].terminal_connect, "N/A", sizeof(dev->line[j].terminal_connect) - 1);

                // <20><><EFBFBD>Ӽ<EFBFBD><D3BC><EFBFBD><EFBFBD><EFBFBD>״̬
                cJSON* monitorstatus = cJSON_GetObjectItem(monitorItem, "status"); // status
                if (monitorstatus && monitorstatus->type == cJSON_String) strncpy(dev->line[j].status, monitorstatus->valuestring, sizeof(dev->line[j].status) - 1);
                else strncpy(dev->line[j].status, "N/A", sizeof(dev->line[j].status) - 1);

                j++;
            }
        }

        // ׼<><D7BC><EFBFBD><EFBFBD>
    	QString key = QString(dev->terminal_id);//<2F><>id<69><64><EFBFBD><EFBFBD><EFBFBD><EFBFBD>code<64><65><EFBFBD>֣<EFBFBD><D6A3>е<EFBFBD>code<64><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

    	// <20><><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ظ<EFBFBD><D8B8><EFBFBD>
    	if (terminal_dev_map->contains(key)) {
        	std::cerr << "Duplicate terminal_code found: " << key.toStdString() << std::endl;

        	// ɾ<><C9BE><EFBFBD>ɵ<EFBFBD> terminal_dev <20><><EFBFBD><EFBFBD><EFBFBD>Ա<EFBFBD><D4B1><EFBFBD><EFBFBD>ڴ<EFBFBD>й©
        	delete terminal_dev_map->value(key);

        	// <20>Ƴ<EFBFBD><C6B3>ɵļ<C9B5>ֵ<EFBFBD><D6B5>
        	terminal_dev_map->remove(key);

        	// <20><><EFBFBD><EFBFBD><EFBFBD>µ<EFBFBD> terminal_dev <20><><EFBFBD><EFBFBD>
			if(atoi(dev->processNo) == g_front_seg_index || g_front_seg_index == 0){//lnk20250210ƥ<30><C6A5><EFBFBD><EFBFBD><EFBFBD>̺<EFBFBD>
				//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				std::cout<< "process num match" << std::endl;
        		terminal_dev_map->insert(key, dev);}//<2F><><EFBFBD><EFBFBD><EFBFBD>޸<EFBFBD>Ϊֻ<CEAA>н<EFBFBD><D0BD>̺<EFBFBD>ƥ<EFBFBD><C6A5><EFBFBD><EFBFBD>index<65><78>¼<EFBFBD>뵱ǰ<EBB5B1><C7B0><EFBFBD><EFBFBD>
    	} else {
        	// <20><><EFBFBD><EFBFBD><EFBFBD>µ<EFBFBD> terminal_dev <20><><EFBFBD><EFBFBD>
			if(atoi(dev->processNo) == g_front_seg_index ||  g_front_seg_index == 0){//lnk20250210ƥ<30><C6A5><EFBFBD><EFBFBD><EFBFBD>̺<EFBFBD>
				//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				std::cout<< "process num match" << std::endl;
        		terminal_dev_map->insert(key, dev);}//<2F><><EFBFBD><EFBFBD><EFBFBD>޸<EFBFBD>Ϊֻ<CEAA>н<EFBFBD><D0BD>̺<EFBFBD>ƥ<EFBFBD><C6A5><EFBFBD><EFBFBD>index<65><78>¼<EFBFBD>뵱ǰ<EBB5B1><C7B0><EFBFBD><EFBFBD>
			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
			//std::cout << "i =  " << i << std::endl;
			//std::cout << "terminal_dev_map.size:" << terminal_dev_map->size() << std::endl;
    	}//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ظ<EFBFBD><D8B8><EFBFBD><EEA3AC>־Ҫ<D6BE><D2AA><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD>Ų<EFBFBD>

		
    }

    // <20>ͷ<EFBFBD><CDB7><EFBFBD>Դ
    cJSON_Delete(root);
    free(ptr);

    return 0; // ȷ<><C8B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>з<EFBFBD><D0B7><EFBFBD>ֵ
}

int parse_device_cfg_web()
{
	std::cout << "parse_device_cfg_web" << endl;

	std::vector<std::string> codes;	//<2F><><EFBFBD>μ<EFBFBD><CEBC><EFBFBD>

	ied_t* ied;
	ied_usr_t* ied_usr;
	chnl_usr_t* chnl_usr;
	int count_cfg = 0;	//<2F>ն<EFBFBD>̨<EFBFBD><CCA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	int count_real = 0;	//<2F><><EFBFBD><EFBFBD><EFBFBD>ն<EFBFBD>̨<EFBFBD>˵ļ<CBB5><C4BC><EFBFBD><EFBFBD><EFBFBD>

	//<2F>ӿںϲ<DABA><CFB2><EFBFBD>ֻ<EFBFBD><D6BB>һ<EFBFBD><D2BB>web<65>ӿڻ<D3BF>ȡ<EFBFBD>ն<EFBFBD>̨<EFBFBD>˺ͼ<CBBA><CDBC><EFBFBD><EFBFBD><EFBFBD>̨<EFBFBD><CCA8>
	QMap<QString, terminal_dev*> terminal_dev_map;	

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>json
	std::string input_jstr = "{";
	input_jstr += "\"ip\":\"" + std::string(FRONT_IP) + "\",";
	input_jstr += "\"runFlag\":" + TERMINAL_STATUS + "";
	input_jstr += "}";

	std::cout << "input_jstr: " << input_jstr << std::endl; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

	codes.push_back(input_jstr);	//<2F>Ƿ<EFBFBD><C7B7><EFBFBD>Ҫɸѡ״ֱ̬<CCAC><D6B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>

	terminal_ledger_web(&terminal_dev_map,codes,g_front_seg_index,g_front_seg_num);
	codes.clear();

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	//printTerminalDevMap(terminal_dev_map);

	count_cfg = terminal_dev_map.size();//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̨<EFBFBD>˵<EFBFBD><CBB5><EFBFBD><EFBFBD><EFBFBD>

	std::cout << "terminal_ledger_num:" << count_cfg << std::endl;

	g_node->n_clients = count_cfg;
	//<2F><><EFBFBD>￪<EFBFBD>ٵ<EFBFBD>ied<65>Ŀռ<C4BF><D5BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC>е<EFBFBD><D0B5>ն<EFBFBD>̨<EFBFBD><CCA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>lnk20250121
	if(IED_COUNT < count_cfg){		//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>dz<EFBFBD>ʼ<EFBFBD><CABC><EFBFBD>ܶ<EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>̨<EFBFBD><CCA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֹ<EFBFBD><D6B9><EFBFBD><EFBFBD>ʧ<EFBFBD><CAA7><EFBFBD><EFBFBD><EFBFBD>µı<C2B5><C4B1><EFBFBD><EFBFBD><EFBFBD>
		//<2F><><EFBFBD><EFBFBD><EFBFBD>Ƕ<EFBFBD><C7B6><EFBFBD><EFBFBD>̣<EFBFBD>IED_COUNTӦ<54><D3A6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>ƽ<EFBFBD><C6BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		//<2F><><EFBFBD><EFBFBD><EFBFBD>ǵ<EFBFBD><C7B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD><EFBFBD>ն<EFBFBD><D5B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		//<2F><><EFBFBD><EFBFBD><EFBFBD>̶<EFBFBD><CCB6><EFBFBD><EFBFBD><EFBFBD>ͬʱ<CDAC><CAB1><EFBFBD><EFBFBD><EFBFBD>򵥽<EFBFBD><F2B5A5BD><EFBFBD>Ӧ<EFBFBD>ô<EFBFBD><C3B4><EFBFBD><EFBFBD>ն<EFBFBD><D5B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̨<EFBFBD><CCA8>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD>̲<EFBFBD><CCB2>־<EFBFBD><D6BE>޷<EFBFBD>ͬ<EFBFBD><CDAC><EFBFBD><EFBFBD><EFBFBD>ӡ<EFBFBD>
		g_node->clients = (ied_t**)apr_pcalloc(g_cfg_pool, count_cfg * sizeof(ied_t*));
		//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʾ
		std::cout << "!!!!!!!!!!single process can not add any ledger unless reboot!!!!!!!"<< std::endl;
	}
	else{
		g_node->clients = (ied_t**)apr_pcalloc(g_cfg_pool, IED_COUNT * sizeof(ied_t*));//g_node->clients <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD><DAB4>ռ<EFBFBD><D5BC>洢<EFBFBD><E6B4A2> count_cfg <20><> ied_t* <20><><EFBFBD>͵<EFBFBD>ָ<EFBFBD>루<EFBFBD><EBA3A8>һ<EFBFBD><D2BB>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD>飩<EFBFBD><E9A3A9><EFBFBD>ǣ<EFBFBD>ָ<EFBFBD><D6B8><EFBFBD>ڴ<EFBFBD><DAB4><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD>룩<EFBFBD><EBA3A9>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	}
	
	//<2F><>ied<65><64><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	
	for (int k = 0; k < count_cfg; k++){

		//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		std::cout << "!!!!!!!!!!gnodeindex:" << k  << std::endl;

		g_node->clients[k] = (ied_t*)apr_pcalloc(g_cfg_pool, sizeof(ied_t));}//ÿ<><C3BF> g_node->clients[k] ָ<><D6B8><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD><DAB4><EFBFBD><EFBFBD>Ƕ<EFBFBD><C7B6><EFBFBD><EFBFBD>ģ<EFBFBD>ÿ<EFBFBD><C3BF> ied_t <20>ṹ<EFBFBD><E1B9B9>ռ<EFBFBD>õ<EFBFBD><C3B5>ڴ<EFBFBD><DAB4>飩<EFBFBD><E9A3A9><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD>ڴ<EFBFBD><DAB4><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>

//<2F><>ȡ<EFBFBD>ն<EFBFBD>̨<EFBFBD>˱<EFBFBD><CBB1>滻Ϊweb<65>ӿ<EFBFBD>
//////////////////////////////////////////////////////////////////////////////////////////////////
	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	try {
		char terminal_id[64];
		char terminal_code[64];
		char org_name[64];
		char maint_name[64];
		char station_name[64];
		char tmnl_factory[64];
		char tmnl_status[64];
		char dev_type[64];
		char dev_key[255];
		char dev_series[255];
		char addr_str[64];
		char port_char[64];

		//lnk20250210<31><30><EFBFBD>ӽ<EFBFBD><D3BD>̺<EFBFBD>
		char processNo[64];

		otl_datetime timestamp;

		// <20><><EFBFBD><EFBFBD><EFBFBD>ն<EFBFBD>̨<EFBFBD><CCA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		QMap<QString, terminal_dev*>::iterator it;
    	for (it = terminal_dev_map.begin(); it != terminal_dev_map.end(); ++it) {
    		terminal_dev* value = it.value();

			// ȷ<><C8B7> value <20><>Ϊ<EFBFBD><CEAA>
    		if (value != nullptr) {
        		// <20>ҵ<EFBFBD><D2B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD>Ʋ<EFBFBD>ȡֵ
        		strncpy(terminal_id, value->terminal_id, sizeof(terminal_id) - 1);
        		strncpy(terminal_code, value->terminal_code, sizeof(terminal_code) - 1);
        		strncpy(org_name, value->org_name, sizeof(org_name) - 1);
        		strncpy(maint_name, value->maint_name, sizeof(maint_name) - 1);
        		strncpy(station_name, value->station_name, sizeof(station_name) - 1);
        		strncpy(tmnl_factory, value->tmnl_factory, sizeof(tmnl_factory) - 1);
        		strncpy(tmnl_status, value->tmnl_status, sizeof(tmnl_status) - 1);
        		strncpy(dev_type, value->dev_type, sizeof(dev_type) - 1);
        		strncpy(dev_key, value->dev_key, sizeof(dev_key) - 1);
        		strncpy(dev_series, value->dev_series, sizeof(dev_series) - 1);
        		strncpy(addr_str, value->addr_str, sizeof(addr_str) - 1);
        		strncpy(port_char, value->port, sizeof(port_char) - 1);
				strncpy(processNo, value->processNo, sizeof(processNo) - 1);//<2F><><EFBFBD>̺<EFBFBD>
				timestamp = parseTimestamp(value->timestamp);

				//<2F><><EFBFBD><EFBFBD><EFBFBD>ն<EFBFBD>̨<EFBFBD><CCA8>
				ied = g_node->clients[count_real++];
				//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀռ<C4BF><D5BC><EFBFBD><EFBFBD><EFBFBD>ied<65><64><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ص<EFBFBD>ied<65><64>
				ied_usr = (ied_usr_t*)apr_pcalloc(g_init_pool, sizeof(ied_usr_t));//<2F>ն<EFBFBD>̨<EFBFBD><CCA8><EFBFBD><EFBFBD>initpool<6F><6C><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ռ<EFBFBD>
				ied->usr_ext = ied_usr;

				if (ied_usr == NULL)
					return APR_ENOMEM;

				ied_usr->last_call_wavelist_time = sGetMsTime() + g_pt61850app->giTime * 1000;
				//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀռ<C4BF><D5BC><EFBFBD><EFBFBD><EFBFBD>ied<65><64><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ص<EFBFBD>ied<65><64>
				ied_usr->LD_info = (LD_info_t*)apr_pcalloc(g_init_pool, MAX_CPUNO * sizeof(LD_info_t));//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̨<EFBFBD><CCA8><EFBFBD><EFBFBD>initpool<6F><6C><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ռ<EFBFBD>

				if (ied_usr->LD_info == NULL)
					return APR_ENOMEM;

				ied_usr->dev_flag = ENABLE;//<2F>ն<EFBFBD><D5B6><EFBFBD>Ч
				ied->chncount = 1;//<2F>豸ͨ<E8B1B8>Ŷ˿<C5B6><CBBF><EFBFBD><EFBFBD><EFBFBD>
				//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀռ<C4BF><D5BC><EFBFBD><EFBFBD><EFBFBD>ied<65><64><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ص<EFBFBD>ied<65><64>
				ied->channel = (channel_t*)apr_pcalloc(g_cfg_pool, sizeof(channel_t) * ied->chncount);//ͨ<>Žṹ<C5BD><E1B9B9>g_cfg_pool<6F><6C><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ռ䣺<D5BC>ն˵<D5B6>ip<69>˿ڵ<CBBF>
				ied->channel[0].ied = ied;
				ied->channel[0].status = STATUS_BREAKOFF;
				ied->cpucount = 0;

				if (strlen(terminal_id) != 0) {
					apr_snprintf(ied_usr->terminal_id, sizeof(ied_usr->terminal_id), "%s", terminal_id);//terminal_id
					cout << "ied_usr->terminal_id:" << ied_usr->terminal_id << endl;
				}
				if (terminal_code != NULL) {
					apr_snprintf(ied_usr->terminal_code, sizeof(ied_usr->terminal_code), "%s", terminal_code);//terminal_code
					cout << "ied_usr->terminal_code:" << ied_usr->terminal_code << endl;
				}
	/*<2A><><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ			
				if (org_name != NULL) {
					apr_snprintf(ied_usr->org_name, sizeof(ied_usr->org_name), "%s", org_name);//org_name
					cout << "ied_usr->org_name:" << ied_usr->org_name << endl;

				}
				if (maint_name != NULL) {
					apr_snprintf(ied_usr->maint_name, sizeof(ied_usr->maint_name), "%s", maint_name);//maint_name
					cout << "ied_usr->maint_name:" << ied_usr->maint_name << endl;

				}
				if (station_name != NULL) {
					apr_snprintf(ied_usr->station_name, sizeof(ied_usr->station_name), "%s", station_name);//station_name
					cout << "ied_usr->station_name:" << ied_usr->station_name << endl;
				}
				*/
				if (tmnl_factory != NULL) {
					apr_snprintf(ied_usr->tmnl_factory, sizeof(ied_usr->tmnl_factory), "%s", tmnl_factory);//tmnl_factory
					cout << "ied_usr->tmnl_factory:" << ied_usr->tmnl_factory << endl;
				}
				if (tmnl_status != NULL) {
					apr_snprintf(ied_usr->tmnl_status, sizeof(ied_usr->tmnl_status), "%s", tmnl_status);//tmnl_status
					cout << "ied_usr->tmnl_status:" << ied_usr->tmnl_status << endl;
				}
				if (dev_type != NULL) {
					apr_snprintf(ied_usr->dev_type, sizeof(ied_usr->dev_type), "%s", dev_type);//dev_type
					cout << "ied_usr->dev_type:" << ied_usr->dev_type << endl;
				}

				//lnk20250210̨<30>˽<EFBFBD><CBBD>̺<EFBFBD>
				if (processNo != NULL) {
					apr_snprintf(ied_usr->processNo, sizeof(ied_usr->processNo), "%s", processNo);//processNo
					cout << "ied_usr->processNo:" << ied_usr->processNo << endl;
				}

				if (dev_series != NULL) {
					apr_snprintf(ied_usr->dev_series, sizeof(ied_usr->dev_series), "%s", dev_series);//DEV_Series
					cout << "defalut dev_series:" << ied_usr->dev_series << endl;
				}
				else
				{
					apr_snprintf(ied_usr->dev_series, sizeof(ied_usr->dev_series), "%s", "");//DEV_Series
					cout << "defalut dev_series:" << ied_usr->dev_series << endl;
				}
				if (dev_key != NULL) {
					apr_snprintf(ied_usr->dev_key, sizeof(ied_usr->dev_key), "%s", dev_key);//DEV_Key
					cout << "defalut dev_key:" << ied_usr->dev_key << endl;
				}
				else
				{
					apr_snprintf(ied_usr->dev_key, sizeof(ied_usr->dev_key), "%s", "");//DEV_Key
					cout << "defalut dev_key:" << ied_usr->dev_key << endl;
				}

				//lnk20241125ʵʱ<CAB5><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				ied_usr->dev_idx = count_real;
				cout << "dev_idx:" << ied_usr->dev_idx << endl;

				ied->channel[0].channel_type = CHANNEL_TYPE_IPV4;//channel
				ied->channel[0].addr_str[LONGNAME - 1] = 0;//DEV_IP
				if (addr_str != NULL) {
					ied->channel[0].addr = ntohl(inet_addr(addr_str));//DEV_IP
					strncpy(ied->channel[0].addr_str, addr_str, LONGNAME - 1);//DEV_IP
					cout << "ied_usr->addr_str:" << ied->channel[0].addr_str << endl;
				}
				else
				{
					ied->channel[0].addr = ntohl(inet_addr("0.0.0.0"));//DEV_IP
					strncpy(ied->channel[0].addr_str, addr_str, LONGNAME - 1);//DEV_IP
					cout << "ied_usr->addr_str:" << ied->channel[0].addr_str << endl;
				}
				if (port_char != NULL) {
					int port = 102;
					if (stringToInt(port_char, &port)) {
						// ת<><D7AA><EFBFBD>ɹ<EFBFBD><C9B9><EFBFBD>portStrȫΪ<C8AB><CEAA><EFBFBD>֣<EFBFBD><D6A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ѿ<EFBFBD>ת<EFBFBD><D7AA>Ϊint<6E><74><EFBFBD>͵<EFBFBD>port  
						ied->channel[0].port = port;//DEV_PortID
						cout << "ied_usr->port:" << ied->channel[0].port << endl;//DEV_PortID
					}
					else {
						ied->channel[0].port = 102;//DEV_PortID
						cout << "ied_usr->port:" << port_char << ",<2C>ǺϷ<C7BA><CFB7>˿<EFBFBD>.ʹ<><CAB9>Ĭ<EFBFBD>϶˿<CFB6>:" << ied->channel[0].port << endl;//DEV_PortID
					}
				}
				if (timestamp.year != 0) {
					//// <20><><EFBFBD><EFBFBD>struct tm<74><6D><EFBFBD><EFBFBD>
					struct tm timeinfo;
					timeinfo.tm_year = timestamp.year - 1900; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA>ȥ1900
					timeinfo.tm_mon = timestamp.month - 1; // <20>·<EFBFBD><C2B7><EFBFBD>Ҫ<EFBFBD><D2AA>ȥ1
					timeinfo.tm_mday = timestamp.day;
					timeinfo.tm_hour = timestamp.hour;
					timeinfo.tm_min = timestamp.minute;
					timeinfo.tm_sec = timestamp.second;
					time_t time = std::mktime(&timeinfo);
					ied_usr->time = static_cast<long long>(time);
					cout << "ied_usr->time:" << ied_usr->time << endl;
				}

				//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀռ<C4BF><D5BC><EFBFBD><EFBFBD><EFBFBD>ied<65><64><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ص<EFBFBD>ied<65><64>
				chnl_usr = (chnl_usr_t*)apr_pcalloc(g_init_pool, sizeof(chnl_usr_t));//<2F><>չ<EFBFBD><D5B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͨ<EFBFBD>Žṹ<C5BD><E1B9B9>g_init_pool<6F><6C><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ռ䣺<D5BC><E4A3BA>չ<EFBFBD><D5B9>¼һЩ<D2BB><D0A9><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>Ϣ
				ied->channel[0].connect = chnl_usr;
				chnl_usr->chnl = &(ied->channel[0]);
				chnl_usr->chnl_id = 0;
				chnl_usr->m_state = CHANNEL_DISCONNECTED;
				chnl_usr->m_ClosedMsTime = NEXT_CONNECT_TIME * (-1);
				g_pt61850app->chnl_counts++;

				//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				//std::cout << "value:" << terminal_id <<"  "<<terminal_code <<"  "<<tmnl_factory <<"  "<<dev_series <<"  "<<dev_key <<"  "<< tmnl_status <<"  "<<dev_type <<"  "<<addr_str <<"  "<<port_char <<"  "<< timestamp.year << std::endl;

				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
				LD_info_t line_info;
				int count_real_monitor = 0;	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̨<EFBFBD>˵ļ<CBB5><C4BC><EFBFBD><EFBFBD><EFBFBD>

				//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				//std::cout << "n_clients:" << g_node->n_clients << std::endl;

				if (g_node->n_clients <= 0) {
					std::cout << "no terminal exist " << std::endl;
					return APR_EBADF;
				}

				char monitor_id[64];
				//char terminal_code[64];
				char monitor_name[64];
				char logical_device_seq[64];
				char voltage_level[64];
				char terminal_connect[64];
				char monitor_status[64];
				//otl_datetime timestamp;

            	//for (int j = 0; j < 10; ++j) { // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>10<31><30><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				for (int j = 0; value->line[j].monitor_id[0] != '\0'; ++j){
                	ledger_monitor& monitor = value->line[j];

                	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ID <20>Ƿ<EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD>Ա<EFBFBD><D4B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ч<EFBFBD><D0A7><EFBFBD><EFBFBD>
                	/*if (monitor.monitor_id[0] != '\0') { 
                	    std::cout << "  Monitor ID: " << monitor.monitor_id << std::endl;
                	    std::cout << "  Terminal Code: " << monitor.terminal_code << std::endl;		//Ӧ<><D3A6>Ϊ<EFBFBD>գ<EFBFBD>json<6F><6E><EFBFBD><EFBFBD>
                	    std::cout << "  Monitor Name: " << monitor.monitor_name << std::endl;
                	    std::cout << "  Logical Device Seq: " << monitor.logical_device_seq << std::endl;
                	    std::cout << "  Voltage Level: " << monitor.voltage_level << std::endl;
                	    std::cout << "  Terminal Connect: " << monitor.terminal_connect << std::endl;
                	    std::cout << "  Timestamp: " << monitor.timestamp << std::endl;				//Ӧ<><D3A6>Ϊ<EFBFBD><CEAA>json<6F><6E><EFBFBD><EFBFBD>
						std::cout << "  monitor_status: " << monitor.status << std::endl;*/

						strncpy(monitor_id, monitor.monitor_id, sizeof(monitor_id) - 1);
        				//strncpy(terminal_code, monitor.terminal_code, sizeof(terminal_code) - 1);	//<2F><><EFBFBD>ϼ<EFBFBD><CFBC><EFBFBD>ȡ
        				strncpy(monitor_name, monitor.monitor_name, sizeof(monitor_name) - 1);
        				strncpy(logical_device_seq, monitor.logical_device_seq, sizeof(logical_device_seq) - 1);
        				strncpy(voltage_level, monitor.voltage_level, sizeof(voltage_level) - 1);
        				strncpy(terminal_connect, monitor.terminal_connect, sizeof(terminal_connect) - 1);
						//timestamp = parseTimestamp(monitor.timestamp);								//<2F><><EFBFBD>ϼ<EFBFBD><CFBC><EFBFBD>ȡ
						strncpy(monitor_status, monitor.status, sizeof(monitor_status) - 1);//<2F><><EFBFBD>Ӽ<EFBFBD><D3BC><EFBFBD><EFBFBD><EFBFBD>״̬
						//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̨<EFBFBD>˴<EFBFBD><CBB4><EFBFBD>
						count_real_monitor++;

						memset(&line_info, 0, sizeof(line_info));

						line_info.line_id = count_real_monitor;			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ź<EFBFBD>
						cout << "line_id:" << line_info.line_id << endl;

						strcpy(line_info.mp_id, monitor_id);
						cout << "mp_id:" << line_info.mp_id << endl;

						strcpy(line_info.terminal_code, terminal_code);					//<2F><><EFBFBD>ϼ<EFBFBD><CFBC><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD>ն˺<D5B6>
						cout << "terminal_code:" << line_info.terminal_code << endl;

						if (isCharPtrEmpty(logical_device_seq)) {
							line_info.cpuno = 1;										//Ĭ<>ϼ<EFBFBD><CFBC><EFBFBD><EFBFBD><EFBFBD>ʵ<EFBFBD><CAB5><EFBFBD><EFBFBD>1
							cout << "logical_device_seq:is null,set cpuno:"<< line_info.cpuno << endl;
						}
						else {
							line_info.cpuno = std::atoi(logical_device_seq);
							cout << "logical_device_seq:"<< line_info.cpuno << endl;
						}
						//cout << "cpuno:" << line_info.cpuno << endl;

						strcpy(line_info.voltage_level, voltage_level);
						cout << "voltage_level:" << line_info.voltage_level << endl;

						strcpy(line_info.v_wiring_type, terminal_connect);
						cout << "v_wiring_type:" << line_info.v_wiring_type << endl;

						//lnk2024-8-14<31><34>¼<EFBFBD><C2BC><EFBFBD>߱<EFBFBD>־
						if (strcmp(line_info.v_wiring_type, "0") != 0)
						{
							isdelta_flag = 1;	//<2F><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD>ͽ<EFBFBD><CDBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ǰ<EFBFBD>þ<EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD>ڶ<EFBFBD><DAB6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD>
							cout << "monitor_id" << monitor_id << "v_wiring_type:" << line_info.v_wiring_type << "is delta wiring:" << isdelta_flag << endl;
						}

						strcpy(line_info.monitor_status, monitor_status);
						cout << "monitor_status:" << line_info.monitor_status << endl;

						//// <20><><EFBFBD><EFBFBD>struct tm<74><6D><EFBFBD><EFBFBD>
						struct tm timeinfo;
						timeinfo.tm_year = timestamp.year - 1900; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA>ȥ1900		//<2F><><EFBFBD>ϼ<EFBFBD><CFBC><EFBFBD>ȡ<EFBFBD><C8A1>timestamp
						timeinfo.tm_mon = timestamp.month - 1; // <20>·<EFBFBD><C2B7><EFBFBD>Ҫ<EFBFBD><D2AA>ȥ1
						timeinfo.tm_mday = timestamp.day;
						timeinfo.tm_hour = timestamp.hour;
						timeinfo.tm_min = timestamp.minute;
						timeinfo.tm_sec = timestamp.second;

						time_t time = std::mktime(&timeinfo);
						line_info.time = static_cast<long long>(time);
						cout << "time:" << line_info.time << endl;

						strcpy(line_info.name, monitor_name);
						cout << "name:" << line_info.name << endl;

						line_info.read_flag = ENABLE;				//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ч

						//ied = find_ied_from_dev_code(line_info.terminal_code); //<2F><><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD>ϼ<EFBFBD><CFBC>ն<EFBFBD><D5B6>ˣ<EFBFBD><CBA3>Ѿ<EFBFBD><D1BE><EFBFBD><EFBFBD>ն<EFBFBD><D5B6><EFBFBD><EFBFBD><EFBFBD>

						if (ied && ied->usr_ext && line_info.cpuno && (static_cast<int>(line_info.cpuno) < 10)) {
							char str[256];			//256<35><36>С
							byte_t cpuno = line_info.cpuno;

							cout << "cpuno:" << (int)line_info.cpuno << endl;
							cout << "index cpuno:" << cpuno-1 << endl;

							ied_usr = (ied_usr_t*)ied->usr_ext;
							ied_usr->LD_info[cpuno - 1] = line_info;   //cpunoĬ<6F><C4AC><EFBFBD><EFBFBD>1
							ied_usr->LD_info[cpuno - 1].ied = ied;
							apr_snprintf(str, sizeof(str), "PQMonitorPQM%d", cpuno);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>߼<EFBFBD><DFBC><EFBFBD>תΪPQMonitorPQM+<2B>߼<EFBFBD><DFBC><EFBFBD>

							//lnk20250208<30><38>ʹ<EFBFBD><CAB9>apr_pstrdup<75><70><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֱ<EFBFBD>Ӹ<EFBFBD><D3B8><EFBFBD>
							//ied_usr->LD_info[cpuno - 1].LD_name = apr_pstrdup(g_init_pool, str);//<2F><> str <20>еĸ<D0B5>ʽ<EFBFBD><CABD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƶ<EFBFBD><C6B5>ڴ<EFBFBD><DAB4><EFBFBD> g_init_pool <20>С<EFBFBD>ied_usr->LD_info[cpuno - 1].LD_name <20>洢<EFBFBD><E6B4A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD>ĸ<EFBFBD><C4B8><EFBFBD><EFBFBD><EFBFBD>LD_name <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> PQMonitorPQM{cpuno} <20><><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD>
							// <20><> g_init_pool <20>ڴ<EFBFBD><DAB4><EFBFBD><EFBFBD>з<EFBFBD><D0B7><EFBFBD><EFBFBD>̶<EFBFBD> 256 <20>ֽڵ<D6BD><DAB5>ڴ<EFBFBD>
							ied_usr->LD_info[cpuno - 1].LD_name = (char *)apr_palloc(g_init_pool, 256);

							// <20><><EFBFBD><EFBFBD><EFBFBD>ڴ棬<DAB4><E6A3AC>ֹ<EFBFBD><D6B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
							memset(ied_usr->LD_info[cpuno - 1].LD_name, 0, 256);

							// <20><> str <20>е<EFBFBD><D0B5><EFBFBD><EFBFBD>ݸ<EFBFBD><DDB8>Ƶ<EFBFBD>Ԥ<EFBFBD>ȷ<EFBFBD><C8B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD><DAB4>У<EFBFBD><D0A3><EFBFBD><EFBFBD>ิ<EFBFBD><E0B8B4> 256 <20>ֽڣ<D6BD><DAA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
							apr_cpystrn(ied_usr->LD_info[cpuno - 1].LD_name, str, 256);
							
							//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀռ<C4BF><D5BC><EFBFBD><EFBFBD><EFBFBD>ied<65><64><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ص<EFBFBD>ied<65><64>
							ied_usr->LD_info[cpuno - 1].ht_fcd = apr_hash_make(g_init_pool);	//<2F><><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD>ֱ<EFBFBD>Ϊ ied_usr->LD_info[cpuno - 1] <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ա<EFBFBD><D4B1>ht_fcd <20><> ht_full_fcda<64><61><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˿յĹ<D5B5>ϣ<EFBFBD><CFA3><EFBFBD><EFBFBD>apr_hash_make(g_init_pool) <20><><EFBFBD><EFBFBD> g_init_pool <20>ڴ<EFBFBD><DAB4><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϣ<EFBFBD><CFA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD><DAB4>ռ<EFBFBD>
							ied_usr->LD_info[cpuno - 1].ht_full_fcda = apr_hash_make(g_init_pool);//<2F><><EFBFBD>ǵ<EFBFBD> key ֵ<><D6B5> value <20>ں<EFBFBD><DABA><EFBFBD><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD>п<EFBFBD><D0BF>ܻᱻ<DCBB><E1B1BB><EFBFBD><EFBFBD>
							ied_usr->LD_info[cpuno - 1].rptcount = 0;
							cout << "rptcount:" << ied_usr->LD_info[cpuno - 1].rptcount << endl;

							if (cpuno > ied->cpucount) {
								ied->cpucount = cpuno;
							}
						}						
                	//}					
            	}
    		}
		}
//////////////////////////////////////////////////////////////////////////////////////////////////		

		if (count_real < count_cfg)
			g_node->n_clients = count_real;
		if (count_cfg != count_real)
			return APR_EBADF;
		cout << "dev init create count:" << count_real;
		return APR_SUCCESS;
	}
	catch (otl_exception& e)
	{
		printf("\n device error,ERROR code= %d,msg= %s \n", e.code, e.msg);
		return e.code;
	}
}

int parse_model_web(QMap<QString, icd_model*>* icd_model_map,const std::vector<std::string>& codes)
{
	std::string parm = codes[0];	//װ<><D7B0><EFBFBD>ͺ<EFBFBD><CDBA>б<EFBFBD><D0B1><EFBFBD><EFBFBD><EFBFBD>ʽ["<22>ͺ<EFBFBD>1","<22>ͺ<EFBFBD>2"...]

	char* ptr=NULL;

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>url<72><6C><EFBFBD><EFBFBD>
	//SendJsonAPI_web("http://192.168.1.149:8091/powerQuality/getProperties", parm.c_str(), "",&ptr);
	SendJsonAPI_web(WEB_ICD,"",parm.c_str(),&ptr);

	// <20><><EFBFBD><EFBFBD> ptr <20>Ƿ<EFBFBD>Ϊ NULL<4C><4C><EFBFBD><EFBFBD><EFBFBD><EFBFBD> std::string <20><>ʼ<EFBFBD><CABC>ʧ<EFBFBD><CAA7>
	if (ptr == NULL) {
		// <20><><EFBFBD><EFBFBD> ptr Ϊ NULL <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>־<EFBFBD><D6BE>¼<EFBFBD><C2BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	    std::cout << "Error: Received NULL response"<< std::endl;
		return 1;
	}

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	printf("ptr:%s\n",ptr);

	cJSON* root = cJSON_Parse(ptr);   //json<6F><6E>ʽ<EFBFBD><CABD><EFBFBD>л<EFBFBD>

	int retry = 0;

	if (root == NULL) {
		printf("web error %s\n", cJSON_GetErrorPtr());

		//<2F>ط<EFBFBD><D8B7><EFBFBD><EFBFBD><EFBFBD>
		while(root == NULL){
			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ǰ<EFBFBD>ͷ<EFBFBD>֮ǰ<D6AE><C7B0> ptr <20>Ա<EFBFBD><D4B1><EFBFBD><EFBFBD>ڴ<EFBFBD>й©
            if (ptr != NULL) {
                free(ptr);
                ptr = NULL;
            }
			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>url<72><6C><EFBFBD><EFBFBD>
			//SendJsonAPI_web("http://192.168.1.149:8091/powerQuality/getProperties", parm.c_str(), "",&ptr);
			SendJsonAPI_web(WEB_ICD,"",parm.c_str(),&ptr);
			if(ptr == NULL){
				retry++;if(retry>3)break;
				continue;
			}
			root = cJSON_Parse(ptr);
			retry++;if(retry>3)break;
		}
		if (root == NULL) {
        	printf("web error %s\n", cJSON_GetErrorPtr());
        	return 1;
    	}
	}

	cJSON* codeItem = cJSON_GetObjectItem(root, "code");
	cJSON* msgItem = cJSON_GetObjectItem(root, "msg");

	// ʹ<><CAB9> std::string <20><>ȡֵ
    std::string code = (codeItem != NULL) ? codeItem->valuestring : "not found";
    std::string msg = (msgItem != NULL) ? msgItem->valuestring : "not found";

    // <20><>ӡ<EFBFBD><D3A1><EFBFBD><EFBFBD>
    std::cout << "code: " << code << std::endl;
    std::cout << "msg: " << msg << std::endl;

    cJSON* data = cJSON_GetObjectItem(root, "data");
    if (data && data->type == cJSON_Array) {
        cJSON* item;
        cJSON_ArrayForEach(item, data) {
            icd_model* model = new icd_model;

            cJSON* id = cJSON_GetObjectItem(item, "id");//model_id
            if (id && id->type == cJSON_String) strncpy(model->model_id, id->valuestring, sizeof(model->model_id) - 1);

            cJSON* fileName = cJSON_GetObjectItem(item, "fileName");//file_name
            if (fileName && fileName->type == cJSON_String) strncpy(model->file_name, fileName->valuestring, sizeof(model->file_name) - 1);

            cJSON* filePath = cJSON_GetObjectItem(item, "filePath");//<2F><><EFBFBD><EFBFBD>
            if (filePath && filePath->type == cJSON_String) strncpy(model->file_path, filePath->valuestring, sizeof(model->file_path) - 1);

            cJSON* devType = cJSON_GetObjectItem(item, "devType");//tmnl_type
            if (devType && devType->type == cJSON_String) strncpy(model->tmnl_type, devType->valuestring, sizeof(model->tmnl_type) - 1);

            cJSON* updateTime = cJSON_GetObjectItem(item, "updateTime");//timestamp
            if (updateTime && updateTime->type == cJSON_String) strncpy(model->timestamp, updateTime->valuestring, sizeof(model->timestamp) - 1);

            // <20><><EFBFBD>ӵ<EFBFBD> QMap
            icd_model_map->insert(model->model_id, model);
        }
    }

    cJSON_Delete(root);
	free(ptr);  // <20><><EFBFBD><EFBFBD> SendJsonAPI_web <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ棬<DAB4>ǵ<EFBFBD><C7B5>ͷ<EFBFBD>

	return 0; // ȷ<><C8B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>з<EFBFBD><D0B7><EFBFBD>ֵ
}

int parse_model_cfg_web()
{
	std::vector<std::string> codes;//<2F><><EFBFBD>μ<EFBFBD><CEBC><EFBFBD>
	QMap<QString, icd_model*>  icd_model_map;
/////////////////////////////////////////////////////////////////////////
	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	//codes.push_back("code1=model1");	//<2F><><EFBFBD><EFBFBD><EFBFBD>ն<EFBFBD><D5B6>ͺ<EFBFBD><CDBA>б<EFBFBD>

	//ʹ<><CAB9><EFBFBD>ж<EFBFBD><D0B6>ͺ<EFBFBD><CDBA>б<EFBFBD><D0B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>json<6F>ַ<EFBFBD><D6B7><EFBFBD>
	// <20><><EFBFBD><EFBFBD>ǰ<EFBFBD><C7B0><EFBFBD><EFBFBD><EFBFBD>м<EFBFBD><D0BC><EFBFBD><EFBFBD><EFBFBD>
	ied_t* ied;
	ied_usr_t* ied_usr;
	std::cout <<  "g_node->n_clients" <<  g_node->n_clients << std::endl;
    std::set<std::string> devTypes; // <20><><EFBFBD><EFBFBD>ȥ<EFBFBD>صļ<D8B5><C4BC><EFBFBD>set

    for (int t = 0; t < g_node->n_clients; t++) {
        ied = (ied_t*)g_node->clients[t];
        ied_usr = (ied_usr_t*)ied->usr_ext;

        // <20><><EFBFBD><EFBFBD> dev_type <20><>һ<EFBFBD><D2BB><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͣ<EFBFBD><CDA3><EFBFBD><EFBFBD>뼯<EFBFBD><EBBCAF> ,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȥ<EFBFBD><C8A5>
        if (strlen(ied_usr->dev_type) > 0) {
            devTypes.insert(std::string(ied_usr->dev_type));
        }
    }

    // <20>ֶ<EFBFBD><D6B6><EFBFBD><EFBFBD><EFBFBD> JSON <20>ַ<EFBFBD><D6B7><EFBFBD>
    std::string input_jstr = "[";
    bool first = true; // <20><><EFBFBD>ڴ<EFBFBD><DAB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

    for (std::set<std::string>::iterator it = devTypes.begin(); it != devTypes.end(); ++it) {
        if (!first) {
            input_jstr += ","; // <20><><EFBFBD>Ӷ<EFBFBD><D3B6><EFBFBD>
        }
        first = false; // <20><>һ<EFBFBD><D2BB>֮<EFBFBD><D6AE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ false
        input_jstr += "\"" + *it + "\""; // <20><><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>
    }

    input_jstr += "]"; // <20><><EFBFBD><EFBFBD> JSON <20><><EFBFBD><EFBFBD>
    std::cout << "input_jstr: " << input_jstr << std::endl; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

	if(ICD_FLAG == "1"){
		codes.push_back(input_jstr);	//<2F><><EFBFBD><EFBFBD><EFBFBD>ն<EFBFBD><D5B6>ͺ<EFBFBD><CDBA>б<EFBFBD>-<2D><>ȡָ<C8A1><D6B8><EFBFBD><EFBFBD>icd<63><64><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
	}
	else{
		codes.push_back("[]");	//<2F><><EFBFBD><EFBFBD>-<2D><>ȡ<EFBFBD><C8A1><EFBFBD>е<EFBFBD>icd<63><64><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
	}

/////////////////////////////////////////////////////////////////////////
	parse_model_web(&icd_model_map,codes);

	codes.clear();

	try {
		char model_id[64];
		char tmnl_type[64];
		//char tmnl_factory[64];
		char file_name[128];
		char file_path[128];
		//char timestamp[64];
		otl_datetime timestamp;

		// <20><><EFBFBD><EFBFBD><EFBFBD>ն<EFBFBD>̨<EFBFBD><CCA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		QMap<QString, icd_model*>::iterator it;
    	for (it = icd_model_map.begin(); it != icd_model_map.end(); ++it) {
    		icd_model* value = it.value();

			// ȷ<><C8B7> value <20><>Ϊ<EFBFBD><CEAA>
    		if (value != nullptr) {
        		// <20>ҵ<EFBFBD><D2B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD>Ʋ<EFBFBD>ȡֵ
        		strncpy(model_id, value->model_id, sizeof(model_id) - 1);
        		strncpy(tmnl_type, value->tmnl_type, sizeof(tmnl_type) - 1);
        		strncpy(file_path, value->file_path, sizeof(file_path) - 1);
        		strncpy(file_name, value->file_name, sizeof(file_name) - 1);
        		//strncpy(timestamp, value->timestamp, sizeof(timestamp) - 1);

				std::cout << "model_id" << model_id << std::endl;
				std::cout << "tmnl_type" << tmnl_type << std::endl;
				std::cout << "filepath" << file_path << std::endl;
				std::cout << "filename" << file_name << std::endl;

				//lnk20241125<32><35><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				//strncpy(tmnl_type, "PS_NET", sizeof(tmnl_type) - 1);

				Set_xml_databaseinfo(model_id, tmnl_type, file_path, file_name, timestamp.year, timestamp.month, timestamp.day, timestamp.hour, timestamp.minute, timestamp.second);
    		}
		}
		return APR_SUCCESS;
	}
	catch (otl_exception& e)
	{
		printf("\n icd model error,ERROR code= %d,msg= %s \n",  e.code, e.msg);
		return e.code;
	}
}
////////////////////////////////////////////////////////////icdģ<64><C4A3><EFBFBD>ع<EFBFBD><D8B9><EFBFBD><EFBFBD><EFBFBD>lnk20250116
char* parse_model_cfg_web_one(ied_t* ied)
{
	std::vector<std::string> codes;//<2F><><EFBFBD>μ<EFBFBD><CEBC><EFBFBD>
	QMap<QString, icd_model*>  icd_model_map;
	ied_usr_t* ied_usr;

    ied_usr = (ied_usr_t*)ied->usr_ext;

    // <20>ֶ<EFBFBD><D6B6><EFBFBD><EFBFBD><EFBFBD> JSON <20>ַ<EFBFBD><D6B7><EFBFBD>
    std::string input_jstr = "[";
    input_jstr += "\"" + std::string(ied_usr->dev_type) + "\""; 
    input_jstr += "]"; // <20><><EFBFBD><EFBFBD> JSON <20><><EFBFBD><EFBFBD>
    std::cout << "input_jstr: " << input_jstr << std::endl; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

	codes.push_back(input_jstr);	//<2F><><EFBFBD><EFBFBD><EFBFBD>ն<EFBFBD><D5B6>ͺ<EFBFBD><CDBA>б<EFBFBD>-<2D><>ȡָ<C8A1><D6B8><EFBFBD><EFBFBD>icd<63><64><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>

	parse_model_web(&icd_model_map,codes);

	codes.clear();

	try {
		char model_id[64];
		char tmnl_type[64];
		char file_name[128];
		char file_path[128];
		otl_datetime timestamp;//<2F><>ʹ<EFBFBD><CAB9>

		// <20><><EFBFBD><EFBFBD><EFBFBD>ն<EFBFBD>̨<EFBFBD><CCA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		QMap<QString, icd_model*>::iterator it;
    	for (it = icd_model_map.begin(); it != icd_model_map.end(); ++it) {
    		icd_model* value = it.value();

			// ȷ<><C8B7> value <20><>Ϊ<EFBFBD><CEAA>
    		if (value != nullptr) {
        		// <20>ҵ<EFBFBD><D2B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD>Ʋ<EFBFBD>ȡֵ
        		strncpy(model_id, value->model_id, sizeof(model_id) - 1);
        		strncpy(tmnl_type, value->tmnl_type, sizeof(tmnl_type) - 1);
        		strncpy(file_path, value->file_path, sizeof(file_path) - 1);
        		strncpy(file_name, value->file_name, sizeof(file_name) - 1);

				std::cout << "model_id" << model_id << std::endl;
				std::cout << "tmnl_type" << tmnl_type << std::endl;
				std::cout << "filepath" << file_path << std::endl;
				std::cout << "filename" << file_name << std::endl;

				Set_xml_databaseinfo(model_id, tmnl_type, file_path, file_name, timestamp.year, timestamp.month, timestamp.day, timestamp.hour, timestamp.minute, timestamp.second);
    		}
		}
		return model_id;
	}
	catch (otl_exception& e)
	{
		printf("\n icd model error,ERROR code= %d,msg= %s \n",  e.code, e.msg);
		return NULL;
	}
}
////////////////////////////////////////////////////////////
//<2F><>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA>ʱ<EFBFBD><CAB1>־<EFBFBD><D6BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һЩ<D2BB><D0A9><EFBFBD>ܣ<EFBFBD>ͳһ<CDB3><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>޸<EFBFBD>
void OnTimerThread::run()
{
	msleep(10000);
	printf("OnTimerThread::run() is called ...... \n");

	bool account_update = true;
	bool asd = true;

	//<2F><>ǰʱ<C7B0><CAB1><EFBFBD><EFBFBD>ȡ
	apr_time_t	previousTime = apr_time_now();//
	apr_time_exp_t localTime;
	apr_time_exp_gmt(&localTime, previousTime);
	cout << "Local Time: "
		<< localTime.tm_year + 1900 << "-" << localTime.tm_mon + 1 << "-" << localTime.tm_mday << " "
		<< localTime.tm_hour << ":" << localTime.tm_min << ":" << localTime.tm_sec
		<< endl;

	//<2F><><EFBFBD><EFBFBD>ģʽ
	if (g_onlyIP[0] != 0)
	{
		printf("g_onlyIP[0]=!0 ontimer--%s--\n", g_onlyIP);
		add_comm_log(const_cast<char*>("g_onlyIP[0]=!0,g_onlyIP is --%s--", g_onlyIP));
	}
	else 
	{
		printf("g_onlyIP[0] == 0!");
	}

	int pgflag = 0;
	int pgmin = 0;
	int mp_num_hour = 0;

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	std::vector<std::string> codes;

	while (1)
	{
		//<2F><><EFBFBD><EFBFBD><EFBFBD>߳<EFBFBD>ʱ<EFBFBD><CAB1>
		previousTime = apr_time_now();
		apr_time_exp_gmt(&localTime, previousTime);

		if (strcmp(subdir, "cfg_stat_data") == 0 || strcmp(subdir, "cfg_newhis_data") == 0) {//̨<>˸<EFBFBD><CBB8><EFBFBD>,<2C><><EFBFBD>ڵ<EFBFBD>,ͨѶ
			
			//<2F><>־<EFBFBD><D6BE>¼
			if (mp_num_hour != localTime.tm_hour) {
				pthread_mutex_lock(&mtx);     std::cout << "ontime hold lock !!!!!!!!!!!" << std::endl;
				std::string mp_num_str = "";
				mp_num_str.append("connected device count:");
				mp_num_str.append(QString::number(FRONT_MP_NUM).toStdString());//<2F><>¼<EFBFBD><C2BC><EFBFBD>ӵļ<D3B5><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				mp_num_str.append(",g_node clients:");
				mp_num_str.append(QString::number(g_node->n_clients).toStdString());

				add_comm_log(const_cast<char*>(mp_num_str.c_str()));
				mp_num_hour = localTime.tm_hour;
				pthread_mutex_unlock(&mtx);   std::cout << "ontime free lock !!!!!!!!!!!" << std::endl;
			}

		}	
		msleep(1000);
	}
	printf(">>>OnTimerThread::run() is end!!!\n");
}

//<2F><><EFBFBD><EFBFBD>web<65><62><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int recall_json_handle(const char* jstr)
{
	//<2F><>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>̬/<2F><>̬<EFBFBD><CCAC>ȫ<EFBFBD><C8AB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	int stat = 0;	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	int voltage= 0;
	try{

		std::vector<RecallParam> recallParams;
		cJSON* json_root = cJSON_Parse(jstr);   //json<6F><6E>ʽ<EFBFBD><CABD><EFBFBD>л<EFBFBD>  //<2F><>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		if (json_root == NULL) {
			std::cout <<  "json root<6F><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>"<< std::endl;
			return 10000;
		}

		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ÿ<EFBFBD><C3BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    	if (json_root->type == cJSON_Array) {
        	for (cJSON* item = json_root->child; item != nullptr; item = item->next) {
        	    // <20><>ȡ monitorId <20><><EFBFBD><EFBFBD>
        	    cJSON* monitorIdArray = cJSON_GetObjectItem(item, "monitorId");
        	    cJSON* timeIntervalArray = cJSON_GetObjectItem(item, "timeInterval");
				//<2F>ж<EFBFBD>dataType<70>Ƿ<EFBFBD>Ϊ<EFBFBD><CEAA>
				cJSON* datatype = cJSON_GetObjectItem(item, "dataType");

				//<2F><><EFBFBD><EFBFBD><EFBFBD>쳣<EFBFBD>жϷ<D0B6>ֹ<EFBFBD><D6B9><EFBFBD><EFBFBD>
				if(monitorIdArray == NULL || timeIntervalArray == NULL  || datatype == NULL ){
					std::cout <<  "json<EFBFBD><EFBFBD><EFBFBD>ݽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> "<< std::endl;
					return 10000;
				}

				if(strcmp(datatype->valuestring, "") != 0)//<2F>ǿ<EFBFBD>
				{
					stat = (strcmp(datatype->valuestring, "0") == 0) ? 1 : 0;//<2F><>̬
					voltage= (strcmp(datatype->valuestring, "1") == 0) ? 1 : 0;//<2F><>̬
				}
				else //<2F>ջ<EFBFBD><D5BB><EFBFBD><EFBFBD><EFBFBD>
				{
					stat = 1;
					voltage= 1;
				}

				//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				if(monitorIdArray != nullptr && monitorIdArray->child != nullptr)std::cout <<  "monitorIdArray<EFBFBD>ij<EFBFBD>ԱΪ"<< monitorIdArray->child->valuestring << std::endl;
				if(monitorIdArray != nullptr && monitorIdArray->child == nullptr)std::cout <<  "monitorIdArrayû<EFBFBD>г<EFBFBD>Ա"<< std::endl;

				//monitorIdArray<61><79><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD><DDB5><EFBFBD><EFBFBD><EFBFBD>
        	    if (monitorIdArray != nullptr && monitorIdArray->type == cJSON_Array && timeIntervalArray->type == cJSON_Array && monitorIdArray->child != nullptr) {
        	        // <20><><EFBFBD><EFBFBD> monitorId <20><><EFBFBD><EFBFBD>				
        	        for (cJSON* idItem = monitorIdArray->child; idItem != nullptr; idItem = idItem->next) {
        	            QString monitorId = QString(idItem->valuestring);

						//<2F><><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD><D0B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>е<EFBFBD>ǰ<EFBFBD><C7B0><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD>ڱ<EFBFBD><DAB1><EFBFBD><EFBFBD><EFBFBD>20241230<33><30><EFBFBD><EFBFBD>ֹ<EFBFBD><D6B9><EFBFBD>ַDZ<D6B7><C7B1><EFBFBD><EFBFBD>̵ļ<CCB5><C4BC><EFBFBD><EFBFBD>㴥<EFBFBD><E3B4A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
						int mppair = 0;
						ied_t* ied;
						ied_usr_t* ied_usr;
						for (int t = 0; t < g_node->n_clients; t++){
							ied = (ied_t*)g_node->clients[t];
							ied_usr = (ied_usr_t*)ied->usr_ext;
							for (int m = 0; m<10; m++){//<2F><><EFBFBD><EFBFBD>10<31><30>

								if(strcmp(ied_usr->LD_info[m].mp_id,"") == 0)continue;//<2F><><EFBFBD><EFBFBD><EFBFBD>յ<EFBFBD>

								if(strcmp(ied_usr->LD_info[m].mp_id,monitorId.toStdString().c_str()) == 0){//ƥ<><C6A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

									mppair = 1;
									break;//<2F>ҵ<EFBFBD><D2B5><EFBFBD><EFBFBD>˳<EFBFBD><CBB3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ѭ<EFBFBD><D1AD>
								}
							
							}
							if(mppair == 1)break;//<2F>ҵ<EFBFBD><D2B5><EFBFBD><EFBFBD>˳<EFBFBD><CBB3>ն<EFBFBD>ѭ<EFBFBD><D1AD>
						}
						if(mppair == 0)continue;//<2F><>ǰ<EFBFBD><C7B0><EFBFBD>̵ļ<CCB5><C4BC><EFBFBD><EFBFBD>㶼û<E3B6BC><C3BB><EFBFBD>ҵ<EFBFBD><D2B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ţ<EFBFBD>˵<EFBFBD><CBB5><EFBFBD><EFBFBD><EFBFBD>DZ<EFBFBD><C7B1><EFBFBD><EFBFBD>̵ļ<CCB5><C4BC><EFBFBD><EFBFBD>㣬<EFBFBD><E3A3AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
						//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
						std::cout << "find mpid:" << monitorId.toStdString() << "in this process,mppair=" << mppair <<std::endl;

        	            // <20><><EFBFBD><EFBFBD> timeInterval <20><><EFBFBD><EFBFBD>
        	            for (cJSON* timeItem = timeIntervalArray->child; timeItem != nullptr; timeItem = timeItem->next) {
        	                QString timeInterval = QString(timeItem->valuestring);
        	                QString start = timeInterval.left(timeInterval.indexOf("~"));
        	                QString end = timeInterval.mid(timeInterval.indexOf("~") + 1);

        	                // <20><><EFBFBD><EFBFBD> RecallParam <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӵ<EFBFBD><D3B5>б<EFBFBD><D0B1><EFBFBD>

        	                RecallParam param;
        	                param.mp_id = monitorId;
        	                param.start = start;
        	                param.end = end;
        	                param.stat = stat; 
							param.voltage = voltage;
        	                recallParams.push_back(param);
        	            }
        	        }
        	    }
				//monitorIdArrayΪ<79>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD>
				else if (monitorIdArray != nullptr && monitorIdArray->type == cJSON_Array && monitorIdArray->child == nullptr) {
    				// monitorIdArray Ϊ<><CEAA>
    				std::cout << "monitorIdArray is null" << std::endl;
					//<2F><><EFBFBD>м<EFBFBD><D0BC><EFBFBD><EFBFBD>㲹<EFBFBD><E3B2B9>
					// <20><><EFBFBD><EFBFBD>ǰ<EFBFBD><C7B0><EFBFBD><EFBFBD><EFBFBD>м<EFBFBD><D0BC><EFBFBD><EFBFBD><EFBFBD>
					ied_t* ied;
					ied_usr_t* ied_usr;
					std::cout <<  "g_node->n_clients" <<  g_node->n_clients << std::endl;
        	        for (int t = 0; t < g_node->n_clients; t++){
						ied = (ied_t*)g_node->clients[t];
						ied_usr = (ied_usr_t*)ied->usr_ext;
						for (int m = 0; m<10; m++){

							if(strcmp(ied_usr->LD_info[m].mp_id,"") == 0)continue;
							std::cout <<  "ied_usr->LD_info[m].mp_id" <<  m  << "   "<<  ied_usr->LD_info[m].mp_id << std::endl;
        	            	QString monitorId = QString(ied_usr->LD_info[m].mp_id);

        	            	// <20><><EFBFBD><EFBFBD> timeInterval <20><><EFBFBD><EFBFBD>
        	            	for (cJSON* timeItem = timeIntervalArray->child; timeItem != nullptr; timeItem = timeItem->next) {
        	            	    QString timeInterval = QString(timeItem->valuestring);
        	            	    QString start = timeInterval.left(timeInterval.indexOf("~"));
        	            	    QString end = timeInterval.mid(timeInterval.indexOf("~") + 1);

        	            	    // <20><><EFBFBD><EFBFBD> RecallParam <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӵ<EFBFBD><D3B5>б<EFBFBD><D0B1><EFBFBD>
        	            	    RecallParam param;
        	            	    param.mp_id = monitorId;
        	            	    param.start = start;
								param.end = end;
        	                	param.stat = stat; 
								param.voltage = voltage;
        	            	    recallParams.push_back(param);
        	            	}
						}
        	        }
				}
				else{
					std::cout << "monitorIdArray <20><><EFBFBD><EFBFBD><EFBFBD>ڻ<EFBFBD><DABB><EFBFBD><EFBFBD>Ͳ<EFBFBD><CDB2><EFBFBD>ȷ" << std::endl;
				}
        	}
		}
		cJSON_Delete(json_root);	//web<65><62><EFBFBD>δ<EFBFBD><CEB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD>в<EFBFBD><D0B2><EFBFBD>
		for (std::vector<RecallParam>::iterator it = recallParams.begin(); it != recallParams.end(); ++it) {

			QList<RecallInfo> recallinfo_list_hour;
			char start_time[64];
			char end_time[64];
			QString mp_id;

			mp_id = it->mp_id;
			apr_snprintf(start_time, sizeof(start_time), "%s", it->start.toStdString().c_str());//start_time
			apr_snprintf(end_time, sizeof(end_time), "%s", it->end.toStdString().c_str());//end_time

			qDebug() << "mp_id" << mp_id << "  " <<  "start_time" << start_time << "  " << "end_time" << "  " << "stat" << it->stat << "  " << "voltage" << it->voltage<< end_time;
				
			Get_Recall_Time_Char(start_time, end_time, recallinfo_list_hour);
			
			for (int j = 0; j < recallinfo_list_hour.size(); j++) {
				CJournalRecall jr;
				jr.MonitorID = mp_id;
				jr.StartTime = QDateTime::fromTime_t(recallinfo_list_hour[j].starttime).toString("yyyy-MM-dd hh:mm:ss");
				jr.EndTime = QDateTime::fromTime_t(recallinfo_list_hour[j].endtime).toString("yyyy-MM-dd hh:mm:ss");

				//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̬<EFBFBD><CCAC>̬<EFBFBD><CCAC><EFBFBD><EFBFBD>web<65><62>ȡ
				//jr.STEADY = QString::number(1, 10); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 1 ת<><D7AA>Ϊ<EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
				//jr.VOLTAGE = QString::number(1, 10);// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 1 ת<><D7AA>Ϊ<EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
				//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				//std::cout << "stat" << it->stat << "voltage" << it->voltage << std::endl;
				jr.STEADY = QString::number(it->stat);
				jr.VOLTAGE = QString::number(it->voltage);

				g_StatisticLackList_list_mutex.lock();
				g_StatisticLackList.push_back(jr);
				g_StatisticLackList_list_mutex.unlock();
			}				
		}		
	}
	catch (exception& e)
	{
		printf("<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͻ<EFBFBD><EFBFBD>˷<EFBFBD><EFBFBD>͵<EFBFBD><EFBFBD><EFBFBD>Ϣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ԭ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>%s\n", e.what());
		return 10004;
	}

	return 000000;
}

int rtdata_http(const char* jstr)
{

}

// <20><><EFBFBD><EFBFBD><EFBFBD>ⲿ<EFBFBD><E2B2BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD>http<74><70><EFBFBD><EFBFBD><EFBFBD>ÿ<EFBFBD><C3BF><EFBFBD><EFBFBD>ӣ<EFBFBD><D3A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#ifdef __cplusplus
extern "C" {
#endif

void httprun();
const char* getReceivedData(int fun);
void threadmsgweb(int fun);
bool threadmsghttp(int fun);

#ifdef __cplusplus
}
#endif
#if 0
void RecallJsonResponse(int result) {
    char* ptr=NULL;
	
	// <20><><EFBFBD><EFBFBD> JSON <20><><EFBFBD><EFBFBD>
    cJSON* json_response = cJSON_CreateObject();

    // <20><><EFBFBD><EFBFBD><EFBFBD>ֶ<EFBFBD>
	if(result == 000000){
		cJSON_AddStringToObject(json_response, "code", "A0000");
		cJSON_AddStringToObject(json_response, "msg", "<EFBFBD><EFBFBD><EFBFBD>ݲ<EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD>гɹ<EFBFBD>");
	}
	else{
		cJSON_AddStringToObject(json_response, "code", "A0002");
		cJSON_AddStringToObject(json_response, "msg", "<EFBFBD><EFBFBD><EFBFBD>ݲ<EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD><EFBFBD>ʧ<EFBFBD><EFBFBD>");
	}
    
    cJSON_AddNullToObject(json_response, "data"); // <20><><EFBFBD><EFBFBD>Ϊ null

    // <20><> JSON <20><><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>Ϊ<EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>
    char* json_string = cJSON_Print(json_response);
    std::cout << json_string << std::endl;

	//<2F><><EFBFBD>ͻظ<CDBB><D8B8><EFBFBD><EFBFBD>Է<EFBFBD><D4B7><EFBFBD>ֻ<EFBFBD><D6BB>һ<EFBFBD><D2BB>
	SendJsonAPI_web("<EFBFBD><EFBFBD><EFBFBD>÷<EFBFBD>", "", json_string ,&ptr);

    // <20><><EFBFBD><EFBFBD>
    cJSON_Delete(json_response);
    free(json_string); // <20>ͷŴ<CDB7>ӡ<EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD>
}
#endif

void WebhttpThread::run()
{
	int ret = 1;
	printf("WebhttpThread::run() is called ...... \n");

	while(1){

		//<2F><><EFBFBD>н<EFBFBD><D0BD><EFBFBD>
		if (!threadmsghttp(1) && g_node_id == RECALL_HIS_DATA_BASE_NODE_ID) {//http<74><70><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD>Ϣ,״̬<D7B4><CCAC>Ϊfalse<73><65><EFBFBD><EFBFBD><EFBFBD>ٴ<EFBFBD><D9B4><EFBFBD><EFBFBD><EFBFBD>Ϣ<EFBFBD><CFA2>http<74><70>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD><EFBFBD>Dz<EFBFBD><C7B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>߳̿<DFB3>ʼ<EFBFBD><CABC>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>

			const char* data = getReceivedData(1);//<2F><>http<74><70>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>,ָ<><D6B8>

			std::cout << "recall data cfg:" << data <<std::endl;

			pthread_mutex_lock(&mtx);    std::cout << "recall http hold lock !!!!!!!!!!!" << std::endl;
			ret = recall_json_handle(data);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
			pthread_mutex_unlock(&mtx);  std::cout << "recall http free lock !!!!!!!!!!!" << std::endl;

			
			threadmsgweb(1);//<2F><>ȡ<EFBFBD><C8A1><EFBFBD>ݺ<EFBFBD><DDBA><EFBFBD><EFBFBD><EFBFBD>http<74><70>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>Ϣ<EFBFBD><CFA2><EFBFBD>Żᴦ<C5BB><E1B4A6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>״̬<D7B4><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>ѭ<EFBFBD><D1AD>
    	}
		//3s<33><73><EFBFBD>ݽ<EFBFBD><DDBD><EFBFBD>
		if (!threadmsghttp(2) && g_node_id == THREE_SECS_DATA_BASE_NODE_ID) {//http<74><70><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD>Ϣ,״̬<D7B4><CCAC>Ϊfalse<73><65><EFBFBD><EFBFBD><EFBFBD>ٴ<EFBFBD><D9B4><EFBFBD><EFBFBD><EFBFBD>Ϣ<EFBFBD><CFA2>http<74><70>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD><EFBFBD>Dz<EFBFBD><C7B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>߳̿<DFB3>ʼ<EFBFBD><CABC>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>

			const char* data = getReceivedData(2);//<2F><>http<74><70>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>,ָ<><D6B8>

			std::cout << "rt data cfg:" << data <<std::endl;

			ret = rtdata_http(data);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>

			threadmsgweb(2);//<2F><>ȡ<EFBFBD><C8A1><EFBFBD>ݺ<EFBFBD><DDBA><EFBFBD><EFBFBD><EFBFBD>http<74><70>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>Ϣ<EFBFBD><CFA2><EFBFBD>Żᴦ<C5BB><E1B4A6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>״̬<D7B4><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>ѭ<EFBFBD><D1AD>
    	}
	}
	printf("WebhttpThread::run() is end ...... \n");
}

void httpThread::run()
{
	printf("httpThread::run() is called ...... \n");
	std::cout << "Server started at" << HTTP_IP << ":" << HTTP_PORT << std::endl;
	httprun();	//<2F><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>http<74><70><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ip<69><70><EFBFBD>˿<EFBFBD>10004

	printf("httpThread::run() is end ...... \n");
}

// Base64 <20><><EFBFBD>뺯<EFBFBD><EBBAAF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ Base64 <20><>ʽ //ʵ<><CAB5>json<6F>е<EFBFBD><D0B5>ļ<EFBFBD><C4BC><EFBFBD>
std::string base64_encode(const std::string& in) {
    // Base64 <20>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 64 <20><><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD>
    static const std::string base64_chars = 
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz"
        "0123456789+/";

    std::string out;  // <20><><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>
    int val = 0;      // <20><>ǰֵ
    int valb = -6;    // ֵ<><D6B5>λƫ<CEBB><C6AB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼΪ -6

    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD>ÿһ<C3BF><D2BB><EFBFBD>ַ<EFBFBD>
    for (std::string::const_iterator it = in.begin(); it != in.end(); ++it) {
        // <20><><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD> ASCII ֵ<><D6B5><EFBFBD><EFBFBD> 8 λ<><CEBB><EFBFBD>ӵ<EFBFBD> val <20><>
        val = (val << 8) + *it;
        valb += 8;  // <20><><EFBFBD><EFBFBD>λƫ<CEBB><C6AB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ÿ<EFBFBD><C3BF><EFBFBD>ַ<EFBFBD>ռ 8 λ

        // <20><> valb <20><><EFBFBD>ڵ<EFBFBD><DAB5><EFBFBD> 0 ʱ<><CAB1>˵<EFBFBD><CBB5><EFBFBD><EFBFBD><EFBFBD>㹻<EFBFBD><E3B9BB>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD>Խ<EFBFBD><D4BD>б<EFBFBD><D0B1><EFBFBD>
        while (valb >= 0) {
            // <20><> val <20>ĸ<EFBFBD> 6 λת<CEBB><D7AA>Ϊ Base64 <20>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӵ<EFBFBD><D3B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
            out.push_back(base64_chars[(val >> valb) & 0x3F]);
            valb -= 6;  // ÿ<>α<EFBFBD><CEB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λƫ<CEBB><C6AB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 6 λ
        }
    }

    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʣ<EFBFBD><CAA3><EFBFBD><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> '=' <20>ַ<EFBFBD>
    while (valb > -6) {
        out.push_back('=');
        valb -= 6;  // ÿ<><C3BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB> '='<27><>λƫ<CEBB><C6AB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 6 λ
    }
    
    return out;  // <20><><EFBFBD>ر<EFBFBD><D8B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>
}

void handleUploadResponse(const std::string& response, char* wavepath) {
    
	// <20><><EFBFBD><EFBFBD> JSON <20><>Ӧ
    cJSON* json_data = cJSON_Parse(response.c_str());
    if (json_data == nullptr) {
        std::cerr << "Error parsing response: " << cJSON_GetErrorPtr() << std::endl;
        return;
    }

    // <20><>ȡ<EFBFBD>ֶ<EFBFBD>
    cJSON* codeItem = cJSON_GetObjectItem(json_data, "code");
    cJSON* msgItem = cJSON_GetObjectItem(json_data, "msg");
    cJSON* dataItem = cJSON_GetObjectItem(json_data, "data");

    if (codeItem && dataItem) {
        std::string code = codeItem->valuestring;
		std::cout << "Response Code: " << code << std::endl;
        std::string msg = (msgItem != NULL) ? msgItem->valuestring : "not found";
		std::cout << "Message: " << msg << std::endl;

        cJSON* nameItem = cJSON_GetObjectItem(dataItem, "name");
        cJSON* fileNameItem = cJSON_GetObjectItem(dataItem, "fileName");
        cJSON* urlItem = cJSON_GetObjectItem(dataItem, "url");

        if (nameItem && fileNameItem && urlItem) {
            std::string name = nameItem->valuestring;
            std::string fileName = fileNameItem->valuestring;
            std::string url = urlItem->valuestring;

            // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
            std::cout << "File Path: " << name << std::endl;
			std::cout << "Uploaded File Name: " << fileName << std::endl;
            std::cout << "File URL: " << url << std::endl;

			// <20>ҵ<EFBFBD><D2B5><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB> '.'
			size_t pos = fileName.find_last_of('.');
			std::string nameWithoutExt;
		
			if (pos != std::string::npos) {
				// <20><>ȡȥ<C8A1><C8A5><EFBFBD><EFBFBD>׺<EFBFBD>IJ<EFBFBD><C4B2><EFBFBD>
				nameWithoutExt = fileName.substr(0, pos);
			} else {
				// <20><><EFBFBD><EFBFBD>û<EFBFBD>к<EFBFBD>׺<EFBFBD><D7BA>ֱ<EFBFBD><D6B1>ʹ<EFBFBD><CAB9>ԭ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>
				nameWithoutExt = fileName;
			}
		
			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> wavepath
			strcpy(wavepath, nameWithoutExt.c_str());

			std::cout << "wavepath: " << wavepath << std::endl;
        }
    } else {
        std::cerr << "Error: Missing expected fields in JSON response." << std::endl;
    }

    // <20>ͷ<EFBFBD> JSON <20><><EFBFBD><EFBFBD>
    cJSON_Delete(json_data);
}
//<2F><><EFBFBD><EFBFBD>json<6F>ṹ<EFBFBD><E1B9B9><EFBFBD>͵ķ<CDB5>ʽ
/*void SendFileWeb(const std::string& strUrl, const char* localpath, const char* cloudpath, char* wavepath) {
    // <20>ӱ<EFBFBD><D3B1><EFBFBD>·<EFBFBD><C2B7><EFBFBD><EFBFBD>ȡ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
    std::ifstream file(localpath, std::ios::binary);
    if (!file) {
        std::cerr << "Failed to open file: " << localpath << std::endl;
        return;
    }
    
    std::ostringstream ss;
    ss << file.rdbuf();	
    std::string fileContent = ss.str();//<2F>ļ<EFBFBD><C4BC><EFBFBD>
    std::string encodedFile = base64_encode(fileContent);//<2F>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

    // <20><><EFBFBD><EFBFBD> JSON <20><><EFBFBD><EFBFBD> ʵ<><CAB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA>

    cJSON* json_root = cJSON_CreateObject();
    cJSON_AddItemToObject(json_root, "multipartFile", cJSON_CreateString(encodedFile.c_str()));
    cJSON_AddItemToObject(json_root, "path", cJSON_CreateString(cloudpath));//Զ<><D4B6>·<EFBFBD><C2B7>
    cJSON_AddItemToObject(json_root, "isReserveName", cJSON_CreateBool(true)); // <20><><EFBFBD><EFBFBD>ֵ

    char* szjson = cJSON_Print(json_root);
    std::cout << ">>> json: " << szjson << std::endl;

    // curl <20><>ʼ<EFBFBD><CABC>
    CURL* curl = curl_easy_init();
    if (curl) {
        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ POST <20><><EFBFBD><EFBFBD>
        curl_easy_setopt(curl, CURLOPT_POST, 1);
        curl_easy_setopt(curl, CURLOPT_URL, strUrl.c_str());
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, szjson);
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, curl_slist_append(NULL, "Content-Type: application/json"));

        // <20><><EFBFBD>ó<EFBFBD>ʱʱ<CAB1><CAB1>
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10);
        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10);

        std::string resPost0;
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&resPost0);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, req_reply_web); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݽ<EFBFBD><DDBD>պ<EFBFBD>д<EFBFBD>뺯<EFBFBD><EBBAAF>

        // ִ<><D6B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
        CURLcode res = curl_easy_perform(curl);
        if (res != CURLE_OK) {
            std::cerr << "lnk web failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            std::cout << "lnk web success, response: " << resPost0 << std::endl;
			 handleUploadResponse(resPost0,wavepath); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӧ
        }

        // <20><><EFBFBD><EFBFBD>
        free(szjson);
    } else {
        std::cerr << ">>> curl init failed" << std::endl;
    }
    curl_easy_cleanup(curl);
    cJSON_Delete(json_root);
}*/

//<2F><><EFBFBD><EFBFBD>dataform<72><6D><EFBFBD>ͷ<EFBFBD>ʽ
void SendFileWeb(const std::string& strUrl, const char* localpath, const char* cloudpath, char* wavepath) {
    // <20><>ʼ<EFBFBD><CABC> curl
    CURL* curl = curl_easy_init();
    if (curl) {
        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> URL <20><> POST <20><><EFBFBD><EFBFBD>
        curl_easy_setopt(curl, CURLOPT_URL, strUrl.c_str());
        curl_easy_setopt(curl, CURLOPT_POST, 1);

        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
        curl_httppost* formpost = nullptr;
        curl_httppost* lastptr = nullptr;

        // <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC>ֶΣ<D6B6>ֱ<EFBFBD>Ӵӱ<D3B4><D3B1><EFBFBD>·<EFBFBD><C2B7><EFBFBD><EFBFBD>ȡ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
        curl_formadd(&formpost, &lastptr,
                     CURLFORM_COPYNAME, "file",
                     CURLFORM_FILE, localpath,
                     CURLFORM_END);

        // <20><><EFBFBD><EFBFBD> `path` <20>ֶ<EFBFBD>
        curl_formadd(&formpost, &lastptr,
                     CURLFORM_COPYNAME, "path",
                     CURLFORM_COPYCONTENTS, cloudpath,
                     CURLFORM_END);

        // <20><><EFBFBD><EFBFBD> `isReserveName` <20>ֶ<EFBFBD>
        curl_formadd(&formpost, &lastptr,
                     CURLFORM_COPYNAME, "isReserveName",
                     CURLFORM_COPYCONTENTS, "true",
                     CURLFORM_END);

        // <20><><EFBFBD>ñ<EFBFBD><C3B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD><DDB5><EFBFBD><EFBFBD><EFBFBD>
        curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);

        // <20><><EFBFBD><EFBFBD>ͷ<EFBFBD><CDB7>Ϣ
        struct curl_slist* header_list = nullptr;
        header_list = curl_slist_append(header_list, "Content-Type: multipart/form-data");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, header_list);

        // <20><><EFBFBD>ó<EFBFBD>ʱʱ<CAB1><CAB1>
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10);
        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10);

        // <20><><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD>ݵĺ<DDB5><C4BA><EFBFBD>
        std::string resPost0;
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&resPost0);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, req_reply_web);

        // ִ<><D6B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
        CURLcode res = curl_easy_perform(curl);
        if (res != CURLE_OK) {
            std::cerr << "http web failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            std::cout << "http web success, response: " << resPost0 << std::endl;
            handleUploadResponse(resPost0, wavepath);  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӧ
        }

        // <20><><EFBFBD><EFBFBD>
        curl_formfree(formpost);  // <20>ͷű<CDB7><C5B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
        curl_slist_free_all(header_list);  // <20>ͷ<EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD>б<EFBFBD>
        curl_easy_cleanup(curl);
    } else {
        std::cerr << ">>> curl init failed" << std::endl;
    }
}

void SOEFileWeb(char* localpath,char* cloudpath, char* wavepath)
{
	//ʾ<><CABE>ip<69><70><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊʵ<CEAA><CAB5>ip<69><70><EFBFBD><EFBFBD>
	SendFileWeb(WEB_FILEUPLOAD,localpath,cloudpath,wavepath);
}

void SOEFileWeb_test()
{
	char localpath[128] = {"/FeProject/comtrade/his/PQMonitor_PQM1_000420_20250310_151030_923.cfg"};
	char cloudpath[128] = {"/comtrade/192.168.1.105/"};
	char wavepath[128] = {""};
	SOEFileWeb(localpath,cloudpath,wavepath);
	std::cout << "wavepath:" << wavepath << std::endl;
}
/*/////////////////////////////////////////////////////////lnk10-24<32><34><EFBFBD><EFBFBD>web<65>ӿ<EFBFBD><D3BF>޸<EFBFBD>/////////////////////////////////////////////////////////////*/
/*<2A><>װC<D7B0>ɵ<EFBFBD><C9B5>õ<EFBFBD>̨<EFBFBD>˸<EFBFBD><CBB8>º<EFBFBD><C2BA><EFBFBD> */////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int update_one_terminal_ledger(terminal* update, int i,ied_t* ied,int terminal_index,int ied_take)			
{
	chnl_usr_t* chnl_usr = NULL;
	ied_usr_t* ied_usr = NULL;
	ied_usr = (ied_usr_t*)ied->usr_ext;

	// <20><> update[i] <20>е<EFBFBD><D0B5><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD>뵽 ied_usr <20><>
	if (strlen(update[i].terminal_id) != 0) {
	    apr_snprintf(ied_usr->terminal_id, sizeof(ied_usr->terminal_id), "%s", update[i].terminal_id);
	    printf("ied_usr->terminal_id: %s\n", ied_usr->terminal_id);
	}
	if (update[i].terminal_code != NULL) {
	    apr_snprintf(ied_usr->terminal_code, sizeof(ied_usr->terminal_code), "%s", update[i].terminal_code);
	    printf("ied_usr->terminal_code: %s\n", ied_usr->terminal_code);
	}
	if (update[i].tmnl_factory != NULL) {
	    apr_snprintf(ied_usr->tmnl_factory, sizeof(ied_usr->tmnl_factory), "%s", update[i].tmnl_factory);
	    printf("ied_usr->tmnl_factory: %s\n", ied_usr->tmnl_factory);
	}
	if (update[i].tmnl_status != NULL) {
	    apr_snprintf(ied_usr->tmnl_status, sizeof(ied_usr->tmnl_status), "%s", update[i].tmnl_status);
	    printf("ied_usr->tmnl_status: %s\n", ied_usr->tmnl_status);
	}
	if (update[i].dev_type != NULL) {
	    apr_snprintf(ied_usr->dev_type, sizeof(ied_usr->dev_type), "%s", update[i].dev_type);
	    printf("ied_usr->dev_type: %s\n", ied_usr->dev_type);
	}
	if (update[i].processNo != NULL) {
	    apr_snprintf(ied_usr->processNo, sizeof(ied_usr->processNo), "%s", update[i].processNo);
	    printf("ied_usr->processNo: %s\n", ied_usr->processNo);
	}
	if (update[i].dev_series != NULL) {
	    apr_snprintf(ied_usr->dev_series, sizeof(ied_usr->dev_series), "%s", update[i].dev_series);
	    printf("ied_usr->dev_series: %s\n", ied_usr->dev_series);
	} else {
	    apr_snprintf(ied_usr->dev_series, sizeof(ied_usr->dev_series), "%s", "");  // Ĭ<><C4AC>Ϊ<EFBFBD><CEAA><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>
	    printf("ied_usr->dev_series (default): %s\n", ied_usr->dev_series);
	}
	if (update[i].dev_key != NULL) {
	    apr_snprintf(ied_usr->dev_key, sizeof(ied_usr->dev_key), "%s", update[i].dev_key);
	    printf("ied_usr->dev_key: %s\n", ied_usr->dev_key);
	} else {
	    apr_snprintf(ied_usr->dev_key, sizeof(ied_usr->dev_key), "%s", "");  // Ĭ<><C4AC>Ϊ<EFBFBD><CEAA><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>
	    printf("ied_usr->dev_key (default): %s\n", ied_usr->dev_key);
	}

	ied_usr->dev_idx = terminal_index;        //<2F>ն<EFBFBD><D5B6>źţ<C5BA>g_node<64>±<EFBFBD>
	printf("dev_idx: %d\n", ied_usr->dev_idx);

	ied->channel[0].channel_type = CHANNEL_TYPE_IPV4;  // channel
	ied->channel[0].addr_str[LONGNAME - 1] = 0;  // DEV_IP
	if (update[i].addr_str != NULL) {
	    ied->channel[0].addr = ntohl(inet_addr(update[i].addr_str));  // DEV_IP
	    strncpy(ied->channel[0].addr_str, update[i].addr_str, LONGNAME - 1);  // DEV_IP
	    printf("ied_usr->addr_str: %s\n", ied->channel[0].addr_str);
	} else {
	    ied->channel[0].addr = ntohl(inet_addr("0.0.0.0"));  // DEV_IP
	    strncpy(ied->channel[0].addr_str, update[i].addr_str, LONGNAME - 1);  // DEV_IP
	    printf("ied_usr->addr_str: %s\n", ied->channel[0].addr_str);
	}
	if (update[i].port != NULL) {
	    int port = 102;
	    if (stringToInt(update[i].port, &port)) {
	        // ת<><D7AA><EFBFBD>ɹ<EFBFBD><C9B9><EFBFBD>portStrȫΪ<C8AB><CEAA><EFBFBD>֣<EFBFBD><D6A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ѿ<EFBFBD>ת<EFBFBD><D7AA>Ϊint<6E><74><EFBFBD>͵<EFBFBD>port  
	        ied->channel[0].port = port;  // DEV_PortID
	        printf("ied_usr->port: %d\n", ied->channel[0].port);  // DEV_PortID
	    } else {
	        ied->channel[0].port = 102;  // DEV_PortID
	        printf("ied_usr->port: %s, <20>ǺϷ<C7BA><CFB7>˿<EFBFBD>. ʹ<><CAB9>Ĭ<EFBFBD>϶˿<CFB6>: %d\n", update[i].port, ied->channel[0].port);  // DEV_PortID
	    }
	}

	if (update[i].timestamp != NULL && strlen(update[i].timestamp) > 0) {
	    // <20><><EFBFBD><EFBFBD>struct tm<74><6D><EFBFBD><EFBFBD>
	    struct tm timeinfo = {0};  // <20><>ʼ<EFBFBD><CABC>Ϊ0
	    // <20><><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD>ʽΪ "YYYY-MM-DD HH:MM:SS"
	    // ʹ<><CAB9>sscanf<6E><66><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD>ֶ<EFBFBD>
	    if (sscanf(update[i].timestamp, "%4d-%2d-%2d %2d:%2d:%2d",
	               &timeinfo.tm_year, &timeinfo.tm_mon, &timeinfo.tm_mday,
	               &timeinfo.tm_hour, &timeinfo.tm_min, &timeinfo.tm_sec) == 6) {
	        // <20><><EFBFBD><EFBFBD><EFBFBD>ݴ<EFBFBD>1900<30><30>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>
	        timeinfo.tm_year -= 1900;
	        // <20>·ݴ<C2B7>0<EFBFBD><30>ʼ<EFBFBD><CABC><EFBFBD>㣬<EFBFBD><E3A3AC>ȥ1
	        timeinfo.tm_mon -= 1;
	        // <20><>tm_isdst<73><74><EFBFBD>г<EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ-1<><31><EFBFBD><EFBFBD>mktime<6D>Զ<EFBFBD><D4B6>ж<EFBFBD>
	        timeinfo.tm_isdst = -1;
	        // ʹ<><CAB9>mktime<6D><65>struct tmת<6D><D7AA>Ϊtime_t
	        time_t raw_time = mktime(&timeinfo);
	        // <20>ж<EFBFBD>mktime<6D>Ƿ<EFBFBD><C7B7>ɹ<EFBFBD>
	        if (raw_time != -1) {
	            ied_usr->time = (long long)raw_time;
	            printf("ied_usr->time: %lld\n", ied_usr->time);
	        } else {
	            printf("Error: mktime failed.\n");
	        }
	    } else {
	        printf("Error: sscanf failed. Invalid timestamp format.\n");
			return -1;
	    }
	}

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʹ<EFBFBD><CAB9><EFBFBD><EFBFBD><EFBFBD>пռ<D0BF><D5BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	if(!ied_take){
		chnl_usr = (chnl_usr_t*)apr_pcalloc(g_init_pool, sizeof(chnl_usr_t));
		ied->channel[0].connect = chnl_usr;
		g_pt61850app->chnl_counts++;	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD>
	}
	else{
		chnl_usr = (chnl_usr_t*)ied->channel[0].connect;
	}

	chnl_usr->chnl = &(ied->channel[0]);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>е<EFBFBD>ied<65><64><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5>ԭ<EFBFBD><D4AD><EFBFBD>ʹ<EFBFBD><CDB4>ڵģ<DAB5><C4A3>ٸ<EFBFBD>ֵһ<D6B5><D2BB>
	chnl_usr->chnl_id = 0;
	chnl_usr->m_state = CHANNEL_DISCONNECTED;
	chnl_usr->m_ClosedMsTime = NEXT_CONNECT_TIME * (-1);

	// <20><> monitorData <20>е<EFBFBD><D0B5><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD>뵽 LD_info <20><>
	int count_real_monitor = 0;	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̨<EFBFBD>˵ļ<CBB5><C4BC><EFBFBD><EFBFBD><EFBFBD>
	int j;
	for (j = 0; j < 10 && update[i].line[j].monitor_id[0] != '\0'; ++j) {
	    monitor monitor_data = update[i].line[j];
		//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		count_real_monitor++;
	    // <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD> LD_info<66><6F><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>漰ָ<E6BCB0><D6B8><EFBFBD>IJ<EFBFBD><C4B2>ֶ<EFBFBD>Ϊ<EFBFBD><CEAA>
	    LD_info_t line_info;
	    memset(&line_info, 0, sizeof(line_info));

		char logical_device_seq[64];
	    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
	    strncpy(line_info.mp_id, monitor_data.monitor_id, sizeof(line_info.mp_id) - 1);
	    strncpy(line_info.name, monitor_data.monitor_name, sizeof(line_info.name) - 1);	    
	    strncpy(line_info.voltage_level, monitor_data.voltage_level, sizeof(line_info.voltage_level) - 1);
	    strncpy(line_info.v_wiring_type, monitor_data.terminal_connect, sizeof(line_info.v_wiring_type) - 1);
	    strncpy(line_info.monitor_status, monitor_data.status, sizeof(line_info.monitor_status) - 1);
		strncpy(line_info.terminal_code, monitor_data.terminal_code, sizeof(line_info.terminal_code) - 1);
		strncpy(logical_device_seq, monitor_data.logical_device_seq, sizeof(logical_device_seq) - 1);
		if (isCharPtrEmpty(logical_device_seq)) {
		    line_info.cpuno = 1;  // Ĭ<>ϼ<EFBFBD><CFBC><EFBFBD><EFBFBD><EFBFBD>ʵ<EFBFBD><CAB5><EFBFBD><EFBFBD>1
		    printf("logical_device_seq: is null, set cpuno: %d\n", (int)line_info.cpuno);
		} else {
		    line_info.cpuno = atoi(logical_device_seq);
		    printf("logical_device_seq: %d\n", (int)line_info.cpuno);
		}
		line_info.line_id = count_real_monitor;  // <20><>¼<EFBFBD>ն<EFBFBD><D5B6>ź<EFBFBD>

		printf("line_id: %d\n", line_info.line_id);
		printf("mp_id: %s\n", line_info.mp_id);
		printf("terminal_code: %s\n", line_info.terminal_code);
		printf("voltage_level: %s\n", line_info.voltage_level);
		printf("v_wiring_type: %s\n", line_info.v_wiring_type);
		printf("monitor_status: %s\n", line_info.monitor_status);
		printf("name: %s\n", line_info.name);

		//lnk20250214<31><34><EFBFBD><EFBFBD>
		if (strcmp(line_info.v_wiring_type, "0") != 0)
		{
			isdelta_flag = 1;	//<2F><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD>ͽ<EFBFBD><CDBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ǰ<EFBFBD>þ<EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD>ڶ<EFBFBD><DAB6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD>
			cout << "monitor_id" << line_info.mp_id << "v_wiring_type:" << line_info.v_wiring_type << "is delta wiring:" << isdelta_flag << endl;
		}

	    // <20><><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>
	    if (update[i].timestamp[0] != '\0') {
		    struct tm timeinfo;
		    char timestamp[64];
		    // <20><><EFBFBD><EFBFBD>update[i].timestamp<6D><70>ʽΪ "YYYY-MM-DD HH:MM:SS"
		    // <20><><EFBFBD>磺"2023-01-14 12:34:56"
		    sscanf(update[i].timestamp, "%4d-%2d-%2d %2d:%2d:%2d",
		           &timeinfo.tm_year, &timeinfo.tm_mon, &timeinfo.tm_mday,
		           &timeinfo.tm_hour, &timeinfo.tm_min, &timeinfo.tm_sec);
		    // <20><><EFBFBD><EFBFBD><EFBFBD>ݴ<EFBFBD>1900<30>꿪ʼ<EABFAA><CABC><EFBFBD><EFBFBD>
		    timeinfo.tm_year -= 1900;
		    // <20>·ݴ<C2B7>0<EFBFBD><30>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>1
		    timeinfo.tm_mon -= 1;
		    // <20><>tm_isdst<73><74><EFBFBD>г<EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ-1<><31><EFBFBD><EFBFBD>mktime<6D>Զ<EFBFBD><D4B6>ж<EFBFBD>
		    timeinfo.tm_isdst = -1;
		    // ʹ<><CAB9>mktime<6D><65>struct tmת<6D><D7AA>Ϊtime_t
		    time_t raw_time = mktime(&timeinfo);
		    // <20>ж<EFBFBD>mktime<6D>Ƿ<EFBFBD><C7B7>ɹ<EFBFBD>
		    if (raw_time != -1) {
		        line_info.time = (long long)raw_time;
		        printf("time: %lld\n", line_info.time);
		    } else {
		        printf("Error: mktime failed.\n");
				return -1;
		    }
		}				
		line_info.read_flag = 1;				//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ч
	    // <20><><EFBFBD><EFBFBD> LD_info
		if (ied && ied->usr_ext && line_info.cpuno && ((int)line_info.cpuno < 10)) {
		    char str[256];
		    byte_t cpuno = line_info.cpuno;	//ʹ<><CAB9><EFBFBD><EFBFBD>̨<EFBFBD>˵<EFBFBD><CBB5>߼<EFBFBD><DFBC><EFBFBD><EFBFBD>кţ<D0BA><C5A3><EFBFBD>ʹ<EFBFBD><CAB9>ԭ<EFBFBD><D4AD>ied<65><64><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>£<EFBFBD><C2A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>к<EFBFBD><D0BA><EFBFBD><EFBFBD><EFBFBD>С<EFBFBD><D0A1>ԭ<EFBFBD><D4AD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ô<EFBFBD>µIJ<C2B5><C4B2>ֻᱻ<D6BB><E1B1BB><EFBFBD>ǣ<EFBFBD><C7A3><EFBFBD><EFBFBD><EFBFBD>ɾ<EFBFBD><C9BE>ʱû<CAB1><C3BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ԭ<EFBFBD>е<EFBFBD><D0B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֻ<EFBFBD><D6BB>Դ<EFBFBD><D4B4><EFBFBD><EFBFBD>ڴ<EFBFBD><DAB4>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ᱻʹ<E1B1BB><CAB9>
		    printf("cpuno: %d\n", (int)line_info.cpuno);
		    printf("index cpuno: %d\n", cpuno - 1);

		    ied_usr = (ied_usr_t*)ied->usr_ext;
		    //ied_usr->LD_info[cpuno - 1] = line_info;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ں<EFBFBD><DABA>棬<EFBFBD><E6A3AC>Ϊ<EFBFBD><CEAA>Ҫ<EFBFBD><D2AA><EFBFBD>ж<EFBFBD>ԭ<EFBFBD>е<EFBFBD>ָ<EFBFBD><D6B8>
		    //ied_usr->LD_info[cpuno - 1].ied = ied;  //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ں<EFBFBD><DABA>棬<EFBFBD><E6A3AC>Ϊ<EFBFBD><CEAA>Ҫ<EFBFBD><D2AA><EFBFBD>ж<EFBFBD>ԭ<EFBFBD>е<EFBFBD>ָ<EFBFBD><D6B8>

			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>¼<EFBFBD><C2BC><EFBFBD>ܵ<EFBFBD><DCB5><EFBFBD><EFBFBD>е<EFBFBD>ldname
			char *ldname = NULL;

			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>¼<EFBFBD><C2BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>еı<D0B5><C4B1>桢<EFBFBD><E6A1A2>־<EFBFBD><D6BE><EFBFBD><EFBFBD>
			loginfo_t			**loginfo = NULL;
			rptinfo_t			**rptinfo = NULL;

			//<2F><><EFBFBD><EFBFBD>
			//printf("check error111 !!!!!!!!!!!!!!\n");

			

/////////			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>еIJ<D0B5><C4B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ռ<EFBFBD>ÿռ<C3BF>
			if (ied_usr->LD_info[cpuno - 1].autorecallcount != 0) {
				for (int j = 0; j < ied_usr->LD_info[cpuno - 1].autorecallcount; j++) {
					if(NULL != ied_usr->LD_info[cpuno - 1].autorecall[j]){
						delete ied_usr->LD_info[cpuno - 1].autorecall[j];
					}					
				}
				if(NULL != ied_usr->LD_info[cpuno - 1].autorecall){
					delete ied_usr->LD_info[cpuno - 1].autorecall;
				}
				
				ied_usr->LD_info[cpuno - 1].autorecallcount = 0;
			}

			//<2F><><EFBFBD><EFBFBD>
			//printf("check error112 !!!!!!!!!!!!!!\n");

////////			//<2F><>¼ԭ<C2BC>еı<D0B5><C4B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>־<EFBFBD><D6BE><EFBFBD><EFBFBD>
			loginfo = ied_usr->LD_info[cpuno - 1].loginfo?ied_usr->LD_info[cpuno - 1].loginfo:NULL;
			rptinfo = ied_usr->LD_info[cpuno - 1].rptinfo?ied_usr->LD_info[cpuno - 1].rptinfo:NULL;

			//<2F><><EFBFBD><EFBFBD>
			//printf("check error113 !!!!!!!!!!!!!!\n");

    		//<2F><><EFBFBD><EFBFBD><EFBFBD>ظ<EFBFBD><D8B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ棬<DAB4><E6A3AC><EFBFBD><EFBFBD>ʹ<EFBFBD><CAB9><EFBFBD>Ѵ<EFBFBD><D1B4>ڵ<EFBFBD>ied<65><64><EFBFBD><EFBFBD>ô<EFBFBD><C3B4>֮ǰ<D6AE><C7B0>ʼ<EFBFBD><CABC><EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD>˹<EFBFBD>ϣ<EFBFBD><CFA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɾ<EFBFBD><C9BE>̨<EFBFBD><CCA8>ʱû<CAB1><C3BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA>ԭ<EFBFBD><D4AD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    		if (ied_usr->LD_info[cpuno - 1].ht_fcd != NULL) {
    		    apr_hash_clear(ied_usr->LD_info[cpuno - 1].ht_fcd);
    		}
    		if (ied_usr->LD_info[cpuno - 1].ht_full_fcda != NULL) {
    		    apr_hash_clear(ied_usr->LD_info[cpuno - 1].ht_full_fcda);
    		}

			//<2F><><EFBFBD><EFBFBD>
			//printf("check error116 !!!!!!!!!!!!!!\n");

			//<2F><>Щ<EFBFBD><D0A9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>е<EFBFBD><D0B5>ڴ棬<DAB4><E6A3AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̨<EFBFBD><CCA8>ɾ<EFBFBD><C9BE>ʱ<EFBFBD><CAB1>Ӧ<EFBFBD><D3A6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
			apr_snprintf(str, sizeof(str), "PQMonitorPQM%d", cpuno);

			// <20><><EFBFBD><EFBFBD>û<EFBFBD><C3BB>ֵʱ<D6B5><CAB1><EFBFBD><EFBFBD> LD_name<6D><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ظ<EFBFBD><D8B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD>
			if (ied_usr->LD_info[cpuno - 1].LD_name == NULL) {

				//lnk20250208<30><38><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				std::cout << "new space for LD_name" << std::endl;
			  
				//lnk20250208<30><38>ʹ<EFBFBD><CAB9>apr_pstrdup<75><70>ʹ<EFBFBD>ù̶<C3B9><CCB6><EFBFBD>С<EFBFBD><D0A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD><DAB4><EFBFBD>ֱ<EFBFBD>Ӹ<EFBFBD><D3B8><EFBFBD>
				//ied_usr->LD_info[cpuno - 1].LD_name = apr_pstrdup(g_init_pool, str);
				// <20><> g_init_pool <20>ڴ<EFBFBD><DAB4><EFBFBD><EFBFBD>з<EFBFBD><D0B7><EFBFBD><EFBFBD>̶<EFBFBD> 256 <20>ֽڵ<D6BD><DAB5>ڴ<EFBFBD>
				ied_usr->LD_info[cpuno - 1].LD_name = (char *)apr_palloc(g_init_pool, 256);

				// <20><><EFBFBD><EFBFBD><EFBFBD>ڴ棬<DAB4><E6A3AC>ֹ<EFBFBD><D6B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				memset(ied_usr->LD_info[cpuno - 1].LD_name, 0, 256);

				// <20><> str <20>е<EFBFBD><D0B5><EFBFBD><EFBFBD>ݸ<EFBFBD><DDB8>Ƶ<EFBFBD>Ԥ<EFBFBD>ȷ<EFBFBD><C8B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD><DAB4>У<EFBFBD><D0A3><EFBFBD><EFBFBD>ิ<EFBFBD><E0B8B4> 256 <20>ֽڣ<D6BD><DAA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				apr_cpystrn(ied_usr->LD_info[cpuno - 1].LD_name, str, 256);

			} else {//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>滻<EFBFBD><E6BBBB><EFBFBD><EFBFBD>ԭ<EFBFBD>пռ<D0BF><D5BC>ϸ<EFBFBD><CFB8><EFBFBD>

				//lnk20250208<30><38><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				std::cout << "old space for LD_name:" << ied_usr->LD_info[cpuno - 1].LD_name <<std::endl;

				// <20><><EFBFBD><EFBFBD><EFBFBD>ڴ棬<DAB4><E6A3AC>ֹ<EFBFBD><D6B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				memset(ied_usr->LD_info[cpuno - 1].LD_name, 0, 256);

				//printf("check error333 !!!!!!!!!!!!!!\n");

				apr_cpystrn(ied_usr->LD_info[cpuno - 1].LD_name, str, 256);	//ԭ<>пռ串<D5BC><E4B8B2>

				//printf("check error222 !!!!!!!!!!!!!!\n");
			}

			ldname = ied_usr->LD_info[cpuno - 1].LD_name;

			//<2F><><EFBFBD><EFBFBD>
			//printf("check error114 !!!!!!!!!!!!!!\n");

			ied_usr->LD_info[cpuno - 1] = line_info;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ں<EFBFBD><DABA>棬<EFBFBD><E6A3AC>Ϊ<EFBFBD><CEAA>Ҫ<EFBFBD><D2AA><EFBFBD>ж<EFBFBD>ԭ<EFBFBD>е<EFBFBD>ָ<EFBFBD><D6B8>
		    ied_usr->LD_info[cpuno - 1].ied = ied;  //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ں<EFBFBD><DABA>棬<EFBFBD><E6A3AC>Ϊ<EFBFBD><CEAA>Ҫ<EFBFBD><D2AA><EFBFBD>ж<EFBFBD>ԭ<EFBFBD>е<EFBFBD>ָ<EFBFBD><D6B8>

			//<2F><><EFBFBD><EFBFBD>
			//printf("check error115 !!!!!!!!!!!!!!\n");



			ied_usr->LD_info[cpuno - 1].LD_name = ldname;//<2F><>¼ԭ<C2BC>еĻ<D0B5><C4BB><EFBFBD><EFBFBD>µ<EFBFBD>ldname

			//<2F><><EFBFBD><EFBFBD>
			printf("ledger ied_usr->LD_info[cpuno - 1].LD_name: %s\n", ied_usr->LD_info[cpuno - 1].LD_name);

			ied_usr->LD_info[cpuno - 1].ht_fcd = apr_hash_make(g_init_pool);	//<2F><><EFBFBD>´<EFBFBD><C2B4><EFBFBD><EFBFBD><EFBFBD>ϣ<EFBFBD><CFA3>
			ied_usr->LD_info[cpuno - 1].ht_full_fcda = apr_hash_make(g_init_pool);

		    ied_usr->LD_info[cpuno - 1].rptcount = 0;	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>㣬<EFBFBD><E3A3AC><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5>ied_usr->LD_info[cpuno - 1] = line_info;ʱӦ<CAB1>þ<EFBFBD><C3BE><EFBFBD><EFBFBD><EFBFBD>0<EFBFBD><30><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀռ<C4BF><D5BC><EFBFBD><EFBFBD>ڱ<EFBFBD><DAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>
		    printf("rptcount: %d\n", ied_usr->LD_info[cpuno - 1].rptcount);

			//ʹ<><CAB9>ԭ<EFBFBD>еı<D0B5><C4B1><EFBFBD><EFBFBD><EFBFBD>־<EFBFBD>ռ<EFBFBD>
			ied_usr->LD_info[cpuno - 1].loginfo = loginfo;	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>µĻ<C2B5><C4BB>ǾɵĿռ䣬<D5BC><E4A3AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD>涼<EFBFBD>Ὣ<EFBFBD><E1BDAB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
			ied_usr->LD_info[cpuno - 1].rptinfo = rptinfo;

		    if (cpuno > ied->cpucount) {//<2F><>̨<EFBFBD>˵<EFBFBD><CBB5>߼<EFBFBD><DFBC>Ŵ<EFBFBD><C5B4><EFBFBD>iedԭ<64>е<EFBFBD>cpu<70><75><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>0<EFBFBD><30><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>cpu<70><75><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>¼<EFBFBD>ж<EFBFBD><D0B6>ٸ<EFBFBD><D9B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		        ied->cpucount = cpuno;
		    }
		}
		printf("Monitor Info [ID: %s, Name: %s] saved in LD_info\n", line_info.mp_id, line_info.name);
	}
	return 0;
}

////////////////////////////////////////////////////////////////////////̨<>˸<EFBFBD><CBB8>¼<EFBFBD>¼<EFBFBD><C2BC>־
// <20><>ȡ<EFBFBD><C8A1>ǰʱ<C7B0>䲢<EFBFBD><E4B2A2>ʽ<EFBFBD><CABD>Ϊ "YYYY-MM-DD HH:MM:SS"
std::string get_current_time() {
    std::time_t t = std::time(NULL);
    struct std::tm tm = *std::localtime(&t);

    char buffer[80];
    strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &tm);
    return std::string(buffer);
}

// д<><D0B4><EFBFBD><EFBFBD>־<EFBFBD><D6BE>Ŀ
void write_log_entry(std::ofstream &log_file, const std::string &action, const std::string &terminal_id, const std::string &current_time) {
    log_file << terminal_id << "\t" << action << "time:" << current_time << "\n";
}

// <20><><EFBFBD><EFBFBD>̨<EFBFBD>˸<EFBFBD><CBB8><EFBFBD><EFBFBD><EFBFBD>־
void create_ledger_log(trigger_update_xml_t* ledger_update_xml) {

	std::cout << "create_ledger_log." << std::endl;

    std::string log_filename = "../etc/" + std::string(LEDGER_UPDATE_FN);
    std::ofstream log_file(log_filename.c_str(), std::ios::app);  // <20><>׷<EFBFBD><D7B7>ģʽ<C4A3><CABD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>

    if (!log_file.is_open()) {
        std::cerr << "Failed to open log file: " << log_filename << std::endl;
        return;
    }

	std::vector<std::pair<std::string, std::string> > new_entries;      // <20><><EFBFBD>ڴ洢new<65><77>terminal_id<69><64>ʱ<EFBFBD><CAB1>
	std::vector<std::pair<std::string, std::string> > modify_entries;   // <20><><EFBFBD>ڴ洢modify<66><79>terminal_id<69><64>ʱ<EFBFBD><CAB1>
	std::vector<std::pair<std::string, std::string> > delete_entries;   // <20><><EFBFBD>ڴ洢delete<74><65>terminal_id<69><64>ʱ<EFBFBD><CAB1>

    std::string current_time = get_current_time(); // <20><>ȡ<EFBFBD><C8A1>ǰʱ<C7B0><CAB1>

    // <20><><EFBFBD><EFBFBD> new_updates
    for (int i = 0; i < ledger_update_xml->new_update_num; ++i) {
        std::string terminal_id = ledger_update_xml->new_updates[i].terminal_id;
        new_entries.push_back(std::make_pair(terminal_id, current_time));
    }

    // <20><><EFBFBD><EFBFBD> modify_updates
    for (int i = 0; i < ledger_update_xml->modify_update_num; ++i) {
        std::string terminal_id = ledger_update_xml->modify_updates[i].terminal_id;
        modify_entries.push_back(std::make_pair(terminal_id, current_time));
    }

    // <20><><EFBFBD><EFBFBD> delete_updates
    for (int i = 0; i < ledger_update_xml->delete_update_num; ++i) {
        std::string terminal_id = ledger_update_xml->delete_updates[i].terminal_id;
        delete_entries.push_back(std::make_pair(terminal_id, current_time));
    }

    // д<><D0B4><EFBFBD><EFBFBD>־<EFBFBD>ļ<EFBFBD>
    if (!new_entries.empty()) {
        log_file << "<new>\n";
        for (size_t i = 0; i < new_entries.size(); ++i) {
            write_log_entry(log_file, "add", new_entries[i].first, new_entries[i].second);
        }
        log_file << "</new>\n";
    }

    if (!modify_entries.empty()) {
        log_file << "<modify>\n";
        for (size_t i = 0; i < modify_entries.size(); ++i) {
            write_log_entry(log_file, "modify", modify_entries[i].first, modify_entries[i].second);
        }
        log_file << "</modify>\n";
    }

    if (!delete_entries.empty()) {
        log_file << "<delete>\n";
        for (size_t i = 0; i < delete_entries.size(); ++i) {
            write_log_entry(log_file, "delete", delete_entries[i].first, delete_entries[i].second);
        }
        log_file << "</delete>\n";
    }

    log_file.close();
    std::cout << "Ledger log has been updated." << std::endl;
}	
///////////////////////////////////////////////////////////////////////////̨<><CCA8><EFBFBD>ڴ<EFBFBD><DAB4><EFBFBD><EFBFBD>䲿<EFBFBD>ֹ<EFBFBD><D6B9>ܴ<EFBFBD><DCB4>룺δʹ<CEB4><CAB9>
// ɾ<><C9BE>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD>ӳ<EFBFBD>
void delete_sub_pool(const char* terminal_id) {
    std::list<std::pair<std::string, apr_pool_t*> >::iterator it;
    
    for (it = pool_list.begin(); it != pool_list.end(); ++it) {
        if (it->first == terminal_id) {
            apr_pool_destroy(it->second);  // <20><><EFBFBD><EFBFBD><EFBFBD>ӳ<EFBFBD>
            pool_list.erase(it);  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƴ<EFBFBD>
            break;
        }
    }
}
//<2F>Ҷ<EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD>ӳ<EFBFBD>
apr_pool_t* find_sub_pool(const char* terminal_id) {
    std::list<std::pair<std::string, apr_pool_t*> >::iterator it;
    
    for (it = pool_list.begin(); it != pool_list.end(); ++it) {
        if (it->first == terminal_id) {
            return it->second;  // <20>ҵ<EFBFBD><D2B5><EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD>ӳ<EFBFBD>
        }
    }
    
    return NULL;  // û<><C3BB><EFBFBD>ҵ<EFBFBD><D2B5><EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD>ӳ<EFBFBD>
}
// <20><><EFBFBD><EFBFBD><EFBFBD>ӳز<D3B3><D8B2><EFBFBD><EFBFBD>ӵ<EFBFBD><D3B5><EFBFBD><EFBFBD><EFBFBD>
apr_pool_t* create_sub_pool(apr_pool_t* parent_pool, const char* terminal_id) {
    apr_pool_t* new_sub_pool = NULL;

    // <20>ڸ<EFBFBD><DAB8><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ӳ<EFBFBD>
    apr_pool_create(&new_sub_pool, parent_pool);
    
    if (new_sub_pool == NULL) {
        return NULL;  // <20><><EFBFBD><EFBFBD>ʧ<EFBFBD><CAA7>
    }

    // <20><><EFBFBD>ӳغ<D3B3><D8BA>ն<EFBFBD> ID <20>洢<EFBFBD><E6B4A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    pool_list.push_back(std::make_pair(std::string(terminal_id), new_sub_pool));

    return new_sub_pool;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
//̨<>˱<EFBFBD><CBB1><EFBFBD><EFBFBD>ı<EFBFBD><C4B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC>
int parse_rpt_log_ini_one(ied_t* ied)
{
	QMap<QString, QStringList*> rpt_cfg_strlists;
	QMap<QString, QStringList*> log_cfg_strlists;

	int	iedno, cpuno;
	ied_usr_t* ied_usr;
	LD_info_t* LD_info;
	char		buf[256];

	ied_usr = GET_IEDEXT_ADDR(ied);
	QString type;
	type.append(ied_usr->dev_type);
	if (!rpt_cfg_strlists.contains(type))
	{
		QStringList* rpt_temp = new QStringList();
		QStringList* log_temp = new QStringList();
		rpt_cfg_strlists.insert(type, rpt_temp);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD>
		log_cfg_strlists.insert(type, log_temp);//<2F><>־<EFBFBD><D6BE><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD>
		//g_DevFlagû<67><C3BB>ʹ<EFBFBD><CAB9>
		parse_one_rpt_log_ini(g_DevFlag, rpt_cfg_strlists[type], log_cfg_strlists[type], ied_usr->dev_type);
	}

	//lnk20250208<30><38><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	std::cout << "ied->cpucount:" << (int)(ied->cpucount) <<std::endl;

	for (cpuno = 0; cpuno < ied->cpucount; cpuno++) {//<2F><><EFBFBD><EFBFBD>iedʵ<64>ʵļ<CAB5><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

		//lnk20250208<30><38><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		std::cout << "cpuno:" << cpuno << "log init !!!!!!" <<std::endl;

		LD_info = &(ied_usr->LD_info[cpuno]);

		//<2F><>Щ<EFBFBD><D0A9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>е<EFBFBD><D0B5>ڴ棬<DAB4><E6A3AC><EFBFBD><EFBFBD><EFBFBD>жϲ<D0B6><CFB2>ܴ<EFBFBD>g_init_pool<6F>з<EFBFBD><D0B7><EFBFBD><EFBFBD>ڴ棬lnk20250122
		char str[256];
		char* tmp = Get_IED(ied_usr->dev_type);
		if(tmp == NULL){std::cerr << "front read ied config error!" << std::endl;continue;}
		qDebug() << tmp << endl;
		apr_snprintf(str, sizeof(str), tmp, cpuno + 1);

		//<2F><><EFBFBD><EFBFBD>
		printf("logini ied_usr->LD_info[cpuno - 1].LD_name: %s\n", ied_usr->LD_info[cpuno].LD_name);

		delete[] tmp;//Get_IED<45>з<EFBFBD><D0B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ棬ʹ<E6A3AC>ú<EFBFBD>ɾ<EFBFBD><C9BE>

		//lnk20250208<30><38><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		std::cout << "cpuno:" << cpuno << " fill report control" <<std::endl;

		//<2F><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ı<EFBFBD><C4B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		init_rptctrl_by_count(LD_info, rpt_cfg_strlists[type]->size());
		for (int i = 0; i < rpt_cfg_strlists[type]->size(); ++i) {
			apr_snprintf(buf, sizeof(buf), "%s", rpt_cfg_strlists[type]->at(i).toAscii().constData());
			fill_rptctrl_by_cfg(LD_info, i, buf);
		}
		//<2F><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>־<EFBFBD><D6BE><EFBFBD><EFBFBD>
		init_logctrl_by_count(LD_info, log_cfg_strlists[type]->size());
		for (int i = 0; i < log_cfg_strlists[type]->size(); ++i) {
			apr_snprintf(buf, sizeof(buf), "%s", log_cfg_strlists[type]->at(i).toAscii().constData());
			char* tmp = Get_LDevice(ied_usr->dev_type);
			if(tmp == NULL){std::cerr << "front read monitor config error!" << std::endl;continue;}
			fill_logctrl_by_cfg(LD_info, i, buf, tmp);
			delete[] tmp;
		}
	}

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƿ<EFBFBD><C6BF><EFBFBD><EFBFBD><EFBFBD>־<EFBFBD><D6BE><EFBFBD>ƿ鴦<C6BF><E9B4A6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	for (QMap<QString, QStringList*>::iterator it1 = log_cfg_strlists.begin(); it1 != log_cfg_strlists.end(); ++it1)
	{
		delete it1.value();
	}
	for (QMap<QString, QStringList*>::iterator it2 = rpt_cfg_strlists.begin(); it2 != rpt_cfg_strlists.end(); ++it2)
	{
		delete it2.value();
	}
	rpt_cfg_strlists.clear();
	log_cfg_strlists.clear();

	return APR_SUCCESS;
}
////////////////////////////////////////////////////////////remdibtable
apr_status_t init_rem_dib_table_one(ied_t *ied)
{
	int pos = 0;
	int			iedno,chnl_no;
	struct in_addr	ip;
	chnl_usr_t	*chnl_usr;

	ied_usr_t* ied_usr;

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD>ú<EFBFBD>g_nodeһ<65><D2BB>
	ied_usr = (ied_usr_t*)ied->usr_ext;
	pos = ied_usr->dev_idx - 1;

	std::cout << "!!!!!!!!!rem_dib_table pos is " << pos << std::endl;

	for(chnl_no=0 ; chnl_no<ied->chncount; chnl_no++) {	
		chnl_usr = (chnl_usr_t*)ied->channel[chnl_no].connect;//<2F><>ʼ<EFBFBD><CABC>ʱ<EFBFBD>Ѹ<EFBFBD><D1B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ռ<EFBFBD>
		g_pt61850app->chnl_usr[pos] = chnl_usr;

		std::cout << "!!!!!!!!!g_pt61850app pos " << pos << "is " << ied_usr->terminal_id << "is" << (chnl_usr == NULL?"NULL":"NOTNULL") << std::endl;

		ip.s_addr = htonl(ied->channel[chnl_no].addr);
		strcpy(chnl_usr->ip_str,inet_ntoa(ip));
		printf( " add_rem_dib_table  %s:%d \n",chnl_usr->ip_str ,ied->channel[chnl_no].port );
		add_rem_dib_table (pos++,chnl_usr->ip_str,ied->channel[chnl_no].port );//<2F><>ǰ<EFBFBD>ն˵<D5B6>IP<49>˿ڼ<CBBF>¼<EFBFBD><C2BC><EFBFBD><EFBFBD><EFBFBD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD>Ҫע<D2AA><D7A2><EFBFBD><EFBFBD><EFBFBD>ӵ<EFBFBD><D3B5>±꣬<C2B1><EAA3AC><EFBFBD><EFBFBD>ɾ<EFBFBD><C9BE><EFBFBD>նˣ<D5B6><CBA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڵ<EFBFBD><DAB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ<EFBFBD><D4B4>ڣ<EFBFBD><DAA3>ٴ<EFBFBD>ʹ<EFBFBD><CAB9>ʱ<EFBFBD>ᱻ<EFBFBD>滻
		{
			char comm_str[256]; 
			memset(comm_str,0,256);
			apr_snprintf(comm_str,sizeof(comm_str),"%16s:%d\t\tinited",chnl_usr->ip_str,ied->channel[chnl_no].port);
			add_comm_log(comm_str);
		}
	}
	return APR_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////////////////////////<2F><><EFBFBD><EFBFBD>ied
void clearLogInfo(loginfo_t *loginfo) {
    if (loginfo == nullptr) {
        return; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>Ϊ<EFBFBD>գ<EFBFBD>ֱ<EFBFBD>ӷ<EFBFBD><D3B7><EFBFBD>
    }

    // <20><><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD>
    memset(loginfo->logName, 0, sizeof(loginfo->logName));

    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>Ա
    loginfo->IntgPd = 0;
    loginfo->reasonCode = 0;
    loginfo->TrgOpt = 0;

    loginfo->start_time = 0;
    loginfo->end_time = 0;
    loginfo->need_steady = 0;
    loginfo->need_voltage = 0;

    // <20><>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>Ա<EFBFBD><D4B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͷ<EFBFBD><CDB7>ڴ<EFBFBD>
    if (loginfo->lcbName != nullptr) {
        memset(loginfo->lcbName, 0, strlen(loginfo->lcbName)); // <20><><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    }
    if (loginfo->datasetName != nullptr) {
        memset(loginfo->datasetName, 0, strlen(loginfo->datasetName)); // <20><><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    }

    // <20><><EFBFBD><EFBFBD> LD_info <20><>ָ<EFBFBD>룬<EFBFBD><EBA3AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,<2C><>ָ<EFBFBD><D6B8><EFBFBD>ϼ<EFBFBD>
}

void clearRptInfo(rptinfo_t *rptinfo) {
    if (rptinfo == nullptr) {
        return; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>Ϊ<EFBFBD>գ<EFBFBD>ֱ<EFBFBD>ӷ<EFBFBD><D3B7><EFBFBD>
    }

    // <20><><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͷ<EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>Ա
	rptinfo->instanceNeedSuffix = 0;
	rptinfo->TrgOpt = 0;

    memset(rptinfo->OptFlds, 0, sizeof(rptinfo->OptFlds));
    rptinfo->IntgPd = 0;
    rptinfo->report_PQ_type = 0;

    rptinfo->rpt_registered = 0;
    rptinfo->chnl_id = 0;

    rptinfo->m_LastDataTime = 0;
    rptinfo->m_LastGITime = 0;

    rptinfo->m_LastRegisterFailedTime = 0;
    rptinfo->m_LastUnRegisterFailedTime = 0;

    memset(rptinfo->m_EntryID, 0, sizeof(rptinfo->m_EntryID));
    rptinfo->m_curRptSuffix = 0;

    rptinfo->count = 0;
    rptinfo->rptNo = 0;
    rptinfo->flickerflag = 0;

    rptinfo->pstflag = 0;

    // <20><>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>Ա<EFBFBD><D4B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͷ<EFBFBD><CDB7>ڴ<EFBFBD>
    if (rptinfo->rptID != nullptr) {
        memset(rptinfo->rptID, 0, strlen(rptinfo->rptID)); // <20><><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    }

    // <20><><EFBFBD><EFBFBD> LD_info <20><>ָ<EFBFBD>룬<EFBFBD><EBA3AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD>򸸼<EFBFBD>
    //rptinfo->LD_info = nullptr;

    // <20><> RCBC_INFO <20>ṹ<EFBFBD><E1B9B9>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD>
    if (rptinfo->m_rcb_info != nullptr) {
        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ѡ<EFBFBD><D1A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ṹ<EFBFBD><E1B9B9><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD><EFBFBD>ݣ<EFBFBD><DDA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͷ<EFBFBD><CDB7>ڴ<EFBFBD>
        rptinfo->m_rcb_info = nullptr;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>գ<EFBFBD><D5A3><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͨ<EFBFBD><CDA8><EFBFBD>ر<EFBFBD>ʱ<EFBFBD>ᱻ<EFBFBD><E1B1BB><EFBFBD><EFBFBD>
    }
}

void clearLDInfo(LD_info_t *ld_info) {
    if (ld_info == nullptr) {
		std::cout << "ldinfo is null" << std::endl;
        return;
    }

	//<2F><><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD><EFBFBD><EFBFBD>iedָ<64><D6B8>

	//<2F><><EFBFBD>ձ<EFBFBD><D5B1><EFBFBD>
	if (ld_info->rptinfo != nullptr) {
        for (int i = 0; i < ld_info->rptcount; ++i) {
            if (ld_info->rptinfo[i] != nullptr) {
                clearRptInfo(ld_info->rptinfo[i]); //<2F><><EFBFBD>ձ<EFBFBD><D5B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƿ<EFBFBD>
            }
        }
    }
	std::cout << "clean RptInfo!!!" << std::endl;

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>־
    if (ld_info->loginfo != nullptr) {
        for (int i = 0; i < ld_info->logcount; ++i) {
            if (ld_info->loginfo[i] != nullptr) {
                clearLogInfo(ld_info->loginfo[i]); //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>־<EFBFBD><D6BE><EFBFBD>ƿ<EFBFBD>
            }
        }
    }
	std::cout << "clean loginfo_t!!!" << std::endl;

	//<2F><><EFBFBD>ղ<EFBFBD><D5B2><EFBFBD>
    if (ld_info->autorecall != nullptr) {
        for (int i = 0; i < ld_info->autorecallcount; ++i) {
            if (ld_info->autorecall[i] != nullptr) {
                memset(ld_info->autorecall[i], 0, sizeof(autorecall_t));
				delete ld_info->autorecall[i];	//ɾ<><C9BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD>ؿռ䣬<D5BC><E4A3AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڲ<EFBFBD><DAB2>е<EFBFBD><D0B5><EFBFBD><EFBFBD>ݣ<EFBFBD><DDA3><EFBFBD><EFBFBD>Ѿ<EFBFBD><D1BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ռ䣬<D5BC><E4A3AC>Ҫ<EFBFBD>ͷ<EFBFBD>
            }
        }
		delete ld_info->autorecall;	//ɾ<><C9BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ռ<EFBFBD>
    }
	std::cout << "clean autorecall_t!!!" << std::endl;

    if (ld_info->ht_fcd != nullptr) {
        apr_hash_clear(ld_info->ht_fcd);
    }
    if (ld_info->ht_full_fcda != nullptr) {
        apr_hash_clear(ld_info->ht_full_fcda);
    }

    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>Ա
	if (ld_info->name != nullptr) {
        memset(ld_info->name, 0, sizeof(char) * 256);
    }
    if (ld_info->LD_name != nullptr) {
        memset(ld_info->LD_name, 0, sizeof(char) * 256);
    }
    if (ld_info->mp_id != nullptr) {
        memset(ld_info->mp_id, 0, sizeof(char) * 256);
    }
    if (ld_info->voltage_level != nullptr) {
        memset(ld_info->voltage_level, 0, sizeof(char) * 256);
    }
    if (ld_info->v_wiring_type != nullptr) {
        memset(ld_info->v_wiring_type, 0, sizeof(char) * 256);
    }
    if (ld_info->monitor_status != nullptr) {
        memset(ld_info->monitor_status, 0, sizeof(char) * 64);
    }
    if (ld_info->terminal_code != nullptr) {
        memset(ld_info->terminal_code, 0, sizeof(char) * 256);
    }

	ld_info->cpuno = 0;	//<2F><><EFBFBD><EFBFBD><EFBFBD>߼<EFBFBD><DFBC><EFBFBD><EFBFBD>к<EFBFBD>

	ld_info->time = 0; //̨<>˸<EFBFBD><CBB8><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>0
	ld_info->update_flag = 0; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>±<EFBFBD>־<EFBFBD><D6BE><EFBFBD>ݲ<EFBFBD>ʹ<EFBFBD><CAB9>

	ld_info->rptRecvFlag = 0;//<2F><><EFBFBD>ñ<EFBFBD><C3B1><EFBFBD><EFBFBD><EFBFBD>־
	ld_info->rptRecvCheckFlag = 0;
	ld_info->rptPstRecvFlag = 0;
	ld_info->rptPstRecvCheckFlag = 0;

	ld_info->read_flag = 0;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ч

    ld_info->rptcount = 0;
    ld_info->logcount = 0;
    ld_info->autorecallflag = 0;
    ld_info->autorecallcount = 0;

	//ld_info->group = 0; //<2F><>ʹ<EFBFBD><CAB9>

	//<2F><><EFBFBD><EFBFBD>ʵʱ<CAB5><CAB1><EFBFBD>ݲ<EFBFBD><DDB2><EFBFBD>
    ld_info->line_id = 0;
    ld_info->real_data = 0;
    ld_info->soe_data = 0;
    ld_info->limit = 0;
    ld_info->count = 0;

    //ld_info->SubV_Index = 0;	//<2F><>ʹ<EFBFBD><CAB9>
    //ld_info->Dev_Index = 0;	//<2F><>ʹ<EFBFBD><CAB9>
    //ld_info->Sub_Index = 0;	//<2F><>ʹ<EFBFBD><CAB9>
    //ld_info->GD_Index = 0;	//<2F><>ʹ<EFBFBD><CAB9>

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̬<EFBFBD>ṹ
	for (int i = 0; i < QVVR_NUM; ++i) {
        ld_info->qvvr[i].used_status = 0;
        ld_info->qvvr[i].QVVR_start = 0;
        ld_info->qvvr[i].QVVR_type = 0;
        ld_info->qvvr[i].QVVR_time = 0;
        ld_info->qvvr[i].QVVR_PerTime = 0.0f;
        ld_info->qvvr[i].QVVR_Amg = 0.0f;
        memset(ld_info->qvvr[i].QVVR_Rptname, 0, sizeof(ld_info->qvvr[i].QVVR_Rptname));  // <20><><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD>
        ld_info->qvvr[i].timestamp = 0;
    }
	ld_info->qvvr_idx = 0;

	memset(ld_info->FltNum, 0, sizeof(ld_info->FltNum));

    ld_info->RDRE_FltNum = 0;	//¼<><C2BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    

}

void clearIedUsr(ied_usr_t *ied_usr) {
    if (ied_usr == nullptr) {
		std::cout << "ied_usr is null" << std::endl;
        return;
    }

    // <20><><EFBFBD><EFBFBD> ied_usr_t <20>еķ<D0B5>ָ<EFBFBD>벿<EFBFBD><EBB2BF>
    //ied_usr->dev_idx = 0;//<2F><><EFBFBD><EFBFBD>index
    ied_usr->dev_flag = UNUSED;
    ied_usr->last_call_wavelist_time = 0;
    ied_usr->time = 0;			//̨<>˸<EFBFBD><CBB8><EFBFBD>ʱ<EFBFBD><CAB1>
    ied_usr->update_flag = 0;	//̨<>˸<EFBFBD><CBB8>±<EFBFBD>־<EFBFBD>ݲ<EFBFBD>ʹ<EFBFBD><CAB9>

    // <20><><EFBFBD><EFBFBD>ָ<EFBFBD>벿<EFBFBD>֣<EFBFBD><D6A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ǿ<EFBFBD>ָ<EFBFBD><D6B8>
    if (ied_usr->LD_info != nullptr) {

        // <20><><EFBFBD><EFBFBD> LD_info <20><>Ϊ<EFBFBD>գ<EFBFBD><D5A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
        for (int i = 0; i < MAX_CPUNO; ++i) {
			LD_info_t * ld =NULL;
			ld = (LD_info_t *)&ied_usr->LD_info[i];
            if (ld != NULL) {
                clearLDInfo(ld);
            }
        }
    }

    if (ied_usr->cookie != nullptr) {	//<2F><>ʹ<EFBFBD><CAB9>
		std::cout << "cookie not null" << std::endl;
    }

    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD>벿<EFBFBD>֣<EFBFBD>Ҳ<EFBFBD><D2B2><EFBFBD>Բ<EFBFBD><D4B2><EFBFBD>0<EFBFBD><30><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ḳ<EFBFBD><E1B8B2>
    memset(ied_usr->dev_type, 0, sizeof(ied_usr->dev_type));
    memset(ied_usr->dev_key, 0, sizeof(ied_usr->dev_key));
    memset(ied_usr->dev_series, 0, sizeof(ied_usr->dev_series));
    memset(ied_usr->terminal_id, 0, sizeof(ied_usr->terminal_id));
    memset(ied_usr->org_name, 0, sizeof(ied_usr->org_name));
    memset(ied_usr->maint_name, 0, sizeof(ied_usr->maint_name));
    memset(ied_usr->station_name, 0, sizeof(ied_usr->station_name));
    memset(ied_usr->tmnl_factory, 0, sizeof(ied_usr->tmnl_factory));
    memset(ied_usr->tmnl_status, 0, sizeof(ied_usr->tmnl_status));
    memset(ied_usr->terminal_code, 0, sizeof(ied_usr->terminal_code));
}

// <20><><EFBFBD><EFBFBD> channel <20><> cpuinfo <20>ķ<EFBFBD>ָ<EFBFBD>벿<EFBFBD><EBB2BF>
void clear_channel_and_cpuinfo(byte_t chncount, channel_t *channel, byte_t cpucount, cpuinfo_t *cpuinfo) {
    // <20><><EFBFBD><EFBFBD> channel <20><><EFBFBD><EFBFBD><EFBFBD>е<EFBFBD>ÿ<EFBFBD><C3BF>Ԫ<EFBFBD>صķ<D8B5>ָ<EFBFBD><D6B8><EFBFBD>ֶ<EFBFBD>
    for (byte_t i = 0; i < chncount && (&channel[i] != NULL); ++i) {
        channel[i].master = 0;
        channel[i].channel_type = 0;
        memset(channel[i].addr_str, 0, LONGNAME);
        channel[i].addr = 0;
        channel[i].port = 0;
        channel[i].status = 0;
        channel[i].last_ticks = 0;
        channel[i].last_send_ticks = 0;
        channel[i].ied_id = 0;

		// <20><><EFBFBD><EFBFBD> channel <20><><EFBFBD><EFBFBD> chnl_usr_t <20><><EFBFBD><EFBFBD>
		// <20>ر<EFBFBD><D8B1><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD>뱾<EFBFBD><EBB1BE>
    }

    // <20><><EFBFBD><EFBFBD> cpuinfo <20><><EFBFBD><EFBFBD><EFBFBD>е<EFBFBD>ÿ<EFBFBD><C3BF>Ԫ<EFBFBD>صķ<D8B5>ָ<EFBFBD><D6B8><EFBFBD>ֶ<EFBFBD>
    for (byte_t i = 0; i < cpucount  && (&cpuinfo[i] != NULL); ++i) {
        cpuinfo[i].addr = 0;
        cpuinfo[i].status = 0;
        cpuinfo[i].templ = 0;
        memset(cpuinfo[i].name, 0, LONGNAME);
        cpuinfo[i].last_gi = 0;
        cpuinfo[i].last_gi_send = 0;
        cpuinfo[i].next_gi_send = 0;
        cpuinfo[i].last_ticks = 0;
        cpuinfo[i].last_send_ticks = 0;
    }
}

void clearIed(ied_t *ied) {
    if (ied == nullptr) {
        return;
    }

    // <20><><EFBFBD><EFBFBD> ied_t <20><>id
    ied->id = 0;		
    //ied->flags = 0;	//δʹ<CEB4><CAB9>
    //ied->type = 0;	//δʹ<CEB4><CAB9>

	//<2F><><EFBFBD><EFBFBD>channel	//<2F><><EFBFBD><EFBFBD>cpuinfo
	clear_channel_and_cpuinfo(ied->chncount,ied->channel,ied->cpucount,ied->cpuinfo);
    ied->chncount = 0;	//<2F><><EFBFBD><EFBFBD>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD>
    ied->cpucount = 0;	//<2F><><EFBFBD>ռ<EFBFBD><D5BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	memset(ied->name, 0, LONGNAME);

    //ied->station = 0;		//δʹ<CEB4><CAB9>
    //ied->node = 0;		//δʹ<CEB4><CAB9>
    //ied->frequency = 0;	//δʹ<CEB4><CAB9>
    //ied->delay = 0;		//δʹ<CEB4><CAB9>
    //ied->count = 0;		//δʹ<CEB4><CAB9>
	
	//<2F><><EFBFBD><EFBFBD><EFBFBD>鶨<EFBFBD>岿<EFBFBD><E5B2BF>δʹ<CEB4><CAB9>
	//ied->groups = NULL;
	//ied->htgroups = NULL;

	//ϵͳ<CFB5><CDB3><EFBFBD><EFBFBD>δʹ<CEB4><CAB9>
    //ied->systoken_st = 0;

    //ied->index = 0;			//δʹ<CEB4><CAB9>
    ied->status = STATUS_NOINIT;		//<2F>豸״̬<D7B4><CCAC>Ϊδ<CEAA><CEB4>ʼ<EFBFBD><CABC>
    //ied->last_ticks = 0;	//δʹ<CEB4><CAB9>
    //ied->last_gi = 0;		//δʹ<CEB4><CAB9>

    // <20><><EFBFBD><EFBFBD>ָ<EFBFBD>벿<EFBFBD><EBB2BF>
    if (ied->usr_ext != nullptr) {
        ied_usr_t *ied_usr = (ied_usr_t*)ied->usr_ext;
        clearIedUsr(ied_usr);
    }

	if (ied->sys_ext != nullptr) {
		//<2F><>ʹ<EFBFBD><CAB9>
    }

	if (ied->app_ext != nullptr) {
		//<2F><>ʹ<EFBFBD><CAB9>
    }

}
/*<2A><>װC<D7B0>ɵ<EFBFBD><C9B5>õ<EFBFBD>̨<EFBFBD>˸<EFBFBD><CBB8>º<EFBFBD><C2BA><EFBFBD> */////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//<2F><><EFBFBD>Ժ<EFBFBD><D4BA><EFBFBD>
std::string my_to_string(long long value) {
    std::stringstream ss;
    ss << value;
    return ss.str();
}

//lnk20250328<32><38><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƥ<EFBFBD>䵽<EFBFBD><E4B5BD><EFBFBD>ն<EFBFBD>
bool shouldSkipTerminal(const char* terminal_id) {
    for (size_t i = 0; i < TESTARRAY.size(); ++i) {
        if (TESTARRAY[i] == terminal_id) {
            return true;
        }
    }
    return false;
}

void rocketmq_test_300(int mpnum,int front_index) {
    Ckafka_data_t data;
    data.strTopic = QString::fromStdString(G_ROCKETMQ_TOPIC);
    data.mp_id = "0";

    // <20><>ȡ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
    std::ifstream file("long_string.txt");  // <20>ļ<EFBFBD><C4BC>д洢<D0B4><E6B4A2><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>
    std::stringstream buffer;
    buffer << file.rdbuf();
    std::string file_contents = buffer.str();  // <20><>ȡ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
    std::string base_strText = file_contents;

    // <20><>ȡ<EFBFBD><C8A1>ǰʱ<C7B0><CAB1><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA>ʼʱ<CABC><CAB1>
    std::time_t t = std::time(NULL);//<2F><>ȡ<EFBFBD><C8A1>ǰ<EFBFBD><C7B0>ϵͳʱ<CDB3>䣨<EFBFBD><E4A3A8> 1970 <20><> 1 <20><> 1 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD>Ϊ UNIX ʱ<><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    std::tm* time_info = std::localtime(&t);//<2F><> std::time_t<5F><74><EFBFBD><EFBFBD>ʾ<EFBFBD><CABE>ǰ<EFBFBD><C7B0> UNIX ʱ<><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>ʱ<EFBFBD>䣨std::tm <20>ṹ<EFBFBD><E1B9B9>
    time_info->tm_sec = 0;  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ
    //time_info->tm_msec = 0; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD>ȷ<EFBFBD><C8B7>ʹ<EFBFBD>ø߾<C3B8><DFBE><EFBFBD>ʱ<EFBFBD>䣩

    // <20><>ȡ<EFBFBD><C8A1>ǰ<EFBFBD><C7B0>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>룩
    std::time_t base_time_t = std::mktime(time_info);//<2F><> std::tm <20>ṹ<EFBFBD><E1B9B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD>䣩ת<E4A3A9><D7AA><EFBFBD><EFBFBD> std::time_t<5F><74>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

    // <20><><EFBFBD><EFBFBD>ÿ<EFBFBD><C3BF><EFBFBD><EFBFBD>Ϣ<EFBFBD><CFA2>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȷ<EFBFBD><C8B7><EFBFBD><EFBFBD><EFBFBD>ӣ<EFBFBD><D3A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    long long current_time_ms = static_cast<long long>(base_time_t) * 1000;  // ÿ<><C3BF><EFBFBD>ӵ<EFBFBD><D3B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD>

    // <20>趨<EFBFBD>ܵ<EFBFBD><DCB5><EFBFBD>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD>
    int total_messages = mpnum;

    ied_t* ied;
    ied_usr_t* ied_usr;

    // ѭ<><D1AD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 300 <20><><EFBFBD><EFBFBD>Ϣ
    for (int i = 0; (total_messages != 0 && g_front_seg_index == 1 && g_node_id == 100) && i < g_node->n_clients; ++i) {

        ied = (ied_t*)g_node->clients[i];
		if(ied != NULL){
			ied_usr = (ied_usr_t*)ied->usr_ext;

			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ն<EFBFBD>
			if (shouldSkipTerminal(ied_usr->terminal_id)) {
				std::cout << ied_usr->terminal_id << " use true message " << std::endl;
				continue;
			}

            for (int j = 0; j < 10 && ied_usr->LD_info[j].mp_id[0] != '\0'; j++){
                // <20>޸<EFBFBD> Monitor ֵ
                char monitor_id[256] = {};
                strncpy(monitor_id, ied_usr->LD_info[j].mp_id, sizeof(monitor_id) - 1);
                monitor_id[sizeof(monitor_id) - 1] = '\0';

                data.mp_id = QString(monitor_id);

                data.monitor_id = i + j;
                
                std::string modified_time = my_to_string(current_time_ms);  // ʱ<><CAB1>ת<EFBFBD><D7AA>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͣ<EFBFBD>Unixʱ<78><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

                // <20>滻<EFBFBD><E6BBBB>Ϣ<EFBFBD>е<EFBFBD> Monitor <20><> TIME <20>ֶΣ<D6B6>ֻƥ<D6BB><C6A5><EFBFBD>ֶ<EFBFBD><D6B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƥ<EFBFBD><C6A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5>
                std::string modified_strText = base_strText;

                // <20>滻 Monitor <20>ֶ<EFBFBD>
                size_t monitor_pos = modified_strText.find("\"Monitor\"");
                if (monitor_pos != std::string::npos) {
                    size_t colon_pos = modified_strText.find(":", monitor_pos);
                    size_t quote_pos = modified_strText.find("\"", colon_pos);
                    size_t end_quote_pos = modified_strText.find("\"", quote_pos + 1);
                    if (colon_pos != std::string::npos && quote_pos != std::string::npos && end_quote_pos != std::string::npos) {
                        modified_strText.replace(quote_pos + 1, end_quote_pos - quote_pos - 1, data.mp_id.toStdString());
                    }
                }

                // <20>滻 TIME <20>ֶ<EFBFBD>
                size_t time_pos = modified_strText.find("\"TIME\"");
                if (time_pos != std::string::npos) {
                    size_t colon_pos = modified_strText.find(":", time_pos);
                    size_t quote_pos = colon_pos;
                    size_t end_quote_pos = modified_strText.find(",", quote_pos + 1);
                    if (colon_pos != std::string::npos && quote_pos != std::string::npos && end_quote_pos != std::string::npos) {
                        modified_strText.replace(quote_pos + 1, end_quote_pos - quote_pos - 1, modified_time);
                    }
                }

                // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
                data.strText = QString::fromStdString(modified_strText);

                // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
                my_rocketmq_send(data);

                // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
                std::cout << "Sent message " << (i + 1) << " with Monitor " << data.monitor_id << " and TIME " << modified_time << std::endl;

                // <20>ȴ<EFBFBD><C8B4><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD>Ϣ<EFBFBD>ķ<EFBFBD><C4B7>ͣ<EFBFBD><CDA3>̶<EFBFBD>Ϊ1<CEAA><31><EFBFBD>ӣ<EFBFBD>
                //QThread::sleep(60);  // ÿ<>η<EFBFBD><CEB7>ͼ<EFBFBD><CDBC><EFBFBD>1<EFBFBD><31><EFBFBD><EFBFBD>
            }
        }
    }

    std::cout << "Finished sending " << total_messages << " messages." << std::endl;
}

///////////////////////////////////////////////////////////////////////////////lnkʵʱ<CAB5><CAB1>־<EFBFBD><D6BE><EFBFBD><EFBFBD>20250205
// ------------------ ȫ<><C8AB><EFBFBD><EFBFBD>־<EFBFBD>б<EFBFBD><D0B1><EFBFBD><EFBFBD><EFBFBD> ------------------
std::list<std::string> errorList;
std::list<std::string> warnList;
std::list<std::string> normalList;
std::list<std::string> debugList;   // <20><><EFBFBD><EFBFBD> debugList

pthread_mutex_t errorListMutex  = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t warnListMutex   = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t normalListMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t debugListMutex  = PTHREAD_MUTEX_INITIALIZER; // <20><><EFBFBD><EFBFBD> debugList <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

// ------------------ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ------------------
bool errorOutputEnabled  = false;  // <20>Ƿ<EFBFBD><C7B7><EFBFBD> error <20><><EFBFBD><EFBFBD>д<EFBFBD><D0B4> errorList
bool warnOutputEnabled   = false;  // <20>Ƿ<EFBFBD><C7B7><EFBFBD> warn <20><><EFBFBD><EFBFBD>д<EFBFBD><D0B4> warnList
bool normalOutputEnabled = false;  // <20>Ƿ<EFBFBD><C7B7><EFBFBD> normal <20><><EFBFBD><EFBFBD>д<EFBFBD><D0B4> normalList
bool debugOutputEnabled  = false;   // <20><><EFBFBD><EFBFBD> debug <20><><EFBFBD><EFBFBD>

// ------------------ <20><><EFBFBD>ڻָ<DABB>ԭʼ<D4AD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ------------------
static std::streambuf* g_originalCoutBuf = NULL;
static std::streambuf* g_originalClogBuf = NULL;
static std::streambuf* g_originalCerrBuf = NULL;



// ------------------ <20><>־<EFBFBD><D6BE><EFBFBD><EFBFBD>ö<EFBFBD>٣<EFBFBD>C++98<39><38> ------------------
enum LogLevel {
    LOGERROR,
    LOGWARN,
    LOGNORMAL,
	LOGDEBUG       // <20><><EFBFBD><EFBFBD> debug <20><><EFBFBD><EFBFBD>
};

// ------------------------------------------------------------------
//  TeeStreamBuf: <20><>д<EFBFBD><D0B4>ԭʼbuf(<28><><EFBFBD><EFBFBD><EFBFBD>ն<EFBFBD><D5B6><EFBFBD><EFBFBD><EFBFBD>)<29><><EFBFBD>ٿ<EFBFBD><D9BF><EFBFBD><EFBFBD><EFBFBD>list<73><74>
// ------------------------------------------------------------------
class TeeStreamBuf : public std::streambuf
{
public:
    // Ĭ<>Ϲ<EFBFBD><CFB9>죺<EFBFBD>Ȱ<EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>ΪNULL
    TeeStreamBuf()
        : m_originalBuf(NULL), m_level(LOGNORMAL)
    {
        pthread_mutex_init(&m_mutex, NULL);
    }

    // <20><><EFBFBD>ι<EFBFBD><CEB9>죺ֱ<ECA3BA>ӳ<EFBFBD>ʼ<EFBFBD><CABC>
    TeeStreamBuf(std::streambuf* originalBuf, LogLevel level)
        : m_originalBuf(originalBuf), m_level(level)
    {
        pthread_mutex_init(&m_mutex, NULL);
    }

    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ٻ<EFBFBD><D9BB><EFBFBD><EFBFBD><EFBFBD>
    virtual ~TeeStreamBuf()
    {
        pthread_mutex_destroy(&m_mutex);
    }

    // <20>Զ<EFBFBD><D4B6><EFBFBD> init(...) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͬһ<CDAC><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    void init(std::streambuf* originalBuf, LogLevel level)
    {
        m_originalBuf = originalBuf;
        m_level       = level;
        pthread_mutex_lock(&m_mutex);
        m_buffer.clear();
        pthread_mutex_unlock(&m_mutex);
    }

protected:
    // <20><> flush <20><> std::endl ʱ<><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD> sync()
    virtual int sync()
    {
        // <20><><EFBFBD><EFBFBD>ԭʼ<D4AD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD><D6B4>ͬ<EFBFBD><CDAC>
        if (m_originalBuf) {
            m_originalBuf->pubsync();
        }
        // <20>ٽ<EFBFBD><D9BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ļ<EFBFBD><C4BB><EFBFBD> flush
        flushBuffer();
        return 0; // <20>ɹ<EFBFBD>
    }

    // <20><>д<EFBFBD><D0B4>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD>ʱ<EFBFBD><CAB1>overflow() <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    virtual int_type overflow(int_type ch)
    {
        if (ch == traits_type::eof()) {
            return ch;
        }
        // 1) д<><D0B4>ԭʼ<D4AD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ն<EFBFBD><D5B6><EFBFBD><EFBFBD><EFBFBD>
        if (m_originalBuf) {
            if (m_originalBuf->sputc(static_cast<char>(ch)) == traits_type::eof()) {
                return traits_type::eof();
            }
        }
        // 2) <20>浽<EFBFBD><E6B5BD><EFBFBD>ǵ<EFBFBD><C7B5><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD>棬ע<E6A3AC><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
        pthread_mutex_lock(&m_mutex);	//<2F><>ֹ<EFBFBD><D6B9><EFBFBD>߳<EFBFBD><DFB3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>lnk20250305
        m_buffer.push_back(static_cast<char>(ch));
        // 3) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>о<EFBFBD> flushBuffer()
        if (ch == '\n') {
            flushBuffer_locked();
        }
        pthread_mutex_unlock(&m_mutex);
        return ch;
    }

private:
    // <20>ڲ<EFBFBD><DAB2>汾<EFBFBD><E6B1BE><EFBFBD>ٶ<EFBFBD><D9B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ѿ<EFBFBD><D1BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    void flushBuffer_locked()
    {
        if (m_buffer.empty()) {
            return;
        }
        // <20><><EFBFBD>ݵȼ<DDB5><C8BC>Ͷ<EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD>أ<EFBFBD><D8A3><EFBFBD> m_buffer д<><D0B4><EFBFBD><EFBFBD>Ӧ<EFBFBD><D3A6> list
        switch (m_level) {
            case LOGERROR:
                if (debugOutputEnabled) {
                    pthread_mutex_lock(&debugListMutex);
                    debugList.push_back(m_buffer);
                    pthread_mutex_unlock(&debugListMutex);
                }
                else if (normalOutputEnabled) {
                    pthread_mutex_lock(&normalListMutex);
                    normalList.push_back(m_buffer);
                    pthread_mutex_unlock(&normalListMutex);
                }
                else if (warnOutputEnabled) {
                    pthread_mutex_lock(&warnListMutex);
                    warnList.push_back(m_buffer);
                    pthread_mutex_unlock(&warnListMutex);
                }
                else if (errorOutputEnabled) {
                    pthread_mutex_lock(&errorListMutex);
                    errorList.push_back(m_buffer);
                    pthread_mutex_unlock(&errorListMutex);
                }
                break;

            case LOGWARN:
                if (debugOutputEnabled) {
                    pthread_mutex_lock(&debugListMutex);
                    debugList.push_back(m_buffer);
                    pthread_mutex_unlock(&debugListMutex);
                }
                else if (normalOutputEnabled) {
                    pthread_mutex_lock(&normalListMutex);
                    normalList.push_back(m_buffer);
                    pthread_mutex_unlock(&normalListMutex);
                }
                else if (warnOutputEnabled) {
                    pthread_mutex_lock(&warnListMutex);
                    warnList.push_back(m_buffer);
                    pthread_mutex_unlock(&warnListMutex);
                }
                break;

            case LOGNORMAL:
                if (debugOutputEnabled) {
                    pthread_mutex_lock(&debugListMutex);
                    debugList.push_back(m_buffer);
                    pthread_mutex_unlock(&debugListMutex);
                }
                else if (normalOutputEnabled) {
                    pthread_mutex_lock(&normalListMutex);
                    normalList.push_back(m_buffer);
                    pthread_mutex_unlock(&normalListMutex);
                }
                break;
        }
        m_buffer.clear();
    }

    // <20><><EFBFBD><EFBFBD><EFBFBD>ӿڣ<D3BF><DAA3>ڲ<EFBFBD><DAB2><EFBFBD> m_buffer <20><><EFBFBD><EFBFBD>
    void flushBuffer()
    {
        pthread_mutex_lock(&m_mutex);
        flushBuffer_locked();
        pthread_mutex_unlock(&m_mutex);
    }

private:
    // <20><>ֹ<EFBFBD>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD>ɵĸ<C9B5>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>
    TeeStreamBuf& operator=(const TeeStreamBuf&);

private:
    std::streambuf* m_originalBuf;
    LogLevel        m_level;
    std::string     m_buffer;
    pthread_mutex_t m_mutex;
};

// ------------------ ȫ<><C8AB>Tee<65><65><EFBFBD>󣨱<EFBFBD><F3A3A8B1><EFBFBD><EFBFBD>ظ<EFBFBD><D8B8><EFBFBD>ֵ<EFBFBD><D6B5> ------------------
static TeeStreamBuf g_errorTeeBuf;
static TeeStreamBuf g_warnTeeBuf;
static TeeStreamBuf g_normalTeeBuf;

// ------------------ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ṩһ<E1B9A9><D2BB>ȫ<EFBFBD>ֵ<EFBFBD> debug <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ------------------
// <20><>ԭʼbufĬ<66><C4AC>Ϊ NULL<4C><4C><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>նˣ<D5B6><CBA3><EFBFBD>ֻ<EFBFBD>浽 debugList(<28><><EFBFBD><EFBFBD><EFBFBD>ؿ<EFBFBD>)
//static std::ostream g_debug(&g_debugTeeBuf);

// <20><> qDebug() ӳ<>䵽<EFBFBD><E4B5BD><EFBFBD><EFBFBD>ȫ<EFBFBD><C8AB><EFBFBD><EFBFBD>
//#define qDebug() g_debug

// ------------------ <20>ض<EFBFBD><D8B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ------------------
// ֻ<>ڵ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD> init(...) <20><>ʼ<EFBFBD><CABC> TeeStreamBuf<75><66>
// ֮<><D6AE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD> new <20><> <20><>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֱ<EFBFBD><D6B1><EFBFBD><EFBFBD>֮ǰ<D6AE><C7B0><EFBFBD><EFBFBD><EFBFBD>õĶ<C3B5><C4B6><EFBFBD><EFBFBD><EFBFBD>
void redirectErrorOutput(bool enabled)
{
    errorOutputEnabled = enabled;
    if (enabled) {
        if (g_originalCerrBuf == NULL) {
            g_originalCerrBuf = std::cerr.rdbuf();
            g_errorTeeBuf.init(g_originalCerrBuf, LOGERROR);
        }
        std::cerr.rdbuf(&g_errorTeeBuf);
    } else {
        if (g_originalCerrBuf) {
            std::cerr.rdbuf(g_originalCerrBuf);
        }
    }
}

void redirectWarnOutput(bool enabled)
{
    warnOutputEnabled = enabled;
    if (enabled) {
        if (g_originalClogBuf == NULL) {
            g_originalClogBuf = std::clog.rdbuf();
            g_warnTeeBuf.init(g_originalClogBuf, LOGWARN);
        }
        std::clog.rdbuf(&g_warnTeeBuf);
    } else {
        if (g_originalClogBuf) {
            std::clog.rdbuf(g_originalClogBuf);
        }
    }
}

void redirectNormalOutput(bool enabled)
{
    normalOutputEnabled = enabled;
    if (enabled) {
        if (g_originalCoutBuf == NULL) {
            g_originalCoutBuf = std::cout.rdbuf();
            g_normalTeeBuf.init(g_originalCoutBuf, LOGNORMAL);
        }
        std::cout.rdbuf(&g_normalTeeBuf);
    } else {
        if (g_originalCoutBuf) {
            std::cout.rdbuf(g_originalCoutBuf);
        }
    }
}

// ------------------ <20>ض<EFBFBD><D8B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ------------------
void redirectDebugOutput(bool enable)
{
    debugOutputEnabled = enable;
    // <20><>ȥ<EFBFBD><C8A5> clog.rdbuf()
    // <20><>ȥ install <20>κ<EFBFBD> msg handler
}

// ------------------ Qt4 <20><>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ------------------
void myQtMsgHandler(QtMsgType type, const char *msg)
{
    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Σ<EFBFBD><CEA3><EFBFBD>д<EFBFBD><D0B4> debugList
    if (debugOutputEnabled) {
        pthread_mutex_lock(&debugListMutex);
        debugList.push_back(msg);
        pthread_mutex_unlock(&debugListMutex);
    }

    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD>ѡ<EFBFBD><D1A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    FILE* output = nullptr;
    const char* typeStr = "";
    switch (type) {
    case QtDebugMsg:
        typeStr = "Debug";
        output = stdout;   // Debug <20>߱<EFBFBD>׼<EFBFBD><D7BC><EFBFBD><EFBFBD>
        break;
    case QtWarningMsg:
        typeStr = "Warning";
        output = stderr;   // Warning <20>߱<EFBFBD>׼<EFBFBD><D7BC><EFBFBD><EFBFBD>
        break;
    case QtCriticalMsg:
        typeStr = "Critical";
        output = stderr;   // Critical <20>߱<EFBFBD>׼<EFBFBD><D7BC><EFBFBD><EFBFBD>
        break;
    case QtFatalMsg:
        typeStr = "Fatal";
        output = stderr;   // Fatal <20>߱<EFBFBD>׼<EFBFBD><D7BC><EFBFBD><EFBFBD>
        break;
    }

    fprintf(output, "[%s] %s\n", typeStr, msg);
    fflush(output);

    // Fatal ʱ<><CAB1><EFBFBD><EFBFBD><EFBFBD>˳<EFBFBD>
    if (type == QtFatalMsg) {
        abort();
    }
}

// ------------------ <20>Զ<EFBFBD><D4B6><EFBFBD> printf <20><><EFBFBD><EFBFBD> ------------------
// <20><><EFBFBD><EFBFBD>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> normal <20><><EFBFBD><EFBFBD> => <20><><EFBFBD>ջ<EFBFBD><D5BB><EFBFBD><EFBFBD><EFBFBD>normalList(<28><><EFBFBD><EFBFBD><EFBFBD>ؿ<EFBFBD>)
// <20><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>ȫ<EFBFBD>־<EFBFBD>̬<EFBFBD>Ļ<EFBFBD><C4BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ printfmtx
static pthread_mutex_t printfmtx = PTHREAD_MUTEX_INITIALIZER;

// RAII<49><49><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>װ<EFBFBD><D7B0>
class LockGuard {
public:
    explicit LockGuard(pthread_mutex_t& mutex) : mtx(mutex) {
        pthread_mutex_lock(&mtx);
    }
    ~LockGuard() {
        pthread_mutex_unlock(&mtx);
    }
private:
    pthread_mutex_t& mtx;
};

int customPrintf(const char* format, ...)
{
    // <20>ڽ<EFBFBD><DABD>뺯<EFBFBD><EBBAAF>ʱ<EFBFBD>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˳<EFBFBD>ʱ<EFBFBD>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD>
    LockGuard lock(printfmtx);

    va_list args;
    va_start(args, format);

    char buffer[1024];
    int written = vsnprintf(buffer, sizeof(buffer), format, args);

    va_end(args);

    if (written < 0) {
        return -1;
    }

    // <20><><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> std::cout
    std::cout << buffer << std::endl;

    return written;
}

///////////////////////////////////////////////////////////////////////////////
void echo_msg_errexy(const char *file_name, int line_no, int rv, const char *fmt, ...) {
    char __buf[1024];
    va_list __ap;
    va_start(__ap, fmt);
    vsnprintf(__buf, sizeof(__buf), fmt, __ap);
    va_end(__ap);

    // <20>ն<EFBFBD><D5B6><EFBFBD><EFBFBD><EFBFBD>
    printf("[ERROR] rv=%d %s:%d => %s", rv, file_name, line_no, __buf);
    fflush(stdout);

    // д<><D0B4> errorList
    if (errorOutputEnabled) {
        pthread_mutex_lock(&errorListMutex);
        errorList.push_back(std::string(__buf));
        pthread_mutex_unlock(&errorListMutex);
    }
}

void echo_msg_warnexy(const char *file_name, int line_no, const char *fmt, ...) {
    char __buf[1024];
    va_list __ap;
    va_start(__ap, fmt);
    vsnprintf(__buf, sizeof(__buf), fmt, __ap);
    va_end(__ap);

    // <20>ն<EFBFBD><D5B6><EFBFBD><EFBFBD><EFBFBD>
    printf("[WARN ] %s:%d => %s", file_name, line_no, __buf);
    fflush(stdout);

    // д<><D0B4> warnList
    if (warnOutputEnabled) {
        pthread_mutex_lock(&warnListMutex);
        warnList.push_back(std::string(__buf));
        pthread_mutex_unlock(&warnListMutex);
    }
}

void echo_msg_debugexy(const char *file_name, int line_no, const char *fmt, ...) {
    char __buf[1024];
    va_list __ap;
    va_start(__ap, fmt);
    vsnprintf(__buf, sizeof(__buf), fmt, __ap);
    va_end(__ap);

    // <20>ն<EFBFBD><D5B6><EFBFBD><EFBFBD><EFBFBD>
    printf("[DEBUG] %s:%d => %s", file_name, line_no, __buf);
    fflush(stdout);

    // д<><D0B4> normalList
    if (normalOutputEnabled) {
        pthread_mutex_lock(&normalListMutex);
        normalList.push_back(std::string(__buf));
        pthread_mutex_unlock(&normalListMutex);
    }
}
///////////////////////////////////////////////////////////////////////////////
void Worker::telnetetst(QTcpSocket* clientSocket) {
	int ip_count = 0;
	int telnet_count = 0;
	//<2F>ڲ<EFBFBD><DAB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>̨<EFBFBD>˼<EFBFBD><CBBC><EFBFBD>lnk20250114
	pthread_mutex_lock(&mtx);   std::cout << "testping hold lock !!!!!!!!!!!" << std::endl;
	Worker::init_ping_telnet(clientSocket,ip_count, telnet_count);
	Cout_account_information();
	pthread_mutex_unlock(&mtx); std::cout << "testping free lock !!!!!!!!!!!" << std::endl; 
}