name string | code string | asm string | file string |
|---|---|---|---|
Curl_range | CURLcode Curl_range(struct Curl_easy *data)
{
curl_off_t from, to;
char *ptr;
char *ptr2;
if(data->state.use_range && data->state.range) {
CURLofft from_t;
CURLofft to_t;
from_t = curlx_strtoofft(data->state.range, &ptr, 10, &from);
if(from_t == CURL_OFFT_FLOW)
return CURLE_RANGE_ERROR;
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq $-0x1, %rax
movl $0xf8, %ecx
testb $0x1, 0x139d(%rdi)
je 0x201b3
movq 0x1190(%rbx), %rdi
testq %rdi, %rdi
je 0x201b3
movq %rsp, %rsi
leaq 0x10(%rsp), %rcx
movl $0xa, %edx
callq 0x57bf4
movl $0x21, %ebp
cmpl $0x1, %eax
je 0x201b9
movl %eax, %r14d
mov... | /Unity-Technologies[P]curl/lib/curl_range.c |
Curl_sasl_cleanup | void Curl_sasl_cleanup(struct connectdata *conn, unsigned short authused)
{
(void)conn;
(void)authused;
#if defined(USE_KERBEROS5)
/* Cleanup the gssapi structure */
if(authused == SASL_MECH_GSSAPI) {
Curl_auth_cleanup_gssapi(&conn->krb5);
}
#endif
#if defined(USE_GSASL)
/* Cleanup the GSASL structure... | cmpl $0x40, %esi
jne 0x201d5
addq $0x410, %rdi # imm = 0x410
jmp 0x65165
retq
| /Unity-Technologies[P]curl/lib/curl_sasl.c |
Curl_sasl_decode_mech | unsigned short Curl_sasl_decode_mech(const char *ptr, size_t maxlen,
size_t *len)
{
unsigned int i;
char c;
for(i = 0; mechtable[i].name; i++) {
if(maxlen >= mechtable[i].len &&
!memcmp(ptr, mechtable[i].name, mechtable[i].len)) {
if(len)
*len = mecht... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x54b1e(%rip), %rsi # 0x74d0f
movl $0x18, %r13d
leaq 0x719f2(%rip), %rbp # 0x91bf0
movq -0x10(%r13,%rbp), %r12
cmpq %r14, %r12
ja 0x2024a
movq %r15, %rdi
movq %r12, %rdx
callq 0xfbe0... | /Unity-Technologies[P]curl/lib/curl_sasl.c |
Curl_sasl_parse_url_auth_option | CURLcode Curl_sasl_parse_url_auth_option(struct SASL *sasl,
const char *value, size_t len)
{
CURLcode result = CURLE_OK;
size_t mechlen;
if(!len)
return CURLE_URL_MALFORMAT;
if(sasl->resetprefs) {
sasl->resetprefs = FALSE;
sasl->prefmech = SASL_AUTH_NONE;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x3, %ebx
testq %rdx, %rdx
je 0x202e3
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movb 0x1e(%rdi), %al
testb $0x1, %al
je 0x202a4
andb $-0x2, %al
movb %al, 0x1e(%r14)
movw $0x0, 0x1a(%r14)
leaq 0x548de(%rip), %rsi # 0x74b89
movq %r12, %rdi
movq %r15, ... | /Unity-Technologies[P]curl/lib/curl_sasl.c |
Curl_sasl_init | void Curl_sasl_init(struct SASL *sasl, struct Curl_easy *data,
const struct SASLproto *params)
{
unsigned long auth = data->set.httpauth;
sasl->params = params; /* Set protocol dependent parameters */
sasl->state = SASL_STOP; /* Not yet running */
sasl->curmech = NULL; ... | movq 0x208(%rsi), %rax
movq %rdx, (%rdi)
movl $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movw %cx, 0x18(%rdi)
movzwl 0x38(%rdx), %edx
movw %dx, 0x1a(%rdi)
movw %cx, 0x1c(%rdi)
movb 0x1e(%rdi), %cl
andb $-0x8, %cl
incb %cl
movb %cl, 0x1e(%rdi)
cmpq $0x1, %rax
je 0x20367
xorl %ecx, %ecx
testb $0x1, %al
setne %... | /Unity-Technologies[P]curl/lib/curl_sasl.c |
Curl_sha512_256it | CURLcode
Curl_sha512_256it(unsigned char *output, const unsigned char *input,
size_t input_size)
{
Curl_sha512_256_ctx ctx;
CURLcode res;
res = Curl_sha512_256_init(&ctx);
if(res != CURLE_OK)
return res;
res = Curl_sha512_256_update(&ctx, (const void *) input, input_size);
if(res !=... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsp, %rdi
callq 0x20e15
movl %eax, %ebx
testl %eax, %eax
jne 0x20e04
movq (%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x10620
movl %eax, %ebp
xorl %ebx, %ebx
movq %r1... | /Unity-Technologies[P]curl/lib/curl_sha512_256.c |
Curl_failf | void Curl_failf(struct Curl_easy *data, const char *fmt, ...)
{
DEBUGASSERT(!strchr(fmt, '\n'));
if(data->set.verbose || data->set.errorbuffer) {
va_list ap;
int len;
char error[CURL_ERROR_SIZE + 2];
va_start(ap, fmt);
len = mvsnprintf(error, CURL_ERROR_SIZE, fmt, ap);
if(data->set.errorbuf... | pushq %rbp
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, %r10
movq %rdi, %rbx
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x2109d
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
m... | /Unity-Technologies[P]curl/lib/curl_trc.c |
trc_infof | static void trc_infof(struct Curl_easy *data, struct curl_trc_feat *feat,
const char * const fmt, va_list ap)
{
int len = 0;
char buffer[MAXINFO + 5];
if(feat)
len = msnprintf(buffer, (MAXINFO + 1), "[%s] ", feat->name);
len += mvsnprintf(buffer + len, (MAXINFO + 1) - len, fmt, ap);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x808, %rsp # imm = 0x808
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
testq %rsi, %rsi
je 0x21240
movq (%rsi), %rcx
leaq 0x4f6c6(%rip), %rdx # 0x708f5
movq %rsp, %rdi
movl $0x801, %esi # imm = 0x801
xorl %eax, %eax
callq 0xf600
jmp 0x21242
... | /Unity-Technologies[P]curl/lib/curl_trc.c |
Curl_trc_cf_infof | void Curl_trc_cf_infof(struct Curl_easy *data, struct Curl_cfilter *cf,
const char *fmt, ...)
{
DEBUGASSERT(cf);
if(Curl_trc_cf_is_verbose(cf, data)) {
va_list ap;
int len = 0;
char buffer[MAXINFO + 2];
if(data->state.feat)
len += msnprintf(buffer + len, MAXINFO - len, "... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x8d8, %rsp # imm = 0x8D8
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x212fa
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0... | /Unity-Technologies[P]curl/lib/curl_trc.c |
cw_out_do_write | static CURLcode cw_out_do_write(struct cw_out_ctx *ctx,
struct Curl_easy *data,
cw_out_type otype,
bool flush_all,
const char *buf, size_t blen)
{
CURLcode result = CURLE_OK;
/* if we hav... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x21c32
leaq 0x20(%rbx), %r15
cmpl %ebp, 0x28(%rax)
jne 0x21c0f
movq %r15, 0x8(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
movq %rcx, %rdx... | /Unity-Technologies[P]curl/lib/cw-out.c |
cw_out_append | static CURLcode cw_out_append(struct cw_out_ctx *ctx,
cw_out_type otype,
const char *buf, size_t blen)
{
if(cw_out_bufs_len(ctx) + blen > DYN_PAUSE_BUFFER)
return CURLE_TOO_LARGE;
/* if we do not have a buffer, or it is of another type, make a new one... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq 0x20(%rdi), %r13
xorl %r12d, %r12d
testq %r13, %r13
je 0x21dff
leaq 0x8(%r13), %rdi
callq 0x240d8
addq %rax, %r12
movq (%r13), %r13
jmp 0x21de8
addq %rbx, %r12
movl $0x64, %e... | /Unity-Technologies[P]curl/lib/cw-out.c |
dict_do | static CURLcode dict_do(struct Curl_easy *data, bool *done)
{
char *word;
char *eword = NULL;
char *ppath;
char *database = NULL;
char *strategy = NULL;
char *nthdef = NULL; /* This is not part of the protocol, but required
by RFC 2229 */
CURLcode result;
char *path;
*done ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, (%rsi)
movq 0x1228(%rdi), %rdi
movq %rsp, %rdx
xorl %esi, %esi
xorl %ecx, %ecx
movl $0x3, %r8d
callq 0x2566b
movl %eax, %r13d
testl %eax, %eax
jne 0x2241c
movq (%rsp), %rdi
leaq 0x4e8d0(%rip), %rsi # 0x70a34
movl... | /Unity-Technologies[P]curl/lib/dict.c |
Curl_doh_is_resolved | CURLcode Curl_doh_is_resolved(struct Curl_easy *data,
struct Curl_dns_entry **dnsp)
{
CURLcode result;
struct doh_probes *dohp = data->req.doh;
*dnsp = NULL; /* defaults to no response */
if(!dohp)
return CURLE_OUT_OF_MEMORY;
if(dohp->probe[DOH_SLOT_IPV4].easy_mid < 0 &&
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movq 0x1c0(%rdi), %rax
movq $0x0, (%rsi)
testq %rax, %rax
je 0x23540
movq %rdi, %r13
cmpq $0x0, 0x8(%rax)
jns 0x22fe0
cmpq $0x0, 0x240(%rax)
js 0x236f6
xorl %ebp, %ebp
cmpl $0x0, 0x478(%rax)
jne 0x2382a
movq %rs... | /Unity-Technologies[P]curl/lib/doh.c |
Curl_doh_close | void Curl_doh_close(struct Curl_easy *data)
{
struct doh_probes *doh = data->req.doh;
if(doh && data->multi) {
struct Curl_easy *probe_data;
curl_off_t mid;
size_t slot;
for(slot = 0; slot < DOH_SLOT_COUNT; slot++) {
mid = doh->probe[slot].easy_mid;
if(mid < 0)
continue;
do... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x1c0(%rdi), %r15
testq %r15, %r15
je 0x238cf
movq %rdi, %rbx
cmpq $0x0, 0xd0(%rdi)
je 0x238cf
addq $0x8, %r15
movb $0x1, %bpl
xorl %eax, %eax
movq %rsp, %r14
imulq $0x238, %rax, %rax # imm = 0x238
movq (%r15,%rax), %rsi
testq %rsi, %rsi
js 0x238bf
addq %... | /Unity-Technologies[P]curl/lib/doh.c |
doh_show | static void doh_show(struct Curl_easy *data,
const struct dohentry *d)
{
int i;
infof(data, "[DoH] TTL: %u seconds", d->ttl);
for(i = 0; i < d->numaddr; i++) {
const struct dohaddr *a = &d->addr[i];
if(a->type == DNS_TYPE_A) {
infof(data, "[DoH] A: %u.%u.%u.%u",
a->i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbp
testb $0x10, 0xa9d(%rdi)
je 0x23924
movq 0x1320(%rbp), %rax
testq %rax, %rax
je 0x2390c
cmpl $0x0, 0x8(%rax)
jle 0x23924
movl 0x264(%r14), %edx
leaq 0x4d377(%rip), %rsi # 0x70c91
movq %rbp, %rdi
xorl %... | /Unity-Technologies[P]curl/lib/doh.c |
doh_done | static int doh_done(struct Curl_easy *doh, CURLcode result)
{
struct Curl_easy *data; /* the transfer that asked for the DoH probe */
data = Curl_multi_get_handle(doh->multi, doh->set.dohfor_mid);
if(!data) {
DEBUGF(infof(doh, "doh_done: xfer for mid=%" FMT_OFF_T
" not found", doh->set.dohfo... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movq 0xd0(%rdi), %rdi
movq 0xa60(%r14), %rsi
callq 0x45e38
testq %rax, %rax
je 0x23c0d
movq %rax, %rbx
movq 0x1c0(%rax), %r15
movl 0x478(%r15), %edx
decl %edx
movl %edx, 0x478(%r15)
testb $0x10, 0xa9d(%r14)
je 0x23bb9
movq 0x1320(%r1... | /Unity-Technologies[P]curl/lib/doh.c |
doh_skipqname | static DOHcode doh_skipqname(const unsigned char *doh, size_t dohlen,
unsigned int *indexp)
{
unsigned char length;
do {
if(dohlen < (*indexp + 1))
return DOH_DNS_OUT_OF_RANGE;
length = doh[*indexp];
if((length & 0xc0) == 0xc0) {
/* name pointer, advance over it ... | movl (%rdx), %ecx
leal 0x1(%rcx), %r8d
movl $0x2, %eax
cmpq %rsi, %r8
ja 0x23c76
movl %ecx, %eax
movzbl (%rdi,%rax), %r9d
movl %r9d, %r10d
andl $0xc0, %r10d
jne 0x23c57
addl %r9d, %r8d
movl $0x2, %eax
cmpq %rsi, %r8
ja 0x23c76
movl %r8d, (%rdx)
movl %r8d, %ecx
testl %r9d, %r9d
jne 0x23c1c
jmp 0x23c74
movl $0x1, %eax
cm... | /Unity-Technologies[P]curl/lib/doh.c |
doh_rdata | static DOHcode doh_rdata(const unsigned char *doh,
size_t dohlen,
unsigned short rdlength,
unsigned short type,
int index,
struct dohentry *d)
{
/* RDATA
- A (TYPE 1): 4 bytes
- AAAA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r13d
cmpl $0x1c, %ecx
je 0x23dfd
cmpl $0x5, %ecx
je 0x23ce2
cmpl $0x1, %ecx
jne 0x23e3e
movl $0x6, %ebp
cmpw $0x4, %dx
jne 0x23e40
movslq 0x260(%r9), %rax
cmpq $0x17, %rax
jg 0x23e3e
leaq (%rax,%rax,4), %rcx
movl $0x1, 0x80(%... | /Unity-Technologies[P]curl/lib/doh.c |
Curl_dyn_init | void Curl_dyn_init(struct dynbuf *s, size_t toobig)
{
DEBUGASSERT(s);
DEBUGASSERT(toobig);
s->bufr = NULL;
s->leng = 0;
s->allc = 0;
s->toobig = toobig;
#ifdef DEBUGBUILD
s->init = DYNINIT;
#endif
} | xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
retq
| /Unity-Technologies[P]curl/lib/dynbuf.c |
Curl_dyn_reset | void Curl_dyn_reset(struct dynbuf *s)
{
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
DEBUGASSERT(!s->leng || s->bufr);
if(s->leng)
s->bufr[0] = 0;
s->leng = 0;
} | cmpq $0x0, 0x8(%rdi)
je 0x23e98
movq (%rdi), %rax
movb $0x0, (%rax)
movq $0x0, 0x8(%rdi)
retq
| /Unity-Technologies[P]curl/lib/dynbuf.c |
Curl_dyn_tail | CURLcode Curl_dyn_tail(struct dynbuf *s, size_t trail)
{
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
DEBUGASSERT(!s->leng || s->bufr);
if(trail > s->leng)
return CURLE_BAD_FUNCTION_ARGUMENT;
else if(trail == s->leng)
return CURLE_OK;
else if(!trail) {
Curl_dyn_reset(s);
}
else {
mem... | pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rax
movl $0x2b, %ebx
cmpq %rsi, %rax
jb 0x23ef8
movq %rsi, %r15
xorl %ebx, %ebx
movq %rax, %rsi
subq %r15, %rsi
je 0x23ef8
movq %rdi, %r14
testq %r15, %r15
je 0x23ee5
movq (%r14), %rdi
addq %rdi, %rsi
movq %r15, %rdx
callq 0x10290
movq %r15, 0x8(%r14)
movq (%r14), %rax
... | /Unity-Technologies[P]curl/lib/dynbuf.c |
dyn_nappend | static CURLcode dyn_nappend(struct dynbuf *s,
const unsigned char *mem, size_t len)
{
size_t indx = s->leng;
size_t a = s->allc;
size_t fit = len + indx + 1; /* new string + old string + zero byte */
/* try to detect if there is rubbish in the struct */
DEBUGASSERT(s->init == DYNI... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r13
movq 0x18(%rdi), %r12
leaq (%rdx,%r13), %rcx
incq %rcx
cmpq %r12, %rcx
jbe 0x23f46
leaq 0x7113f(%rip), %rax # 0x95068
movq (%rbx), %rdi
callq *(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movl $0x64, ... | /Unity-Technologies[P]curl/lib/dynbuf.c |
Curl_dyn_add | CURLcode Curl_dyn_add(struct dynbuf *s, const char *str)
{
size_t n;
DEBUGASSERT(str);
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
DEBUGASSERT(!s->leng || s->bufr);
n = strlen(str);
return dyn_nappend(s, (unsigned char *)str, n);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xf4b0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23f02
| /Unity-Technologies[P]curl/lib/dynbuf.c |
Curl_dyn_vaddf | CURLcode Curl_dyn_vaddf(struct dynbuf *s, const char *fmt, va_list ap)
{
#ifdef BUILDING_LIBCURL
int rc;
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
DEBUGASSERT(!s->leng || s->bufr);
DEBUGASSERT(fmt);
rc = Curl_dyn_vprintf(s, fmt, ap);
if(!rc)
return CURLE_OK;
else if(rc == MERR_TOO_LARGE)
... | pushq %rax
callq 0x40f60
cmpl $0x2, %eax
movl $0x64, %ecx
movl $0x1b, %edx
cmovel %ecx, %edx
testl %eax, %eax
cmovnel %edx, %eax
popq %rcx
retq
| /Unity-Technologies[P]curl/lib/dynbuf.c |
Curl_dyn_addf | CURLcode Curl_dyn_addf(struct dynbuf *s, const char *fmt, ...)
{
CURLcode result;
va_list ap;
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
DEBUGASSERT(!s->leng || s->bufr);
va_start(ap, fmt);
result = Curl_dyn_vaddf(s, fmt, ap);
va_end(ap);
return result;
} | subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x2408e
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(... | /Unity-Technologies[P]curl/lib/dynbuf.c |
curl_global_init | CURLcode curl_global_init(long flags)
{
CURLcode result;
global_init_lock();
result = global_init(flags, TRUE);
global_init_unlock();
return result;
} | pushq %rax
movl $0x1, %eax
xchgl %eax, 0x72af8(%rip) # 0x971a4
testl %eax, %eax
jne 0x246b4
jmp 0x246c0
pause
movl 0x72aea(%rip), %eax # 0x971a4
testl %eax, %eax
jne 0x246b2
jmp 0x246a1
movl $0x1, %edi
callq 0x246d6
movl $0x0, 0x72ad0(%rip) # 0x971a4
popq %rcx
retq
| /Unity-Technologies[P]curl/lib/easy.c |
curl_global_cleanup | void curl_global_cleanup(void)
{
global_init_lock();
if(!initialized) {
global_init_unlock();
return;
}
if(--initialized) {
global_init_unlock();
return;
}
Curl_ssl_cleanup();
Curl_resolver_global_cleanup();
#ifdef _WIN32
Curl_win32_cleanup(easy_init_flags);
#endif
Curl_amiga_clea... | pushq %rax
movl $0x1, %eax
xchgl %eax, 0x72975(%rip) # 0x971a4
testl %eax, %eax
jne 0x24837
jmp 0x24843
pause
movl 0x72967(%rip), %eax # 0x971a4
testl %eax, %eax
jne 0x24835
jmp 0x24824
movl 0x7295f(%rip), %eax # 0x971a8
testl %eax, %eax
je 0x24861
decl %eax
movl %eax, 0x72953(%rip) # 0x971a8
jne 0x2486... | /Unity-Technologies[P]curl/lib/easy.c |
curl_easy_recv | CURLcode curl_easy_recv(struct Curl_easy *data, void *buffer, size_t buflen,
size_t *n)
{
CURLcode result;
ssize_t n1;
struct connectdata *c;
if(Curl_is_in_callback(data))
return CURLE_RECURSIVE_API_CALL;
result = easy_connection(data, &c);
if(result)
return result;
if(!... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x45b37
movl $0x5d, %ebp
testb %al, %al
jne 0x25273
movq %rsp, %rsi
movq %r12, %rdi
callq 0x2528c
testl %eax, %eax
jne 0x25271
cmpq $0x0, 0x18(%r12)
jne 0x2524f
movq (%rsp), %rsi... | /Unity-Technologies[P]curl/lib/easy.c |
lookup | static struct curl_easyoption *lookup(const char *name, CURLoption id)
{
DEBUGASSERT(name || id);
DEBUGASSERT(!Curl_easyopts_check());
if(name || id) {
struct curl_easyoption *o = &Curl_easyopts[0];
do {
if(name) {
if(strcasecompare(o->name, name))
return o;
}
else {
... | pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
sete %al
testl %esi, %esi
sete %cl
testb %cl, %al
jne 0x25466
movl %esi, %ebp
movq %rdi, %r14
leaq 0x6fc56(%rip), %rbx # 0x95090
testq %r14, %r14
je 0x25450
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x10580
testl %eax, %eax
je 0x2545b
jmp 0x25468
cmpl %ebp, 0x8(%rbx)
... | /Unity-Technologies[P]curl/lib/easygetopt.c |
Curl_hash_clean_with_criterium | void
Curl_hash_clean_with_criterium(struct Curl_hash *h, void *user,
int (*comp)(void *, void *))
{
size_t i;
if(!h || !h->table)
return;
DEBUGASSERT(h->init == HASHINIT);
for(i = 0; i < h->slots; ++i) {
struct Curl_llist *list = &h->table[i];
struct Curl_llist_node ... | testq %rdi, %rdi
je 0x2ec39
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
cmpq $0x0, (%rdi)
je 0x2ec2b
cmpq $0x0, 0x20(%r15)
je 0x2ec2b
movq %rdx, %rbx
movq %rsi, %r14
xorl %edi, %edi
movq %rdi, (%rsp)
shlq $0x5, %rdi
addq (%r15), %rdi
callq 0x3cb2e
testq %rax, %rax
je 0x2... | /Unity-Technologies[P]curl/lib/hash.c |
Curl_headers_init | CURLcode Curl_headers_init(struct Curl_easy *data)
{
struct Curl_cwriter *writer;
CURLcode result;
if(data->conn && (data->conn->handler->protocol & PROTO_FAMILY_HTTP)) {
/* avoid installing it twice */
if(Curl_cwriter_get_by_name(data, hds_cw_collect.name))
return CURLE_OK;
result = Curl_cwri... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x18(%rdi), %rax
xorl %ebp, %ebp
testq %rax, %rax
je 0x2f464
movq 0x3c0(%rax), %rax
testb $0x3, 0x8c(%rax)
je 0x2f464
movq %rdi, %rbx
leaq 0x43ea3(%rip), %rsi # 0x732b5
callq 0x4c397
testq %rax, %rax
jne 0x2f464
leaq 0x62f2d(%rip), %rdx # 0x92350
leaq 0x8(%... | /Unity-Technologies[P]curl/lib/headers.c |
hds_cw_collect_write | static CURLcode hds_cw_collect_write(struct Curl_easy *data,
struct Curl_cwriter *writer, int type,
const char *buf, size_t blen)
{
if((type & CLIENTWRITE_HEADER) && !(type & CLIENTWRITE_STATUS)) {
unsigned char htype = (unsigned char)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r15
movl %edx, %eax
andl $0xc, %eax
cmpl $0x4, %eax
jne 0x2f599
movq %r8, (%rsp)
movb $0x4, %al
testb $0x10, %bpl
jne 0x2f520
movb $0x8, %al
testb $0x20, %bpl
jne 0x2f520
movl %ebp, %... | /Unity-Technologies[P]curl/lib/headers.c |
http_rw_hd | static CURLcode http_rw_hd(struct Curl_easy *data,
const char *hd, size_t hdlen,
const char *buf_remain, size_t blen,
size_t *pconsumed)
{
CURLcode result = CURLE_OK;
struct SingleRequest *k = &data->req;
int writetype;
*pconsumed... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, (%rcx)
movzbl (%rsi), %eax
cmpl $0xd, %eax
je 0x35701
cmpl $0xa, %eax
jne 0x35810
leaq 0x1(%r14), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x23e58
movq %r12, %rdi
movq %r1... | /Unity-Technologies[P]curl/lib/http.c |
Curl_http_decode_status | CURLcode Curl_http_decode_status(int *pstatus, const char *s, size_t len)
{
CURLcode result = CURLE_BAD_FUNCTION_ARGUMENT;
int status = 0;
int i;
if(len != 3)
goto out;
for(i = 0; i < 3; ++i) {
char c = s[i];
if(c < '0' || c > '9')
goto out;
status *= 10;
status += c - '0';
}
... | movl $0x2b, %eax
cmpq $0x3, %rdx
jne 0x36402
xorl %edx, %edx
xorl %ecx, %ecx
movzbl (%rsi,%rdx), %r8d
leal -0x3a(%r8), %r9d
cmpb $-0xa, %r9b
jb 0x36402
leal (%rcx,%rcx,4), %ecx
leal (%r8,%rcx,2), %ecx
addl $-0x30, %ecx
incq %rdx
cmpq $0x3, %rdx
jne 0x363dc
xorl %eax, %eax
jmp 0x36407
movl $0xffffffff, %ecx # imm ... | /Unity-Technologies[P]curl/lib/http.c |
Curl_http_req_free | void Curl_http_req_free(struct httpreq *req)
{
if(req) {
free(req->scheme);
free(req->authority);
free(req->path);
Curl_dynhds_free(&req->headers);
Curl_dynhds_free(&req->trailers);
free(req);
}
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x36561
movq %rdi, %rbx
leaq 0x5eb3d(%rip), %r14 # 0x95068
movq 0x18(%rdi), %rdi
callq *(%r14)
movq 0x20(%rbx), %rdi
callq *(%r14)
movq 0x28(%rbx), %rdi
callq *(%r14)
leaq 0x30(%rbx), %rdi
callq 0x24118
leaq 0x68(%rbx), %rdi
callq 0x24118
movq %rbx, %rdi
movq %r1... | /Unity-Technologies[P]curl/lib/http.c |
Curl_http_req_to_h2 | CURLcode Curl_http_req_to_h2(struct dynhds *h2_headers,
struct httpreq *req, struct Curl_easy *data)
{
const char *scheme = NULL, *authority = NULL;
struct dynhds_entry *e;
size_t i;
CURLcode result;
DEBUGASSERT(req);
DEBUGASSERT(h2_headers);
if(req->scheme) {
scheme = r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq 0x18(%rsi), %r15
testq %r15, %r15
je 0x369a0
movq 0x20(%rbx), %r12
testq %r12, %r12
jne 0x36a43
leaq 0x30(%rbx), %rdi
leaq 0x3cee3(%rip), %rsi # 0x73867
movl $0x4, %edx
callq 0x241d3
testq %r... | /Unity-Technologies[P]curl/lib/http.c |
http_exp100_send_anyway | static void http_exp100_send_anyway(struct Curl_easy *data)
{
struct Curl_creader *r = Curl_creader_get_by_type(data, &cr_exp100);
if(r)
http_exp100_continue(data, r);
} | pushq %rbx
movq %rdi, %rbx
leaq 0x5b640(%rip), %rsi # 0x924b0
callq 0x4cbd3
testq %rax, %rax
je 0x36ea8
movq 0x10(%rax), %rax
cmpl $0x0, 0x30(%rax)
je 0x36ea8
movl $0x0, 0x30(%rax)
movl 0x140(%rbx), %eax
andl $-0x43, %eax
orl $0x2, %eax
movl %eax, 0x140(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x45a6e
po... | /Unity-Technologies[P]curl/lib/http.c |
cr_exp100_read | static CURLcode cr_exp100_read(struct Curl_easy *data,
struct Curl_creader *reader,
char *buf, size_t blen,
size_t *nread, bool *eos)
{
struct cr_exp100_ctx *ctx = reader->ctx;
timediff_t ms;
switch(ctx->state) {
case ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
movq 0x10(%rsi), %rbx
movl 0x30(%rbx), %eax
cmpl $0x1, %eax
je 0x36f97
cmpl $0x3, %eax
je 0x36f82
cmpl $0x2, %eax
jne 0x37048
movq %r9, %r12
movq %r15, %rdi
callq 0... | /Unity-Technologies[P]curl/lib/http.c |
Curl_h1_req_write_head | CURLcode Curl_h1_req_write_head(struct httpreq *req, int http_minor,
struct dynbuf *dbuf)
{
CURLcode result;
result = Curl_dyn_addf(dbuf, "%s %s%s%s%s HTTP/1.%d\r\n",
req->method,
req->scheme? req->scheme : "",
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
leaq 0x43b04(%rip), %rax # 0x7b0f5
cmoveq %rax, %rcx
movl %esi, %r10d
leaq 0x435c3(%rip), %r8 # 0x7abc2
cmoveq %rax, %r8
movq 0x20(%rdi), %r9
testq %r9, %r9
cmoveq %rax, %r9
movq 0x28(%rdi), %r11
testq %r11,... | /Unity-Technologies[P]curl/lib/http1.c |
calc_payload_hash | static CURLcode calc_payload_hash(struct Curl_easy *data,
unsigned char *sha_hash, char *sha_hex)
{
const char *post_data = data->set.postfields;
size_t post_data_len = 0;
CURLcode result;
if(post_data) {
if(data->set.postfieldsize < 0)
post_data_len = strlen(post_da... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x220(%rdi), %r15
testq %r15, %r15
je 0x38780
movq 0x230(%rdi), %rdx
testq %rdx, %rdx
jns 0x38782
movq %r15, %rdi
callq 0xf4b0
movq %rax, %rdx
jmp 0x38782
xorl %edx, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5261c
movl %eax, ... | /Unity-Technologies[P]curl/lib/http_aws_sigv4.c |
Curl_httpchunk_init | void Curl_httpchunk_init(struct Curl_easy *data, struct Curl_chunker *ch,
bool ignore_body)
{
(void)data;
ch->hexindex = 0; /* start at 0 */
ch->state = CHUNK_HEX; /* we get hex first! */
ch->last_code = CHUNKE_OK;
Curl_dyn_init(&ch->trailer, DYN_H1_TRAILER);
ch->ignore_body = ... | pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movb $0x0, 0x30(%rsi)
movq $0x0, 0x8(%rsi)
leaq 0x10(%rsi), %rdi
movl $0x1000, %esi # imm = 0x1000
callq 0x23e58
movb 0x42(%r14), %al
andb $-0x2, %al
orb %bl, %al
movb %al, 0x42(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Unity-Technologies[P]curl/lib/http_chunks.c |
httpchunk_readwrite | static CURLcode httpchunk_readwrite(struct Curl_easy *data,
struct Curl_chunker *ch,
struct Curl_cwriter *cw_next,
const char *buf, size_t blen,
size_t *pconsumed)
{
CURLcode... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x18(%rsp)
movq $0x0, (%r9)
movl 0x8(%rsi), %eax
xorl %r14d, %r14d
cmpl $0x8, %eax
je 0x3901a
cmpl $0x9, %eax
jne 0x38ba0
movl $0x38, %r14d
jmp 0x3901a
movq %r9, %rbp
movq %r8, %rbx
movq %rcx, %r12
movq %rsi, %r15
movq %rdi, %... | /Unity-Technologies[P]curl/lib/http_chunks.c |
cw_chunked_init | static CURLcode cw_chunked_init(struct Curl_easy *data,
struct Curl_cwriter *writer)
{
struct chunked_writer *ctx = writer->ctx;
data->req.chunk = TRUE; /* chunks coming our way. */
Curl_httpchunk_init(data, &ctx->ch, FALSE);
return CURLE_OK;
} | pushq %rbx
movq 0x10(%rsi), %rbx
orl $0x1000, 0x1c9(%rdi) # imm = 0x1000
movb $0x0, 0x50(%rbx)
movq $0x0, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
movl $0x1000, %esi # imm = 0x1000
callq 0x23e58
andb $-0x2, 0x62(%rbx)
xorl %eax, %eax
popq %rbx
retq
| /Unity-Technologies[P]curl/lib/http_chunks.c |
cr_chunked_read | static CURLcode cr_chunked_read(struct Curl_easy *data,
struct Curl_creader *reader,
char *buf, size_t blen,
size_t *pnread, bool *peos)
{
struct chunked_reader *ctx = reader->ctx;
CURLcode result = CURLE_READ_ERROR;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x458, %rsp # imm = 0x458
movq 0x10(%rsi), %r15
movq $0x0, (%r8)
movb 0x60(%r15), %al
shrb %al
andb $0x1, %al
movb %al, (%r9)
movb 0x60(%r15), %al
testb $0x2, %al
jne 0x3965f
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r13
movq %rdx, 0x48(... | /Unity-Technologies[P]curl/lib/http_chunks.c |
Curl_input_digest | CURLcode Curl_input_digest(struct Curl_easy *data,
bool proxy,
const char *header) /* rest of the *-authenticate:
header */
{
/* Point to the correct struct with this */
struct digestdata *digest;
if(proxy) {
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xcf0(%rdi), %rax
addq $0xd28, %r14 # imm = 0xD28
testl %esi, %esi
cmoveq %rax, %r14
leaq 0x39f32(%rip), %rsi # 0x73777
movl $0x6, %edx
movq %rbx, %rdi
callq 0xf530
testl %eax, %eax
je 0x3988e
movzbl 0x6(%rbx), %eax
cmpl $0x20, %eax
je... | /Unity-Technologies[P]curl/lib/http_digest.c |
Curl_input_ntlm | CURLcode Curl_input_ntlm(struct Curl_easy *data,
bool proxy, /* if proxy or not */
const char *header) /* rest of the www-authenticate:
header */
{
/* point to the correct struct with this */
struct ntlmdata *n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbp
movl %esi, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %r15
leaq 0x410(%r15), %r12
leaq 0x428(%r15), %rax
testl %esi, %esi
movq %r12, %r13
movq %rax, 0x8(%rsp)
cmovneq %rax, %r13
leaq 0x39c65(%rip), %rsi # 0x73726
movl $0x4... | /Unity-Technologies[P]curl/lib/http_ntlm.c |
Curl_http_proxy_get_destination | CURLcode Curl_http_proxy_get_destination(struct Curl_cfilter *cf,
const char **phostname,
int *pport, bool *pipv6_ip)
{
DEBUGASSERT(cf);
DEBUGASSERT(cf->conn);
if(cf->conn->bits.conn_to_host)
*phostname = cf->conn->conn_to_host... | pushq %rbx
movq %rcx, %rbx
movq %rdi, %rax
movq 0x18(%rdi), %rcx
testb $0x1, 0x3b9(%rcx)
jne 0x39fca
cmpl $0x1, 0x20(%rax)
jne 0x39fe7
movq 0x80(%rcx), %rdi
movq %rdi, (%rsi)
jmp 0x39fda
movq 0x98(%rcx), %rdi
movq %rdi, (%rsi)
cmpl $0x1, 0x20(%rax)
jne 0x39fee
movq 0x18(%rax), %rax
movzwl 0x57e(%rax), %ecx
jmp 0x3a009
... | /Unity-Technologies[P]curl/lib/http_proxy.c |
Curl_cf_http_proxy_get_host | void Curl_cf_http_proxy_get_host(struct Curl_cfilter *cf,
struct Curl_easy *data,
const char **phost,
const char **pdisplay_host,
int *pport)
{
(void)data;
if(!cf->connected) {
*ph... | testb $0x1, 0x24(%rdi)
jne 0x3a2bd
movq 0x18(%rdi), %rax
movq 0xf0(%rax), %rax
movq %rax, (%rdx)
movq 0x18(%rdi), %rax
movq 0xf8(%rax), %rax
movq %rax, (%rcx)
movq 0x18(%rdi), %rax
movl 0x100(%rax), %eax
movl %eax, (%r8)
retq
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
jmpq *%rax
| /Unity-Technologies[P]curl/lib/http_proxy.c |
http_proxy_cf_close | static void http_proxy_cf_close(struct Curl_cfilter *cf,
struct Curl_easy *data)
{
struct cf_proxy_ctx *ctx = cf->ctx;
CURL_TRC_CF(data, cf, "close");
cf->connected = FALSE;
if(ctx->cf_protocol) {
struct Curl_cfilter *f;
/* if someone already removed it, we assume he als... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
testq %rsi, %rsi
je 0x3a514
testb $0x10, 0xa9d(%rbx)
je 0x3a514
movq 0x1320(%rbx), %rax
testq %rax, %rax
je 0x3a4f7
cmpl $0x0, 0x8(%rax)
jle 0x3a514
movq (%r14), %rax
cmpl $0x0, 0xc(%rax)
jle 0x3a514
leaq 0x397f3(%rip), %rdx # 0x... | /Unity-Technologies[P]curl/lib/http_proxy.c |
Curl_is_ASCII_name | bool Curl_is_ASCII_name(const char *hostname)
{
/* get an UNSIGNED local version of the pointer */
const unsigned char *ch = (const unsigned char *)hostname;
if(!hostname) /* bad input, consider it ASCII! */
return TRUE;
while(*ch) {
if(*ch++ & 0x80)
return FALSE;
}
return TRUE;
} | testq %rdi, %rdi
je 0x3a5ea
cmpb $0x0, (%rdi)
leaq 0x1(%rdi), %rdi
jg 0x3a5dd
sete %al
retq
movb $0x1, %al
retq
| /Unity-Technologies[P]curl/lib/idn.c |
imap_setup_connection | static CURLcode imap_setup_connection(struct Curl_easy *data,
struct connectdata *conn)
{
/* Initialise the IMAP layer */
CURLcode result = imap_init(data);
if(result)
return result;
/* Clear the TLS upgraded flag */
conn->bits.tls_upgraded = FALSE;
return CURLE_O... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5a863(%rip), %rax # 0x95080
movl $0x1, %edi
movl $0x50, %esi
callq *(%rax)
movq %rax, 0x1b8(%r14)
testq %rax, %rax
je 0x3a840
andb $-0x9, 0x3bb(%rbx)
xorl %eax, %eax
jmp 0x3a845
movl $0x1b, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Unity-Technologies[P]curl/lib/imap.c |
imap_done | static CURLcode imap_done(struct Curl_easy *data, CURLcode status,
bool premature)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct IMAP *imap = data->req.p.imap;
(void)premature;
if(!imap)
return CURLE_OK;
if(status) {
connclose(conn, "IMAP do... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x1b8(%rdi), %r12
testq %r12, %r12
je 0x3afed
movl %esi, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %r15
testl %esi, %esi
je 0x3aff4
movq %r15, %rdi
movl $0x1, %esi
callq 0x1ae25
jmp 0x3b095
xorl %ebx, %ebx
jmp 0x3b11c
xorl %ebx, %ebx
cmpb $0x0, 0xa99(%r14)
jne 0x3... | /Unity-Technologies[P]curl/lib/imap.c |
imap_doing | static CURLcode imap_doing(struct Curl_easy *data, bool *dophase_done)
{
CURLcode result = imap_multi_statemach(data, dophase_done);
if(result)
DEBUGF(infof(data, "DO phase failed"));
else if(*dophase_done) {
result = imap_dophase_done(data, FALSE /* not connected */);
DEBUGF(infof(data, "DO phase i... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3b322
movl %eax, %ebp
testl %eax, %eax
jne 0x3b3e3
cmpb $0x1, (%r14)
jne 0x3b3e3
movq 0x1b8(%rbx), %rax
cmpl $0x0, (%rax)
je 0x3b3e3
movq %rbx, %rdi
callq 0x5c44e
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /Unity-Technologies[P]curl/lib/imap.c |
imap_perform_upgrade_tls | static CURLcode imap_perform_upgrade_tls(struct Curl_easy *data,
struct connectdata *conn)
{
/* Start the SSL connection */
struct imap_conn *imapc = &conn->proto.imapc;
CURLcode result;
bool ssldone = FALSE;
if(!Curl_conn_is_ssl(conn, FIRSTSOCKET)) {
result = Cur... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, 0xf(%rsp)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1832e
testb %al, %al
jne 0x3c121
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6d5fc
testl %eax, %eax
jne 0x3c136
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
xorl %esi, %esi
... | /Unity-Technologies[P]curl/lib/imap.c |
imap_perform_authentication | static CURLcode imap_perform_authentication(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct imap_conn *imapc = &conn->proto.imapc;
saslprogress progress;
/* Check if already authenticated OR if there is enough data to authentica... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x2, 0x53b(%rsi)
jne 0x3c393
movq %rsi, %r14
leaq 0x4e0(%rsi), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x20368
testb %al, %al
je 0x3c393
movb 0x53b(%r14), %al
andb $0x10, %al
shrb $0x4, %al
movzbl %al, %edx
leaq 0x4(%rsp), %rcx
movq %r15, ... | /Unity-Technologies[P]curl/lib/imap.c |
imap_atom | static char *imap_atom(const char *str, bool escape_only)
{
struct dynbuf line;
size_t nclean;
size_t len;
if(!str)
return NULL;
len = strlen(str);
nclean = strcspn(str, "() {%*]\\\"");
if(len == nclean)
/* nothing to escape, return a strdup */
return strdup(str);
Curl_dyn_init(&line, 200... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x3c51c
movl %esi, %ebx
movq %rdi, %r14
callq 0xf4b0
movq %rax, %r15
leaq 0x3862e(%rip), %rsi # 0x74afb
movq %r14, %rdi
callq 0xf130
cmpq %rax, %r15
jne 0x3c4f3
leaq 0x58b97(%rip), %rax # 0x95078
movq %r14, %rdi
addq $0x... | /Unity-Technologies[P]curl/lib/imap.c |
imap_perform_search | static CURLcode imap_perform_search(struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct IMAP *imap = data->req.p.imap;
/* Check we have a query string */
if(!imap->query) {
failf(data, "Cannot SEARCH without a query string.");
return CURLE_URL_MALFORMAT;
}
/* Send the SEARCH command */
... | pushq %rbx
movq %rdi, %rbx
movq 0x1b8(%rdi), %rax
movq 0x38(%rax), %rdx
testq %rdx, %rdx
je 0x3c694
leaq 0x3853d(%rip), %rsi # 0x74bb1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3c1d9
testl %eax, %eax
jne 0x3c6aa
movq 0x18(%rbx), %rax
movl $0xd, 0x530(%rax)
xorl %eax, %eax
jmp 0x3c6aa
leaq 0x384f0(%rip), %rsi # 0x... | /Unity-Technologies[P]curl/lib/imap.c |
imap_matchresp | static bool imap_matchresp(const char *line, size_t len, const char *cmd)
{
const char *end = line + len;
size_t cmd_len = strlen(cmd);
/* Skip the untagged response marker */
line += 2;
/* Do we have a number after the marker? */
if(line < end && ISDIGIT(*line)) {
/* Skip the number */
do
l... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq (%rdi,%rsi), %r12
movq %rdx, %rdi
callq 0xf4b0
leaq 0x2(%r14), %rdi
cmpq $0x3, %r15
jl 0x3c7d6
movb (%rdi), %cl
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0x3c7d6
leaq 0x3(%r14), %rsi
xorl %edi, %edi
movq %rdi, %rcx
movq... | /Unity-Technologies[P]curl/lib/imap.c |
imap_get_message | static CURLcode imap_get_message(struct Curl_easy *data, struct bufref *out)
{
char *message = Curl_dyn_ptr(&data->conn->proto.imapc.pp.recvbuf);
size_t len = data->conn->proto.imapc.pp.nfinal;
if(len > 2) {
/* Find the start of the message */
len -= 2;
for(message += 2; *message == ' ' || *message =... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4a0, %edi # imm = 0x4A0
addq 0x18(%r14), %rdi
callq 0x240d0
movq 0x18(%r14), %rcx
movq 0x4c8(%rcx), %rdi
cmpq $0x3, %rdi
jb 0x3c904
leaq 0x2(%rax), %rsi
xorl %ecx, %ecx
movzbl 0x2(%rax,%rcx), %edx
cmpl $0x9, %edx
je 0x3c8ef
cmpl $0x20, ... | /Unity-Technologies[P]curl/lib/imap.c |
Curl_llist_insert_next | void
Curl_llist_insert_next(struct Curl_llist *list,
struct Curl_llist_node *e, /* may be NULL */
const void *p,
struct Curl_llist_node *ne)
{
DEBUGASSERT(list);
DEBUGASSERT(list->_init == LLISTINIT);
DEBUGASSERT(ne);
#ifdef DEBUGBUILD
ne->_i... | movq %rdx, 0x8(%rcx)
movq %rdi, (%rcx)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x3ca51
leaq 0x18(%rsi), %rdx
movq %rdx, %r8
testq %rsi, %rsi
cmoveq %rdi, %r8
movq (%r8), %r8
movq %r8, 0x18(%rcx)
movq %rsi, 0x10(%rcx)
je 0x3ca61
movq (%rdx), %rsi
leaq 0x10(%rsi), %r8
leaq 0x8(%rdi), %r9
testq %rsi, %rsi
cmoveq %r9, %r... | /Unity-Technologies[P]curl/lib/llist.c |
Curl_md4it | CURLcode Curl_md4it(unsigned char *output, const unsigned char *input,
const size_t len)
{
MD4_CTX ctx;
#ifdef VOID_MD4_INIT
MD4_Init(&ctx);
#else
if(!MD4_Init(&ctx))
return CURLE_FAILED_INIT;
#endif
MD4_Update(&ctx, input, curlx_uztoui(len));
MD4_Final(output, &ctx);
return CURLE_... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movaps 0x3828b(%rip), %xmm0 # 0x74df0
movups %xmm0, 0x10(%rsp)
movq %rdx, %rdi
callq 0x6384a
movl %eax, %r13d
movl %eax, %r14d
andl $0x1fffffff, %r14d # imm = 0x1FFFFFFF
movl %r14d, 0x8(%rsp)
movl %eax, %ecx
... | /Unity-Technologies[P]curl/lib/md4.c |
Curl_md5it | CURLcode Curl_md5it(unsigned char *outbuffer, const unsigned char *input,
const size_t len)
{
CURLcode result;
my_md5_ctx ctx;
result = my_md5_init(&ctx);
if(!result) {
my_md5_update(&ctx, input, curlx_uztoui(len));
my_md5_final(outbuffer, &ctx);
}
return result;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(%rsp), %rdi
callq 0xf850
testl %eax, %eax
je 0x3d3a1
movq %r15, %rdi
callq 0x6384a
movl %eax, %edx
leaq 0x4(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x10610
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfeb0
xo... | /Unity-Technologies[P]curl/lib/md5.c |
Curl_mime_cleanpart | void Curl_mime_cleanpart(curl_mimepart *part)
{
if(part) {
cleanup_part_content(part);
curl_slist_free_all(part->curlheaders);
if(part->flags & MIME_USERHEADERS_OWNER)
curl_slist_free_all(part->userheaders);
Curl_safefree(part->mimetype);
Curl_safefree(part->name);
Curl_safefree(part->fi... | testq %rdi, %rdi
je 0x3d4ce
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3d4cf
movq 0x48(%rbx), %rdi
callq 0xfe40
testb $0x1, 0x14(%rbx)
je 0x3d47e
movq 0x50(%rbx), %rdi
callq 0xfe40
leaq 0x57be3(%rip), %r14 # 0x95068
movq 0x58(%rbx), %rdi
callq *(%r14)
xorl %r15d, %r15d
movq %r15, 0x58(%rbx)
movq 0x68(... | /Unity-Technologies[P]curl/lib/mime.c |
curl_mime_free | void curl_mime_free(curl_mime *mime)
{
curl_mimepart *part;
if(mime) {
mime_subparts_unbind(mime); /* Be sure it is not referenced anymore. */
while(mime->firstpart) {
part = mime->firstpart;
mime->firstpart = part->nextpart;
Curl_mime_cleanpart(part);
free(part);
}
free(mi... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3d5af
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x3d56f
xorl %r14d, %r14d
movq %r14, 0x30(%rdi)
callq 0x3d4cf
movq %r14, (%rbx)
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x3d59e
leaq 0x57ae9(%rip), %r15 # 0x95068
movq 0x8(%r14), %rax
movq %rax, 0x8(%... | /Unity-Technologies[P]curl/lib/mime.c |
curl_mime_data | CURLcode curl_mime_data(curl_mimepart *part,
const char *ptr, size_t datasize)
{
if(!part)
return CURLE_BAD_FUNCTION_ARGUMENT;
cleanup_part_content(part);
if(ptr) {
if(datasize == CURL_ZERO_TERMINATED)
datasize = strlen(ptr);
part->data = Curl_memdup0(ptr, datasize);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3d8d8
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x3d4cf
xorl %ebx, %ebx
testq %r12, %r12
je 0x3d8e4
cmpq $-0x1, %r15
jne 0x3d890
movq %r12, %rdi
callq 0xf4b0
movq %rax, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x57a48
movq %rax, ... | /Unity-Technologies[P]curl/lib/mime.c |
curl_mime_data_cb | CURLcode curl_mime_data_cb(curl_mimepart *part, curl_off_t datasize,
curl_read_callback readfunc,
curl_seek_callback seekfunc,
curl_free_callback freefunc, void *arg)
{
if(!part)
return CURLE_BAD_FUNCTION_ARGUMENT;
cleanup_part_co... | testq %rdi, %rdi
je 0x3da81
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %r15
callq 0x3d4cf
xorl %eax, %eax
testq %rbp, %rbp
je 0x3da72
movq %rbp, 0x20(%r15)
movq %r13, 0x28(%r15)
movq %r14, 0x30(%r1... | /Unity-Technologies[P]curl/lib/mime.c |
curl_mime_addpart | curl_mimepart *curl_mime_addpart(curl_mime *mime)
{
curl_mimepart *part;
if(!mime)
return NULL;
part = (curl_mimepart *) malloc(sizeof(*part));
if(part) {
Curl_mime_initpart(part);
part->parent = mime;
if(mime->lastpart)
mime->lastpart->nextpart = part;
else
mime->firstpart =... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3db78
movq %rdi, %r14
leaq 0x57537(%rip), %rax # 0x95060
movl $0x1b8, %edi # imm = 0x1B8
callq *(%rax)
testq %rax, %rax
je 0x3db78
movq %rax, %rbx
movq %rax, %rdi
addq $0x8, %rdi
movl $0x1a8, %edx # imm = 0x1A8
xorl %esi, %esi
callq 0xf620... | /Unity-Technologies[P]curl/lib/mime.c |
curl_mime_type | CURLcode curl_mime_type(curl_mimepart *part, const char *mimetype)
{
if(!part)
return CURLE_BAD_FUNCTION_ARGUMENT;
Curl_safefree(part->mimetype);
if(mimetype) {
part->mimetype = strdup(mimetype);
if(!part->mimetype)
return CURLE_OUT_OF_MEMORY;
}
return CURLE_OK;
} | testq %rdi, %rdi
je 0x3dc1f
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x57475(%rip), %rax # 0x95068
movq 0x58(%rdi), %rdi
callq *(%rax)
movq $0x0, 0x58(%rbx)
testq %r14, %r14
je 0x3dc1b
leaq 0x5746b(%rip), %rax # 0x95078
movq %r14, %rdi
callq *(%rax)
movq %rax, 0x58(%rbx)
testq %rax,... | /Unity-Technologies[P]curl/lib/mime.c |
curl_mime_filename | CURLcode curl_mime_filename(curl_mimepart *part, const char *filename)
{
if(!part)
return CURLE_BAD_FUNCTION_ARGUMENT;
Curl_safefree(part->filename);
if(filename) {
part->filename = strdup(filename);
if(!part->filename)
return CURLE_OUT_OF_MEMORY;
}
return CURLE_OK;
} | testq %rdi, %rdi
je 0x3dcc9
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x573cb(%rip), %rax # 0x95068
movq 0x60(%rdi), %rdi
callq *(%rax)
movq $0x0, 0x60(%rbx)
testq %r14, %r14
je 0x3dcc5
leaq 0x573c1(%rip), %rax # 0x95078
movq %r14, %rdi
callq *(%rax)
movq %rax, 0x60(%rbx)
testq %rax,... | /Unity-Technologies[P]curl/lib/mime.c |
mime_mem_seek | static int mime_mem_seek(void *instream, curl_off_t offset, int whence)
{
curl_mimepart *part = (curl_mimepart *) instream;
switch(whence) {
case SEEK_CUR:
offset += part->state.offset;
break;
case SEEK_END:
offset += part->datasize;
break;
}
if(offset < 0 || offset > part->datasize)
r... | cmpl $0x1, %edx
je 0x3dd5c
cmpl $0x2, %edx
jne 0x3dd65
movl $0x70, %eax
jmp 0x3dd61
movl $0x88, %eax
addq (%rdi,%rax), %rsi
movl $0x1, %eax
testq %rsi, %rsi
js 0x3dd7e
cmpq 0x70(%rdi), %rsi
jg 0x3dd7e
movq %rsi, 0x88(%rdi)
xorl %eax, %eax
retq
| /Unity-Technologies[P]curl/lib/mime.c |
mime_file_read | static size_t mime_file_read(char *buffer, size_t size, size_t nitems,
void *instream)
{
curl_mimepart *part = (curl_mimepart *) instream;
if(!nitems)
return STOP_FILLING;
if(mime_open_file(part))
return READ_ERROR;
return fread(buffer, size, nitems, part->fp);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x3de5f
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x40(%rcx), %rcx
testq %rcx, %rcx
jne 0x3de46
movq 0x18(%r12), %rdi
leaq 0x32892(%rip), %rsi # 0x706c6
callq 0xfd40
movq %rax, %rcx
movq %rax, 0x40(%r12)
testq %rax... | /Unity-Technologies[P]curl/lib/mime.c |
curl_mime_encoder | CURLcode curl_mime_encoder(curl_mimepart *part, const char *encoding)
{
CURLcode result = CURLE_BAD_FUNCTION_ARGUMENT;
const struct mime_encoder *mep;
if(!part)
return result;
part->encoder = NULL;
if(!encoding)
return CURLE_OK; /* Removing current encoder. */
for(mep = encoders; mep->name; m... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3df05
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, 0x90(%rdi)
testq %rsi, %rsi
je 0x3df0c
movl $0x2b, %ebp
leaq 0x54906(%rip), %r15 # 0x927e0
leaq 0x371d6(%rip), %rsi # 0x750b7
movq %rbx, %rdi
callq 0x10580
testl %eax, %eax
je 0x3def6
mo... | /Unity-Technologies[P]curl/lib/mime.c |
mime_subparts_seek | static int mime_subparts_seek(void *instream, curl_off_t offset, int whence)
{
curl_mime *mime = (curl_mime *) instream;
curl_mimepart *part;
int result = CURL_SEEKFUNC_OK;
if(whence != SEEK_SET || offset)
return CURL_SEEKFUNC_CANTSEEK; /* Only support full rewind. */
if(mime->state.state == MIMESTAT... | pushq %rbp
pushq %r14
pushq %rbx
testl %edx, %edx
setne %al
testq %rsi, %rsi
setne %cl
orb %al, %cl
movl $0x2, %ebp
jne 0x3e018
movq %rdi, %rbx
xorl %ebp, %ebp
cmpl $0x0, 0x48(%rdi)
je 0x3e018
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x3e008
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x3f1d6
testl %eax, %eax
cmovnel %eax, %... | /Unity-Technologies[P]curl/lib/mime.c |
readback_part | static size_t readback_part(curl_mimepart *part,
char *buffer, size_t bufsize, bool *hasread)
{
size_t cursize = 0;
/* Readback from part. */
while(bufsize) {
size_t sz = 0;
struct curl_slist *hdr = (struct curl_slist *) part->state.ptr;
switch(part->state.state) {
ca... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x20(%rsp)
testq %rdx, %rdx
je 0x3e43c
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
leaq 0x80(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0xb0(%rdi), %rax
movq %rax, 0x28(%rsp)
leaq 0x98(%rdi), %rax
movq %rax, 0x30(%rsp)
xorl %eb... | /Unity-Technologies[P]curl/lib/mime.c |
Curl_mime_contenttype | const char *Curl_mime_contenttype(const char *filename)
{
/*
* If no content type was specified, we scan through a few well-known
* extensions and pick the first we match!
*/
struct ContentType {
const char *extension;
const char *type;
};
static const struct ContentType ctts[] = {
{".gif",... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3e581
movq %rdi, %rbx
callq 0xf4b0
movq %rax, %r15
addq %rax, %rbx
movl $0x8, %r13d
leaq 0x54325(%rip), %rbp # 0x92870
xorl %r14d, %r14d
movq -0x8(%r13,%rbp), %r12
movq %r12, %rdi
callq 0xf4b0
cmpq %rax, %r15
jb 0x3e5... | /Unity-Technologies[P]curl/lib/mime.c |
escape_string | static char *escape_string(struct Curl_easy *data,
const char *src, enum mimestrategy strategy)
{
CURLcode result;
struct dynbuf db;
const char * const *table;
const char * const *p;
/* replace first character by rest of string. */
static const char * const mimetable[] = {
"\\... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testl %edx, %edx
je 0x3ea73
leaq 0x53f2b(%rip), %r15 # 0x92990
testq %rdi, %rdi
je 0x3ea7a
testb $0x1, 0xa9a(%rdi)
je 0x3ea7a
leaq 0x53ef6(%rip), %r15 # 0x92970
leaq 0x8(%rsp), %r14
movl $0x7a1200, %esi # imm = 0x7A1200
movq %r... | /Unity-Technologies[P]curl/lib/mime.c |
Curl_pgrsStartNow | void Curl_pgrsStartNow(struct Curl_easy *data)
{
data->progress.speeder_c = 0; /* reset the progress meter display */
data->progress.start = Curl_now();
data->progress.is_t_startransfer_set = false;
data->progress.ul.limit.start = data->progress.start;
data->progress.dl.limit.start = data->progress.start;
d... | pushq %rbx
movq %rdi, %rbx
movl $0x0, 0xc50(%rdi)
callq 0x5b170
movq %rax, 0xb80(%rbx)
movl %edx, 0xb88(%rbx)
andb $-0x3, 0xc54(%rbx)
movups 0xb80(%rbx), %xmm0
movups %xmm0, 0xae0(%rbx)
movups %xmm0, 0xb10(%rbx)
xorl %ecx, %ecx
movq %rcx, 0xaf0(%rbx)
movq %rcx, 0xb20(%rbx)
movq %rcx, 0xb00(%rbx)
movq %rcx, 0xad0(%rbx)
... | /Unity-Technologies[P]curl/lib/progress.c |
Curl_ratelimit | void Curl_ratelimit(struct Curl_easy *data, struct curltime now)
{
/* do not set a new stamp unless the time since last update is long enough */
if(data->set.max_recv_speed) {
if(Curl_timediff(now, data->progress.dl.limit.start) >=
MIN_RATE_LIMIT_PERIOD) {
data->progress.dl.limit.start = now;
... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x348(%rdi)
je 0x495ef
movq 0xb10(%rbx), %rdx
movl 0xb18(%rbx), %ecx
movq %r14, %rdi
movl %ebp, %esi
callq 0x5b1d8
cmpq $0xbb8, %rax # imm = 0xBB8
jl 0x495ef
movq %r14, 0xb10(%rbx)
movl %ebp, 0xb18(%rbx)
movq 0xb00(%r... | /Unity-Technologies[P]curl/lib/progress.c |
Curl_pgrsLimitWaitTime | timediff_t Curl_pgrsLimitWaitTime(struct pgrs_dir *d,
curl_off_t speed_limit,
struct curltime now)
{
curl_off_t size = d->cur_size - d->limit.start_size;
timediff_t minimum;
timediff_t actual;
if(!speed_limit || !size)
return 0;
/*
*... | movq 0x8(%rdi), %rax
testq %rsi, %rsi
setne %r9b
subq 0x28(%rdi), %rax
movq %rdx, %r8
setne %dl
andb %r9b, %dl
cmpb $0x1, %dl
jne 0x49676
pushq %rbx
movabsq $0x20c49ba5e353f7, %r9 # imm = 0x20C49BA5E353F7
cmpq %r9, %rax
jge 0x49679
imulq $0x3e8, %rax, %rax # imm = 0x3E8
cqto
idivq %rsi
movq %rax, %rbx
jmp 0x49696... | /Unity-Technologies[P]curl/lib/progress.c |
progress_calc | static bool progress_calc(struct Curl_easy *data, struct curltime now)
{
bool timetoshow = FALSE;
struct Progress * const p = &data->progress;
/* The time spent so far (from the start) in microseconds */
p->timespent = Curl_timediff_us(now, p->start);
p->dl.speed = trspeed(p->dl.cur_size, p->timespent);
p-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0xb80(%rdi), %rdx
movl 0xb88(%rdi), %ecx
movq %rsi, %rdi
movl %ebp, %esi
callq 0x5b288
movq %rax, 0xb38(%r14)
movq 0xb00(%r14), %rsi
testq %rax, %rax
jle 0x49730
movq %rax, %r9
movabsq $0x7f... | /Unity-Technologies[P]curl/lib/progress.c |
Curl_rename | int Curl_rename(const char *oldpath, const char *newpath)
{
#ifdef _WIN32
/* rename() on Windows does not overwrite, so we cannot use it here.
MoveFileEx() will overwrite and is usually atomic, however it fails
when there are open handles to the file. */
const int max_wait_ms = 1000;
struct curltime sta... | pushq %rax
callq 0xf6e0
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movl %ecx, %eax
popq %rcx
retq
nopl (%rax)
| /Unity-Technologies[P]curl/lib/rename.c |
Curl_req_soft_reset | CURLcode Curl_req_soft_reset(struct SingleRequest *req,
struct Curl_easy *data)
{
CURLcode result;
req->done = FALSE;
req->upload_done = FALSE;
req->upload_aborted = FALSE;
req->download_done = FALSE;
req->eos_written = FALSE;
req->eos_read = FALSE;
req->eos_sent = FALSE;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0xffeff884, %eax # imm = 0xFFEFF884
andl 0xd9(%rdi), %eax
incl %eax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl %eax, 0xd9(%rdi)
movups %xmm0, 0x30(%rdi)
movq %rsi, %rdi
callq 0x4c15f
movl %eax, %ebx
testl %eax, %eax... | /Unity-Technologies[P]curl/lib/request.c |
req_flush | static CURLcode req_flush(struct Curl_easy *data)
{
CURLcode result;
if(!data || !data->conn)
return CURLE_FAILED_INIT;
if(!Curl_bufq_is_empty(&data->req.sendbuf)) {
result = req_send_buffer_flush(data);
if(result)
return result;
if(!Curl_bufq_is_empty(&data->req.sendbuf)) {
DEBUGF(i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x2, %eax
testq %rdi, %rdi
je 0x4a03f
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x4a03f
leaq 0x158(%rbx), %r14
movq %r14, %rdi
callq 0x12403
testb %al, %al
je 0x49f22
movq %rbx, %rdi
callq 0x5c6e1
testb %al, %al
je 0x49fc0
movq %rbx... | /Unity-Technologies[P]curl/lib/request.c |
Curl_req_hard_reset | void Curl_req_hard_reset(struct SingleRequest *req, struct Curl_easy *data)
{
struct curltime t0 = {0, 0};
/* This is a bit ugly. `req->p` is a union and we assume we can
* free this safely without leaks. */
Curl_safefree(req->p.ftp);
Curl_safefree(req->newurl);
Curl_client_reset(data);
if(req->sendbuf_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4b005(%rip), %r15 # 0x95068
movq 0xc8(%rdi), %rdi
callq *(%r15)
xorl %r12d, %r12d
movq %r12, 0xc8(%rbx)
movq 0xc0(%rbx), %rdi
callq *(%r15)
movq %r12, 0xc0(%rbx)
movq %r14, %rdi
callq 0x4c046
testb $0x8, 0xdb(%rbx)
je 0x4a... | /Unity-Technologies[P]curl/lib/request.c |
rtsp_setup_connection | static CURLcode rtsp_setup_connection(struct Curl_easy *data,
struct connectdata *conn)
{
struct RTSP *rtsp;
(void)conn;
data->req.p.rtsp = rtsp = calloc(1, sizeof(struct RTSP));
if(!rtsp)
return CURLE_OUT_OF_MEMORY;
Curl_dyn_init(&conn->proto.rtspc.buf, MAX_RTP_BUF... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4aa27(%rip), %rax # 0x95080
movl $0x1, %edi
movl $0x10, %esi
callq *(%rax)
movq %rax, 0x1b8(%r14)
testq %rax, %rax
je 0x4a689
addq $0x440, %rbx # imm = 0x440
movl $0xf4240, %esi # imm = 0xF4240
movq %rbx, %rdi
callq 0x23e58
... | /Unity-Technologies[P]curl/lib/rtsp.c |
rtsp_do | static CURLcode rtsp_do(struct Curl_easy *data, bool *done)
{
struct connectdata *conn = data->conn;
CURLcode result = CURLE_OK;
Curl_RtspReq rtspreq = data->set.rtspreq;
struct RTSP *rtsp = data->req.p.rtsp;
struct dynbuf req_buffer;
const char *p_request = NULL;
const char *p_session_id = NULL;
const... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %r13
movq 0x1b8(%rdi), %r15
movl 0x9f8(%rdi), %r14d
movb $0x1, (%rsi)
leaq 0x40(%rsp), %rdi
movl $0x10000, %esi # imm = 0x10000
callq 0x23e58
movq 0x11a0(%rbx), %rax
movq %rax, (%r15)
movq $0x0, ... | /Unity-Technologies[P]curl/lib/rtsp.c |
rtsp_connect | static CURLcode rtsp_connect(struct Curl_easy *data, bool *done)
{
CURLcode httpStatus;
httpStatus = Curl_http_connect(data, done);
/* Initialize the CSeq if not already done */
if(data->state.rtsp_next_client_CSeq == 0)
data->state.rtsp_next_client_CSeq = 1;
if(data->state.rtsp_next_server_CSeq == 0)
... | pushq %rbx
movq %rdi, %rbx
callq 0x32016
cmpq $0x0, 0x11a0(%rbx)
jne 0x4b04f
movq $0x1, 0x11a0(%rbx)
cmpq $0x0, 0x11a8(%rbx)
jne 0x4b064
movq $0x1, 0x11a8(%rbx)
movq 0x18(%rbx), %rcx
movl $0xffffffff, 0x460(%rcx) # imm = 0xFFFFFFFF
popq %rbx
retq
| /Unity-Technologies[P]curl/lib/rtsp.c |
rtsp_rtp_write_resp | static CURLcode rtsp_rtp_write_resp(struct Curl_easy *data,
const char *buf,
size_t blen,
bool is_eos)
{
struct rtsp_conn *rtspc = &(data->conn->proto.rtspc);
CURLcode result = CURLE_OK;
size_t consumed = 0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rdi), %r13
movq $0x0, (%rsp)
testb $0x1, 0x1c9(%rdi)
jne 0x4b0c7
andb $-0x2, 0x474(%r13)
xorl %ebp, %ebp
testq %r14, %r14
je 0x4b1c2
testb $0x1, 0x474(%r13)
jne 0x4b0f... | /Unity-Technologies[P]curl/lib/rtsp.c |
Curl_rtsp_parseheader | CURLcode Curl_rtsp_parseheader(struct Curl_easy *data, const char *header)
{
if(checkprefix("CSeq:", header)) {
long CSeq = 0;
char *endp;
const char *p = &header[5];
while(ISBLANK(*p))
p++;
CSeq = strtol(p, &endp, 10);
if(p != endp) {
struct RTSP *rtsp = data->req.p.rtsp;
rt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2b120(%rip), %rsi # 0x76341
movl $0x5, %edx
movq %r14, %rdi
callq 0xf530
testl %eax, %eax
je 0x4b27b
leaq 0x5(%r14), %r15
movzbl (%r15), %eax
cmpl $0x20, %eax
je 0x4b244
cmpl $0x9, %eax
jne 0x4b249
in... | /Unity-Technologies[P]curl/lib/rtsp.c |
rtp_write_body_junk | static CURLcode rtp_write_body_junk(struct Curl_easy *data,
const char *buf,
size_t blen)
{
struct rtsp_conn *rtspc = &(data->conn->proto.rtspc);
curl_off_t body_remain;
bool in_body;
in_body = (data->req.headerline && !rtspc->in_header) &... | cmpl $0x0, 0x12c(%rdi)
je 0x4ba1e
movq 0x18(%rdi), %rax
testb $0x1, 0x474(%rax)
jne 0x4ba1e
movq 0xf0(%rdi), %rax
testq %rax, %rax
js 0x4ba1e
subq 0x100(%rdi), %rax
jle 0x4ba1e
movq %rdx, %rcx
movq %rsi, %rdx
cmpq %rcx, %rax
cmovlq %rax, %rcx
movl $0x1, %esi
jmp 0x4be1c
xorl %eax, %eax
retq
nopl (%rax)
| /Unity-Technologies[P]curl/lib/rtsp.c |
Curl_cwriter_count | size_t Curl_cwriter_count(struct Curl_easy *data, Curl_cwriter_phase phase)
{
struct Curl_cwriter *w;
size_t n = 0;
for(w = data->req.writer_stack; w; w = w->next) {
if(w->phase == phase)
++n;
}
return n;
} | movq 0x148(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x4c335
xorl %edx, %edx
cmpl %esi, 0x18(%rcx)
sete %dl
addq %rdx, %rax
movq 0x8(%rcx), %rcx
jmp 0x4c31f
retq
| /Unity-Technologies[P]curl/lib/sendf.c |
Curl_cwriter_remove_by_name | void Curl_cwriter_remove_by_name(struct Curl_easy *data,
const char *name)
{
struct Curl_cwriter **anchor = &data->req.writer_stack;
while(*anchor) {
if(!strcmp(name, (*anchor)->cwt->name)) {
struct Curl_cwriter *w = (*anchor);
*anchor = w->next;
Curl_cwriter_... | movq 0x148(%rdi), %rcx
testq %rcx, %rcx
je 0x4c465
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x148(%rdi), %r13
leaq 0x48c53(%rip), %r12 # 0x95068
movq %rcx, %r15
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x10010
movq 0x8(%r15), %rcx
testl %eax, %eax
... | /Unity-Technologies[P]curl/lib/sendf.c |
Curl_creader_add | CURLcode Curl_creader_add(struct Curl_easy *data,
struct Curl_creader *reader)
{
CURLcode result;
struct Curl_creader **anchor = &data->req.reader_stack;
if(!*anchor) {
result = Curl_creader_set_fread(data, data->state.infilesize);
if(result)
return result;
}
/* Inser... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x150(%rdi), %r14
movq 0x150(%rdi), %rax
testq %rax, %rax
je 0x4c733
movl 0x18(%rbx), %ecx
cmpl %ecx, 0x18(%rax)
jae 0x4c755
movq %rax, %r14
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x4c74f
cmpl %ecx, 0x18(%rax)
jb 0x4c720
jmp 0x4c751
movq 0x11d8(%rdi), %rsi
callq 0... | /Unity-Technologies[P]curl/lib/sendf.c |
Curl_creader_needs_rewind | bool Curl_creader_needs_rewind(struct Curl_easy *data)
{
struct Curl_creader *reader = data->req.reader_stack;
while(reader) {
if(reader->crt->needs_rewind(data, reader)) {
CURL_TRC_READ(data, "client reader needs rewind before next request");
return TRUE;
}
reader = reader->next;
}
retu... | pushq %r14
pushq %rbx
pushq %rax
movq 0x150(%rdi), %rbx
testq %rbx, %rbx
je 0x4c8fa
movq %rdi, %r14
movq (%rbx), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
testb %al, %al
jne 0x4c906
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x4c8e1
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
mo... | /Unity-Technologies[P]curl/lib/sendf.c |
Curl_creader_is_paused | bool Curl_creader_is_paused(struct Curl_easy *data)
{
struct Curl_creader *reader = data->req.reader_stack;
while(reader) {
if(reader->crt->is_paused(data, reader))
return TRUE;
reader = reader->next;
}
return FALSE;
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x150(%rdi), %r14
testq %r14, %r14
je 0x4cb96
movq %rdi, %rbx
movq (%r14), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x48(%rax)
testb %al, %al
jne 0x4cb98
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x4cb7b
jmp 0x4cb98
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Unity-Technologies[P]curl/lib/sendf.c |
cw_download_write | static CURLcode cw_download_write(struct Curl_easy *data,
struct Curl_cwriter *writer, int type,
const char *buf, size_t nbytes)
{
struct cw_download_ctx *ctx = writer->ctx;
CURLcode result;
size_t nwrite, excess_len = 0;
bool is_connect = !!(t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r9
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testb $0x10, %bpl
jne 0x4cc39
movq 0x10(%r14), %r12
testb $0x1, 0x20(%r12)
jne 0x4cc31
movq %rbx, %rdi
movl $0x8, %esi
movq %r9, %r13
callq 0x494fa
movq %r13, %r9
or... | /Unity-Technologies[P]curl/lib/sendf.c |
cr_in_rewind | static CURLcode cr_in_rewind(struct Curl_easy *data,
struct Curl_creader *reader)
{
struct cr_in_ctx *ctx = reader->ctx;
/* If we never invoked the callback, there is noting to rewind */
if(!ctx->has_used_cb)
return CURLE_OK;
if(data->set.seek_func) {
int err;
Curl_se... | pushq %rbp
pushq %r14
pushq %rbx
movq 0x10(%rsi), %rax
xorl %r14d, %r14d
testb $0x4, 0x44(%rax)
je 0x4d574
movq %rdi, %rbx
cmpq $0x0, 0x228(%rdi)
je 0x4d4dd
movq %rbx, %rdi
movl $0x1, %esi
callq 0x45b0f
movq 0x2c0(%rbx), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
xorl %edx, %edx
callq *0x228(%rbx)
movl %eax, %ebp
movq %rbx... | /Unity-Technologies[P]curl/lib/sendf.c |
cr_buf_read | static CURLcode cr_buf_read(struct Curl_easy *data,
struct Curl_creader *reader,
char *buf, size_t blen,
size_t *pnread, bool *peos)
{
struct cr_buf_ctx *ctx = reader->ctx;
size_t nread = ctx->blen - ctx->index;
(void)data;
if(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %r15
movq %rcx, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rbp
movq 0x28(%rbp), %r13
movq 0x30(%rbp), %rax
subq %rax, %r13
je 0x4d9a2
movq 0x20(%rbp), %rsi
testq %rsi, %rsi
je 0x4d9a2
cmpq %rbx, %r13
cmovaeq %rbx, %r13
add... | /Unity-Technologies[P]curl/lib/sendf.c |
cr_buf_resume_from | static CURLcode cr_buf_resume_from(struct Curl_easy *data,
struct Curl_creader *reader,
curl_off_t offset)
{
struct cr_buf_ctx *ctx = reader->ctx;
size_t boffset;
(void)data;
DEBUGASSERT(data->conn);
/* already started reading? */
if(ctx... | movq 0x10(%rsi), %rcx
movl $0x1a, %eax
cmpq $0x0, 0x30(%rcx)
je 0x4da30
retq
testq %rdx, %rdx
jle 0x4da46
movq 0x28(%rcx), %rsi
subq %rdx, %rsi
jb 0x4da2f
addq %rdx, 0x20(%rcx)
movq %rsi, 0x28(%rcx)
xorl %eax, %eax
retq
nopl (%rax)
| /Unity-Technologies[P]curl/lib/sendf.c |
Curl_setstropt | CURLcode Curl_setstropt(char **charp, const char *s)
{
/* Release the previous storage at `charp' and replace by a dynamic storage
copy of `s'. Return CURLE_OK or CURLE_OUT_OF_MEMORY. */
Curl_safefree(*charp);
if(s) {
if(strlen(s) > CURL_MAX_INPUT_LENGTH)
return CURLE_BAD_FUNCTION_ARGUMENT;
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4760b(%rip), %rax # 0x95068
movq (%rdi), %rdi
callq *(%rax)
movq $0x0, (%rbx)
testq %r14, %r14
je 0x4da9b
movq %r14, %rdi
callq 0xf4b0
movq %rax, %rcx
movl $0x2b, %eax
cmpq $0x7a1200, %rcx # imm = 0x7A1200
ja 0x4da9d
leaq 0x475ea(%rip),... | /Unity-Technologies[P]curl/lib/setopt.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.