889 lines
22 KiB
C
889 lines
22 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <strings.h>
|
|
|
|
#include "stringbuf.h"
|
|
#include "rpmbuild.h"
|
|
|
|
#include "xmlmisc.h"
|
|
#include "xmlstruct.h"
|
|
#include "xmlverify.h"
|
|
|
|
extern Spec g_pSpec;
|
|
char* g_szSpecPath = NULL;
|
|
|
|
void attrSetStr(const t_structXMLAttr* pAttr,
|
|
const char* szParam,
|
|
char** pszVar)
|
|
{
|
|
if (pAttr && !strcasecmp(pAttr->m_szName, szParam))
|
|
newStrEx(pAttr->m_szValue, pszVar);
|
|
}
|
|
|
|
void attrSetInt(const t_structXMLAttr* pAttr,
|
|
const char* szParam,
|
|
int* pnVar)
|
|
{
|
|
if (pAttr && !strcasecmp(pAttr->m_szName, szParam))
|
|
(*pnVar) = atoi(pAttr->m_szValue);
|
|
}
|
|
|
|
void attrSetBool(const t_structXMLAttr* pAttr,
|
|
const char* szParam,
|
|
int* pnVar)
|
|
{
|
|
if (pAttr && !strcasecmp(pAttr->m_szName, szParam))
|
|
(*pnVar) = strToBool(pAttr->m_szValue);
|
|
}
|
|
|
|
t_structXMLAttr* newXMLAttr(const char* szName,
|
|
const char* szValue,
|
|
int nType)
|
|
{
|
|
t_structXMLAttr* pAttr = NULL;
|
|
|
|
if ((pAttr = malloc(sizeof(t_structXMLAttr)))) {
|
|
pAttr->m_szName = NULL;
|
|
pAttr->m_szValue = NULL;
|
|
pAttr->m_nType = nType;
|
|
pAttr->m_pNext = NULL;
|
|
|
|
newStrEx(szName, &(pAttr->m_szName));
|
|
newStrEx(szValue, &(pAttr->m_szValue));
|
|
}
|
|
|
|
return pAttr;
|
|
}
|
|
|
|
int freeXMLAttr(t_structXMLAttr** ppAttr)
|
|
{
|
|
if (*ppAttr) {
|
|
freeStr(&((*ppAttr)->m_szName));
|
|
freeStr(&((*ppAttr)->m_szValue));
|
|
freeXMLAttr(&((*ppAttr)->m_pNext));
|
|
free(*ppAttr);
|
|
*ppAttr = NULL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
t_structXMLAttr* addXMLAttr(const char* szName,
|
|
const char* szValue,
|
|
int nType,
|
|
t_structXMLAttr** ppAttr)
|
|
{
|
|
t_structXMLAttr* pAttr = NULL;
|
|
|
|
if ((pAttr = getLastXMLAttr(*ppAttr)))
|
|
pAttr = (pAttr->m_pNext = newXMLAttr(szName, szValue, nType));
|
|
else
|
|
pAttr = (*ppAttr = newXMLAttr(szName, szValue, nType));
|
|
|
|
return pAttr;
|
|
}
|
|
|
|
t_structXMLAttr* getLastXMLAttr(t_structXMLAttr* pAttr)
|
|
{
|
|
while (pAttr && (pAttr->m_pNext))
|
|
pAttr = pAttr->m_pNext;
|
|
|
|
return pAttr;
|
|
}
|
|
|
|
t_structXMLAttr* getXMLAttr(const char* szName,
|
|
t_structXMLAttr* pAttr)
|
|
{
|
|
while (pAttr && (strcasecmp(szName, pAttr->m_szName) != 0))
|
|
pAttr = pAttr->m_pNext;
|
|
|
|
return pAttr;
|
|
}
|
|
|
|
t_structXMLMacro* newXMLMacro(const t_structXMLAttr* pAttrs)
|
|
{
|
|
t_structXMLMacro* pMacro = NULL;
|
|
t_structXMLAttr* pAttr = NULL;
|
|
|
|
if ((pMacro = malloc(sizeof(t_structXMLMacro)))) {
|
|
pMacro->m_szName = NULL;
|
|
pMacro->m_szValue = NULL;
|
|
pMacro->m_pNext = NULL;
|
|
|
|
pAttr = (t_structXMLAttr*)pAttrs;
|
|
do {
|
|
attrSetStr(pAttr, "name", &(pMacro->m_szName));
|
|
} while ((pAttr = pAttr->m_pNext));
|
|
//addMacroEx(pMacro->m_szName, (char**)&(pMacro->m_szValue), 1);
|
|
}
|
|
|
|
return pMacro;
|
|
}
|
|
|
|
int freeXMLMacro(t_structXMLMacro** ppMacro)
|
|
{
|
|
if (*ppMacro) {
|
|
freeStr(&((*ppMacro)->m_szName));
|
|
freeStr(&((*ppMacro)->m_szValue));
|
|
freeXMLMacro(&((*ppMacro)->m_pNext));
|
|
free(*ppMacro);
|
|
}
|
|
*ppMacro = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
t_structXMLMacro* addXMLMacro(const t_structXMLAttr* pAttrs,
|
|
t_structXMLMacro** ppMacro)
|
|
{
|
|
t_structXMLMacro* pMacro = NULL;
|
|
|
|
if ((pMacro = getLastXMLMacro(*ppMacro)))
|
|
pMacro = (pMacro->m_pNext = newXMLMacro(pAttrs));
|
|
else
|
|
pMacro = (*ppMacro = newXMLMacro(pAttrs));
|
|
|
|
return pMacro;
|
|
}
|
|
|
|
t_structXMLMacro* getLastXMLMacro(t_structXMLMacro* pMacro)
|
|
{
|
|
while (pMacro && (pMacro->m_pNext))
|
|
pMacro = pMacro->m_pNext;
|
|
|
|
return pMacro;
|
|
}
|
|
|
|
t_structXMLMirror* newXMLMirror(const t_structXMLAttr* pAttrs)
|
|
{
|
|
t_structXMLMirror* pMirror = NULL;
|
|
t_structXMLAttr* pAttr = NULL;
|
|
|
|
if ((pMirror = malloc(sizeof(t_structXMLMirror)))) {
|
|
pMirror->m_szName = NULL;
|
|
pMirror->m_szLocation = NULL;
|
|
pMirror->m_szCountry = NULL;
|
|
pMirror->m_szPath = NULL;
|
|
pMirror->m_nTries = 0;
|
|
pMirror->m_pNext = NULL;
|
|
|
|
pAttr = (t_structXMLAttr*)pAttrs;
|
|
do {
|
|
attrSetStr(pAttr, "name", &(pMirror->m_szName));
|
|
attrSetStr(pAttr, "location", &(pMirror->m_szLocation));
|
|
attrSetStr(pAttr, "country", &(pMirror->m_szCountry));
|
|
attrSetStr(pAttr, "path", &(pMirror->m_szPath));
|
|
} while ((pAttr = pAttr->m_pNext));
|
|
}
|
|
|
|
return pMirror;
|
|
}
|
|
|
|
int freeXMLMirror(t_structXMLMirror** ppMirror)
|
|
{
|
|
if (*ppMirror) {
|
|
freeStr(&((*ppMirror)->m_szName));
|
|
freeStr(&((*ppMirror)->m_szLocation));
|
|
freeStr(&((*ppMirror)->m_szCountry));
|
|
freeStr(&((*ppMirror)->m_szPath));
|
|
freeXMLMirror(&((*ppMirror)->m_pNext));
|
|
free(*ppMirror);
|
|
}
|
|
*ppMirror = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
t_structXMLMirror* addXMLMirror(const t_structXMLAttr* pAttrs,
|
|
t_structXMLMirror** ppMirror)
|
|
{
|
|
t_structXMLMirror* pMirror = NULL;
|
|
|
|
if ((pMirror = getLastXMLMirror(*ppMirror)))
|
|
pMirror = (pMirror->m_pNext = newXMLMirror(pAttrs));
|
|
else
|
|
pMirror = (*ppMirror = newXMLMirror(pAttrs));
|
|
|
|
return pMirror;
|
|
}
|
|
|
|
t_structXMLMirror* getLastXMLMirror(t_structXMLMirror* pMirror)
|
|
{
|
|
while (pMirror && (pMirror->m_pNext))
|
|
pMirror = pMirror->m_pNext;
|
|
|
|
return pMirror;
|
|
}
|
|
|
|
t_structXMLSource* newXMLSource(const t_structXMLAttr* pAttrs)
|
|
{
|
|
t_structXMLSource* pSource = NULL;
|
|
t_structXMLAttr* pAttr = NULL;
|
|
|
|
if ((pSource = malloc(sizeof(t_structXMLSource)))) {
|
|
pSource->m_szName = NULL;
|
|
pSource->m_szMD5 = NULL;
|
|
pSource->m_szDirectory = NULL;
|
|
pSource->m_nSize = 0;
|
|
pSource->m_nNum = -1;
|
|
pSource->m_pMirrors = NULL;
|
|
pSource->m_pNext = NULL;
|
|
|
|
pAttr = (t_structXMLAttr*)pAttrs;
|
|
do {
|
|
attrSetStr(pAttr, "name", &(pSource->m_szName));
|
|
attrSetInt(pAttr, "size", &(pSource->m_nSize));
|
|
attrSetStr(pAttr, "md5", &(pSource->m_szMD5));
|
|
attrSetStr(pAttr, "directory", &(pSource->m_szDirectory));
|
|
attrSetInt(pAttr, "id", &(pSource->m_nNum));
|
|
} while ((pAttr = pAttr->m_pNext));
|
|
}
|
|
|
|
return pSource;
|
|
}
|
|
|
|
int freeXMLSource(t_structXMLSource** ppSource)
|
|
{
|
|
if (*ppSource) {
|
|
freeStr(&((*ppSource)->m_szName));
|
|
freeStr(&((*ppSource)->m_szMD5));
|
|
freeStr(&((*ppSource)->m_szDirectory));
|
|
freeXMLMirror(&((*ppSource)->m_pMirrors));
|
|
freeXMLSource(&((*ppSource)->m_pNext));
|
|
free(*ppSource);
|
|
}
|
|
*ppSource = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
t_structXMLSource* addXMLSource(const t_structXMLAttr* pAttrs,
|
|
t_structXMLSource** ppSource)
|
|
{
|
|
t_structXMLSource* pSource = NULL;
|
|
|
|
if ((pSource = getLastXMLSource(*ppSource))) {
|
|
pSource->m_pNext = newXMLSource(pAttrs);
|
|
if (pSource->m_pNext->m_nNum == -1)
|
|
pSource->m_pNext->m_nNum = pSource->m_nNum + 1;
|
|
pSource = pSource->m_pNext;
|
|
}
|
|
else {
|
|
pSource = (*ppSource = newXMLSource(pAttrs));
|
|
if (pSource->m_nNum == -1)
|
|
pSource->m_nNum = 0;
|
|
}
|
|
|
|
return pSource;
|
|
}
|
|
|
|
t_structXMLSource* getLastXMLSource(t_structXMLSource* pSource)
|
|
{
|
|
while (pSource && (pSource->m_pNext))
|
|
pSource = pSource->m_pNext;
|
|
|
|
return pSource;
|
|
}
|
|
|
|
t_structXMLSource* getXMLSource(int nNum,
|
|
t_structXMLSource* pSource)
|
|
{
|
|
while (pSource && (pSource->m_nNum != nNum))
|
|
pSource = pSource->m_pNext;
|
|
|
|
return pSource;
|
|
}
|
|
|
|
t_structXMLRequire* newXMLRequire(const t_structXMLAttr* pAttrs)
|
|
{
|
|
t_structXMLRequire* pRequire = NULL;
|
|
t_structXMLAttr* pAttr = NULL;
|
|
|
|
if ((pRequire = malloc(sizeof(t_structXMLRequire)))) {
|
|
pRequire->m_szName = NULL;
|
|
pRequire->m_szVersion = NULL;
|
|
pRequire->m_szRelease = NULL;
|
|
pRequire->m_szEpoch = NULL;
|
|
pRequire->m_szCompare = NULL;
|
|
pRequire->m_pNext = NULL;
|
|
|
|
pAttr = (t_structXMLAttr*)pAttrs;
|
|
do {
|
|
attrSetStr(pAttr, "name", &(pRequire->m_szName));
|
|
attrSetStr(pAttr, "version", &(pRequire->m_szVersion));
|
|
attrSetStr(pAttr, "release", &(pRequire->m_szRelease));
|
|
attrSetStr(pAttr, "epoch", &(pRequire->m_szEpoch));
|
|
attrSetStr(pAttr, "compare", &(pRequire->m_szCompare));
|
|
} while ((pAttr = pAttr->m_pNext));
|
|
}
|
|
|
|
return pRequire;
|
|
}
|
|
|
|
int freeXMLRequire(t_structXMLRequire** ppRequire)
|
|
{
|
|
if (*ppRequire) {
|
|
freeStr(&((*ppRequire)->m_szName));
|
|
freeStr(&((*ppRequire)->m_szVersion));
|
|
freeStr(&((*ppRequire)->m_szRelease));
|
|
freeStr(&((*ppRequire)->m_szEpoch));
|
|
freeStr(&((*ppRequire)->m_szCompare));
|
|
freeXMLRequire(&((*ppRequire)->m_pNext));
|
|
free(*ppRequire);
|
|
}
|
|
*ppRequire = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
t_structXMLRequire* addXMLRequire(const t_structXMLAttr* pAttrs,
|
|
t_structXMLRequire** ppRequire)
|
|
{
|
|
t_structXMLRequire* pRequire = NULL;
|
|
|
|
if ((pRequire = getLastXMLRequire(*ppRequire)))
|
|
pRequire = (pRequire->m_pNext = newXMLRequire(pAttrs));
|
|
else
|
|
pRequire = (*ppRequire = newXMLRequire(pAttrs));
|
|
|
|
return pRequire;
|
|
}
|
|
|
|
t_structXMLRequire* getLastXMLRequire(t_structXMLRequire* pRequire)
|
|
{
|
|
while (pRequire && (pRequire->m_pNext))
|
|
pRequire = pRequire->m_pNext;
|
|
|
|
return pRequire;
|
|
}
|
|
|
|
t_structXMLScript* newXMLScript(const t_structXMLAttr* pAttrs)
|
|
{
|
|
t_structXMLScript* pScript = NULL;
|
|
t_structXMLAttr* pAttr = NULL;
|
|
|
|
if ((pScript = malloc(sizeof(t_structXMLScript)))) {
|
|
pScript->m_szInterpreter = NULL;
|
|
pScript->m_szArch = NULL;
|
|
pScript->m_szOS = NULL;
|
|
pScript->m_szScript = NULL;
|
|
pScript->m_szEntry = NULL;
|
|
pScript->m_pNext = NULL;
|
|
|
|
if ((pAttr = (t_structXMLAttr*)pAttrs)) {
|
|
do {
|
|
attrSetStr(pAttr, "interpreter",
|
|
&(pScript->m_szInterpreter));
|
|
attrSetStr(pAttr, "arch",
|
|
&(pScript->m_szArch));
|
|
attrSetStr(pAttr, "os",
|
|
&(pScript->m_szOS));
|
|
attrSetStr(pAttr, "script",
|
|
&(pScript->m_szScript));
|
|
} while ((pAttr = pAttr->m_pNext));
|
|
}
|
|
}
|
|
|
|
return pScript;
|
|
}
|
|
|
|
int freeXMLScript(t_structXMLScript** ppScript)
|
|
{
|
|
if (*ppScript) {
|
|
freeStr(&((*ppScript)->m_szInterpreter));
|
|
freeStr(&((*ppScript)->m_szArch));
|
|
freeStr(&((*ppScript)->m_szOS));
|
|
freeStr(&((*ppScript)->m_szScript));
|
|
freeStr(&((*ppScript)->m_szEntry));
|
|
freeXMLScript(&((*ppScript)->m_pNext));
|
|
free(*ppScript);
|
|
}
|
|
*ppScript = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
t_structXMLScript* addXMLScript(const t_structXMLAttr* pAttrs,
|
|
t_structXMLScript** ppScript)
|
|
{
|
|
t_structXMLScript* pScript = NULL;
|
|
|
|
if ((pScript = getLastXMLScript(*ppScript)))
|
|
pScript = (pScript->m_pNext = newXMLScript(pAttrs));
|
|
else
|
|
pScript = (*ppScript = newXMLScript(pAttrs));
|
|
|
|
return pScript;
|
|
}
|
|
|
|
t_structXMLScript* getLastXMLScript(t_structXMLScript* pScript)
|
|
{
|
|
while (pScript && (pScript->m_pNext))
|
|
pScript = pScript->m_pNext;
|
|
|
|
return pScript;
|
|
}
|
|
|
|
t_structXMLScripts* newXMLScripts(const t_structXMLAttr* pAttrs)
|
|
{
|
|
t_structXMLScripts* pScripts = NULL;
|
|
t_structXMLAttr* pAttr = NULL;
|
|
|
|
if ((pScripts = malloc(sizeof(t_structXMLScripts)))) {
|
|
pScripts->m_szInterpreter = NULL;
|
|
pScripts->m_szScript = NULL;
|
|
pScripts->m_pScripts = NULL;
|
|
|
|
if ((pAttr = (t_structXMLAttr*)pAttrs)) {
|
|
do {
|
|
attrSetStr(pAttr, "interpreter", &(pScripts->m_szInterpreter));
|
|
attrSetStr(pAttr, "script", &(pScripts->m_szScript));
|
|
} while ((pAttr = pAttr->m_pNext));
|
|
}
|
|
}
|
|
|
|
return pScripts;
|
|
}
|
|
|
|
int freeXMLScripts(t_structXMLScripts** ppScripts)
|
|
{
|
|
if (*ppScripts) {
|
|
freeStr(&((*ppScripts)->m_szInterpreter));
|
|
freeStr(&((*ppScripts)->m_szScript));
|
|
freeXMLScript(&((*ppScripts)->m_pScripts));
|
|
free(*ppScripts);
|
|
}
|
|
*ppScripts = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
t_structXMLFiles* newXMLFiles(const t_structXMLAttr* pAttrs)
|
|
{
|
|
t_structXMLFiles* pFiles = NULL;
|
|
t_structXMLAttr* pAttr = NULL;
|
|
|
|
if ((pFiles = malloc(sizeof(t_structXMLFiles)))) {
|
|
pFiles->m_szFileList = NULL;
|
|
pFiles->m_szUID = NULL;
|
|
pFiles->m_szGID = NULL;
|
|
|
|
pAttr = (t_structXMLAttr*)pAttrs;
|
|
do {
|
|
attrSetStr(pAttr, "list", &(pFiles->m_szFileList));
|
|
attrSetStr(pAttr, "uid", &(pFiles->m_szUID));
|
|
attrSetStr(pAttr, "gid", &(pFiles->m_szGID));
|
|
} while ((pAttr = pAttr->m_pNext));
|
|
}
|
|
|
|
return pFiles;
|
|
}
|
|
|
|
int freeXMLFiles(t_structXMLFiles** ppFiles)
|
|
{
|
|
if (*ppFiles) {
|
|
freeStr(&((*ppFiles)->m_szFileList));
|
|
freeStr(&((*ppFiles)->m_szUID));
|
|
freeStr(&((*ppFiles)->m_szGID));
|
|
free(*ppFiles);
|
|
}
|
|
*ppFiles = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
t_structI18NStr* newI18NStr(const t_structXMLAttr* pAttrs)
|
|
{
|
|
t_structI18NStr* pStr = NULL;
|
|
t_structXMLAttr* pAttr = NULL;
|
|
|
|
if ((pStr = malloc(sizeof(t_structI18NStr)))) {
|
|
pStr->m_szLang = NULL;
|
|
pStr->m_szText = NULL;
|
|
pStr->m_pNext = NULL;
|
|
|
|
pAttr = (t_structXMLAttr*)pAttrs;
|
|
do {
|
|
attrSetStr(pAttr, "lang", &(pStr->m_szLang));
|
|
} while ((pAttr = pAttr->m_pNext));
|
|
}
|
|
|
|
return pStr;
|
|
}
|
|
|
|
int freeI18NStr(t_structI18NStr** ppStr)
|
|
{
|
|
if (*ppStr) {
|
|
freeStr(&((*ppStr)->m_szLang));
|
|
freeStr(&((*ppStr)->m_szText));
|
|
freeI18NStr(&((*ppStr)->m_pNext));
|
|
free(*ppStr);
|
|
}
|
|
*ppStr = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
t_structI18NStr* addI18NStr(const t_structXMLAttr* pAttrs,
|
|
t_structI18NStr** ppStr)
|
|
{
|
|
t_structI18NStr* pStr = NULL;
|
|
|
|
if ((pStr = getLastI18NStr(*ppStr)))
|
|
pStr = (pStr->m_pNext = newI18NStr(pAttrs));
|
|
else
|
|
pStr = (*ppStr = newI18NStr(pAttrs));
|
|
|
|
return pStr;
|
|
}
|
|
|
|
t_structI18NStr* getLastI18NStr(t_structI18NStr* pStr)
|
|
{
|
|
while (pStr && (pStr->m_pNext))
|
|
pStr = pStr->m_pNext;
|
|
|
|
return pStr;
|
|
}
|
|
|
|
t_structXMLPackage* newXMLPackage(const t_structXMLAttr* pAttrs)
|
|
{
|
|
t_structXMLPackage* pPackage = NULL;
|
|
t_structXMLAttr* pAttr = NULL;
|
|
|
|
if ((pPackage = malloc(sizeof(t_structXMLPackage)))) {
|
|
pPackage->m_szName = NULL;
|
|
pPackage->m_szVersion = NULL;
|
|
pPackage->m_szGroup = NULL;
|
|
pPackage->m_szSummary = NULL;
|
|
pPackage->m_szDescription = NULL;
|
|
pPackage->m_pPre = NULL;
|
|
pPackage->m_pPost = NULL;
|
|
pPackage->m_pPreUn = NULL;
|
|
pPackage->m_pPostUn = NULL;
|
|
pPackage->m_pVerify = NULL;
|
|
pPackage->m_nAutoRequire = 1;
|
|
pPackage->m_nAutoProvide = 1;
|
|
pPackage->m_nAutoSuggest = 0;
|
|
pPackage->m_pFiles = NULL;
|
|
pPackage->m_pRequires = NULL;
|
|
pPackage->m_pSuggests = NULL;
|
|
pPackage->m_pObsoletes = NULL;
|
|
pPackage->m_pConflicts = NULL;
|
|
pPackage->m_pProvides = NULL;
|
|
pPackage->m_pNext = NULL;
|
|
|
|
pAttr = (t_structXMLAttr*)pAttrs;
|
|
do {
|
|
attrSetStr(pAttr, "name", &(pPackage->m_szName));
|
|
attrSetStr(pAttr, "version", &(pPackage->m_szVersion));
|
|
attrSetStr(pAttr, "group", &(pPackage->m_szGroup));
|
|
attrSetBool(pAttr, "autorequire", &(pPackage->m_nAutoRequire));
|
|
attrSetBool(pAttr, "autoreq", &(pPackage->m_nAutoRequire));
|
|
attrSetBool(pAttr, "autoprovide", &(pPackage->m_nAutoProvide));
|
|
attrSetBool(pAttr, "autoprov", &(pPackage->m_nAutoProvide));
|
|
attrSetBool(pAttr, "autoreqprov", &(pPackage->m_nAutoProvide));
|
|
attrSetBool(pAttr, "autoreqprov", &(pPackage->m_nAutoRequire));
|
|
attrSetBool(pAttr, "autosuggest", &(pPackage->m_nAutoSuggest));
|
|
} while ((pAttr = pAttr->m_pNext));
|
|
}
|
|
|
|
return pPackage;
|
|
}
|
|
|
|
int freeXMLPackage(t_structXMLPackage** ppPackage)
|
|
{
|
|
if (*ppPackage) {
|
|
freeStr(&((*ppPackage)->m_szName));
|
|
freeStr(&((*ppPackage)->m_szVersion));
|
|
freeStr(&((*ppPackage)->m_szGroup));
|
|
freeStr(&((*ppPackage)->m_szSummary));
|
|
freeStr(&((*ppPackage)->m_szDescription));
|
|
freeXMLFiles(&((*ppPackage)->m_pFiles));
|
|
freeXMLScripts(&((*ppPackage)->m_pPre));
|
|
freeXMLScripts(&((*ppPackage)->m_pPost));
|
|
freeXMLScripts(&((*ppPackage)->m_pPreUn));
|
|
freeXMLScripts(&((*ppPackage)->m_pPostUn));
|
|
freeXMLScripts(&((*ppPackage)->m_pVerify));
|
|
freeXMLRequire(&((*ppPackage)->m_pRequires));
|
|
freeXMLRequire(&((*ppPackage)->m_pSuggests));
|
|
freeXMLRequire(&((*ppPackage)->m_pObsoletes));
|
|
freeXMLRequire(&((*ppPackage)->m_pConflicts));
|
|
freeXMLRequire(&((*ppPackage)->m_pProvides));
|
|
freeXMLPackage(&((*ppPackage)->m_pNext));
|
|
free(*ppPackage);
|
|
}
|
|
*ppPackage = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
t_structXMLPackage* addXMLPackage(const t_structXMLAttr* pAttrs,
|
|
t_structXMLPackage** ppPackage)
|
|
{
|
|
t_structXMLPackage* pPackage = NULL;
|
|
|
|
if ((pPackage = getLastXMLPackage(*ppPackage)))
|
|
pPackage = (pPackage->m_pNext = newXMLPackage(pAttrs));
|
|
else
|
|
pPackage = (*ppPackage = newXMLPackage(pAttrs));
|
|
|
|
return pPackage;
|
|
}
|
|
|
|
t_structXMLPackage* getLastXMLPackage(t_structXMLPackage* pPackage)
|
|
{
|
|
while (pPackage && (pPackage->m_pNext))
|
|
pPackage = pPackage->m_pNext;
|
|
|
|
return pPackage;
|
|
}
|
|
|
|
t_structXMLChange* newXMLChange(const t_structXMLAttr* pAttrs)
|
|
{
|
|
t_structXMLChange* pChange = NULL;
|
|
|
|
if ((pChange = malloc(sizeof(t_structXMLChange)))) {
|
|
pChange->m_szValue = NULL;
|
|
pChange->m_pNext = NULL;
|
|
}
|
|
|
|
return pChange;
|
|
}
|
|
|
|
int freeXMLChange(t_structXMLChange** ppChange)
|
|
{
|
|
if (*ppChange) {
|
|
freeStr(&((*ppChange)->m_szValue));
|
|
freeXMLChange(&((*ppChange)->m_pNext));
|
|
free(*ppChange);
|
|
}
|
|
*ppChange = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
t_structXMLChange* addXMLChange(const t_structXMLAttr* pAttrs,
|
|
t_structXMLChange** ppChange)
|
|
{
|
|
t_structXMLChange* pChange = NULL;
|
|
|
|
if ((pChange = getLastXMLChange(*ppChange)))
|
|
pChange = (pChange->m_pNext = newXMLChange(pAttrs));
|
|
else
|
|
pChange = (*ppChange = newXMLChange(pAttrs));
|
|
return pChange;
|
|
}
|
|
|
|
t_structXMLChange* getLastXMLChange(t_structXMLChange* pChange)
|
|
{
|
|
while (pChange && (pChange->m_pNext))
|
|
pChange = pChange->m_pNext;
|
|
|
|
return pChange;
|
|
}
|
|
|
|
t_structXMLChanges* newXMLChanges(const t_structXMLAttr* pAttrs)
|
|
{
|
|
t_structXMLChanges* pChanges = NULL;
|
|
t_structXMLAttr* pAttr = NULL;
|
|
|
|
if ((pChanges = malloc(sizeof(t_structXMLChanges)))) {
|
|
pChanges->m_szDate = NULL;
|
|
pChanges->m_szVersion = NULL;
|
|
pChanges->m_szAuthor = NULL;
|
|
pChanges->m_szAuthorEmail = NULL;
|
|
pChanges->m_pChanges = NULL;
|
|
pChanges->m_pNext = NULL;
|
|
|
|
pAttr = (t_structXMLAttr*)pAttrs;
|
|
do {
|
|
attrSetStr(pAttr, "date", &(pChanges->m_szDate));
|
|
attrSetStr(pAttr, "version", &(pChanges->m_szVersion));
|
|
attrSetStr(pAttr, "author", &(pChanges->m_szAuthor));
|
|
attrSetStr(pAttr, "author-email", &(pChanges->m_szAuthorEmail));
|
|
} while ((pAttr = pAttr->m_pNext));
|
|
}
|
|
|
|
return pChanges;
|
|
}
|
|
|
|
int freeXMLChanges(t_structXMLChanges** ppChanges)
|
|
{
|
|
if (*ppChanges) {
|
|
freeStr(&((*ppChanges)->m_szDate));
|
|
freeStr(&((*ppChanges)->m_szVersion));
|
|
freeStr(&((*ppChanges)->m_szAuthor));
|
|
freeStr(&((*ppChanges)->m_szAuthorEmail));
|
|
freeXMLChanges(&((*ppChanges)->m_pNext));
|
|
free(*ppChanges);
|
|
}
|
|
*ppChanges = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
t_structXMLChanges* addXMLChanges(const t_structXMLAttr* pAttrs,
|
|
t_structXMLChanges** ppChanges)
|
|
{
|
|
t_structXMLChanges* pChanges = NULL;
|
|
|
|
if ((pChanges = getLastXMLChanges(*ppChanges)))
|
|
pChanges = (pChanges->m_pNext = newXMLChanges(pAttrs));
|
|
else
|
|
pChanges = (*ppChanges = newXMLChanges(pAttrs));
|
|
|
|
return pChanges;
|
|
}
|
|
|
|
t_structXMLChanges* getLastXMLChanges(t_structXMLChanges* pChanges)
|
|
{
|
|
while (pChanges && (pChanges->m_pNext))
|
|
pChanges = pChanges->m_pNext;
|
|
|
|
return pChanges;
|
|
}
|
|
|
|
t_structXMLSpec* newXMLSpec(const t_structXMLAttr* pAttrs,
|
|
const char* szXMLFile)
|
|
{
|
|
t_structXMLSpec* pSpec = NULL;
|
|
t_structXMLAttr* pAttr = NULL;
|
|
char* szTmp = NULL;
|
|
int nLen;
|
|
|
|
if ((pSpec = malloc(sizeof(t_structXMLSpec)))) {
|
|
pSpec->m_szSpecName = NULL;
|
|
pSpec->m_szBuildRootDir = NULL;
|
|
pSpec->m_szBuildSubdir = NULL;
|
|
pSpec->m_szRootDir = NULL;
|
|
pSpec->m_szName = NULL;
|
|
pSpec->m_szVersion = NULL;
|
|
pSpec->m_szRelease = NULL;
|
|
pSpec->m_szEpoch = NULL;
|
|
pSpec->m_szDistribution = NULL;
|
|
pSpec->m_szVendor = NULL;
|
|
pSpec->m_szPackager = NULL;
|
|
pSpec->m_szPackagerEmail = NULL;
|
|
pSpec->m_szCopyright = NULL;
|
|
pSpec->m_szURL = NULL;
|
|
pSpec->m_pBuildRequires = NULL;
|
|
pSpec->m_pBuildConflicts = NULL;
|
|
pSpec->m_pBuildSuggests = NULL;
|
|
pSpec->m_pPrep = NULL;
|
|
pSpec->m_pBuild = NULL;
|
|
pSpec->m_pInstall = NULL;
|
|
pSpec->m_pClean = NULL;
|
|
pSpec->m_pMacros = NULL;
|
|
pSpec->m_pSources = NULL;
|
|
pSpec->m_pPatches = NULL;
|
|
pSpec->m_pPackages = NULL;
|
|
pSpec->m_pChangelog = NULL;
|
|
g_pSpec = newSpec();
|
|
|
|
pAttr = (t_structXMLAttr*)pAttrs;
|
|
do {
|
|
attrSetStr(pAttr, "name", &(pSpec->m_szName));
|
|
attrSetStr(pAttr, "version", &(pSpec->m_szVersion));
|
|
attrSetStr(pAttr, "release", &(pSpec->m_szRelease));
|
|
attrSetStr(pAttr, "epoch", &(pSpec->m_szEpoch));
|
|
attrSetStr(pAttr, "distribution", &(pSpec->m_szDistribution));
|
|
attrSetStr(pAttr, "vendor", &(pSpec->m_szVendor));
|
|
attrSetStr(pAttr, "packager", &(pSpec->m_szPackager));
|
|
attrSetStr(pAttr, "packager-email", &(pSpec->m_szPackagerEmail));
|
|
attrSetStr(pAttr, "copyright", &(pSpec->m_szCopyright));
|
|
attrSetStr(pAttr, "url", &(pSpec->m_szURL));
|
|
attrSetStr(pAttr, "buildroot", &(pSpec->m_szBuildRootDir));
|
|
attrSetStr(pAttr, "builddir", &(pSpec->m_szBuildSubdir));
|
|
} while ((pAttr = pAttr->m_pNext));
|
|
|
|
addMacro(NULL, "_docdir", NULL, "%{_defaultdocdir}", RMIL_SPEC);
|
|
szTmp = (char*)rpmGetPath(szXMLFile, NULL);
|
|
newStr(szTmp, &(pSpec->m_szSpecName));
|
|
free(szTmp);
|
|
if ((szTmp = rindex(pSpec->m_szSpecName, '/'))) {
|
|
szTmp++;
|
|
nLen = szTmp-(pSpec->m_szSpecName);
|
|
g_szSpecPath = malloc(nLen+1);
|
|
snprintf(g_szSpecPath, nLen, "%s", pSpec->m_szSpecName);
|
|
}
|
|
szTmp = malloc(4097);
|
|
if (pSpec->m_szBuildRootDir == NULL) {
|
|
snprintf(szTmp, 4096, "%%{_tmppath}/rpmxml-%s-%s", pSpec->m_szName,
|
|
pSpec->m_szVersion);
|
|
newStrEx(szTmp, &(pSpec->m_szBuildRootDir));
|
|
}
|
|
if (pSpec->m_szBuildSubdir == NULL) {
|
|
snprintf(szTmp, 4096, "%s-%s", pSpec->m_szName,
|
|
pSpec->m_szVersion);
|
|
newStrEx(szTmp, &(pSpec->m_szBuildSubdir));
|
|
}
|
|
free(szTmp);
|
|
if (pSpec->m_szRootDir == NULL)
|
|
newStrEx("/", &(pSpec->m_szRootDir));
|
|
addMacroEx("name", (char**)&(pSpec->m_szName), RMIL_SPEC);
|
|
addMacroEx("version", (char**)&(pSpec->m_szVersion), RMIL_SPEC);
|
|
addMacroEx("PACKAGE_VERSION", (char**)&(pSpec->m_szVersion), -1);
|
|
addMacroEx("release", (char**)&(pSpec->m_szRelease), RMIL_SPEC);
|
|
addMacroEx("PACKAGE_RELEASE", (char**)&(pSpec->m_szRelease), -2);
|
|
addMacroEx("copyright", (char**)&(pSpec->m_szCopyright), RMIL_SPEC);
|
|
addMacroEx("url", (char**)&(pSpec->m_szURL), RMIL_SPEC);
|
|
addMacroEx("distribution", (char**)&(pSpec->m_szDistribution), RMIL_SPEC);
|
|
addMacroEx("vendor", (char**)&(pSpec->m_szVendor), RMIL_SPEC);
|
|
addMacroEx("buildroot", (char**)&(pSpec->m_szBuildRootDir), RMIL_SPEC);
|
|
addMacroEx("buildsubdir", (char**)&(pSpec->m_szBuildSubdir), RMIL_SPEC);
|
|
if (pSpec->m_szPackagerEmail || pSpec->m_szPackager) {
|
|
szTmp = malloc(strlen(pSpec->m_szPackager)+strlen(pSpec->m_szPackagerEmail)+4);
|
|
if (pSpec->m_szPackagerEmail && pSpec->m_szPackager)
|
|
sprintf(szTmp, "%s <%s>", pSpec->m_szPackager, pSpec->m_szPackagerEmail);
|
|
else
|
|
sprintf(szTmp, "%s", pSpec->m_szPackager ? pSpec->m_szPackager : pSpec->m_szPackagerEmail);
|
|
addMacroEx("packager", (char**)&(szTmp), RMIL_SPEC);
|
|
free(szTmp);
|
|
}
|
|
}
|
|
|
|
return pSpec;
|
|
}
|
|
|
|
int freeXMLSpec(t_structXMLSpec** ppSpec)
|
|
{
|
|
if (*ppSpec) {
|
|
freeStr(&((*ppSpec)->m_szSpecName));
|
|
freeStr(&((*ppSpec)->m_szBuildRootDir));
|
|
freeStr(&((*ppSpec)->m_szBuildSubdir));
|
|
freeStr(&((*ppSpec)->m_szRootDir));
|
|
freeStr(&((*ppSpec)->m_szName));
|
|
freeStr(&((*ppSpec)->m_szVersion));
|
|
freeStr(&((*ppSpec)->m_szRelease));
|
|
freeStr(&((*ppSpec)->m_szEpoch));
|
|
freeStr(&((*ppSpec)->m_szDistribution));
|
|
freeStr(&((*ppSpec)->m_szVendor));
|
|
freeStr(&((*ppSpec)->m_szPackager));
|
|
freeStr(&((*ppSpec)->m_szPackagerEmail));
|
|
freeStr(&((*ppSpec)->m_szCopyright));
|
|
freeStr(&((*ppSpec)->m_szURL));
|
|
freeXMLRequire(&((*ppSpec)->m_pBuildRequires));
|
|
freeXMLRequire(&((*ppSpec)->m_pBuildConflicts));
|
|
freeXMLRequire(&((*ppSpec)->m_pBuildSuggests));
|
|
freeXMLScripts(&((*ppSpec)->m_pPrep));
|
|
freeXMLScripts(&((*ppSpec)->m_pBuild));
|
|
freeXMLScripts(&((*ppSpec)->m_pInstall));
|
|
freeXMLScripts(&((*ppSpec)->m_pClean));
|
|
freeXMLMacro(&((*ppSpec)->m_pMacros));
|
|
freeXMLSource(&((*ppSpec)->m_pSources));
|
|
freeXMLSource(&((*ppSpec)->m_pPatches));
|
|
freeXMLPackage(&((*ppSpec)->m_pPackages));
|
|
freeXMLChanges(&((*ppSpec)->m_pChangelog));
|
|
if (g_pSpec)
|
|
freeSpec(g_pSpec);
|
|
g_pSpec = NULL;
|
|
if (g_szSpecPath)
|
|
freeStr(&g_szSpecPath);
|
|
free(*ppSpec);
|
|
}
|
|
*ppSpec = NULL;
|
|
|
|
return 0;
|
|
}
|