From: jbj Date: Mon, 26 Aug 2002 19:11:56 +0000 (+0000) Subject: ... in with the new C implementation. X-Git-Tag: tznext/4.11.0.1.tizen20130304~7216 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=8df2a575d6d514b796bd2c8c7b5ea1fa5147deb1;p=tools%2Flibrpm-tizen.git ... in with the new C implementation. CVS patchset: 5676 CVS date: 2002/08/26 19:11:56 --- diff --git a/xmlspec/Makefile b/xmlspec/Makefile new file mode 100644 index 000000000..cad6f8503 --- /dev/null +++ b/xmlspec/Makefile @@ -0,0 +1,48 @@ +CC = gcc +RANLIB = ranlib +AR = ar +STRIP = strip +ARFLAGS = cr +LDFLAGS = +CFLAGS = -O2 -Wall -Wpointer-arith -Wno-char-subscripts +INCDIR = -I. -I.. -I../build -I../lib -I../misc -I../popt -I../rpmdb -I../rpmio +RPMDIR = .. +DESTDIR = /usr/local + +XMLBUILD = rpmxmlbuild +XMLBUILD_SRC = rpmxmlbuild.c +XMLBUILD_OBJ = $(XMLBUILD_SRC:.c=.o) + +XMLLIB = libxmlrpm.a +XMLLIB_SRC = xml2rpm.c xmlbuild.c xmlmisc.c xmlparse.c xmlstruct.c xmlverify.c +XMLLIB_H = $(XMLLIB_SRC:.c=.h) +XMLLIB_OBJ = $(XMLLIB_SRC:.c=.o) + +LIBS = $(XMLLIB) $(RPMDIR)/build/.libs/librpmbuild.a \ + $(RPMDIR)/lib/.libs/librpm.a $(RPMDIR)/rpmdb/.libs/librpmdb.a \ + $(RPMDIR)/rpmio/.libs/librpmio.a $(RPMDIR)/popt/.libs/libpopt.a \ + -lz -lexpat -lbz2 +LIBDIR = -L. -L$(RPMDIR)/.libs -L/usr/lib + +all: $(XMLLIB) $(XMLBUILD) + +.c.o: + $(CC) $(CFLAGS) $(INCDIR) -c $? + +strip: + $(STRIP) $(XMLBUILD) + +install: + @(cp $(XMLBUILD) $(DESTDIR)/bin) + @(cp $(XMLLIB) $(DESTDIR)/lib) + @(cp $(XMLLIB_H) $(DESTDIR)/include) + +$(XMLLIB): $(XMLLIB_OBJ) + $(AR) $(ARFLAGS) $(XMLLIB) $(XMLLIB_OBJ) + $(RANLIB) $(XMLLIB) + +$(XMLBUILD): $(XMLLIB) $(XMLBUILD_OBJ) + $(CC) $(LDFLAGS) $(CFLAGS) $(INCDIR) -o $(XMLBUILD) $(XMLBUILD_OBJ) $(LIBS) $(LIBDIR) + +clean: + rm -rf $(XMLLIB) $(XMLBUILD) *.o core diff --git a/xmlspec/examples/bash-doc.files.lst b/xmlspec/examples/bash-doc.files.lst new file mode 100644 index 000000000..34d23193d --- /dev/null +++ b/xmlspec/examples/bash-doc.files.lst @@ -0,0 +1,2 @@ +%attr(-,root,root) %{_usr}/man/man1/* +%attr(-,root,root) %{_usr}/info/* diff --git a/xmlspec/examples/bash-doc.pre.sh b/xmlspec/examples/bash-doc.pre.sh new file mode 100644 index 000000000..623d75bd6 --- /dev/null +++ b/xmlspec/examples/bash-doc.pre.sh @@ -0,0 +1,2 @@ +echo "Pre-Installation script" +/usr/sbin/ldconfig diff --git a/xmlspec/examples/bash.build.sh b/xmlspec/examples/bash.build.sh new file mode 100644 index 000000000..ea87ac105 --- /dev/null +++ b/xmlspec/examples/bash.build.sh @@ -0,0 +1,4 @@ +echo "Build script" +./configure --prefix=/usr \ + --with-curses \ + --bindir=/bin diff --git a/xmlspec/examples/bash.clean.sh b/xmlspec/examples/bash.clean.sh new file mode 100644 index 000000000..9c9413fbf --- /dev/null +++ b/xmlspec/examples/bash.clean.sh @@ -0,0 +1,3 @@ +echo "Clean script" +rm -rf $RPM_BUILD_DIR/%{name}-%{version} +rm -rf %{buildroot} diff --git a/xmlspec/examples/bash.files.lst b/xmlspec/examples/bash.files.lst new file mode 100644 index 000000000..f1da9e94f --- /dev/null +++ b/xmlspec/examples/bash.files.lst @@ -0,0 +1,2 @@ +%attr(-,root,root) /bin/bash +%attr(-,root,root) /bin/sh diff --git a/xmlspec/examples/bash.install.sh b/xmlspec/examples/bash.install.sh new file mode 100644 index 000000000..db8deee28 --- /dev/null +++ b/xmlspec/examples/bash.install.sh @@ -0,0 +1,6 @@ +echo "Install script" +make DESTDIR=%{buildroot} install +cd %{buildroot}/bin +ln -sf bash sh +rm -rf %{buildroot}/usr/info/dir + diff --git a/xmlspec/examples/bash.prep.sh b/xmlspec/examples/bash.prep.sh new file mode 100644 index 000000000..59cb8648a --- /dev/null +++ b/xmlspec/examples/bash.prep.sh @@ -0,0 +1,3 @@ +echo "Prep script" +rm -rf $RPM_BUILD_DIR/%{name}-%{version} +rm -rf %{buildroot} diff --git a/xmlspec/examples/bash.xmlspec b/xmlspec/examples/bash.xmlspec new file mode 100644 index 000000000..aaca4f711 --- /dev/null +++ b/xmlspec/examples/bash.xmlspec @@ -0,0 +1,74 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + The Bash package contains the bash program. + %{summary} +Bash is the Bourne-Again SHell, which is a widely used command interpreter on Unix +systems. Bash is a program that reads from standard input, the keyboard. A user types +something and the program will evaluate what he has typed and do something with it, +like running a program. + + + + + + + + Documentation (info and man pages) for the bash package. + %{summary} + 
+		
+	
+
+	
+	
+		
+		
+	
+	
+	
+	
+
+	
+	
+		
+			Added setup macro to extract files
+			Initial version ready for jbj
+		
+		
+			Initial package created
+		
+	
+
diff --git a/xmlspec/rpmxmlbuild.c b/xmlspec/rpmxmlbuild.c
new file mode 100644
index 000000000..a88e58ed2
--- /dev/null
+++ b/xmlspec/rpmxmlbuild.c
@@ -0,0 +1,102 @@
+#include 
+#include 
+#include 
+#include 
+
+#include "rpmbuild.h"
+
+#include "xmlbuild.h"
+
+#define RUN_HELP  "\n       Run \"rpmxmlbuild --help\" for a list of valid options."
+
+#define MASK_BP   (RPMBUILD_PREP)
+#define MASK_BC   (RPMBUILD_BUILD|MASK_BP)
+#define MASK_BI   (RPMBUILD_INSTALL|MASK_BC)
+#define MASK_BL   (RPMBUILD_FILECHECK)
+#define MASK_BB   (RPMBUILD_PACKAGEBINARY|RPMBUILD_CLEAN|MASK_BI)
+#define MASK_BS   (RPMBUILD_PACKAGESOURCE)
+#define MASK_BA   (MASK_BB|MASK_BS)
+
+int usage()
+{
+	printf("Usage  : rpmxmlbuild [options] \n");
+	printf("General Options:\n");
+	printf("\t--help|-h|-?       - Display this message\n");
+	printf("\t--quiet|-q         - Don't display build information\n");
+	printf("\t--verbose|-v       - Display verbose information\n");
+	printf("\n");
+	printf("Build Options:\n");
+	printf("\t-b{p|c|i|l|a|b|s}  - Build spec file to the options specified.\n");
+	printf("\t                     (Options as per rpmbuild.)\n");
+	printf("\n");
+
+	return 0;
+}
+
+int main(int argc, char** argv)
+{
+	char* szSpec = NULL;
+	int i = 0;
+	int nBuild = 0;
+	int nVerbose = 1;
+	int nQuiet = 0;
+
+	for (i = 1; i < argc; i++) {
+		if (argv[i][0] == '-') {
+			if (!strcasecmp(argv[i], "--help") ||
+			    !strcasecmp(argv[i], "-h") ||
+			    !strcasecmp(argv[i], "-?"))
+				return usage();
+			else if ((argv[i][1] == 'b') &&
+				 (argv[i][2] != '\0') &&
+				 (argv[i][3] == '\0')) {
+				switch (argv[i][2]) {
+					case 'a': nBuild = MASK_BA; break;
+					case 'b': nBuild = MASK_BB; break;
+					case 's': nBuild = MASK_BS; break;
+					case 'p': nBuild = MASK_BP; break;
+					case 'c': nBuild = MASK_BC; break;
+					case 'i': nBuild = MASK_BI; break;
+					case 'l': nBuild = MASK_BL; break;
+					default:
+						printf("error: Unknown option \"%s\". %s\n",
+							argv[i], RUN_HELP);
+						return -1;
+				}
+			}
+			else if (!strcasecmp(argv[i], "--verbose") ||
+				 !strcasecmp(argv[i], "-v")) {
+				nVerbose = 1;
+				nQuiet = 0;
+			}
+			else if (!strcasecmp(argv[i], "--quiet") ||
+				 !strcasecmp(argv[i], "-q")) {
+				nVerbose = 0;
+				nQuiet = 1;
+			}
+			else {
+				printf("error: Unknown option \"%s\". %s\n",
+					argv[i], RUN_HELP);
+				return -1;
+			}
+		}
+		else if (!szSpec)
+			szSpec = argv[i];
+		else {
+			printf("error: Extra characters \"%s\" on the command-line. %s\n",
+				argv[i], RUN_HELP);
+			return -2;
+		}
+	}
+
+	if (!szSpec) {
+		printf("error: No XML RPM spec specified. %s\n", RUN_HELP);
+		return -3;
+	}
+
+	rpmReadConfigFiles(NULL, NULL);
+	if (!nQuiet)
+		rpmIncreaseVerbosity();
+
+	return parseBuildXMLSpec(szSpec, nBuild, 0, nVerbose);
+}
diff --git a/xmlspec/xml2rpm.c b/xmlspec/xml2rpm.c
new file mode 100644
index 000000000..b270c87c9
--- /dev/null
+++ b/xmlspec/xml2rpm.c
@@ -0,0 +1,545 @@
+#include 
+#include 
+#include 
+
+#include "rpmio.h"
+#include "header.h"
+#include "stringbuf.h"
+#include "rpmspec.h"
+#include "rpmbuild.h"
+#include "header_internal.h"
+
+#include "xml2rpm.h"
+#include "xmlstruct.h"
+
+// 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)
+				appendLineStringBuf(pSb, pScript->m_szEntry);
+			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 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);
+
+	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;
+}
diff --git a/xmlspec/xml2rpm.h b/xmlspec/xml2rpm.h
new file mode 100644
index 000000000..335867cb8
--- /dev/null
+++ b/xmlspec/xml2rpm.h
@@ -0,0 +1,10 @@
+#ifndef _XML_TO_RPM_H_
+#define _XML_TO_RPM_H_
+
+#include "rpmspec.h"
+
+#include "xmlstruct.h"
+
+Spec toRPMStruct(const t_structXMLSpec* pXMLSpec);
+
+#endif
diff --git a/xmlspec/xmlbuild.c b/xmlspec/xmlbuild.c
new file mode 100644
index 000000000..2cdc55637
--- /dev/null
+++ b/xmlspec/xmlbuild.c
@@ -0,0 +1,55 @@
+#include 
+#include 
+#include 
+#include 
+
+#include "rpmio.h"
+#include "header.h"
+#include "stringbuf.h"
+#include "rpmspec.h"
+#include "rpmbuild.h"
+#include "header_internal.h"
+
+#include "xml2rpm.h"
+#include "xmlbuild.h"
+#include "xmlparse.h"
+#include "xmlstruct.h"
+
+extern Spec g_pSpec;
+
+int buildXMLSpec(t_structXMLSpec* pXMLSpec,
+		 int nWhat,
+		 int nTest)
+{
+	Spec pRPMSpec = NULL;
+	int nRet = 0;
+
+	if ((pRPMSpec = toRPMStruct(pXMLSpec))) {
+		nRet = buildSpec(pRPMSpec, nWhat, nTest);
+		if (g_pSpec)
+			freeSpec(g_pSpec);
+		g_pSpec = NULL;
+	}
+	else
+		nRet = -1;
+		
+	return nRet;
+}
+
+int parseBuildXMLSpec(const char* szXMLSpec,
+		      int nWhat,
+		      int nTest,
+		      int nVerbose)
+{
+	t_structXMLSpec* pXMLSpec = NULL;
+	int nRet = 0;
+
+	if ((pXMLSpec = parseXMLSpec(szXMLSpec, nVerbose))) {
+		nRet = buildXMLSpec(pXMLSpec, nWhat, 0);
+		freeXMLSpec(&pXMLSpec);
+	}
+	else
+		nRet = -1;
+
+	return nRet;
+}
diff --git a/xmlspec/xmlbuild.h b/xmlspec/xmlbuild.h
new file mode 100644
index 000000000..34c635c56
--- /dev/null
+++ b/xmlspec/xmlbuild.h
@@ -0,0 +1,15 @@
+#ifndef _XML_BUILD_H_
+#define _XML_BUILD_H_
+
+#include "xmlstruct.h"
+
+int buildXMLSpec(t_structXMLSpec* pXMLSpec,
+		 int nWhat,
+		 int nTest);
+
+int parseBuildXMLSpec(const char* szXMLSpec,
+		      int nWhat,
+		      int nTest,
+		      int nVerbose);
+
+#endif
diff --git a/xmlspec/xmlmisc.c b/xmlspec/xmlmisc.c
new file mode 100644
index 000000000..5b6adbe4f
--- /dev/null
+++ b/xmlspec/xmlmisc.c
@@ -0,0 +1,151 @@
+#include 
+#include 
+#include 
+
+#include "rpmio.h"
+#include "header.h"
+#include "stringbuf.h"
+#include "rpmspec.h"
+#include "rpmbuild.h"
+#include "header_internal.h"
+
+#include "xmlmisc.h"
+
+extern Spec g_pSpec;
+
+void freeStr(char** pszStr)
+{
+	if (*pszStr != NULL)
+		free(*pszStr);
+	*pszStr = NULL;
+}
+
+char* newStr(const char* szValue,
+	     char** pszStr)
+{
+	freeStr(pszStr);
+	if (szValue) {
+		*pszStr = malloc((strlen(szValue)+1)*sizeof(char));
+		sprintf(*pszStr, "%s", szValue);
+	}
+
+	return *pszStr;
+}
+
+char* newStrEx(const char* szValue,
+	       char** pszStr)
+{
+	char* szBuffer = NULL;
+	int nLen;
+
+	if (g_pSpec == NULL)
+		return newStr(szValue, pszStr);
+
+	if (szValue) {
+		nLen = (strlen(szValue)*2)+1024;
+		szBuffer = malloc(nLen+1);
+		sprintf(szBuffer, "%s", szValue);
+		expandMacros(g_pSpec, g_pSpec->macros, szBuffer, nLen);
+		freeStr(pszStr);
+		newStr(szBuffer, pszStr);
+		free(szBuffer);
+	}
+	else
+		freeStr(pszStr);
+
+	return *pszStr;
+}
+
+void addMacroEx(char* szName, char** pszVar, int nLevel)
+{
+	if (g_pSpec && g_pSpec->macros)
+		addMacro(g_pSpec->macros, szName, NULL, newStrEx(*pszVar, pszVar), nLevel);
+}
+
+int strToBool(const char* szBool)
+{
+	int nBool = 0;
+
+	if (!strcasecmp(szBool, "on"))
+		nBool = 1;
+	else if (!strcasecmp(szBool, "off"))
+		nBool = 0;
+	else if (!strcasecmp(szBool, "true"))
+		nBool = 1;
+	else if (!strcasecmp(szBool, "false"))
+		nBool = 0;
+	else if (!strcasecmp(szBool, "yes"))
+		nBool = 1;
+	else if (!strcasecmp(szBool, "no"))
+		nBool = 0;
+	else if (!strcasecmp(szBool, "1"))
+		nBool = 1;
+	else if (!strcasecmp(szBool, "0"))
+		nBool = 0;
+
+	return nBool;
+}
+
+StringBuf fileToStrBuf(const char* szFile,
+		       const char* szPrepend)
+{
+	FILE* fIn;
+	StringBuf pSb = NULL;
+	StringBuf pTmp;
+	int nLen;
+	char szBuffer[1025];
+	char* szTmp = NULL;
+	char** szaLines, **szaStart;
+
+	if ((szFile) &&
+	    (fIn = fopen(szFile, "r"))) {
+		pTmp = newStringBuf();
+		if (szPrepend)
+			appendLineStringBuf(pTmp, szPrepend);
+		while (!feof(fIn)) {
+			nLen = fread(szBuffer, sizeof(char), 1024, fIn);
+			szBuffer[nLen] = '\0';
+			appendStringBuf(pTmp, szBuffer);
+		}
+		appendLineStringBuf(pTmp, "");
+		fclose(fIn);
+		szaStart = splitString(getStringBuf(pTmp), strlen(getStringBuf(pTmp)), '\n');
+		//newStrEx(getStringBuf(pSb), &szTmp);
+		//freeStringBuf(pSb);
+
+		pSb = newStringBuf();
+		for (szaLines = szaStart; *szaLines; szaLines++) {
+			if (!strncmp(*szaLines, "%setup", sizeof("%setup")-1)) {
+				//doSetupMacro(spec, *sazLines);
+			}
+			else if (!strncmp(*szaLines, "%patch", sizeof("%patch")-1)) {
+	    			//doPatchMacro(spec, *szaLines);
+			}
+			else {
+				newStrEx(*szaLines, &szTmp);
+	    			appendLineStringBuf(pSb, szTmp);
+				freeStr(&szTmp);
+			}
+		}
+		//appendStringBuf(pSb, szTmp);
+		//freeStr(&szTmp);
+		freeSplitString(szaStart);
+		freeStringBuf(pTmp);
+	}
+
+	return pSb;
+}
+
+char* fileToStr(const char* szFile,
+		const char* szPrepend)
+{
+	StringBuf pSb;
+	char* szRet = NULL;
+
+	if ((pSb = fileToStrBuf(szFile, szPrepend))) {
+		newStr(getStringBuf(pSb), &szRet);
+		freeStringBuf(pSb);
+	}
+
+	return szRet;
+}
diff --git a/xmlspec/xmlmisc.h b/xmlspec/xmlmisc.h
new file mode 100644
index 000000000..7aa100712
--- /dev/null
+++ b/xmlspec/xmlmisc.h
@@ -0,0 +1,23 @@
+#ifndef _XML_MISC_H_
+#define _XML_MISC_H_
+
+#include "stringbuf.h"
+
+void freeStr(char** pszStr);
+char* newStr(const char* szValue,
+	     char** pszStr);
+char* newStrEx(const char* szValue,
+	       char** pszStr);
+
+void addMacroEx(char* szName,
+		char** pszVar,
+		int nLevel);
+
+int strToBool(const char* szBool);
+
+StringBuf fileToStrBuf(const char* szFile,
+		       const char* szPrepend);
+char* fileToStr(const char* szFile,
+		const char* szPrepend);
+
+#endif
diff --git a/xmlspec/xmlparse.c b/xmlspec/xmlparse.c
new file mode 100644
index 000000000..5ff6aae74
--- /dev/null
+++ b/xmlspec/xmlparse.c
@@ -0,0 +1,632 @@
+#include 
+#include 
+#include 
+#include 
+
+#include 
+
+#include "rpmbuild.h"
+
+#include "xmlparse.h"
+#include "xmlmisc.h"
+#include "xmlverify.h"
+#include "xmlstruct.h"
+
+void handleXMLStartLevel0(t_structXMLParse* pParse)
+{
+	switch (g_pXMLTags[pParse->m_naTree[pParse->m_nLevel]].m_nValue) {
+		case TAGVAL_SPEC:
+			pParse->m_pSpec = newXMLSpec(pParse->m_pAttrs, pParse->m_szXMLFile);
+			break;
+		default:
+			fprintf(stderr, "warning: %s(%d): Ignoring tag \"%s\" on level %d. (Function not implemented)\n",
+				pParse->m_szXMLFile,
+				XML_GetCurrentLineNumber(pParse->m_pParser),
+				g_pXMLTags[pParse->m_naTree[pParse->m_nLevel]].m_szName,
+				pParse->m_nLevel);
+			pParse->m_nWarnings++;
+			break;
+	}
+}
+
+/*f (!strcasecmp(szName, "pre")) {
+			pPkg = getLastXMLPackage(pParse->m_pSpec->m_pPackages);
+			pPkg->m_pPre = newXMLScript(attrToStruct(szaAttrs, &(pParse->m_pAttrs)));
+		}*/
+void handleXMLStartLevel1(t_structXMLParse* pParse)
+{
+	t_structXMLSpec* pSpec = NULL;
+
+	pSpec = pParse->m_pSpec;
+	switch (g_pXMLTags[pParse->m_naTree[pParse->m_nLevel]].m_nValue) {
+		case TAGVAL_MACRO:
+			addXMLMacro(pParse->m_pAttrs, &(pSpec->m_pMacros));
+			break;
+		case TAGVAL_SOURCE:
+			addXMLSource(pParse->m_pAttrs, &(pSpec->m_pSources));
+			break;
+		case TAGVAL_PATCH:
+			addXMLSource(pParse->m_pAttrs, &(pSpec->m_pPatches));
+			break;
+		case TAGVAL_PACKAGE:
+			addXMLPackage(pParse->m_pAttrs, &(pSpec->m_pPackages));
+			break;
+		case TAGVAL_PREP:
+			pSpec->m_pPrep = newXMLScripts(pParse->m_pAttrs);
+			break;
+		case TAGVAL_BUILD:
+			pSpec->m_pBuild = newXMLScripts(pParse->m_pAttrs);
+			break;
+		case TAGVAL_INSTALL:
+			pSpec->m_pInstall = newXMLScripts(pParse->m_pAttrs);
+			break;
+		case TAGVAL_CLEAN:
+			pSpec->m_pClean = newXMLScripts(pParse->m_pAttrs);
+			break;
+		case TAGVAL_BUILDREQUIRES:
+		case TAGVAL_CHANGELOG:
+			// we don't need to do anything
+			break;
+		default:
+			fprintf(stderr, "warning: %s(%d): Ignoring tag \"%s\" on level %d. (Function not implemented)\n",
+				pParse->m_szXMLFile,
+				XML_GetCurrentLineNumber(pParse->m_pParser),
+				g_pXMLTags[pParse->m_naTree[pParse->m_nLevel]].m_szName,
+				pParse->m_nLevel);
+			pParse->m_nWarnings++;
+			break;
+	}
+}
+
+void handleXMLStartLevel2(t_structXMLParse* pParse)
+{
+	t_structXMLSpec* pSpec = NULL;
+	t_structXMLSource* pSource = NULL;
+	t_structXMLPackage* pPkg = NULL;
+	t_structXMLScript* pScript = NULL;
+	t_structXMLAttr* pAttr = NULL;
+	StringBuf pSb = NULL;
+	int nNum = 0;
+	int nLevel = 0;
+	char* szTmp = NULL;
+	char* szPath = NULL;
+
+	pSpec = pParse->m_pSpec;
+	switch (g_pXMLTags[pParse->m_naTree[pParse->m_nLevel]].m_nValue) {
+		case TAGVAL_SOURCEMIRROR:
+			pSource = getLastXMLSource(pSpec->m_pSources);
+			addXMLMirror(pParse->m_pAttrs, &(pSource->m_pMirrors));
+			break;
+		case TAGVAL_PATCHMIRROR:
+			pSource = getLastXMLSource(pSpec->m_pPatches);
+			addXMLMirror(pParse->m_pAttrs, &(pSource->m_pMirrors));
+			break;
+		case TAGVAL_BUILDREQUIRE:
+			addXMLRequire(pParse->m_pAttrs, &(pSpec->m_pBuildRequires));
+			break;
+		case TAGVAL_CHANGES:
+			addXMLChanges(pParse->m_pAttrs, &(pSpec->m_pChangelog));
+			break;
+		case TAGVAL_PRE:
+			pPkg = getLastXMLPackage(pSpec->m_pPackages);
+			pPkg->m_pPre = newXMLScripts(pParse->m_pAttrs);
+			break;
+		case TAGVAL_POST:
+			pPkg = getLastXMLPackage(pSpec->m_pPackages);
+			pPkg->m_pPost = newXMLScripts(pParse->m_pAttrs);
+			break;
+		case TAGVAL_PREUN:
+			pPkg = getLastXMLPackage(pSpec->m_pPackages);
+			pPkg->m_pPreUn = newXMLScripts(pParse->m_pAttrs);
+			break;
+		case TAGVAL_POSTUN:
+			pPkg = getLastXMLPackage(pSpec->m_pPackages);
+			pPkg->m_pPostUn = newXMLScripts(pParse->m_pAttrs);
+			break;
+		case TAGVAL_VERIFY:
+			pPkg = getLastXMLPackage(pSpec->m_pPackages);
+			pPkg->m_pVerify = newXMLScripts(pParse->m_pAttrs);
+			break;
+		case TAGVAL_FILES:
+			pPkg = getLastXMLPackage(pSpec->m_pPackages);
+			pPkg->m_pFiles = newXMLFiles(pParse->m_pAttrs);
+			break;
+		case TAGVAL_SCRIPT: // prep, build, install, clean
+			switch (g_pXMLTags[pParse->m_naTree[pParse->m_nLevel-1]].m_nValue) {
+				case TAGVAL_PREP:
+					addXMLScript(pParse->m_pAttrs,
+						     &(pSpec->m_pPrep->m_pScripts));
+					break;
+				case TAGVAL_BUILD:
+					addXMLScript(pParse->m_pAttrs,
+						     &(pSpec->m_pBuild->m_pScripts));
+					break;
+				case TAGVAL_INSTALL:
+					addXMLScript(pParse->m_pAttrs,
+						     &(pSpec->m_pInstall->m_pScripts));
+					break;
+				case TAGVAL_CLEAN:
+					addXMLScript(pParse->m_pAttrs,
+						     &(pSpec->m_pClean->m_pScripts));
+					break;
+				default:
+					break;
+			}
+			break;
+		case TAGVAL_SETUPMACRO:
+			pScript = addXMLScript(NULL, &(pSpec->m_pPrep->m_pScripts));
+			if ((pAttr = getXMLAttr("source", pParse->m_pAttrs)))
+				attrSetInt(pAttr, "source", &nNum);
+			if ((pAttr = getXMLAttr("path", pParse->m_pAttrs)))
+				attrSetStr(pAttr, "path", &szPath);
+			else
+				newStrEx(pParse->m_pSpec->m_szBuildSubdir, &szPath);
+			if ((pSource = getXMLSource(nNum, pSpec->m_pSources))) {
+				nNum = strlen(pSource->m_szName);
+				szTmp = pSource->m_szName+(nNum-3);
+				pSb = newStringBuf();
+				nNum = 1;
+				if (!strcasecmp(szTmp, "bz2")) {
+					szTmp = NULL;
+					newStrEx("%{_bzip2bin} -dc ", &szTmp);
+					appendStringBuf(pSb, szTmp);
+					appendStringBuf(pSb, pSource->m_szName);
+				}
+				else if (!strcasecmp(szTmp, ".gz")) {
+					szTmp = NULL;
+					newStrEx("%{_gzipbin} -dc ", &szTmp);
+					appendStringBuf(pSb, szTmp);
+					appendStringBuf(pSb, pSource->m_szName);
+				}
+				else if (!strcasecmp(szTmp, "zip")) {
+					szTmp = NULL;
+					newStrEx("%{_unzipbin} ", &szTmp);
+					appendStringBuf(pSb, szTmp);
+					appendStringBuf(pSb, pSource->m_szName);
+					nNum = 0;
+				}
+				else if (!strcasecmp(szTmp, "tar")) {
+					szTmp = NULL;
+					newStrEx("cat ", &szTmp);
+					appendStringBuf(pSb, szTmp);
+					appendStringBuf(pSb, pSource->m_szName);
+				}
+				else {
+					fprintf(stderr, "error: %s(%d): Invalid compressed format for source in \"setup\" script.\n",
+						pParse->m_szXMLFile,
+						XML_GetCurrentLineNumber(pParse->m_pParser));
+					pParse->m_nErrors++;
+					freeStr(&szPath);
+					freeStringBuf(pSb);
+					return;
+				}
+				if (nNum && pParse->m_nVerbose)
+					appendStringBuf(pSb, " | tar -xvvf -");
+				else if (nNum)
+					appendStringBuf(pSb, " | tar -xf -");
+				appendLineStringBuf(pSb, "");
+				appendLineStringBuf(pSb, "STATUS=$?");
+				appendLineStringBuf(pSb, "if [ $STATUS -ne 0 ]; then");
+				appendLineStringBuf(pSb, "    exit $STATUS");
+				appendLineStringBuf(pSb, "fi");
+				appendStringBuf(pSb, "cd ");
+				appendStringBuf(pSb, szPath);
+				appendLineStringBuf(pSb, "");
+				newStr(getStringBuf(pSb), (char**)&(pScript->m_szEntry));
+				freeStringBuf(pSb);
+				freeStr(&szTmp);
+				freeStr(&szPath);
+			}
+			else {
+				freeStr(&szPath);
+				fprintf(stderr, "error: %s(%d): Invalid \"setup\" script. Source not available.\n",
+					pParse->m_szXMLFile,
+					XML_GetCurrentLineNumber(pParse->m_pParser));
+				pParse->m_nErrors++;
+			}
+			break;
+		case TAGVAL_PATCHMACRO:
+			pScript = addXMLScript(NULL, &(pSpec->m_pPrep->m_pScripts));
+			if ((pAttr = getXMLAttr("patch", pParse->m_pAttrs)))
+				attrSetInt(pAttr, "patch", &nNum);
+			if ((pAttr = getXMLAttr("path", pParse->m_pAttrs)))
+				attrSetStr(pAttr, "path", &szPath);
+			else
+				newStrEx(pParse->m_pSpec->m_szBuildSubdir, &szPath);
+			if ((pAttr = getXMLAttr("level", pParse->m_pAttrs)))
+				attrSetInt(pAttr, "level", &nLevel);
+			if ((pSource = getXMLSource(nNum, pSpec->m_pPatches))) {
+				pSb = newStringBuf();
+				newStrEx("cd %{_builddir}", &szTmp);
+				appendLineStringBuf(pSb, szTmp);
+				freeStr(&szTmp);
+				appendStringBuf(pSb, "cd ");
+				appendStringBuf(pSb, szPath);
+				appendLineStringBuf(pSb, "");
+				nNum = strlen(pSource->m_szName);
+				szTmp = pSource->m_szName+(nNum-3);
+				nNum = 1;
+				if (!strcasecmp(szTmp, "bz2")) {
+					szTmp = NULL;
+					newStrEx("%{_bzip2bin} -dc ", &szTmp);
+					appendStringBuf(pSb, szTmp);
+					appendStringBuf(pSb, pSource->m_szName);
+				}
+				else if (!strcasecmp(szTmp, ".gz")) {
+					szTmp = NULL;
+					newStrEx("%{_gzipbin} -dc ", &szTmp);
+					appendStringBuf(pSb, szTmp);
+					appendStringBuf(pSb, pSource->m_szName);
+				}
+				else {
+					szTmp = NULL;
+					newStrEx("cat ", &szTmp);
+					appendStringBuf(pSb, szTmp);
+					appendStringBuf(pSb, pSource->m_szName);
+				}
+				freeStr(&szTmp);
+				szTmp = malloc(strlen(" > patch -p1234567890 -s ")+strlen(pSource->m_szName)+1);
+				sprintf(szTmp, " | patch -p%d -s", nLevel);
+				appendStringBuf(pSb, szTmp);
+				appendLineStringBuf(pSb, "");
+				appendLineStringBuf(pSb, "STATUS=$?");
+				appendLineStringBuf(pSb, "if [ $STATUS -ne 0 ]; then");
+				appendLineStringBuf(pSb, "    exit $STATUS");
+				appendLineStringBuf(pSb, "fi");
+				appendLineStringBuf(pSb, "");
+				newStr(getStringBuf(pSb), (char**)&(pScript->m_szEntry));
+				freeStringBuf(pSb);
+				freeStr(&szTmp);
+				freeStr(&szPath);
+			}
+			else {
+				freeStr(&szPath);
+				fprintf(stderr, "error: %s(%d): Invalid \"patch\" script. Patch not available.\n",
+					pParse->m_szXMLFile,
+					XML_GetCurrentLineNumber(pParse->m_pParser));
+				pParse->m_nErrors++;
+			}
+			break;
+		case TAGVAL_SUMMARY:
+		case TAGVAL_DESCRIPTION:
+		case TAGVAL_REQUIRES:
+			// we don't need to do anything
+			break;
+		default:
+			fprintf(stderr, "warning: %s(%d): Ignoring tag \"%s\" on level %d. (Function not implemented)\n",
+				pParse->m_szXMLFile,
+				XML_GetCurrentLineNumber(pParse->m_pParser),
+				g_pXMLTags[pParse->m_naTree[pParse->m_nLevel]].m_szName,
+				pParse->m_nLevel);
+			pParse->m_nWarnings++;
+			break;
+	}
+}
+
+void handleXMLStartLevel3(t_structXMLParse* pParse)
+{
+	t_structXMLSpec* pSpec = NULL;
+	t_structXMLPackage* pPkg = NULL;
+	t_structXMLChanges* pChanges = NULL;
+
+	pSpec = pParse->m_pSpec;
+	switch (g_pXMLTags[pParse->m_naTree[pParse->m_nLevel]].m_nValue) {
+		case TAGVAL_REQUIRE:
+			pPkg = getLastXMLPackage(pSpec->m_pPackages);
+			addXMLRequire(pParse->m_pAttrs, &(pPkg->m_pRequires));
+			break;
+		case TAGVAL_CHANGE:
+			pChanges = getLastXMLChanges(pSpec->m_pChangelog);
+			addXMLChange(pParse->m_pAttrs, &(pChanges->m_pChanges));
+			break;
+		case TAGVAL_SCRIPT: // pre, post, ...
+			pPkg = getLastXMLPackage(pSpec->m_pPackages);
+			switch (g_pXMLTags[pParse->m_naTree[pParse->m_nLevel-1]].m_nValue) {
+				case TAGVAL_PRE:
+					addXMLScript(pParse->m_pAttrs,
+						     &(pPkg->m_pPre->m_pScripts));
+					break;
+				case TAGVAL_POST:
+					addXMLScript(pParse->m_pAttrs,
+						     &(pPkg->m_pPost->m_pScripts));
+					break;
+				case TAGVAL_PREUN:
+					addXMLScript(pParse->m_pAttrs,
+						     &(pPkg->m_pPreUn->m_pScripts));
+					break;
+				case TAGVAL_POSTUN:
+					addXMLScript(pParse->m_pAttrs,
+						     &(pPkg->m_pPostUn->m_pScripts));
+					break;
+				case TAGVAL_VERIFY:
+					addXMLScript(pParse->m_pAttrs,
+						     &(pPkg->m_pVerify->m_pScripts));
+					break;
+				default:
+					break;
+			}
+			break;
+		default:
+			fprintf(stderr, "warning: %s(%d): Ignoring tag \"%s\" on level %d. (Function not implemented)\n",
+				pParse->m_szXMLFile,
+				XML_GetCurrentLineNumber(pParse->m_pParser),
+				g_pXMLTags[pParse->m_naTree[pParse->m_nLevel]].m_szName,
+				pParse->m_nLevel);
+			pParse->m_nWarnings++;
+			break;
+	}
+}
+
+void startXMLCB(void* pData,
+		const XML_Char* szName,
+		const XML_Char** szaAttrs)
+{
+	t_structXMLParse* pParse = NULL;
+	int nTagPos;
+
+	if (!(pParse = (t_structXMLParse*)pData))
+		return;
+
+	if ((nTagPos = verifyXMLPath(szName, pParse)) == -1) {
+		pParse->m_nLevel++;
+		return;
+	}
+
+	if (verifyXMLAttrs(szaAttrs, pParse, nTagPos) == -1) {
+		pParse->m_nLevel++;
+		return;
+	}
+
+	pParse->m_naTree[pParse->m_nLevel] = nTagPos;
+	switch (pParse->m_nLevel) {
+		case 0:
+			handleXMLStartLevel0(pParse);
+			break;
+		case 1:
+			handleXMLStartLevel1(pParse);
+			break;
+		case 2:
+			handleXMLStartLevel2(pParse);
+			break;
+		case 3:
+			handleXMLStartLevel3(pParse);
+			break;
+		default:
+			fprintf(stderr, "warning: %s(%d): XML tag nesting of %d levels not handled Ignoring tag \"%s\".\n",
+				pParse->m_szXMLFile,
+				XML_GetCurrentLineNumber(pParse->m_pParser),
+				pParse->m_nLevel,
+				szName);
+			pParse->m_nWarnings++;
+			break;
+	}
+
+	pParse->m_nLevel++;
+	pParse->m_nLastGoodLevel = pParse->m_nLevel;
+	return;
+}
+
+void handleXMLEndLevel0(t_structXMLParse* pParse)
+{
+	t_structXMLSpec* pSpec = NULL;
+
+	pSpec = pParse->m_pSpec;
+	switch (g_pXMLTags[pParse->m_naTree[pParse->m_nLevel]].m_nValue) {
+		default:
+			break;
+	}
+}
+
+void handleXMLEndLevel1(t_structXMLParse* pParse)
+{
+	t_structXMLSpec* pSpec = NULL;
+	t_structXMLMacro* pMacro = NULL;
+
+	pSpec = pParse->m_pSpec;
+	switch (g_pXMLTags[pParse->m_naTree[pParse->m_nLevel]].m_nValue) {
+		case TAGVAL_MACRO:
+			pMacro = getLastXMLMacro(pSpec->m_pMacros);
+			newStr(pParse->m_szValue, &(pMacro->m_szValue));
+			break;
+		default:
+			break;
+	}
+}
+
+void handleXMLEndLevel2(t_structXMLParse* pParse)
+{
+	t_structXMLSpec* pSpec = NULL;
+	t_structXMLPackage* pPkg = NULL;
+	t_structXMLScript* pScript = NULL;
+
+	pSpec = pParse->m_pSpec;
+	switch (g_pXMLTags[pParse->m_naTree[pParse->m_nLevel]].m_nValue) {
+		case TAGVAL_SUMMARY:
+			pPkg = getLastXMLPackage(pSpec->m_pPackages);
+			newStrEx(pParse->m_szValue, &(pPkg->m_szSummary));
+			break;
+		case TAGVAL_DESCRIPTION:
+			pPkg = getLastXMLPackage(pSpec->m_pPackages);
+			newStrEx(pParse->m_szValue, &(pPkg->m_szDescription));
+			break;
+		case TAGVAL_SCRIPT:
+			switch (g_pXMLTags[pParse->m_naTree[pParse->m_nLevel-1]].m_nValue) {
+				case TAGVAL_PREP:
+					pScript = getLastXMLScript(pSpec->m_pPrep->m_pScripts);
+					break;
+				case TAGVAL_BUILD:
+					pScript = getLastXMLScript(pSpec->m_pBuild->m_pScripts);
+					break;
+				case TAGVAL_INSTALL:
+					pScript = getLastXMLScript(pSpec->m_pInstall->m_pScripts);
+					break;
+				case TAGVAL_CLEAN:
+					pScript = getLastXMLScript(pSpec->m_pClean->m_pScripts);
+					break;
+				default:
+					break;
+			}
+			if (pScript)
+				newStrEx(pParse->m_szValue, (char**)&(pScript->m_szEntry));
+			break;
+		default:
+			break;
+	}
+}
+
+void handleXMLEndLevel3(t_structXMLParse* pParse)
+{
+	t_structXMLSpec* pSpec = NULL;
+	t_structXMLPackage* pPkg = NULL;
+	t_structXMLScript* pScript = NULL;
+
+	pSpec = pParse->m_pSpec;
+	switch (g_pXMLTags[pParse->m_naTree[pParse->m_nLevel]].m_nValue) {
+		case TAGVAL_SCRIPT:
+			pPkg = getLastXMLPackage(pSpec->m_pPackages);
+			switch (g_pXMLTags[pParse->m_naTree[pParse->m_nLevel-1]].m_nValue) {
+				case TAGVAL_PRE:
+					pScript = getLastXMLScript(pPkg->m_pPre->m_pScripts);
+					break;
+				case TAGVAL_POST:
+					pScript = getLastXMLScript(pPkg->m_pPost->m_pScripts);
+					break;
+				case TAGVAL_PREUN:
+					pScript = getLastXMLScript(pPkg->m_pPreUn->m_pScripts);
+					break;
+				case TAGVAL_POSTUN:
+					pScript = getLastXMLScript(pPkg->m_pPostUn->m_pScripts);
+					break;
+				case TAGVAL_VERIFY:
+					pScript = getLastXMLScript(pPkg->m_pVerify->m_pScripts);
+					break;
+				default:
+					break;
+			}
+			if (pScript)
+				newStrEx(pParse->m_szValue,
+					 (char**)&(pScript->m_szEntry));
+			break;
+		default:
+			break;
+	}
+}
+
+void endXMLCB(void* pData,
+	      const XML_Char* szName)
+{
+	t_structXMLParse* pParse = NULL;
+
+	if ((pParse = (t_structXMLParse*)pData)) {
+		pParse->m_nLevel--;
+		switch (pParse->m_nLevel) {
+			case 0:
+				handleXMLEndLevel0(pParse);
+				break;
+			case 1:
+				handleXMLEndLevel1(pParse);
+				break;
+			case 2:
+				handleXMLEndLevel2(pParse);
+				break;
+			case 3:
+				handleXMLEndLevel3(pParse);
+				break;
+			default:
+				break;
+		}
+		freeStr(&(pParse->m_szValue));
+	}
+}
+
+void dataXMLCB(void* pData,
+	       const XML_Char* szValue,
+	       int nLen)
+{
+	t_structXMLParse* pParse = NULL;
+	char* szTmp = NULL;
+	char* szTmpValue = NULL;
+	char* szPos = NULL;
+
+	if ((pParse = (t_structXMLParse*)pData)) {
+		szTmp = malloc(nLen+2);
+		szTmp[nLen] = '\0';
+		snprintf(szTmp, nLen+1, "%s", szValue);
+		szPos = szTmp;
+		while ((*szPos == ' ') ||
+		       (*szPos == '\t') ||
+		       (*szPos == '\r') ||
+		       (*szPos == '\n'))
+			szPos++;
+
+		if (strlen(szPos)) {
+			if (pParse->m_szValue) {
+				szTmpValue = malloc(strlen(szPos)+strlen(pParse->m_szValue)+1);
+				sprintf(szTmpValue, "%s%s", pParse->m_szValue, szPos);
+				newStr(szTmpValue, &(pParse->m_szValue));
+				free(szTmpValue);
+			}
+			else
+				newStr(szPos, &(pParse->m_szValue));
+		}
+		free(szTmp);
+	}
+}
+
+t_structXMLSpec* parseXMLSpec(const char* szFile, int nVerbose)
+{
+	XML_Parser pParser = NULL;
+	t_structXMLParse* pSParse = NULL;
+	t_structXMLSpec* pSpec = NULL;
+	FILE* fIn = NULL;
+	int nLen = 0;
+	char szBuffer[1024+1];
+
+	pSParse = malloc(sizeof(t_structXMLParse));
+	pSParse->m_szXMLFile = (char*)szFile;
+	pSParse->m_szValue = NULL;
+	pSParse->m_nLevel = 0;
+	pSParse->m_nLastGoodLevel = 0;
+	pSParse->m_nWarnings = 0;
+	pSParse->m_nErrors = 0;
+	pSParse->m_pSpec = NULL;
+	pSParse->m_pAttrs = NULL;
+	pSParse->m_nVerbose = nVerbose;
+
+	if ((fIn = fopen(szFile, "r"))) {
+		if ((pParser = XML_ParserCreate(NULL))) {
+			pSParse->m_pParser = pParser;
+			XML_SetStartElementHandler(pParser, &startXMLCB);
+			XML_SetEndElementHandler(pParser, &endXMLCB);
+			XML_SetCharacterDataHandler(pParser, &dataXMLCB);
+			XML_SetUserData(pParser, pSParse);
+			while (!feof(fIn)) {
+				nLen = fread(szBuffer, sizeof(char), 1024, fIn);
+				if (!XML_Parse(pParser, szBuffer, nLen, 0)) {
+					fprintf(stderr, "fatal: %s(%d): %s \n", szFile,
+							XML_GetCurrentLineNumber(pParser),
+							XML_ErrorString(XML_GetErrorCode(pParser)));
+					pSParse->m_nErrors++;
+				}
+			}
+			if (nVerbose)
+				printf("+ XML parse completed with %d error(s), %d warning(s).\n", pSParse->m_nErrors, pSParse->m_nWarnings);
+			XML_Parse(pParser, szBuffer, 0, 1);
+			XML_ParserFree(pParser);
+		}
+		fclose(fIn);
+	}
+	else {
+		free(pSParse);
+		fprintf(stderr, "fatal: Open of \"%s\" failed.\n", szFile);
+		return NULL;
+	}
+
+	freeXMLAttr(&(pSParse->m_pAttrs));
+	if (pSParse->m_nErrors)
+		freeXMLSpec(&(pSParse->m_pSpec));
+
+	pSpec = pSParse->m_pSpec;
+	free(pSParse);
+	return pSpec;
+}
diff --git a/xmlspec/xmlparse.h b/xmlspec/xmlparse.h
new file mode 100644
index 000000000..543359e1f
--- /dev/null
+++ b/xmlspec/xmlparse.h
@@ -0,0 +1,26 @@
+#ifndef _XML_PARSE_H_
+#define _XML_PARSE_H_
+
+#include 
+
+#include "xmlstruct.h"
+
+#define MAX_XML_LEVELS                  10
+#define MAX_XML_ATTRS                   20
+
+typedef struct structXMLParse
+{
+	char*            m_szXMLFile;
+	XML_Parser       m_pParser;
+	char*            m_szValue;
+	int              m_nLevel;
+	int              m_nLastGoodLevel;
+	int              m_nErrors;
+	int              m_nWarnings;
+	int              m_naTree[MAX_XML_LEVELS];
+	int              m_nVerbose;
+	t_structXMLAttr* m_pAttrs;
+	t_structXMLSpec* m_pSpec;
+} t_structXMLParse;
+
+#endif
diff --git a/xmlspec/xmlstruct.c b/xmlspec/xmlstruct.c
new file mode 100644
index 000000000..4b2d9f628
--- /dev/null
+++ b/xmlspec/xmlstruct.c
@@ -0,0 +1,821 @@
+#include 
+#include 
+#include 
+#include 
+
+#include "rpmio.h"
+#include "header.h"
+#include "stringbuf.h"
+#include "rpmspec.h"
+#include "header_internal.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, "number", &(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_szScript = NULL;
+		pScript->m_szEntry = NULL;
+		pScript->m_pNext = NULL;
+
+		if ((pAttr = (t_structXMLAttr*)pAttrs)) {
+			do {
+				attrSetStr(pAttr, "interpreter",
+					   &(pScript->m_szInterpreter));
+				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_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_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_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_pProvides = NULL;
+		pPackage->m_pNext = NULL;
+
+		pAttr = (t_structXMLAttr*)pAttrs;
+		do {
+			attrSetStr(pAttr, "name", &(pPackage->m_szName));
+			attrSetStr(pAttr, "group", &(pPackage->m_szGroup));
+			attrSetBool(pAttr, "autorequire", &(pPackage->m_nAutoRequire));
+			attrSetBool(pAttr, "autoprovide", &(pPackage->m_nAutoProvide));
+			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_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_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;
+}
diff --git a/xmlspec/xmlstruct.h b/xmlspec/xmlstruct.h
new file mode 100644
index 000000000..6b8e62a4c
--- /dev/null
+++ b/xmlspec/xmlstruct.h
@@ -0,0 +1,226 @@
+#ifndef _XML_STRUCT_H_
+#define _XML_STRUCT_H_
+
+#include "xmlmisc.h"
+
+typedef struct structXMLAttr
+{
+	char*                 m_szName;
+	char*                 m_szValue;
+	int                   m_nType;
+	struct structXMLAttr* m_pNext;
+} t_structXMLAttr;
+
+typedef struct structXMLMacro
+{
+	char*                  m_szName;
+	char*                  m_szValue;
+	struct structXMLMacro* m_pNext;
+} t_structXMLMacro;
+
+typedef struct structXMLMirror
+{
+	char*                   m_szName;
+	char*                   m_szLocation;
+	char*                   m_szCountry;
+	char*                   m_szPath;
+	int                     m_nTries;
+	struct structXMLMirror* m_pNext;
+} t_structXMLMirror;
+
+typedef struct structXMLSource
+{
+	char*                   m_szName;
+	int                     m_nSize;
+	char*                   m_szMD5;
+	char*                   m_szDirectory;
+	int                     m_nNum;
+	struct structXMLMirror* m_pMirrors;
+	struct structXMLSource* m_pNext;
+} t_structXMLSource;
+
+typedef struct structXMLRequire
+{
+	char*                    m_szName;
+	char*                    m_szVersion;
+	char*                    m_szRelease;
+	char*                    m_szEpoch;
+	char*                    m_szCompare;
+	struct structXMLRequire* m_pNext;
+} t_structXMLRequire;
+
+typedef struct structXMLScript
+{
+	char*                   m_szInterpreter;
+	char*                   m_szScript;
+	char*                   m_szEntry;
+	struct structXMLScript* m_pNext;
+} t_structXMLScript;
+
+typedef struct structXMLScripts
+{
+	char*                   m_szInterpreter;
+	char*                   m_szScript;
+	struct structXMLScript* m_pScripts;
+} t_structXMLScripts;
+
+typedef struct structXMLFiles
+{
+	char* m_szFileList;
+	char* m_szUID;
+	char* m_szGID;
+} t_structXMLFiles;
+
+typedef struct structXMLPackage
+{
+	char*                    m_szName;
+	char*                    m_szGroup;
+	char*                    m_szSummary;
+	char*                    m_szDescription;
+	int                      m_nAutoRequire;
+	int                      m_nAutoProvide;
+	int                      m_nAutoSuggest;
+	struct structXMLFiles*   m_pFiles;
+	struct structXMLScripts* m_pPre;
+	struct structXMLScripts* m_pPost;
+	struct structXMLScripts* m_pPreUn;
+	struct structXMLScripts* m_pPostUn;
+	struct structXMLScripts* m_pVerify;
+	struct structXMLRequire* m_pRequires;
+	struct structXMLRequire* m_pSuggests;
+	struct structXMLRequire* m_pObsoletes;
+	struct structXMLRequire* m_pProvides;
+	struct structXMLPackage* m_pNext;
+} t_structXMLPackage;
+
+typedef struct structXMLChange
+{
+	char*                   m_szValue;
+	struct structXMLChange* m_pNext;
+} t_structXMLChange;
+
+typedef struct structXMLChanges
+{
+	char*                    m_szDate;
+	char*                    m_szVersion;
+	char*                    m_szAuthor;
+	char*                    m_szAuthorEmail;
+	struct structXMLChange*  m_pChanges;
+	struct structXMLChanges* m_pNext;
+} t_structXMLChanges;
+
+typedef struct structXMLSpec
+{
+	char*                    m_szSpecName;
+	char*                    m_szBuildRootDir;
+	char*                    m_szBuildSubdir;
+	char*                    m_szRootDir;
+	char*                    m_szName;
+	char*                    m_szVersion;
+	char*                    m_szRelease;
+	char*                    m_szEpoch;
+	char*                    m_szDistribution;
+	char*                    m_szVendor;
+	char*                    m_szPackager;
+	char*                    m_szPackagerEmail;
+	char*                    m_szCopyright;
+	char*                    m_szURL;
+	struct structXMLRequire* m_pBuildRequires;
+	struct structXMLRequire* m_pBuildConflicts;
+	struct structXMLRequire* m_pBuildSuggests;
+	struct structXMLScripts* m_pPrep;
+	struct structXMLScripts* m_pBuild;
+	struct structXMLScripts* m_pInstall;
+	struct structXMLScripts* m_pClean;
+	struct structXMLMacro*   m_pMacros;
+	struct structXMLSource*  m_pSources;
+	struct structXMLSource*  m_pPatches;
+	struct structXMLPackage* m_pPackages;
+	struct structXMLChanges* m_pChangelog;
+} t_structXMLSpec;
+
+void attrSetStr(const t_structXMLAttr* pAttr,
+		const char* szParam,
+		char** pszVar);
+void attrSetInt(const t_structXMLAttr* pAttr,
+		const char* szParam,
+		int* pnVar);
+void attrSetBool(const t_structXMLAttr* pAttr,
+		 const char* szParam,
+		 int* pnVar);
+
+t_structXMLAttr* newXMLAttr(const char* szName,
+			    const char* szValue,
+			    int nType);
+int freeXMLAttr(t_structXMLAttr** ppAttr);
+t_structXMLAttr* addXMLAttr(const char* szName,
+			    const char* szValue,
+			    int nType,
+			    t_structXMLAttr** ppAttr);
+t_structXMLAttr* getLastXMLAttr(t_structXMLAttr* pAttr);
+t_structXMLAttr* getXMLAttr(const char* szName,
+			    t_structXMLAttr* pAttr);
+
+t_structXMLSpec* parseXMLSpec(const char* szFile, int nVerbose);
+
+t_structXMLMacro* newXMLMacro(const t_structXMLAttr* pAttrs);
+int freeXMLMacro(t_structXMLMacro** ppMacro);
+t_structXMLMacro* addXMLMacro(const t_structXMLAttr* pAttrs,
+			      t_structXMLMacro** ppMacro);
+t_structXMLMacro* getLastXMLMacro(t_structXMLMacro* pMacro);
+
+t_structXMLMirror* newXMLMirror(const t_structXMLAttr* pAttrs);
+int freeXMLMirror(t_structXMLMirror** ppMirror);
+t_structXMLMirror* addXMLMirror(const t_structXMLAttr* pAttrs,
+				t_structXMLMirror** ppMirror);
+t_structXMLMirror* getLastXMLMirror(t_structXMLMirror* pMirror);
+
+t_structXMLSource* newXMLSource(const t_structXMLAttr* pAttrs);
+int freeXMLSource(t_structXMLSource** ppSource);
+t_structXMLSource* addXMLSource(const t_structXMLAttr* pAttrs,
+				t_structXMLSource** ppSource);
+t_structXMLSource* getLastXMLSource(t_structXMLSource* pSource);
+t_structXMLSource* getXMLSource(int nNum,
+				t_structXMLSource* pSource);
+
+t_structXMLRequire* newXMLRequire(const t_structXMLAttr* pAttrs);
+int freeXMLRequire(t_structXMLRequire** ppRequire);
+t_structXMLRequire* addXMLRequire(const t_structXMLAttr* pAttrs,
+				  t_structXMLRequire** ppRequire);
+t_structXMLRequire* getLastXMLRequire(t_structXMLRequire* pRequire);
+
+t_structXMLScript* newXMLScript(const t_structXMLAttr* pAttrs);
+int freeXMLScript(t_structXMLScript** ppScript);
+t_structXMLScript* addXMLScript(const t_structXMLAttr* pAttrs,
+				t_structXMLScript** ppScript);
+t_structXMLScript* getLastXMLScript(t_structXMLScript* pScript);
+
+t_structXMLScripts* newXMLScripts(const t_structXMLAttr* pAttrs);
+int freeXMLScripts(t_structXMLScripts** ppScripts);
+
+t_structXMLFiles* newXMLFiles(const t_structXMLAttr* pAttrs);
+int freeXMLFiles(t_structXMLFiles** ppFiles);
+
+t_structXMLPackage* newXMLPackage(const t_structXMLAttr* pAttrs);
+int freeXMLPackage(t_structXMLPackage** ppPackage);
+t_structXMLPackage* addXMLPackage(const t_structXMLAttr* pAttrs,
+				  t_structXMLPackage** ppPackage);
+t_structXMLPackage* getLastXMLPackage(t_structXMLPackage* pPackage);
+
+t_structXMLChange* newXMLChange(const t_structXMLAttr* pAttrs);
+int freeXMLChange(t_structXMLChange** ppChange);
+t_structXMLChange* addXMLChange(const t_structXMLAttr* pAttrs,
+				t_structXMLChange** ppChange);
+t_structXMLChange* getLastXMLChange(t_structXMLChange* pChange);
+
+t_structXMLChanges* newXMLChanges(const t_structXMLAttr* pAttrs);
+int freeXMLChanges(t_structXMLChanges** ppChanges);
+t_structXMLChanges* addXMLChanges(const t_structXMLAttr* pAttrs,
+				  t_structXMLChanges** ppChanges);
+t_structXMLChanges* getLastXMLChanges(t_structXMLChanges* pChanges);
+
+t_structXMLSpec* newXMLSpec(const t_structXMLAttr* pAttrs,
+			    const char* szXMLFile);
+int freeXMLSpec(t_structXMLSpec** ppSpec);
+
+#endif
diff --git a/xmlspec/xmlverify.c b/xmlspec/xmlverify.c
new file mode 100644
index 000000000..718a0cfab
--- /dev/null
+++ b/xmlspec/xmlverify.c
@@ -0,0 +1,893 @@
+#include 
+#include 
+#include 
+#include 
+#include 
+
+// This is a hack to make sure we can include the
+// xmlverify header file
+#define NO_XMLTAGS_EXTERN               1
+
+#include "xmlparse.h"
+#include "xmlverify.h"
+
+extern char* g_szSpecPath;
+
+t_structXMLTags g_pXMLTags[] =
+{
+	{
+		"spec", TAGVAL_SPEC, 0,
+		{
+			TAGVAL_LAST
+		},
+		{
+			{"name",           ATTRTYPE_ANY,     1},
+			{"version",        ATTRTYPE_ANY,     1},
+			{"release",        ATTRTYPE_ANY,     1},
+			{"epoch",          ATTRTYPE_NUMERIC, 0},
+			{"buildroot",      ATTRTYPE_ANY,     0},
+			{"builddir",       ATTRTYPE_ANY,     0},
+			{"url",            ATTRTYPE_URL,     0},
+			{"copyright",      ATTRTYPE_ANY,     0},
+			{"distribution",   ATTRTYPE_ANY,     1},
+			{"vendor",         ATTRTYPE_ANY,     1},
+			{"packager",       ATTRTYPE_ANY,     1},
+			{"packager-email", ATTRTYPE_EMAIL,   0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		},
+	},
+	{
+		"macro", TAGVAL_MACRO, 1,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_LAST
+		},
+		{
+			{"name",           ATTRTYPE_ANY,     1},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"source", TAGVAL_SOURCE, 1,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_LAST
+		},
+		{
+			{"name",           ATTRTYPE_SRCFILE, 1},
+			{"size",           ATTRTYPE_NUMERIC, 0},
+			{"md5",            ATTRTYPE_MD5,     0},
+			{"path",           ATTRTYPE_ANY,     0},
+			{"number",         ATTRTYPE_NUMERIC, 0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"mirror", TAGVAL_SOURCEMIRROR, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_SOURCE,
+			TAGVAL_LAST
+		},
+		{
+			{"name",           ATTRTYPE_ANY,     0},
+			{"location",       ATTRTYPE_ANY,     0},
+			{"country",        ATTRTYPE_COUNTRY, 0},
+			{"path",           ATTRTYPE_URL,     1},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+
+	{
+		"patch", TAGVAL_PATCH, 1,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_LAST
+		},
+		{
+			{"name",           ATTRTYPE_SRCFILE, 1},
+			{"size",           ATTRTYPE_NUMERIC, 0},
+			{"md5",            ATTRTYPE_MD5,     0},
+			{"path",           ATTRTYPE_ANY,     0},
+			{"number",         ATTRTYPE_NUMERIC, 0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"mirror", TAGVAL_PATCHMIRROR, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PATCH,
+			TAGVAL_LAST
+		},
+		{
+			{"name",           ATTRTYPE_ANY,     0},
+			{"location",       ATTRTYPE_ANY,     0},
+			{"country",        ATTRTYPE_COUNTRY, 0},
+			{"path",           ATTRTYPE_URL,     1},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"buildrequires", TAGVAL_BUILDREQUIRES, 1,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_LAST
+		},
+		{
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"require", TAGVAL_BUILDREQUIRE, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_BUILDREQUIRES,
+			TAGVAL_LAST
+		},
+		{
+			{"name",           ATTRTYPE_ANY,     1},
+			{"version",        ATTRTYPE_ANY,     0},
+			{"cmp",            ATTRTYPE_CMP,     0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"buildsuggests", TAGVAL_BUILDSUGGESTS, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_LAST
+		},
+		{
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"suggest", TAGVAL_BUILDSUGGEST, 3,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_BUILDSUGGESTS,
+			TAGVAL_LAST
+		},
+		{
+			{"name",           ATTRTYPE_ANY,     1},
+			{"version",        ATTRTYPE_ANY,     0},
+			{"cmp",            ATTRTYPE_CMP,     0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{	"package", TAGVAL_PACKAGE, 1,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_LAST
+		},
+		{
+			{"name",           ATTRTYPE_ANY,     0},
+			{"group",          ATTRTYPE_ANY,     1},
+			{"autoreqprov",    ATTRTYPE_BOOL,    0},
+			{"autoprov",       ATTRTYPE_BOOL,    0},
+			{"autoreq",        ATTRTYPE_BOOL,    0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"requires", TAGVAL_REQUIRES, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_LAST
+		},
+		{
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"require", TAGVAL_REQUIRE, 3,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_REQUIRES,
+			TAGVAL_LAST
+		},
+		{
+			{"name",           ATTRTYPE_ANY,     1},
+			{"version",        ATTRTYPE_ANY,     0},
+			{"cmp",            ATTRTYPE_CMP,     0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"provides", TAGVAL_PROVIDES, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_LAST
+		},
+		{
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"provide", TAGVAL_PROVIDE, 3,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_PROVIDES,
+			TAGVAL_LAST
+		},
+		{
+			{"name",           ATTRTYPE_ANY,     1},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"obsoletes", TAGVAL_OBSOLETES, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_LAST
+		},
+		{
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"obsolete", TAGVAL_OBSOLETE, 3,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_OBSOLETES,
+			TAGVAL_LAST
+		},
+		{
+			{"name",           ATTRTYPE_ANY,     1},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"suggests", TAGVAL_SUGGESTS, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_LAST
+		},
+		{
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"suggest", TAGVAL_SUGGEST, 3,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_SUGGESTS,
+			TAGVAL_LAST
+		},
+		{
+			{"name",           ATTRTYPE_ANY,     1},
+			{"version",        ATTRTYPE_ANY,     0},
+			{"cmp",            ATTRTYPE_CMP,     0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"summary", TAGVAL_SUMMARY, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_LAST
+		},
+		{
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"description", TAGVAL_DESCRIPTION, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_LAST
+		},
+		{
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"pre", TAGVAL_PRE, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"script", TAGVAL_SCRIPT, 3,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_PRE,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"post", TAGVAL_POST, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"script", TAGVAL_SCRIPT, 3,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_POST,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"preun", TAGVAL_PREUN, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"script", TAGVAL_SCRIPT, 3,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_PREUN,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"postun", TAGVAL_POSTUN, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"script", TAGVAL_SCRIPT, 3,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_POSTUN,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{"verify", TAGVAL_VERIFY, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"script", TAGVAL_SCRIPT, 3,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_VERIFY,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"files", TAGVAL_FILES, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PACKAGE,
+			TAGVAL_LAST
+		},
+		{
+			{"uid",            ATTRTYPE_ANY,     0},
+			{"gid",            ATTRTYPE_ANY,     0},
+			{"list",           ATTRTYPE_SCRIPT,  1},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"prep", TAGVAL_PREP, 1,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"script", TAGVAL_SCRIPT, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PREP,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"setup", TAGVAL_SETUPMACRO, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PREP,
+			TAGVAL_LAST
+		},
+		{
+			{"source",         ATTRTYPE_NUMERIC, 0},
+			{"path",           ATTRTYPE_ANY,     0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"patch", TAGVAL_PATCHMACRO, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_PREP,
+			TAGVAL_LAST
+		},
+		{
+			{"patch",          ATTRTYPE_NUMERIC, 0},
+			{"level",          ATTRTYPE_NUMERIC, 0},
+			{"path",           ATTRTYPE_ANY,     0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"build", TAGVAL_BUILD, 1,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"script", TAGVAL_SCRIPT, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_BUILD,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"install", TAGVAL_INSTALL, 1,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"script", TAGVAL_SCRIPT, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_INSTALL,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"clean", TAGVAL_CLEAN, 1,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"script", TAGVAL_SCRIPT, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_CLEAN,
+			TAGVAL_LAST
+		},
+		{
+			{"interpreter",    ATTRTYPE_ANY,     0},
+			{"script",         ATTRTYPE_SCRIPT,  0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"changelog", TAGVAL_CHANGELOG, 1,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_LAST
+		},
+		{
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"changes", TAGVAL_CHANGES, 2,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_CHANGELOG,
+			TAGVAL_LAST
+		},
+		{
+			{"date",           ATTRTYPE_ANY,     1},
+			{"version",        ATTRTYPE_ANY,     0},
+			{"author",         ATTRTYPE_ANY,     0},
+			{"author-email",   ATTRTYPE_EMAIL,   0},
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		"change", TAGVAL_CHANGE, 3,
+		{
+			TAGVAL_SPEC,
+			TAGVAL_CHANGELOG,
+			TAGVAL_CHANGES,
+			TAGVAL_CHANGE,
+			TAGVAL_LAST
+		},
+		{
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	},
+	{
+		NULL, TAGVAL_LAST, 0,
+		{
+			TAGVAL_LAST
+		},
+		{
+			{NULL,             ATTRTYPE_ANY,     1}
+		}
+	}
+};
+
+int verifyXMLPath(const char* szName,
+		  t_structXMLParse* pParse)
+{
+	int nFound = -1;
+	int i = 0;
+	int j = 0;
+	int nValue = 0;
+
+	if (pParse->m_nLevel == MAX_XML_LEVELS)
+		return -1;
+
+	while ((nFound == -1) && (g_pXMLTags[i].m_nValue != TAGVAL_LAST)) {
+		if (g_pXMLTags[i].m_nLevel == pParse->m_nLevel) {
+			if (!strcasecmp(szName, g_pXMLTags[i].m_szName)) {
+				nFound = i;
+				for (j = 0; j < pParse->m_nLevel; j++) {
+					// NB: Remember that we are storing the position
+					// of the tag, not the actualv value!!!
+					nValue = g_pXMLTags[pParse->m_naTree[j]].m_nValue;
+					if (nValue != g_pXMLTags[i].m_naTree[j])
+						nFound = -1;
+				}
+			}
+		}
+		i++;
+	}
+
+	if (nFound == -1) {
+		pParse->m_nWarnings++;
+		fprintf(stderr, "warning: %s(%d): Unexpected XML structure/tag \"%s\" found. (Ignoring)\n",
+			pParse->m_szXMLFile,
+			XML_GetCurrentLineNumber(pParse->m_pParser), szName);
+	}
+
+	return nFound;
+}
+
+int verifyXMLAttr(const char* szAttr,
+		  t_structXMLParse* pParse,
+		  int nTagPos)
+{
+	int nFound = -1;
+	int i = 0;
+
+	while ((nFound == -1) && (g_pXMLTags[nTagPos].m_saAttrs[i].m_szName)) {
+		if (!strcasecmp(szAttr, g_pXMLTags[nTagPos].m_saAttrs[i].m_szName))
+			nFound = i;
+		i++;
+	}
+
+	if (nFound == -1) {
+		pParse->m_nWarnings++;
+		fprintf(stderr, "warning: %s(%d): Unexpected tag attribute \"%s\" for tag \"%s\" found.\n",
+			pParse->m_szXMLFile,
+			XML_GetCurrentLineNumber(pParse->m_pParser),
+			szAttr, g_pXMLTags[nTagPos].m_szName);
+	}
+
+	return nFound;
+}
+
+int verifyXMLAttrType(const t_structXMLAttr* pAttr,
+		      const t_structXMLAttrAttr* pAttrAttr,
+		      t_structXMLParse* pParse,
+		      int nTagPos)
+{
+	int i = 0;
+	int nError = 0;
+	char* szTmp;
+	char* szOld;
+	FILE* fTmp;
+
+	if (!pAttr->m_szValue || !strlen(pAttr->m_szValue)) {
+		pParse->m_nErrors++;
+		fprintf(stderr, "error: %s(%d): Attribute \"%s\" for tag \"%s\" does not have a value.\n",
+			pParse->m_szXMLFile,
+			XML_GetCurrentLineNumber(pParse->m_pParser),
+			pAttr->m_szName,
+			g_pXMLTags[nTagPos].m_szName);
+		return ++nError;
+	}
+
+	switch (pAttrAttr->m_nType) {
+		case ATTRTYPE_ALPHA:
+			while ((!nError) && (pAttr->m_szValue[i])) {
+				if (!isalpha(pAttr->m_szValue[i])) {
+					fprintf(stderr, "error: %s(%d): Attribute \"%s\" for tag \"%s\" contains non-alphabetic characters.\n",
+						pParse->m_szXMLFile,
+						XML_GetCurrentLineNumber(pParse->m_pParser),
+						pAttr->m_szName,
+						g_pXMLTags[nTagPos].m_szName);
+					nError++;
+				}
+				i++;
+			}
+			break;
+		case ATTRTYPE_NUMERIC:
+			while ((!nError) && (pAttr->m_szValue[i])) {
+				if (!isdigit(pAttr->m_szValue[i])) {
+					fprintf(stderr, "error: %s(%d): Attribute \"%s\" for tag \"%s\" contains non-numeric characters.\n",
+						pParse->m_szXMLFile,
+						XML_GetCurrentLineNumber(pParse->m_pParser),
+						pAttr->m_szName,
+						g_pXMLTags[nTagPos].m_szName);
+					nError++;
+				}
+				i++;
+			}
+			break;
+		case ATTRTYPE_BOOL:
+			nError++;
+			if (!strcasecmp(pAttr->m_szValue, "yes") ||
+			    !strcasecmp(pAttr->m_szValue, "no") ||
+			    !strcasecmp(pAttr->m_szValue, "true") ||
+			    !strcasecmp(pAttr->m_szValue, "false") ||
+			    !strcasecmp(pAttr->m_szValue, "0") ||
+			    !strcasecmp(pAttr->m_szValue, "1"))
+				nError = 0;
+			if (nError) {
+				fprintf(stderr, "error: %s(%d): Attribute \"%s\" for tag \"%s\" does not contain a valid boolean value. Allowed values are: \"yes\"/\"no\", \"true\"/\"false\" or \"1\"/\"0\" combinations.\n",
+					pParse->m_szXMLFile,
+					XML_GetCurrentLineNumber(pParse->m_pParser),
+					pAttr->m_szName,
+					g_pXMLTags[nTagPos].m_szName);
+			}
+			break;
+		case ATTRTYPE_EMAIL:
+			break;
+		case ATTRTYPE_DATE:
+			break;
+		case ATTRTYPE_CMP:
+			nError++;
+			if (!strcasecmp(pAttr->m_szValue, "eq") ||
+			    !strcasecmp(pAttr->m_szValue, "lt") ||
+			    !strcasecmp(pAttr->m_szValue, "le") ||
+			    !strcasecmp(pAttr->m_szValue, "gt") ||
+			    !strcasecmp(pAttr->m_szValue, "ge"))
+				nError = 0;
+			if (nError) {
+				fprintf(stderr, "error: %s(%d): Attribute \"%s\" for tag \"%s\" does not contain a valid comparison value. Allowed values are: \"eq\" (equal), \"lt\" (less), \"le\" (less or equal), \"gt\" (greater) and \"ge\" (greater or equal).\n",
+					pParse->m_szXMLFile,
+					XML_GetCurrentLineNumber(pParse->m_pParser),
+					pAttr->m_szName,
+					g_pXMLTags[nTagPos].m_szName);
+			}
+			break;
+		case ATTRTYPE_SCRIPT:
+			/*nError++;
+			szTmp = NULL;
+			szOld = NULL;
+			newStr(pAttr->m_szValue, &szOld);
+			if (g_szSpecPath) {
+				szTmp = malloc(strlen(g_szSpecPath)+strlen(szOld)+2);
+				sprintf(szTmp, "%s/%s", g_szSpecPath, szOld);
+			}
+			else {
+				szTmp = malloc(strlen(szOld)+2);
+				sprintf(szTmp, "%s", szOld);
+			}
+			newStrEx(szTmp, (char**)&(pAttr->m_szValue));
+			if ((fTmp = fopen(pAttr->m_szValue, "r"))) {
+				nError = 0;
+				fclose(fTmp);
+				freeStr(&szOld);
+			}
+			freeStr(&szTmp);
+			if (!nError)
+				break;
+			newStrEx(szOld, (char**)&(pAttr->m_szValue));
+			freeStr(&szOld);
+			nError = 0;*/
+		case ATTRTYPE_SRCFILE:
+			nError++;
+			szTmp = NULL;
+			szOld = NULL;
+			newStr(pAttr->m_szValue, &szOld);
+			szTmp = malloc(strlen("%%{_sourcedir}")+strlen(pAttr->m_szValue)+2);
+			sprintf(szTmp, "%%{_sourcedir}/%s", szOld);
+			newStrEx(szTmp, (char**)&(pAttr->m_szValue));
+			if ((fTmp = fopen(pAttr->m_szValue, "r"))) {
+				nError = 0;
+				fclose(fTmp);
+			}
+
+			if (nError) {
+				fprintf(stderr, "error: %s(%d): File \"%s\" (attribute \"%s\" for tag \"%s\") does not exist.\n",
+					pParse->m_szXMLFile,
+					XML_GetCurrentLineNumber(pParse->m_pParser),
+					pAttr->m_szValue,
+					pAttr->m_szName,
+					g_pXMLTags[nTagPos].m_szName);
+				newStr(szOld, (char**)&(pAttr->m_szValue));
+			}
+			freeStr(&szTmp);
+			freeStr(&szOld);
+			break;
+		case ATTRTYPE_URL:
+			break;
+		case ATTRTYPE_MD5:
+			if (strlen(pAttr->m_szValue) != 32) {
+				fprintf(stderr, "error: %s(%d): Attribute \"%s\" for tag \"%s\" does not contain a valid MD5 sum.\n",
+					pParse->m_szXMLFile,
+					XML_GetCurrentLineNumber(pParse->m_pParser),
+					pAttr->m_szName,
+					g_pXMLTags[nTagPos].m_szName);
+				nError++;
+			}
+			break;
+		case ATTRTYPE_COUNTRY:
+			if (strlen(pAttr->m_szValue) != 2) {
+				fprintf(stderr, "error: %s(%d): Attribute \"%s\" for tag \"%s\" does not contain a valid country code.\n",
+					pParse->m_szXMLFile,
+					XML_GetCurrentLineNumber(pParse->m_pParser),
+					pAttr->m_szName,
+					g_pXMLTags[nTagPos].m_szName);
+				nError++;
+			}
+		case ATTRTYPE_ANY:
+		default:
+			break;
+	}
+
+	return nError;
+}
+
+int verifyXMLAttrs(const char** szaAttrs,
+		   t_structXMLParse* pParse,
+		   int nTagPos)
+
+{
+	int i = 0;
+	int nRet = 1;
+	int nFound = 0;
+	int nAttrPos = 0;
+	t_structXMLAttr* pAttr = NULL;
+
+	// add all tags
+	freeXMLAttr(&(pParse->m_pAttrs));
+	for (i = 0; szaAttrs[i]; i += 2) {
+		if ((nAttrPos = verifyXMLAttr(szaAttrs[i], pParse, nTagPos)) != -1)
+			addXMLAttr(szaAttrs[i], szaAttrs[i+1],
+				   g_pXMLTags[nTagPos].m_saAttrs[nAttrPos].m_nType,
+				   &(pParse->m_pAttrs));
+	}
+
+	// verify mandatory tags and check attribute type
+	for (i = 0; g_pXMLTags[nTagPos].m_saAttrs[i].m_szName; i++) {
+		pAttr = pParse->m_pAttrs;
+		nFound = 0;
+		while ((!nFound) && (pAttr)) {
+			if (!strcasecmp(pAttr->m_szName,
+					g_pXMLTags[nTagPos].m_saAttrs[i].m_szName)) {
+				nFound = 1;
+				pParse->m_nErrors += verifyXMLAttrType(pAttr,
+						     &(g_pXMLTags[nTagPos].m_saAttrs[i]),
+						     pParse, nTagPos);
+			}
+			else
+				pAttr = pAttr->m_pNext;
+		}
+		if ((!nFound) && (g_pXMLTags[nTagPos].m_saAttrs[i].m_nMandatory)) {
+			pParse->m_nErrors++;
+			fprintf(stderr, "error: %s(%d): Mandatory attribute (%s) for tag \"%s\" not found.\n",
+				pParse->m_szXMLFile,
+				XML_GetCurrentLineNumber(pParse->m_pParser),
+				g_pXMLTags[nTagPos].m_saAttrs[i].m_szName,
+				g_pXMLTags[nTagPos].m_szName);
+			nRet = -1;
+		}
+	}
+
+	return nRet;
+}
diff --git a/xmlspec/xmlverify.h b/xmlspec/xmlverify.h
new file mode 100644
index 000000000..0eba1e280
--- /dev/null
+++ b/xmlspec/xmlverify.h
@@ -0,0 +1,97 @@
+#ifndef _XML_VERIFY_H_
+#define _XML_VERIFY_H_
+
+#include "xmlparse.h"
+
+typedef enum enumXMLTagVals
+{
+	TAGVAL_SPEC                   = 0,
+	TAGVAL_MACRO,
+	TAGVAL_SOURCE,
+	TAGVAL_SOURCEMIRROR,
+	TAGVAL_PATCH,
+	TAGVAL_PATCHMIRROR,
+	TAGVAL_BUILDREQUIRES,
+	TAGVAL_BUILDREQUIRE,
+	TAGVAL_BUILDSUGGESTS,
+	TAGVAL_BUILDSUGGEST,
+	TAGVAL_PACKAGE,
+	TAGVAL_PROVIDE,
+	TAGVAL_PROVIDES,
+	TAGVAL_REQUIRES,
+	TAGVAL_REQUIRE,
+	TAGVAL_OBSOLETES,
+	TAGVAL_OBSOLETE,
+	TAGVAL_SUGGESTS,
+	TAGVAL_SUGGEST,
+	TAGVAL_SUMMARY,
+	TAGVAL_DESCRIPTION,
+	TAGVAL_PRE,
+	TAGVAL_POST,
+	TAGVAL_PREUN,
+	TAGVAL_POSTUN,
+	TAGVAL_VERIFY,
+	TAGVAL_FILES,
+	TAGVAL_PREP,
+	TAGVAL_BUILD,
+	TAGVAL_INSTALL,
+	TAGVAL_CLEAN,
+	TAGVAL_SCRIPT,
+	TAGVAL_SETUPMACRO,
+	TAGVAL_PATCHMACRO,
+	TAGVAL_CHANGELOG,
+	TAGVAL_CHANGES,
+	TAGVAL_CHANGE,
+	TAGVAL_LAST                   = 0xFFFF
+} t_enumXMLTagVals;
+
+typedef enum enumXMLAttrTypes
+{
+	ATTRTYPE_ANY                  = 0,
+	ATTRTYPE_ALPHA,
+	ATTRTYPE_NUMERIC,
+	ATTRTYPE_BOOL,
+	ATTRTYPE_EMAIL,
+	ATTRTYPE_DATE,
+	ATTRTYPE_CMP,
+	ATTRTYPE_SRCFILE,
+	ATTRTYPE_SCRIPT,
+	ATTRTYPE_URL,
+	ATTRTYPE_MD5,
+	ATTRTYPE_COUNTRY,
+	ATTRTYPE_LAST                 = 0xFFFF
+} t_enumXMLAttrTypes;
+
+typedef struct structXMLAttrAttr
+{
+	char* m_szName;
+	int   m_nType;
+	int   m_nMandatory;
+} t_structXMLAttrAttr;
+
+typedef struct structXMLTags
+{
+	char*               m_szName;
+	int                 m_nValue;
+	int                 m_nLevel;
+	int                 m_naTree[MAX_XML_LEVELS];
+	t_structXMLAttrAttr m_saAttrs[MAX_XML_ATTRS];
+} t_structXMLTags;
+
+#ifndef NO_XMLTAGS_EXTERN
+extern t_structXMLTags g_pXMLTags[];
+#endif
+
+int verifyXMLPath(const char* szName,
+		  t_structXMLParse* pParse);
+
+int verifyXMLAttr(const char* szAttr,
+		  t_structXMLParse* pParse,
+		  int nTagPos);
+
+int verifyXMLAttrs(const char** szaAttrs,
+		   t_structXMLParse* pParse,
+		   int nTagPos);
+
+#endif
+