folkslinux
/
rpm
mirror of https://github.com/rpm-software-management/rpm.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
rpm/xmlspec/xml2rpm.c

583 lines
20 KiB
C
Raw Blame History

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "stringbuf.h"
#include "rpmbuild.h"
#include "xml2rpm.h"
#include "xmlstruct.h"
#ifdef XML_DEBUG
#include "header_internal.h"
#endif
// This is where our packaged scripts start (or the largest number
// of the sources)
int g_nMaxSourceNum = 511;
static struct ReqComp {
const char* m_szCmp;
rpmsenseFlags m_rpmCmp;
} sReqComp[] = {
{"le", RPMSENSE_LESS | RPMSENSE_EQUAL },
{"lt", RPMSENSE_LESS },
{"eq", RPMSENSE_EQUAL },
{"ge", RPMSENSE_GREATER | RPMSENSE_EQUAL},
{"gt", RPMSENSE_GREATER },
{NULL, 0 }
};
Spec g_pSpec = NULL;
const char* g_szDefLang = "C";
#ifdef XML_DEBUG
void printSourceInfo(struct Source* pSource)
{
if (pSource) {
printf("D: Source (%08x){\n", (unsigned int)pSource);
printf("D: Source->fullSource (%08x): {%s}\n", (unsigned int)(pSource->fullSource), pSource->fullSource);
printf("D: Source->source (%08x): {%s}\n", (unsigned int)(pSource->source), pSource->source);
printf("D: Source->flags : {%08x}\n", pSource->flags);
printf("D: Source->num : {%d}\n", pSource->num);
printf("D: }\n");
}
}
#endif
#ifdef XML_DEBUG
void printHeaderInfo(Header pHeader)
{
int i = 0;
int j = 0;
int nVal = 0;
indexEntry pIdx;
const struct headerTagTableEntry_s* pEntry;
char* pData;
int nCnt;
char szType[20];
if (pHeader) {
printf("D: Header->indexUsed : {%d}\n", pHeader->indexUsed);
printf("D: Header->indexAlloced : {%d}\n", pHeader->indexAlloced);
printf("D: Header->flags : {%d}\n", pHeader->flags);
printf("D: Header->nrefs : {%d}\n", pHeader->nrefs);
printf("D: Header->hv {\n");
printf("D: HV.hdrvecs : {%08x}\n", (unsigned int)(pHeader->hv.hdrvecs));
printf("D: HV.hdrdata : {%08x}\n", (unsigned int)(pHeader->hv.hdrdata));
printf("D: HV.hdrversion : {%d}\n", pHeader->hv.hdrversion);
printf("D: }\n");
printf("D: Header->blob (%08x): {\n", (unsigned int)(pHeader->blob));
pIdx = pHeader->index;
for (i = 0; i < pHeader->indexUsed; i++, pIdx++) {
pEntry = rpmTagTable;
while (pEntry->name && pEntry->val != pIdx->info.tag)
pEntry++;
nCnt = pIdx->info.count;
pData = pIdx->data;
switch (pIdx->info.type) {
case RPM_STRING_TYPE: sprintf(szType, "STRING"); break;
case RPM_STRING_ARRAY_TYPE: sprintf(szType, "STRING_ARRAY"); break;
case RPM_I18NSTRING_TYPE: sprintf(szType, "STRING_I18N"); break;
case RPM_CHAR_TYPE: sprintf(szType, "CHAR"); break;
case RPM_INT8_TYPE: sprintf(szType, "INT8"); break;
case RPM_INT16_TYPE: sprintf(szType, "INT16"); break;
case RPM_INT32_TYPE: sprintf(szType, "INT32"); break;
default: sprintf(szType, "OTHER"); break;
}
printf("D: %02d %s(%02d) %s\n", i, pEntry->name, nCnt, szType);
switch (pIdx->info.type) {
case RPM_STRING_TYPE:
case RPM_STRING_ARRAY_TYPE:
case RPM_I18NSTRING_TYPE:
for (j = 0; j < nCnt; j++) {
if (strlen(pData))
printf("D: %02d {%s}\n", j, pData);
pData = strchr(pData, 0);
pData++;
}
break;
case RPM_CHAR_TYPE:
case RPM_INT8_TYPE:
case RPM_INT16_TYPE:
case RPM_INT32_TYPE:
for (j = 0; j < nCnt; j++) {
switch (pIdx->info.type) {
case RPM_CHAR_TYPE:
case RPM_INT8_TYPE:
nVal = *(((int_8*)pData)+j);
break;
case RPM_INT16_TYPE:
nVal = *(((uint_16*)pData)+j);
break;
case RPM_INT32_TYPE:
default:
nVal = *(((int_32*)pData)+j);
break;
}
printf("D: %02d {%08x}\n", j, nVal);
}
break;
default:
break;
}
}
printf("D: }\n");
}
}
#endif
#ifdef XML_DEBUG
void printMacroInfo(MacroContext pMacro)
{
int i = 0;
MacroEntry pEntry = NULL;
if (pMacro) {
for (i = 0; i < pMacro->firstFree; i++) {
if ((pEntry = pMacro->macroTable[i]) &&
(pEntry->level >= RMIL_SPEC)) {
printf("D: %03d % 3d %s", i, pEntry->level,
pEntry->name);
if ((pEntry->opts) &&
(*pEntry->opts))
printf("(%s)", pEntry->opts);
printf("\n");
if ((pEntry->level >= RMIL_SPEC) &&
(pEntry->body) &&
(*pEntry->body))
printf("D: {%s}\n", pEntry->body);
}
}
}
}
#endif
#ifdef XML_DEBUG
void printSpecInfo(Spec pSpec)
{
struct Source* pSource = NULL;
struct PackageStruct* pPackage = NULL;
printf("D: Spec(%08x) {\n", (unsigned int)pSpec);
if (pSpec) {
printf("D: Spec->specfile (%08x): {%s}\n", (unsigned int)(pSpec->specFile), pSpec->specFile);
printf("D: Spec->sourceRpmName (%08x): {%s}\n", (unsigned int)(pSpec->sourceRpmName), pSpec->sourceRpmName);
printf("D: Spec->buildRootURL (%08x): {%s}\n", (unsigned int)(pSpec->buildRootURL), pSpec->buildRootURL);
printf("D: Spec->buildSubdir (%08x): {%s}\n", (unsigned int)(pSpec->buildSubdir), pSpec->buildSubdir);
printf("D: Spec->rootURL (%08x): {%s}\n", (unsigned int)(pSpec->rootURL), pSpec->rootURL);
printf("D: Spec->BACount : {%d}\n", pSpec->BACount);
printf("D: Spec->recursing : {%d}\n", pSpec->recursing);
printf("D: Spec->force : {%d}\n", pSpec->force);
printf("D: Spec->anyarch : {%d}\n", pSpec->anyarch);
printf("D: Spec->gotBuildRootURL : {%d}\n", pSpec->gotBuildRootURL);
printf("D: Spec->timeCheck : {%d}\n", pSpec->timeCheck);
printf("D: Spec->passPhrase (%08x): {%s}\n", (unsigned int)(pSpec->passPhrase), pSpec->passPhrase);
printf("D: Spec->cookie (%08x): {%s}\n", (unsigned int)(pSpec->cookie), pSpec->cookie);
printf("D: Spec->numSources : {%d}\n", pSpec->numSources);
printf("D: Spec->noSource : {%d}\n", pSpec->noSource);
printf("D: Spec->sources : (%08x)\n", (unsigned int)(pSpec->sources));
pSource = pSpec->sources;
while (pSource) {
printSourceInfo(pSource);
pSource = pSource->next;
}
printf("D: Spec->buildRestrictions (%08x){\n", (unsigned int)(pSpec->buildRestrictions));
printHeaderInfo(pSpec->buildRestrictions);
printf("D: }\n");
printf("D: Spec->sourceHeader (%08x){\n", (unsigned int)(pSpec->sourceHeader));
printHeaderInfo(pSpec->sourceHeader);
printf("D: }\n");
printf("D: Spec->packages : {%08x}\n", (unsigned int)(pSpec->packages));
pPackage = pSpec->packages;
while (pPackage) {
printf("D: Package(%08x) {\n", (unsigned int)pPackage);
printf("D: Package->cpioList : {%08x}\n", (unsigned int)(pPackage->cpioList));
printf("D: Package->icon : {%08x}\n", (unsigned int)(pPackage->icon));
printf("D: Package->autoReq : {%d}\n", pPackage->autoReq);
printf("D: Package->autoProv : {%d}\n", pPackage->autoProv);
printf("D: Package->preInFile (%08x): {%s}\n", (unsigned int)(pPackage->preInFile), pPackage->preInFile);
printf("D: Package->postInFile (%08x): {%s}\n", (unsigned int)(pPackage->postInFile), pPackage->postInFile);
printf("D: Package->preUnFile (%08x): {%s}\n", (unsigned int)(pPackage->preUnFile), pPackage->preUnFile);
printf("D: Package->postUnFile (%08x): {%s}\n", (unsigned int)(pPackage->postUnFile), pPackage->postUnFile);
printf("D: Package->triggerFiles : {%08x}\n", (unsigned int)(pPackage->triggerFiles));
printf("D: Package->fileFile (%08x): {%s}\n", (unsigned int)(pPackage->fileFile), pPackage->fileFile);
printf("D: Package->fileFile (%08x): {%s}\n", (unsigned int)(pPackage->fileList), pPackage->fileList ? getStringBuf(pPackage->fileList) : NULL);
printf("D: Package->header (%08x){\n", (unsigned int)(pPackage->header));
printHeaderInfo(pPackage->header);
printf("D: }\n");
pPackage = pPackage->next;
printf("D: }\n");
}
printf("D: Spec->macros (%08x){\n", (unsigned int)(pSpec->macros));
printMacroInfo(pSpec->macros);
printf("D: }\n");
printf("D: Spec->prep (%08x): {%s}\n", (unsigned int)(pSpec->prep), pSpec->prep ? getStringBuf(pSpec->prep) : NULL);
printf("D: Spec->build (%08x): {%s}\n", (unsigned int)(pSpec->build), pSpec->build ? getStringBuf(pSpec->build) : NULL);
printf("D: Spec->install (%08x): {%s}\n", (unsigned int)(pSpec->install), pSpec->install ? getStringBuf(pSpec->install) : NULL);
printf("D: Spec->clean (%08x): {%s}\n", (unsigned int)(pSpec->clean), pSpec->clean ? getStringBuf(pSpec->clean) : NULL);
}
printf("D: }\n");
}
#endif
void createRPMSource(const char* szName, int nNum,
Spec pSpec, int nType)
{
struct Source* pSrc = NULL;
struct Source* pPrev = NULL;
char szTmpName[20];
char szPre[3];
char szType[7];
if (!szName || !pSpec)
return;
if ((nType & RPMBUILD_ISNO) == RPMBUILD_ISNO) {
pSpec->noSource++;
sprintf(szPre, "NO");
}
else {
pSpec->numSources++;
szPre[0] = '\0';
}
pSrc = malloc(sizeof(struct Source));
pSrc->fullSource = NULL;
newStrEx(szName, &(pSrc->fullSource));
if (!(pSrc->source = strrchr(pSrc->fullSource, '/')))
pSrc->source = pSrc->fullSource;
else
pSrc->source++;
pSrc->num = nNum;
pSrc->flags = nType;
pSrc->next = NULL;
if ((pPrev = pSpec->sources)) {
while (pPrev->next)
pPrev = pPrev->next;
pPrev->next = pSrc;
}
else
pSpec->sources = pSrc;
if ((nType & RPMBUILD_ISSOURCE) == RPMBUILD_ISSOURCE)
sprintf(szType, "SOURCE");
else
sprintf(szType, "PATCH");
sprintf(szTmpName, "%s%s%d", szPre, szType, nNum);
addMacro(pSpec->macros, szTmpName, NULL, pSrc->fullSource, RMIL_SPEC);
sprintf(szTmpName, "%s%sURL%d", szPre, szType, nNum);
addMacro(pSpec->macros, szTmpName, NULL, pSrc->source, RMIL_SPEC);
if (nNum > g_nMaxSourceNum)
g_nMaxSourceNum = nNum;
}
void convertXMLSource(const t_structXMLSource* pXMLSrc,
Spec pSpec, int nType)
{
if (!pXMLSrc || !pSpec)
return;
createRPMSource(pXMLSrc->m_szName, pXMLSrc->m_nNum, pSpec, nType);
convertXMLSource(pXMLSrc->m_pNext, pSpec, nType);
}
StringBuf scriptsToStringBuf(const t_structXMLScripts* pScripts,
Spec pSpec)
{
StringBuf pSb = NULL;
t_structXMLScript* pScript = NULL;
char* szTmp = NULL;
if (pScripts) {
pSb = newStringBuf();
if ((pScripts->m_szScript) &&
(szTmp = fileToStr(pScripts->m_szScript, NULL))) {
appendLineStringBuf(pSb, szTmp);
freeStr(&(szTmp));
createRPMSource(pScripts->m_szScript, g_nMaxSourceNum+1,
pSpec, RPMBUILD_ISSOURCE);
}
pScript = pScripts->m_pScripts;
while (pScript) {
if ((pScript->m_szScript) &&
(szTmp = fileToStr(pScript->m_szScript, NULL))) {
appendLineStringBuf(pSb, szTmp);
freeStr(&(szTmp));
createRPMSource(pScript->m_szScript, g_nMaxSourceNum+1,
pSpec, RPMBUILD_ISSOURCE);
}
if (pScript->m_szEntry) {
// we do a newStrEx to make sure we expand all
// macros, as is done in the case of the files
// (done as part of the fileToStr call)
newStrEx(pScript->m_szEntry, (char**)(&szTmp));
appendLineStringBuf(pSb, szTmp);
freeStr(&(szTmp));
}
pScript = pScript->m_pNext;
}
}
return pSb;
}
void convertXMLScripts(const t_structXMLScripts* pScripts,
struct PackageStruct* pPkg,
Spec pSpec,
int nScript, int nInterpreter)
{
StringBuf pSb = NULL;
if (!pScripts || !pPkg)
return;
if ((pSb = scriptsToStringBuf(pScripts, pSpec))) {
headerAddEntry(pPkg->header,
nScript, RPM_STRING_TYPE,
getStringBuf(pSb), 1);
freeStringBuf(pSb);
}
if (pScripts->m_szInterpreter)
headerAddEntry(pPkg->header,
nInterpreter, RPM_STRING_TYPE,
pScripts->m_szInterpreter, 1);
}
void handleProvObsConf(Header pHeader, t_structXMLRequire* pReqs, rpmsenseFlags fSense)
{
t_structXMLRequire* pReq = NULL;
int nFlags = 0;
int i = 0;
int nIndex = 0;
pReq = pReqs;
while (pReq) {
if (pReq->m_szName) {
nFlags = 0;
if (pReq->m_szCompare && pReq->m_szVersion) {
for (i = 0; sReqComp[i].m_szCmp; i++) {
if (!strcasecmp(sReqComp[i].m_szCmp,
pReq->m_szCompare)) {
nFlags = (sReqComp[i].m_rpmCmp | RPMSENSE_ANY) & ~RPMSENSE_SENSEMASK;
}
}
}
addReqProv(NULL, pHeader, fSense | nFlags,
pReq->m_szName, pReq->m_szVersion, nIndex++);
}
pReq = pReq->m_pNext;
}
}
void convertXMLPackage(const t_structXMLPackage* pXMLPkg,
const t_structXMLSpec* pXMLSpec,
Spec pSpec)
{
struct PackageStruct* pPkg = NULL;
char* szPlatform = NULL;
char* szArch = NULL;
char* szOs = NULL;
char* szTmp = NULL;
if (!pXMLPkg || !pSpec)
return;
pPkg = newPackage(pSpec);
pPkg->autoReq = pXMLPkg->m_nAutoRequire;
pPkg->autoProv = pXMLPkg->m_nAutoProvide;
pPkg->header = headerNew();
szPlatform = rpmExpand("%{_target_platform}", NULL);
szArch = rpmExpand("%{_target_cpu}", NULL);
szOs = rpmExpand("%{_target_os}", NULL);
headerAddOrAppendEntry(pPkg->header, RPMTAG_OS, RPM_STRING_TYPE, szOs, 1);
headerAddOrAppendEntry(pPkg->header, RPMTAG_ARCH, RPM_STRING_TYPE, szArch, 1);
headerAddOrAppendEntry(pPkg->header, RPMTAG_RHNPLATFORM, RPM_STRING_TYPE, szArch, 1);
headerAddOrAppendEntry(pPkg->header, RPMTAG_PLATFORM, RPM_STRING_TYPE, szPlatform, 1);
_free(szPlatform);
_free(szArch);
_free(szOs);
// do the provides, obsoletes, conflicts
handleProvObsConf(pPkg->header, pXMLPkg->m_pProvides, RPMSENSE_PROVIDES);
handleProvObsConf(pPkg->header, pXMLPkg->m_pObsoletes, RPMSENSE_OBSOLETES);
handleProvObsConf(pPkg->header, pXMLPkg->m_pConflicts, RPMSENSE_CONFLICTS);
if (pXMLPkg->m_szName)
headerAddOrAppendEntry(pPkg->header, RPMTAG_NAME,
RPM_STRING_TYPE, pXMLPkg->m_szName, 1);
else
headerAddOrAppendEntry(pPkg->header, RPMTAG_NAME,
RPM_STRING_TYPE, pXMLSpec->m_szName, 1);
headerAddOrAppendEntry(pPkg->header, RPMTAG_VERSION,
RPM_STRING_TYPE, pXMLSpec->m_szVersion, 1);
headerAddOrAppendEntry(pPkg->header, RPMTAG_RELEASE,
RPM_STRING_TYPE, pXMLSpec->m_szRelease, 1);
headerAddOrAppendEntry(pPkg->header, RPMTAG_GROUP,
RPM_STRING_TYPE, pXMLPkg->m_szGroup, 1);
headerAddOrAppendEntry(pPkg->header, RPMTAG_RELEASE,
RPM_STRING_TYPE, pXMLSpec->m_szRelease, 1);
headerAddOrAppendEntry(pPkg->header, RPMTAG_LICENSE,
RPM_STRING_TYPE, pXMLSpec->m_szCopyright, 1);
headerAddOrAppendEntry(pPkg->header, RPMTAG_URL,
RPM_STRING_TYPE, pXMLSpec->m_szURL, 1);
headerAddOrAppendEntry(pPkg->header, RPMTAG_DISTRIBUTION,
RPM_STRING_TYPE, pXMLSpec->m_szDistribution, 1);
headerAddOrAppendEntry(pPkg->header, RPMTAG_VENDOR,
RPM_STRING_TYPE, pXMLSpec->m_szVendor, 1);
headerAddOrAppendEntry(pPkg->header, HEADER_I18NTABLE,
RPM_STRING_ARRAY_TYPE, &g_szDefLang, 1);
headerAddI18NString(pPkg->header, RPMTAG_SUMMARY,
pXMLPkg->m_szSummary, g_szDefLang);
headerAddI18NString(pPkg->header, RPMTAG_DESCRIPTION,
pXMLPkg->m_szSummary, g_szDefLang);
if (pXMLSpec->m_szPackagerEmail || pXMLSpec->m_szPackager) {
szTmp = malloc(strlen(pXMLSpec->m_szPackager)+strlen(pXMLSpec->m_szPackagerEmail)+4);
if (pXMLSpec->m_szPackagerEmail && pXMLSpec->m_szPackager)
sprintf(szTmp, "%s <%s>", pXMLSpec->m_szPackager,
pXMLSpec->m_szPackagerEmail);
else
sprintf(szTmp, "%s", pXMLSpec->m_szPackager ? pXMLSpec->m_szPackager : pXMLSpec->m_szPackagerEmail);
headerAddOrAppendEntry(pPkg->header, RPMTAG_PACKAGER,
RPM_STRING_TYPE, szTmp, 1);
free(szTmp);
}
if (pXMLPkg->m_pFiles)
pPkg->fileList = fileToStrBuf(pXMLPkg->m_pFiles->m_szFileList, NULL);
convertXMLScripts(pXMLPkg->m_pPre, pPkg, pSpec,
RPMTAG_PREIN, RPMTAG_PREINPROG);
convertXMLScripts(pXMLPkg->m_pPost, pPkg, pSpec,
RPMTAG_POSTIN, RPMTAG_POSTINPROG);
convertXMLScripts(pXMLPkg->m_pPreUn, pPkg, pSpec,
RPMTAG_PREUN, RPMTAG_PREUNPROG);
convertXMLScripts(pXMLPkg->m_pPostUn, pPkg, pSpec,
RPMTAG_POSTUN, RPMTAG_POSTUNPROG);
convertXMLScripts(pXMLPkg->m_pVerify, pPkg, pSpec,
RPMTAG_VERIFYSCRIPT, RPMTAG_VERIFYSCRIPTPROG);
convertXMLPackage(pXMLPkg->m_pNext, pXMLSpec, pSpec);
}
void convertXMLMacro(const t_structXMLMacro* pMacro,
Spec pSpec)
{
if (!pMacro || !pSpec)
return;
addMacroEx(pMacro->m_szName, (char**)&(pMacro->m_szValue), 1);
convertXMLMacro(pMacro->m_pNext, pSpec);
}
void convertXMLBuildRequires(const t_structXMLSpec* pXMLSpec,
Spec pSpec)
{
t_structXMLRequire* pRequire = NULL;
char* szTmp = NULL;
char* szVal = NULL;
int i = 0;
int nFlags = 0;
int nIndex = 0;
char* szVersion = NULL;
pRequire = pXMLSpec->m_pBuildRequires;
szVal = malloc(1);
szVal[0] = '\0';
while (pRequire) {
if (pRequire->m_szName) {
szTmp = malloc(strlen(szVal)+strlen(pRequire->m_szName)+2);
if (strlen(szVal))
sprintf(szTmp, "%s", pRequire->m_szName);
else
sprintf(szTmp, "%s %s", szVal, pRequire->m_szName);
free(szVal);
szVal = szTmp;
}
szVersion = NULL;
nFlags = 0;
if (pRequire->m_szCompare && pRequire->m_szVersion) {
for (i = 0; sReqComp[i].m_szCmp; i++)
if (!strcasecmp(sReqComp[i].m_szCmp, pRequire->m_szCompare)) {
nFlags = (sReqComp[i].m_rpmCmp | RPMSENSE_ANY) & ~RPMSENSE_SENSEMASK;
szVersion = pRequire->m_szVersion;
}
}
addReqProv(pSpec, pSpec->buildRestrictions, nFlags,
pRequire->m_szName, pRequire->m_szVersion, nIndex);
addReqProv(pSpec, pSpec->sourceHeader, nFlags,
pRequire->m_szName, pRequire->m_szVersion, nIndex);
pRequire = pRequire->m_pNext;
nIndex++;
}
if (pXMLSpec->m_szPackagerEmail || pXMLSpec->m_szPackager) {
szTmp = malloc(strlen(pXMLSpec->m_szPackager)+strlen(pXMLSpec->m_szPackagerEmail)+4);
if (pXMLSpec->m_szPackagerEmail && pXMLSpec->m_szPackager)
sprintf(szTmp, "%s <%s>", pXMLSpec->m_szPackager, pXMLSpec->m_szPackagerEmail);
else
sprintf(szTmp, "%s", pXMLSpec->m_szPackager ? pXMLSpec->m_szPackager : pXMLSpec->m_szPackagerEmail);
headerAddOrAppendEntry(pSpec->packages->header, RPMTAG_PACKAGER,
RPM_STRING_TYPE, szTmp, 1);
free(szTmp);
}
free(szVal);
}
Spec toRPMStruct(const t_structXMLSpec* pXMLSpec)
{
Spec pSpec = NULL;
char* szTmp = NULL;
if (!pXMLSpec)
return NULL;
pSpec = g_pSpec;
newStrEx(pXMLSpec->m_szSpecName, (char**)&(pSpec->specFile));
if (pXMLSpec->m_pPackages) {
addMacroEx("group",
(char**)&(pXMLSpec->m_pPackages->m_szGroup), RMIL_SPEC);
addMacroEx("summary",
(char**)&(pXMLSpec->m_pPackages->m_szSummary), RMIL_SPEC);
}
pSpec->gotBuildRootURL = 1;
newStrEx(pXMLSpec->m_szBuildRootDir, (char**)(&(pSpec->buildRootURL)));
newStrEx(pXMLSpec->m_szBuildSubdir, (char**)(&(pSpec->buildSubdir)));
newStrEx(pXMLSpec->m_szRootDir, (char**)(&(pSpec->rootURL)));
convertXMLSource(pXMLSpec->m_pSources, pSpec, RPMBUILD_ISSOURCE);
convertXMLSource(pXMLSpec->m_pPatches, pSpec, RPMBUILD_ISPATCH);
pSpec->prep = scriptsToStringBuf(pXMLSpec->m_pPrep, pSpec);
pSpec->build = scriptsToStringBuf(pXMLSpec->m_pBuild, pSpec);
pSpec->install = scriptsToStringBuf(pXMLSpec->m_pInstall, pSpec);
pSpec->clean = scriptsToStringBuf(pXMLSpec->m_pClean, pSpec);
convertXMLPackage(pXMLSpec->m_pPackages, pXMLSpec, pSpec);
initSourceHeader(pSpec);
if (pXMLSpec->m_szPackagerEmail || pXMLSpec->m_szPackager) {
szTmp = malloc(strlen(pXMLSpec->m_szPackager)+strlen(pXMLSpec->m_szPackagerEmail)+4);
if (pXMLSpec->m_szPackagerEmail && pXMLSpec->m_szPackager)
sprintf(szTmp, "%s <%s>", pXMLSpec->m_szPackager,
pXMLSpec->m_szPackagerEmail);
else
sprintf(szTmp, "%s", pXMLSpec->m_szPackager ? pXMLSpec->m_szPackager : pXMLSpec->m_szPackagerEmail);
headerAddOrAppendEntry(pSpec->sourceHeader, RPMTAG_PACKAGER,
RPM_STRING_TYPE, szTmp, 1);
free(szTmp);
}
pSpec->buildRestrictions = headerNew();
convertXMLBuildRequires(pXMLSpec, pSpec);
#ifdef XML_DEBUG
printSpecInfo(pSpec);
#endif
return pSpec;
}
Reference in New Issue View Git Blame Copy Permalink