EFI_STATUS ParseTagList( CHAR8* buffer, TagPtr * tag, UINT32 type, UINT32 empty, UINT32* lenPtr)
{
EFI_STATUS Status=EFI_SUCCESS;
UINT32 pos;
TagPtr tagList;
TagPtr tmpTag;
UINT32 length=0;
tagList = NULL;
pos = 0;
if (!empty)
{
while (TRUE)
{
Status = XMLParseNextTag(buffer + pos, &tmpTag,&length);
if (EFI_ERROR(Status))
break;
pos += length;
if (tmpTag == NULL)
break;
tmpTag->tagNext = tagList;
tagList = tmpTag;
}
if (EFI_ERROR(Status))
{
FreeTag(tagList);
return Status;
}
}
tmpTag = NewTag();
if (tmpTag == NULL)
{
FreeTag(tagList);
return EFI_UNSUPPORTED;
}
tmpTag->type = type;
tmpTag->string = 0;
tmpTag->offset = buffer_start ? buffer - buffer_start : 0;
tmpTag->tag = tagList;
tmpTag->tagNext = 0;
*tag = tmpTag;
*lenPtr=pos;
return Status;
}
static long ParseTagInteger(char *buffer, TagPtr *tag)
{
long length;
char *intString;
TagPtr tmpTag;
length = FixDataMatchingTag(buffer, kXMLTagInteger);
if (length == -1) return -1;
tmpTag = NewTag();
if (tmpTag == 0) return -1;
intString = NewSymbol(buffer);
if (intString == 0) {
FreeTag(tmpTag);
return -1;
}
tmpTag->type = kTagTypeInteger;
tmpTag->string = intString;
tmpTag->tag = 0;
tmpTag->tagNext = 0;
*tag = tmpTag;
return length;
}
EFI_STATUS ParseTagString(CHAR8* buffer, TagPtr * tag,UINT32* lenPtr)
{
EFI_STATUS Status;
UINT32 length;
CHAR8* string;
TagPtr tmpTag;
Status = FixDataMatchingTag(buffer, kXMLTagString,&length);
if (EFI_ERROR(Status))
return Status;
tmpTag = NewTag();
if (tmpTag == NULL)
return EFI_UNSUPPORTED;
string = NewSymbol(buffer);
if (string == NULL)
{
FreeTag(tmpTag);
return EFI_UNSUPPORTED;
}
tmpTag->type = kTagTypeString;
tmpTag->string = string;
tmpTag->tag = NULL;
tmpTag->tagNext = NULL;
tmpTag->offset = buffer_start ? buffer - buffer_start: 0;
*tag = tmpTag;
*lenPtr=length;
return EFI_SUCCESS;
}
// currently a no-op
void FreeTag(TagPtr tag)
{
return; // XXXX revisit callers, particularly ParseTagKey (4063982)
if (tag == 0) return;
if (tag->string) FreeSymbol(tag->string);
FreeTag(tag->tag);
FreeTag(tag->tagNext);
// Clear and free the tag.
tag->type = kTagTypeNone;
tag->string = 0;
tag->tag = 0;
tag->tagNext = gTagsFree;
gTagsFree = tag;
}
static long ParseTagList(char *buffer, TagPtr *tag, long type, long empty)
{
long length, pos;
TagPtr tagList, tmpTag = (TagPtr)-1;
tagList = 0;
pos = 0;
if (!empty) {
while (1) {
tmpTag = (TagPtr)-1;
length = ParseNextTag(buffer + pos, &tmpTag);
if (length == -1) break;
pos += length;
// detect end of list
if (tmpTag == 0) break;
// if we made a new tag, insert into list
if (tmpTag != (TagPtr)-1) {
tmpTag->tagNext = tagList;
tagList = tmpTag;
}
}
if (length == -1) {
FreeTag(tagList);
return -1;
}
}
tmpTag = NewTag();
if (tmpTag == 0) {
FreeTag(tagList);
return -1;
}
tmpTag->type = type;
tmpTag->string = 0;
tmpTag->tag = tagList;
tmpTag->tagNext = 0;
*tag = tmpTag;
return pos;
}
void FreeTag( TagPtr tag )
{
if (tag == NULL)
return;
if (tag->string) FreeSymbol(tag->string);
FreeTag(tag->tag);
FreeTag(tag->tagNext);
// Clear and free the tag.
tag->type = kTagTypeNone;
tag->string = NULL;
tag->tag = NULL;
tag->offset = 0;
tag->tagNext = gTagsFree;
gTagsFree = tag;
}
EFI_STATUS ParseTagKey( char * buffer, TagPtr * tag,UINT32* lenPtr)
{
EFI_STATUS Status;
UINT32 length;
UINT32 length2;
CHAR8* string;
TagPtr tmpTag;
TagPtr subTag;
Status = FixDataMatchingTag(buffer, kXMLTagKey,&length);
if (EFI_ERROR(Status))
return Status;
Status = XMLParseNextTag(buffer + length, &subTag,&length2);
if (EFI_ERROR(Status))
return Status;
tmpTag = NewTag();
if (tmpTag == NULL)
{
FreeTag(subTag);
return EFI_UNSUPPORTED;
}
string = NewSymbol(buffer);
if (string == NULL)
{
FreeTag(subTag);
FreeTag(tmpTag);
return EFI_UNSUPPORTED;
}
tmpTag->type = kTagTypeKey;
tmpTag->string = string;
tmpTag->tag = subTag;
tmpTag->offset = buffer_start ? buffer - buffer_start: 0;
tmpTag->tagNext = 0;
*tag = tmpTag;
*lenPtr=length + length2;
return EFI_SUCCESS;
}
static long ParseTagKey(char *buffer, TagPtr *tag)
{
long length, length2;
char *string;
TagPtr tmpTag, subTag = (TagPtr)-1; // eliminate possible stale tag
length = FixDataMatchingTag(buffer, kXMLTagKey);
if (length == -1) return -1;
length2 = ParseNextTag(buffer + length, &subTag);
if (length2 == -1) return -1;
// XXXX revisit 4063982 if FreeTag becomes real
if(subTag == (TagPtr)-1)
subTag = NULL;
tmpTag = NewTag();
if (tmpTag == 0) {
FreeTag(subTag);
return -1;
}
string = NewSymbol(buffer);
if (string == 0) {
FreeTag(subTag);
FreeTag(tmpTag);
return -1;
}
tmpTag->type = kTagTypeKey;
tmpTag->string = string;
tmpTag->tag = subTag;
tmpTag->tagNext = 0;
*tag = tmpTag;
return length + length2;
}
EFI_STATUS ParseXML(const CHAR8* buffer, TagPtr * dict)
{
EFI_STATUS Status;
UINT32 length=0;
UINT32 pos=0;
TagPtr tag=NULL;
CHAR8* configBuffer=NULL;
UINT32 bufferSize=(UINT32)AsciiStrLen(buffer)+1;
if(dict==NULL)
return EFI_UNSUPPORTED;
*dict=NULL;
configBuffer=AllocateZeroPool(bufferSize);
if(configBuffer==NULL)
return EFI_UNSUPPORTED;
CopyMem(configBuffer,buffer,bufferSize);
buffer_start = configBuffer;
while (TRUE)
{
Status = XMLParseNextTag(configBuffer + pos, &tag, &length);
if (EFI_ERROR(Status))
break;
pos += length;
if (tag == NULL)
continue;
if (tag->type == kTagTypeDict)
break;
FreeTag(tag);
}
FreePool(configBuffer);
if (EFI_ERROR(Status))
return Status;
*dict = tag;
return EFI_SUCCESS;
}
long ParseXML(char *buffer, TagPtr *dict)
{
long length, pos;
TagPtr moduleDict;
#if PLIST_DEBUG
gTagsParsed = 0;
gLastTag = NULL;
#endif
if (InitTagCache()) return -1;
pos = 0;
while (1) {
moduleDict = (TagPtr)-1; // have to detect changes to by-ref parameter
length = ParseNextTag(buffer + pos, &moduleDict);
if (length == -1) break;
pos += length;
if (moduleDict == 0) continue;
// did we actually create anything?
if (moduleDict != (TagPtr)-1) {
if (moduleDict->type == kTagTypeDict) break;
if (moduleDict->type == kTagTypeArray) break;
FreeTag(moduleDict);
}
}
*dict = moduleDict;
#if PLIST_DEBUG
if (length == -1)
printf("ParseXML gagged (-1) after %s (%d tags); buf+pos: %s\n",
gLastTag,gTagsParsed,buffer+pos);
#endif
// for tidyness even though kext parsing resets all of malloc
FreeTagCache();
// return 0 for no error
return (length != -1) ? 0 : -1;
}
