zcy
/
firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
firmware/src/conf.c

1272 lines
41 KiB
C
Raw Normal View History

stvm 1.2.2
2018-03-12 07:01:29 +00:00
/*
* Copyright (c) 2018 Savens Liu
*
* The original has been patented, Open source is not equal to open rights.
* Anyone can clone, download, learn and discuss for free. Without the permission
* of the copyright owner or author, it shall not be merged, published, licensed or sold.
* The copyright owner or author has the right to pursue his responsibility.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include "tvm.h"
#include "tmain.h"
/*************************************************************************************************
global
*************************************************************************************************/
TBoot g_stBoot = {0};
/*************************************************************************************************
description：get the config of boot
parameters:
return:
void*
*************************************************************************************************/
void* pGetBoot()
{
return &g_stBoot;
}
/*************************************************************************************************
description：get log file
parameters:
return:
void*
*************************************************************************************************/
char* pGetLog()
{
return g_stBoot.m_szLog;
}
/*************************************************************************************************
description：Get the current node
parameters:
return:
void*
*************************************************************************************************/
char* sGetNode()
{
return g_stBoot.m_szNode;
}
/*************************************************************************************************
description：Set the current node
parameters:
return:
*************************************************************************************************/
void vSetNode(char *s)
{
if(!s) return ;
strncpy(g_stBoot.m_szNode, s, sizeof(g_stBoot.m_szNode));
}
/*************************************************************************************************
description：Set STVM boot type
parameters:
return:
*************************************************************************************************/
void vSetBootType(long lType)
{
g_stBoot.m_lBootType = lType;
}
/*************************************************************************************************
description：Get current type of boot
parameters:
return:
lBootType
*************************************************************************************************/
long lGetBootType()
{
return g_stBoot.m_lBootType;
}
/*************************************************************************************************
函数说明：获取配置日志名称
参数说明：
返回值：
void --日志名
*************************************************************************************************/
char* sGetLog()
{
return g_stBoot.m_szLog;
}
/*************************************************************************************************
description：create default config
parameters:
return:
RC_SUCC --success
RC_FAIL --failure
*************************************************************************************************/
long lDefaultBoot()
{
FILE *fp = NULL;
char szPath[512];
TBoot *pstBoot = (TBoot *)pGetBoot();
memset(szPath, 0, sizeof(szPath));
memset(pstBoot, 0, sizeof(TBoot));
snprintf(szPath, sizeof(szPath), "%s", getenv("TVMCFG"));
pstBoot->m_lMaxTable = 255;
pstBoot->m_lMaxField = 3000;
pstBoot->m_lMaxDomain = 1024;
pstBoot->m_lMaxSeque = 1024;
pstBoot->m_lBootExec = get_nprocs();
pstBoot->m_lBootPort = 2000;
pstBoot->m_lBootType = TVM_BOOT_SIMPLE;
strcpy(pstBoot->m_szNode, "STVM");
strcpy(pstBoot->m_szLog, "stvm.log");
if(NULL == (fp = fopen(szPath, "wb")))
{
fprintf(stderr, "create default param failed, %s\n", strerror(errno));
return RC_FAIL;
}
fwrite(TVM_RUNCFG_TAG, 4, 1, fp);
fwrite(pstBoot, sizeof(TBoot), 1, fp);
fclose(fp);
return RC_SUCC;
}
/*************************************************************************************************
description：from the config to boot system
parameters:
pstSavm --stvm handle
pstBoot --boot paramer
return:
RC_SUCC --success
RC_FAIL --failure
*************************************************************************************************/
long lGetBootConfig(SATvm *pstSavm, TBoot *pstBoot)
{
FILE *fp = NULL;
char szPath[512], szVersion[10];
if(!pstSavm || !pstBoot)
{
pstSavm->m_lErrno = CONDIT_IS_NIL;
return RC_FAIL;
}
memset(szPath, 0, sizeof(szPath));
memset(szVersion, 0, sizeof(szVersion));
snprintf(szPath, sizeof(szPath), "%s", getenv("TVMCFG"));
if(NULL == (fp = fopen(szPath, "rb")))
{
pstSavm->m_lErrno = FILE_NOTFOUND;
return RC_FAIL;
}
fread(szVersion, 4, 1, fp);
if(memcmp(szVersion, TVM_RUNCFG_TAG, 4))
{
fclose(fp);
pstSavm->m_lErrno = BOOT_VER_ICMP;
return RC_FAIL;
}
fread(pstBoot, sizeof(TBoot), 1, fp);
fclose(fp);
return RC_SUCC;
}
/*************************************************************************************************
description： Startup initialization
parameters:
return:
void *
*************************************************************************************************/
TBoot* pBootInitial()
{
static int i = 0;
SATvm *pstSavm = (SATvm *)pGetSATvm();
if(1 == i ++) return &g_stBoot;
memset(&g_stBoot, 0, sizeof(TBoot));
pstSavm->m_lErrno = TVM_DONE_SUCC;
lGetBootConfig(pstSavm, &g_stBoot);
return &g_stBoot;
}
/*************************************************************************************************
description：from the config to initial table index
parameters:
pstSavm --stvm handle
plOut --number
ppstIndex --out of index group
return:
RC_SUCC --success
RC_FAIL --failure
*************************************************************************************************/
long lGetLocalIndex(SATvm *pstSavm, long *plOut, TIndex **ppstIndex)
{
FILE *fp = NULL;
char szPath[512], szVersion[10];
if(!pstSavm || !ppstIndex || !plOut)
{
pstSavm->m_lErrno = CONDIT_IS_NIL;
return RC_FAIL;
}
memset(szPath, 0, sizeof(szPath));
memset(szVersion, 0, sizeof(szVersion));
snprintf(szPath, sizeof(szPath), "%s", getenv("TVMCFG"));
if(NULL == (fp = fopen(szPath, "rb")))
{
pstSavm->m_lErrno = FILE_NOTFOUND;
return RC_FAIL;
}
fread(szVersion, 4, 1, fp);
if(memcmp(szVersion, TVM_RUNCFG_TAG, 4))
{
fclose(fp);
pstSavm->m_lErrno = BOOT_VER_ICMP;
return RC_FAIL;
}
fseek(fp, sizeof(TBoot), SEEK_CUR);
fread((void *)plOut, sizeof(long), 1, fp);
if(*plOut <= 0)
{
fclose(fp);
return RC_SUCC;
}
if(NULL == (*ppstIndex = (void *)calloc(*plOut, sizeof(TIndex))))
{
fclose(fp);
pstSavm->m_lErrno = MALLC_MEM_ERR;
return RC_FAIL;
}
fread(*ppstIndex, (*plOut) * sizeof(TIndex), 1, fp);
fclose(fp);
return RC_SUCC;
}
/*************************************************************************************************
description：from the config to initial domain
parameters:
pstSavm --stvm handle
plOut --number
ppstIndex --out of index group
return:
RC_SUCC --success
RC_FAIL --failure
*************************************************************************************************/
long lGetDomainIndex(SATvm *pstSavm, long *plOut, TIndex **ppstIndex)
{
FILE *fp = NULL;
char szPath[512], szVersion[10];
if(!pstSavm || !ppstIndex || !plOut)
{
pstSavm->m_lErrno = CONDIT_IS_NIL;
return RC_FAIL;
}
memset(szPath, 0, sizeof(szPath));
memset(szVersion, 0, sizeof(szVersion));
snprintf(szPath, sizeof(szPath), "%s", getenv("TVMCFG"));
if(NULL == (fp = fopen(szPath, "rb")))
{
pstSavm->m_lErrno = FILE_NOTFOUND;
return RC_FAIL;
}
fread(szVersion, 4, 1, fp);
if(memcmp(szVersion, TVM_RUNCFG_TAG, 4))
{
fclose(fp);
pstSavm->m_lErrno = BOOT_VER_ICMP;
return RC_FAIL;
}
fseek(fp, sizeof(TBoot), SEEK_CUR);
fread((void *)plOut, sizeof(long), 1, fp);
if(*plOut <= 0)
{
fclose(fp);
return RC_SUCC;
}
fseek(fp, (*plOut) * sizeof(TIndex), SEEK_CUR);
fread((void *)plOut, sizeof(long), 1, fp);
if(NULL == (*ppstIndex = (void *)calloc(*plOut, sizeof(TIndex))))
{
fclose(fp);
pstSavm->m_lErrno = MALLC_MEM_ERR;
return RC_FAIL;
}
fread(*ppstIndex, (*plOut) * sizeof(TIndex), 1, fp);
fclose(fp);
return RC_SUCC;
}
/*************************************************************************************************
description：from the config to initial table of domain
parameters:
pstSavm --stvm handle
plOut --number
ppstIndex --out of index group
return:
RC_SUCC --success
RC_FAIL --failure
*************************************************************************************************/
long lGetDomainTable(SATvm *pstSavm, long *plOut, TDomain **ppstDomain)
{
FILE *fp = NULL;
char szPath[512], szVersion[10];
if(!pstSavm || !ppstDomain || !plOut)
{
pstSavm->m_lErrno = CONDIT_IS_NIL;
return RC_FAIL;
}
memset(szPath, 0, sizeof(szPath));
memset(szVersion, 0, sizeof(szVersion));
snprintf(szPath, sizeof(szPath), "%s", getenv("TVMCFG"));
if(NULL == (fp = fopen(szPath, "rb")))
{
pstSavm->m_lErrno = FILE_NOTFOUND;
return RC_FAIL;
}
fread(szVersion, 4, 1, fp);
if(memcmp(szVersion, TVM_RUNCFG_TAG, 4))
{
fclose(fp);
pstSavm->m_lErrno = BOOT_VER_ICMP;
return RC_FAIL;
}
fseek(fp, sizeof(TBoot), SEEK_CUR);
fread((void *)plOut, sizeof(long), 1, fp);
fseek(fp, (*plOut) * sizeof(TIndex), SEEK_CUR);
fread((void *)plOut, sizeof(long), 1, fp);
fseek(fp, (*plOut) * sizeof(TIndex), SEEK_CUR);
fread((void *)plOut, sizeof(long), 1, fp);
if(*plOut <= 0)
{
fclose(fp);
return RC_SUCC;
}
if(NULL == (*ppstDomain = (void *)calloc(*plOut, sizeof(TDomain))))
{
fclose(fp);
pstSavm->m_lErrno = MALLC_MEM_ERR;
return RC_FAIL;
}
fread(*ppstDomain, (*plOut) * sizeof(TDomain), 1, fp);
fclose(fp);
return RC_SUCC;
}
/*************************************************************************************************
description：parse config field
parameters:
pszBuffer --file content
pszTarg --target
nTarg --target length
pszValue --The label value
nValue --value max length
return:
RC_SUCC --success
RC_FAIL --failure
*************************************************************************************************/
long lPraseField(char *pszBuffer, char *pszTarg, long nTarg, char *pszValue, long nValue)
{
char szAttr[512];
memset(szAttr, 0, sizeof(szAttr));
strncpy(szAttr, pszBuffer, sizeof(szAttr));
if(!strstr(szAttr, "="))
{
fprintf(stdout, "%s\n*may be lost '='\n", szAttr);
return RC_FAIL;
}
strncpy(pszTarg, sgetvalue(szAttr, "=", 1), nTarg);
strncpy(pszValue, sgetvalue(szAttr, "=", 2), nValue);
srtrim(pszTarg);
sltrim(pszValue);
strimabout(pszValue, "\"", "\"");
if(!strlen(pszValue))
{
fprintf(stdout, "%s\n*config error, The initial value is not set\n", szAttr);
return RC_FAIL;
}
return RC_SUCC;
}
/*************************************************************************************************
description：from the config to initial table index
parameters:
pstSavm --stvm handle
ppstRoot --content list
pszFile --config file
pszTarge --target
return:
RC_SUCC --success
RC_FAIL --failure
*************************************************************************************************/
long _lParseFile(SATvm *pstSavm, CMList **ppstRoot, char *pszFile, const char *pszTarget)
{
FILE *fp = NULL;
char szLine[4098];
BOOL bFlag = FALSE;
CMList *pstList = NULL;
if(NULL == (fp = fopen(pszFile, "rb")))
{
pstSavm->m_lErrno = FILE_NOTFOUND;
return RC_FAIL;
}
memset(szLine, 0, sizeof(szLine));
while(fgets(szLine, sizeof(szLine), fp))
{
strimcrlf(szLine);
sltrim(szLine);
srtrim(szLine);
if(!strlen(szLine))
continue;
if('#' == szLine[0] || !memcmp("//", szLine, 2) || !memcmp("/*", szLine, 2) ||
!memcmp("＃", szLine, 2) || !memcmp("--", szLine, 2))
continue;
if(!strcmp(pszTarget, szLine) && !bFlag)
{
bFlag = TRUE;
memset(szLine, 0, sizeof(szLine));
continue;
}
else if(szLine[0] == '*' && bFlag)
break;
if(!bFlag)
{
memset(szLine, 0, sizeof(szLine));
continue;
}
if(NULL == (pstList = pInsertList(pstList, (void *)szLine, sizeof(szLine))))
{
fclose(fp);
vDestroyList(pstList);
return RC_FAIL;
}
}
fclose(fp);
*ppstRoot = pstList;
return RC_SUCC;
}
/*************************************************************************************************
description：parse STVM boot parameter
parameters:
pstSavm --stvm handle
pszFile --config file
pstBoot --target
return:
RC_SUCC --success
RC_FAIL --failure
*************************************************************************************************/
long lParseBoot(SATvm *pstSavm, char *pszFile, TBoot *pstBoot)
{
char szTarg[128], szValue[64];
CMList *pstNode = NULL, *pstRoot = NULL;
if(RC_SUCC != _lParseFile(pstSavm, &pstRoot, pszFile, "*GLOBLE"))
{
fprintf(stderr, "parse file, err:(%d)(%s)\n", pstSavm->m_lErrno, sGetTError(pstSavm->m_lErrno));
return RC_FAIL;
}
for(pstNode = pstRoot; pstNode; pstNode = pstNode->pstNext)
{
memset(szTarg, 0, sizeof(szTarg));
memset(szValue, 0, sizeof(szValue));
if(RC_SUCC != lPraseField((char *)pstNode->m_psvData, szTarg, sizeof(szTarg), szValue,
sizeof(szValue)))
goto PBOOT_ERROR;
if(!strcasecmp(szTarg, "MACHINE"))
strncpy(pstBoot->m_szNode, szValue, sizeof(pstBoot->m_szNode));
else if(!strcasecmp(szTarg, "LOGNAME"))
strncpy(pstBoot->m_szLog, szValue, sizeof(pstBoot->m_szLog));
else if(!strcasecmp(szTarg, "DEPLOY"))
{
if(!strcasecmp(szValue, "cluster"))
pstBoot->m_lBootType = TVM_BOOT_CLUSTER;
else if(!strcasecmp(szValue, "local"))
pstBoot->m_lBootType = TVM_BOOT_LOCAL;
else // local
pstBoot->m_lBootType = TVM_BOOT_SIMPLE;
}
else if(!strcasecmp(szTarg, "MAXTABLE"))
{
pstBoot->m_lMaxTable = atol(szValue);
if(pstBoot->m_lMaxTable <= 5)
{
fprintf(stdout, "%s\n*Set STVM maximum support table number error\n",
(char *)pstNode->m_psvData);
}
else if(pstBoot->m_lMaxTable > 255)
{
fprintf(stdout, "%s\n*STVM maximum support table 255\n",
(char *)pstNode->m_psvData);
goto PBOOT_ERROR;
}
}
else if(!strcasecmp(szTarg, "MAXFILED"))
{
pstBoot->m_lMaxField = atol(szValue);
if(pstBoot->m_lMaxField <= 100)
{
fprintf(stdout, "%s\n*Set the number of STVM field details error\n",
(char *)pstNode->m_psvData);
goto PBOOT_ERROR;
}
}
else if(!strcasecmp(szTarg, "MAXDOMAIN"))
{
pstBoot->m_lMaxDomain = atol(szValue);
if(pstBoot->m_lMaxDomain <= 0)
{
fprintf(stdout, "%s\n*Error in setting maximum number of domain\n",
(char *)pstNode->m_psvData);
goto PBOOT_ERROR;
}
}
else if(!strcasecmp(szTarg, "MAXSEQUE"))
{
pstBoot->m_lMaxSeque = atol(szValue);
if(pstBoot->m_lMaxSeque <= 0)
{
fprintf(stdout, "%s\n*Error in setting maximum number of sequences\n",
(char *)pstNode->m_psvData);
goto PBOOT_ERROR;
}
}
else if(!strcasecmp(szTarg, "SERVER_EXEC"))
{
pstBoot->m_lBootExec = atol(szValue);
if(pstBoot->m_lBootExec <= 0)
{
fprintf(stdout, "%s\n*LIS.tvm: startup number set error",
(char *)pstNode->m_psvData);
goto PBOOT_ERROR;
}
}
else if(!strcasecmp(szTarg, "SERVER_PORT"))
{
pstBoot->m_lBootPort = atol(szValue);
if(pstBoot->m_lBootPort <= 0)
{
fprintf(stdout, "%s\n*LIS.tvm: Error starting port setting\n",
(char *)pstNode->m_psvData);
goto PBOOT_ERROR;
}
}
else
{
fprintf(stdout, "%s\n*Invalid parameter\n", (char *)pstNode->m_psvData);
goto PBOOT_ERROR;
}
}
if(!strlen(pstBoot->m_szNode))
{
fprintf(stdout, "MACHINE\n*The local node is not set\n");
goto PBOOT_ERROR;
}
if(pstBoot->m_lMaxTable <= 0)
pstBoot->m_lMaxTable = TVM_MAX_TABLE;
if(pstBoot->m_lMaxField <= 0)
pstBoot->m_lMaxField = 3000;
if(pstBoot->m_lMaxDomain <= 0)
pstBoot->m_lMaxDomain = 500;
if(pstBoot->m_lMaxSeque <= 0)
pstBoot->m_lMaxSeque = 500;
if(pstBoot->m_lBootExec <= 0)
pstBoot->m_lBootExec = get_nprocs() > 0 ? get_nprocs() : 1;
if(pstBoot->m_lBootPort <= 0)
pstBoot->m_lBootPort = TVM_PORT_LISTEN;
vDestroyList(pstRoot);
return RC_SUCC;
PBOOT_ERROR:
vDestroyList(pstRoot);
return RC_FAIL;
}
/*************************************************************************************************
description：get config domain resource
parameters:
lDomain --number of domain
pstDomain --domain group
pszDomain --domain
return:
void* --domain
*************************************************************************************************/
TDomain* pGetResourse(long lDomain, TDomain *pstDomain, char *pszDomain)
{
long i = 0;
for(i = 0; i < lDomain; i ++)
{
if(!strcmp(pstDomain[i].m_szOwner, pszDomain))
return &pstDomain[i];
}
return NULL;
}
/*************************************************************************************************
description：parse local table config
parameters:
pstSavm --stvm handle
pszFile --config
plOut --number
ppstIndex --out of index group
return:
RC_SUCC --success
RC_FAIL --failure
*************************************************************************************************/
long lParseIndex(SATvm *pstSavm, char *pszFile, long *plOut, TIndex **ppstIndex)
{
long i, j, n;
TIndex *pstIndex = NULL;
CMList *pstNode = NULL, *pstRoot = NULL;
char szTarg[128], szValue[64], szAttr[1024];
memset(szTarg, 0, sizeof(szTarg));
memset(szAttr, 0, sizeof(szAttr));
memset(szValue, 0, sizeof(szValue));
if(RC_SUCC != _lParseFile(pstSavm, &pstRoot, pszFile, "*LOCAL_RESOURCE"))
{
fprintf(stderr, "parse file, err:(%d)(%s)\n", pstSavm->m_lErrno, sGetTError(pstSavm->m_lErrno));
return RC_FAIL;
}
for(pstNode = pstRoot, j = 0; pstNode; pstNode = pstNode->pstNext)
{
sfieldreplace((char *)pstNode->m_psvData, '\t', ' ');
if(!strlen((char *)pstNode->m_psvData)) continue;
if(NULL == (pstIndex = (TIndex *)realloc(pstIndex, (++ j) * sizeof(TIndex))))
{
pstSavm->m_lErrno = MALLC_MEM_ERR;
return RC_FAIL;
}
memset(&pstIndex[j - 1], 0, sizeof(TIndex));
for(i = 0, n = lfieldnum((char *)pstNode->m_psvData, " "); i < n; i ++)
{
memset(szTarg, 0, sizeof(szTarg));
memset(szValue, 0, sizeof(szValue));
if(RC_SUCC != lPraseField(sfieldvalue((char *)pstNode->m_psvData, " ", i + 1),
szTarg, sizeof(szTarg), szValue, sizeof(szValue)))
goto PINDEX_ERROR;
if(!strcasecmp(szTarg, "TABLE"))
pstIndex[j - 1].m_table = atol(szValue);
else if(!strcasecmp(szTarg, "PERMIT"))
pstIndex[j - 1].m_lPers = atol(szValue);
else
{
fprintf(stdout, "%s\n*Invalid parameter\n", (char *)pstNode->m_psvData);
goto PINDEX_ERROR;
}
}
if(pstIndex[j - 1].m_table <= 0)
{
fprintf(stdout, "%s\n*Table setting error\n", (char *)pstNode->m_psvData);
goto PINDEX_ERROR;
}
if(pstIndex[j - 1].m_lPers <= 0)
pstIndex[j - 1].m_lPers = OPERATE_DEFAULT;
}
*plOut = j;
*ppstIndex = pstIndex;
vDestroyList(pstRoot);
return RC_SUCC;
PINDEX_ERROR:
TFree(*ppstIndex);
vDestroyList(pstRoot);
return RC_FAIL;
}
/*************************************************************************************************
description：parse domain
parameters:
pstSavm --stvm handle
pszFile --config
plCount --number
ppstDom --out of domain group
return:
RC_SUCC --success
RC_FAIL --failure
*************************************************************************************************/
long lParseResouce(SATvm *pstSavm, char *pszFile, long *plCout, TDomain **ppstDom)
{
TDomain *pv;
long i, n;
char szTarg[128], szValue[64];
CMList *pstNode = NULL, *pstRoot = NULL;
if(RC_SUCC != _lParseFile(pstSavm, &pstRoot, pszFile, "*REMOTE_DOMAIN"))
{
fprintf(stderr, "parse file, err:(%d)(%s)\n", pstSavm->m_lErrno, sGetTError(pstSavm->m_lErrno));
return RC_FAIL;
}
for(pstNode = pstRoot, *plCout = 0; pstNode; pstNode = pstNode->pstNext)
{
sfieldreplace((char *)pstNode->m_psvData, '\t', ' ');
if(!strlen((char *)pstNode->m_psvData)) continue;
if(NULL == (*ppstDom = (TDomain *)realloc(*ppstDom, (++ (*plCout)) * sizeof(TDomain))))
{
pstSavm->m_lErrno = MALLC_MEM_ERR;
return RC_FAIL;
}
pv = &(*ppstDom)[(*plCout) - 1];
memset(pv, 0, sizeof(TDomain));
for(i = 0, n = lfieldnum((char *)pstNode->m_psvData, " "); i < n; i ++)
{
memset(szTarg, 0, sizeof(szTarg));
memset(szValue, 0, sizeof(szValue));
if(RC_SUCC != lPraseField(sfieldvalue((char *)pstNode->m_psvData, " ", i + 1),
szTarg, sizeof(szTarg), szValue, sizeof(szValue)))
goto PDOMAIN_ERROR;
if(!strcasecmp(szTarg, "DOMAINID"))
strncpy(pv->m_szOwner, szValue, sizeof(pv->m_szOwner));
else if(!strcasecmp(szTarg, "GROUP"))
pv->m_lGroup = atol(szValue);
else if(!strcasecmp(szTarg, "WSADDR"))
{
strncpy(pv->m_szIp, sgetvalue(szValue, ":", 1), sizeof(pv->m_szIp));
pv->m_lPort = atol(sgetvalue(szValue, ":", 2));
}
else if(!strcasecmp(szTarg, "TIMTOUT"))
pv->m_lTimeOut = atol(szValue);
else if(!strcasecmp(szTarg, "MAXTRY"))
pv->m_lTryMax = atol(szValue);
else if(!strcasecmp(szTarg, "KEEPALIVE"))
pv->m_lKeepLive = atol(szValue);
}
if(!strlen(pv->m_szOwner))
{
fprintf(stdout, "%s\n*域名未设置\n", (char *)pstNode->m_psvData);
goto PDOMAIN_ERROR;
}
if(!strlen(pv->m_szIp))
{
fprintf(stdout, "%s\n*域地址未设置\n", (char *)pstNode->m_psvData);
goto PDOMAIN_ERROR;
}
if(pv->m_lPort <= 0)
{
fprintf(stdout, "%s\n*The domain port is set incorrectly or unset\n",
(char *)pstNode->m_psvData);
goto PDOMAIN_ERROR;
}
pv->m_lGroup = pv->m_lGroup > 0 ? pv->m_lGroup : 1;
pv->m_lTimeOut = pv->m_lTimeOut > 0 ? pv->m_lTimeOut : 5;
pv->m_lTryMax = pv->m_lTryMax > 0 ? pv->m_lTryMax : 3;
pv->m_lKeepLive= pv->m_lKeepLive > 0 ? pv->m_lKeepLive : 30;
}
TFlst(pstRoot);
return RC_SUCC;
PDOMAIN_ERROR:
TFree(*ppstDom);
TFlst(pstRoot);
return RC_FAIL;
}
/*************************************************************************************************
description：parse the table of domain
parameters:
pszNode --node
pszBuffer --content
plOut --number
ppIndx --out of index
return:
RC_SUCC --success
RC_FAIL --failure
*************************************************************************************************/
long lParseTable(char *pszNode, char *pszBuffer, long *plOut, TIndex **ppIndx)
{
long i, n;
TIndex *pv = NULL;
char szTarg[128], szValue[64];
if(NULL == (*ppIndx = (TIndex *)realloc(*ppIndx, (++ (*plOut)) * sizeof(TIndex))))
return RC_FAIL;
pv = &(*ppIndx)[(*plOut) - 1];
memset(pv, 0, sizeof(TIndex));
sfieldreplace(pszBuffer, '\t', ' ');
for(i = 0, n = lfieldnum(pszBuffer, " "); i < n; i ++)
{
memset(szTarg, 0, sizeof(szTarg));
memset(szValue, 0, sizeof(szValue));
if(RC_SUCC != lPraseField(sfieldvalue(pszBuffer, " ", i + 1), szTarg, sizeof(szTarg),
szValue, sizeof(szValue)))
return RC_FAIL;
if(!strcasecmp(szTarg, "TABLE"))
pv->m_table = atol(szValue);
else if(!strcasecmp(szTarg, "TABLENAME"))
strncpy(pv->m_szTable, szValue, sizeof(pv->m_szTable));
else if(!strcasecmp(szTarg, "PART"))
strncpy(pv->m_szPart, szValue, sizeof(pv->m_szPart));
if(!strlen(pv->m_szPart))
strcpy(pv->m_szPart, pszNode);
strcpy(pv->m_szOwner, pszNode);
}
pv->m_lLocal = RES_REMOT_SID;
pv->m_lPers = OPERATE_NULL;
pv->m_lType = TYPE_CLIENT;
strncpy(pv->m_szTime, sGetUpdTime(), sizeof(pv->m_szTime));
return RC_SUCC;
}
/*************************************************************************************************
description：parse domain resource
parameters:
pszBuffer --content
pstIndex --index
pstDom --domain
plDom --number
ppstDom --domain list
return:
RC_SUCC --success
RC_FAIL --failure
*************************************************************************************************/
long lParseDomain(char *pszBuffer, TIndex *pstIndex, TDomain *pstDom, long *plDom,
TDomain **ppstDom)
{
long i, n;
TDomain *pv = NULL;
char szTarg[128], szValue[64];
if(NULL == (*ppstDom = (TDomain *)realloc(*ppstDom, (++ (*plDom)) * sizeof(TDomain))))
return RC_FAIL;
pv = &(*ppstDom)[(*plDom) - 1];
memset(pv, 0, sizeof(TDomain));
for(i = 0, n = lfieldnum(pszBuffer, " "); i < n; i ++)
{
memset(szTarg, 0, sizeof(szTarg));
memset(szValue, 0, sizeof(szValue));
if(RC_SUCC != lPraseField(sfieldvalue(pszBuffer, " ", i + 1), szTarg, sizeof(szTarg),
szValue, sizeof(szValue)))
return RC_FAIL;
if(!strcasecmp(szTarg, "MTABLE"))
pv->m_mtable = atol(szValue);
else if(!strcasecmp(szTarg, "DOMAINID"))
strncpy(pv->m_szOwner, szValue, sizeof(pv->m_szOwner));
else
{
fprintf(stdout, "%s\n*Invalid parameter\n", pszBuffer);
return RC_FAIL;
}
}
pv->m_lTryMax = 0;
pv->m_lLastTime = 0;
pv->m_lStatus = RESOURCE_INIT;
pv->m_table = pstIndex->m_table;
pv->m_lPort = pstDom->m_lPort;
pv->m_lGroup = pstDom->m_lGroup;
pv->m_lKeepLive = pstDom->m_lKeepLive;
pv->m_lTimeOut = pstDom->m_lTimeOut;
pv->m_lTryMax = pstDom->m_lTryMax;
strcpy(pv->m_szIp, pstDom->m_szIp);
strcpy(pv->m_szTable, pstIndex->m_szTable);
strcpy(pv->m_szOwner, pstDom->m_szOwner);
if(!strlen(pv->m_szPart))
strcpy(pv->m_szPart, pstDom->m_szOwner);
return RC_SUCC;
}
/*************************************************************************************************
description：parse domain table of remote
parameters:
pstSavm --stvm handle
pszFile --config
pstBoot --boot paramter
plOut --number of index
ppstIndex --out of index list
plDom --number of domain
ppstDom --out of domain list
return:
RC_SUCC --success
RC_FAIL --failure
*************************************************************************************************/
long lParseRemote(SATvm *pstSavm, char *pszFile, TBoot *pstBoot, long *plOut, TIndex **ppstIndex,
long *plDom, TDomain **ppstDom)
{
long i, lResource;
TIndex *pv = NULL;
CMList *pstNode = NULL, *pstRoot = NULL;
TDomain *pstRes = NULL, *pstResouce = NULL;
char szTarg[128], szValue[64], *p = NULL;
if(RC_SUCC != lParseResouce(pstSavm, pszFile, &lResource, &pstResouce))
return RC_FAIL;
if(RC_SUCC != _lParseFile(pstSavm, &pstRoot, pszFile, "*REMOTE_TABLE"))
{
fprintf(stderr, "parse file, err:(%d)(%s)\n", pstSavm->m_lErrno, sGetTError(pstSavm->m_lErrno));
return RC_FAIL;
}
if(!pstRoot)
{
for(i = 0; i < lResource; i ++)
{
pstResouce[i].m_table = SYS_TVM_INDEX;
pstResouce[i].m_mtable = SYS_TVM_INDEX;
strcpy(pstResouce[i].m_szTable, "SYS_TVM_INDEX");
strcpy(pstResouce[i].m_szPart, pstResouce[i].m_szOwner);
}
*plOut = 0;
*ppstIndex = NULL;
*plDom = lResource;
*ppstDom = pstResouce;
return RC_SUCC;
}
else
{
for(pstNode = pstRoot, *plDom = 0, *plOut = 0; pstNode; pstNode = pstNode->pstNext)
{
sfieldreplace((char *)pstNode->m_psvData, '\t', ' ');
if(!strncmp((char *)pstNode->m_psvData, "TABLE", 5))
{
if(RC_SUCC != lParseTable(pstBoot->m_szNode, (char *)pstNode->m_psvData,
plOut, ppstIndex))
goto PREMOTE_ERROR;
pv = &(*ppstIndex)[(*plOut) - 1];
continue;
}
if(NULL == (p = strstr((char *)pstNode->m_psvData, "DOMAINID")))
{
fprintf(stderr, "set error:%s\n", (char *)pstNode->m_psvData);
goto PREMOTE_ERROR;
}
if(NULL == (pstRes = pGetResourse(lResource, pstResouce,
strimabout(sfieldvalue(p, "=", 2), "\"", "\""))))
{
fprintf(stderr, "No domain (%s) is found\n", sfieldvalue(p, "=", 2));
goto PREMOTE_ERROR;
}
if(RC_SUCC != lParseDomain((char *)pstNode->m_psvData, pv, pstRes, plDom, ppstDom))
{
TFlst(pstRoot);
return RC_FAIL;
}
}
}
TFree(pstResouce);
TFlst(pstRoot);
return RC_SUCC;
PREMOTE_ERROR:
TFlst(pstRoot);
TFree(*ppstIndex);
TFree(pstResouce);
return RC_FAIL;
}
/*************************************************************************************************
description：Domain uniqueness checks
parameters:
lCount --number
pstDomain --domain list
return:
true --repeat
false
*************************************************************************************************/
BOOL bDomIsRepeat(long lCount, TDomain *pstDomain)
{
int i, j;
for(i = 0; i < lCount; i ++)
{
for(j = 0; j < lCount; j ++)
{
if(i == j) continue;
if(pstDomain[i].m_lPort == pstDomain[j].m_lPort &&
!strcmp(pstDomain[i].m_szIp, pstDomain[j].m_szIp) &&
!strcmp(pstDomain[i].m_szPart, pstDomain[j].m_szPart) &&
!strcmp(pstDomain[i].m_szTable, pstDomain[j].m_szTable))
{
if(SYS_TVM_INDEX == pstDomain[i].m_table)
{
fprintf(stderr, "*domain(%s)(%s:%ld)repeate\n", pstDomain[i].m_szOwner,
pstDomain[i].m_szIp, pstDomain[i].m_lPort);
}
else
{
fprintf(stderr, "*table(%s)(%s)repeate\n", pstDomain[i].m_szTable,
pstDomain[i].m_szPart);
}
return true;
}
}
}
return false;
}
/*************************************************************************************************
description：Compile configuration file
parameters:
pszFile --config file
return:
RC_SUCC --success
RC_FAIL --failure
*************************************************************************************************/
long lMakeConfig(char *pszFile)
{
TBoot stBoot;
FILE *fp = NULL;
TIndex *pstIndex = NULL;
TDomain *pstDomain = NULL;
long i, lOut = 0, lCount = 0;
SATvm *pstSavm = (SATvm *)pGetSATvm();
if(!pszFile || !strlen(pszFile))
{
fprintf(stderr, "The configuration file is not set\n");
return RC_FAIL;
}
if(RC_SUCC != access(pszFile, R_OK | F_OK ))
{
fprintf(stderr, "Insufficient authority(%s), please confirm!!!\n\n", pszFile);
return RC_FAIL;
}
memset(&stBoot, 0, sizeof(TBoot));
if(NULL == (fp = fopen(getenv("TVMCFG"), "wb")))
{
fprintf(stderr, "open (%s) failure, err:(%d)(%s)", getenv("TVMCFG"),
errno, strerror(errno));
return RC_FAIL;
}
fwrite(TVM_RUNCFG_TAG, 4, 1, fp);
if(RC_SUCC != lParseBoot(pstSavm, pszFile, &stBoot))
goto CREATE_ERROR;
fwrite(&stBoot, sizeof(stBoot), 1, fp);
if(TVM_BOOT_CLUSTER != stBoot.m_lBootType) // 单机部署
{
fclose(fp);
fprintf(stdout, "create completed successfully!!!\n");
return RC_FAIL;
}
if(RC_SUCC != lParseIndex(pstSavm, pszFile, &lOut, &pstIndex))
goto CREATE_ERROR;
fwrite(&lOut, sizeof(long), 1, fp);
fwrite(pstIndex, sizeof(TIndex), lOut, fp);
TFree(pstIndex);
if(RC_SUCC != lParseRemote(pstSavm, pszFile, &stBoot, &lOut, &pstIndex,
&lCount, &pstDomain))
goto CREATE_ERROR;
if(bDomIsRepeat(lCount, pstDomain))
goto CREATE_ERROR;
fwrite(&lOut, sizeof(long), 1, fp);
if(lOut > 0)
{
fwrite(pstIndex, sizeof(TIndex), lOut, fp);
TFree(pstIndex);
}
fwrite(&lCount, sizeof(long), 1, fp);
if(lCount > 0)
{
fwrite(pstDomain, sizeof(TDomain), lCount, fp);
TFree(pstDomain);
}
fclose(fp);
fprintf(stdout, "create completed successfully!!!\n");
return RC_SUCC;
CREATE_ERROR:
TFree(pstDomain);
TFree(pstIndex);
fclose(fp);
return RC_FAIL;
}
/*************************************************************************************************
description：Decompilate compilation configuration
parameters:
pszFile --config file
return:
RC_SUCC --success
RC_FAIL --failure
*************************************************************************************************/
long lUnmakeConfig(char *pszFile)
{
char ch;
TBoot stBoot;
FILE *fp = NULL;
BOOL bf = false;
TIndex *pstIndex = NULL;
TDomain *pstDomain = NULL;
long i, j, lOut = 0, lCount = 0;
SATvm *pstSavm = (SATvm *)pGetSATvm();
if(RC_SUCC == access(pszFile, F_OK))
{
fprintf(stderr, "The configuration already exists, Confirm the cover(Y/N)?:");
ch = getchar();
if(ch != 'y' && 'Y' != ch)
return RC_SUCC;
}
if(NULL == (fp = fopen(pszFile, "w")))
{
fprintf(stderr, "open file error, %s\n", strerror(errno));
return RC_FAIL;
}
if(RC_SUCC != lGetBootConfig(pstSavm, &stBoot))
goto UNMAKE_ERR;
fprintf(fp, "*GLOBLE\n");
fprintf(fp, "MACHINE=\"%s\"\n", stBoot.m_szNode);
fprintf(fp, "MAXTABLE=%ld\n", stBoot.m_lMaxTable);
fprintf(fp, "MAXFILED=%ld\n", stBoot.m_lMaxField);
fprintf(fp, "MAXDOMAIN=%ld\n", stBoot.m_lMaxDomain);
fprintf(fp, "MAXSEQUE=%ld\n", stBoot.m_lMaxSeque);
fprintf(fp, "SERVER_EXEC=%ld\n", stBoot.m_lBootExec);
fprintf(fp, "SERVER_PORT=%ld\n", stBoot.m_lBootPort);
fprintf(fp, "LOGNAME=\"%s\"\n\n", stBoot.m_szLog);
fprintf(fp, "*LOCAL_RESOURCE\n");
if(RC_SUCC != lGetLocalIndex(pstSavm, &lCount, (void *)&pstIndex))
goto UNMAKE_ERR;
for(i = 0; i < lCount; i ++)
fprintf(fp, "TABLE=%d PERMIT=%ld\n", pstIndex[i].m_table, pstIndex[i].m_lPers);
TFree(pstIndex);
fprintf(fp, "\n*REMOTE_DOMAIN");
if(RC_SUCC != lGetDomainIndex(pstSavm, &lCount, &pstIndex))
goto UNMAKE_ERR;
if(RC_SUCC != lGetDomainTable(pstSavm, &lOut, &pstDomain))
goto UNMAKE_ERR;
for(i = 0; i < lCount; i ++)
{
fprintf(fp, "\nTABLE=%d TABLENAME=\"%s\" PART=\"%s\" ", pstIndex[i].m_table,
pstIndex[i].m_szTable, pstIndex[i].m_szPart);
for(j = 0, bf = false; j < lOut; j ++)
{
if(strcmp(pstDomain[j].m_szTable, pstIndex[i].m_szTable) ||
strcmp(pstDomain[j].m_szPart, pstIndex[i].m_szPart))
continue;
if(!bf)
{
bf = !bf;
fprintf(fp, "GROUP=%ld TIMTOUT=%ld MAXTRY=%ld KEEPALIVE=%ld\n",
pstDomain[j].m_lGroup, pstDomain[j].m_lTimeOut, pstDomain[j].m_lTryMax,
pstDomain[j].m_lKeepLive);
}
fprintf(fp, "\tDOMAINID=\"%s\" WSADDR=\"%s:%ld\"\n", pstDomain[j].m_szOwner,
pstDomain[j].m_szIp, pstDomain[j].m_lPort);
}
}
TFree(pstIndex);
TFree(pstDomain);
fclose(fp);
fprintf(stdout, "导出文件(%s)成功，completed successfully!!!\n", pszFile);
return RC_SUCC;
UNMAKE_ERR:
fclose(fp);
TFree(pstIndex);
TFree(pstDomain);
fprintf(stderr, "get config err:(%d)(%s)\n", pstSavm->m_lErrno, sGetTError(pstSavm->m_lErrno));
return RC_FAIL;
}
/**************************************************************************************************
code end
**************************************************************************************************/