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; }