name string | code string | asm string | file string |
|---|---|---|---|
base64_encode | static CURLcode base64_encode(const char *table64,
const char *inputbuff, size_t insize,
char **outptr, size_t *outlen)
{
char *output;
char *base64data;
const unsigned char *in = (const unsigned char *)inputbuff;
const char *padstr = &table64[64]; ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%... | /AraHaan[P]curl/lib/base64.c |
bufq_init | static void bufq_init(struct bufq *q, struct bufc_pool *pool,
size_t chunk_size, size_t max_chunks, int opts)
{
DEBUGASSERT(chunk_size > 0);
DEBUGASSERT(max_chunks > 0);
memset(q, 0, sizeof(*q));
q->chunk_size = chunk_size;
q->max_chunks = max_chunks;
q->pool = pool;
q->opts = opts;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
jmp 0x1483e
jmp 0x14840
jmp 0x14842
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x106f0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0... | /AraHaan[P]curl/lib/bufq.c |
get_non_full_tail | static struct buf_chunk *get_non_full_tail(struct bufq *q)
{
struct buf_chunk *chunk;
if(q->tail && !chunk_is_full(q->tail))
return q->tail;
chunk = get_spare(q);
if(chunk) {
/* new tail, and possibly new head */
if(q->tail) {
q->tail->next = chunk;
q->tail = chunk;
}
else {
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x14c66
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x14b00
testb $0x1, %al
jne 0x14c66
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x14cc3
movq -0x10(%rbp), %rdi
callq 0x15a... | /AraHaan[P]curl/lib/bufq.c |
chunk_append | static size_t chunk_append(struct buf_chunk *chunk,
const unsigned char *buf, size_t len)
{
unsigned char *p = &chunk->x.data[chunk->w_offset];
size_t n = chunk->dlen - chunk->w_offset;
DEBUGASSERT(chunk->dlen >= chunk->w_offset);
if(n) {
n = CURLMIN(n, len);
memcpy(p, buf, n)... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq -0x8(%rbp), %rcx
addq 0x18(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
subq 0x18(%rcx), %rax
movq %rax, -0x2... | /AraHaan[P]curl/lib/bufq.c |
chunk_unwrite | static size_t chunk_unwrite(struct buf_chunk *chunk, size_t len)
{
size_t n = chunk->w_offset - chunk->r_offset;
DEBUGASSERT(chunk->w_offset >= chunk->r_offset);
if(!n) {
return 0;
}
else if(n <= len) {
chunk->r_offset = chunk->w_offset = 0;
return n;
}
else {
chunk->w_offset -= len;
r... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x10(%rcx), %rax
movq %rax, -0x20(%rbp)
jmp 0x14e72
cmpq $0x0, -0x20(%rbp)
jne 0x14e83
movq $0x0, -0x8(%rbp)
jmp 0x14eca
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x14... | /AraHaan[P]curl/lib/bufq.c |
chunk_read | static size_t chunk_read(struct buf_chunk *chunk,
unsigned char *buf, size_t len)
{
unsigned char *p = &chunk->x.data[chunk->r_offset];
size_t n = chunk->w_offset - chunk->r_offset;
DEBUGASSERT(chunk->w_offset >= chunk->r_offset);
if(!n) {
return 0;
}
else if(n <= len) {
mem... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq -0x10(%rbp), %rcx
addq 0x10(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x10(%rcx), %rax
movq %rax... | /AraHaan[P]curl/lib/bufq.c |
Curl_bufq_peek | bool Curl_bufq_peek(struct bufq *q,
const unsigned char **pbuf, size_t *plen)
{
if(q->head && chunk_is_empty(q->head)) {
prune_head(q);
}
if(q->head && !chunk_is_empty(q->head)) {
chunk_peek(q->head, pbuf, plen);
return TRUE;
}
*pbuf = NULL;
*plen = 0;
return FALSE;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x15339
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x14a60
testb $0x1, %al
jne 0x15330
jmp 0x15339
movq -0x10(%rbp), %rdi
callq 0x15190
movq -0x10(%rbp), %rax
... | /AraHaan[P]curl/lib/bufq.c |
Curl_bufq_skip | void Curl_bufq_skip(struct bufq *q, size_t amount)
{
size_t n;
while(amount && q->head) {
n = chunk_skip(q->head, amount);
amount -= n;
prune_head(q);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x1551a
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x15523
jmp 0x15551
movq -0x8(%rbp), %rax
mov... | /AraHaan[P]curl/lib/bufq.c |
get_spare | static struct buf_chunk *get_spare(struct bufq *q)
{
struct buf_chunk *chunk = NULL;
if(q->spare) {
chunk = q->spare;
q->spare = chunk->next;
chunk_reset(chunk);
return chunk;
}
if(q->chunk_count >= q->max_chunks && (!(q->opts & BUFQ_OPT_SOFT_LIMIT)))
return NULL;
if(q->pool) {
if(b... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x15b00
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %r... | /AraHaan[P]curl/lib/bufq.c |
bufcp_put | static void bufcp_put(struct bufc_pool *pool,
struct buf_chunk *chunk)
{
if(pool->spare_count >= pool->spare_max) {
free(chunk);
}
else {
chunk_reset(chunk);
chunk->next = pool->spare;
pool->spare = chunk;
++pool->spare_count;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x15d74
leaq 0xd756f(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
jmp 0x15da6
movq -0x10(%rbp), %rdi
callq... | /AraHaan[P]curl/lib/bufq.c |
cf_h1_proxy_adjust_pollset | static void cf_h1_proxy_adjust_pollset(struct Curl_cfilter *cf,
struct Curl_easy *data,
struct easy_pollset *ps)
{
struct h1_tunnel_state *ts = cf->ctx;
if(!cf->connected) {
/* If we are not connected, but the filter "below" is
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movb 0x24(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1639e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp)... | /AraHaan[P]curl/lib/cf-h1-proxy.c |
tunnel_free | static void tunnel_free(struct Curl_cfilter *cf,
struct Curl_easy *data)
{
if(cf) {
struct h1_tunnel_state *ts = cf->ctx;
if(ts) {
h1_tunnel_go_state(cf, ts, H1_TUNNEL_FAILED, data);
Curl_dyn_free(&ts->rcvbuf);
Curl_dyn_free(&ts->request_data);
Curl_httpchunk_fr... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x16485
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x16483
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movl $0x5, %edx
callq 0x16490... | /AraHaan[P]curl/lib/cf-h1-proxy.c |
tunnel_reinit | static CURLcode tunnel_reinit(struct Curl_cfilter *cf,
struct Curl_easy *data,
struct h1_tunnel_state *ts)
{
(void)data;
(void)cf;
DEBUGASSERT(ts);
Curl_dyn_reset(&ts->rcvbuf);
Curl_dyn_reset(&ts->request_data);
ts->tunnel_state = H1_TUNNEL_INIT;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x168d6
movq -0x18(%rbp), %rdi
callq 0x351e0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x351e0
movq -0x18(%rbp), %rax
movl $0x0, 0xa8(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x98(%rax)
movq -0x18(%rbp... | /AraHaan[P]curl/lib/cf-h1-proxy.c |
recv_CONNECT_resp | static CURLcode recv_CONNECT_resp(struct Curl_cfilter *cf,
struct Curl_easy *data,
struct h1_tunnel_state *ts,
bool *done)
{
CURLcode result = CURLE_OK;
struct SingleRequest *k = &data->req;
char *linep;
size_t... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(... | /AraHaan[P]curl/lib/cf-h1-proxy.c |
cf_hc_connect | static CURLcode cf_hc_connect(struct Curl_cfilter *cf,
struct Curl_easy *data,
bool *done)
{
struct cf_hc_ctx *ctx = cf->ctx;
struct curltime now;
CURLcode result = CURLE_OK;
size_t i, failed_ballers;
if(cf->connected) {
*done = TRUE;
return... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x10(%rbp), %rax
movb 0x24(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x1865b
movq -0x20(%r... | /AraHaan[P]curl/lib/cf-https-connect.c |
cf_hc_query | static CURLcode cf_hc_query(struct Curl_cfilter *cf,
struct Curl_easy *data,
int query, int *pres1, void *pres2)
{
struct cf_hc_ctx *ctx = cf->ctx;
size_t i;
if(!cf->connected) {
switch(query) {
case CF_QUERY_TIMER_CONNECT: {
struct curltime *... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movb 0x24(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jn... | /AraHaan[P]curl/lib/cf-https-connect.c |
cf_get_max_baller_time | static struct curltime cf_get_max_baller_time(struct Curl_cfilter *cf,
struct Curl_easy *data,
int query)
{
struct cf_hc_ctx *ctx = cf->ctx;
struct curltime t, tmax;
size_t i;
memset(&tmax, 0, sizeof(tmax));
for(i = 0... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x106f0
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
... | /AraHaan[P]curl/lib/cf-https-connect.c |
Curl_cf_tcp_create | CURLcode Curl_cf_tcp_create(struct Curl_cfilter **pcf,
struct Curl_easy *data,
struct connectdata *conn,
const struct Curl_addrinfo *ai,
int transport)
{
struct cf_socket_ctx *ctx = NULL;
struct Curl_cfil... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
jmp 0x1befe
movl $0x1, %edi
movl $0x138, %esi # imm = 0x138
leaq 0xd13e1(%rip), %rax # 0xed2f0
callq ... | /AraHaan[P]curl/lib/cf-socket.c |
Curl_cf_unix_create | CURLcode Curl_cf_unix_create(struct Curl_cfilter **pcf,
struct Curl_easy *data,
struct connectdata *conn,
const struct Curl_addrinfo *ai,
int transport)
{
struct cf_socket_ctx *ctx = NULL;
struct Curl... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
jmp 0x1c39e
movl $0x1, %edi
movl $0x138, %esi # imm = 0x138
leaq 0xd0f41(%rip), %rax # 0xed2f0
callq ... | /AraHaan[P]curl/lib/cf-socket.c |
Curl_conn_tcp_listen_set | CURLcode Curl_conn_tcp_listen_set(struct Curl_easy *data,
struct connectdata *conn,
int sockindex, curl_socket_t *s)
{
CURLcode result;
struct Curl_cfilter *cf = NULL;
struct cf_socket_ctx *ctx = NULL;
/* replace any existing */
Curl_conn_cf... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1efa0
jmp 0x1ca99
movl $0x1, %edi
movl $0x138, %esi ... | /AraHaan[P]curl/lib/cf-socket.c |
set_local_ip | static CURLcode set_local_ip(struct Curl_cfilter *cf,
struct Curl_easy *data)
{
struct cf_socket_ctx *ctx = cf->ctx;
#ifdef HAVE_GETSOCKNAME
if((ctx->sock != CURL_SOCKET_BAD) &&
!(data->conn->handler->protocol & CURLPROTO_TFTP)) {
/* TFTP does not connect, so it cannot get the... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x98(%rax)
je 0x1ce12
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x3e8(%rax), %rax
movl 0x94(%... | /AraHaan[P]curl/lib/cf-socket.c |
Curl_conn_is_tcp_listen | bool Curl_conn_is_tcp_listen(struct Curl_easy *data,
int sockindex)
{
struct Curl_cfilter *cf = data->conn->cfilter[sockindex];
while(cf) {
if(cf->cft == &Curl_cft_tcp_accept)
return TRUE;
cf = cf->next;
}
return FALSE;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq 0x298(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1ce7e
movq -0x20(%rbp), %rax
leaq 0xd0113(%rip), %rcx # 0xecf78
cmpq %rcx, (%rax)
jne 0x1ce7... | /AraHaan[P]curl/lib/cf-socket.c |
do_connect | static int do_connect(struct Curl_cfilter *cf, struct Curl_easy *data,
bool is_tcp_fastopen)
{
struct cf_socket_ctx *ctx = cf->ctx;
#ifdef TCP_FASTOPEN_CONNECT
int optval = 1;
#endif
int rc = -1;
(void)data;
if(is_tcp_fastopen) {
#if defined(CONNECT_DATA_IDEMPOTENT) /* Darwin */
# if d... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
testb $0x1, -0x11(%rbp)
je 0x1d5a2
movq -... | /AraHaan[P]curl/lib/cf-socket.c |
verifyconnect | static bool verifyconnect(curl_socket_t sockfd, int *error)
{
bool rc = TRUE;
#ifdef SO_ERROR
int err = 0;
curl_socklen_t errSize = sizeof(err);
#ifdef _WIN32
/*
* In October 2003 we effectively nullified this function on Windows due to
* problems with it using all CPU in multi-threaded cases.
*
* ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x4, -0x1c(%rbp)
movl -0x4(%rbp), %edi
movl $0x1, %esi
movl $0x4, %edx
leaq -0x18(%rbp), %rcx
leaq -0x1c(%rbp), %r8
callq 0x10980
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
j... | /AraHaan[P]curl/lib/cf-socket.c |
tcpkeepalive | static void
tcpkeepalive(struct Curl_easy *data,
curl_socket_t sockfd)
{
int optval = data->set.tcp_keepalive ? 1 : 0;
/* only set IDLE and INTVL if setting KEEPALIVE is successful */
if(setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE,
(void *)&optval, sizeof(optval)) < 0) {
infof(da... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0xa2c(%rax), %rax
shrq $0x28, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl $0x1, %esi
movl $0x9,... | /AraHaan[P]curl/lib/cf-socket.c |
bindlocal | static CURLcode bindlocal(struct Curl_easy *data, struct connectdata *conn,
curl_socket_t sockfd, int af, unsigned int scope)
{
struct Curl_sockaddr_storage sa;
struct sockaddr *sock = (struct sockaddr *)&sa; /* bind to this address */
curl_socklen_t sizeof_sa = 0; /* size of the data s... | pushq %rbp
movq %rsp, %rbp
subq $0x5b0, %rsp # imm = 0x5B0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
leaq -0xa8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x0, -0xb4(%rbp)
leaq -0xa8(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0xa8(%rbp), %r... | /AraHaan[P]curl/lib/cf-socket.c |
cf_socket_active | static void cf_socket_active(struct Curl_cfilter *cf, struct Curl_easy *data)
{
struct cf_socket_ctx *ctx = cf->ctx;
/* use this socket from now on */
cf->conn->sock[cf->sockindex] = ctx->sock;
set_local_ip(cf, data);
if(cf->sockindex == FIRSTSOCKET) {
cf->conn->primary = ctx->ip;
cf->conn->remote_ad... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x98(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x20(%rcx), %rcx
movl %edx, 0x270(%rax,%rcx,4)... | /AraHaan[P]curl/lib/cf-socket.c |
cf_socket_update_data | static void cf_socket_update_data(struct Curl_cfilter *cf,
struct Curl_easy *data)
{
/* Update the IP info held in the transfer, if we have that. */
if(cf->connected && (cf->sockindex == FIRSTSOCKET)) {
struct cf_socket_ctx *ctx = cf->ctx;
data->info.primary = ctx->ip;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb 0x24(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x1e753
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x1e753
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -... | /AraHaan[P]curl/lib/cf-socket.c |
cf_tcp_accept_timeleft | static timediff_t cf_tcp_accept_timeleft(struct Curl_cfilter *cf,
struct Curl_easy *data)
{
struct cf_socket_ctx *ctx = cf->ctx;
timediff_t timeout_ms = DEFAULT_ACCEPT_TIMEOUT;
timediff_t other;
struct curltime now;
#ifndef CURL_DISABLE_FTP
if(data->set.accepttimeout... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0xea60, -0x20(%rbp) # imm = 0xEA60
movq -0x10(%rbp), %rax
cmpl $0x0, 0x6b0(%rax)
jbe 0x1e9af
movq -0x10(%rbp), %rax
movl 0x6b0(%rax), %eax
movq %rax, -0x20... | /AraHaan[P]curl/lib/cf-socket.c |
Curl_cf_def_get_host | void Curl_cf_def_get_host(struct Curl_cfilter *cf, struct Curl_easy *data,
const char **phost, const char **pdisplay_host,
int *pport)
{
if(cf->next)
cf->next->cft->get_host(cf->next, data, phost, pdisplay_host, pport);
else {
*phost = cf->conn->host.name;... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1ec22
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq... | /AraHaan[P]curl/lib/cfilters.c |
Curl_conn_close | void Curl_conn_close(struct Curl_easy *data, int index)
{
struct Curl_cfilter *cf;
DEBUGASSERT(data->conn);
/* it is valid to call that without filters being present */
cf = data->conn->cfilter[index];
if(cf) {
cf->cft->do_close(cf, data);
}
Curl_shutdown_clear(data, index);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
jmp 0x1eff1
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq 0x298(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1f025
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
mo... | /AraHaan[P]curl/lib/cfilters.c |
Curl_cf_recv | ssize_t Curl_cf_recv(struct Curl_easy *data, int num, char *buf,
size_t len, CURLcode *code)
{
struct Curl_cfilter *cf;
DEBUGASSERT(data);
DEBUGASSERT(data->conn);
*code = CURLE_OK;
cf = data->conn->cfilter[num];
while(cf && !cf->connected) {
cf = cf->next;
}
if(cf) {
ssize... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
jmp 0x1f43d
jmp 0x1f43f
jmp 0x1f441
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq 0x298(%rax... | /AraHaan[P]curl/lib/cfilters.c |
Curl_cf_create | CURLcode Curl_cf_create(struct Curl_cfilter **pcf,
const struct Curl_cftype *cft,
void *ctx)
{
struct Curl_cfilter *cf;
CURLcode result = CURLE_OUT_OF_MEMORY;
DEBUGASSERT(cft);
cf = calloc(1, sizeof(*cf));
if(!cf)
goto out;
cf->cft = cft;
cf->ctx = ctx... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1b, -0x24(%rbp)
jmp 0x1f62d
movl $0x1, %edi
movl $0x28, %esi
leaq 0xcdcb2(%rip), %rax # 0xed2f0
callq *(%rax)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1f64d
jmp 0x1f66b
movq -0x10(%rbp)... | /AraHaan[P]curl/lib/cfilters.c |
Curl_conn_cf_insert_after | void Curl_conn_cf_insert_after(struct Curl_cfilter *cf_at,
struct Curl_cfilter *cf_new)
{
struct Curl_cfilter *tail, **pnext;
DEBUGASSERT(cf_at);
DEBUGASSERT(cf_new);
DEBUGASSERT(!cf_new->conn);
tail = cf_at->next;
cf_at->next = cf_new;
do {
cf_new->conn = cf_at->conn;... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x1f76e
jmp 0x1f770
jmp 0x1f772
jmp 0x1f774
jmp 0x1f776
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%... | /AraHaan[P]curl/lib/cfilters.c |
Curl_conn_connect | CURLcode Curl_conn_connect(struct Curl_easy *data,
int sockindex,
bool blocking,
bool *done)
{
#define CF_CONN_NUM_POLLS_ON_STACK 5
struct pollfd a_few_on_stack[CF_CONN_NUM_POLLS_ON_STACK];
struct curl_pollfds cpfds;
struct Curl_cfil... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x74(%rbp)
jmp 0x1fa46
jmp 0x1fa48
jmp 0x1fa4a
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq 0x298(%rax,%rcx,8), %r... | /AraHaan[P]curl/lib/cfilters.c |
Curl_pollset_change | void Curl_pollset_change(struct Curl_easy *data,
struct easy_pollset *ps, curl_socket_t sock,
int add_flags, int remove_flags)
{
unsigned int i;
(void)data;
DEBUGASSERT(VALID_SOCK(sock));
if(!VALID_SOCK(sock))
return;
DEBUGASSERT(add_flags <= (CURL_POLL_IN|C... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
jmp 0x2016c
cmpl $0x0, -0x14(%rbp)
jge 0x20177
jmp 0x202d6
jmp 0x20179
jmp 0x2017b
jmp 0x2017d
jmp 0x2017f
jmp 0x20181
jmp 0x20183
movl $0x0, -0x20(%rbp)
movl -0x... | /AraHaan[P]curl/lib/cfilters.c |
Curl_conn_cf_is_ssl | bool Curl_conn_cf_is_ssl(struct Curl_cfilter *cf)
{
for(; cf; cf = cf->next) {
if(cf->cft->flags & CF_TYPE_SSL)
return TRUE;
if(cf->cft->flags & CF_TYPE_IP_CONNECT)
return FALSE;
}
return FALSE;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2045f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x20437
movb $0x1, -0x1(%rbp)
jmp 0x20463
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je ... | /AraHaan[P]curl/lib/cfilters.c |
Curl_conn_data_pending | bool Curl_conn_data_pending(struct Curl_easy *data, int sockindex)
{
struct Curl_cfilter *cf;
(void)data;
DEBUGASSERT(data);
DEBUGASSERT(data->conn);
cf = data->conn->cfilter[sockindex];
while(cf && !cf->connected) {
cf = cf->next;
}
if(cf) {
return cf->cft->has_data_pending(cf, data);
}
r... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
jmp 0x20641
jmp 0x20643
jmp 0x20645
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq 0x298(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x20680... | /AraHaan[P]curl/lib/cfilters.c |
cf_cntrl_all | static CURLcode cf_cntrl_all(struct connectdata *conn,
struct Curl_easy *data,
bool ignore_result,
int event, int arg1, void *arg2)
{
CURLcode result = CURLE_OK;
size_t i;
for(i = 0; i < CURL_ARRAYSIZE(conn->cfilter); ++i) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x2, -0x38(%rbp)
jae 0x20d05
movq -0x8(%rbp), %rax
movq -0x3... | /AraHaan[P]curl/lib/cfilters.c |
Curl_conn_get_max_concurrent | size_t Curl_conn_get_max_concurrent(struct Curl_easy *data,
struct connectdata *conn,
int sockindex)
{
CURLcode result;
int n = 0;
struct Curl_cfilter *cf = conn->cfilter[sockindex];
result = cf ? cf->cft->query(cf, data, CF_QUERY_MAX_CO... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x298(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x20f5b
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x70... | /AraHaan[P]curl/lib/cfilters.c |
Curl_conn_get_stream_error | int Curl_conn_get_stream_error(struct Curl_easy *data,
struct connectdata *conn,
int sockindex)
{
CURLcode result;
int n = 0;
struct Curl_cfilter *cf = conn->cfilter[sockindex];
result = cf ? cf->cft->query(cf, data, CF_QUERY_STREAM_ERROR,
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x298(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x20ffb
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x70... | /AraHaan[P]curl/lib/cfilters.c |
ps_add | static void ps_add(struct Curl_easy *data, struct easy_pollset *ps,
int bitmap, curl_socket_t *socks)
{
if(bitmap) {
int i;
for(i = 0; i < MAX_SOCKSPEREASYHANDLE; ++i) {
if(!(bitmap & GETSOCK_MASK_RW(i)) || !VALID_SOCK((socks[i]))) {
break;
}
if(bitmap & GETSOCK_RE... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x21423
movl $0x0, -0x24(%rbp)
cmpl $0x5, -0x24(%rbp)
jge 0x21421
movl -0x14(%rbp), %eax
movl -0x24(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, -0x28... | /AraHaan[P]curl/lib/cfilters.c |
Curl_pollset_check | void Curl_pollset_check(struct Curl_easy *data,
struct easy_pollset *ps, curl_socket_t sock,
bool *pwant_read, bool *pwant_write)
{
unsigned int i;
(void)data;
DEBUGASSERT(VALID_SOCK(sock));
for(i = 0; i < ps->num; ++i) {
if(ps->sockets[i] == sock) {
*p... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
jmp 0x21449
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x214c2
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl (%rax,%rcx,4),... | /AraHaan[P]curl/lib/cfilters.c |
Curl_cpool_init | void Curl_cpool_init(struct cpool *cpool,
struct Curl_easy *idata,
struct Curl_share *share,
size_t size)
{
Curl_hash_init(&cpool->dest2bundle, size, Curl_hash_str,
Curl_str_key_compare, cpool_bundle_free_entry);
DEBUGASSERT(idata);
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x275d9(%rip), %rdx # 0x48ae0
leaq 0x27652(%rip), %rcx # 0x48b60
leaq 0x3b(%rip), %r8 # 0x21550
callq 0x48340
jmp 0x215... | /AraHaan[P]curl/lib/conncache.c |
cpool_discard_conn | static void cpool_discard_conn(struct cpool *cpool,
struct Curl_easy *data,
struct connectdata *conn,
bool aborted)
{
bool done = FALSE;
DEBUGASSERT(data);
DEBUGASSERT(!data->conn);
DEBUGASSERT(cpool);
DEBUGASSERT(!c... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
jmp 0x21991
jmp 0x21993
jmp 0x21995
jmp 0x21997
jmp 0x21999
jmp 0x2199b
jmp 0x2199d
movq -0x18(%rbp), %rdi
addq $0x410, %rdi ... | /AraHaan[P]curl/lib/conncache.c |
cpool_get_instance | static struct cpool *cpool_get_instance(struct Curl_easy *data)
{
if(data) {
if(CURL_SHARE_KEEP_CONNECT(data->share))
return &data->share->cpool;
else if(data->multi_easy)
return &data->multi_easy->cpool;
else if(data->multi)
return &data->multi->cpool;
}
return NULL;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x21d03
movq -0x10(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x21cbf
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movl 0x4(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x21cbf
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
addq $0x30, %rax
movq %ra... | /AraHaan[P]curl/lib/conncache.c |
Curl_cpool_add | CURLcode Curl_cpool_add(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct cpool_bundle *bundle = NULL;
struct cpool *cpool = cpool_get_instance(data);
DEBUGASSERT(conn);
DEBUGASSERT(cpool);
if(!cpool)
return CURLE_FAILED_INIT;
CPOOL_LOCK(c... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21c80
movq %rax, -0x30(%rbp)
jmp 0x226ae
jmp 0x226b0
jmp 0x226b2
cmpq $0x0, -0x30(%rbp)
jne 0x226c5
movl $0x2, -0x4(%rbp)
jmp 0x2284f
jmp 0x226c7
cmpq $0... | /AraHaan[P]curl/lib/conncache.c |
cpool_add_bundle | static struct cpool_bundle *
cpool_add_bundle(struct cpool *cpool, struct connectdata *conn)
{
struct cpool_bundle *bundle;
bundle = cpool_bundle_create(conn->destination);
if(!bundle)
return NULL;
if(!Curl_hash_add(&cpool->dest2bundle,
bundle->dest, bundle->dest_len, bundle)) {
cp... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x23600
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x22892
movq $0x0, -0x8(%rbp)
jmp 0x228d0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x28, %rsi
movq -0x20(%rbp)... | /AraHaan[P]curl/lib/conncache.c |
Curl_cpool_find | bool Curl_cpool_find(struct Curl_easy *data,
const char *destination,
Curl_cpool_conn_match_cb *conn_cb,
Curl_cpool_done_match_cb *done_cb,
void *userdata)
{
struct cpool *cpool = cpool_get_instance(data);
struct cpool_bundle *bundl... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21c80
movq %rax, -0x38(%rbp)
movb $0x0, -0x41(%rbp)
jmp 0x22baf
jmp 0x22bb1
jmp 0x22bb3
cmpq $0x0, -0x38(%rbp)
jne 0x22bc3
movb $0x... | /AraHaan[P]curl/lib/conncache.c |
cpool_reap_dead_cb | static int cpool_reap_dead_cb(struct Curl_easy *data,
struct connectdata *conn, void *param)
{
struct cpool_reaper_ctx *rctx = param;
if(Curl_conn_seems_dead(conn, data, &rctx->now)) {
/* stop the iteration here, pass back the connection that was pruned */
Curl_conn_terminate(d... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x9c930
testb $0x1, %al
jne 0x22f63
jmp 0x22f7b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp... | /AraHaan[P]curl/lib/conncache.c |
Curl_cpool_upkeep | CURLcode Curl_cpool_upkeep(void *data)
{
struct cpool *cpool = cpool_get_instance(data);
struct curltime now = Curl_now();
if(!cpool)
return CURLE_OK;
CPOOL_LOCK(cpool, data);
cpool_foreach(data, cpool, &now, conn_upkeep);
CPOOL_UNLOCK(cpool, data);
return CURLE_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21c80
movq %rax, -0x18(%rbp)
callq 0x97950
movq %rax, -0x28(%rbp)
movl %edx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x22fc8
movl $0x0, -0x4(%rbp)
jmp 0x23082
jmp 0x22fca
cmpq $0x0, -0x18(%rbp)
je 0x23016
movq -0x18(%rbp), ... | /AraHaan[P]curl/lib/conncache.c |
cpool_find_conn | static int cpool_find_conn(struct Curl_easy *data,
struct connectdata *conn, void *param)
{
struct cpool_find_ctx *fctx = param;
(void)data;
if(conn->connection_id == fctx->id) {
fctx->conn = conn;
return 1;
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x2321e
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0... | /AraHaan[P]curl/lib/conncache.c |
Curl_cpool_do_by_id | void Curl_cpool_do_by_id(struct Curl_easy *data, curl_off_t conn_id,
Curl_cpool_conn_do_cb *cb, void *cbdata)
{
struct cpool *cpool = cpool_get_instance(data);
struct cpool_do_conn_ctx dctx;
if(!cpool)
return;
dctx.id = conn_id;
dctx.cb = cb;
dctx.cbdata = cbdata;
CPOOL_LOCK(... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x21c80
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x23261
jmp 0x2332a
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax,... | /AraHaan[P]curl/lib/conncache.c |
Curl_cpool_do_locked | void Curl_cpool_do_locked(struct Curl_easy *data,
struct connectdata *conn,
Curl_cpool_conn_do_cb *cb, void *cbdata)
{
struct cpool *cpool = cpool_get_instance(data);
if(cpool) {
CPOOL_LOCK(cpool, data);
cb(conn, data, cbdata);
CPOOL_UNLOCK(cpool, data... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x21c80
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2346f
jmp 0x233c2
cmpq $0x0, -0x28(%rbp)
je 0x2340e
movq -0x28(%rbp), %rax
cmpq $0x0, 0x60(%rax)
j... | /AraHaan[P]curl/lib/conncache.c |
sigpipe_ignore | static void sigpipe_ignore(struct Curl_easy *data,
struct sigpipe_ignore *ig)
{
/* get a local copy of no_signal because the Curl_easy might not be
around when we restore */
ig->no_signal = data->set.no_signal;
if(!data->set.no_signal) {
struct sigaction action;
/* first, e... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xa2c(%rax), %rax
shrq $0x21, %rax
andq $0x1, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movb %cl, %dl
movb 0x98(%rax), %cl
andb $0x1, %dl
andb $-0x2, %cl
orb %dl, %cl
movb %cl, 0x98(%rax)
movq -0x8(%rbp... | /AraHaan[P]curl/lib/sigpipe.h |
cpool_bundle_create | static struct cpool_bundle *cpool_bundle_create(const char *dest)
{
struct cpool_bundle *bundle;
size_t dest_len = strlen(dest);
bundle = calloc(1, sizeof(*bundle) + dest_len);
if(!bundle)
return NULL;
Curl_llist_init(&bundle->conns, NULL);
bundle->dest_len = dest_len + 1;
memcpy(bundle->dest, dest, ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10540
movq %rax, -0x20(%rbp)
leaq 0xc9cd0(%rip), %rax # 0xed2f0
movq (%rax), %rax
movq -0x20(%rbp), %rsi
addq $0x30, %rsi
movl $0x1, %edi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x23647
movq $0x0,... | /AraHaan[P]curl/lib/conncache.c |
Curl_timeleft | timediff_t Curl_timeleft(struct Curl_easy *data,
struct curltime *nowp,
bool duringconnect)
{
timediff_t timeleft_ms = 0;
timediff_t ctimeleft_ms = 0;
struct curltime now;
/* The duration of a connect and the total transfer are calculated from two
differen... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x9b8(%rax)
ja 0x2379a
testb $0x1, -0x19(%rbp)
jne 0x2379a
movq $0x0, -0x8(%rbp)
jmp 0x238e7
cmpq $... | /AraHaan[P]curl/lib/connect.c |
Curl_shutdown_start | void Curl_shutdown_start(struct Curl_easy *data, int sockindex,
int timeout_ms, struct curltime *nowp)
{
struct curltime now;
DEBUGASSERT(data->conn);
if(!nowp) {
now = Curl_now();
nowp = &now;
}
data->conn->shutdown.start[sockindex] = *nowp;
data->conn->shutdown.timeout_ms... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
jmp 0x23918
cmpq $0x0, -0x18(%rbp)
jne 0x23943
callq 0x97950
movq %rax, -0x38(%rbp)
movl %edx, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax,... | /AraHaan[P]curl/lib/connect.c |
Curl_conn_shutdown_timeleft | timediff_t Curl_conn_shutdown_timeleft(struct connectdata *conn,
struct curltime *nowp)
{
timediff_t left_ms = 0, ms;
struct curltime now;
int i;
for(i = 0; conn->shutdown.timeout_ms && (i < 2); ++i) {
if(!conn->shutdown.start[i].tv_sec)
continue;
if(!nowp) ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x2c8(%rcx)
movb %al, -0x49(%rbp)
je 0x23b2b
cmpl $0x2, -0x34(%rbp)
setl %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al... | /AraHaan[P]curl/lib/connect.c |
cf_he_close | static void cf_he_close(struct Curl_cfilter *cf,
struct Curl_easy *data)
{
struct cf_he_ctx *ctx = cf->ctx;
CURL_TRC_CF(data, cf, "close");
cf_he_ctx_clear(cf, data);
cf->connected = FALSE;
ctx->state = SCFST_INIT;
if(cf->next) {
cf->next->cft->do_close(cf->next, data);
Cur... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x24354
movq -0x10(%rbp), %rax
movq 0xa2c(%rax), %rax
shrq $0x1e, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x24354
movq -0x10(%rbp), %rax
c... | /AraHaan[P]curl/lib/connect.c |
cf_he_adjust_pollset | static void cf_he_adjust_pollset(struct Curl_cfilter *cf,
struct Curl_easy *data,
struct easy_pollset *ps)
{
struct cf_he_ctx *ctx = cf->ctx;
size_t i;
if(!cf->connected) {
for(i = 0; i < CURL_ARRAYSIZE(ctx->baller); i++) {
struct eyeb... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movb 0x24(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x24701
movq $0x0, -0x28(%rbp)
cmpq $0x2, -0x2... | /AraHaan[P]curl/lib/connect.c |
cf_he_data_pending | static bool cf_he_data_pending(struct Curl_cfilter *cf,
const struct Curl_easy *data)
{
struct cf_he_ctx *ctx = cf->ctx;
size_t i;
if(cf->connected)
return cf->next->cft->has_data_pending(cf->next, data);
for(i = 0; i < CURL_ARRAYSIZE(ctx->baller); i++) {
struct eyeballe... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movb 0x24(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x24761
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %r... | /AraHaan[P]curl/lib/connect.c |
Curl_conn_setup | CURLcode Curl_conn_setup(struct Curl_easy *data,
struct connectdata *conn,
int sockindex,
const struct Curl_dns_entry *remotehost,
int ssl_mode)
{
CURLcode result = CURLE_OK;
DEBUGASSERT(data);
DEBUGASSERT(conn->h... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
jmp 0x25184
jmp 0x25186
jmp 0x25188
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, 0x298(%rax,%rcx,8)
jne 0x251d4
movq -0x10(%r... | /AraHaan[P]curl/lib/connect.c |
cf_he_insert_after | static CURLcode cf_he_insert_after(struct Curl_cfilter *cf_at,
struct Curl_easy *data,
const struct Curl_dns_entry *remotehost,
int transport)
{
cf_ip_connect_create *cf_create;
struct Curl_cfilter *cf;
CURLco... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
jmp 0x26959
movl -0x24(%rbp), %edi
callq 0x26a40
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x269e4
jmp 0x2696e
cmpq $0x0, -0x18(%rbp)
je 0x269d9
movq -0x18(%rbp), %rax
movq 0xa... | /AraHaan[P]curl/lib/connect.c |
Curl_all_content_encodings | void Curl_all_content_encodings(char *buf, size_t blen)
{
size_t len = 0;
const struct Curl_cwtype * const *cep;
const struct Curl_cwtype *ce;
DEBUGASSERT(buf);
DEBUGASSERT(blen);
buf[0] = 0;
for(cep = general_unencoders; *cep; cep++) {
ce = *cep;
if(!strcasecompare(ce->name, CONTENT_ENCODING_DE... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
jmp 0x26baa
jmp 0x26bac
jmp 0x26bae
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
leaq 0xc0dd4(%rip), %rax # 0xe7990
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x26c15
movq -0x20(%rbp), ... | /AraHaan[P]curl/lib/content_encoding.c |
Curl_build_unencoding_stack | CURLcode Curl_build_unencoding_stack(struct Curl_easy *data,
const char *enclist, int is_transfer)
{
Curl_cwriter_phase phase = is_transfer ?
CURL_CW_TRANSFER_DECODE : CURL_CW_CONTENT_DECODE;
CURLcode result;
bool has_chunked = FALSE;
do {
const char *name;
size... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
movl $0x3, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x20(%rbp)
movb $0x0, -0x25(%rbp)
movb $0x0, -0x39(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb ... | /AraHaan[P]curl/lib/content_encoding.c |
process_zlib_error | static CURLcode
process_zlib_error(struct Curl_easy *data, z_stream *z)
{
if(z->msg)
failf(data, "Error while processing content unencoding: %s",
z->msg);
else
failf(data, "Error while processing content unencoding: "
"Unknown failure within decompression software.");
return CURLE_BAD... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x275e7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
leaq 0x9b283(%rip), %rsi # 0xc2861
movb $0x0, %al
callq 0x2f5c0
jmp 0x275f9
movq -0x8(%rbp), %rdi
leaq 0... | /AraHaan[P]curl/lib/content_encoding.c |
inflate_stream | static CURLcode inflate_stream(struct Curl_easy *data,
struct Curl_cwriter *writer, int type,
zlibInitState started)
{
struct zlib_writer *zp = (struct zlib_writer *) writer;
z_stream *z = &zp->z; /* zlib state structure */
uInt nread = z->avai... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x4028, %rax # imm = 0x4028
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movl... | /AraHaan[P]curl/lib/content_encoding.c |
brotli_map_error | static CURLcode brotli_map_error(BrotliDecoderErrorCode be)
{
switch(be) {
case BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE:
case BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE:
case BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET:
case BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME:
case BROTLI_DE... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $-0x1e, %eax
je 0x27e68
jmp 0x27e24
movl -0xc(%rbp), %eax
addl $0x1b, %eax
subl $0x3, %eax
jb 0x27e68
jmp 0x27e31
movl -0xc(%rbp), %eax
addl $0x16, %eax
subl $0x2, %eax
jb 0x27e68
jmp 0x27e3e
movl -0xc(%rbp), %eax
subl $-0... | /AraHaan[P]curl/lib/content_encoding.c |
Curl_cookie_init | struct CookieInfo *Curl_cookie_init(struct Curl_easy *data,
const char *file,
struct CookieInfo *ci,
bool newsession)
{
FILE *handle = NULL;
if(!ci) {
int i;
/* we did not get a struct, create one *... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x282bd
movl $0x1, %edi
movl $0x7f8, %esi # imm = 0x7F8
leaq 0xc5092(%rip), %rax # 0xed2f0
... | /AraHaan[P]curl/lib/cookie.c |
cookie_tailmatch | static bool cookie_tailmatch(const char *cookie_domain,
size_t cookie_domain_len,
const char *hostname)
{
size_t hostname_len = strlen(hostname);
if(hostname_len < cookie_domain_len)
return FALSE;
if(!strncasecompare(cookie_domain,
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10540
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2a1d1
movb $0x0, -0x1(%rbp)
jmp 0x2a230
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq -0x2... | /AraHaan[P]curl/lib/cookie.c |
cookie_list | static struct curl_slist *cookie_list(struct Curl_easy *data)
{
struct curl_slist *list = NULL;
struct curl_slist *beg;
unsigned int i;
struct Curl_llist_node *n;
if(!data->cookies || (data->cookies->numcookies == 0))
return NULL;
for(i = 0; i < COOKIE_HASH_SIZE; i++) {
for(n = Curl_llist_head(&da... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa38(%rax)
je 0x2a716
movq -0x10(%rbp), %rax
movq 0xa38(%rax), %rax
cmpl $0x0, 0x7e8(%rax)
jne 0x2a723
movq $0x0, -0x8(%rbp)
jmp 0x2a80b
movl $0x0, -0x24(%rbp)
cmpl $0x3f, -0x24(%rbp)
jae 0x2a803... | /AraHaan[P]curl/lib/cookie.c |
cookie_hash_domain | static size_t cookie_hash_domain(const char *domain, const size_t len)
{
const char *end = domain + len;
size_t h = 5381;
while(domain < end) {
size_t j = (size_t)Curl_raw_toupper(*domain++);
h += h << 5;
h ^= j;
}
return (h % COOKIE_HASH_SIZE);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x1505, -0x20(%rbp) # imm = 0x1505
movq -0x8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2af6b
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rc... | /AraHaan[P]curl/lib/cookie.c |
Curl_cshutdn_destroy | void Curl_cshutdn_destroy(struct cshutdn *cshutdn,
struct Curl_easy *data)
{
if(cshutdn->initialised && data) {
int timeout_ms = 0;
/* Just for testing, run graceful shutdown */
#ifdef DEBUGBUILD
{
const char *p = getenv("CURL_GRACEFUL_SHUTDOWN");
if(p) {
curl... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb 0x28(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x2b8fd
cmpq $0x0, -0x10(%rbp)
je 0x2b8fd
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2b8eb
movq -0x10(%rbp), %rax
movq 0xa2c(%rax... | /AraHaan[P]curl/lib/cshutdn.c |
Curl_cshutdn_dest_count | size_t Curl_cshutdn_dest_count(struct Curl_easy *data,
const char *destination)
{
if(data && data->multi) {
struct cshutdn *csd = &data->multi->cshutdn;
size_t n = 0;
struct Curl_llist_node *e = Curl_llist_head(&csd->list);
while(e) {
struct connectdata *conn = Cur... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2bd0c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x2bd0c
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
addq $0x188, %rax # imm = 0x188
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -... | /AraHaan[P]curl/lib/cshutdn.c |
cshutdn_update_ev | static CURLMcode cshutdn_update_ev(struct cshutdn *cshutdn,
struct Curl_easy *data,
struct connectdata *conn)
{
CURLMcode mresult;
DEBUGASSERT(cshutdn);
DEBUGASSERT(cshutdn->multi->socket_cb);
Curl_attach_connection(data, conn);
mresu... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x2bf96
jmp 0x2bf98
jmp 0x2bf9a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6d440
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x733a0
movl %ea... | /AraHaan[P]curl/lib/cshutdn.c |
Curl_getaddrinfo_ex | int
Curl_getaddrinfo_ex(const char *nodename,
const char *servname,
const struct addrinfo *hints,
struct Curl_addrinfo **result)
{
const struct addrinfo *ai;
struct addrinfo *aihead;
struct Curl_addrinfo *cafirst = NULL;
struct Curl_addrinfo *calast = ... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq... | /AraHaan[P]curl/lib/curl_addrinfo.c |
Curl_ntlm_core_lm_resp | void Curl_ntlm_core_lm_resp(const unsigned char *keys,
const unsigned char *plaintext,
unsigned char *results)
{
#if defined(USE_OPENSSL_DES)
DES_key_schedule ks;
setup_des_key(keys, DESKEY(ks));
DES_ecb_encrypt((DES_cblock*)CURL_UNCONST(plaintext),
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x2d1b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x98(%rbp), %rdx
movl $0x1, %ecx
callq 0x10600
movq -0x8(%rbp), %rdi
addq $0x7, %rdi
leaq -0x98(%... | /AraHaan[P]curl/lib/curl_ntlm_core.c |
Curl_ntlm_core_mk_lm_hash | CURLcode Curl_ntlm_core_mk_lm_hash(const char *password,
unsigned char *lmbuffer /* 21 bytes */)
{
unsigned char pw[14];
#if !defined(CURL_NTLM_NOT_SUPPORTED)
static const unsigned char magic[] = {
0x4B, 0x47, 0x53, 0x21, 0x40, 0x23, 0x24, 0x25 /* i.e. KGS!@#$% */
};
#endif
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10540
cmpq $0xe, %rax
jae 0x2d224
movq -0x8(%rbp), %rdi
callq 0x10540
movq %rax, -0xb0(%rbp)
jmp 0x2d232
movl $0xe, %eax
movq %rax, -0xb0(%rbp)
jmp 0x2d232
movq -0xb0(%rbp), %rax
movq %rax, -0x28(%rbp)... | /AraHaan[P]curl/lib/curl_ntlm_core.c |
Curl_ntlm_core_mk_lmv2_resp | CURLcode Curl_ntlm_core_mk_lmv2_resp(unsigned char *ntlmv2hash,
unsigned char *challenge_client,
unsigned char *challenge_server,
unsigned char *lmresp)
{
unsigned char data[16];
unsigned char hmac_out... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x54(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40... | /AraHaan[P]curl/lib/curl_ntlm_core.c |
sasl_state | static void sasl_state(struct SASL *sasl, struct Curl_easy *data,
saslstate newstate)
{
#if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
/* for debug purposes */
static const char * const names[]={
"STOP",
"PLAIN",
"LOGIN",
"LOGIN_PASSWD",
"EXTERNAL",
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
popq %rbp
retq
nopl (%rax,%rax)
| /AraHaan[P]curl/lib/curl_sasl.c |
Curl_sasl_continue | CURLcode Curl_sasl_continue(struct SASL *sasl, struct Curl_easy *data,
int code, saslprogress *progress)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
saslstate newstate = SASL_FINAL;
struct bufref resp;
const char *hostname, *disp_hostname;
int port;
#if d... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x11, -0x3c(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x738(%rax)
je 0x2e716
movq -0x18(%... | /AraHaan[P]curl/lib/curl_sasl.c |
trc_infof | static void trc_infof(struct Curl_easy *data,
struct curl_trc_feat *feat,
const char *opt_id, int opt_id_idx,
const char * const fmt, va_list ap)
{
size_t len = 0;
char buf[TRC_LINE_MAX];
if(CURL_TRC_IDS(data))
len += trc_print_ids(data, buf +... | pushq %rbp
movq %rsp, %rbp
subq $0x840, %rsp # imm = 0x840
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2f9c6
movq -0x8(%rbp), %rax
movq 0xa2c(%rax), %rax
shrq $0x1e, %r... | /AraHaan[P]curl/lib/curl_trc.c |
trc_opt | static CURLcode trc_opt(const char *config)
{
struct Curl_str out;
while(!Curl_str_until(&config, &out, 32, ',')) {
int lvl = CURL_LOG_LVL_INFO;
const char *token = Curl_str(&out);
if(*token == '-') {
lvl = CURL_LOG_LVL_NONE;
Curl_str_nudge(&out, 1);
}
else if(*token == '+')
C... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x20, %edx
movl $0x2c, %ecx
callq 0x91030
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x304f4
jmp 0x3063c
movl $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28... | /AraHaan[P]curl/lib/curl_trc.c |
cw_out_flush_chain | static CURLcode cw_out_flush_chain(struct cw_out_ctx *ctx,
struct Curl_easy *data,
struct cw_out_buf **pcwbuf,
bool flush_all)
{
struct cw_out_buf *cwbuf = *pcwbuf;
CURLcode result;
if(!cwbuf)
return CURL... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x30e89
movl $0x0, -0x4(%rbp)
jmp 0x30f6f
movq -0x10(%rbp), %rax
... | /AraHaan[P]curl/lib/cw-out.c |
sendf | static CURLcode sendf(struct Curl_easy *data, const char *fmt, ...)
{
size_t bytes_written;
size_t write_len;
CURLcode result = CURLE_OK;
char *s;
char *sptr;
va_list ap;
va_start(ap, fmt);
s = vaprintf(fmt, ap); /* returns an allocated string */
va_end(ap);
if(!s)
return CURLE_OUT_OF_MEMORY; /*... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
testb %al, %al
je 0x32671
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(... | /AraHaan[P]curl/lib/dict.c |
Curl_doh | struct Curl_addrinfo *Curl_doh(struct Curl_easy *data,
const char *hostname,
int port,
int ip_version,
int *waitp)
{
CURLcode result = CURLE_OK;
struct doh_probes *dohp = NULL;
struct connec... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x327c7
jmp 0x327c9
jmp 0x327cb
movq -0x10(%... | /AraHaan[P]curl/lib/doh.c |
Curl_doh_cleanup | void Curl_doh_cleanup(struct Curl_easy *data)
{
struct doh_probes *dohp = data->state.async.doh;
if(dohp) {
int i;
Curl_doh_close(data);
for(i = 0; i < DOH_SLOT_COUNT; ++i) {
Curl_dyn_free(&dohp->probe_resp[i].body);
}
Curl_safefree(data->state.async.doh);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xd38(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x32a75
movq -0x8(%rbp), %rdi
callq 0x33b60
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x32a4b
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
imulq $0x3... | /AraHaan[P]curl/lib/doh.c |
doh_probe_write_cb | static size_t
doh_probe_write_cb(char *contents, size_t size, size_t nmemb, void *userp)
{
size_t realsize = size * nmemb;
struct Curl_easy *data = userp;
struct doh_request *doh_req = Curl_meta_get(data, CURL_EZM_DOH_PROBE);
if(!doh_req)
return CURL_WRITEFUNC_ERROR;
if(Curl_dyn_addn(&doh_req->resp_body,... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
imulq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x8e9b9(%rip), %rsi # 0xc3531
callq ... | /AraHaan[P]curl/lib/doh.c |
doh_probe_dtor | static void doh_probe_dtor(void *key, size_t klen, void *e)
{
(void)key;
(void)klen;
if(e) {
struct doh_request *doh_req = e;
curl_slist_free_all(doh_req->req_hds);
Curl_dyn_free(&doh_req->resp_body);
free(e);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x34c23
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x110(%rax), %rdi
callq 0x10fa0
movq -0x20(%rbp), %rdi
addq $0x118, %rdi # imm = 0x118
ca... | /AraHaan[P]curl/lib/doh.c |
curl_simple_lock_lock | static CURL_INLINE void curl_simple_lock_lock(curl_simple_lock *lock)
{
for(;;) {
if(!atomic_exchange_explicit(lock, true, memory_order_acquire))
break;
/* Reduce cache coherency traffic */
while(atomic_load_explicit(lock, memory_order_relaxed)) {
/* Reduce load (not mandatory) */
#ifdef HAVE_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
xchgl %eax, (%rcx)
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x36303
jmp 0x3631a
jmp 0x36305
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x36318
pause
j... | /AraHaan[P]curl/lib/easy_lock.h |
curl_easy_upkeep | CURLcode curl_easy_upkeep(CURL *d)
{
struct Curl_easy *data = d;
/* Verify that we got an easy handle we can work with. */
if(!GOOD_EASY_HANDLE(data))
return CURLE_BAD_FUNCTION_ARGUMENT;
if(Curl_is_in_callback(data))
return CURLE_RECURSIVE_API_CALL;
/* Use the common function to keep connections ali... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x37967
movq -0x18(%rbp), %rax
cmpl $0xc0dedbad, (%rax) # imm = 0xC0DEDBAD
je 0x37970
movl $0x2b, -0x4(%rbp)
jmp 0x37994
movq -0x18(%rbp), %rdi
callq 0x71350
testb $0x1, %al
jne... | /AraHaan[P]curl/lib/easy.c |
file_setup_connection | static CURLcode file_setup_connection(struct Curl_easy *data,
struct connectdata *conn)
{
(void)conn;
/* allocate the FILE specific struct */
data->req.p.file = calloc(1, sizeof(struct FILEPROTO));
if(!data->req.p.file)
return CURLE_OUT_OF_MEMORY;
return CURLE_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x18, %esi
leaq 0xb4e0f(%rip), %rax # 0xed2f0
callq *(%rax)
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x180(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x180(%rax)
jne 0x38508
movl $0x1b, -0x4(%rbp)
j... | /AraHaan[P]curl/lib/file.c |
dirslash | static char *dirslash(const char *path)
{
size_t n;
struct dynbuf out;
DEBUGASSERT(path);
Curl_dyn_init(&out, CURL_MAX_INPUT_LENGTH);
n = strlen(path);
if(n) {
/* find the rightmost path separator, if any */
while(n && !IS_SEP(path[n-1]))
--n;
/* skip over all the path separators, if any *... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
jmp 0x3951e
leaq -0x38(%rbp), %rdi
movl $0x7a1200, %esi # imm = 0x7A1200
callq 0x35140
movq -0x10(%rbp), %rdi
callq 0x10540
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x395c4
jmp 0x39546
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x... | /AraHaan[P]curl/lib/fopen.c |
AddFormInfo | static struct FormInfo *AddFormInfo(char *value,
char *contenttype,
struct FormInfo *parent_form_info)
{
struct FormInfo *form_info;
form_info = calloc(1, sizeof(struct FormInfo));
if(!form_info)
return NULL;
if(value)
form_info->va... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, %edi
movl $0x68, %esi
leaq 0xb1ebb(%rip), %rax # 0xed2f0
callq *(%rax)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3b44c
movq $0x0, -0x8(%rbp)
jmp 0x3b4a9
cmpq $0x0, -0x10(%rbp)
je 0x3... | /AraHaan[P]curl/lib/formdata.c |
ftp_endofresp | static bool ftp_endofresp(struct Curl_easy *data, struct connectdata *conn,
const char *line, size_t len, int *code)
{
curl_off_t status;
(void)data;
(void)conn;
if((len > 3) && LASTLINE(line) && !Curl_str_number(&line, &status, 999)) {
*code = (int)status;
return TRUE;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x3, -0x28(%rbp)
jbe 0x3e62d
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x3e62d
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %... | /AraHaan[P]curl/lib/ftp.c |
ftp_state_user_resp | static CURLcode ftp_state_user_resp(struct Curl_easy *data,
int ftpcode)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct ftp_conn *ftpc = &conn->proto.ftpc;
/* some need password anyway, and others just return 2xx ignored */
if((ftpcode == 331) ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x20(%rbp)
cmpl $0x14b, -0xc(%rbp) # imm = 0x14B
jne 0x3e6f... | /AraHaan[P]curl/lib/ftp.c |
ftp_state_stor_resp | static CURLcode ftp_state_stor_resp(struct Curl_easy *data,
int ftpcode, ftpstate instate)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
if(ftpcode >= 400) {
failf(data, "Failed FTP upload: %0d", ftpcode);
ftp_state(data, FTP_STOP);
/* oops, ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb %al, -0x15(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x190, -0x14(%rbp) # imm = 0x190
jl 0x406cc
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
lea... | /AraHaan[P]curl/lib/ftp.c |
ftp_nb_type | static CURLcode ftp_nb_type(struct Curl_easy *data,
struct connectdata *conn,
bool ascii, ftpstate newstate)
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
CURLcode result;
char want = (char)(ascii ? 'A' : 'I');
if(ftpc->transfertype == want) {
ftp_stat... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
movb %al, -0x1a(%rbp)
movq -0x18(%rbp), %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x28(%rbp)
movb -0x19(%rbp), %dl
movl $0x49, %eax
movl $0x41, %ec... | /AraHaan[P]curl/lib/ftp.c |
ftp_213_date | static bool ftp_213_date(const char *p, int *year, int *month, int *day,
int *hour, int *minute, int *second)
{
size_t len = strlen(p);
if(len < 14)
return FALSE;
*year = twodigit(&p[0]) * 100 + twodigit(&p[2]);
*month = twodigit(&p[4]);
*day = twodigit(&p[6]);
*hour = twodigit(... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10540
movq %rax, -0x40(%rbp)
cmpq $0xe, -0x40(%rbp)
jae 0x42771
movb $0x0, -0x1(%rbp)
j... | /AraHaan[P]curl/lib/ftp.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.