Datasets:
LLM4Binary
/
decompile-bench

Dataset card Data Studio Files
xet
 Community
1
name
string
code
string
asm
string
file
string
htmlParseHTMLName
static const xmlChar * htmlParseHTMLName(htmlParserCtxtPtr ctxt) { int i = 0; xmlChar loc[HTML_PARSER_BUFFER_SIZE]; if (!IS_ASCII_LETTER(CUR) && (CUR != '_') && (CUR != ':') && (CUR != '.')) return(NULL); while ((i < HTML_PARSER_BUFFER_SIZE) && ((IS_ASCII_LETTER(CUR)) || (IS_ASCII_D...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x68, %rsp movq %rdi, %rbx movq 0x38(%rdi), %rax movq 0x20(%rax), %rax movzbl (%rax), %ecx movl %ecx, %eax andb $-0x21, %al addb $-0x41, %al cmpb $0x1a, %al jb 0x4df2e xorl %eax, %eax addl $-0x2e, %ecx cmpl $0x31, %ecx ja 0x4dfa6 movabsq $0x2000000001001, %rdx # imm = ...
/frida[P]libxml2/HTMLparser.c
htmlCheckImplied
static void htmlCheckImplied(htmlParserCtxtPtr ctxt, const xmlChar *newtag) { int i; if (ctxt->options & HTML_PARSE_NOIMPLIED) return; if (!htmlOmittedDefaultValue) return; if (xmlStrEqual(newtag, BAD_CAST"html")) return; if (ctxt->nameNr <= 0) { htmlnamePush(ctxt, BAD_CAST"html"); if (...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax testb $0x20, 0x235(%rdi) jne 0x4e079 cmpl $0x0, 0xe1451(%rip) # 0x12f480 je 0x4e079 movq %rsi, %r14 movq %rdi, %rbx leaq 0x9fd69(%rip), %rsi # 0xedda7 movq %r14, %rdi callq 0x35170 testl %eax, %eax jne 0x4e079 cmpl $0x0, 0x128(%rbx) jle 0x4e085 leaq 0x91f09...
/frida[P]libxml2/HTMLparser.c
htmlParseHTMLAttribute
static xmlChar * htmlParseHTMLAttribute(htmlParserCtxtPtr ctxt, const xmlChar stop) { xmlChar *buffer = NULL; int buffer_size = 0; xmlChar *out = NULL; const xmlChar *name = NULL; const xmlChar *cur = NULL; const htmlEntityDesc * ent; /* * allocate a translation buffer. */ buf...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movl %esi, %ebp movq %rdi, %rbx andq $0x0, 0x18(%rsp) movq 0xde7e9(%rip), %rax # 0x12cb30 pushq $0x64 popq %rdi callq *(%rax) testq %rax, %rax je 0x4e70b movq %rax, %r13 movq %rbx, 0x10(%rsp) pushq $0x64 popq %rsi pushq $0x1 popq %rb...
/frida[P]libxml2/HTMLparser.c
htmlSkipBogusComment
static void htmlSkipBogusComment(htmlParserCtxtPtr ctxt) { int c; htmlParseErr(ctxt, XML_HTML_INCORRECTLY_OPENED_COMMENT, "Incorrectly opened comment\n", NULL, NULL); do { c = CUR; if (c == 0) break; NEXT; } while (c != '>'); }
pushq %rbp pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x9483c(%rip), %rdx # 0xe3702 movl $0x322, %esi # imm = 0x322 xorl %ecx, %ecx xorl %r8d, %r8d callq 0x49001 movq 0x38(%rbx), %rax movq 0x20(%rax), %rax movb (%rax), %bpl testb %bpl, %bpl je 0x4eef3 movq %rbx, %rdi callq 0x35590 cmpb $0x3e, %bpl jne 0x...
/frida[P]libxml2/HTMLparser.c
htmlCheckParagraph
static int htmlCheckParagraph(htmlParserCtxtPtr ctxt) { const xmlChar *tag; int i; if (ctxt == NULL) return(-1); tag = ctxt->name; if (tag == NULL) { htmlAutoClose(ctxt, BAD_CAST"p"); htmlCheckImplied(ctxt, BAD_CAST"p"); htmlnamePush(ctxt, BAD_CAST"p"); if ((ctxt->sax != NULL) && (ctxt->sax->s...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x120(%rdi), %r14 testq %r14, %r14 je 0x4f4f3 cmpl $0x0, 0xdffb3(%rip) # 0x12f480 je 0x4f546 xorl %r15d, %r15d leaq 0xdc407(%rip), %r12 # 0x12b8e0 cmpq $0x10, %r15 je 0x4f546 movq (%r15,%r12), %rsi movq %r14, %rdi callq 0x35170 addq $0x...
/frida[P]libxml2/HTMLparser.c
htmlParseLookupSequence
static int htmlParseLookupSequence(htmlParserCtxtPtr ctxt, xmlChar first, xmlChar next, xmlChar third, int ignoreattrval) { int base, len; htmlParserInputPtr in; const xmlChar *buf; int invalue = 0; char valdellim = 0x0; in = ctxt->input; if (in == NULL) retu...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %edx, %r15d movq 0x38(%rdi), %rdx pushq $-0x1 popq %r11 testq %rdx, %rdx je 0x4fa60 movq 0x18(%rdx), %r13 movq 0x20(%rdx), %r14 subq %r13, %r14 testl %r14d, %r14d js 0x4fa60 movl %ecx, %ebp movl %esi, %r12d movq 0x140(%rdi), %rax mo...
/frida[P]libxml2/HTMLparser.c
htmlParseLookupCommentEnd
static int htmlParseLookupCommentEnd(htmlParserCtxtPtr ctxt) { int mark = 0; int cur = CUR_PTR - BASE_PTR; while (mark >= 0) { mark = htmlParseLookupSequence(ctxt, '-', '-', 0, 0); if ((mark < 0) || (NXT(mark+2) == '>') || ((NXT(mark+2) == '!') && (NXT(mark+3) == '>'))) { return mark; } ...
pushq %rbp pushq %r14 pushq %rbx movq %rdi, %rbx movq 0x38(%rdi), %rax movl 0x20(%rax), %r14d subl 0x18(%rax), %r14d incl %r14d pushq $0x2d popq %rbp movq %rbx, %rdi movl %ebp, %esi movl %ebp, %edx xorl %ecx, %ecx callq 0x4f908 testl %eax, %eax js 0x4facd movq 0x38(%rbx), %rcx movq 0x20(%rcx), %rcx movl %eax, %edx movz...
/frida[P]libxml2/HTMLparser.c
htmlNodeDumpFileFormat
int htmlNodeDumpFileFormat(FILE *out, xmlDocPtr doc, xmlNodePtr cur, const char *encoding, int format) { xmlOutputBufferPtr buf; xmlCharEncodingHandlerPtr handler = NULL; int ret; xmlInitParser(); if (encoding != NULL) { xmlCharEncoding enc; enc = xmlParseCharEncoding(encoding);...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %r8d, %ebx movq %rcx, %rbp movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %r12 callq 0x32ce0 testq %rbp, %rbp je 0x50176 movq %rbp, %rdi callq 0x35540 cmpl $0x1, %eax jne 0x50195 xorl %r13d, %r13d jmp 0x501a5 leaq 0x8ee2e(%rip), %rdi # 0x...
/frida[P]libxml2/HTMLtree.c
htmlSaveErr
static void htmlSaveErr(int code, xmlNodePtr node, const char *extra) { const char *msg = NULL; switch(code) { case XML_SAVE_NOT_UTF8: msg = "string is not in UTF-8\n"; break; case XML_SAVE_CHAR_INVALID: msg = "invalid character value\n"; break; case XML_SAVE_UNKNOWN_ENCODING: ...
movq %rdx, %r8 movq %rsi, %rdx movl %edi, %esi cmpl $0x57a, %edi # imm = 0x57A leaq 0x93a92(%rip), %rax # 0xe3cad leaq 0x933d3(%rip), %rcx # 0xe35f5 cmoveq %rax, %rcx pushq $0x7 popq %rdi jmp 0x32090
/frida[P]libxml2/HTMLtree.c
htmlDocContentDumpFormatOutput
void htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf, xmlDocPtr cur, const char *encoding ATTRIBUTE_UNUSED, int format) { int type = 0; if (cur) { type = cur->type; cur->type = XML_HTML_DOCUMENT_NODE; } htmlNodeDumpFormatOutput...
pushq %rbp pushq %rbx pushq %rax movl %ecx, %r8d movq %rsi, %rbx testq %rsi, %rsi je 0x50a5a movl 0x8(%rbx), %ebp movl $0xd, 0x8(%rbx) jmp 0x50a5c xorl %ebp, %ebp movq %rbx, %rsi movq %rbx, %rdx xorl %ecx, %ecx callq 0x35be0 testq %rbx, %rbx je 0x50a71 movl %ebp, 0x8(%rbx) addq $0x8, %rsp popq %rbx popq %rbp retq
/frida[P]libxml2/HTMLtree.c
htmlSaveFile
int htmlSaveFile(const char *filename, xmlDocPtr cur) { xmlOutputBufferPtr buf; xmlCharEncodingHandlerPtr handler = NULL; const char *encoding; int ret; if ((cur == NULL) || (filename == NULL)) return(-1); xmlInitParser(); encoding = (const char *) htmlGetMetaEncoding(cur); i...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax testq %rsi, %rsi sete %al testq %rdi, %rdi sete %cl orb %al, %cl je 0x50d26 pushq $-0x1 popq %rax jmp 0x50db8 movq %rsi, %rbx movq %rdi, %r14 callq 0x32ce0 movq %rbx, %rdi callq 0x33b30 testq %rax, %rax je 0x50d53 movq %rax, %r12 movq %rax, %rdi callq 0x35540 cmpl ...
/frida[P]libxml2/HTMLtree.c
xmlListReverseSearch
void * xmlListReverseSearch(xmlListPtr l, void *data) { xmlLinkPtr lk; if (l == NULL) return(NULL); lk = xmlListLinkReverseSearch(l, data); if (lk) return (lk->data); return NULL; }
testq %rdi, %rdi je 0x51018 pushq %rax callq 0x51022 testq %rax, %rax je 0x5101b movq 0x10(%rax), %rax jmp 0x5101d xorl %eax, %eax retq xorl %eax, %eax addq $0x8, %rsp retq
/frida[P]libxml2/list.c
xmlListInsert
int xmlListInsert(xmlListPtr l, void *data) { xmlLinkPtr lkPlace, lkNew; if (l == NULL) return(1); lkPlace = xmlListLowerSearch(l, data); /* Add the new link */ lkNew = (xmlLinkPtr) xmlMalloc(sizeof(xmlLink)); if (lkNew == NULL) { xmlGenericError(xmlGenericErrorContext, ...
pushq %r15 pushq %r14 pushq %rbx pushq $0x1 popq %rbx testq %rdi, %rdi je 0x510bb movq %rsi, %r14 callq 0x510c3 movq %rax, %r15 movq 0xdbf58(%rip), %rax # 0x12cfd0 pushq $0x18 popq %rdi callq *(%rax) testq %rax, %rax je 0x5109f movq %r14, 0x10(%rax) movq 0x8(%r15), %rcx movq (%rcx), %rdx movq %rdx, (%rax) movq %rax...
/frida[P]libxml2/list.c
xmlListAppend
int xmlListAppend(xmlListPtr l, void *data) { xmlLinkPtr lkPlace, lkNew; if (l == NULL) return(1); lkPlace = xmlListHigherSearch(l, data); /* Add the new link */ lkNew = (xmlLinkPtr) xmlMalloc(sizeof(xmlLink)); if (lkNew == NULL) { xmlGenericError(xmlGenericErrorContext, ...
pushq %r15 pushq %r14 pushq %rbx pushq $0x1 popq %rbx testq %rdi, %rdi je 0x5114f movq %rsi, %r14 callq 0x51157 movq %rax, %r15 movq 0xdbec0(%rip), %rax # 0x12cfd0 pushq $0x18 popq %rdi callq *(%rax) testq %rax, %rax je 0x51133 movq %r14, 0x10(%rax) movq (%r15), %rcx movq %rcx, (%rax) movq %rax, 0x8(%rcx) movq %rax...
/frida[P]libxml2/list.c
xmlListRemoveLast
int xmlListRemoveLast(xmlListPtr l, void *data) { xmlLinkPtr lk; if (l == NULL) return(0); /*Find the last instance of this data */ lk = xmlListLinkReverseSearch(l, data); if (lk != NULL) { xmlLinkDeallocator(l, lk); return 1; } return 0; }
pushq %r14 pushq %rbx pushq %rax xorl %ebx, %ebx testq %rdi, %rdi je 0x51270 movq %rdi, %r14 callq 0x51022 testq %rax, %rax je 0x51270 movq %r14, %rdi movq %rax, %rsi callq 0x5121d pushq $0x1 popq %rbx movl %ebx, %eax addq $0x8, %rsp popq %rbx popq %r14 retq
/frida[P]libxml2/list.c
xmlListSize
int xmlListSize(xmlListPtr l) { xmlLinkPtr lk; int count=0; if (l == NULL) return(-1); /* TODO: keep a counter in xmlList instead */ for(lk = l->sentinel->next; lk != l->sentinel; lk = lk->next, count++); return count; }
testq %rdi, %rdi je 0x512f5 movq (%rdi), %rcx pushq $-0x1 popq %rax movq %rcx, %rdx movq (%rdx), %rdx incl %eax cmpq %rcx, %rdx jne 0x512ea retq pushq $-0x1 popq %rax retq
/frida[P]libxml2/list.c
xmlListReverse
void xmlListReverse(xmlListPtr l) { xmlLinkPtr lk; xmlLinkPtr lkPrev; if (l == NULL) return; lkPrev = l->sentinel; for (lk = l->sentinel->next; lk != l->sentinel; lk = lk->next) { lkPrev->next = lkPrev->prev; lkPrev->prev = lk; lkPrev = lk; } /* Fix up the la...
testq %rdi, %rdi je 0x51423 movq (%rdi), %rax movq %rax, %rcx movq (%rcx), %rdx movq 0x8(%rcx), %rsi movq %rsi, (%rcx) movq %rdx, 0x8(%rcx) movq %rdx, %rcx cmpq %rax, %rdx jne 0x5140d retq
/frida[P]libxml2/list.c
xmlListDup
xmlListPtr xmlListDup(const xmlListPtr old) { xmlListPtr cur; if (old == NULL) return(NULL); /* Hmmm, how to best deal with allocation issues when copying * lists. If there is a de-allocator, should responsibility lie with * the new list or the old list. Surely not both. I'll arbitrarily ...
pushq %r15 pushq %r14 pushq %rbx testq %rdi, %rdi je 0x514a9 movq %rdi, %r14 movq 0x10(%rdi), %rsi xorl %ebx, %ebx xorl %edi, %edi callq 0x34ec0 testq %rax, %rax je 0x514ab movq %rax, %r15 movq %rax, %rdi movq %r14, %rsi callq 0x34b20 xorl %ebx, %ebx testl %eax, %eax cmoveq %r15, %rbx jmp 0x514ab xorl %ebx, %ebx movq %...
/frida[P]libxml2/list.c
xmlListReverseWalk
void xmlListReverseWalk(xmlListPtr l, xmlListWalker walker, void *user) { xmlLinkPtr lk; if ((l == NULL) || (walker == NULL)) return; for(lk = l->sentinel->prev; lk != l->sentinel; lk = lk->prev) { if((walker(lk->data, user)) == 0) break; } }
testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl jne 0x51556 pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 movq (%rdi), %r12 movq 0x8(%r12), %r12 cmpq (%r15), %r12 je 0x5154b movq 0x10(%r12), %rdi movq %rbx, %rsi callq *%r14 testl %eax, %eax jne 0...
/frida[P]libxml2/list.c
xmlNanoHTTPCleanup
void xmlNanoHTTPCleanup(void) { if (proxy != NULL) { xmlFree(proxy); proxy = NULL; } #ifdef _WINSOCKAPI_ if (initialized) WSACleanup(); #endif initialized = 0; return; }
movq 0xde7f5(%rip), %rdi # 0x12fed0 testq %rdi, %rdi je 0x516f6 pushq %rax movq 0xdb8c8(%rip), %rax # 0x12cfb0 callq *(%rax) andq $0x0, 0xde7de(%rip) # 0x12fed0 addq $0x8, %rsp movb $0x0, 0xde7cb(%rip) # 0x12fec8 retq
/frida[P]libxml2/nanohttp.c
xmlNanoHTTPRead
int xmlNanoHTTPRead(void *ctx, void *dest, int len) { xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr) ctx; #ifdef LIBXML_ZLIB_ENABLED int bytes_read = 0; int orig_avail_in; int z_ret; #endif if (ctx == NULL) return(-1); if (dest == NULL) return(-1); if (len <= 0) return(0); #ifdef LIBXML_ZL...
testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl je 0x521cb pushq $-0x1 popq %rax retq pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movl %edx, %ebx xorl %eax, %eax testl %edx, %edx jle 0x522bf movq %rsi, %r15 movq %rdi, %r14 cmpl $0x1, 0xa8(%rdi) jne 0x5226c movq 0xa0(%r14), %rdi testq %rdi, %...
/frida[P]libxml2/nanohttp.c
xmlNanoHTTPNewCtxt
static xmlNanoHTTPCtxtPtr xmlNanoHTTPNewCtxt(const char *URL) { xmlNanoHTTPCtxtPtr ret; ret = (xmlNanoHTTPCtxtPtr) xmlMalloc(sizeof(xmlNanoHTTPCtxt)); if (ret == NULL) { xmlHTTPErrMemory("allocating context"); return(NULL); } memset(ret, 0, sizeof(xmlNanoHTTPCtxt)); ret->port =...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdi, %r14 movq 0xda9ef(%rip), %rax # 0x12cfd0 movl $0xb0, %edi callq *(%rax) movq %rax, %rbx testq %rax, %rax je 0x52685 movl $0xb0, %edx movq %rbx, %rdi xorl %esi, %esi callq 0x32350 movl $0x50, 0x10(%rbx) orl $-0x1, 0x28(%rbx) orl $-0x1, 0x70(%rbx) push...
/frida[P]libxml2/nanohttp.c
xmlNanoHTTPFetch
int xmlNanoHTTPFetch(const char *URL, const char *filename, char **contentType) { void *ctxt = NULL; char *buf = NULL; int fd; int len; int ret = 0; if (filename == NULL) return(-1); ctxt = xmlNanoHTTPOpen(URL, contentType); if (ctxt == NULL) return(-1); if (!strcmp(filename, "-"))...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x10, %rsp andq $0x0, (%rsp) pushq $-0x1 popq %rbx testq %rsi, %rsi je 0x52ab2 movq %rdx, %r15 movq %rsi, %r12 movq %rdx, %rsi callq 0x34720 testq %rax, %rax je 0x52ab2 movq %rax, %r14 cmpb $0x2d, (%r12) jne 0x52a30 cmpb $0x0, 0x1(%r12) je 0x52a6c pushq $0x41...
/frida[P]libxml2/nanohttp.c
socket_errno
static int socket_errno(void) { #ifdef _WINSOCKAPI_ int err = WSAGetLastError(); switch(err) { case WSAECONNRESET: return(ECONNRESET); case WSAEINPROGRESS: return(EINPROGRESS); case WSAEINTR: return(EINTR); case WSAESHUTDOWN: return...
pushq %rax callq 0x347e0 movl (%rax), %eax popq %rcx retq nop
/frida[P]libxml2/nanohttp.c
inputPush
int inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value) { if ((ctxt == NULL) || (value == NULL)) return(-1); if (ctxt->inputNr >= ctxt->inputMax) { ctxt->inputMax *= 2; ctxt->inputTab = (xmlParserInputPtr *) xmlRealloc(ctxt->inputTab, ...
pushq %rbp pushq %r14 pushq %rbx testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl pushq $-0x1 popq %rbp jne 0x52ed4 movq %rsi, %r14 movq %rdi, %rbx movl 0x40(%rdi), %ecx movslq 0x44(%rdi), %rsi cmpl %esi, %ecx jge 0x52e9f movq 0x48(%rbx), %rax jmp 0x52ec2 leal (%rsi,%rsi), %eax movl %eax, 0x44(%rbx) mov...
/frida[P]libxml2/parser.c
nodePush
int nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value) { if (ctxt == NULL) return(0); if (ctxt->nodeNr >= ctxt->nodeMax) { xmlNodePtr *tmp; tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab, ctxt->nodeMax * 2 * sizeof(ctxt->nodeTab...
testq %rdi, %rdi je 0x52faf pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx movl 0x58(%rdi), %eax movslq 0x5c(%rdi), %rsi cmpl %esi, %eax jl 0x52f66 movq 0xd9c43(%rip), %rax # 0x12cb90 movq 0x60(%rbx), %rdi shlq $0x4, %rsi callq *(%rax) testq %rax, %rax je 0x52fb2 movq %rax, 0x60(%rbx) shll 0x5c(%r...
/frida[P]libxml2/parser.c
namePop
const xmlChar * namePop(xmlParserCtxtPtr ctxt) { const xmlChar *ret; if ((ctxt == NULL) || (ctxt->nameNr <= 0)) return (NULL); ctxt->nameNr--; if (ctxt->nameNr > 0) ctxt->name = ctxt->nameTab[ctxt->nameNr - 1]; else ctxt->name = NULL; ret = ctxt->nameTab[ctxt->nameNr]; ...
testq %rdi, %rdi je 0x5321a movslq 0x128(%rdi), %rdx testq %rdx, %rdx jle 0x5321a leal -0x1(%rdx), %eax movl %eax, 0x128(%rdi) movq 0x130(%rdi), %rcx cmpl $0x1, %edx jne 0x5321d xorl %edx, %edx jmp 0x53222 xorl %eax, %eax retq movq -0x10(%rcx,%rdx,8), %rdx movq %rdx, 0x120(%rdi) movl %eax, %edx movq (%rcx,%rdx,8), %rax...
/frida[P]libxml2/parser.c
xmlParsePEReference
void xmlParsePEReference(xmlParserCtxtPtr ctxt) { const xmlChar *name; xmlEntityPtr entity = NULL; xmlParserInputPtr input; if (RAW != '%') return; NEXT; name = xmlParseName(ctxt); if (name == NULL) { xmlFatalErrMsg(ctxt, XML_ERR_PEREF_NO_NAME, "PEReference: no name\n"); return; ...
pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq 0x38(%rdi), %rax movq 0x20(%rax), %rax cmpb $0x25, (%rax) jne 0x5364e movq %rdi, %rbx callq 0x35590 movq %rbx, %rdi callq 0x32800 testq %rax, %rax je 0x53418 movq %rax, %r14 callq 0x32340 cmpl $0x0, (%rax) je 0x533da callq 0x34700 movq (%rax), %r15 callq 0x335a0 mo...
/frida[P]libxml2/parser.c
xmlFatalErr
static void xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info) { const char *errmsg; if ((ctxt != NULL) && (ctxt->disableSAX != 0) && (ctxt->instate == XML_PARSER_EOF)) return; switch (error) { case XML_ERR_INVALID_HEX_CHARREF: errmsg = "CharRef: invali...
pushq %rbx subq $0x60, %rsp movq %rdi, %rbx testq %rdi, %rdi je 0x5372e cmpl $0x0, 0x14c(%rbx) je 0x5372e cmpl $-0x1, 0x110(%rbx) je 0x53800 leal -0x1(%rsi), %eax cmpl $0x6d, %eax ja 0x53748 movl %eax, %eax leaq 0x90bd5(%rip), %rcx # 0xe4314 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmp 0x5374f leaq 0x92449(%rip),...
/frida[P]libxml2/parser.c
xmlPushInput
int xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) { int ret; if (input == NULL) return(-1); if (xmlParserDebugEntities) { if ((ctxt->input != NULL) && (ctxt->input->filename)) xmlGenericError(xmlGenericErrorContext, "%s(%d): ", ctxt->input->filename, ctxt->input->line); xm...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax pushq $-0x1 popq %rbp testq %rsi, %rsi je 0x538e1 movq %rsi, %r14 movq %rdi, %rbx callq 0x32340 cmpl $0x0, (%rax) je 0x53885 movq 0x38(%rbx), %rax testq %rax, %rax je 0x53860 cmpq $0x0, 0x8(%rax) je 0x53860 callq 0x34700 movq (%rax), %r15 callq 0x335a0 movq (%rax),...
/frida[P]libxml2/parser.c
xmlStringLenDecodeEntities
xmlChar * xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len, int what, xmlChar end, xmlChar end2, xmlChar end3) { xmlChar *buffer = NULL; size_t buffer_size = 0; size_t nbchars = 0; xmlChar *current = NULL; xmlChar *rep = NULL; const xmlChar *last; xmlEn...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movl %ecx, 0x30(%rsp) testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl testl %edx, %edx sets %al orb %cl, %al jne 0x54c8c movl %r9d, %r12d movl %r8d, %ebp movl %edx, %r14d movq %rsi, %rbx movl 0x188(%rdi), %eax cmpl $0x29...
/frida[P]libxml2/parser.c
xmlFatalErrMsg
static void LIBXML_ATTR_FORMAT(3,0) xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *msg) { if ((ctxt != NULL) && (ctxt->disableSAX != 0) && (ctxt->instate == XML_PARSER_EOF)) return; if (ctxt != NULL) ctxt->errNo = error; __xmlRaiseError(NULL, NULL, NULL, ct...
pushq %r14 pushq %rbx subq $0x58, %rsp testq %rdi, %rdi je 0x5505e movq %rdi, %rbx cmpl $0x0, 0x14c(%rdi) je 0x54fe6 cmpl $-0x1, 0x110(%rbx) je 0x550b3 movl %esi, 0x88(%rbx) movq %rdx, 0x50(%rsp) leaq 0x913c8(%rip), %rax # 0xe63c0 movq %rax, 0x48(%rsp) xorps %xmm0, %xmm0 movups %xmm0, 0x20(%rsp) andl $0x0, 0x40(%rs...
/frida[P]libxml2/parser.c
xmlSplitQName
xmlChar * xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix) { xmlChar buf[XML_MAX_NAMELEN + 5]; xmlChar *buffer = NULL; int len = 0; int max = XML_MAX_NAMELEN; xmlChar *ret = NULL; const xmlChar *cur = name; int c; if (prefix == NULL) return(NULL); *prefix ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x98, %rsp testq %rdx, %rdx je 0x55591 movq %rsi, %r15 andq $0x0, (%rdx) testq %rsi, %rsi je 0x55591 movb (%r15), %al cmpb $0x3a, %al jne 0x55262 movq %r15, %rdi addq $0x98, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0x35f...
/frida[P]libxml2/parser.c
xmlParseNmtoken
xmlChar * xmlParseNmtoken(xmlParserCtxtPtr ctxt) { xmlChar buf[XML_MAX_NAMELEN + 5]; int len = 0, l; int c; int count = 0; int maxLength = (ctxt->options & XML_PARSE_HUGE) ? XML_MAX_TEXT_LENGTH : XML_MAX_NAME_LENGTH; #ifdef DEBUG nbParseNmToken++; #endif ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x88, %rsp movq %rdi, %rbx testb $0x8, 0x236(%rdi) movl $0xc350, %eax # imm = 0xC350 movl $0x989680, %ecx # imm = 0x989680 cmovel %eax, %ecx movl %ecx, 0x4(%rsp) cmpl $0x0, 0x1c4(%rdi) jne 0x55e00 movq 0x38(%rbx), %rax movq 0x28(%...
/frida[P]libxml2/parser.c
xmlParseEntityValue
xmlChar * xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) { xmlChar *buf = NULL; int len = 0; int size = XML_PARSER_BUFFER_SIZE; int c, l; int maxLength = (ctxt->options & XML_PARSE_HUGE) ? XML_MAX_HUGE_LENGTH : XML_MAX_TEXT_LENGTH; xmlChar stop...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rdi, %rbx btl $0x13, 0x234(%rdi) movl $0x989680, %eax # imm = 0x989680 movl $0x3b9aca00, %ecx # imm = 0x3B9ACA00 cmovael %eax, %ecx movl %ecx, 0x14(%rsp) movq %rsi, %r14 andq $0x0, 0x8(%rsp) movq 0x38(%rdi), %rax movq...
/frida[P]libxml2/parser.c
xmlParseAttValueInternal
static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *len, int *alloc, int normalize) { xmlChar limit = 0; const xmlChar *in = NULL, *start, *end, *last; xmlChar *ret = NULL; int line, col; int maxLength = (ctxt->options & XML_PARSE_HUGE) ? ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movl %ecx, %r12d movq %rsi, %r10 testb $0x8, 0x236(%rdi) movl $0x989680, %eax # imm = 0x989680 movl $0x3b9aca00, %r15d # imm = 0x3B9ACA00 cmovel %eax, %r15d cmpl $0x0, 0x1c4(%rdi) jne 0x569ce movq 0x38(%rdi), %rax movq 0x28(...
/frida[P]libxml2/parser.c
xmlParseSystemLiteral
xmlChar * xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) { xmlChar *buf = NULL; int len = 0; int size = XML_PARSER_BUFFER_SIZE; int cur, l; int maxLength = (ctxt->options & XML_PARSE_HUGE) ? XML_MAX_TEXT_LENGTH : XML_MAX_NAME_LENGTH; xmlChar stop; int st...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rdi, %rbx testb $0x8, 0x236(%rdi) movl $0xc350, %eax # imm = 0xC350 movl $0x989680, %ecx # imm = 0x989680 cmovel %eax, %ecx movl %ecx, 0x24(%rsp) movl 0x110(%rdi), %ebp cmpl $0x0, 0x1c4(%rdi) jne 0x57854 movq 0x38...
/frida[P]libxml2/parser.c
xmlParseComment
void xmlParseComment(xmlParserCtxtPtr ctxt) { xmlChar *buf = NULL; size_t size = XML_PARSER_BUFFER_SIZE; size_t len = 0; size_t maxLength = (ctxt->options & XML_PARSE_HUGE) ? XML_MAX_HUGE_LENGTH : XML_MAX_TEXT_LENGTH; xmlParserInputState state; const...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %rdi, %rbx testb $0x8, 0x236(%rdi) movl $0x989680, %eax # imm = 0x989680 movl $0x3b9aca00, %esi # imm = 0x3B9ACA00 cmoveq %rax, %rsi movq 0x38(%rdi), %rdi movq 0x20(%rdi), %rax cmpb $0x3c, (%rax) jne 0x58fe2 cmpb $0x21...
/frida[P]libxml2/parser.c
xmlParsePITarget
const xmlChar * xmlParsePITarget(xmlParserCtxtPtr ctxt) { const xmlChar *name; name = xmlParseName(ctxt); if ((name != NULL) && ((name[0] == 'x') || (name[0] == 'X')) && ((name[1] == 'm') || (name[1] == 'M')) && ((name[2] == 'l') || (name[2] == 'L'))) { int i; if ((name[0] == 'x')...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdi, %r14 callq 0x32800 movq %rax, %rbx testq %rax, %rax je 0x59591 movzbl (%rbx), %eax movl %eax, %ecx orl $0x20, %ecx cmpl $0x78, %ecx jne 0x59564 movzbl 0x1(%rbx), %ecx movl %ecx, %edx orl $0x20, %edx cmpl $0x6d, %edx jne 0x59564 movzbl 0x2(%rbx), %edx mov...
/frida[P]libxml2/parser.c
xmlErrMsgStr
static void LIBXML_ATTR_FORMAT(3,0) xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *msg, const xmlChar * val) { if ((ctxt != NULL) && (ctxt->disableSAX != 0) && (ctxt->instate == XML_PARSER_EOF)) return; if (ctxt != NULL) ctxt->errNo = error; __xmlRaiseErro...
movq %rdi, %rax testq %rdi, %rdi je 0x5a6da cmpl $0x0, 0x14c(%rax) je 0x5a6d4 cmpl $-0x1, 0x110(%rax) je 0x5a730 movl %esi, 0x88(%rax) subq $0x58, %rsp movq %rcx, 0x50(%rsp) movq %rdx, 0x48(%rsp) xorps %xmm0, %xmm0 movups %xmm0, 0x28(%rsp) andl $0x0, 0x40(%rsp) movq %rcx, 0x20(%rsp) andl $0x0, 0x38(%rsp) movl %esi, (%r...
/frida[P]libxml2/parser.c
xmlParseNotationType
xmlEnumerationPtr xmlParseNotationType(xmlParserCtxtPtr ctxt) { const xmlChar *name; xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp; if (RAW != '(') { xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL); return(NULL); } SHRINK; do { NEXT; SKIP_BLANKS; name = xmlParseNa...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %r14 movq 0x38(%rdi), %rcx movq 0x20(%rcx), %rax cmpb $0x28, (%rax) jne 0x5a9e2 cmpl $0x0, 0x1c4(%r14) jne 0x5a911 movq %rax, %rdx subq 0x18(%rcx), %rdx cmpq $0x1f5, %rdx # imm = 0x1F5 jl 0x5a911 movq 0x28(%rcx), %rcx sub...
/frida[P]libxml2/parser.c
xmlParseEnumerationType
xmlEnumerationPtr xmlParseEnumerationType(xmlParserCtxtPtr ctxt) { xmlChar *name; xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp; if (RAW != '(') { xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL); return(NULL); } SHRINK; do { NEXT; SKIP_BLANKS; name = xmlParseNmtoke...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %r14 movq 0x38(%rdi), %rcx movq 0x20(%rcx), %rax cmpb $0x28, (%rax) jne 0x5ac86 cmpl $0x0, 0x1c4(%r14) jne 0x5ab93 movq %rax, %rdx subq 0x18(%rcx), %rdx cmpq $0x1f5, %rdx # imm = 0x1F5 jl 0x5ab93 movq 0x28(%rcx), %rcx sub...
/frida[P]libxml2/parser.c
xmlParseElementMixedContentDecl
xmlElementContentPtr xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) { xmlElementContentPtr ret = NULL, cur = NULL, n; const xmlChar *elem = NULL; GROW; if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) { SKIP(7); SKIP_BLANKS; SHRINK; if (RAW == ')') { if (ctxt->input-...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %esi, %ebp movq %rdi, %rbx cmpl $0x0, 0x1c4(%rdi) jne 0x5b671 movq 0x38(%rbx), %rax movq 0x28(%rax), %rcx subq 0x20(%rax), %rcx cmpq $0xf9, %rcx jg 0x5b671 movq %rbx, %rdi callq 0x53913 movq 0x38(%rbx), %rdi movq 0x20(%rdi), %rax cmpb $0x...
/frida[P]libxml2/parser.c
xmlParseElementChildrenContentDeclPriv
static xmlElementContentPtr xmlParseElementChildrenContentDeclPriv(xmlParserCtxtPtr ctxt, int inputchk, int depth) { xmlElementContentPtr ret = NULL, cur = NULL, last = NULL, op = NULL; const xmlChar *elem; xmlChar type = 0; if (((depth > 128) && ((ctxt->options &...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %edx, %r15d movl %esi, %r14d movq %rdi, %rbx cmpl $0x81, %edx jl 0x5b9d4 cmpl $0x800, %r15d # imm = 0x800 ja 0x5bade movl $0x80000, %eax # imm = 0x80000 andl 0x234(%rbx), %eax je 0x5bade movq %rbx, %rdi callq 0x33140 cm...
/frida[P]libxml2/parser.c
xmlParseElementDecl
int xmlParseElementDecl(xmlParserCtxtPtr ctxt) { const xmlChar *name; int ret = -1; xmlElementContentPtr content = NULL; /* GROW; done in the caller */ if (CMP9(CUR_PTR, '<', '!', 'E', 'L', 'E', 'M', 'E', 'N', 'T')) { int inputid = ctxt->input->id; SKIP(9); if (SKIP_BLANKS == 0) { xmlFata...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x10, %rsp movq %rdi, %r14 andq $0x0, 0x8(%rsp) movq 0x38(%rdi), %rdi movq 0x20(%rdi), %rax pushq $-0x1 popq %rbx cmpb $0x3c, (%rax) jne 0x5c30d cmpb $0x21, 0x1(%rax) jne 0x5c30d cmpb $0x45, 0x2(%rax) jne 0x5c30d cmpb $0x4c, 0x3(%rax) jne 0x5c30d cmpb $0x45, ...
/frida[P]libxml2/parser.c
xmlParseTextDecl
void xmlParseTextDecl(xmlParserCtxtPtr ctxt) { xmlChar *version; const xmlChar *encoding; int oldstate; /* * We know that '<?xml' is here. */ if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) { SKIP(5); } else { xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NUL...
pushq %rbp pushq %r14 pushq %rbx movq %rdi, %rbx movq 0x38(%rdi), %rdi movq 0x20(%rdi), %rax cmpb $0x3c, (%rax) jne 0x5c4db cmpb $0x3f, 0x1(%rax) jne 0x5c4db cmpb $0x78, 0x2(%rax) jne 0x5c4db cmpb $0x6d, 0x3(%rax) jne 0x5c4db cmpb $0x6c, 0x4(%rax) jne 0x5c4db movzbl 0x5(%rax), %ecx cmpq $0x20, %rcx ja 0x5c4db movabsq $...
/frida[P]libxml2/parser.c
xmlParseVersionInfo
xmlChar * xmlParseVersionInfo(xmlParserCtxtPtr ctxt) { xmlChar *version = NULL; if (CMP7(CUR_PTR, 'v', 'e', 'r', 's', 'i', 'o', 'n')) { SKIP(7); SKIP_BLANKS; if (RAW != '=') { xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL); return(NULL); } NEXT; SKIP_BLANKS; if (RAW == '"') { NEXT...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x38(%rdi), %rdi movq 0x20(%rdi), %rax cmpb $0x76, (%rax) jne 0x5c69d cmpb $0x65, 0x1(%rax) jne 0x5c69d cmpb $0x72, 0x2(%rax) jne 0x5c69d cmpb $0x73, 0x3(%rax) jne 0x5c69d cmpb $0x69, 0x4(%rax) jne 0x5c69d cmpb $0x6f, 0x5(%rax) jne 0x5c69d cmpb $0x6e, 0x6(%rax) jne ...
/frida[P]libxml2/parser.c
xmlParseEncodingDecl
const xmlChar * xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) { xmlChar *encoding = NULL; SKIP_BLANKS; if (CMP8(CUR_PTR, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g')) { SKIP(8); SKIP_BLANKS; if (RAW != '=') { xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL); return(NULL); } NEXT; SKIP_BLANKS...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx callq 0x33140 movq 0x38(%rbx), %rdi movq 0x20(%rdi), %rax cmpb $0x65, (%rax) jne 0x5c8e6 cmpb $0x6e, 0x1(%rax) jne 0x5c8e6 cmpb $0x63, 0x2(%rax) jne 0x5c8e6 cmpb $0x6f, 0x3(%rax) jne 0x5c8e6 cmpb $0x64, 0x4(%rax) jne 0x5c8e6 cmpb $0x69, 0x5(%rax) jne 0x5c8e6 cmpb $0x6e, ...
/frida[P]libxml2/parser.c
xmlParseReference
void xmlParseReference(xmlParserCtxtPtr ctxt) { xmlEntityPtr ent; xmlChar *val; int was_checked; xmlNodePtr list = NULL; xmlParserErrors ret = XML_ERR_OK; if (RAW != '&') return; /* * Simple case of a CharRef */ if (NXT(1) == '#') { int i = 0; xmlChar out[16]; int...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp andq $0x0, 0x8(%rsp) movq 0x38(%rdi), %rax movq 0x20(%rax), %rax cmpb $0x26, (%rax) jne 0x5d4ec movq %rdi, %rbx cmpb $0x23, 0x1(%rax) jne 0x5d149 movb 0x2(%rax), %bpl movq %rbx, %rdi callq 0x35500 testl %eax, %eax je 0x5d4ec cmpl $0x1, 0...
/frida[P]libxml2/parser.c
xmlParseBalancedChunkMemoryInternal
static xmlParserErrors xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt, const xmlChar *string, void *user_data, xmlNodePtr *lst) { xmlParserCtxtPtr ctxt; xmlDocPtr newDoc = NULL; xmlNodePtr newRoot; xmlSAXHandlerPtr oldsax = NULL; xmlNodePtr content = NULL; xmlNodePtr last = NULL; ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r14 movq %rdi, %rbx movl 0x188(%rdi), %eax cmpl $0x29, %eax jl 0x5db46 pushq $0x59 popq %rbp cmpl $0x400, %eax # imm = 0x400 ja 0x5defe movl $0x80000, %eax # imm = 0x80000 a...
/frida[P]libxml2/parser.c
xmlParseExternalEntityPrivate
static xmlParserErrors xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt, xmlSAXHandlerPtr sax, void *user_data, int depth, const xmlChar *URL, const xmlChar *ID, xmlNodePtr *list) { xmlParserCtxtPtr ctxt; xmlDocPtr newDoc; xmlNodePtr newRoot; xmlParser...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movl %r8d, %ebp movq %rdx, %r12 movq %rsi, %rbx movq %rdi, %r15 cmpl $0x29, %r8d jl 0x5df59 pushq $0x59 popq %r13 testq %rbx, %rbx je 0x5e496 cmpl $0x400, %ebp # imm = 0x400 ja 0x5e496 movl $0x80000, %eax # imm = 0x80...
/frida[P]libxml2/parser.c
xmlErrAttributeDup
static void xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix, const xmlChar * localname) { if ((ctxt != NULL) && (ctxt->disableSAX != 0) && (ctxt->instate == XML_PARSER_EOF)) return; if (ctxt != NULL) ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED; if (prefix == NULL...
pushq %rbx subq $0x60, %rsp movq %rdi, %rbx testq %rdi, %rdi je 0x5eb77 cmpl $0x0, 0x14c(%rbx) je 0x5eb6d cmpl $-0x1, 0x110(%rbx) je 0x5ec2e movl $0x2a, 0x88(%rbx) testq %rsi, %rsi je 0x5ebb9 andl $0x0, 0x40(%rsp) movq %rdx, 0x58(%rsp) andl $0x0, 0x38(%rsp) movq %rsi, 0x50(%rsp) andq $0x0, 0x30(%rsp) leaq 0x87315(%rip)...
/frida[P]libxml2/parser.c
xmlParseEndTag1
static void xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) { const xmlChar *name; GROW; if ((RAW != '<') || (NXT(1) != '/')) { xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED, "xmlParseEndTag: '</' not found\n"); return; } SKIP(2); name = xmlParseNameAndCompare(ctxt,ctxt->name); ...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx cmpl $0x0, 0x1c4(%rdi) jne 0x5ec63 movq 0x38(%rbx), %rax movq 0x28(%rax), %rcx subq 0x20(%rax), %rcx cmpq $0xf9, %rcx jg 0x5ec63 movq %rbx, %rdi callq 0x53913 movq 0x38(%rbx), %rdi movq 0x20(%rdi), %rax cmpb $0x3c, (%rax) jne 0x5ed04 cmpb $0x2f, 0x1(%rax) jne 0x5ed04 lea...
/frida[P]libxml2/parser.c
xmlParseContentInternal
static void xmlParseContentInternal(xmlParserCtxtPtr ctxt) { int nameNr = ctxt->nameNr; GROW; while ((RAW != 0) && (ctxt->instate != XML_PARSER_EOF)) { int id = ctxt->input->id; unsigned long cons = CUR_CONSUMED; const xmlChar *cur = ctxt->input->cur; /* * First case : a Processing Instru...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movl 0x128(%rdi), %ebp cmpl $0x0, 0x1c4(%rdi) jne 0x5f31b movq 0x38(%rbx), %rax movq 0x28(%rax), %rcx subq 0x20(%rax), %rcx cmpq $0xf9, %rcx jg 0x5f31b movq %rbx, %rdi callq 0x53913 movq 0x38(%rbx), %rcx movq 0x20(%rcx), %rax movzbl (%rax), %edx tes...
/frida[P]libxml2/parser.c
xmlParseElementStart
static int xmlParseElementStart(xmlParserCtxtPtr ctxt) { const xmlChar *name; const xmlChar *prefix = NULL; const xmlChar *URI = NULL; xmlParserNodeInfo node_info; int line, tlen = 0; xmlNodePtr ret; int nsNr = ctxt->nsNr; if (((unsigned int) ctxt->nameNr > xmlParserMaxDepth) && ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movq %rdi, %rbx andq $0x0, 0x10(%rsp) andq $0x0, 0x8(%rsp) movl 0x1fc(%rdi), %r12d movq 0xcd697(%rip), %rax # 0x12ccf0 movl (%rax), %ecx cmpl %ecx, 0x128(%rdi) jbe 0x5f68e testb $0x8, 0x236(%rbx) jne 0x5f68e leaq 0x84eed(%rip), %rdx ...
/frida[P]libxml2/parser.c
xmlParseVersionNum
xmlChar * xmlParseVersionNum(xmlParserCtxtPtr ctxt) { xmlChar *buf = NULL; int len = 0; int size = 10; xmlChar cur; buf = (xmlChar *) xmlMallocAtomic(size); if (buf == NULL) { xmlErrMemory(ctxt, NULL); return(NULL); } cur = CUR; if (!((cur >= '0') && (cur <= '9'))) { xmlFree(buf)...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %r14 movq 0xcd118(%rip), %rax # 0x12cb30 pushq $0xa popq %rdi callq *(%rax) testq %rax, %rax je 0x5face movq %rax, %rbx movq 0x38(%r14), %rax movq 0x20(%rax), %rax movb (%rax), %al leal -0x30(%rax), %ecx cmpb $0xa, %cl jae 0x5fa...
/frida[P]libxml2/parser.c
xmlParseEncName
xmlChar * xmlParseEncName(xmlParserCtxtPtr ctxt) { xmlChar *buf = NULL; int len = 0; int size = 10; xmlChar cur; cur = CUR; if (((cur >= 'a') && (cur <= 'z')) || ((cur >= 'A') && (cur <= 'Z'))) { buf = (xmlChar *) xmlMallocAtomic(size); if (buf == NULL) { xmlErrMemory(ctxt, NULL)...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x38(%rdi), %rax movq 0x20(%rax), %rax movb (%rax), %bpl movl %ebp, %eax andb $-0x21, %al addb $-0x41, %al cmpb $0x19, %al ja 0x5fc33 movq 0xcd016(%rip), %rax # 0x12cb30 pushq $0xa popq %rdi callq *(%rax) testq %rax, %...
/frida[P]libxml2/parser.c
xmlParseMisc
void xmlParseMisc(xmlParserCtxtPtr ctxt) { while (ctxt->instate != XML_PARSER_EOF) { SKIP_BLANKS; GROW; if ((RAW == '<') && (NXT(1) == '?')) { xmlParsePI(ctxt); } else if (CMP4(CUR_PTR, '<', '!', '-', '-')) { xmlParseComment(ctxt); } else { break; ...
pushq %rbx movq %rdi, %rbx cmpl $-0x1, 0x110(%rbx) je 0x601a0 movq %rbx, %rdi callq 0x33140 cmpl $0x0, 0x1c4(%rbx) movq 0x38(%rbx), %rax jne 0x60169 movq 0x28(%rax), %rcx subq 0x20(%rax), %rcx cmpq $0xf9, %rcx jg 0x60169 movq %rbx, %rdi callq 0x53913 movq 0x38(%rbx), %rax movq 0x20(%rax), %rax cmpb $0x3c, (%rax) jne 0x...
/frida[P]libxml2/parser.c
xmlParseDocument
int xmlParseDocument(xmlParserCtxtPtr ctxt) { xmlChar start[4]; xmlCharEncoding enc; xmlInitParser(); if ((ctxt == NULL) || (ctxt->input == NULL)) return(-1); GROW; /* * SAX: detecting the level. */ xmlDetectSAX2(ctxt); /* * SAX: beginning of the document proc...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdi, %r14 callq 0x32ce0 pushq $-0x1 popq %rbx testq %r14, %r14 je 0x60602 movq 0x38(%r14), %rax testq %rax, %rax je 0x60602 cmpl $0x0, 0x1c4(%r14) jne 0x601ee movq 0x28(%rax), %rcx subq 0x20(%rax), %rcx cmpq $0xf9, %rcx jg 0x601ee movq %r14, %rdi callq 0x5391...
/frida[P]libxml2/parser.c
xmlParseExtParsedEnt
int xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) { xmlChar start[4]; xmlCharEncoding enc; if ((ctxt == NULL) || (ctxt->input == NULL)) return(-1); xmlDetectSAX2(ctxt); GROW; /* * SAX: beginning of the document processing. */ if ((ctxt->sax) && (ctxt->sax->setDocumentLoca...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax pushq $-0x1 popq %rbp testq %rdi, %rdi je 0x60a04 movq %rdi, %rbx cmpq $0x0, 0x38(%rdi) je 0x60a04 movq %rbx, %rdi callq 0x5cb5e cmpl $0x0, 0x1c4(%rbx) jne 0x6085c movq 0x38(%rbx), %rax movq 0x28(%rax), %rcx subq 0x20(%rax), %rcx cmpq $0xf9, %rcx jg 0x6085c movq %r...
/frida[P]libxml2/parser.c
xmlCreatePushParserCtxt
xmlParserCtxtPtr xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, void *user_data, const char *chunk, int size, const char *filename) { xmlParserCtxtPtr ctxt; xmlParserInputPtr inputStream; xmlParserInputBufferPtr buf; xmlCharEncoding enc = XML_CHAR_ENCODING_NONE; /* * plu...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r13 movl %ecx, %r15d movq %rdx, %r14 movq %rsi, %rbx movq %rdi, %rbp testq %rdx, %rdx sete %al cmpl $0x4, %ecx setl %cl xorl %edi, %edi orb %al, %cl jne 0x6235f movq %r14, %rdi movl %r15d, %esi callq 0x34d10 movl %eax, %edi movl %ed...
/frida[P]libxml2/parser.c
xmlSAXParseDTD
xmlDtdPtr xmlSAXParseDTD(xmlSAXHandlerPtr sax, const xmlChar *ExternalID, const xmlChar *SystemID) { xmlDtdPtr ret = NULL; xmlParserCtxtPtr ctxt; xmlParserInputPtr input = NULL; xmlCharEncoding enc; xmlChar* systemIdCanonic; if ((ExternalID == NULL) && (SystemID == NUL...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rsi, %rax orq %rdx, %rax je 0x62815 movq %rdx, %r14 movq %rsi, %r15 xorl %r12d, %r12d xorl %esi, %esi callq 0x34f70 testq %rax, %rax je 0x62818 movq %rax, %rbx orb $0x4, 0x234(%rax) movq %r14, %rdi callq 0x34490 movq %rax, %r12 testq %r14, %r14 setne %al test...
/frida[P]libxml2/parser.c
xmlParseCtxtExternalEntity
int xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, const xmlChar *URL, const xmlChar *ID, xmlNodePtr *lst) { void *userData; if (ctx == NULL) return(-1); /* * If the user provided their own SAX callbacks, then reuse the * userData callback field, otherwise the expected setup in ...
testq %rdi, %rdi je 0x62957 pushq %rax movq %rcx, %r10 movq %rdx, %rax movq %rsi, %r9 movq %rdi, %rsi movq 0x8(%rdi), %rdx xorl %ecx, %ecx cmpq %rdi, %rdx cmovneq %rdx, %rcx movq (%rdi), %rdx movq 0x10(%rdi), %rdi movl 0x188(%rsi), %r8d incl %r8d pushq %r10 pushq %rax callq 0x5df0f popq %rcx popq %rdx popq %rcx retq pu...
/frida[P]libxml2/parser.c
xmlCreateMemoryParserCtxt
xmlParserCtxtPtr xmlCreateMemoryParserCtxt(const char *buffer, int size) { xmlParserCtxtPtr ctxt; xmlParserInputPtr input; xmlParserInputBufferPtr buf; if (buffer == NULL) return(NULL); if (size <= 0) return(NULL); ctxt = xmlNewParserCtxt(); if (ctxt == NULL) return(NULL); /* TODO:...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax testq %rdi, %rdi sete %al testl %esi, %esi setle %cl orb %al, %cl jne 0x630f3 movl %esi, %ebp movq %rdi, %r14 callq 0x356f0 testq %rax, %rax je 0x630f3 movq %rax, %rbx movq %r14, %rdi movl %ebp, %esi xorl %edx, %edx callq 0x32ba0 testq %rax, %rax je 0x630eb movq %r...
/frida[P]libxml2/parser.c
nsPop
static int nsPop(xmlParserCtxtPtr ctxt, int nr) { int i; if (ctxt->nsTab == NULL) return(0); if (ctxt->nsNr < nr) { xmlGenericError(xmlGenericErrorContext, "Pbm popping %d NS\n", nr); nr = ctxt->nsNr; } if (ctxt->nsNr <= 0) return (0); for (i = 0;i < nr;i++) { ...
cmpq $0x0, 0x208(%rdi) je 0x63598 pushq %rbp pushq %r14 pushq %rbx movl %esi, %ebp movq %rdi, %rbx movl 0x1fc(%rdi), %eax cmpl %esi, %eax jge 0x6356c callq 0x34700 movq (%rax), %r14 callq 0x335a0 movq (%rax), %rdi leaq 0x82eb6(%rip), %rsi # 0xe6413 movl %ebp, %edx xorl %eax, %eax callq *%r14 movl 0x1fc(%rbx), %eax ...
/frida[P]libxml2/parser.c
xmlCreateEntityParserCtxtInternal
static xmlParserCtxtPtr xmlCreateEntityParserCtxtInternal(xmlSAXHandlerPtr sax, void *userData, const xmlChar *URL, const xmlChar *ID, const xmlChar *base, xmlParserCtxtPtr pctx) { xmlParserCtxtPtr ctxt; xmlParserInputPtr inputStream; char *directory = NULL; xmlChar *uri; ctxt = xml...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %r9, %r13 movq %r8, %r15 movq %rcx, %r14 movq %rdx, %r12 callq 0x34f70 testq %rax, %rax je 0x63774 movq %rax, %rbx testq %r13, %r13 je 0x63688 movl 0x234(%r13), %eax movl %eax, 0x234(%rbx) movq 0x1a8(%r13), %rax movq %rax, 0x1a8(%rbx) movl 0x2e0(%r13), %eax in...
/frida[P]libxml2/parser.c
xmlSAXParseFileWithData
xmlDocPtr xmlSAXParseFileWithData(xmlSAXHandlerPtr sax, const char *filename, int recovery, void *data) { xmlDocPtr ret; xmlParserCtxtPtr ctxt; xmlInitParser(); ctxt = xmlCreateFileParserCtxt(filename); if (ctxt == NULL) { return(NULL); } if (sax != NULL) { if (ct...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movq %rcx, %r12 movl %edx, %ebp movq %rsi, %r15 movq %rdi, %rbx callq 0x32ce0 movq %r15, %rdi callq 0x33fb0 testq %rax, %rax je 0x638d4 movq %rax, %r14 testq %rbx, %rbx je 0x6386c movq (%r14), %rdi testq %rdi, %rdi je 0x63869 movq 0xc9749(%rip), %rax # 0x12cfb0...
/frida[P]libxml2/parser.c
xmlSAXParseDoc
xmlDocPtr xmlSAXParseDoc(xmlSAXHandlerPtr sax, const xmlChar *cur, int recovery) { xmlDocPtr ret; xmlParserCtxtPtr ctxt; xmlSAXHandlerPtr oldsax = NULL; if (cur == NULL) return(NULL); ctxt = xmlCreateDocParserCtxt(cur); if (ctxt == NULL) return(NULL); if (sax != NULL) { oldsax = c...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx testq %rsi, %rsi je 0x63954 movl %edx, %ebp movq %rdi, %rbx movq %rsi, %rdi callq 0x35870 testq %rax, %rax je 0x63954 movq %rax, %r14 testq %rbx, %rbx je 0x63959 movq (%r14), %r12 movq %rbx, (%r14) andq $0x0, 0x8(%r14) jmp 0x6395c xorl %r15d, %r15d jmp 0x63996 xorl...
/frida[P]libxml2/parser.c
xmlCtxtReset
void xmlCtxtReset(xmlParserCtxtPtr ctxt) { xmlParserInputPtr input; xmlDictPtr dict; if (ctxt == NULL) return; dict = ctxt->dict; while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */ xmlFreeInputStream(input); } ctxt->inputNr = 0; ctxt->input = NULL; ctx...
pushq %r14 pushq %rbx pushq %rax testq %rdi, %rdi je 0x63f4e movq %rdi, %rbx movq 0x1c8(%rdi), %r14 movq %rbx, %rdi callq 0x35150 testq %rax, %rax je 0x63d0f movq %rax, %rdi callq 0x34300 jmp 0x63cf8 andl $0x0, 0x40(%rbx) andq $0x0, 0x38(%rbx) andl $0x0, 0x178(%rbx) movq 0x180(%rbx), %rax testq %rax, %rax je 0x63d2e or...
/frida[P]libxml2/parser.c
xmlReadDoc
xmlDocPtr xmlReadDoc(const xmlChar * cur, const char *URL, const char *encoding, int options) { xmlParserCtxtPtr ctxt; if (cur == NULL) return (NULL); xmlInitParser(); ctxt = xmlCreateDocParserCtxt(cur); if (ctxt == NULL) return (NULL); return (xmlDoRead(ctxt, URL, encoding, op...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax testq %rdi, %rdi je 0x64156 movl %ecx, %ebx movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %r12 callq 0x32ce0 movq %r12, %rdi callq 0x35870 testq %rax, %rax je 0x64156 movq %rax, %rdi movq %r15, %rsi movq %r14, %rdx movl %ebx, %ecx xorl %r8d, %r8d addq $0x8, %rsp popq ...
/frida[P]libxml2/parser.c
xmlReadMemory
xmlDocPtr xmlReadMemory(const char *buffer, int size, const char *URL, const char *encoding, int options) { xmlParserCtxtPtr ctxt; xmlInitParser(); ctxt = xmlCreateMemoryParserCtxt(buffer, size); if (ctxt == NULL) return (NULL); return (xmlDoRead(ctxt, URL, encoding, options, 0)); }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movl %r8d, %ebx movq %rcx, %r14 movq %rdx, %r15 movl %esi, %ebp movq %rdi, %r12 callq 0x32ce0 movq %r12, %rdi movl %ebp, %esi callq 0x33a80 testq %rax, %rax je 0x64292 movq %rax, %rdi movq %r15, %rsi movq %r14, %rdx movl %ebx, %ecx xorl %r8d, %r8d popq %rbx popq %r...
/frida[P]libxml2/parser.c
xmlCtxtReadFile
xmlDocPtr xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename, const char *encoding, int options) { xmlParserInputPtr stream; if (filename == NULL) return (NULL); if (ctxt == NULL) return (NULL); xmlInitParser(); xmlCtxtReset(ctxt); stream = xmlLoadExte...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movl %ecx, %ebx testq %rsi, %rsi sete %al testq %rdi, %rdi sete %cl orb %al, %cl jne 0x64568 movq %rdx, %r14 movq %rsi, %r12 movq %rdi, %r15 callq 0x32ce0 movq %r15, %rdi callq 0x35310 movq %r12, %rdi xorl %esi, %esi movq %r15, %rdx callq 0x32900 testq %rax, %rax j...
/frida[P]libxml2/parser.c
xmlIsNameStartChar
static int xmlIsNameStartChar(xmlParserCtxtPtr ctxt, int c) { if ((ctxt->options & XML_PARSE_OLD10) == 0) { /* * Use the new checks of production [4] [4a] amd [5] of the * Update 5 of XML-1.0 */ if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */ (((c >= 'a') && (c <= 'z')) || ...
pushq %rbx movl %esi, %ebx testb $0x2, 0x236(%rdi) jne 0x64718 cmpl $0x3e, %ebx ja 0x647c7 movl %ebx, %eax movabsq $0x4000800100000000, %rcx # imm = 0x4000800100000000 btq %rax, %rcx jae 0x647c7 xorl %eax, %eax jmp 0x6488e cmpl $0xff, %ebx jg 0x64776 leal -0xc0(%rbx), %ecx pushq $0x1 popq %rax cmpl $0x17, %ecx jb 0x648...
/frida[P]libxml2/parser.c
xmlParseNameAndCompare
static const xmlChar * xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) { register const xmlChar *cmp = other; register const xmlChar *in; const xmlChar *ret; GROW; if (ctxt->instate == XML_PARSER_EOF) return(NULL); in = ctxt->input->cur; while (*in != 0 && *in =...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 cmpl $0x0, 0x1c4(%rdi) jne 0x648c0 movq 0x38(%r14), %rax movq 0x28(%rax), %rcx subq 0x20(%rax), %rcx cmpq $0xf9, %rcx jg 0x648c0 movq %r14, %rdi callq 0x53913 cmpl $-0x1, 0x110(%r14) je 0x64906 movq 0x38(%r14), %rax movq 0x20(%rax), %rcx xorl %edx, %edx m...
/frida[P]libxml2/parser.c
spacePop
static int spacePop(xmlParserCtxtPtr ctxt) { int ret; if (ctxt->spaceNr <= 0) return(0); ctxt->spaceNr--; if (ctxt->spaceNr > 0) ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1]; else ctxt->space = &ctxt->spaceTab[0]; ret = ctxt->spaceTab[ctxt->spaceNr]; ctxt->spaceTab[ctxt->spaceNr...
movslq 0x178(%rdi), %rax testq %rax, %rax jle 0x64969 leal -0x1(%rax), %ecx movl %ecx, 0x178(%rdi) cmpl $0x1, %eax movq 0x180(%rdi), %rdx leaq -0x8(%rdx,%rax,4), %rax cmoveq %rdx, %rax movq %rax, 0x170(%rdi) orl $-0x1, (%rdx,%rcx,4) retq
/frida[P]libxml2/parser.c
xmlCtxtGrowAttrs
static int xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) { const xmlChar **atts; int *attallocs; int maxatts; if (ctxt->atts == NULL) { maxatts = 55; /* allow for 10 attrs by default */ atts = (const xmlChar **) xmlMalloc(maxatts * sizeof(xmlChar *)); if (atts == NULL) goto mem_error; ctx...
pushq %rbp pushq %r14 pushq %rbx movq %rdi, %rbx movq 0x1d0(%rdi), %rdi testq %rdi, %rdi je 0x65d2d movl %esi, %ebp addl $0x5, %ebp movl 0x1d8(%rbx), %eax cmpl %eax, %ebp jle 0x65d75 addl %ebp, %ebp movq 0xc6ea8(%rip), %r14 # 0x12cb90 movslq %ebp, %rsi shlq $0x3, %rsi callq *(%r14) testq %rax, %rax je 0x65d68 movq ...
/frida[P]libxml2/parser.c
xmlParseGetLasts
static void xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt, const xmlChar **lastgt) { const xmlChar *tmp; if ((ctxt == NULL) || (lastlt == NULL) || (lastgt == NULL)) { xmlGenericError(xmlGenericErrorContext, "Internal error: xmlParseGetLasts\n"); return; } if ((...
pushq %rbx testq %rsi, %rsi setne %al testq %rdx, %rdx setne %cl testb %cl, %al jne 0x66355 callq 0x34700 movq (%rax), %rbx callq 0x335a0 movq (%rax), %rdi leaq 0x80076(%rip), %rsi # 0xe63c3 xorl %eax, %eax movq %rbx, %rcx popq %rbx jmpq *%rcx cmpl $0x0, 0x1c4(%rdi) je 0x66408 cmpl $0x1, 0x40(%rdi) jne 0x66408 movq...
/frida[P]libxml2/parser.c
xmlCheckCdataPush
static int xmlCheckCdataPush(const xmlChar *utf, int len, int complete) { int ix; unsigned char c; int codepoint; if ((utf == NULL) || (len <= 0)) return(0); for (ix = 0; ix < len;) { /* string is 0-terminated */ c = utf[ix]; if ((c & 0x80) == 0x00) { /* 1-byte code, s...
testq %rdi, %rdi sete %cl testl %esi, %esi setle %r8b xorl %eax, %eax orb %cl, %r8b jne 0x66792 pushq %rbp pushq %rbx xorl %r8d, %r8d movl $0x2600, %ecx # imm = 0x2600 movl %r8d, %eax cmpl %esi, %r8d jge 0x66790 movslq %eax, %r10 movzbl (%rdi,%r10), %r9d testb %r9b, %r9b js 0x66596 cmpb $0x20, %r9b jae 0x6658...
/frida[P]libxml2/parser.c
xmlErrMemory
void xmlErrMemory(xmlParserCtxtPtr ctxt, const char *extra) { if ((ctxt != NULL) && (ctxt->disableSAX != 0) && (ctxt->instate == XML_PARSER_EOF)) return; if (ctxt != NULL) { ctxt->errNo = XML_ERR_NO_MEMORY; ctxt->instate = XML_PARSER_EOF; ctxt->disableSAX = 1; } if (extr...
subq $0x58, %rsp movq %rdi, %rcx testq %rdi, %rdi je 0x66889 cmpl $0x0, 0x14c(%rcx) je 0x6686e cmpl $-0x1, 0x110(%rcx) je 0x66915 movl $0x2, 0x88(%rcx) orl $-0x1, 0x110(%rcx) movl $0x1, 0x14c(%rcx) testq %rsi, %rsi je 0x668c3 movq %rsi, 0x50(%rsp) leaq 0x75f3c(%rip), %rax # 0xdc7d6 movq %rax, 0x48(%rsp) xorps %xmm0...
/frida[P]libxml2/parserInternals.c
_xmlErrEncoding
void __xmlErrEncoding(xmlParserCtxtPtr ctxt, xmlParserErrors xmlerr, const char *msg, const xmlChar * str1, const xmlChar * str2) { if ((ctxt != NULL) && (ctxt->disableSAX != 0) && (ctxt->instate == XML_PARSER_EOF)) return; if (ctxt != NULL) ctxt->errNo = xmlerr; __xmlRaise...
pushq %r14 pushq %rbx subq $0x68, %rsp testq %rdi, %rdi je 0x669bb movq %rdi, %rbx cmpl $0x0, 0x14c(%rdi) je 0x66943 cmpl $-0x1, 0x110(%rbx) je 0x66a10 movl %esi, 0x88(%rbx) andl $0x0, 0x40(%rsp) movq %r8, 0x58(%rsp) andl $0x0, 0x38(%rsp) movq %rcx, 0x50(%rsp) andq $0x0, 0x30(%rsp) movq %rdx, 0x48(%rsp) andl $0x0, 0x18...
/frida[P]libxml2/parserInternals.c
xmlParserInputShrink
void xmlParserInputShrink(xmlParserInputPtr in) { size_t used; size_t ret; #ifdef DEBUG_INPUT xmlGenericError(xmlGenericErrorContext, "Shrink\n"); #endif if (in == NULL) return; if (in->buf == NULL) return; if (in->base == NULL) return; if (in->cur == NULL) return; if (in->buf->buffer =...
testq %rdi, %rdi je 0x66bd9 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq (%rdi), %rcx testq %rcx, %rcx je 0x66bd2 movq 0x18(%rbx), %rax testq %rax, %rax je 0x66bd2 movq 0x20(%rbx), %r14 testq %r14, %r14 je 0x66bd2 movq 0x20(%rcx), %rdi testq %rdi, %rdi je 0x66bd2 subq %rax, %r14 cmpq $0xfb, %r14 jb 0x66b8a lea...
/frida[P]libxml2/parserInternals.c
xmlErrEncodingInt
static void LIBXML_ATTR_FORMAT(3,0) xmlErrEncodingInt(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *msg, int val) { if ((ctxt != NULL) && (ctxt->disableSAX != 0) && (ctxt->instate == XML_PARSER_EOF)) return; if (ctxt != NULL) ctxt->errNo = error; __xmlRaiseErro...
pushq %r14 pushq %rbx subq $0x58, %rsp testq %rdi, %rdi je 0x67027 movq %rdi, %rbx cmpl $0x0, 0x14c(%rdi) je 0x66fb5 cmpl $-0x1, 0x110(%rbx) je 0x67077 pushq $0x9 popq %rax movl %eax, 0x88(%rbx) movl %edx, 0x50(%rsp) movq %rsi, 0x48(%rsp) movl %edx, 0x38(%rsp) xorps %xmm0, %xmm0 movups %xmm0, 0x20(%rsp) andl $0x0, 0x40...
/frida[P]libxml2/parserInternals.c
xmlCurrentChar
int xmlCurrentChar(xmlParserCtxtPtr ctxt, int *len) { if ((ctxt == NULL) || (len == NULL) || (ctxt->input == NULL)) return(0); if (ctxt->instate == XML_PARSER_EOF) return(0); if ((*ctxt->input->cur >= 0x20) && (*ctxt->input->cur <= 0x7F)) { *len = 1; return(*ctxt->input->cur); } if (ctxt...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0xb0, %rsp testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl xorl %r14d, %r14d orb %al, %cl jne 0x670d1 movq %rdi, %rbx movq 0x38(%rdi), %rdi testq %rdi, %rdi je 0x670d1 cmpl $-0x1, 0x110(%rbx) je 0x670d1 movq %rsi, %r15 movq 0x20(%rdi), %rax movzbl (%rax),...
/frida[P]libxml2/parserInternals.c
xmlStringCurrentChar
int xmlStringCurrentChar(xmlParserCtxtPtr ctxt, const xmlChar * cur, int *len) { if ((len == NULL) || (cur == NULL)) return(0); if ((ctxt == NULL) || (ctxt->charset == XML_CHAR_ENCODING_UTF8)) { /* * We are supposed to handle UTF8, check it's valid * From rfc2044: encoding of the Unico...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0xa8, %rsp testq %rdx, %rdx sete %al testq %rsi, %rsi sete %cl xorl %r15d, %r15d orb %al, %cl jne 0x673dd movq %rdx, %r12 movq %rsi, %r14 movq %rdi, %rbx testq %rdi, %rdi je 0x673c9 cmpl $0x1, 0x198(%rbx) jne 0x673d1 movzbl (%r14), %eax testb %al, %al js 0x673ef movl $0...
/frida[P]libxml2/parserInternals.c
xmlCopyChar
int xmlCopyChar(int len ATTRIBUTE_UNUSED, xmlChar *out, int val) { if ((out == NULL) || (val < 0)) return(0); /* the len parameter is ignored */ if (val >= 0x80) { return(xmlCopyCharMultiByte (out, val)); } *out = val; return 1; }
testq %rsi, %rsi sete %cl testl %edx, %edx sets %dil xorl %eax, %eax orb %cl, %dil jne 0x6764e cmpl $0x80, %edx jb 0x67649 movq %rsi, %rdi movl %edx, %esi jmp 0x35d20 movb %dl, (%rsi) pushq $0x1 popq %rax retq
/frida[P]libxml2/parserInternals.c
xmlSwitchInputEncodingInt
static int xmlSwitchInputEncodingInt(xmlParserCtxtPtr ctxt, xmlParserInputPtr input, xmlCharEncodingHandlerPtr handler, int len) { int nbchars; if (handler == NULL) return (-1); if (input == NULL) return (-1); if (input->buf != NULL) { ctxt->charset = XML_CHAR...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %ecx, %r15d testq %rdx, %rdx sete %al testq %rsi, %rsi sete %cl orb %al, %cl pushq $-0x1 popq %r13 jne 0x67884 movq %rdx, %r12 movq %rsi, %rbx movq %rdi, %r14 movq (%rsi), %rax testq %rax, %rax je 0x6786b movl $0x1, 0x198(%r14) movq 0x18(...
/frida[P]libxml2/parserInternals.c
xmlNewIOInputStream
xmlParserInputPtr xmlNewIOInputStream(xmlParserCtxtPtr ctxt, xmlParserInputBufferPtr input, xmlCharEncoding enc) { xmlParserInputPtr inputStream; if (input == NULL) return(NULL); if (xmlParserDebugEntities) xmlGenericError(xmlGenericErrorContext, "new input from I/O\n"); inputStream = xml...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax testq %rsi, %rsi je 0x67b86 movl %edx, %ebx movq %rsi, %r15 movq %rdi, %r14 callq 0x32340 cmpl $0x0, (%rax) je 0x67b52 callq 0x34700 movq (%rax), %r12 callq 0x335a0 movq (%rax), %rdi leaq 0x7ea73(%rip), %rsi # 0xe65c0 xorl %eax, %eax callq *%r12 movq %r14, %rdi...
/frida[P]libxml2/parserInternals.c
xmlNewStringInputStream
xmlParserInputPtr xmlNewStringInputStream(xmlParserCtxtPtr ctxt, const xmlChar *buffer) { xmlParserInputPtr input; xmlParserInputBufferPtr buf; if (buffer == NULL) { xmlErrInternal(ctxt, "xmlNewStringInputStream string = NULL\n", NULL); return(NULL); } if (xmlParserDebugEnt...
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx testq %rsi, %rsi je 0x67d35 movq %rsi, %r14 callq 0x32340 cmpl $0x0, (%rax) je 0x67cf8 callq 0x34700 movq (%rax), %r15 callq 0x335a0 movq (%rax), %rdi leaq 0x7e9e3(%rip), %rsi # 0xe66d3 movq %r14, %rdx xorl %eax, %eax callq *%r15 movq %r14, %rdi callq 0x33fa0 movq %r...
/frida[P]libxml2/parserInternals.c
xmlInitSAXParserCtxt
static int xmlInitSAXParserCtxt(xmlParserCtxtPtr ctxt, const xmlSAXHandler *sax, void *userData) { xmlParserInputPtr input; if(ctxt==NULL) { xmlErrInternal(NULL, "Got NULL parser context\n", NULL); return(-1); } xmlInitParser(); if (ctxt->dict == NULL) ctxt->...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx testq %rdi, %rdi je 0x67f4d movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %rbx callq 0x32ce0 movq 0x1c8(%rbx), %rdi testq %rdi, %rdi jne 0x67f09 callq 0x326b0 movq %rax, %rdi movq %rax, 0x1c8(%rbx) testq %rax, %rax je 0x67f7e movl $0x989680, %esi # imm = 0x989...
/frida[P]libxml2/parserInternals.c
xmlNewSAXParserCtxt
xmlParserCtxtPtr xmlNewSAXParserCtxt(const xmlSAXHandler *sax, void *userData) { xmlParserCtxtPtr ctxt; ctxt = (xmlParserCtxtPtr) xmlMalloc(sizeof(xmlParserCtxt)); if (ctxt == NULL) { xmlErrMemory(NULL, "cannot allocate parser context\n"); return(NULL); } memset(ctxt, 0, sizeof(xmlParserCtxt)); ...
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movq 0xc4a5b(%rip), %rax # 0x12cfd0 movl $0x2f0, %edi # imm = 0x2F0 callq *(%rax) testq %rax, %rax je 0x685b1 movq %rax, %rbx movl $0x2f0, %edx # imm = 0x2F0 movq %rax, %rdi xorl %esi, %esi callq 0x32350 movq %rbx, %rdi movq %r15...
/frida[P]libxml2/parserInternals.c
xmlParserFindNodeInfo
const xmlParserNodeInfo * xmlParserFindNodeInfo(const xmlParserCtxtPtr ctx, const xmlNodePtr node) { unsigned long pos; if ((ctx == NULL) || (node == NULL)) return (NULL); /* Find position where node should be at */ pos = xmlParserFindNodeInfoIndex(&ctx->node_seq, node); if (pos < ctx->node...
testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl je 0x68646 xorl %eax, %eax retq pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 addq $0x70, %rdi callq 0x34900 cmpq 0x78(%r14), %rax jae 0x68673 movq %rax, %rcx movq 0x80(%r14), %rax imulq $0x28, %rcx, %rcx cmpq %rbx, (%rax,%rcx) je 0x686...
/frida[P]libxml2/parserInternals.c
xmlFreePatternList
void xmlFreePatternList(xmlPatternPtr comp) { xmlPatternPtr cur; while (comp != NULL) { cur = comp; comp = comp->next; cur->next = NULL; xmlFreePatternInternal(cur); } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx movq 0xc469e(%rip), %r15 # 0x12cfb0 testq %rbx, %rbx je 0x689b9 movq 0x10(%rbx), %r13 movq 0x38(%rbx), %rdi andq $0x0, 0x10(%rbx) testq %rdi, %rdi je 0x68932 callq 0x69bb3 movq 0x18(%rbx), %rdi testq %rdi, %rdi je 0x6893e c...
/frida[P]libxml2/pattern.c
xmlStreamPushInternal
static int xmlStreamPushInternal(xmlStreamCtxtPtr stream, const xmlChar *name, const xmlChar *ns, int nodeType) { int ret = 0, err = 0, final = 0, tmp, i, m, match, stepNr, desc; xmlStreamCompPtr comp; xmlStreamStep step; #ifdef DEBUG_STREAMING xmlStreamCtxtPtr orig = stream; #endif ...
pushq $-0x1 popq %rax testq %rdi, %rdi je 0x69002 movq %rdi, %r9 cmpl $0x0, 0x10(%rdi) js 0x69002 pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %rdx, %r12 movq %rsi, %rbp cmpl $0x1, %ecx sete %al testq %rsi, %rsi sete %dl andb %al, %dl testq %r12, %r12 sete %r15b andb %dl, %r15...
/frida[P]libxml2/pattern.c
xmlStreamPop
int xmlStreamPop(xmlStreamCtxtPtr stream) { int i, lev; if (stream == NULL) return(-1); while (stream != NULL) { /* * Reset block-level. */ if (stream->blockLevel == stream->level) stream->blockLevel = -1; /* * stream->level can be zero when XML_FINAL_IS_ANY_NODE is set * (see the ...
testq %rdi, %rdi je 0x6906f testq %rdi, %rdi je 0x6906c movl 0x18(%rdi), %eax cmpl %eax, 0x2c(%rdi) jne 0x6902b orl $-0x1, 0x2c(%rdi) testl %eax, %eax je 0x69036 decl %eax movl %eax, 0x18(%rdi) jmp 0x69038 xorl %eax, %eax movl 0x10(%rdi), %ecx leaq -0x2(,%rcx,2), %rdx testl %ecx, %ecx jle 0x69067 movq 0x20(%rdi), %rsi ...
/frida[P]libxml2/pattern.c
xmlPatterncompile
xmlPatternPtr xmlPatterncompile(const xmlChar *pattern, xmlDict *dict, int flags, const xmlChar **namespaces) { xmlPatternPtr ret = NULL, cur; xmlPatParserContextPtr ctxt = NULL; const xmlChar *or, *start; xmlChar *tmp = NULL; int type = 0; int streamable = 1; if (pattern ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %rcx, 0x40(%rsp) testq %rdi, %rdi je 0x69b35 movq %rdi, %r15 movq $0x0, 0x18(%rsp) movq %rsi, 0x20(%rsp) movl %edx, %eax orl $0x200, %eax # imm = 0x200 movl %eax, 0x14(%rsp) movl %edx, 0x34(%rsp) orl $0x100, %edx ...
/frida[P]libxml2/pattern.c
xmlPatternStreamable
int xmlPatternStreamable(xmlPatternPtr comp) { if (comp == NULL) return(-1); while (comp != NULL) { if (comp->stream == NULL) return(0); comp = comp->next; } return(1); }
testq %rdi, %rdi je 0x6a111 pushq $0x1 popq %rax testq %rdi, %rdi je 0x6a114 cmpq $0x0, 0x38(%rdi) je 0x6a115 movq 0x10(%rdi), %rdi jmp 0x6a0ff pushq $-0x1 popq %rax retq xorl %eax, %eax retq
/frida[P]libxml2/pattern.c
xmlPatternMinDepth
int xmlPatternMinDepth(xmlPatternPtr comp) { int ret = 12345678; if (comp == NULL) return(-1); while (comp != NULL) { if (comp->stream == NULL) return(-1); if (comp->stream->nbStep < ret) ret = comp->stream->nbStep; if (ret == 0) return(0); comp = comp->next; } retu...
pushq $-0x1 popq %rax testq %rdi, %rdi je 0x6a1b1 movl $0xbc614e, %ecx # imm = 0xBC614E testq %rdi, %rdi je 0x6a1af movq 0x38(%rdi), %rdx testq %rdx, %rdx je 0x6a1b1 movl 0x8(%rdx), %edx cmpl %ecx, %edx cmovll %edx, %ecx testl %ecx, %ecx je 0x6a1b2 movq 0x10(%rdi), %rdi jmp 0x6a18f movl %ecx, %eax retq xorl %ea...
/frida[P]libxml2/pattern.c
xmlPatternFromRoot
int xmlPatternFromRoot(xmlPatternPtr comp) { if (comp == NULL) return(-1); while (comp != NULL) { if (comp->stream == NULL) return(-1); if (comp->flags & PAT_FROM_ROOT) return(1); comp = comp->next; } return(0); }
pushq $-0x1 popq %rax testq %rdi, %rdi je 0x6a1dd pushq $0x1 popq %rcx testq %rdi, %rdi je 0x6a1d8 cmpq $0x0, 0x38(%rdi) je 0x6a1dd testb $0x1, 0x21(%rdi) jne 0x6a1db movq 0x10(%rdi), %rdi jmp 0x6a1c0 xorl %eax, %eax retq movl %ecx, %eax retq
/frida[P]libxml2/pattern.c
xmlStreamCtxtAddState
static int xmlStreamCtxtAddState(xmlStreamCtxtPtr comp, int idx, int level) { int i; for (i = 0;i < comp->nbState;i++) { if (comp->states[2 * i] < 0) { comp->states[2 * i] = idx; comp->states[2 * i + 1] = level; return(i); } } if (comp->nbState >= comp->maxState) { int *c...
pushq %rbp pushq %r14 pushq %rbx movl %edx, %ebx movl %esi, %ebp movq %rdi, %r14 movl 0x10(%rdi), %ecx xorl %eax, %eax testl %ecx, %ecx movl $0x0, %edx cmovgl %ecx, %edx cmpq %rax, %rdx je 0x6a20c movq 0x20(%r14), %rsi cmpl $0x0, (%rsi,%rax,8) js 0x6a258 incq %rax jmp 0x6a1f8 movslq 0x14(%r14), %rsi movq 0x20(%r14), %r...
/frida[P]libxml2/pattern.c
xmlPatScanName
static xmlChar * xmlPatScanName(xmlPatParserContextPtr ctxt) { const xmlChar *q, *cur; xmlChar *ret = NULL; int val, len; SKIP_BLANKS; cur = q = CUR_PTR; val = xmlStringCurrentChar(NULL, cur, &len); if (!IS_LETTER(val) && (val != '_') && (val != ':')) return(NULL); while ((IS_LETTER(...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %r12 movq (%rdi), %rbx movabsq $0x100002600, %rax # imm = 0x100002600 movq %rbx, %r14 movzbl (%r14), %ecx cmpq $0x20, %rcx ja 0x6ac77 btq %rcx, %rax jae 0x6ac77 incq %r14 movq %r14, (%r12) incl %ebx jmp 0x6ac5c leaq 0xc(%...
/frida[P]libxml2/pattern.c